celluloid 0.17.4 → 0.18.0

data/lib/celluloid/supervision/supervise.rb

@@ -0,0 +1,34 @@
+# collect together all instances of the `supervise` method
+module Celluloid
+  class << self
+    def supervise(config = {}, &block)
+      supervisor = Supervision.router(config)
+      supervisor.supervise(config, &block)
+    end
+  end
+  module ClassMethods
+    def supervise(config = {}, &block)
+      Celluloid.supervise(config.merge(type: self), &block)
+    end
+  end
+  module Supervision
+    class << self
+      def router(_config = {})
+        # TODO: Actually route.
+        Celluloid.services # for now, hardcode .services
+      end
+    end
+    class Container
+      class << self
+        def supervise(config, &block)
+          blocks << lambda do |container|
+            container.add(config, &block)
+          end
+        end
+      end
+      def supervise(config, &block)
+        add(Configuration.options(config, block: block))
+      end
+    end
+  end
+end

data/lib/celluloid/supervision/validation.rb

@@ -0,0 +1,40 @@
+module Celluloid
+  module Supervision
+    class Configuration
+      class << self
+        def valid?(configuration, fails = false)
+          parameters(:mandatory).each do |k|
+            unless configuration.key? k
+              if fails
+                raise Error::Incomplete, "Missing `:#{k}` in supervision configuration."
+              else
+                return false
+              end
+            end
+          end
+          arity.each do |klass, args|
+            next if configuration[args].is_a? Proc
+            __a = configuration[args] && configuration[args].count || 0
+            __arity = configuration[klass].allocate.method(:initialize).arity
+            unless (__arity < 0 && __a >= __arity.abs - 1) || __a == __arity.abs
+              if fails
+                raise ArgumentError, "#{__a} vs. #{__arity}"
+              else
+                return false
+              end
+            end
+          end
+          true
+        end
+
+        def options(config = {}, options = {})
+          configuration = config.merge(options)
+          return configuration if configuration.is_a? Configuration
+          configuration[:configuration] = Container::Behavior.configure(configuration)
+          valid?(configuration, true)
+          configuration
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/supervision/version.rb

@@ -0,0 +1,5 @@
+module Celluloid
+  module Supervision
+    VERSION = "0.20.6".freeze
+  end
+end

data/lib/celluloid/supervision.rb

@@ -0,0 +1,17 @@
+require "celluloid" unless defined? Celluloid
+
+require "celluloid/supervision/constants"
+require "celluloid/supervision/supervise"
+
+require "celluloid/supervision/container"
+require "celluloid/supervision/container/instance"
+require "celluloid/supervision/container/behavior"
+require "celluloid/supervision/container/injections"
+
+require "celluloid/supervision/container/behavior/tree"
+
+require "celluloid/supervision/validation"
+require "celluloid/supervision/configuration"
+require "celluloid/supervision/configuration/instance"
+
+require "celluloid/supervision/service"

data/lib/celluloid/system_events.rb

@@ -5,7 +5,10 @@ module Celluloid
       if handler = SystemEvent.handle(event.class)
         send(handler, event)
       else
+        # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+        # rubocop:disable Style/GlobalVars
         Internals::Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
+        # rubocop:enable Style/GlobalVars
       end
     end
   end
@@ -18,7 +21,7 @@ module Celluloid
       end
 
       def handler(&block)
-        fail ArgumentError, "SystemEvent handlers must be defined with a block." unless block
+        raise ArgumentError, "SystemEvent handlers must be defined with a block." unless block
         method = begin
           handler = name
                     .split("::").last
@@ -38,7 +41,7 @@ module Celluloid
       def initialize(actor, type)
         @actor = actor
         @type = type.to_sym
-        fail ArgumentError, "type must be link or unlink" unless [:link, :unlink].include?(@type)
+        raise ArgumentError, "type must be link or unlink" unless %i[link unlink].include?(@type)
       end
     end
   end
@@ -87,7 +90,11 @@ module Celluloid
 
     handler do |event|
       @name = event.name
+
+      # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+      # rubocop:disable Style/GlobalVars
       Celluloid::Probe.actor_named(self) if $CELLULOID_MONITORING
+      # rubocop:enable Style/GlobalVars
     end
 
     def initialize(name)
@@ -97,7 +104,7 @@ module Celluloid
 
   # Request for an actor to terminate
   class TerminationRequest < SystemEvent
-    handler do |event|
+    handler do |_event|
       terminate
     end
   end
@@ -110,9 +117,7 @@ module Celluloid
     end
     attr_reader :task, :value
 
-    handler do |event|
-      event.call
-    end
+    handler(&:call)
 
     def call
       @task.resume(@value)

data/lib/celluloid/task/fibered.rb

@@ -12,8 +12,10 @@ module Celluloid
           Thread.current[:celluloid_queue] = queue
           Thread.current[:celluloid_actor_system] = actor_system
           yield
-          # TODO: Determine why infinite thread leakage happens under jRuby, if `Fiber.yield` is used:
-          Fiber.yield unless RUBY_PLATFORM == "java"
+
+          # Alleged workaround for a MRI memory leak
+          # TODO: validate/confirm this is actually necessary
+          Fiber.yield if RUBY_ENGINE == "ruby"
         end
       end
 
@@ -38,7 +40,9 @@ module Celluloid
       end
 
       def backtrace
+        # rubocop:disable Metrics/LineLength
         ["#{self.class} backtrace unavailable. Please try `Celluloid.task_class = Celluloid::Task::Threaded` if you need backtraces here."]
+        # rubocop:enable Metrics/LineLength
       end
     end
   end

data/lib/celluloid/task/threaded.rb

@@ -18,7 +18,7 @@ module Celluloid
         thread = Internals::ThreadHandle.new(Thread.current[:celluloid_actor_system], :task) do
           begin
             ex = @resume_queue.pop
-            fail ex if ex.is_a?(TaskTerminated)
+            raise ex if ex.is_a?(TaskTerminated)
 
             yield
           rescue ::Exception => ex
@@ -40,12 +40,12 @@ module Celluloid
       end
 
       def deliver(value)
-        fail DeadTaskError, "cannot resume a dead task" unless @thread.alive?
+        raise DeadTaskError, "cannot resume a dead task" unless @thread.alive?
 
         @yield_mutex.synchronize do
           @resume_queue.push(value)
           @yield_cond.wait(@yield_mutex)
-          fail @exception_queue.pop while @exception_queue.size > 0
+          raise @exception_queue.pop until @exception_queue.empty?
         end
       rescue ThreadError
         raise DeadTaskError, "cannot resume a dead task"

data/lib/celluloid/task.rb

@@ -3,7 +3,7 @@ module Celluloid
   class Task
     # Obtain the current task
     def self.current
-      Thread.current[:celluloid_task] || fail(NotTaskError, "not within a task context")
+      Thread.current[:celluloid_task] || raise(NotTaskError, "not within a task context")
     end
 
     # Suspend the running task, deferring to the scheduler
@@ -27,7 +27,7 @@ module Celluloid
       actor     = Thread.current[:celluloid_actor]
       @chain_id = Internals::CallChain.current_id
 
-      fail NotActorError, "can't create tasks outside of actors" unless actor
+      raise NotActorError, "can't create tasks outside of actors" unless actor
       guard "can't create tasks inside of tasks" if Thread.current[:celluloid_task]
 
       create do
@@ -53,26 +53,29 @@ module Celluloid
     end
 
     def create(&_block)
-      fail "Implement #{self.class}#create"
+      raise "Implement #{self.class}#create"
     end
 
     # Suspend the current task, changing the status to the given argument
     def suspend(status)
-      fail "Cannot suspend while in exclusive mode" if exclusive?
-      fail "Cannot suspend a task from outside of itself" unless Task.current == self
+      raise "Cannot suspend while in exclusive mode" if exclusive?
+      raise "Cannot suspend a task from outside of itself" unless Task.current == self
 
       @status = status
 
+      # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+      # rubocop:disable Style/GlobalVars
       if $CELLULOID_DEBUG && @dangerous_suspend
         Internals::Logger.with_backtrace(caller[2...8]) do |logger|
           logger.warn "Dangerously suspending task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
         end
       end
+      # rubocop:enable Style/GlobalVars
 
       value = signal
 
       @status = :running
-      fail value if value.is_a?(Celluloid::Interruption)
+      raise value if value.is_a?(Celluloid::Interruption)
       value
     end
 
@@ -82,7 +85,9 @@ module Celluloid
       if running?
         deliver(value)
       else
+        # rubocop:disable Metrics/LineLength
         Internals::Logger.warn "Attempted to resume a dead task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
+        # rubocop:enable Metrics/LineLength
       end
       nil
     end
@@ -103,20 +108,24 @@ module Celluloid
 
     # Terminate this task
     def terminate
-      fail "Cannot terminate an exclusive task" if exclusive?
+      raise "Cannot terminate an exclusive task" if exclusive?
 
       if running?
+        # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+        # rubocop:disable Style/GlobalVars
         if $CELLULOID_DEBUG
           Internals::Logger.with_backtrace(backtrace) do |logger|
             type = @dangerous_suspend ? :warn : :debug
             logger.send(type, "Terminating task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}")
           end
         end
+        # rubocop:enable Style/GlobalVars
+
         exception = TaskTerminated.new("task was terminated")
         exception.set_backtrace(caller)
         resume exception
       else
-        fail DeadTaskError, "task is already dead"
+        raise DeadTaskError, "task is already dead"
       end
     end
 
@@ -125,8 +134,7 @@ module Celluloid
       @exclusive
     end
 
-    def backtrace
-    end
+    def backtrace; end
 
     # Is the current task still running?
     def running?
@@ -139,11 +147,14 @@ module Celluloid
     end
 
     def guard(message)
+      # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+      # rubocop:disable Style/GlobalVars
       if @guard_warnings
         Internals::Logger.warn message if $CELLULOID_DEBUG
       else
-        fail message if $CELLULOID_DEBUG
+        raise message if $CELLULOID_DEBUG
       end
+      # rubocop:enable Style/GlobalVars
     end
 
     private
@@ -161,7 +172,9 @@ module Celluloid
 
     def thread_metadata
       method = @meta && @meta[:method_name] || "<no method>"
-      klass = Thread.current[:celluloid_actor] && Thread.current[:celluloid_actor].behavior.subject.bare_object.class || "<no actor>"
+      klass = Thread.current[:celluloid_actor] &&
+              Thread.current[:celluloid_actor].behavior.subject.bare_object.class ||
+              "<no actor>"
       format("[Celluloid] %s#%s", klass, method)
     end
   end

data/lib/celluloid/test.rb

@@ -1,3 +1,6 @@
+# !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+# rubocop:disable Style/GlobalVars
 $CELLULOID_TEST = true
-
-require "celluloid"
+# rubocop:enable Style/GlobalVars
+#
+require "celluloid/autostart"

data/lib/celluloid/thread.rb

@@ -1,5 +1,3 @@
-require "celluloid/fiber"
-
 module Celluloid
   class Thread < ::Thread
     def celluloid?

data/lib/celluloid/version.rb

@@ -1,3 +1,3 @@
 module Celluloid
-  VERSION = "0.17.4"
+  VERSION = "0.18.0".freeze
 end

data/lib/celluloid.rb

@@ -1,17 +1,17 @@
+# TODO: eliminate use of global variables
+require "English"
+
 require "logger"
-require "thread"
-require "timeout"
 require "set"
+require "timeout"
 
+# !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+# rubocop:disable Style/GlobalVars
 $CELLULOID_DEBUG = false
-$CELLULOID_MANAGED ||= false
+$CELLULOID_MONITORING = false
+# rubocop:enable Style/GlobalVars
 
 require "celluloid/version"
-require "celluloid/notices"
-
-$CELLULOID_BACKPORTED = false if defined?(CELLULOID_FUTURE) && CELLULOID_FUTURE
-$CELLULOID_BACKPORTED = (ENV["CELLULOID_BACKPORTED"] != "false") unless defined?($CELLULOID_BACKPORTED)
-Celluloid::Notices.backported if $CELLULOID_BACKPORTED
 
 module Celluloid
   # Expose all instance methods as singleton methods
@@ -21,7 +21,7 @@ module Celluloid
   LINKING_TIMEOUT = 5
 
   # Warning message added to Celluloid objects accessed outside their actors
-  BARE_OBJECT_WARNING_MESSAGE = "WARNING: BARE CELLULOID OBJECT "
+  BARE_OBJECT_WARNING_MESSAGE = "WARNING: BARE CELLULOID OBJECT ".freeze
 
   class << self
     attr_writer :actor_system # Default Actor System
@@ -33,9 +33,11 @@ module Celluloid
 
     def actor_system
       if Thread.current.celluloid?
-        Thread.current[:celluloid_actor_system] || fail(Error, "actor system not running")
+        Thread.current[:celluloid_actor_system] || raise(Error, "actor system not running")
       else
-        Thread.current[:celluloid_actor_system] || @actor_system || fail(Error, "Celluloid is not yet started; use Celluloid.boot")
+        Thread.current[:celluloid_actor_system] ||
+          @actor_system ||
+          raise(Error, "Celluloid is not yet started; use Celluloid.boot")
       end
     end
 
@@ -54,15 +56,23 @@ module Celluloid
       klass.property :exclusive_actor, default: false
       klass.property :exclusive_methods, multi: true
       klass.property :execute_block_on_receiver,
-                     default: [:after, :every, :receive],
+                     default: %i[after every receive],
                      multi: true
 
       klass.property :finalizer
       klass.property :exit_handler_name
 
       singleton = class << klass; self; end
-      singleton.send(:remove_method, :trap_exit) rescue nil
-      singleton.send(:remove_method, :exclusive) rescue nil
+      begin
+        singleton.send(:remove_method, :trap_exit)
+      rescue
+        nil
+      end
+      begin
+        singleton.send(:remove_method, :exclusive)
+      rescue
+        nil
+      end
 
       singleton.send(:define_method, :trap_exit) do |*args|
         exit_handler_name(*args)
@@ -96,20 +106,20 @@ module Celluloid
     def cores
       Internals::CPUCounter.cores
     end
-    alias_method :cpus, :cores
-    alias_method :ncpus, :cores
+    alias cpus cores
+    alias ncpus cores
 
     # Perform a stack dump of all actors to the given output object
     def stack_dump(output = STDERR)
       actor_system.stack_dump.print(output)
     end
-    alias_method :dump, :stack_dump
+    alias dump stack_dump
 
     # Perform a stack summary of all actors to the given output object
     def stack_summary(output = STDERR)
       actor_system.stack_summary.print(output)
     end
-    alias_method :summarize, :stack_summary
+    alias summarize stack_summary
 
     def public_registry
       actor_system.public_registry
@@ -148,7 +158,7 @@ module Celluloid
     end
 
     def init
-      @actor_system = Actor::System.new
+      @actor_system ||= Actor::System.new
     end
 
     def start
@@ -157,24 +167,16 @@ module Celluloid
 
     def running?
       actor_system && actor_system.running?
+    rescue Error
+      false
     end
 
+    # de TODO Anticipate outside process finalizer that would by-pass this.
     def register_shutdown
       return if defined?(@shutdown_registered) && @shutdown_registered
-
-      # Terminate all actors at exit
+      # Terminate all actors at exit, unless the exit is abnormal.
       at_exit do
-        sleep 0.126 # hax grace period for unnaturally terminating actors
-        # allows "reason" in exit_handler to resolve before being destroyed
-        if defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby" && RUBY_VERSION >= "1.9"
-          # workaround for MRI bug losing exit status in at_exit block
-          # http://bugs.ruby-lang.org/issues/5218
-          exit_status = $ERROR_INFO.status if $ERROR_INFO.is_a?(SystemExit)
-          Celluloid.shutdown
-          exit exit_status if exit_status
-        else
-          Celluloid.shutdown
-        end
+        Celluloid.shutdown unless $ERROR_INFO
       end
       @shutdown_registered = true
     end
@@ -182,6 +184,7 @@ module Celluloid
     # Shut down all running actors
     def shutdown
       actor_system.shutdown
+      @actor_system = nil
     end
 
     def version
@@ -196,18 +199,18 @@ module Celluloid
       proxy._send_(:initialize, *args, &block)
       proxy
     end
-    alias_method :spawn, :new
+    alias spawn new
 
     # Create a new actor and link to the current one
     def new_link(*args, &block)
-      fail NotActorError, "can't link outside actor context" unless Celluloid.actor?
+      raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
 
       proxy = Cell.new(allocate, behavior_options, actor_options).proxy
       Actor.link(proxy)
       proxy._send_(:initialize, *args, &block)
       proxy
     end
-    alias_method :spawn_link, :new_link
+    alias spawn_link new_link
 
     # Run an actor in the foreground
     def run(*args, &block)
@@ -225,7 +228,7 @@ module Celluloid
         mailbox_class: mailbox_class,
         mailbox_size: mailbox_size,
         task_class: task_class,
-        exclusive: exclusive_actor,
+        exclusive: exclusive_actor
       }
     end
 
@@ -235,7 +238,7 @@ module Celluloid
         exclusive_methods: exclusive_methods,
         exit_handler_name: exit_handler_name,
         finalizer: finalizer,
-        receiver_block_executions: execute_block_on_receiver,
+        receiver_block_executions: execute_block_on_receiver
       }
     end
 
@@ -263,7 +266,7 @@ module Celluloid
     def bare_object
       self
     end
-    alias_method :wrapped_object, :bare_object
+    alias wrapped_object bare_object
 
     # Are we being invoked in a different thread from our owner?
     def leaked?
@@ -279,18 +282,18 @@ module Celluloid
     def registered_name
       Actor.registered_name
     end
-    alias_method :name, :registered_name
+    alias name registered_name
 
     def inspect
       return "..." if Celluloid.detect_recursion
 
       str = "#<"
 
-      if leaked?
-        str << Celluloid::BARE_OBJECT_WARNING_MESSAGE
-      else
-        str << "Celluloid::Proxy::Cell"
-      end
+      str << if leaked?
+               Celluloid::BARE_OBJECT_WARNING_MESSAGE
+             else
+               "Celluloid::Proxy::Cell"
+             end
 
       str << "(#{self.class}:0x#{object_id.to_s(16)})"
       str << " " unless instance_variables.empty?
@@ -318,9 +321,10 @@ module Celluloid
     cause = case cause
             when String then RuntimeError.new(cause)
             when Exception then cause
-            else fail TypeError, "Exception object/String expected, but #{cause.class} received"
-    end
-    fail AbortError.new(cause)
+            else raise TypeError, "Exception object/String expected, but #{cause.class} received"
+            end
+
+    raise AbortError, cause
   end
 
   # Terminate this actor
@@ -457,14 +461,13 @@ module Celluloid
   end
 end
 
-if defined?(JRUBY_VERSION) && JRUBY_VERSION == "1.7.3"
-  fail "Celluloid is broken on JRuby 1.7.3. Please upgrade to 1.7.4+"
-end
-
 require "celluloid/exceptions"
 
 Celluloid.logger = Logger.new(STDERR).tap do |logger|
+  # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+  # rubocop:disable Style/GlobalVars
   logger.level = Logger::INFO unless $CELLULOID_DEBUG
+  # rubocop:enable Style/GlobalVars
 end
 
 Celluloid.shutdown_timeout = 10
@@ -483,8 +486,6 @@ require "celluloid/proxies"
 require "celluloid/mailbox"
 require "celluloid/mailbox/evented"
 
-require "celluloid/essentials"
-
 require "celluloid/group"
 require "celluloid/group/spawner"
 require "celluloid/group/pool"      # TODO: Find way to only load this if being used.
@@ -497,13 +498,27 @@ require "celluloid/actor"
 require "celluloid/cell"
 require "celluloid/future"
 
+require "celluloid/internals/call_chain"
+require "celluloid/internals/cpu_counter"
+require "celluloid/internals/handlers"
+require "celluloid/internals/links"
+require "celluloid/internals/logger"
+require "celluloid/internals/method"
+require "celluloid/internals/properties"
+require "celluloid/internals/receivers"
+require "celluloid/internals/registry"
+require "celluloid/internals/responses"
+require "celluloid/internals/signals"
+require "celluloid/internals/stack"
+require "celluloid/internals/task_set"
+require "celluloid/internals/thread_handle"
+require "celluloid/internals/uuid"
+
+require "celluloid/notifications"
+require "celluloid/supervision"
+
+require "celluloid/logging"
 require "celluloid/actor/system"
-require "celluloid/actor/manager"
-
-require "celluloid/deprecate" unless $CELLULOID_BACKPORTED == false
-
-$CELLULOID_MONITORING = false
-Celluloid::Notices.output
 
 # Configure default systemwide settings
 
@@ -530,8 +545,3 @@ Celluloid.group_class =
       Celluloid::Group.const_get(str)
     end
   end
-
-unless defined?($CELLULOID_TEST) && $CELLULOID_TEST
-  Celluloid.register_shutdown
-  Celluloid.init
-end