celluloid 0.11.1 → 0.12.0

data/lib/celluloid/{actor_proxy.rb → proxies/actor_proxy.rb}

@@ -1,20 +1,28 @@
 module Celluloid
-  # A proxy object returned from Celluloid::Actor.spawn/spawn_link which
-  # dispatches calls and casts to normal Ruby objects which are running inside
-  # of their own threads.
-  class ActorProxy
-    attr_reader :mailbox
+  # A proxy object returned from Celluloid::Actor.new/new_link which converts
+  # the normal Ruby method protocol into an inter-actor message protocol
+  class ActorProxy < AbstractProxy
+    attr_reader :mailbox, :thread
 
     def initialize(actor)
       @mailbox, @thread, @klass = actor.mailbox, actor.thread, actor.subject.class.to_s
+
+      @async_proxy  = AsyncProxy.new(actor)
+      @future_proxy = FutureProxy.new(actor)
+    end
+
+    def class
+      Actor.call @mailbox, :__send__, :class
     end
 
     def _send_(meth, *args, &block)
       Actor.call @mailbox, :__send__, meth, *args, &block
     end
 
-    def class
-      Actor.call @mailbox, :__send__, :class
+    def inspect
+      Actor.call @mailbox, :inspect
+    rescue DeadActorError
+      "#<Celluloid::Actor(#{@klass}) dead>"
     end
 
     def name
@@ -29,14 +37,18 @@ module Celluloid
       Actor.call @mailbox, :kind_of?, klass
     end
 
-    def respond_to?(meth)
-      Actor.call @mailbox, :respond_to?, meth
+    def respond_to?(meth, include_private = false)
+      Actor.call @mailbox, :respond_to?, meth, include_private
     end
 
     def methods(include_ancestors = true)
       Actor.call @mailbox, :methods, include_ancestors
     end
 
+    def method(name)
+      Method.new(self, name)
+    end
+
     def alive?
       @mailbox.alive?
     end
@@ -45,48 +57,35 @@ module Celluloid
       Actor.call @mailbox, :to_s
     end
 
-    def inspect
-      Actor.call @mailbox, :inspect
-    rescue DeadActorError
-      "#<Celluloid::Actor(#{@klass}) dead>"
-    end
-
-    # Make an asynchronous call to an actor, for those who don't like the
-    # predicate syntax. TIMTOWTDI!
-    def async(method_name, *args, &block)
-      Actor.async @mailbox, method_name, *args, &block
+    # Obtain an async proxy or explicitly invoke a named async method
+    def async(method_name = nil, *args, &block)
+      if method_name
+        Actor.async @mailbox, method_name, *args, &block
+      else
+        @async_proxy
+      end
     end
 
-    # Create a Celluloid::Future which calls a given method
-    def future(method_name, *args, &block)
-      Actor.future @mailbox, method_name, *args, &block
+    # Obtain a future proxy or explicitly invoke a named future method
+    def future(method_name = nil, *args, &block)
+      if method_name
+        Actor.future @mailbox, method_name, *args, &block
+      else
+        @future_proxy
+      end
     end
 
     # Terminate the associated actor
     def terminate
       terminate!
-      join
+      Actor.join(self)
       nil
     end
 
     # Terminate the associated actor asynchronously
     def terminate!
-      raise DeadActorError, "actor already terminated" unless alive?
-      @mailbox.system_event TerminationRequest.new
-    end
-
-    # Forcibly kill a given actor
-    def kill
-      @thread.kill
-      begin
-        @mailbox.shutdown
-      rescue DeadActorError
-      end
-    end
-
-    # Wait for an actor to terminate
-    def join
-      @thread.join
+      ::Kernel.raise DeadActorError, "actor already terminated" unless alive?
+      @mailbox << TerminationRequest.new
     end
 
     # method_missing black magic to call bang predicate methods asynchronously

data/lib/celluloid/proxies/async_proxy.rb

@@ -0,0 +1,19 @@
+module Celluloid
+  # A proxy which sends asynchronous calls to an actor
+  class AsyncProxy < AbstractProxy
+    attr_reader :mailbox
+
+    def initialize(actor)
+      @mailbox, @klass = actor.mailbox, actor.subject.class.to_s
+    end
+
+    def inspect
+      "#<Celluloid::AsyncProxy(#{@klass})>"
+    end
+
+    # method_missing black magic to call bang predicate methods asynchronously
+    def method_missing(meth, *args, &block)
+      Actor.async @mailbox, meth, *args, &block
+    end
+  end
+end

data/lib/celluloid/proxies/future_proxy.rb

@@ -0,0 +1,19 @@
+module Celluloid
+  # A proxy which creates future calls to an actor
+  class FutureProxy < AbstractProxy
+    attr_reader :mailbox
+
+    def initialize(actor)
+      @mailbox, @klass = actor.mailbox, actor.subject.class.to_s
+    end
+
+    def inspect
+      "#<Celluloid::FutureProxy(#{@klass})>"
+    end
+
+    # method_missing black magic to call bang predicate methods asynchronously
+    def method_missing(meth, *args, &block)
+      Actor.future @mailbox, meth, *args, &block
+    end
+  end
+end

data/lib/celluloid/registry.rb

@@ -3,8 +3,8 @@ require 'thread'
 module Celluloid
   # The Registry allows us to refer to specific actors by human-meaningful names
   class Registry
-    def self.root
-      @root ||= new
+    class << self
+      attr_reader :root
     end
 
     def initialize
@@ -23,7 +23,7 @@ module Celluloid
         @registry[name.to_sym] = actor
       end
 
-      actor.mailbox.system_event NamingRequest.new(name.to_sym)
+      actor.mailbox << NamingRequest.new(name.to_sym)
     end
 
     # Retrieve an actor by name
@@ -38,7 +38,7 @@ module Celluloid
 
     def delete(name)
       @registry_lock.synchronize do
-        @registry[name.to_sym]
+        @registry.delete name.to_sym
       end
     end
 
@@ -48,7 +48,7 @@ module Celluloid
     end
 
     # removes and returns all registered actors as a hash of `name => actor`
-    # can be used in testing to clear the registry 
+    # can be used in testing to clear the registry
     def clear
       hash = nil
       @registry_lock.synchronize do
@@ -57,5 +57,8 @@ module Celluloid
       end
       hash
     end
+
+    # Create the default registry
+    @root = new
   end
 end

data/lib/celluloid/rspec.rb

@@ -1,2 +1,8 @@
+require File.expand_path('../../../spec/support/example_actor_class', __FILE__)
 require File.expand_path('../../../spec/support/actor_examples', __FILE__)
 require File.expand_path('../../../spec/support/mailbox_examples', __FILE__)
+
+module Celluloid
+  # Timer accuracy enforced by the tests (50ms)
+  TIMER_QUANTUM = 0.05
+end

data/lib/celluloid/supervision_group.rb

@@ -28,7 +28,7 @@ module Celluloid
           # Take five, toplevel supervisor
           sleep 5 while supervisor.alive?
 
-          Logger.error "!!! Celluloid::Group #{self} crashed. Restarting..."
+          Logger.error "!!! Celluloid::SupervisionGroup #{self} crashed. Restarting..."
         end
       end
 
@@ -44,9 +44,13 @@ module Celluloid
       end
 
       # Register a pool of actors to be launched on group startup
-      def pool(klass)
+      # Available options are:
+      #
+      # * as: register this application in the Celluloid::Actor[] directory
+      # * args: start the actor pool with the given arguments
+      def pool(klass, options = {})
         blocks << lambda do |group|
-          group.pool klass
+          group.pool klass, options
         end
       end
     end
@@ -67,8 +71,9 @@ module Celluloid
       add(klass, :args => args, :block => block, :as => name)
     end
 
-    def pool(klass)
-      add(klass, :method => 'pool_link')
+    def pool(klass, options = {})
+      options[:method] = 'pool_link'
+      add(klass, options)
     end
 
     def add(klass, options)
@@ -106,16 +111,27 @@ module Celluloid
         options = options.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
 
         @name = options['as']
-        @args = options['args'] ? Array(options['args']) : []
         @block = options['block']
+        @args = options['args'] ? Array(options['args']) : []
         @method = options['method'] || 'new_link'
+        @pool = @method == 'pool_link'
+        @pool_size = options['size'] if @pool
 
         start
       end
       attr_reader :name, :actor
 
       def start
-        @actor = @klass.send(@method, *@args, &@block)
+        # when it is a pool, then we don't splat the args
+        # and we need to extract the pool size if set
+        if @pool
+          options = {:args => @args}.tap do |hash|
+            hash[:size] = @pool_size if @pool_size
+          end
+          @actor = @klass.send(@method, options, &@block)
+        else
+          @actor = @klass.send(@method, *@args, &@block)
+        end
         @registry[@name] = @actor if @name
       end
 
@@ -135,7 +151,4 @@ module Celluloid
       end
     end
   end
-
-  # Legacy support for the old name
-  Group = SupervisionGroup
 end

data/lib/celluloid/system_events.rb

@@ -0,0 +1,54 @@
+module Celluloid
+  # High-priority internal system events
+  class SystemEvent; end
+
+  # Request to link with another actor
+  class LinkingRequest < SystemEvent
+    attr_reader :actor, :type
+
+    def initialize(actor, type)
+      @actor, @type = actor, type.to_sym
+      raise ArgumentError, "type must be link or unlink" unless [:link, :unlink].include?(@type)
+    end
+
+    def process(links)
+      case type
+      when :link   then links << actor
+      when :unlink then links.delete actor
+      end
+
+      actor.mailbox << LinkingResponse.new(Actor.current, type)
+    end
+  end
+
+  # Response to a link request
+  class LinkingResponse
+    attr_reader :actor, :type
+
+    def initialize(actor, type)
+      @actor, @type = actor, type.to_sym
+      raise ArgumentError, "type must be link or unlink" unless [:link, :unlink].include?(@type)
+    end
+  end
+
+  # An actor has exited for the given reason
+  class ExitEvent < SystemEvent
+    attr_reader :actor, :reason
+
+    def initialize(actor, reason = nil)
+      @actor, @reason = actor, reason
+    end
+  end
+
+  # Name an actor at the time it's registered
+  class NamingRequest < SystemEvent
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+  end
+
+  # Request for an actor to terminate
+  class TerminationRequest < SystemEvent; end
+end

data/lib/celluloid/task.rb

@@ -1,78 +1,22 @@
+require 'celluloid/tasks/task_fiber'
+require 'celluloid/tasks/task_thread'
+
 module Celluloid
   # Trying to resume a dead task
   class DeadTaskError < StandardError; end
 
   # Tasks are interruptable/resumable execution contexts used to run methods
-  class Task
-    class TerminatedError < StandardError; end # kill a running fiber
-
-    attr_reader   :type
-    attr_accessor :status
+  module Task
+    class TerminatedError < StandardError; end # kill a running task
 
     # Obtain the current task
     def self.current
-      Fiber.current.task or raise "no task for this Fiber"
+      Thread.current[:task] or raise "not within a task context"
     end
 
     # Suspend the running task, deferring to the scheduler
     def self.suspend(status)
-      task = Task.current
-      task.status = status
-
-      result = Fiber.yield
-      raise TerminatedError, "task was terminated" if result == TerminatedError
-      task.status = :running
-
-      result
-    end
-
-    # Run the given block within a task
-    def initialize(type)
-      @type   = type
-      @status = :new
-
-      actor   = Thread.current[:actor]
-      mailbox = Thread.current[:mailbox]
-
-      @fiber = Fiber.new do
-        @status = :running
-        Thread.current[:actor]   = actor
-        Thread.current[:mailbox] = mailbox
-        Fiber.current.task = self
-        actor.tasks << self
-
-        begin
-          yield
-        rescue TerminatedError
-          # Task was explicitly terminated
-        ensure
-          @status = :dead
-          actor.tasks.delete self
-        end
-      end
-    end
-
-    # Resume a suspended task, giving it a value to return if needed
-    def resume(value = nil)
-      @fiber.resume value
-      nil
-    rescue FiberError
-      raise DeadTaskError, "cannot resume a dead task"
-    end
-
-    # Terminate this task
-    def terminate
-      resume TerminatedError if @fiber.alive?
-    rescue FiberError
-      # If we're getting this the task should already be dead
-    end
-
-    # Is the current task still running?
-    def running?; @fiber.alive?; end
-
-    # Nicer string inspect for tasks
-    def inspect
-      "<Celluloid::Task:0x#{object_id.to_s(16)} @type=#{@type.inspect}, @status=#{@status.inspect}, @running=#{@fiber.alive?}>"
+      Task.current.suspend(status)
     end
   end
 end

data/lib/celluloid/tasks/task_fiber.rb

@@ -0,0 +1,65 @@
+module Celluloid
+  # Tasks with a Fiber backend
+  class TaskFiber
+    attr_reader :type, :status
+
+    # Run the given block within a task
+    def initialize(type)
+      @type   = type
+      @status = :new
+
+      actor, mailbox = Thread.current[:actor], Thread.current[:mailbox]
+      raise NotActorError, "can't create tasks outside of actors" unless actor
+
+      @fiber = Fiber.new do
+        @status = :running
+        Thread.current[:actor]   = actor
+        Thread.current[:mailbox] = mailbox
+        Thread.current[:task]    = self
+        actor.tasks << self
+
+        begin
+          yield
+        rescue Task::TerminatedError
+          # Task was explicitly terminated
+        ensure
+          @status = :dead
+          actor.tasks.delete self
+        end
+      end
+    end
+
+    # Suspend the current task, changing the status to the given argument
+    def suspend(status)
+      @status = status
+      result = Fiber.yield
+      raise result if result.is_a?(Task::TerminatedError)
+      @status = :running
+
+      result
+    end
+
+    # Resume a suspended task, giving it a value to return if needed
+    def resume(value = nil)
+      @fiber.resume value
+      nil
+    rescue FiberError
+      raise DeadTaskError, "cannot resume a dead task"
+    end
+
+    # Terminate this task
+    def terminate
+      resume Task::TerminatedError.new("task was terminated") if @fiber.alive?
+    rescue FiberError
+      # If we're getting this the task should already be dead
+    end
+
+    # Is the current task still running?
+    def running?; @fiber.alive?; end
+
+    # Nicer string inspect for tasks
+    def inspect
+      "<Celluloid::TaskFiber:0x#{object_id.to_s(16)} @type=#{@type.inspect}, @status=#{@status.inspect}>"
+    end
+  end
+end

data/lib/celluloid/tasks/task_thread.rb

@@ -0,0 +1,78 @@
+module Celluloid
+  # Tasks with a Thread backend
+  class TaskThread
+    attr_reader :type, :status
+
+    # Run the given block within a task
+    def initialize(type)
+      @type   = type
+      @status = :new
+
+      @resume_queue = Queue.new
+      @yield_mutex  = Mutex.new
+      @yield_cond   = ConditionVariable.new
+
+      actor, mailbox = Thread.current[:actor], Thread.current[:mailbox]
+      raise NotActorError, "can't create tasks outside of actors" unless actor
+
+      @thread = InternalPool.get do
+        begin
+          unless @resume_queue.pop.is_a?(Task::TerminatedError)
+            @status = :running
+            Thread.current[:actor]   = actor
+            Thread.current[:mailbox] = mailbox
+            Thread.current[:task]    = self
+            actor.tasks << self
+
+            yield
+          end
+        rescue Task::TerminatedError
+          # Task was explicitly terminated
+        ensure
+          @status = :dead
+          actor.tasks.delete self
+          @yield_cond.signal
+        end
+      end
+    end
+
+    # Suspend the current task, changing the status to the given argument
+    def suspend(status)
+      @status = status
+      @yield_cond.signal
+      value = @resume_queue.pop
+
+      raise value if value.is_a?(Task::TerminatedError)
+      @status = :running
+
+      value
+    end
+
+    # Resume a suspended task, giving it a value to return if needed
+    def resume(value = nil)
+      raise DeadTaskError, "cannot resume a dead task" unless @thread.alive?
+
+      @yield_mutex.synchronize do
+        @resume_queue.push(value)
+        @yield_cond.wait(@yield_mutex)
+      end
+
+      nil
+    rescue ThreadError
+      raise DeadTaskError, "cannot resume a dead task"
+    end
+
+    # Terminate this task
+    def terminate
+      resume Task::TerminatedError.new("task was terminated") if @thread.alive?
+    end
+
+    # Is the current task still running?
+    def running?; @status != :dead; end
+
+    # Nicer string inspect for tasks
+    def inspect
+      "<Celluloid::TaskThread:0x#{object_id.to_s(16)} @type=#{@type.inspect}, @status=#{@status.inspect}>"
+    end
+  end
+end

data/lib/celluloid/thread_handle.rb

@@ -27,12 +27,13 @@ module Celluloid
     # Forcibly kill the thread
     def kill
       !!@mutex.synchronize { @thread.kill if @thread }
+      self
     end
 
     # Join to a running thread, blocking until it terminates
     def join
       @mutex.synchronize { @join.wait(@mutex) if @thread }
-      nil
+      self
     end
   end
 end

data/lib/celluloid/version.rb

@@ -1,4 +1,4 @@
 module Celluloid
-  VERSION = '0.11.1'
+  VERSION = '0.12.0'
   def self.version; VERSION; end
 end