celluloid 0.6.2 → 0.7.0

data/lib/celluloid.rb

@@ -20,23 +20,35 @@ module Celluloid
     def current_actor
       actor = Thread.current[:actor]
       raise NotActorError, "not in actor scope" unless actor
-
       actor.proxy
     end
+    alias_method :current, :current_actor
 
     # Receive an asynchronous message
-    def receive(&block)
+    def receive(timeout = nil, &block)
+      actor = Thread.current[:actor]
+      if actor
+        actor.receive(timeout, &block)
+      else
+        Thread.mailbox.receive(timeout, &block)
+      end
+    end
+
+    # Sleep letting the actor continue processing messages
+    def sleep(interval)
       actor = Thread.current[:actor]
       if actor
-        actor.receive(&block)
+        actor.sleep(interval)
       else
-        Thread.mailbox.receive(&block)
+        Kernel.sleep interval
       end
     end
 
-    # Resume a fiber that participates in the Celluloid protocol
-    def resume_fiber(fiber, value = nil)
-      fiber.resume value
+    # Obtain a hash of active tasks to their current activities
+    def tasks
+      actor = Thread.current[:actor]
+      raise NotActorError, "not in actor scope" unless actor
+      actor.tasks
     end
   end
 
@@ -44,7 +56,7 @@ module Celluloid
   module ClassMethods
     # Create a new actor
     def new(*args, &block)
-      proxy = Celluloid::Actor.new(allocate).proxy
+      proxy = Actor.new(allocate).proxy
       proxy.send(:initialize, *args, &block)
       proxy
     end
@@ -55,7 +67,7 @@ module Celluloid
       current_actor = Celluloid.current_actor
       raise NotActorError, "can't link outside actor context" unless current_actor
 
-      proxy = Celluloid::Actor.new(allocate).proxy
+      proxy = Actor.new(allocate).proxy
       current_actor.link proxy
       proxy.send(:initialize, *args, &block)
       proxy
@@ -65,13 +77,13 @@ module Celluloid
     # Create a supervisor which ensures an instance of an actor will restart
     # an actor if it fails
     def supervise(*args, &block)
-      Celluloid::Supervisor.supervise(self, *args, &block)
+      Supervisor.supervise(self, *args, &block)
     end
 
     # Create a supervisor which ensures an instance of an actor will restart
     # an actor if it fails, and keep the actor registered under a given name
     def supervise_as(name, *args, &block)
-      Celluloid::Supervisor.supervise_as(name, self, *args, &block)
+      Supervisor.supervise_as(name, self, *args, &block)
     end
 
     # Trap errors from actors we're linked to when they exit
@@ -136,6 +148,11 @@ module Celluloid
     Celluloid.current_actor
   end
 
+  # Obtain the running tasks for this actor
+  def tasks
+    Celluloid.tasks
+  end
+
   # Obtain the Ruby object the actor is wrapping. This should ONLY be used
   # for a limited set of use cases like runtime metaprogramming. Interacting
   # directly with the wrapped object foregoes any kind of thread safety that
@@ -174,8 +191,18 @@ module Celluloid
   end
 
   # Receive an asynchronous message via the actor protocol
-  def receive(&block)
-    Celluloid.receive(&block)
+  def receive(timeout = nil, &block)
+    Celluloid.receive(timeout, &block)
+  end
+
+  # Sleep while letting the actor continue to receive messages
+  def sleep(interval)
+    Celluloid.sleep(interval)
+  end
+
+  # Call a block after a given interval
+  def after(interval, &block)
+    Thread.current[:actor].after(interval, &block)
   end
 
   # Perform a blocking or computationally intensive action inside an
@@ -183,8 +210,8 @@ module Celluloid
   # messages in its mailbox in the meantime
   def async(&block)
     # This implementation relies on the present implementation of
-    # Celluloid::Future, which uses a Celluloid::Actor to run the block
-    Celluloid::Future.new(&block).value
+    # Celluloid::Future, which uses an Actor to run the block
+    Future.new(&block).value
   end
 
   # Process async calls via method_missing
@@ -216,6 +243,7 @@ require 'celluloid/calls'
 require 'celluloid/core_ext'
 require 'celluloid/events'
 require 'celluloid/fiber'
+require 'celluloid/fsm'
 require 'celluloid/links'
 require 'celluloid/logger'
 require 'celluloid/mailbox'
@@ -223,12 +251,11 @@ require 'celluloid/receivers'
 require 'celluloid/registry'
 require 'celluloid/responses'
 require 'celluloid/signals'
+require 'celluloid/task'
+require 'celluloid/timers'
 
 require 'celluloid/actor'
 require 'celluloid/actor_pool'
 require 'celluloid/supervisor'
 require 'celluloid/future'
 require 'celluloid/application'
-
-require 'celluloid/io'
-require 'celluloid/tcp_server'

data/lib/celluloid/actor.rb

@@ -36,8 +36,7 @@ module Celluloid
       end
 
       if Celluloid.actor?
-        # Yield to the actor scheduler, which resumes us when we get a response
-        response = Fiber.yield(call)
+        response = Thread.current[:actor].wait [:call, call.id]
       else
         # Otherwise we're inside a normal thread, so block
         response = Thread.mailbox.receive do |msg|
@@ -67,15 +66,15 @@ module Celluloid
       if subject.respond_to? :mailbox_factory
         @mailbox = subject.mailbox_factory
       else
-        @mailbox = Celluloid::Mailbox.new
+        @mailbox = Mailbox.new
       end
 
       @links     = Links.new
       @signals   = Signals.new
       @receivers = Receivers.new
+      @timers    = Timers.new
       @proxy     = ActorProxy.new(@mailbox, self.class.to_s)
       @running   = true
-      @pending_calls = {}
 
       @thread = Pool.get do
         Thread.current[:actor]   = self
@@ -107,21 +106,27 @@ module Celluloid
     end
 
     # Receive an asynchronous message
-    def receive(&block)
-      @receivers.receive(&block)
+    def receive(timeout = nil, &block)
+      @receivers.receive(timeout, &block)
     end
 
     # Run the actor loop
     def run
       while @running
         begin
-          message = @mailbox.receive
+          message = @mailbox.receive(timeout)
         rescue ExitEvent => exit_event
-          Celluloid::Fiber.new { handle_exit_event exit_event; nil }.resume
+          Task.new(:exit_handler) { handle_exit_event exit_event; nil }.resume
           retry
         end
 
-        handle_message message
+        if message
+          handle_message message
+        else
+          # No message indicates a timeout
+          @timers.fire
+          @receivers.fire_timers
+        end
       end
 
       cleanup ExitEvent.new(@proxy)
@@ -135,24 +140,61 @@ module Celluloid
       Pool.put @thread
     end
 
-    # Register a fiber waiting for the response to a Celluloid::Call
-    def register_fiber(call, fiber)
-      raise ArgumentError, "attempted to register a dead fiber" unless fiber.alive?
-      @pending_calls[call.id] = fiber
+    # How long to wait until the next timer fires
+    def timeout
+      i1 = @timers.wait_interval
+      i2 = @receivers.wait_interval
+
+      if i1 and i2
+        i1 < i2 ? i1 : i2
+      elsif i1
+        i1
+      else
+        i2
+      end
+    end
+
+    # Obtain a hash of tasks that are currently waiting
+    def tasks
+      # A hash of tasks to what they're waiting on is more meaningful to the
+      # end-user, and lets us make a copy of the tasks table, rather than
+      # handing them the one we're using internally across threads, a definite
+      # thread safety shared state no-no
+      tasks = {}
+      current_task = Thread.current[:task]
+      tasks[current_task] = :running if current_task
+
+      @signals.waiting.each do |waitable, task|
+        tasks[task] = waitable
+      end
+
+      tasks
+    end
+
+    # Schedule a block to run at the given time
+    def after(interval)
+      @timers.add(interval) do
+        Task.new(:timer) { yield; nil }.resume
+      end
+    end
+
+    # Sleep for the given amount of time
+    def sleep(interval)
+      task = Task.current
+      @timers.add(interval) { task.resume }
+      Task.suspend
     end
 
     # Handle an incoming message
     def handle_message(message)
       case message
       when Call
-        Celluloid::Fiber.new { message.dispatch(@subject); nil }.resume
+        Task.new(:message_handler) { message.dispatch(@subject); nil }.resume
       when Response
-        fiber = @pending_calls.delete(message.call_id)
+        handled_successfully = signal [:call, message.call_id], message
 
-        if fiber
-          fiber.resume message
-        else
-          Celluloid::Logger.debug("spurious response to call #{message.call_id}")
+        unless handled_successfully
+          Logger.debug("anomalous message! spurious response to call #{message.call_id}")
         end
       else
         @receivers.handle_message(message)
@@ -174,10 +216,10 @@ module Celluloid
 
     # Handle any exceptions that occur within a running actor
     def handle_crash(exception)
-      Celluloid::Logger.crash("#{@subject.class} crashed!", exception)
+      Logger.crash("#{@subject.class} crashed!", exception)
       cleanup ExitEvent.new(@proxy, exception)
     rescue Exception => ex
-      Celluloid::Logger.crash("#{@subject.class}: ERROR HANDLER CRASHED!", ex)
+      Logger.crash("#{@subject.class}: ERROR HANDLER CRASHED!", ex)
     end
 
     # Handle cleaning up this actor after it exits
@@ -188,7 +230,7 @@ module Celluloid
       begin
         @subject.finalize if @subject.respond_to? :finalize
       rescue Exception => ex
-        Celluloid::Logger.crash("#{@subject.class}#finalize crashed!", ex)
+        Logger.crash("#{@subject.class}#finalize crashed!", ex)
       end
     end
   end

data/lib/celluloid/actor_pool.rb

@@ -42,7 +42,7 @@ module Celluloid
                 func.call
               end
             rescue Exception => ex
-              Celluloid::Logger.crash("#{self} internal failure", ex)
+              Logger.crash("#{self} internal failure", ex)
             end
           end
           thread[:queue] = queue

data/lib/celluloid/actor_proxy.rb

@@ -41,7 +41,7 @@ module Celluloid
 
     # Create a Celluloid::Future which calls a given method
     def future(method_name, *args, &block)
-      Celluloid::Future.new { Actor.call @mailbox, method_name, *args, &block }
+      Future.new { Actor.call @mailbox, method_name, *args, &block }
     end
 
     # Terminate the associated actor

data/lib/celluloid/application.rb

@@ -21,7 +21,7 @@ module Celluloid
           # Take five, toplevel supervisor
           sleep 5 while supervisor.alive?
 
-          Celluloid::Logger.error "!!! Celluloid::Application #{self} crashed. Restarting..."
+          Logger.error "!!! Celluloid::Application #{self} crashed. Restarting..."
         end
       end
 

data/lib/celluloid/calls.rb

@@ -80,14 +80,14 @@ module Celluloid
       begin
         check_signature(obj)
       rescue Exception => ex
-        Celluloid::Logger.crash("#{obj.class}: async call failed!", ex)
+        Logger.crash("#{obj.class}: async call failed!", ex)
         return
       end
 
       obj.send(@method, *@arguments, &@block)
     rescue AbortError => ex
       # Swallow aborted async calls, as they indicate the caller made a mistake
-      Celluloid::Logger.crash("#{obj.class}: async call aborted!", ex)
+      Logger.crash("#{obj.class}: async call aborted!", ex)
     end
   end
 end

data/lib/celluloid/fiber.rb

@@ -1,4 +1,4 @@
-# Every time I look at this code a little part of me dies...
+# Fibers are hard... let's go shopping!
 begin
   require 'fiber'
 rescue LoadError => ex
@@ -30,33 +30,4 @@ rescue LoadError => ex
   else
     raise ex
   end
-end
-
-module Celluloid
-  class Fiber < ::Fiber
-    def initialize(*args)
-      actor   = Thread.current[:actor]
-      mailbox = Thread.current[:mailbox]
-
-      super do
-        Thread.current[:actor]   = actor
-        Thread.current[:mailbox] = mailbox
-
-        yield(*args)
-      end
-    end
-
-    def resume(value = nil)
-      result = super
-      actor = Thread.current[:actor]
-      return result unless actor
-
-      if result.is_a? Celluloid::Call
-        actor.register_fiber result, self
-      elsif result
-        Celluloid::Logger.debug("non-call returned from fiber: #{result.class}")
-      end
-      nil
-    end
-  end
-end
+end

data/lib/celluloid/fsm.rb

@@ -0,0 +1,141 @@
+module Celluloid
+  # Turn concurrent objects into finite state machines
+  # Inspired by Erlang's gen_fsm. See http://www.erlang.org/doc/man/gen_fsm.html
+  module FSM
+    DEFAULT_STATE = :default # Default state name unless one is explicitly set
+
+    # Included hook to extend class methods
+    def self.included(klass)
+      klass.send :include, Celluloid
+      klass.send :extend,  ClassMethods
+    end
+
+    module ClassMethods
+      # Ensure FSMs transition into the default state after they're initialized
+      def new(*args, &block)
+        fsm = super
+        fsm.transition default_state
+        fsm
+      end
+
+      # Ensure FSMs transition into the default state after they're initialized
+      def new_link(*args, &block)
+        fsm = super
+        fsm.transition default_state
+        fsm
+      end
+
+      # Obtain or set the default state
+      # Passing a state name sets the default state
+      def default_state(new_default = nil)
+        if new_default
+          @default_state = new_default.to_sym
+        else
+          defined?(@default_state) ? @default_state : DEFAULT_STATE
+        end
+      end
+
+      # Obtain the valid states for this FSM
+      def states
+        @states ||= {}
+      end
+
+      # Declare an FSM state and optionally provide a callback block to fire
+      # Options:
+      # * to: a state or array of states this state can transition to
+      def state(*args, &block)
+        if args.last.is_a? Hash
+          options = args.pop.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
+        else
+          options = {}
+        end
+
+        args.each do |name|
+          name = name.to_sym
+          states[name] = State.new(name, options['to'], &block)
+        end
+      end
+    end
+
+    # Obtain the current state of the FSM
+    def current_state
+      defined?(@state) ? @state : @state = self.class.default_state
+    end
+    alias_method :state, :current_state
+
+    # Transition to another state
+    # Options:
+    # * delay: don't transition immediately, wait the given number of seconds.
+    #          This will return a Celluloid::Timer object you can use to
+    #          cancel the pending state transition.
+    #
+    # Note: making additional state transitions will cancel delayed transitions
+    def transition(state_name, options = {})
+      state_name = state_name.to_sym
+      current_state = self.class.states[@state]
+
+      return if current_state && current_state.name == state_name
+
+      if current_state and not current_state.valid_transition? state_name
+        valid = current_state.transitions.map(&:to_s).join(", ")
+        raise ArgumentError, "#{self.class} can't change state from '#{@state}' to '#{state_name}', only to: #{valid}"
+      end
+
+      new_state = self.class.states[state_name]
+
+      if !new_state and state_name == self.class.default_state
+        # FIXME This probably isn't thread safe... or wise
+        new_state = self.class.states[state_name] = State.new(state_name)
+      end
+
+      if new_state
+        if options[:delay]
+          @delayed_transition.cancel if @delayed_transition
+
+          @delayed_transition = after(options[:delay]) do
+            transition! new_state.name
+            new_state.call(self)
+          end
+
+          return @delayed_transition
+        end
+
+        if defined?(@delayed_transition) and @delayed_transition
+          @delayed_transition.cancel
+          @delayed_transition = nil
+        end
+
+        transition! new_state.name
+        new_state.call(self)
+      else
+        raise ArgumentError, "invalid state for #{self.class}: #{state_name}"
+      end
+    end
+
+    # Immediate state transition with no sanity checks. "Dangerous!"
+    def transition!(state_name)
+      @state = state_name
+    end
+
+    # FSM states as declared by Celluloid::FSM.state
+    class State
+      attr_reader :name, :transitions
+
+      def initialize(name, transitions = nil, &block)
+        @name, @block = name, block
+        @transitions = Array(transitions).map { |t| t.to_sym } if transitions
+      end
+
+      def call(obj)
+        obj.instance_eval(&@block) if @block
+      end
+
+      def valid_transition?(new_state)
+        # All transitions are allowed unless expressly
+        return true unless @transitions
+
+        @transitions.include? new_state.to_sym
+      end
+    end
+  end
+end