celluloid 0.17.2 → 0.18.0

data/examples/futures.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$LOAD_PATH.push File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.push File.expand_path("../lib", __dir__)
 require "celluloid/autostart"
 require "digest/sha2"
 

data/examples/ring.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$LOAD_PATH.push File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.push File.expand_path("../lib", __dir__)
 require "celluloid/autostart"
 
 class Ring
@@ -28,7 +28,7 @@ class Ring
 
   # Go around the ring the given number of times
   def run(n)
-    fail ArgumentError, "I can't go around a negative number of times" if n < 0
+    raise ArgumentError, "I can't go around a negative number of times" if n < 0
 
     async.around n
     wait :done
@@ -48,14 +48,15 @@ if $PROGRAM_NAME == __FILE__
   require "benchmark"
   SIZE  = 512
   TIMES = 10
+  ring = nil
 
   puts "*** Creating a #{SIZE} node ring..."
   puts Benchmark.measure {
-    $ring = Ring.new(SIZE)
+    ring = Ring.new(SIZE)
   }
 
   puts "*** Sending a message around #{TIMES} times"
   puts Benchmark.measure {
-    $ring.run(TIMES)
+    ring.run(TIMES)
   }
 end

data/examples/simple_pmap.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$LOAD_PATH.push File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.push File.expand_path("../lib", __dir__)
 require "celluloid/autostart"
 
 module Enumerable

data/examples/stack.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$LOAD_PATH.push File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.push File.expand_path("../lib", __dir__)
 require "celluloid/autostart"
 
 # This example builds on basic_usage.rb to show two things about #async: the
@@ -17,7 +17,7 @@ class Stack
   def push(x)
     @ary.push x
   end
-  alias_method :<<, :push
+  alias << push
 
   def pop
     @ary.pop

data/examples/supervisors_and_registry.rb

@@ -0,0 +1,82 @@
+require "celluloid/autostart"
+
+class MyActor
+  include Celluloid
+  attr_reader :state
+
+  def initialize
+    @state = :clean
+  end
+
+  def broken_method
+    @state = :dirty
+    oh_crap_im_totally_broken
+  end
+end
+
+#
+# Using the Supervisor API directly
+#
+
+puts "*** Demonstrating using the Supervisor API directly"
+
+# Calling supervise directly returns the supervisor
+supervisor = MyActor.supervise
+
+# We can get to the current version of an actor by calling
+# Celluloid::Supervisor#actors. This prints ':clean'
+puts "We should be in a clean state now: #{supervisor.actors.first.state}"
+puts "Brace yourself for a crash message..."
+
+# If we call a method that crashes an actor, it will print out a debug message,
+# then restart an actor in a clean state
+begin
+  supervisor.actors.first.broken_method
+rescue NameError
+  puts "Uhoh, we crashed the actor..."
+end
+
+puts "The supervisor should automatically restart the actor"
+
+# By now we'll be back in a :clean state!
+begin
+  puts "We should now be in a clean state again: #{supervisor.actors.first.state}"
+rescue Celluloid::DeadActorError
+  # Perhaps we got ahold of the actor before the supervisor restarted it
+  retry
+end
+
+#
+# Using the Actor Registry
+# This is the preferred approach and will make using DCell easier
+#
+
+puts "*** Demonstrating using the actor registry"
+
+# We can give our actor a name and thus avoid interacting with the supervisor
+MyActor.supervise as: :my_actor
+
+# Same as above, just getting the actor from a different place
+puts "We should be in a clean state now: #{Celluloid::Actor[:my_actor].state}"
+puts "Brace yourself for a crash message..."
+
+# If we call a method that crashes an actor, it will print out a debug message,
+# then restart an actor in a clean state
+begin
+  Celluloid::Actor[:my_actor].broken_method
+rescue NameError
+  puts "Uhoh, we crashed the actor..."
+end
+
+puts "The supervisor should automatically restart the actor"
+
+# By now we'll be back in a :clean state!
+begin
+  puts "We should now be in a clean state again: #{Celluloid::Actor[:my_actor].state}"
+rescue Celluloid::DeadActorError
+  # Perhaps we got ahold of the actor before the supervisor restarted it
+  # Don't want to catch Celluloid::DeadActorError all over the place? If this
+  # code were in a supervised Celluloid::Actor itself, the supervisor would
+  # catch Celluloid::DeadActorError and automatically restart this actor
+  retry
+end

data/examples/timers.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-$LOAD_PATH.push File.expand_path("../../lib", __FILE__)
-require "celluloid/current"
+$LOAD_PATH.push File.expand_path("../lib", __dir__)
+require "celluloid"
 
 class TimerExample
   include Celluloid

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,13 +461,15 @@ 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)
+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
 Celluloid.log_actor_crashes = true
 
@@ -480,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.
@@ -494,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
 
@@ -527,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