celluloid 0.17.4 → 0.18.0

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

@@ -8,7 +8,7 @@ end
 # Base class of Celluloid proxies
 class Celluloid::Proxy::Abstract < BasicObject
   # Needed for storing proxies in data structures
-  needed = [:object_id, :__id__, :hash, :eql?, :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))
@@ -16,9 +16,9 @@ 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
@@ -26,25 +26,25 @@ end
 
 class Celluloid::Proxy::AbstractCall < Celluloid::Proxy::Abstract
   attr_reader :mailbox
-  
+
   def initialize(mailbox, klass)
     @mailbox = mailbox
     @klass = klass
   end
-  
+
   def eql?(other)
-    self.__class__.eql?(::Celluloid::Proxy.class_of(other)) and @mailbox.eql?(other.mailbox)
+    __class__.eql?(::Celluloid::Proxy.class_of(other)) && @mailbox.eql?(other.mailbox)
   end
 
   def hash
     @mailbox.hash
   end
-  
+
   def __klass__
     @klass
   end
-  
+
   def inspect
-    "#<#{self.__class__}(#{@klass})>"
+    "#<#{__class__}(#{@klass})>"
   end
 end

data/lib/celluloid/proxy/async.rb

@@ -7,7 +7,7 @@ class Celluloid::Proxy::Async < Celluloid::Proxy::AbstractCall
     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,7 +1,7 @@
 class Celluloid::Proxy::Block
   attr_writer :execution
   attr_reader :call, :block
-  
+
   def initialize(mailbox, call, block)
     @mailbox = mailbox
     @call = call
@@ -18,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

@@ -22,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,13 +1,11 @@
 # A proxy which creates future calls to an actor
 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: #{meth}"
-    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

@@ -5,9 +5,7 @@ class Celluloid::Proxy::Sync < Celluloid::Proxy::AbstractCall
   end
 
   def method_missing(meth, *args, &block)
-    unless @mailbox.alive?
-      fail ::Celluloid::DeadActorError, "attempted to call a dead actor: #{meth}"
-    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,40 +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
 
-  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
@@ -48,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 }

data/lib/celluloid/supervision/configuration/injections.rb

@@ -0,0 +1,8 @@
+module Celluloid
+  module Supervision
+    class Configuration
+      class Injection
+      end
+    end
+  end
+end

data/lib/celluloid/supervision/configuration/instance.rb

@@ -0,0 +1,113 @@
+module Celluloid
+  module Supervision
+    class Configuration
+      class Instance
+        attr_accessor :configuration
+
+        def initialize(configuration = {})
+          @state = :initializing # :ready
+          resync_accessors
+          @configuration = configuration
+          define(configuration) if configuration.any?
+        end
+
+        def export
+          @configuration.reject { |k, _v| REMOVE_AT_EXPORT.include? k }
+        end
+
+        def ready?(fail = false)
+          unless @state == :ready
+            @state = :ready if Configuration.valid? @configuration, fail
+          end
+          @state == :ready
+        end
+
+        def define(instance, fail = false)
+          raise Configuration::Error::AlreadyDefined if ready? fail
+          invoke_injection(:before_configuration)
+          @configuration = Configuration.options(instance)
+          ready?
+        end
+
+        def injection!(key, proc)
+          @configuration[:injections] ||= {}
+          @configuration[:injections][key] = proc
+        end
+
+        def injections!(_procs)
+          @configuration[:injections] = proces
+        end
+
+        def resync_accessors
+          # methods for setting and getting the usual defaults
+          Configuration.parameters(:mandatory, :optional, :plugins, :meta).each do |key|
+            self.class.instance_eval do
+              remove_method :"#{key}!" rescue nil # avoid warnings in tests
+              define_method(:"#{key}!") { |value| @configuration[key] = value }
+            end
+            self.class.instance_eval do
+              remove_method :"#{key}=" rescue nil # avoid warnings in tests
+              define_method(:"#{key}=") { |value| @configuration[key] = value }
+            end
+            self.class.instance_eval do
+              remove_method :"#{key}?" rescue nil # avoid warnings in tests
+              define_method(:"#{key}?") { !@configuration[key].nil? }
+            end
+            self.class.instance_eval do
+              remove_method :"#{key}" rescue nil # avoid warnings in tests
+              define_method(:"#{key}") { @configuration[key] }
+            end
+          end
+
+          Configuration.aliases.each do |_alias, _original|
+            ["!", :"=", :"?", :""]. each do |m|
+              self.class.instance_eval do
+                remove_method :"#{_alias}#{m}" rescue nil # avoid warnings in tests
+                alias_method :"#{_alias}#{m}", :"#{_original}#{m}"
+              end
+            end
+          end
+          true
+        end
+
+        def merge!(values)
+          @configuration = @configuration.merge(values)
+        end
+
+        def merge(values)
+          if values.is_a? Configuration
+            @configuration.merge(values.configuration)
+          elsif values.is_a? Hash
+            @configuration.merge(values)
+          else
+            raise Error::Invalid
+          end
+        end
+
+        def key?(k)
+          @configuration.key?(k)
+        end
+
+        def set(key, value)
+          @configuration[key] = value
+        end
+        alias []= set
+
+        def get(key)
+          @configuration[key]
+        end
+        alias [] get
+
+        def delete(k)
+          @configuration.delete(k)
+        end
+
+        private
+
+        def invoke_injection(_point)
+          # de puts "injection? #{point}"
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/supervision/configuration.rb

@@ -0,0 +1,169 @@
+module Celluloid
+  module Supervision
+    class Configuration
+      class << self
+        def deploy(options = {})
+          define(options).deploy
+        end
+
+        def define(options = {})
+          new(options)
+        end
+      end
+
+      extend Forwardable
+
+      def_delegators :current_instance,
+                     :delete,
+                     :key?,
+                     :set,
+                     :get,
+                     :[],
+                     :[]=,
+                     :injection!,
+                     :injections!
+
+      attr_accessor :instances
+
+      def initialize(options = {})
+        @instances = [Instance.new]
+        @branch = :services
+        @i = 0 # incrementer of instances in this branch
+        resync_accessors
+        @configuration = options
+
+        if options.is_a? Hash
+          options[:configuration] ||= Container::Behavior.configure(options)
+          @configuration = instance_eval(&options[:configuration])
+          @supervisor ||= @configuration.fetch(:supervisor, :"Celluloid.services")
+        end
+        @supervisor ||= :"Celluloid.services"
+
+        define(@configuration) if (@configuration.is_a?(Hash) || @configuration.is_a?(Array)) && @configuration.any?
+      end
+
+      def provider
+        @provider ||= if @supervisor.is_a? Hash
+                        @supervisor[:type].run!(@supervisor)
+                      elsif @supervisor.is_a? Symbol
+                        @supervisor = Object.module_eval(@supervisor.to_s)
+                        provider
+                      elsif @supervisor.is_a? Class
+                        @supervisor.run!
+                      elsif @supervisor.respond_to? :supervise
+                        @supervisor
+                      else
+                        raise Error::InvalidSupervisor
+                      end
+      end
+
+      def deploy(options = {})
+        define(options) if options.any?
+        @instances.each do |instance|
+          provider.add instance.merge(branch: @branch)
+        end
+        provider
+      end
+
+      def count
+        @instances.count
+      end
+
+      def each(&block)
+        @instances.each(&block)
+      end
+
+      def resync_accessors
+        # methods for setting and getting the usual defaults
+        Configuration.parameters(:mandatory, :optional, :plugins, :meta).each do |key|
+          [:"#{key}!", :"#{key}="].each do |m|
+            self.class.instance_eval do
+              remove_method :"#{m}" rescue nil # avoid warnings in tests
+              define_method(m) { |p| current_instance.send(m, p) }
+            end
+          end
+          [:"#{key}?", :"#{key}"].each do |m|
+            self.class.instance_eval do
+              remove_method :"#{m}" rescue nil # avoid warnings in tests
+              define_method(m) { current_instance.send(m) }
+            end
+          end
+        end
+
+        Configuration.aliases.each do |_alias, _original|
+          ["!", :"=", :"?", :""]. each do |m|
+            self.class.instance_eval do
+              remove_method :"#{_alias}#{m}" rescue nil # avoid warnings in tests
+              alias_method :"#{_alias}#{m}", :"#{_original}#{m}"
+            end
+          end
+        end
+      end
+
+      def merge!(values)
+        if values.is_a?(Configuration) || values.is_a?(Hash)
+          current_instance.merge!(values)
+        else
+          raise Error::Invalid
+        end
+      end
+
+      def merge(values)
+        if values.is_a?(Configuration) || values.is_a?(Hash)
+          current_instance.merge(values)
+        else
+          raise Error::Invalid
+        end
+      end
+
+      def export
+        return current_instance.to_hash if @i == 0
+        @instances.map(&:export)
+      end
+
+      def include?(name)
+        @instances.map(&:name).include? name
+      end
+
+      def define(configuration, fail = false)
+        if configuration.is_a? Array
+          configuration.each { |c| define(c, fail) }
+        else
+          unless include? configuration[:as]
+            begin
+              current_instance.define(configuration, fail)
+            rescue Error::AlreadyDefined
+              increment
+              retry
+            end
+          end
+        end
+        self
+      end
+
+      def increment
+        @i += 1
+      end
+      alias another increment
+
+      def add(options)
+        define(options)
+        provider.supervise options if Configuration.valid? options
+      end
+
+      def shutdown
+        @provider.shutdown
+      end
+
+      private
+
+      def current_instance
+        @instances[@i] ||= Instance.new
+      end
+
+      def invoke_injection(_point)
+        # de puts "injection? #{point}"
+      end
+    end
+  end
+end

data/lib/celluloid/supervision/constants.rb

@@ -0,0 +1,123 @@
+module Celluloid
+  module Supervision
+    # TODO: Do not hard-code. Allow configurable values.
+    INSTANCE_RETRY_WAIT = 3
+    INSTANCE_RETRY_LIMIT = 5
+
+    module Error
+      class NoPublicService < Celluloid::Error; end
+    end
+
+    class Configuration
+      module Error
+        class AlreadyDefined < Celluloid::Error; end
+        class InvalidSupervisor < Celluloid::Error; end
+        class InvalidValues < Celluloid::Error; end
+        class Incomplete < Celluloid::Error; end
+        class Invalid < Celluloid::Error; end
+      end
+
+      # Using class variable so that parameters can be added by plugins.
+
+      @@parameters = {
+
+        mandatory: [:type],
+
+        optional: %i[
+          as
+          args
+          block
+        ],
+
+        # TODO: Move these into Behaviors.
+        plugins: [
+          # de :size,        # Supervision::Pool
+          # de :routers,     # Supervision::Coordinator
+          # de :supervises   # Supervision::Tree
+        ],
+
+        meta: %i[
+          registry
+          branch
+          method
+        ]
+      }
+
+      @@arity = {
+        type: :args
+      }
+
+      @@aliases = {
+        name: :as,
+        kind: :type,
+        # de :pool => :size,   # TODO: Move into Behaviors.
+        # de :supervise => :supervises
+      }
+
+      @@defaults = {}
+
+      class << self
+        def save_defaults
+          @@defaults = {
+            parameters: @@parameters.each_with_object({}) { |(k, v), p| p[k] = v.dup; },
+            aliases: @@aliases.dup,
+            arity: @@arity.dup
+          }
+        end
+
+        def resync_parameters
+          @@parameters = @@defaults[:parameters].each_with_object({}) { |(k, v), p| p[k] = v.dup; }
+          @@aliases = @@defaults[:aliases].dup
+          @@arity = @@defaults[:arity].dup
+        end
+
+        def parameters(*args)
+          args.inject([]) { |parameters, p| parameters += @@parameters[p]; parameters }
+        end
+
+        def parameter!(key, value)
+          @@parameters[key] << value unless @@parameters[key].include? value
+        end
+
+        def arity
+          @@arity
+        end
+
+        def arity!(key, value)
+          @@arity[key] = value
+        end
+
+        def aliases
+          @@aliases
+        end
+
+        def alias!(aliased, original)
+          @@aliases[aliased] = original
+        end
+      end
+
+      save_defaults
+      resync_parameters
+
+      # This was originally added for `#pool` and `PoolManager
+      # `:before_initialize` was added to allow detecting `:size => N`
+      # and turning that into a pool. Other uses could be for `coordinator`
+      # appointing a `router` by detecting `:routers => N`, and many other uses.
+
+      ################ These are applied inside Supervision::Member ################
+
+      REMOVE_AT_EXPORT = %i[
+        configuration
+        behavior
+      ].freeze
+
+      INJECTIONS = %i[
+        configuration
+        before_initialization
+        after_initialization
+        before_start
+        before_restart
+      ].freeze
+    end
+  end
+end