celluloid 0.15.2 → 0.16.0.pre

data/lib/celluloid/actor_system.rb

@@ -0,0 +1,107 @@
+module Celluloid
+  class ActorSystem
+    extend Forwardable
+
+    def initialize
+      @internal_pool = InternalPool.new
+      @registry      = Registry.new
+    end
+    attr_reader :registry
+
+    # Launch default services
+    # FIXME: We should set up the supervision hierarchy here
+    def start
+      within do
+        Celluloid::Notifications::Fanout.supervise_as :notifications_fanout
+        Celluloid::IncidentReporter.supervise_as :default_incident_reporter, STDERR
+      end
+      true
+    end
+
+    def within
+      old = Thread.current[:celluloid_actor_system]
+      Thread.current[:celluloid_actor_system] = self
+      yield
+    ensure
+      Thread.current[:celluloid_actor_system] = old
+    end
+
+    def get_thread
+      @internal_pool.get do
+        Thread.current[:celluloid_actor_system] = self
+        yield
+      end
+    end
+
+    def stack_dump
+      Celluloid::StackDump.new(@internal_pool)
+    end
+
+    def_delegators "@registry", :[], :get, :[]=, :set, :delete
+
+    def registered
+      @registry.names
+    end
+
+    def clear_registry
+      @registry.clear
+    end
+
+    def running
+      actors = []
+      @internal_pool.each do |t|
+        next unless t.role == :actor
+        actors << t.actor.behavior_proxy if t.actor && t.actor.respond_to?(:behavior_proxy)
+      end
+      actors
+    end
+
+    def running?
+      @internal_pool.running?
+    end
+
+    # Shut down all running actors
+    def shutdown
+      actors = running
+      Timeout.timeout(shutdown_timeout) do
+        Logger.debug "Terminating #{actors.size} #{(actors.size > 1) ? 'actors' : 'actor'}..." if actors.size > 0
+
+        # Actors cannot self-terminate, you must do it for them
+        actors.each do |actor|
+          begin
+            actor.terminate!
+          rescue DeadActorError
+          end
+        end
+
+        actors.each do |actor|
+          begin
+            Actor.join(actor)
+          rescue DeadActorError
+          end
+        end
+
+        @internal_pool.shutdown
+      end
+    rescue Timeout::Error
+      Logger.error("Couldn't cleanly terminate all actors in #{shutdown_timeout} seconds!")
+      actors.each do |actor|
+        begin
+          Actor.kill(actor)
+        rescue DeadActorError, MailboxDead
+        end
+      end
+    ensure
+      @internal_pool.kill
+      clear_registry
+    end
+
+    def assert_inactive
+      @internal_pool.assert_inactive
+    end
+
+    def shutdown_timeout
+      Celluloid.shutdown_timeout
+    end
+  end
+end

data/lib/celluloid/calls.rb

@@ -21,32 +21,28 @@ module Celluloid
     end
 
     def dispatch(obj)
+      check(obj)
       _block = @block && @block.to_proc
       obj.public_send(@method, *@arguments, &_block)
-    rescue NoMethodError => ex
-      # Abort if the sender made a mistake
-      raise AbortError.new(ex) unless obj.respond_to? @method
-
-      # Otherwise something blew up. Crash this actor
-      raise
-    rescue ArgumentError => ex
-      # Abort if the sender made a mistake
+    end
+
+    def check(obj)
+      raise NoMethodError, "undefined method `#{@method}' for #{obj.inspect}" unless obj.respond_to? @method
+
       begin
         arity = obj.method(@method).arity
       rescue NameError
-        # In theory this shouldn't happen, but just in case
-        raise AbortError.new(ex)
+        return
       end
 
       if arity >= 0
-        raise AbortError.new(ex) if @arguments.size != arity
+        raise ArgumentError, "wrong number of arguments (#{@arguments.size} for #{arity})" if @arguments.size != arity
       elsif arity < -1
         mandatory_args = -arity - 1
-        raise AbortError.new(ex) if arguments.size < mandatory_args
+        raise ArgumentError, "wrong number of arguments (#{@arguments.size} for #{mandatory_args}+)" if arguments.size < mandatory_args
       end
-
-      # Otherwise something blew up. Crash this actor
-      raise
+    rescue => ex
+      raise AbortError.new(ex)
     end
   end
 
@@ -88,8 +84,12 @@ module Celluloid
       @sender << message
     end
 
+    def response
+      Celluloid.suspend(:callwait, self)
+    end
+
     def value
-      Celluloid.suspend(:callwait, self).value
+      response.value
     end
 
     def wait

data/lib/celluloid/cell.rb

@@ -0,0 +1,89 @@
+module Celluloid
+  OWNER_IVAR = :@celluloid_owner # reference to owning actor
+
+  # Wrap the given subject with an Cell
+  class Cell
+    class ExitHandler
+      def initialize(behavior, subject, method_name)
+        @behavior = behavior
+        @subject = subject
+        @method_name = method_name
+      end
+
+      def call(event)
+        @behavior.task(:exit_handler, @method_name) do
+          @subject.send(@method_name, event.actor, event.reason)
+        end
+      end
+    end
+
+    def initialize(subject, options, actor_options)
+      @actor                      = Actor.new(self, actor_options)
+      @subject                    = subject
+      @receiver_block_executions  = options[:receiver_block_executions]
+      @exclusive_methods          = options[:exclusive_methods]
+      @finalizer                  = options[:finalizer]
+
+      @subject.instance_variable_set(OWNER_IVAR, @actor)
+
+      if exit_handler_name = options[:exit_handler_name]
+        @actor.exit_handler = ExitHandler.new(self, @subject, exit_handler_name)
+      end
+
+      @actor.handle(Call) do |message|
+        invoke(message)
+      end
+      @actor.handle(BlockCall) do |message|
+        task(:invoke_block) { message.dispatch }
+      end
+      @actor.handle(BlockResponse, Response) do |message|
+        message.dispatch
+      end
+
+      @actor.start
+      @proxy = (options[:proxy_class] || CellProxy).new(@actor.proxy, @actor.mailbox, @subject.class.to_s)
+    end
+    attr_reader :proxy, :subject
+
+    def invoke(call)
+      meth = call.method
+      if meth == :__send__
+        meth = call.arguments.first
+      end
+      if @receiver_block_executions && meth
+        if @receiver_block_executions.include?(meth.to_sym)
+          call.execute_block_on_receiver
+        end
+      end
+
+      task(:call, meth, :dangerous_suspend => meth == :initialize) {
+        call.dispatch(@subject)
+      }
+    end
+
+    def task(task_type, method_name = nil, meta = nil, &block)
+      meta ||= {}
+      meta.merge!(:method_name => method_name)
+      @actor.task(task_type, meta) do
+        if @exclusive_methods && method_name && @exclusive_methods.include?(method_name.to_sym)
+          Celluloid.exclusive { yield }
+        else
+          yield
+        end
+      end
+    end
+
+    # Run the user-defined finalizer, if one is set
+    def shutdown
+      return unless @finalizer && @subject.respond_to?(@finalizer, true)
+
+      task(:finalizer, @finalizer, :dangerous_suspend => true) do
+        begin
+          @subject.__send__(@finalizer)
+        rescue => ex
+          Logger.crash("#{@subject.class} finalizer crashed!", ex)
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/condition.rb

@@ -4,10 +4,11 @@ module Celluloid
   # ConditionVariable-like signaling between tasks and threads
   class Condition
     class Waiter
-      def initialize(condition, task, mailbox)
+      def initialize(condition, task, mailbox, timeout)
         @condition = condition
         @task = task
         @mailbox = mailbox
+        @timeout = timeout
       end
       attr_reader :condition, :task
 
@@ -16,9 +17,14 @@ module Celluloid
       end
 
       def wait
-        message = @mailbox.receive do |msg|
-          msg.is_a?(SignalConditionRequest) && msg.task == Thread.current
-        end
+        begin
+          message = @mailbox.receive(@timeout) do |msg|
+            msg.is_a?(SignalConditionRequest) && msg.task == Thread.current
+          end
+        rescue TimeoutError
+          raise ConditionError, "timeout after #{@timeout.inspect} seconds"
+        end until message
+
         message.value
       end
     end
@@ -29,21 +35,30 @@ module Celluloid
     end
 
     # Wait for the given signal and return the associated value
-    def wait
+    def wait(timeout = nil)
       raise ConditionError, "cannot wait for signals while exclusive" if Celluloid.exclusive?
 
-      if Thread.current[:celluloid_actor]
+      if actor = Thread.current[:celluloid_actor]
         task = Task.current
+        if timeout
+          bt = caller
+          timer = actor.timers.after(timeout) do
+            exception = ConditionError.new("timeout after #{timeout.inspect} seconds")
+            exception.set_backtrace bt
+            task.resume exception
+          end
+        end
       else
         task = Thread.current
       end
-      waiter = Waiter.new(self, task, Celluloid.mailbox)
+      waiter = Waiter.new(self, task, Celluloid.mailbox, timeout)
 
       @mutex.synchronize do
         @waiters << waiter
       end
 
       result = Celluloid.suspend :condwait, waiter
+      timer.cancel if timer
       raise result if result.is_a? ConditionError
       result
     end
@@ -54,7 +69,9 @@ module Celluloid
         if waiter = @waiters.shift
           waiter << SignalConditionRequest.new(waiter.task, value)
         else
-          Logger.debug("Celluloid::Condition signaled spuriously")
+          Logger.with_backtrace(caller(3)) do |logger|
+            logger.debug("Celluloid::Condition signaled spuriously")
+          end
         end
       end
     end

data/lib/celluloid/cpu_counter.rb

@@ -13,6 +13,8 @@ module Celluloid
       end
     when 'mingw', 'mswin'
       @cores = Integer(ENV["NUMBER_OF_PROCESSORS"][/\d+/])
+    when 'freebsd'
+      @cores = Integer(`sysctl hw.ncpu`[/\d+/])
     else
       @cores = nil
     end

data/lib/celluloid/evented_mailbox.rb

@@ -42,10 +42,11 @@ module Celluloid
 
       until message
         if timeout
+          # TODO: use hitimes/timers instead of Time.now
           now = Time.now
           wait_until ||= now + timeout
           wait_interval = wait_until - now
-          return if wait_interval < 0
+          raise(TimeoutError, "mailbox timeout exceeded", nil) if wait_interval <= 0
         else
           wait_interval = nil
         end

data/lib/celluloid/exceptions.rb

@@ -0,0 +1,23 @@
+module Celluloid
+  # Base class of all Celluloid errors
+  Error = Class.new(StandardError)
+
+  # Don't do Actor-like things outside Actor scope
+  NotActorError = Class.new(Celluloid::Error)
+
+  # Trying to do something to a dead actor
+  DeadActorError = Class.new(Celluloid::Error)
+
+  # A timeout occured before the given request could complete
+  TimeoutError = Class.new(Celluloid::Error)
+
+  # The sender made an error, not the current actor
+  class AbortError < Celluloid::Error
+    attr_reader :cause
+
+    def initialize(cause)
+      @cause = cause
+      super "caused by #{cause.inspect}: #{cause.to_s}"
+    end
+  end
+end

data/lib/celluloid/future.rb

@@ -8,7 +8,7 @@ module Celluloid
       return super unless block
 
       future = new
-      Celluloid::ThreadHandle.new(:future) do
+      Celluloid::ThreadHandle.new(Celluloid.actor_system, :future) do
         begin
           call = SyncCall.new(future, :call, args)
           call.dispatch(block)

data/lib/celluloid/handlers.rb

@@ -0,0 +1,41 @@
+require 'set'
+
+module Celluloid
+  class Handlers
+    def initialize
+      @handlers = Set.new
+    end
+
+    def handle(*patterns, &block)
+      patterns.each do |pattern|
+        handler = Handler.new pattern, block
+        @handlers << handler
+      end
+    end
+
+    # Handle incoming messages
+    def handle_message(message)
+      if handler = @handlers.find { |h| h.match(message) }
+        handler.call message
+        handler
+      end
+    end
+  end
+
+  # Methods blocking on a call to receive
+  class Handler
+    def initialize(pattern, block)
+      @pattern = pattern
+      @block = block
+    end
+
+    # Match a message with this receiver's block
+    def match(message)
+      @pattern === message
+    end
+
+    def call(message)
+      @block.call message
+    end
+  end
+end

data/lib/celluloid/internal_pool.rb

@@ -6,7 +6,6 @@ module Celluloid
     attr_accessor :max_idle
 
     def initialize
-      @group = ThreadGroup.new
       @mutex = Mutex.new
       @threads = []
 
@@ -108,7 +107,6 @@ module Celluloid
 
       thread[:celluloid_queue] = queue
       @threads << thread
-      @group.add(thread)
       thread
     end
 
@@ -137,7 +135,6 @@ module Celluloid
         @running = false
 
         @threads.shift.kill until @threads.empty?
-        @group.list.each(&:kill)
       end
     end