celluloid 0.15.2 → 0.16.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f22a9c7d89b293484d7dcbe03cda32d7055ee42a
-  data.tar.gz: a13abc0b96f0e4931f6ff20457f9665282a4d08b
+  metadata.gz: 3f9e4bf5d8e26e99c5321bc02c61cafa9de48600
+  data.tar.gz: b239f25215d8c3ca0c9c27cd3e08954fa62ee35c
 SHA512:
-  metadata.gz: fba64fd21b7f58cf3fab69cdcfe889b4b95478a5bcad61557b1376e3965bc73583eeaf215be7003e886cc0fdd6a239aa79dd3738cd6ad831ce1c114435da4ff0
-  data.tar.gz: fea6248e5f4e1931485673a458182ca86f380820b2e18acd7d90618203f8c6a193bdf33213161d397153dd43485bb4e1907ff65fb9efd14cc7c6a70cfcb4c309
+  metadata.gz: be0d373d83500400c1135176382097f8bdffeb378fbce48f95852195975984a626221292ade6182ba84cc5a9ca06fa0849461d28c68e9adea33c129396ab39a3
+  data.tar.gz: 6f6cd39aec05a5b8f4b461ad88cd6c960a37d5832ca36ee5f633bf0e3229b294fb714668dcf87d843e162749507c301d14d32d2ae2d344c726b3f55346f9e6c8

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011-2014 Tony Arcieri
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -94,6 +94,28 @@ The following API documentation is also available:
 * [Celluloid class methods](http://rubydoc.info/gems/celluloid/Celluloid/ClassMethods)
 * [All Celluloid classes](http://rubydoc.info/gems/celluloid/index)
 
+Related Projects
+----------------
+
+Celluloid is the parent project of a related ecosystem of other projects. If you
+like Celluloid we definitely recommend you check them out:
+
+* [Celluloid::IO][celluloid-io]: "Evented" IO support for Celluloid actors
+* [Celluloid::ZMQ][celluloid-zmq]: "Evented" 0MQ support for Celluloid actors
+* [DCell][dcell]: The Celluloid actor protocol distributed over 0MQ
+* [Reel][reel]: An "evented" web server based on Celluloid::IO
+* [Lattice][lattice]: A concurrent realtime web framework based on Celluloid::IO
+* [nio4r][nio4r]: "New IO for Ruby": high performance IO selectors
+* [Timers][timers]: A generic Ruby timer library for event-based systems
+
+[celluloid-io]: https://github.com/celluloid/celluloid-io/
+[celluloid-zmq]: https://github.com/celluloid/celluloid-zmq/
+[dcell]: https://github.com/celluloid/dcell/
+[reel]: https://github.com/celluloid/reel/
+[lattice]: https://github.com/celluloid/lattice/
+[nio4r]: https://github.com/celluloid/nio4r/
+[timers]: https://github.com/celluloid/timers/
+
 Installation
 ------------
 
@@ -131,7 +153,8 @@ Celluloid requires Ruby 1.9 mode on all interpreters.
 Additional Reading
 ------------------
 
-* [Concurrent Object-Oriented Programming in Python with ATOM](http://python.org/workshops/1997-10/proceedings/atom/):
+* [Concurrent Object-Oriented Programming in Python with
+  ATOM](http://citeseerx.ist.psu.edu/viewdoc/download;jsessionid=11A3EACE78AAFF6D6D62A64118AFCA7C?doi=10.1.1.47.5074&rep=rep1&type=pdf):
   a similar system to Celluloid written in Python
 
 Contributing to Celluloid
@@ -145,5 +168,9 @@ Contributing to Celluloid
 License
 -------
 
-Copyright (c) 2013 Tony Arcieri. Distributed under the MIT License. See
+Copyright (c) 2011-2014 Tony Arcieri. Distributed under the MIT License. See
 LICENSE.txt for further details.
+
+
+[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/celluloid/celluloid/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
+

data/lib/celluloid.rb

@@ -3,25 +3,32 @@ require 'thread'
 require 'timeout'
 require 'set'
 
-if defined?(JRUBY_VERSION) && JRUBY_VERSION == "1.7.3"
-  raise "Celluloid is broken on JRuby 1.7.3. Please upgrade to 1.7.4+"
-end
-
 module Celluloid
-  VERSION = '0.15.2'
-  Error = Class.new StandardError
+  # Expose all instance methods as singleton methods
+  extend self
+
+  VERSION = '0.16.0.pre'
 
-  extend self # expose all instance methods as singleton methods
+  # Linking times out after 5 seconds
+  LINKING_TIMEOUT = 5
 
   # Warning message added to Celluloid objects accessed outside their actors
   BARE_OBJECT_WARNING_MESSAGE = "WARNING: BARE CELLULOID OBJECT "
 
   class << self
-    attr_accessor :internal_pool    # Internal thread pool
+    attr_writer   :actor_system     # Default Actor System
     attr_accessor :logger           # Thread-safe logger class
     attr_accessor :task_class       # Default task type to use
     attr_accessor :shutdown_timeout # How long actors have to terminate
 
+    def actor_system
+      if Thread.current.celluloid?
+        Thread.current[:celluloid_actor_system] or raise Error, "actor system not running"
+      else
+        Thread.current[:celluloid_actor_system] || @actor_system or raise Error, "Celluloid is not yet started; use Celluloid.boot"
+      end
+    end
+
     def included(klass)
       klass.send :extend,  ClassMethods
       klass.send :include, InstanceMethods
@@ -29,19 +36,29 @@ module Celluloid
       klass.send :extend, Properties
 
       klass.property :mailbox_class, :default => Celluloid::Mailbox
-      klass.property :proxy_class,   :default => Celluloid::ActorProxy
+      klass.property :proxy_class,   :default => Celluloid::CellProxy
       klass.property :task_class,    :default => Celluloid.task_class
       klass.property :mailbox_size
 
+      klass.property :exclusive_actor, :default => false
+      klass.property :exclusive_methods, :multi => true
       klass.property :execute_block_on_receiver,
         :default => [:after, :every, :receive],
         :multi   => true
 
       klass.property :finalizer
-      klass.property :exit_handler
+      klass.property :exit_handler_name
 
       klass.send(:define_singleton_method, :trap_exit) do |*args|
-        exit_handler(*args)
+        exit_handler_name(*args)
+      end
+
+      klass.send(:define_singleton_method, :exclusive) do |*args|
+        if args.any?
+          exclusive_methods(*exclusive_methods, *args)
+        else
+          exclusive_actor true
+        end
       end
     end
 
@@ -69,7 +86,7 @@ module Celluloid
 
     # Perform a stack dump of all actors to the given output object
     def stack_dump(output = STDERR)
-      Celluloid::StackDump.new.dump(output)
+      actor_system.stack_dump.print(output)
     end
     alias_method :dump, :stack_dump
 
@@ -106,18 +123,15 @@ module Celluloid
     end
 
     def init
-      self.internal_pool = InternalPool.new
+      @actor_system = ActorSystem.new
     end
 
-    # Launch default services
-    # FIXME: We should set up the supervision hierarchy here
     def start
-      Celluloid::Notifications::Fanout.supervise_as :notifications_fanout
-      Celluloid::IncidentReporter.supervise_as :default_incident_reporter, STDERR
+      actor_system.start
     end
 
     def running?
-      internal_pool
+      actor_system && actor_system.running?
     end
 
     def register_shutdown
@@ -139,41 +153,7 @@ module Celluloid
 
     # Shut down all running actors
     def shutdown
-      actors = Actor.all
-
-      Timeout.timeout(shutdown_timeout) do
-        internal_pool.shutdown
-
-        Logger.debug "Terminating #{actors.size} #{(actors.size > 1) ? 'actors' : 'actor'}..." if actors.size > 0
-
-        # Attempt to shut down the supervision tree, if available
-        Supervisor.root.terminate if Supervisor.root
-
-        # 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
-      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
+      actor_system.shutdown
     end
 
     def version
@@ -185,7 +165,7 @@ module Celluloid
   module ClassMethods
     # Create a new actor
     def new(*args, &block)
-      proxy = Actor.new(allocate, actor_options).proxy
+      proxy = Cell.new(allocate, behavior_options, actor_options).proxy
       proxy._send_(:initialize, *args, &block)
       proxy
     end
@@ -195,7 +175,7 @@ module Celluloid
     def new_link(*args, &block)
       raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
 
-      proxy = Actor.new(allocate, actor_options).proxy
+      proxy = Cell.new(allocate, behavior_options, actor_options).proxy
       Actor.link(proxy)
       proxy._send_(:initialize, *args, &block)
       proxy
@@ -233,26 +213,28 @@ module Celluloid
       Actor.join(new(*args, &block))
     end
 
-    # Mark methods as running exclusively
-    def exclusive(*methods)
-      if methods.empty?
-        @exclusive_methods = :all
-      elsif !defined?(@exclusive_methods) || @exclusive_methods != :all
-        @exclusive_methods ||= Set.new
-        @exclusive_methods.merge methods.map(&:to_sym)
-      end
+    def actor_system
+      Celluloid.actor_system
     end
 
     # Configuration options for Actor#new
     def actor_options
       {
+        :actor_system      => actor_system,
         :mailbox_class     => mailbox_class,
         :mailbox_size      => mailbox_size,
-        :proxy_class       => proxy_class,
         :task_class        => task_class,
-        :exit_handler      => exit_handler,
-        :exclusive_methods => defined?(@exclusive_methods) ? @exclusive_methods : nil,
-        :receiver_block_executions => execute_block_on_receiver
+        :exclusive         => exclusive_actor,
+      }
+    end
+
+    def behavior_options
+      {
+        :proxy_class               => proxy_class,
+        :exclusive_methods         => exclusive_methods,
+        :exit_handler_name         => exit_handler_name,
+        :finalizer                 => finalizer,
+        :receiver_block_executions => execute_block_on_receiver,
       }
     end
 
@@ -291,9 +273,10 @@ module Celluloid
     end
 
     # Obtain the name of the current actor
-    def name
-      Actor.name
+    def registered_name
+      Actor.registered_name
     end
+    alias_method :name, :registered_name
 
     def inspect
       return "..." if Celluloid.detect_recursion
@@ -303,7 +286,7 @@ module Celluloid
       if leaked?
         str << Celluloid::BARE_OBJECT_WARNING_MESSAGE
       else
-        str << "Celluloid::ActorProxy"
+        str << "Celluloid::CellProxy"
       end
 
       str << "(#{self.class}:0x#{object_id.to_s(16)})"
@@ -335,7 +318,7 @@ module Celluloid
 
   # Terminate this actor
   def terminate
-    Thread.current[:celluloid_actor].proxy.terminate!
+    Thread.current[:celluloid_actor].behavior_proxy.terminate!
   end
 
   # Send a signal with the given name to all waiting methods
@@ -458,15 +441,21 @@ module Celluloid
 
   # Handle async calls within an actor itself
   def async(meth = nil, *args, &block)
-    Thread.current[:celluloid_actor].proxy.async meth, *args, &block
+    Thread.current[:celluloid_actor].behavior_proxy.async meth, *args, &block
   end
 
   # Handle calls to future within an actor itself
   def future(meth = nil, *args, &block)
-    Thread.current[:celluloid_actor].proxy.future meth, *args, &block
+    Thread.current[:celluloid_actor].behavior_proxy.future meth, *args, &block
   end
 end
 
+if defined?(JRUBY_VERSION) && JRUBY_VERSION == "1.7.3"
+  raise "Celluloid is broken on JRuby 1.7.3. Please upgrade to 1.7.4+"
+end
+
+require 'celluloid/exceptions'
+
 require 'celluloid/calls'
 require 'celluloid/call_chain'
 require 'celluloid/condition'
@@ -482,6 +471,7 @@ require 'celluloid/mailbox'
 require 'celluloid/evented_mailbox'
 require 'celluloid/method'
 require 'celluloid/properties'
+require 'celluloid/handlers'
 require 'celluloid/receivers'
 require 'celluloid/registry'
 require 'celluloid/responses'
@@ -495,13 +485,16 @@ require 'celluloid/uuid'
 
 require 'celluloid/proxies/abstract_proxy'
 require 'celluloid/proxies/sync_proxy'
+require 'celluloid/proxies/cell_proxy'
 require 'celluloid/proxies/actor_proxy'
 require 'celluloid/proxies/async_proxy'
 require 'celluloid/proxies/future_proxy'
 require 'celluloid/proxies/block_proxy'
 
 require 'celluloid/actor'
+require 'celluloid/cell'
 require 'celluloid/future'
+require 'celluloid/actor_system'
 require 'celluloid/pool_manager'
 require 'celluloid/supervision_group'
 require 'celluloid/supervisor'
@@ -510,6 +503,8 @@ require 'celluloid/logging'
 
 require 'celluloid/legacy' unless defined?(CELLULOID_FUTURE)
 
+$CELLULOID_MONITORING = false
+
 # Configure default systemwide settings
 Celluloid.task_class = Celluloid::TaskFiber
 Celluloid.logger     = Logger.new(STDERR)

data/lib/celluloid/actor.rb

@@ -1,56 +1,27 @@
 require 'timers'
 
 module Celluloid
-  # Don't do Actor-like things outside Actor scope
-  class NotActorError < Celluloid::Error; end
-
-  # Trying to do something to a dead actor
-  class DeadActorError < Celluloid::Error; end
-
-  # A timeout occured before the given request could complete
-  class TimeoutError < Celluloid::Error; end
-
-  # 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
-
-  LINKING_TIMEOUT = 5 # linking times out after 5 seconds
-  OWNER_IVAR = :@celluloid_owner # reference to owning actor
-
   # Actors are Celluloid's concurrency primitive. They're implemented as
   # normal Ruby objects wrapped in threads which communicate with asynchronous
   # messages.
   class Actor
-    attr_reader :subject, :proxy, :tasks, :links, :mailbox, :thread, :name
+    attr_reader :behavior, :proxy, :tasks, :links, :mailbox, :thread, :name, :timers
+    attr_writer :exit_handler
 
     class << self
       extend Forwardable
 
-      def_delegators "Celluloid::Registry.root", :[], :[]=
-
-      def registered
-        Registry.root.names
-      end
-
-      def clear_registry
-        Registry.root.clear
-      end
+      def_delegators "Celluloid.actor_system", :[], :[]=, :delete, :registered, :clear_registry
 
       # Obtain the current actor
       def current
         actor = Thread.current[:celluloid_actor]
         raise NotActorError, "not in actor scope" unless actor
-        actor.proxy
+        actor.behavior_proxy
       end
 
       # Obtain the name of the current actor
-      def name
+      def registered_name
         actor = Thread.current[:celluloid_actor]
         raise NotActorError, "not in actor scope" unless actor
         actor.name
@@ -76,12 +47,7 @@ module Celluloid
 
       # Obtain all running actors in the system
       def all
-        actors = []
-        Celluloid.internal_pool.each do |t|
-          next unless t.role == :actor
-          actors << t.actor.proxy if t.actor && t.actor.respond_to?(:proxy)
-        end
-        actors
+        Celluloid.actor_system.running
       end
 
       # Watch for exit events from another actor
@@ -131,34 +97,44 @@ module Celluloid
       end
     end
 
-    # Wrap the given subject with an Actor
-    def initialize(subject, options = {})
-      @subject = subject
+    def initialize(behavior, options)
+      @behavior         = behavior
 
+      @actor_system     = options.fetch(:actor_system)
       @mailbox          = options.fetch(:mailbox_class, Mailbox).new
       @mailbox.max_size = options.fetch(:mailbox_size, nil)
 
       @task_class   = options[:task_class] || Celluloid.task_class
-      @exit_handler = options[:exit_handler]
-      @exclusives   = options[:exclusive_methods]
-      @receiver_block_executions = options[:receiver_block_executions]
+      @exit_handler = method(:default_exit_handler)
+      @exclusive    = options.fetch(:exclusive, false)
 
       @tasks     = TaskSet.new
       @links     = Links.new
       @signals   = Signals.new
       @receivers = Receivers.new
       @timers    = Timers.new
-      @running   = true
-      @exclusive = false
+      @handlers  = Handlers.new
+      @running   = false
       @name      = nil
 
-      @thread = ThreadHandle.new(:actor) do
+      handle(SystemEvent) do |message|
+        handle_system_event message
+      end
+    end
+
+    def start
+      @running = true
+      @thread = ThreadHandle.new(@actor_system, :actor) do
         setup_thread
         run
       end
 
-      @proxy = (options[:proxy_class] || ActorProxy).new(self)
-      @subject.instance_variable_set(OWNER_IVAR, self)
+      @proxy = ActorProxy.new(@thread, @mailbox)
+      Celluloid::Probe.actor_created(self) if $CELLULOID_MONITORING
+    end
+
+    def behavior_proxy
+      @behavior.proxy
     end
 
     def setup_thread
@@ -168,18 +144,16 @@ module Celluloid
 
     # Run the actor loop
     def run
-      begin
-        while @running
-          if message = @mailbox.receive(timeout_interval)
-            handle_message message
-          else
-            # No message indicates a timeout
-            @timers.fire
-            @receivers.fire_timers
-          end
+      while @running
+        begin
+          message = @mailbox.receive(timeout_interval)
+          handle_message message
+        rescue TimeoutError
+          @timers.fire
+          @receivers.fire_timers
+        rescue MailboxShutdown
+          @running = false
         end
-      rescue MailboxShutdown
-        # If the mailbox detects shutdown, exit the actor
       end
 
       shutdown
@@ -208,14 +182,14 @@ module Celluloid
             msg.type == type
           end
 
-          case message
-          when LinkingResponse
+          if message.instance_of? LinkingResponse
+            Celluloid::Probe.actors_linked(self, receiver) if $CELLULOID_MONITORING
             # We're done!
-            system_events.each { |ev| handle_system_event(ev) }
+            system_events.each { |ev| @mailbox << ev }
             return
-          when NilClass
+          elsif message.instance_of? NilClass
             raise TimeoutError, "linking timeout of #{LINKING_TIMEOUT} seconds exceeded"
-          when SystemEvent
+          elsif message.instance_of? SystemEvent
             # Queue up pending system events to be processed after we've successfully linked
             system_events << message
           else raise 'wtf'
@@ -234,6 +208,10 @@ module Celluloid
       @signals.wait name
     end
 
+    def handle(*patterns, &block)
+      @handlers.handle(*patterns, &block)
+    end
+
     # Receive an asynchronous message
     def receive(timeout = nil, &block)
       loop do
@@ -304,28 +282,7 @@ module Celluloid
 
     # Handle standard low-priority messages
     def handle_message(message)
-      case message
-      when SystemEvent
-        handle_system_event message
-      when Call
-        meth = message.method
-        if meth == :__send__
-          meth = message.arguments.first
-        end
-        if @receiver_block_executions && meth
-          if @receiver_block_executions.include?(meth.to_sym)
-            message.execute_block_on_receiver
-          end
-        end
-
-        task(:call, :method_name => meth, :dangerous_suspend => meth == :initialize) {
-          message.dispatch(@subject)
-        }
-      when BlockCall
-        task(:invoke_block) { message.dispatch }
-      when BlockResponse, Response
-        message.dispatch
-      else
+      unless @handlers.handle_message(message)
         unless @receivers.handle_message(message)
           Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
         end
@@ -335,17 +292,19 @@ module Celluloid
 
     # Handle high-priority system event messages
     def handle_system_event(event)
-      case event
-      when ExitEvent
-        task(:exit_handler, :method_name => @exit_handler) { handle_exit_event event }
-      when LinkingRequest
+      if event.instance_of? ExitEvent
+        handle_exit_event(event)
+      elsif event.instance_of? LinkingRequest
         event.process(links)
-      when NamingRequest
+      elsif event.instance_of? NamingRequest
         @name = event.name
-      when TerminationRequest
+        Celluloid::Probe.actor_named(self) if $CELLULOID_MONITORING
+      elsif event.instance_of? TerminationRequest
         terminate
-      when SignalConditionRequest
+      elsif event.instance_of? SignalConditionRequest
         event.call
+      else
+        Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
       end
     end
 
@@ -353,47 +312,34 @@ module Celluloid
     def handle_exit_event(event)
       @links.delete event.actor
 
-      # Run the exit handler if available
-      return @subject.send(@exit_handler, event.actor, event.reason) if @exit_handler
+      @exit_handler.call(event)
+    end
 
-      # Reraise exceptions from linked actors
-      # If no reason is given, actor terminated cleanly
+    def default_exit_handler(event)
       raise event.reason if event.reason
     end
 
     # Handle any exceptions that occur within a running actor
     def handle_crash(exception)
-      Logger.crash("#{@subject.class} crashed!", exception)
-      shutdown ExitEvent.new(@proxy, exception)
+      # TODO: add meta info
+      Logger.crash("Actor crashed!", exception)
+      shutdown ExitEvent.new(behavior_proxy, exception)
     rescue => ex
-      Logger.crash("#{@subject.class}: ERROR HANDLER CRASHED!", ex)
+      Logger.crash("ERROR HANDLER CRASHED!", ex)
     end
 
     # Handle cleaning up this actor after it exits
-    def shutdown(exit_event = ExitEvent.new(@proxy))
-      run_finalizer
+    def shutdown(exit_event = ExitEvent.new(behavior_proxy))
+      @behavior.shutdown
       cleanup exit_event
     ensure
       Thread.current[:celluloid_actor]   = nil
       Thread.current[:celluloid_mailbox] = nil
     end
 
-    # Run the user-defined finalizer, if one is set
-    def run_finalizer
-      finalizer = @subject.class.finalizer
-      return unless finalizer && @subject.respond_to?(finalizer, true)
-
-      task(:finalizer, :method_name => finalizer, :dangerous_suspend => true) do
-        begin
-          @subject.__send__(finalizer)
-        rescue => ex
-          Logger.crash("#{@subject.class}#finalize crashed!", ex)
-        end
-      end
-    end
-
     # Clean up after this actor
     def cleanup(exit_event)
+      Celluloid::Probe.actor_died(self) if $CELLULOID_MONITORING
       @mailbox.shutdown
       @links.each do |actor|
         if actor.mailbox.alive?
@@ -401,16 +347,16 @@ module Celluloid
         end
       end
 
-      tasks.to_a.each { |task| task.terminate }
+      tasks.to_a.each(&:terminate)
     rescue => ex
-      Logger.crash("#{@subject.class}: CLEANUP CRASHED!", ex)
+      # TODO: metadata
+      Logger.crash("CLEANUP CRASHED!", ex)
     end
 
     # Run a method inside a task unless it's exclusive
     def task(task_type, meta = nil)
-      method_name = meta && meta.fetch(:method_name, nil)
       @task_class.new(task_type, meta) {
-        if @exclusives && (@exclusives == :all || (method_name && @exclusives.include?(method_name.to_sym)))
+        if @exclusive
           Celluloid.exclusive { yield }
         else
           yield