celluloid 0.17.2 → 0.18.0

data/lib/celluloid/notifications.rb

@@ -0,0 +1,95 @@
+module Celluloid
+  module Notifications
+    def self.notifier
+      Actor[:notifications_fanout] || raise(DeadActorError, "notifications fanout actor not running")
+    end
+
+    def publish(pattern, *args)
+      Celluloid::Notifications.notifier.publish(pattern, *args)
+    rescue DeadActorError
+      # Bad shutdown logic. Oh well....
+      # TODO: needs a tests
+    end
+
+    module_function :publish
+
+    def subscribe(pattern, method)
+      Celluloid::Notifications.notifier.subscribe(Actor.current, pattern, method)
+    end
+
+    def unsubscribe(*args)
+      Celluloid::Notifications.notifier.unsubscribe(*args)
+    end
+
+    class Fanout
+      include Celluloid
+      trap_exit :prune
+
+      def initialize
+        @subscribers = []
+        @listeners_for = {}
+      end
+
+      def subscribe(actor, pattern, method)
+        subscriber = Subscriber.new(actor, pattern, method).tap do |s|
+          @subscribers << s
+        end
+        link actor
+        @listeners_for.clear
+        subscriber
+      end
+
+      def unsubscribe(subscriber)
+        @subscribers.reject! { |s| s.matches?(subscriber) }
+        @listeners_for.clear
+      end
+
+      def publish(pattern, *args)
+        listeners_for(pattern).each { |s| s.publish(pattern, *args) }
+      end
+
+      def listeners_for(pattern)
+        @listeners_for[pattern] ||= @subscribers.select { |s| s.subscribed_to?(pattern) }
+      end
+
+      def listening?(pattern)
+        listeners_for(pattern).any?
+      end
+
+      def prune(actor, _reason = nil)
+        @subscribers.reject! { |s| s.actor == actor }
+        @listeners_for.clear
+      end
+    end
+
+    class Subscriber
+      attr_accessor :actor, :pattern, :method
+
+      def initialize(actor, pattern, method)
+        @actor = actor
+        @pattern = pattern
+        @method = method
+      end
+
+      def publish(pattern, *args)
+        actor.async method, pattern, *args
+      rescue DeadActorError
+        # TODO: needs a tests
+        # Bad shutdown logic. Oh well....
+      end
+
+      def subscribed_to?(pattern)
+        !pattern || @pattern === pattern.to_s || @pattern === pattern
+      end
+
+      def matches?(subscriber_or_pattern)
+        self === subscriber_or_pattern ||
+          @pattern && @pattern === subscriber_or_pattern
+      end
+    end
+  end
+
+  def self.publish(*args)
+    Notifications.publish(*args)
+  end
+end

data/lib/celluloid/pool.rb

@@ -0,0 +1,6 @@
+require "celluloid" unless defined? Celluloid
+
+require "celluloid/supervision"
+
+require "celluloid/supervision/container/pool"
+require "celluloid/supervision/container/behavior/pool"

data/lib/celluloid/probe.rb

@@ -0,0 +1,81 @@
+require "celluloid"
+
+# !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+# rubocop:disable Style/GlobalVars
+$CELLULOID_MONITORING = true
+# rubocop:enable Style/GlobalVars
+
+module Celluloid
+  class Probe
+    include Celluloid
+    include Celluloid::Notifications
+
+    NOTIFICATIONS_TOPIC_BASE = "celluloid.events.%s".freeze
+    EVENTS_BUFFER = Queue.new
+
+    class << self
+      def run
+        # spawn the actor if not found
+        supervise_as(:probe_actor) unless Actor[:probe_actor] && Actor[:probe_actor].alive?
+      end
+
+      def run_without_supervision
+        Actor[:probe_actor] = Celluloid::Probe.new
+      end
+
+      def actor_created(actor)
+        trigger_event(:actor_created, actor)
+      end
+
+      def actor_named(actor)
+        trigger_event(:actor_named, actor)
+      end
+
+      def actor_died(actor)
+        trigger_event(:actor_died, actor)
+      end
+
+      def actors_linked(a, b)
+        a = find_actor(a)
+        b = find_actor(b)
+        trigger_event(:actors_linked, a, b)
+      end
+
+      private
+
+      def trigger_event(name, *args)
+        # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+        # rubocop:disable Style/GlobalVars
+        return unless $CELLULOID_MONITORING
+        # rubocop:enable Style/GlobalVars
+
+        EVENTS_BUFFER << [name, args]
+        probe_actor = Actor[:probe_actor]
+        probe_actor.async.process_queue if probe_actor
+      end
+
+      def find_actor(obj)
+        if obj.__send__(:class) == Actor
+          obj
+        elsif owner = obj.instance_variable_get(OWNER_IVAR)
+          owner
+        end
+      end
+    end
+
+    def initialize
+      async.process_queue
+    end
+
+    def process_queue
+      until EVENTS_BUFFER.empty?
+        event = EVENTS_BUFFER.pop
+        dispatch_event(*event)
+      end
+    end
+
+    def dispatch_event(cmd, args)
+      publish(NOTIFICATIONS_TOPIC_BASE % cmd, args)
+    end
+  end
+end

data/lib/celluloid/proxy/abstract.rb

@@ -1,12 +1,14 @@
-# Base class of Celluloid proxies
-class Celluloid::Proxy::Abstract < BasicObject
-  # Used for reflecting on proxy objects themselves
-  def __class__
-    ::Celluloid::Proxy::Abstract
+module Celluloid::Proxy
+  # Looks up the actual class of instance, even if instance is a proxy.
+  def self.class_of(instance)
+    (class << instance; self; end).superclass
   end
+end
 
+# Base class of Celluloid proxies
+class Celluloid::Proxy::Abstract < BasicObject
   # Needed for storing proxies in data structures
-  needed = [:object_id, :__id__, :hash, :private_methods] - instance_methods
+  needed = %i[object_id __id__ hash eql? private_methods] - instance_methods
   if needed.any?
     include ::Kernel.dup.module_eval {
       undef_method(*(instance_methods - needed))
@@ -14,6 +16,35 @@ class Celluloid::Proxy::Abstract < BasicObject
     }
     # rubinius bug?  These methods disappear when we include hacked kernel
     define_method :==, ::BasicObject.instance_method(:==) unless instance_methods.include?(:==)
-    alias_method(:equal?, :==) unless instance_methods.include?(:equal?)
+    alias equal? == unless instance_methods.include?(:equal?)
+  end
+
+  def __class__
+    @class ||= ::Celluloid::Proxy.class_of(self)
+  end
+end
+
+class Celluloid::Proxy::AbstractCall < Celluloid::Proxy::Abstract
+  attr_reader :mailbox
+
+  def initialize(mailbox, klass)
+    @mailbox = mailbox
+    @klass = klass
+  end
+
+  def eql?(other)
+    __class__.eql?(::Celluloid::Proxy.class_of(other)) && @mailbox.eql?(other.mailbox)
+  end
+
+  def hash
+    @mailbox.hash
+  end
+
+  def __klass__
+    @klass
+  end
+
+  def inspect
+    "#<#{__class__}(#{@klass})>"
   end
 end

data/lib/celluloid/proxy/actor.rb

@@ -2,11 +2,6 @@
 class Celluloid::Proxy::Actor < Celluloid::Proxy::Abstract
   attr_reader :thread, :mailbox
 
-  # Used for reflecting on proxy objects themselves
-  def __class__
-    ::Celluloid::Proxy::Actor
-  end
-
   def initialize(mailbox, thread)
     @mailbox = mailbox
     @thread = thread

data/lib/celluloid/proxy/async.rb

@@ -1,21 +1,5 @@
 # A proxy which sends asynchronous calls to an actor
-class Celluloid::Proxy::Async < Celluloid::Proxy::Abstract
-  attr_reader :mailbox
-
-  # Used for reflecting on proxy objects themselves
-  def __class__
-    ::Celluloid::Proxy::Async
-  end
-
-  def initialize(mailbox, klass)
-    @mailbox = mailbox
-    @klass = klass
-  end
-
-  def inspect
-    "#<Celluloid::Proxy::Async(#{@klass})>"
-  end
-
+class Celluloid::Proxy::Async < Celluloid::Proxy::AbstractCall
   def method_missing(meth, *args, &block)
     if @mailbox == ::Thread.current[:celluloid_mailbox]
       args.unshift meth
@@ -23,7 +7,7 @@ class Celluloid::Proxy::Async < Celluloid::Proxy::Abstract
     end
     if block_given?
       # FIXME: nicer exception
-      fail "Cannot use blocks with async yet"
+      raise "Cannot use blocks with async yet"
     end
     @mailbox << ::Celluloid::Call::Async.new(meth, args, block)
     self

data/lib/celluloid/proxy/block.rb

@@ -1,6 +1,7 @@
 class Celluloid::Proxy::Block
   attr_writer :execution
   attr_reader :call, :block
+
   def initialize(mailbox, call, block)
     @mailbox = mailbox
     @call = call
@@ -17,7 +18,7 @@ class Celluloid::Proxy::Block
           task.suspend(:invokeblock)
         else
           # FIXME: better exception
-          fail "No task to suspend"
+          raise "No task to suspend"
         end
       end
     else

data/lib/celluloid/proxy/cell.rb

@@ -1,15 +1,9 @@
 # A proxy object returned from Celluloid::Actor.new/new_link which converts
 # the normal Ruby method protocol into an inter-actor message protocol
 class Celluloid::Proxy::Cell < Celluloid::Proxy::Sync
-  # Used for reflecting on proxy objects themselves
-  def __class__
-    ::Celluloid::Proxy::Cell
-  end
-
   def initialize(mailbox, actor_proxy, klass)
     super(mailbox, klass)
     @actor_proxy  = actor_proxy
-    @sync_proxy   = ::Celluloid::Proxy::Sync.new(mailbox, klass)
     @async_proxy  = ::Celluloid::Proxy::Async.new(mailbox, klass)
     @future_proxy = ::Celluloid::Proxy::Future.new(mailbox, klass)
   end
@@ -28,7 +22,7 @@ class Celluloid::Proxy::Cell < Celluloid::Proxy::Sync
     ::Celluloid::Internals::Method.new(self, name)
   end
 
-  alias_method :sync, :method_missing
+  alias sync method_missing
 
   # Obtain an async proxy or explicitly invoke a named async method
   def async(method_name = nil, *args, &block)

data/lib/celluloid/proxy/future.rb

@@ -1,29 +1,11 @@
 # A proxy which creates future calls to an actor
-class Celluloid::Proxy::Future < Celluloid::Proxy::Abstract
-  attr_reader :mailbox
-
-  # Used for reflecting on proxy objects themselves
-  def __class__
-    ::Celluloid::Proxy::Future
-  end
-
-  def initialize(mailbox, klass)
-    @mailbox = mailbox
-    @klass = klass
-  end
-
-  def inspect
-    "#<Celluloid::Proxy::Future(#{@klass})>"
-  end
-
+class Celluloid::Proxy::Future < Celluloid::Proxy::AbstractCall
   def method_missing(meth, *args, &block)
-    unless @mailbox.alive?
-      fail ::Celluloid::DeadActorError, "attempted to call a dead actor"
-    end
+    raise ::Celluloid::DeadActorError, "attempted to call a dead actor: #{meth}" unless @mailbox.alive?
 
     if block_given?
       # FIXME: nicer exception
-      fail "Cannot use blocks with futures yet"
+      raise "Cannot use blocks with futures yet"
     end
 
     future = ::Celluloid::Future.new

data/lib/celluloid/proxy/sync.rb

@@ -1,29 +1,11 @@
 # A proxy which sends synchronous calls to an actor
-class Celluloid::Proxy::Sync < Celluloid::Proxy::Abstract
-  attr_reader :mailbox
-
-  # Used for reflecting on proxy objects themselves
-  def __class__
-    ::Celluloid::Proxy::Sync
-  end
-
-  def initialize(mailbox, klass)
-    @mailbox = mailbox
-    @klass = klass
-  end
-
-  def inspect
-    "#<Celluloid::Proxy::Sync(#{@klass})>"
-  end
-
+class Celluloid::Proxy::Sync < Celluloid::Proxy::AbstractCall
   def respond_to?(meth, include_private = false)
     __class__.instance_methods.include?(meth) || method_missing(:respond_to?, meth, include_private)
   end
 
   def method_missing(meth, *args, &block)
-    unless @mailbox.alive?
-      fail ::Celluloid::DeadActorError, "attempted to call a dead actor"
-    end
+    raise ::Celluloid::DeadActorError, "attempted to call a dead actor: #{meth}" unless @mailbox.alive?
 
     if @mailbox == ::Thread.current[:celluloid_mailbox]
       args.unshift meth

data/lib/celluloid/rspec.rb

@@ -1,41 +1,26 @@
-require "dotenv"
-require "nenv"
-
 require "celluloid/test"
 
-# To help produce better bug reports in Rubinius
-if RUBY_ENGINE == "rbx"
-  # $DEBUG = true # would be nice if this didn't fail ... :(
-  require "rspec/matchers"
-  require "rspec/matchers/built_in/be"
-end
-
-require "rspec/retry"
-
 module Specs
-
-  CHECK_LOOSE_THREADS = !Nenv.ci? unless defined? CHECK_LOOSE_THREADS
+  CHECK_LOOSE_THREADS = false
   ALLOW_RETRIES = 3 unless defined? ALLOW_RETRIES
-  ALLOW_SLOW_MAILBOXES = false unless defined? ALLOW_SLOW_MAILBOXES
 
-  INCLUDE_SUPPORT = [
-    "env",
-    "logging",
-    "sleep_and_wait",
-    "reset_class_variables",
-    "crash_checking",
-    "loose_threads",
-    "stubbing",
-    "coverage",
-    "includer",
-    "configure_rspec"
-  ]
+  INCLUDE_SUPPORT = %w[
+    logging
+    sleep_and_wait
+    reset_class_variables
+    crash_checking
+    loose_threads
+    stubbing
+    coverage
+    includer
+    configure_rspec
+  ].freeze
 
   INCLUDE_PATHS = [
     "./spec/support/*.rb",
     "./spec/support/examples/*.rb",
     "./spec/shared/*.rb"
-  ]
+  ].freeze
 
   MAX_EXECUTION = 13
   MAX_ATTEMPTS = 20
@@ -49,24 +34,27 @@ module Specs
     "rspec-retry",
     "rubysl-thread",
     "rubysl-timeout"
-  ]
+  ].freeze
 end
 
+# !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+# rubocop:disable Style/GlobalVars
 $CELLULOID_DEBUG = true
 
 # Require but disable, so it has to be explicitly enabled in tests
 require "celluloid/probe"
 $CELLULOID_MONITORING = false
+# rubocop:enable Style/GlobalVars
 
 Celluloid.shutdown_timeout = 1
 
 # Load shared examples and test support code for other gems to use.
 
-Specs::INCLUDE_SUPPORT.each { |f|
-  require "#{File.expand_path('../../../spec/support', __FILE__)}/#{f}.rb"
-}
+Specs::INCLUDE_SUPPORT.each do |f|
+  require "#{File.expand_path('../../spec/support', __dir__)}/#{f}.rb"
+end
 
 Specs.reset_probe(nil)
 
-Dir["#{File.expand_path('../../../spec/support/examples', __FILE__)}/*.rb"].map { |f| require f }
-Dir["#{File.expand_path('../../../spec/shared', __FILE__)}/*.rb"].map { |f| require f }
+Dir["#{File.expand_path('../../spec/support/examples', __dir__)}/*.rb"].map { |f| require f }
+Dir["#{File.expand_path('../../spec/shared', __dir__)}/*.rb"].map { |f| require f }