celluloid 0.13.0 → 0.14.0.pre

data/lib/celluloid/core_ext.rb

@@ -1,20 +1,9 @@
 require 'celluloid/fiber'
 
-# Monkeypatch Thread to allow lazy access to its Celluloid::Mailbox
 class Thread
   attr_accessor :uuid_counter, :uuid_limit
 
-  # Retrieve the mailbox for the current thread or lazily initialize it
-  def self.mailbox
-    current[:celluloid_mailbox] ||= Celluloid::Mailbox.new
+  def celluloid?
+    false
   end
-
-  # Receive a message either as an actor or through the local mailbox
-  def self.receive(timeout = nil, &block)
-    if Celluloid.actor?
-      Celluloid.receive(timeout, &block)
-    else
-      mailbox.receive(timeout, &block)
-    end
-  end
-end
+end

data/lib/celluloid/cpu_counter.rb

@@ -12,7 +12,7 @@ module Celluloid
         Dir["/sys/devices/system/cpu/cpu*"].select { |n| n=~/cpu\d+/ }.count
       end
     when 'mingw', 'mswin'
-      @cores = Integer(`SET NUMBER_OF_PROCESSORS`[/\d+/])
+      @cores = Integer(ENV["NUMBER_OF_PROCESSORS"][/\d+/])
     else
       @cores = nil
     end

data/lib/celluloid/evented_mailbox.rb

@@ -0,0 +1,82 @@
+module Celluloid
+  # An alternative implementation of Celluloid::Mailbox using Reactor
+  class EventedMailbox < Celluloid::Mailbox
+    attr_reader :reactor
+
+    def initialize(reactor_class)
+      super()
+      # @condition won't be used in the class.
+      @reactor = reactor_class.new
+    end
+
+    # Add a message to the Mailbox
+    def <<(message)
+      @mutex.lock
+      begin
+        if mailbox_full
+          Logger.debug "Discarded message: #{message}"
+          return
+        end
+        if message.is_a?(SystemEvent)
+          # Silently swallow system events sent to dead actors
+          return if @dead
+
+          # SystemEvents are high priority messages so they get added to the
+          # head of our message queue instead of the end
+          @messages.unshift message
+        else
+          raise MailboxError, "dead recipient" if @dead
+          @messages << message
+        end
+
+        current_actor = Thread.current[:celluloid_actor]
+        @reactor.wakeup unless current_actor && current_actor.mailbox == self
+      rescue IOError
+        raise MailboxError, "dead recipient"
+      ensure
+        @mutex.unlock rescue nil
+      end
+      nil
+    end
+
+    # Receive a message from the Mailbox
+    def receive(timeout = nil, &block)
+      message = next_message(block)
+
+      until message
+        if timeout
+          now = Time.now
+          wait_until ||= now + timeout
+          wait_interval = wait_until - now
+          return if wait_interval < 0
+        else
+          wait_interval = nil
+        end
+
+        @reactor.run_once(wait_interval)
+        message = next_message(block)
+      end
+
+      message
+    rescue IOError
+      shutdown # force shutdown of the mailbox
+      raise MailboxShutdown, "mailbox shutdown called during receive"
+    end
+
+    # Obtain the next message from the mailbox that matches the given block
+    def next_message(block)
+      @mutex.lock
+      begin
+        super(&block)
+      ensure
+        @mutex.unlock rescue nil
+      end
+    end
+
+    # Cleanup any IO objects this Mailbox may be using
+    def shutdown
+      @reactor.shutdown
+      super
+    end
+  end
+end

data/lib/celluloid/fsm.rb

@@ -62,6 +62,7 @@ module Celluloid
     # Be kind and call super if you must redefine initialize
     def initialize(actor = nil)
       @state = self.class.default_state
+      @delayed_transition = nil
       @actor = actor
       @actor ||= Celluloid.current_actor if Celluloid.actor?
     end
@@ -166,6 +167,7 @@ module Celluloid
 
       def initialize(name, transitions = nil, &block)
         @name, @block = name, block
+        @transitions = nil
         @transitions = Array(transitions).map { |t| t.to_sym } if transitions
       end
 

data/lib/celluloid/future.rb

@@ -57,11 +57,11 @@ module Celluloid
         else
           case @forwards
           when Array
-            @forwards << Thread.mailbox
+            @forwards << Celluloid.mailbox
           when NilClass
-            @forwards = Thread.mailbox
+            @forwards = Celluloid.mailbox
           else
-            @forwards = [@forwards, Thread.mailbox]
+            @forwards = [@forwards, Celluloid.mailbox]
           end
         end
       ensure
@@ -69,7 +69,7 @@ module Celluloid
       end
 
       unless ready
-        result = Thread.receive(timeout) do |msg|
+        result = Celluloid.receive(timeout) do |msg|
           msg.is_a?(Future::Result) && msg.future == self
         end
       end

data/lib/celluloid/internal_pool.rb

@@ -10,6 +10,10 @@ module Celluloid
       @mutex = Mutex.new
       @busy_size = @idle_size = 0
 
+      reset
+    end
+
+    def reset
       # TODO: should really adjust this based on usage
       @max_idle = 16
     end
@@ -38,7 +42,7 @@ module Celluloid
         if @pool.size >= @max_idle
           thread[:celluloid_queue] << nil
         else
-          clean_thread_locals(thread)
+          thread.recycle
           @pool << thread
           @idle_size += 1
           @busy_size -= 1
@@ -65,13 +69,12 @@ module Celluloid
       thread
     end
 
-    # Clean the thread locals of an incoming thread
-    def clean_thread_locals(thread)
-      thread.keys.each do |key|
-        next if key == :celluloid_queue
-
-        # Ruby seems to lack an API for deleting thread locals. WTF, Ruby?
-        thread[key] = nil
+    def shutdown
+      @mutex.synchronize do
+        @max_idle = 0
+        @pool.each do |thread|
+          thread[:celluloid_queue] << nil
+        end
       end
     end
   end

data/lib/celluloid/legacy.rb

@@ -9,9 +9,9 @@ module Celluloid
 
         unbanged_meth = meth.to_s
         unbanged_meth.slice!(-1, 1)
-        Actor.async @mailbox, unbanged_meth, *args, &block
+        async unbanged_meth, *args, &block
       else
-        Actor.call  @mailbox, meth, *args, &block
+        super
       end
     end
   end
@@ -27,20 +27,21 @@ module Celluloid
         unbanged_meth = meth.to_s.sub(/!$/, '')
         args.unshift unbanged_meth
 
-        call = AsyncCall.new(:__send__, args, block)
-        begin
-          Thread.current[:celluloid_actor].mailbox << call
-        rescue MailboxError
-          # Silently swallow asynchronous calls to dead actors. There's no way
-          # to reliably generate DeadActorErrors for async calls, so users of
-          # async calls should find other ways to deal with actors dying
-          # during an async call (i.e. linking/supervisors)
-        end
-
+        async :__send__, *args, &block
         return
       end
 
       super
     end
   end
-end
+end
+
+class Thread
+  def self.mailbox
+    Celluloid.mailbox
+  end
+
+  def self.receive(timeout = nil, &block)
+    Celluloid.receive(timeout, &block)
+  end
+end

data/lib/celluloid/logging/incident_logger.rb

@@ -49,9 +49,9 @@ module Celluloid
       @sizelimit = options[:sizelimit] || 100
 
       @buffer_mutex = Mutex.new
-      @buffers = Hash.new do |progname_hash, progname| 
+      @buffers = Hash.new do |progname_hash, _progname|
         @buffer_mutex.synchronize do
-          progname_hash[progname] = Hash.new do |severity_hash, severity|
+          progname_hash[_progname] = Hash.new do |severity_hash, severity|
             severity_hash[severity] = RingBuffer.new(@sizelimit)
           end
         end

data/lib/celluloid/mailbox.rb

@@ -11,6 +11,7 @@ module Celluloid
 
     # A unique address at which this mailbox can be found
     attr_reader :address
+    attr_accessor :max_size
 
     def initialize
       @address   = Celluloid.uuid
@@ -18,12 +19,17 @@ module Celluloid
       @mutex     = Mutex.new
       @dead      = false
       @condition = ConditionVariable.new
+      @max_size  = nil
     end
 
     # Add a message to the Mailbox
     def <<(message)
       @mutex.lock
       begin
+        if mailbox_full
+          Logger.debug "Discarded message: #{message}"
+          return
+        end
         if message.is_a?(SystemEvent)
           # Silently swallow system events sent to dead actors
           return if @dead
@@ -125,5 +131,15 @@ module Celluloid
     def inspect
       "#<#{self.class}:#{object_id.to_s(16)} @messages=[#{map { |m| m.inspect }.join(', ')}]>"
     end
+
+    # Number of messages in the Mailbox
+    def size
+      @mutex.synchronize { @messages.size }
+    end
+
+    private
+    def mailbox_full
+      @max_size && @messages.size >= @max_size
+    end
   end
 end

data/lib/celluloid/method.rb

@@ -2,23 +2,23 @@ module Celluloid
   # Method handles that route through an actor proxy
   class Method
 
-    def initialize(actor, name)
-      raise NameError, "undefined method `#{name}'" unless actor.respond_to? name
+    def initialize(proxy, name)
+      raise NameError, "undefined method `#{name}'" unless proxy.respond_to? name
 
-      @actor, @name = actor, name
-      @klass = @actor.class
+      @proxy, @name = proxy, name
+      @klass = @proxy.class
     end
 
     def arity
-      @actor._send_(:method, @name).arity
+      @proxy.method_missing(:method, @name).arity
     end
 
     def call(*args, &block)
-      @actor._send_(@name, *args, &block)
+      @proxy.__send__(@name, *args, &block)
     end
 
     def inspect
-      "#<Celluloid::Method #{@klass}#{@name}>"
+      "#<Celluloid::Method #{@klass}##{@name}>"
     end
   end
 end

data/lib/celluloid/notifications.rb

@@ -67,7 +67,7 @@ module Celluloid
       end
 
       def publish(pattern, *args)
-        Actor.async(actor.mailbox, method, pattern, *args)
+        actor.async method, pattern, *args
       end
 
       def subscribed_to?(pattern)

data/lib/celluloid/proxies/abstract_proxy.rb

@@ -5,7 +5,7 @@ module Celluloid
     needed = [:object_id, :__id__, :hash] - instance_methods
     if needed.any?
       include ::Kernel.dup.module_eval {
-        undef_method *(instance_methods - needed)
+        undef_method(*(instance_methods - needed))
         self
       }
 

data/lib/celluloid/proxies/actor_proxy.rb

@@ -1,55 +1,54 @@
 module Celluloid
   # 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
-    attr_reader :mailbox, :thread
+  class ActorProxy < SyncProxy
+    attr_reader :thread
 
     def initialize(actor)
-      @mailbox, @thread, @klass = actor.mailbox, actor.thread, actor.subject.class.to_s
+      @thread = actor.thread
 
-      @async_proxy  = AsyncProxy.new(actor)
-      @future_proxy = FutureProxy.new(actor)
+      super(actor.mailbox, actor.subject.class.to_s)
+      @sync_proxy   = SyncProxy.new(@mailbox, @klass)
+      @async_proxy  = AsyncProxy.new(@mailbox, @klass)
+      @future_proxy = FutureProxy.new(@mailbox, @klass)
     end
-    
-    # allow querying the real class
-    alias :__class__ :class
-    
+
     def class
-      Actor.call @mailbox, :__send__, :class
+      method_missing :__send__, :class
     end
 
     def send(meth, *args, &block)
-      Actor.call @mailbox, :send, meth, *args, &block
+      method_missing :send, meth, *args, &block
     end
 
     def _send_(meth, *args, &block)
-      Actor.call @mailbox, :__send__, meth, *args, &block
+      method_missing :__send__, meth, *args, &block
     end
 
     def inspect
-      Actor.call(@mailbox, :inspect)
+      method_missing :inspect
     rescue DeadActorError
-      "#<Celluloid::Actor(#{@klass}) dead>"
+      "#<Celluloid::ActorProxy(#{@klass}) dead>"
     end
 
     def name
-      Actor.call @mailbox, :name
+      method_missing :name
     end
 
     def is_a?(klass)
-      Actor.call @mailbox, :is_a?, klass
+      method_missing :is_a?, klass
     end
 
     def kind_of?(klass)
-      Actor.call @mailbox, :kind_of?, klass
+      method_missing :kind_of?, klass
     end
 
     def respond_to?(meth, include_private = false)
-      Actor.call @mailbox, :respond_to?, meth, include_private
+      method_missing :respond_to?, meth, include_private
     end
 
     def methods(include_ancestors = true)
-      Actor.call @mailbox, :methods, include_ancestors
+      method_missing :methods, include_ancestors
     end
 
     def method(name)
@@ -61,13 +60,15 @@ module Celluloid
     end
 
     def to_s
-      Actor.call @mailbox, :to_s
+      method_missing :to_s
     end
 
+    alias_method :sync, :method_missing
+
     # 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
+        @async_proxy.method_missing method_name, *args, &block
       else
         @async_proxy
       end
@@ -76,7 +77,7 @@ module Celluloid
     # 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
+        @future_proxy.method_missing method_name, *args, &block
       else
         @future_proxy
       end
@@ -94,10 +95,5 @@ module Celluloid
       ::Kernel.raise DeadActorError, "actor already terminated" unless alive?
       @mailbox << TerminationRequest.new
     end
-
-    # method_missing black magic to call bang predicate methods asynchronously
-    def method_missing(meth, *args, &block)
-      Actor.call @mailbox, meth, *args, &block
-    end
   end
 end