celluloid 0.13.0 → 0.14.1

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

data/lib/celluloid/proxies/async_proxy.rb

@@ -3,20 +3,32 @@ module Celluloid
   class AsyncProxy < AbstractProxy
     attr_reader :mailbox
 
-    def initialize(actor)
-      @mailbox, @klass = actor.mailbox, actor.subject.class.to_s
+    def initialize(mailbox, klass)
+      @mailbox, @klass = mailbox, klass
     end
 
     def inspect
       "#<Celluloid::AsyncProxy(#{@klass})>"
     end
 
-    # method_missing black magic to call bang predicate methods asynchronously
     def method_missing(meth, *args, &block)
       if @mailbox == ::Thread.current[:celluloid_mailbox]
-        Actor.async @mailbox, :__send__, meth, *args, &block
-      else
-        Actor.async @mailbox, meth, *args, &block
+        args.unshift meth
+        meth = :__send__
+      end
+
+      if block_given?
+        # FIXME: nicer exception
+        raise "Cannot use blocks with async yet"
+      end
+
+      begin
+        @mailbox << AsyncCall.new(meth, args, block)
+      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
     end
   end

data/lib/celluloid/proxies/block_proxy.rb

@@ -0,0 +1,29 @@
+module Celluloid
+  class BlockProxy
+    def initialize(call, mailbox, block)
+      @call = call
+      @mailbox = mailbox
+      @block = block
+      @execution = :sender
+    end
+    attr_writer :execution
+    attr_reader :call, :block
+
+    def to_proc
+      if @execution == :sender
+        lambda do |*values|
+          if task = Thread.current[:celluloid_task]
+            @mailbox << BlockCall.new(self, Actor.current.mailbox, values)
+            # TODO: if respond fails, the Task will never be resumed
+            task.suspend(:invokeblock)
+          else
+            # FIXME: better exception
+            raise "No task to suspend"
+          end
+        end
+      else
+        @block
+      end
+    end
+  end
+end

data/lib/celluloid/proxies/future_proxy.rb

@@ -3,8 +3,8 @@ module Celluloid
   class FutureProxy < AbstractProxy
     attr_reader :mailbox
 
-    def initialize(actor)
-      @mailbox, @klass = actor.mailbox, actor.subject.class.to_s
+    def initialize(mailbox, klass)
+      @mailbox, @klass = mailbox, klass
     end
 
     def inspect
@@ -13,7 +13,21 @@ module Celluloid
 
     # method_missing black magic to call bang predicate methods asynchronously
     def method_missing(meth, *args, &block)
-      Actor.future @mailbox, meth, *args, &block
+      if block_given?
+        # FIXME: nicer exception
+        raise "Cannot use blocks with futures yet"
+      end
+
+      future = Future.new
+      call = SyncCall.new(future, meth, args, block)
+
+      begin
+        @mailbox << call
+      rescue MailboxError
+        raise DeadActorError, "attempted to call a dead actor"
+      end
+
+      future
     end
   end
 end

data/lib/celluloid/proxies/sync_proxy.rb

@@ -0,0 +1,31 @@
+module Celluloid
+  # A proxy which sends synchronous calls to an actor
+  class SyncProxy < AbstractProxy
+    attr_reader :mailbox
+
+    def initialize(mailbox, klass)
+      @mailbox, @klass = mailbox, klass
+    end
+
+    def inspect
+      "#<Celluloid::SyncProxy(#{@klass})>"
+    end
+
+    def method_missing(meth, *args, &block)
+      if @mailbox == ::Thread.current[:celluloid_mailbox]
+        args.unshift meth
+        meth = :__send__
+      end
+
+      call = SyncCall.new(::Celluloid.mailbox, meth, args, block)
+
+      begin
+        @mailbox << call
+      rescue MailboxError
+        raise DeadActorError, "attempted to call a dead actor"
+      end
+
+      call.value
+    end
+  end
+end

data/lib/celluloid/receivers.rb

@@ -12,7 +12,7 @@ module Celluloid
     # Receive an asynchronous message
     def receive(timeout = nil, &block)
       if Celluloid.exclusive?
-        Thread.mailbox.receive(timeout, &block)
+        Celluloid.mailbox.receive(timeout, &block)
       else
         receiver = Receiver.new block
 

data/lib/celluloid/responses.rb

@@ -15,7 +15,7 @@ module Celluloid
   # Call completed successfully
   class SuccessResponse < Response; end
 
-  # Call was aborted due to caller error
+  # Call was aborted due to sender error
   class ErrorResponse < Response
     def value
       ex = super
@@ -29,4 +29,16 @@ module Celluloid
       raise ex
     end
   end
+
+  class BlockResponse
+    def initialize(call, result)
+      @call = call
+      @result = result
+    end
+
+    def dispatch
+      @call.task.resume(@result)
+    end
+  end
+
 end

data/lib/celluloid/stack_dump.rb

@@ -1,7 +1,7 @@
 module Celluloid
   class StackDump
 
-    class TaskState < Struct.new(:task_class, :status)
+    class TaskState < Struct.new(:task_class, :status, :backtrace)
     end
 
     class ActorState
@@ -24,8 +24,9 @@ module Celluloid
 
     def snapshot
       Thread.list.each do |thread|
-        if actor = thread[:celluloid_actor]
-          @actors << snapshot_actor(actor)
+        if thread.celluloid?
+          next unless thread.role == :actor
+          @actors << snapshot_actor(thread.actor) if thread.actor
         else
           @threads << snapshot_thread(thread)
         end
@@ -42,7 +43,7 @@ module Celluloid
         state.status = :idle
       else
         state.status = :running
-        state.tasks = tasks.collect { |t| TaskState.new(t.class, t.status) }
+        state.tasks = tasks.collect { |t| TaskState.new(t.class, t.status, t.backtrace) }
       end
 
       state.backtrace = actor.thread.backtrace if actor.thread
@@ -62,16 +63,18 @@ module Celluloid
 
         if actor.status == :idle
           string << "State: Idle (waiting for messages)\n"
+          display_backtrace actor.backtrace, string
         else
           string << "State: Running (executing tasks)\n"
+          display_backtrace actor.backtrace, string
           string << "Tasks:\n"
 
           actor.tasks.each_with_index do |task, i|
             string << "  #{i+1}) #{task.task_class}: #{task.status}\n"
+            display_backtrace task.backtrace, string
           end
         end
 
-        display_backtrace actor.backtrace, string
         output.print string
       end
 

data/lib/celluloid/supervision_group.rb

@@ -12,9 +12,9 @@ module Celluloid
 
       # Start this application (and watch it with a supervisor)
       def run!
-        group = new do |group|
+        group = new do |_group|
           blocks.each do |block|
-            block.call(group)
+            block.call(_group)
           end
         end
         group
@@ -63,6 +63,8 @@ module Celluloid
       yield current_actor if block_given?
     end
 
+    execute_block_on_receiver :initialize, :supervise, :supervise_as
+
     def supervise(klass, *args, &block)
       add(klass, :args => args, :block => block)
     end
@@ -95,8 +97,8 @@ module Celluloid
 
     # Restart a crashed actor
     def restart_actor(actor, reason)
-      member = @members.find do |member|
-        member.actor == actor
+      member = @members.find do |_member|
+        _member.actor == actor
       end
       raise "a group member went missing. This shouldn't be!" unless member
 
@@ -127,13 +129,11 @@ module Celluloid
         # 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)
+          options = {:args => @args}
+          options[:size] = @pool_size if @pool_size
+          @args = [options]
         end
+        @actor = @klass.send(@method, *@args, &@block)
         @registry[@name] = @actor if @name
       end
 

data/lib/celluloid/system_events.rb

@@ -57,6 +57,7 @@ module Celluloid
     def initialize(task, value)
       @task, @value = task, value
     end
+    attr_reader :task, :value
 
     def call
       @task.resume(@value)

data/lib/celluloid/tasks/task_fiber.rb

@@ -3,52 +3,22 @@ module Celluloid
 
   # Tasks with a Fiber backend
   class TaskFiber < Task
-    attr_reader :type, :status
-
-    # Run the given block within a task
-    def initialize(type)
-      super
-
-      actor    = Thread.current[:celluloid_actor]
-      mailbox  = Thread.current[:celluloid_mailbox]
-      chain_id = Thread.current[:celluloid_chain_id]
-
-      raise NotActorError, "can't create tasks outside of actors" unless actor
 
+    def create
       @fiber = Fiber.new do
-        @status = :running
-        Thread.current[:celluloid_actor]    = actor
-        Thread.current[:celluloid_mailbox]  = mailbox
-        Thread.current[:celluloid_task]     = self
-        Thread.current[:celluloid_chain_id] = chain_id
-
-        actor.tasks << self
-
-        begin
-          yield
-        rescue Task::TerminatedError
-          # Task was explicitly terminated
-        ensure
-          @status = :dead
-          actor.tasks.delete self
-        end
+        # FIXME: cannot use the writer as specs run inside normal Threads
+        Thread.current[:celluloid_role] = :actor
+        yield
       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
+    def signal
+      Fiber.yield
     end
 
     # Resume a suspended task, giving it a value to return if needed
-    def resume(value = nil)
+    def deliver(value)
       @fiber.resume value
-      nil
     rescue SystemStackError => ex
       raise FiberStackError, "#{ex} (please see https://github.com/celluloid/celluloid/wiki/Fiber-stack-errors)"
     rescue FiberError => ex
@@ -57,17 +27,9 @@ module Celluloid
 
     # Terminate this task
     def terminate
-      resume Task::TerminatedError.new("task was terminated") if @fiber.alive?
+      super
     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
+end