celluloid 0.18.0.pre → 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
@@ -157,14 +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.
+    # 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, unless the exit is abnormal.
       at_exit do
-        Celluloid.shutdown unless $!
+        Celluloid.shutdown unless $ERROR_INFO
       end
       @shutdown_registered = true
     end
@@ -172,6 +184,7 @@ module Celluloid
     # Shut down all running actors
     def shutdown
       actor_system.shutdown
+      @actor_system = nil
     end
 
     def version
@@ -186,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)
@@ -215,7 +228,7 @@ module Celluloid
         mailbox_class: mailbox_class,
         mailbox_size: mailbox_size,
         task_class: task_class,
-        exclusive: exclusive_actor,
+        exclusive: exclusive_actor
       }
     end
 
@@ -225,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
 
@@ -253,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?
@@ -269,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?
@@ -308,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
@@ -447,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
@@ -473,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.
@@ -487,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
 

data/lib/celluloid/actor.rb

@@ -16,14 +16,14 @@ module Celluloid
       # Obtain the current actor
       def current
         actor = Thread.current[:celluloid_actor]
-        fail NotActorError, "not in actor scope" unless actor
+        raise NotActorError, "not in actor scope" unless actor
         actor.behavior_proxy
       end
 
       # Obtain the name of the current actor
       def registered_name
         actor = Thread.current[:celluloid_actor]
-        fail NotActorError, "not in actor scope" unless actor
+        raise NotActorError, "not in actor scope" unless actor
         actor.name
       end
 
@@ -52,13 +52,13 @@ module Celluloid
 
       # Watch for exit events from another actor
       def monitor(actor)
-        fail NotActorError, "can't link outside actor context" unless Celluloid.actor?
+        raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
         Thread.current[:celluloid_actor].linking_request(actor, :link)
       end
 
       # Stop waiting for exit events from another actor
       def unmonitor(actor)
-        fail NotActorError, "can't link outside actor context" unless Celluloid.actor?
+        raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
         Thread.current[:celluloid_actor].linking_request(actor, :unlink)
       end
 
@@ -132,8 +132,11 @@ module Celluloid
       end
 
       @proxy = Proxy::Actor.new(@mailbox, @thread)
+
+      # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+      # rubocop:disable Style/GlobalVars
       Celluloid::Probe.actor_created(self) if $CELLULOID_MONITORING
-      Celluloid::Actor::Manager.actor_created(self) if $CELLULOID_MANAGED
+      # rubocop:enable Style/GlobalVars
     end
 
     def behavior_proxy
@@ -187,25 +190,28 @@ module Celluloid
           begin
             message = @mailbox.receive(remaining) do |msg|
               msg.is_a?(LinkingResponse) &&
-              msg.actor.mailbox.address == receiver.mailbox.address &&
-              msg.type == type
+                msg.actor.mailbox.address == receiver.mailbox.address &&
+                msg.type == type
             end
           rescue TaskTimeout
             next # IO reactor did something, no message in queue yet.
           end
 
           if message.instance_of? LinkingResponse
+            # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+            # rubocop:disable Style/GlobalVars
             Celluloid::Probe.actors_linked(self, receiver) if $CELLULOID_MONITORING
+            # rubocop:enable Style/GlobalVars
             system_events.each { |ev| @mailbox << ev }
             return
           elsif message.is_a? SystemEvent
             # Queue up pending system events to be processed after we've successfully linked
             system_events << message
-          else fail "Unexpected message type: #{message.class}. Expected LinkingResponse, NilClass, SystemEvent."
+          else raise "Unexpected message type: #{message.class}. Expected LinkingResponse, NilClass, SystemEvent."
           end
         end
 
-        fail TaskTimeout, "linking timeout of #{LINKING_TIMEOUT} seconds exceeded with receiver: #{receiver}"
+        raise TaskTimeout, "linking timeout of #{LINKING_TIMEOUT} seconds exceeded with receiver: #{receiver}"
       end
     end
 
@@ -218,7 +224,7 @@ module Celluloid
     def wait(name)
       @signals.wait name
     end
-    
+
     # Register a new handler for a given pattern
     def handle(*patterns, &block)
       @handlers.handle(*patterns, &block)
@@ -226,7 +232,7 @@ module Celluloid
 
     # Receive an asynchronous message
     def receive(timeout = nil, &block)
-      while true
+      loop do
         message = @receivers.receive(timeout, &block)
         return message unless message.is_a?(SystemEvent)
 
@@ -280,16 +286,16 @@ module Celluloid
 
     # Handle standard low-priority messages
     def handle_message(message)
-      unless @handlers.handle_message(message)
-        unless @receivers.handle_message(message)
-          Internals::Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
-        end
-      end
+      # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+      # rubocop:disable Metrics/LineLength, Style/GlobalVars
+      Internals::Logger.debug "Discarded message (unhandled): #{message}" if !@handlers.handle_message(message) && !@receivers.handle_message(message) && $CELLULOID_DEBUG
+      # rubocop:enable Metrics/LineLength, Style/GlobalVars
+
       message
     end
 
     def default_exit_handler(event)
-      fail event.reason if event.reason
+      raise event.reason if event.reason
     end
 
     # Handle any exceptions that occur within a running actor
@@ -312,7 +318,11 @@ module Celluloid
 
     # Clean up after this actor
     def cleanup(exit_event)
+      # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+      # rubocop:disable Style/GlobalVars
       Celluloid::Probe.actor_died(self) if $CELLULOID_MONITORING
+      # rubocop:enable Style/GlobalVars
+
       @mailbox.shutdown
       @links.each do |actor|
         actor.mailbox << exit_event if actor.mailbox.alive?