celluloid 0.16.0 → 0.17.0

data/examples/futures.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.push File.expand_path("../../lib", __FILE__)
+require "celluloid/autostart"
+require "digest/sha2"
+
+class Hasher
+  include Celluloid
+
+  def initialize(secret)
+    @hash = Digest::SHA2.hexdigest(secret)
+  end
+
+  # Add some data into our hash. This demonstrates a non-trivial computation
+  # of the same sort as, say, calculating Fibonacci numbers. Since Celluloid
+  # uses several threads, doing something like this won't grind our entire
+  # application to a halt
+  def add(data, n = 100_000)
+    string = @hash + data
+    n.times { string = Digest::SHA2.hexdigest(string) }
+    @hash = string
+  end
+end
+
+# Create the hasher
+hasher = Hasher.new("super secret initialization data")
+
+# Ask the hasher to perform a complex computation. However, since we're using
+# a future, this doesn't block the current thread
+future = hasher.future.add("some data to be hashed")
+
+# We've kicked off the hasher, but this thread can continue performing other
+# activities while the hasher runs in the background
+puts "The hasher is now running, but this thread is free to do whatever it wants"
+
+# Now let's ask for the return value from the hasher
+puts "Getting the hasher's return value... "
+p future.value

data/examples/ring.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.push File.expand_path("../../lib", __FILE__)
+require "celluloid/autostart"
+
+class Ring
+  include Celluloid
+
+  class Node
+    include Celluloid
+
+    def initialize(link)
+      @link = link
+    end
+
+    def around(n)
+      @link.async.around n
+    end
+  end
+
+  def initialize(size)
+    @node = Node.new_link current_actor
+
+    size.times do
+      @node = Node.new_link @node
+    end
+  end
+
+  # 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
+
+    async.around n
+    wait :done
+  end
+
+  # Go around the ring the given number of times
+  def around(n)
+    if n.zero?
+      signal :done
+    else
+      @node.async.around n - 1
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  require "benchmark"
+  SIZE  = 512
+  TIMES = 10
+
+  puts "*** Creating a #{SIZE} node ring..."
+  puts Benchmark.measure {
+    $ring = Ring.new(SIZE)
+  }
+
+  puts "*** Sending a message around #{TIMES} times"
+  puts Benchmark.measure {
+    $ring.run(TIMES)
+  }
+end

data/examples/simple_pmap.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.push File.expand_path("../../lib", __FILE__)
+require "celluloid/autostart"
+
+module Enumerable
+  # Simple parallel map using Celluloid::Futures
+  def pmap(&block)
+    futures = map { |elem| Celluloid::Future.new(elem, &block) }
+    futures.map(&:value)
+  end
+end
+
+p 100.times.pmap { |n| n * 2 }

data/examples/timers.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.push File.expand_path("../../lib", __FILE__)
+require "celluloid/current"
+
+class TimerExample
+  include Celluloid
+  attr_reader :fired, :timer
+
+  def initialize
+    @fired = false
+    @timer = after(3) { puts "Timer fired!"; @fired = true }
+  end
+end
+
+#
+# Basic timer example
+#
+
+actor = TimerExample.new
+
+# The timer hasn't fired yet, so this should be false
+puts "Timer hasn't fired yet, so this should be false: #{actor.fired}"
+
+# Even if we wait a second, it still hasn't fired
+sleep 1
+puts "Timer still shouldn't have fired yet: #{actor.fired}"
+
+# Wait until after the timer should've fired
+sleep 2.1
+puts "Timer should've fired now: #{actor.fired}"
+
+#
+# Cancelling timers
+#
+
+actor = TimerExample.new
+
+# The timer hasn't fired yet, so this should be false
+puts "Timer hasn't fired yet, so this should be false: #{actor.fired}"
+
+# Cancel the timer, which should prevent it from firing
+actor.timer.cancel
+
+# Wait until after the timer should've fired
+sleep 3.1
+puts "Timer shouldn't have fired because we cancelled it: #{actor.fired}"
+
+class RepeatingTimerExample
+  include Celluloid
+
+  def initialize
+    @sheep = 0
+  end
+
+  def count_sheep
+    print "<#{self.class.name}> Counting sheep to go to sleep: "
+    @timer = every(0.1) do
+      @sheep += 1
+      print @sheep, " "
+    end
+  end
+
+  def stop_counting
+    @timer.cancel
+  end
+end
+
+sleepy_actor = RepeatingTimerExample.new
+sleepy_actor.count_sheep
+sleep 1
+sleepy_actor.stop_counting

data/lib/celluloid.rb

@@ -1,14 +1,21 @@
-require 'logger'
-require 'thread'
-require 'timeout'
-require 'set'
+require "logger"
+require "thread"
+require "timeout"
+require "set"
+
+$CELLULOID_DEBUG = false
+
+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
   extend self
 
-  VERSION = '0.16.0'
-
   # Linking times out after 5 seconds
   LINKING_TIMEOUT = 5
 
@@ -16,16 +23,18 @@ module Celluloid
   BARE_OBJECT_WARNING_MESSAGE = "WARNING: BARE CELLULOID OBJECT "
 
   class << self
-    attr_writer   :actor_system     # Default Actor System
-    attr_accessor :logger           # Thread-safe logger class
-    attr_accessor :task_class       # Default task type to use
-    attr_accessor :shutdown_timeout # How long actors have to terminate
+    attr_writer :actor_system         # Default Actor System
+    attr_accessor :logger               # Thread-safe logger class
+    attr_accessor :log_actor_crashes
+    attr_accessor :group_class          # Default internal thread group to use
+    attr_accessor :task_class           # Default task type to use
+    attr_accessor :shutdown_timeout     # How long actors have to terminate
 
     def actor_system
       if Thread.current.celluloid?
-        Thread.current[:celluloid_actor_system] or raise Error, "actor system not running"
+        Thread.current[:celluloid_actor_system] || fail(Error, "actor system not running")
       else
-        Thread.current[:celluloid_actor_system] || @actor_system or raise Error, "Celluloid is not yet started; use Celluloid.boot"
+        Thread.current[:celluloid_actor_system] || @actor_system || fail(Error, "Celluloid is not yet started; use Celluloid.boot")
       end
     end
 
@@ -33,27 +42,32 @@ module Celluloid
       klass.send :extend,  ClassMethods
       klass.send :include, InstanceMethods
 
-      klass.send :extend, Properties
+      klass.send :extend, Internals::Properties
 
-      klass.property :mailbox_class, :default => Celluloid::Mailbox
-      klass.property :proxy_class,   :default => Celluloid::CellProxy
-      klass.property :task_class,    :default => Celluloid.task_class
+      klass.property :mailbox_class, default: Celluloid::Mailbox
+      klass.property :proxy_class,   default: Celluloid::Proxy::Cell
+      klass.property :task_class,    default: Celluloid.task_class
+      klass.property :group_class,   default: Celluloid.group_class
       klass.property :mailbox_size
 
-      klass.property :exclusive_actor, :default => false
-      klass.property :exclusive_methods, :multi => true
+      klass.property :exclusive_actor, default: false
+      klass.property :exclusive_methods, multi: true
       klass.property :execute_block_on_receiver,
-        :default => [:after, :every, :receive],
-        :multi   => true
+                     default: [:after, :every, :receive],
+                     multi: true
 
       klass.property :finalizer
       klass.property :exit_handler_name
 
-      klass.send(:define_singleton_method, :trap_exit) do |*args|
+      singleton = class << klass; self; end
+      singleton.send(:remove_method, :trap_exit) rescue nil
+      singleton.send(:remove_method, :exclusive) rescue nil
+
+      singleton.send(:define_method, :trap_exit) do |*args|
         exit_handler_name(*args)
       end
 
-      klass.send(:define_singleton_method, :exclusive) do |*args|
+      singleton.send(:define_method, :exclusive) do |*args|
         if args.any?
           exclusive_methods(*exclusive_methods, *args)
         else
@@ -74,12 +88,12 @@ module Celluloid
 
     # Generate a Universally Unique Identifier
     def uuid
-      UUID.generate
+      Internals::UUID.generate
     end
 
     # Obtain the number of CPUs in the system
     def cores
-     CPUCounter.cores
+      Internals::CPUCounter.cores
     end
     alias_method :cpus, :cores
     alias_method :ncpus, :cores
@@ -90,6 +104,16 @@ module Celluloid
     end
     alias_method :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
+
+    def public_registry
+      actor_system.public_registry
+    end
+
     # Detect if a particular call is recursing through multiple actors
     def detect_recursion
       actor = Thread.current[:celluloid_actor]
@@ -98,13 +122,13 @@ module Celluloid
       task = Thread.current[:celluloid_task]
       return unless task
 
-      chain_id = CallChain.current_id
+      chain_id = Internals::CallChain.current_id
       actor.tasks.to_a.any? { |t| t != task && t.chain_id == chain_id }
     end
 
     # Define an exception handler for actor crashes
     def exception_handler(&block)
-      Logger.exception_handler(&block)
+      Internals::Logger.exception_handler(&block)
     end
 
     def suspend(status, waiter)
@@ -135,13 +159,14 @@ module Celluloid
     end
 
     def register_shutdown
-      return if @shutdown_registered
+      return if defined?(@shutdown_registered) && @shutdown_registered
+
       # Terminate all actors at exit
       at_exit do
         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 = $!.status if $!.is_a?(SystemExit)
+          exit_status = $ERROR_INFO.status if $ERROR_INFO.is_a?(SystemExit)
           Celluloid.shutdown
           exit exit_status if exit_status
         else
@@ -163,7 +188,6 @@ module Celluloid
 
   # Class methods added to classes which include Celluloid
   module ClassMethods
-    # Create a new actor
     def new(*args, &block)
       proxy = Cell.new(allocate, behavior_options, actor_options).proxy
       proxy._send_(:initialize, *args, &block)
@@ -173,7 +197,7 @@ module Celluloid
 
     # Create a new actor and link to the current one
     def new_link(*args, &block)
-      raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
+      fail NotActorError, "can't link outside actor context" unless Celluloid.actor?
 
       proxy = Cell.new(allocate, behavior_options, actor_options).proxy
       Actor.link(proxy)
@@ -182,32 +206,6 @@ module Celluloid
     end
     alias_method :spawn_link, :new_link
 
-    # Create a supervisor which ensures an instance of an actor will restart
-    # an actor if it fails
-    def supervise(*args, &block)
-      Supervisor.supervise(self, *args, &block)
-    end
-
-    # Create a supervisor which ensures an instance of an actor will restart
-    # an actor if it fails, and keep the actor registered under a given name
-    def supervise_as(name, *args, &block)
-      Supervisor.supervise_as(name, self, *args, &block)
-    end
-
-    # Create a new pool of workers. Accepts the following options:
-    #
-    # * size: how many workers to create. Default is worker per CPU core
-    # * args: array of arguments to pass when creating a worker
-    #
-    def pool(options = {})
-      PoolManager.new(self, options)
-    end
-
-    # Same as pool, but links to the pool manager
-    def pool_link(options = {})
-      PoolManager.new_link(self, options)
-    end
-
     # Run an actor in the foreground
     def run(*args, &block)
       Actor.join(new(*args, &block))
@@ -220,26 +218,26 @@ module Celluloid
     # Configuration options for Actor#new
     def actor_options
       {
-        :actor_system      => actor_system,
-        :mailbox_class     => mailbox_class,
-        :mailbox_size      => mailbox_size,
-        :task_class        => task_class,
-        :exclusive         => exclusive_actor,
+        actor_system: actor_system,
+        mailbox_class: mailbox_class,
+        mailbox_size: mailbox_size,
+        task_class: task_class,
+        exclusive: exclusive_actor,
       }
     end
 
     def behavior_options
       {
-        :proxy_class               => proxy_class,
-        :exclusive_methods         => exclusive_methods,
-        :exit_handler_name         => exit_handler_name,
-        :finalizer                 => finalizer,
-        :receiver_block_executions => execute_block_on_receiver,
+        proxy_class: proxy_class,
+        exclusive_methods: exclusive_methods,
+        exit_handler_name: exit_handler_name,
+        finalizer: finalizer,
+        receiver_block_executions: execute_block_on_receiver,
       }
     end
 
     def ===(other)
-      other.kind_of? self
+      other.is_a? self
     end
   end
 
@@ -259,7 +257,9 @@ module Celluloid
     #     >> actor.bare_object
     #      => #<WARNING: BARE CELLULOID OBJECT (Foo:0x3fefcb77c194)>
     #
-    def bare_object; self; end
+    def bare_object
+      self
+    end
     alias_method :wrapped_object, :bare_object
 
     # Are we being invoked in a different thread from our owner?
@@ -286,7 +286,7 @@ module Celluloid
       if leaked?
         str << Celluloid::BARE_OBJECT_WARNING_MESSAGE
       else
-        str << "Celluloid::CellProxy"
+        str << "Celluloid::Proxy::Cell"
       end
 
       str << "(#{self.class}:0x#{object_id.to_s(16)})"
@@ -297,7 +297,11 @@ module Celluloid
         str << "#{ivar}=#{instance_variable_get(ivar).inspect} "
       end
 
-      str.sub!(/\s$/, '>')
+      str.sub!(/\s$/, ">")
+    end
+
+    def __arity
+      method(:initialize).arity
     end
   end
 
@@ -311,9 +315,9 @@ module Celluloid
     cause = case cause
       when String then RuntimeError.new(cause)
       when Exception then cause
-      else raise TypeError, "Exception object/String expected, but #{cause.class} received"
+      else fail TypeError, "Exception object/String expected, but #{cause.class} received"
     end
-    raise AbortError.new(cause)
+    fail AbortError.new(cause)
   end
 
   # Terminate this actor
@@ -338,7 +342,7 @@ module Celluloid
 
   # Obtain the UUID of the current call chain
   def call_chain_id
-    CallChain.current_id
+    Internals::CallChain.current_id
   end
 
   # Obtain the running tasks for this actor
@@ -431,7 +435,7 @@ module Celluloid
   end
 
   # Perform a blocking or computationally intensive action inside an
-  # asynchronous thread pool, allowing the sender to continue processing other
+  # asynchronous group of threads, allowing the sender to continue processing other
   # messages in its mailbox in the meantime
   def defer(&block)
     # This implementation relies on the present implementation of
@@ -451,66 +455,77 @@ module Celluloid
 end
 
 if defined?(JRUBY_VERSION) && JRUBY_VERSION == "1.7.3"
-  raise "Celluloid is broken on JRuby 1.7.3. Please upgrade to 1.7.4+"
+  fail "Celluloid is broken on JRuby 1.7.3. Please upgrade to 1.7.4+"
 end
 
-require 'celluloid/exceptions'
-
-require 'celluloid/calls'
-require 'celluloid/call_chain'
-require 'celluloid/condition'
-require 'celluloid/thread'
-require 'celluloid/core_ext'
-require 'celluloid/cpu_counter'
-require 'celluloid/fiber'
-require 'celluloid/fsm'
-require 'celluloid/internal_pool'
-require 'celluloid/links'
-require 'celluloid/logger'
-require 'celluloid/mailbox'
-require 'celluloid/evented_mailbox'
-require 'celluloid/method'
-require 'celluloid/properties'
-require 'celluloid/handlers'
-require 'celluloid/receivers'
-require 'celluloid/registry'
-require 'celluloid/responses'
-require 'celluloid/signals'
-require 'celluloid/stack_dump'
-require 'celluloid/system_events'
-require 'celluloid/tasks'
-require 'celluloid/task_set'
-require 'celluloid/thread_handle'
-require 'celluloid/uuid'
-
-require 'celluloid/proxies/abstract_proxy'
-require 'celluloid/proxies/sync_proxy'
-require 'celluloid/proxies/cell_proxy'
-require 'celluloid/proxies/actor_proxy'
-require 'celluloid/proxies/async_proxy'
-require 'celluloid/proxies/future_proxy'
-require 'celluloid/proxies/block_proxy'
-
-require 'celluloid/actor'
-require 'celluloid/cell'
-require 'celluloid/future'
-require 'celluloid/actor_system'
-require 'celluloid/pool_manager'
-require 'celluloid/supervision_group'
-require 'celluloid/supervisor'
-require 'celluloid/notifications'
-require 'celluloid/logging'
-
-require 'celluloid/legacy' unless defined?(CELLULOID_FUTURE)
+require "celluloid/exceptions"
+
+Celluloid.logger = Logger.new(STDERR)
+Celluloid.shutdown_timeout = 10
+Celluloid.log_actor_crashes = true
+
+require "celluloid/calls"
+require "celluloid/condition"
+require "celluloid/thread"
+
+require "celluloid/core_ext"
+
+require "celluloid/system_events"
+
+require "celluloid/proxies"
+
+require "celluloid/mailbox"
+require "celluloid/mailbox/evented"
+
+require "celluloid/essentials"
+
+require "celluloid/group"
+require "celluloid/group/manager"
+require "celluloid/group/spawner"
+require "celluloid/group/pool"      # TODO: Find way to only load this if being used.
+
+require "celluloid/task"
+require "celluloid/task/fibered"
+require "celluloid/task/threaded"   # TODO: Find way to only load this if being used.
+
+require "celluloid/actor"
+require "celluloid/cell"
+require "celluloid/future"
+
+require "celluloid/actor_system"
+
+require "celluloid/deprecate" unless $CELLULOID_BACKPORTED == false
 
 $CELLULOID_MONITORING = false
+Celluloid::Notices.output
 
 # Configure default systemwide settings
-Celluloid.task_class = Celluloid::TaskFiber
-Celluloid.logger     = Logger.new(STDERR)
-Celluloid.shutdown_timeout = 10
 
-unless $CELLULOID_TEST
+Celluloid.task_class =
+  begin
+    str = ENV["CELLULOID_TASK_CLASS"] || "Fibered"
+    Kernel.const_get(str)
+  rescue NameError
+    begin
+      Celluloid.const_get(str)
+    rescue NameError
+      Celluloid::Task.const_get(str)
+    end
+  end
+
+Celluloid.group_class =
+  begin
+    str = ENV["CELLULOID_GROUP_CLASS"] || "Spawner"
+    Kernel.const_get(str)
+  rescue NameError
+    begin
+      Celluloid.const_get(str)
+    rescue NameError
+      Celluloid::Group.const_get(str)
+    end
+  end
+
+unless defined?($CELLULOID_TEST) && $CELLULOID_TEST
   Celluloid.register_shutdown
   Celluloid.init
 end