celluloid 0.17.4 → 0.18.0

data/README.md

@@ -1,93 +1,45 @@
-![Celluloid](https://raw.github.com/celluloid/celluloid-logos/master/celluloid/celluloid.png)
-=========
-[![Gem Version](https://badge.fury.io/rb/celluloid.svg)](http://rubygems.org/gems/celluloid)
-[![Build Status](https://secure.travis-ci.org/celluloid/celluloid.svg?branch=master)](http://travis-ci.org/celluloid/celluloid)
-[![Code Climate](https://codeclimate.com/github/celluloid/celluloid.svg)](https://codeclimate.com/github/celluloid/celluloid)
-[![Coverage Status](https://coveralls.io/repos/celluloid/celluloid/badge.svg?branch=master)](https://coveralls.io/r/celluloid/celluloid)
-
-_NOTE: This is the 0.17.x **stable** branch of Celluloid. For the 0.18.x
-**development** branch, please see:_
-
-https://github.com/celluloid/celluloid
-
-> "I thought of objects being like biological cells and/or individual
-> computers on a network, only able to communicate with messages"
-> _--Alan Kay, creator of Smalltalk, on the meaning of "object oriented programming"_
-
-Celluloid provides a simple and natural way to build fault-tolerant concurrent
-programs in Ruby. With Celluloid, you can build systems out of concurrent
-objects just as easily as you build sequential programs out of regular objects.
-Recommended for any developer, including novices, Celluloid should help ease
-your worries about building multithreaded Ruby programs.
-
-Much of the difficulty with building concurrent programs in Ruby arises because
-the object-oriented mechanisms for structuring code, such as classes and
-inheritance, are separate from the concurrency mechanisms, such as threads and
-locks. Celluloid combines these into a single structure, an active object
-running within a thread, called an "actor", or in Celluloid vernacular, a "cell".
-
-By combining concurrency with object oriented programming, Celluloid frees you
-up from worry about where to use threads and locks. Celluloid combines them
-together into a single concurrent object oriented programming model,
-encapsulating state in concurrent objects and thus avoiding many of the
-problems associated with multithreaded programming. Celluloid provides many
-features which make concurrent programming simple, easy, and fun:
-
-* __Automatic "deadlock-free" synchronization:__ Celluloid uses a concurrent
-  object model which combines method dispatch and thread synchronization.
-  Each actor is a concurrent object running in its own thread, and every method
-  invocation is wrapped in a fiber that can be suspended whenever it calls
-  out to other actors, and resumed when the response is available. This means
-  methods which are waiting for responses from other actors, external messages,
-  or other system events (including I/O with Celluloid::IO) can be suspended
-  and will never block other methods that are ready to run. This won't prevent
-  bugs in Celluloid, bugs in other thread-safe libraries you use, and even
-  certain "dangerous" features of Celluloid from causing your program to
-  deadlock, but in general, programs built with Celluloid will be naturally
-  immune to deadlocks.
-
-* __Fault-tolerance:__ Celluloid has taken to heart many of Erlang's ideas
-  about fault-tolerance in order to enable self-healing applications.
-  The central idea: have you tried turning it off and on again? Celluloid
-  takes care of rebooting subcomponents of your application when they crash,
-  whether it's a single actor, or large (potentially multi-tiered) groups of
-  actors that are all interdependent. This means rather than worrying about
-  rescuing every last exception, you can just sit back, relax, and let parts
-  of your program crash, knowing Celluloid will automatically reboot them in
-  a clean state. Celluloid provides its own implementation of the core
-  fault-tolerance concepts in Erlang including [linking](https://github.com/celluloid/celluloid/wiki/Linking),
-  [supervisors](https://github.com/celluloid/celluloid/wiki/Supervisors),
-  and [supervision groups](https://github.com/celluloid/celluloid/wiki/Supervision-Groups).
-
-* __[Futures](https://github.com/celluloid/celluloid/wiki/futures):__
-  Ever wanted to call a method "in the background" and retrieve the
-  value it returns later? Celluloid futures do just that. It's like
-  calling ahead to a restaurant to place an order, so they can work
-  on preparing your food while you're on your way to pick it up.
-  When you ask for a method's return value, it's returned immediately
-  if the method has already completed, or otherwise the current method is
-  suspended until the value becomes available.
-
-You can also build distributed systems with Celluloid using its
-[sister project DCell](https://github.com/celluloid/dcell). Evented IO similar
-to EventMachine (with a synchronous API instead of callback/deferrable soup)
-is available through the [Celluloid::IO](https://github.com/celluloid/celluloid-io)
-library.
-
-Like Celluloid? [Join the mailing list/Google Group](http://groups.google.com/group/celluloid-ruby)
-or visit us on IRC at #celluloid on freenode
-
-### Is it any good?
-
-[Yes](http://news.ycombinator.com/item?id=3067434)
-
-### Is It "Production Ready™"?
-
-Yes, many users are now running Celluloid in production by using
-[Sidekiq](http://sidekiq.org) and [Adhearsion](http://adhearsion.com/)
-
-Documentation
--------------
+# ![Celluloid][celluloid-logo-image-raw]
+
+[![Gem Version][gem-image]][gem-link]
+[![MIT licensed][license-image]][license-link]
+[![Build Status][build-image]][build-link]
+[![Maintained: no][maintained-image]][maintained-link]
+[![Gitter Chat][gitter-image]][gitter-link]
+
+[celluloid-logo-image-raw]: https://raw.github.com/celluloid/celluloid-logos/master/celluloid/celluloid.png
+[gem-image]: https://badge.fury.io/rb/celluloid.svg
+[gem-link]: http://rubygems.org/gems/celluloid
+[build-image]: https://secure.travis-ci.org/celluloid/celluloid.svg?branch=master
+[build-link]: http://travis-ci.org/celluloid/celluloid
+[license-image]: https://img.shields.io/badge/license-MIT-blue.svg
+[license-link]: https://github.com/celluloid/celluloid/blob/master/LICENSE.txt
+[maintained-image]: https://img.shields.io/maintenance/no/2016.svg
+[maintained-link]: https://github.com/celluloid/celluloid/issues/779
+[gitter-image]: https://badges.gitter.im/badge.svg
+[gitter-link]: https://gitter.im/celluloid/celluloid
+
+Celluloid is a framework for building asynchronous and multithreaded Ruby
+programs using object-oriented concepts.
+
+## Revival Process Underway
+
+`Celluloid` is in the process of being refactored and released back into the wild during `Google Summer of Code`. The next era will not have one individual active maintainer, but a team of collaborators. Going forward, previously dormant maintainer [Donovan Keme](https://github.com/digitalextremist) is returning to support future primary maintainer [Emese Padányi](https://github.com/emesepadanyi) during `GSoC 2020`. Her plan extends past the Summer program, and aims to revive the community and codebase of `Celluloid` together. Backing this process are [Harsh Deep](https://github.com/harsh183) and `GSoC` alumni [Dilum Navanjana](https://github.com/dilumn). We welcome your collaboration and contributions in this massive work.
+
+The codebase is being refactored to pursue a stable release with no deprecation warnings, and with this cleaned up:
+
+# ![Diagram][celluloid-diagram]
+*Diagram meticulously developed by [Emese Padányi](https://github.com/emesepadanyi)*
+
+[celluloid-diagram]: https://raw.githubusercontent.com/celluloid/celluloid/master/documentation/ClassDiagram-class_diagram.png
+
+### Proudly supported by the best cloud infrastructure provider in the world: [`DigitalOcean`](https://digitalocean.com)
+
+## Discussion
+
+- [Gitter Chat][gitter-link]
+- [Google Group](https://groups.google.com/group/celluloid-ruby)
+
+## Documentation
 
 [Please see the Celluloid Wiki](https://github.com/celluloid/celluloid/wiki)
 for more detailed documentation and usage notes.
@@ -99,11 +51,9 @@ The following API documentation is also available:
 * [Celluloid class methods](http://rubydoc.info/gems/celluloid/Celluloid/ClassMethods)
 * [All Celluloid classes](http://rubydoc.info/gems/celluloid/index)
 
-Related Projects
-----------------
+## Related Projects
 
-Celluloid is the parent project of a related ecosystem of other projects. If you
-like Celluloid we definitely recommend you check them out:
+See also: [Projects Using Celluloid](https://github.com/celluloid/celluloid/wiki/Projects-Using-Celluloid)
 
 * [Reel][reel]: An "evented" web server based on `Celluloid::IO`
 * [DCell][dcell]: The Celluloid actor protocol distributed over 0MQ
@@ -112,79 +62,28 @@ like Celluloid we definitely recommend you check them out:
 * [Celluloid::ZMQ][celluloid-zmq]: "Evented" 0MQ support for `Celluloid` actors
 * [Celluloid::DNS][celluloid-dns]: An "evented" DNS server based on `Celluloid::IO`
 * [Celluloid::SMTP][celluloid-smtp]: An "evented" SMTP server based on `Celluloid::IO`
-* [Lattice][lattice]: A concurrent realtime web framework based on `Celluloid::IO`
 * [nio4r][nio4r]: "New IO for Ruby": high performance IO selectors
 * [Timers][timers]: A generic Ruby timer library for event-based systems
 
 [reel]: https://github.com/celluloid/reel/
 [dcell]: https://github.com/celluloid/dcell/
-[ecell]: https://github.com/celluloid/ecell/
+[ecell]: https://github.com/abstractive/ecell/
 [celluloid-io]: https://github.com/celluloid/celluloid-io/
 [celluloid-zmq]: https://github.com/celluloid/celluloid-zmq/
 [celluloid-dns]: https://github.com/celluloid/celluloid-dns/
-[celluloid-smtp]: https://github.com/celluloid/celluloid-smtp/
-[lattice]: https://github.com/celluloid/lattice/
+[celluloid-smtp]: https://github.com/abstractive/celluloid-smtp/
 [nio4r]: https://github.com/celluloid/nio4r/
 [timers]: https://github.com/celluloid/timers/
 
-Installation
-------------
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'celluloid'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install celluloid
-
-Inside of your Ruby program, require Celluloid with [newest API](https://github.com/celluloid/celluloid/wiki/DEPRECATION-WARNING):
-
-```ruby
-require 'celluloid/current'
-```
-
-Or to support the old API, use:
-
-```ruby
-require 'celluloid/backported'
-```
-
-Supported Platforms
--------------------
-
-Celluloid works on Ruby 2.0+, JRuby 1.7+, and Rubinius 2.0.
-
-JRuby or Rubinius are the preferred platforms as they support true thread-level
-parallelism when executing Ruby code, whereas MRI/YARV is constrained by a global
-interpreter lock (GIL) and can only execute one thread at a time.
-
-Celluloid requires Ruby 1.9 mode on all interpreters.
-
-Additional Reading
-------------------
-
-* [Concurrent Object-Oriented Programming in Python with
-  ATOM](http://citeseerx.ist.psu.edu/viewdoc/download;jsessionid=11A3EACE78AAFF6D6D62A64118AFCA7C?doi=10.1.1.47.5074&rep=rep1&type=pdf):
-  a similar system to Celluloid written in Python
-
-Contributing to Celluloid
--------------------------
+## Contributing to Celluloid
 
-* Fork this repository on github
-* Make your changes and send us a pull request
-* If we like them we'll merge them
-* If we've accepted a patch, feel free to ask for commit access
+- Fork this repository on github
+- Make your changes and send us a pull request
+- Pull requests will be reviewed for inclusion in the project
 
-License
--------
+## License
 
-Copyright (c) 2011-2015 Tony Arcieri, Donovan Keme.
+Copyright (c) 2011-2018 Tony Arcieri, Donovan Keme.
 
-Distributed under the MIT License. See [LICENSE.txt](https://github.com/celluloid/celluloid/blob/master/LICENSE.txt) for further details.
+Distributed under the MIT License. See [LICENSE.txt](https://github.com/celluloid/celluloid/blob/master/LICENSE.txt)
+for further details.

data/REFACTOR.md

@@ -0,0 +1 @@
+20200703113000: `require "celluloid/current"` is removed. use `require "celluloid"`

data/architecture.md

@@ -0,0 +1,120 @@
+# Architecture
+
+The purpose of this document is to provide an overview of the `Celluloid` project architecture. It is intended as a learning tool for
+GSoC (Google Summer of Code) and for anyone else interested in peeking under the hood to figure out how Celluloid works.
+
+This document will evolve since the people writing it are learning the project too. It will likely evolve in the following manner:
+
+1. Document all major classes by describing the purpose of each one.
+2. Document the dependencies between classes described in item 1.
+3. Describe the flow of messages between the classes documented in items 1 and 2.
+4. Generate a Big Picture overview of the overall Celluloid architecture.
+5. Create a flew graphics to depict class dependencies and message flows (perhaps as a directed acyclic graph).
+
+## Document Status
+
+The document is working on item 1.
+
+## Required Libraries
+`logger`
+`thread`
+`timeout`
+`set`
+
+## Require Lifecycle
+Document the steps taken from the moment `require "celluloid"` is executed by the runtime.
+
+The file `celluloid.rb` is read in by the runtime. This file requires some standard libraries like `Thread` and `Set` (see Required Libraries for full list) and initializes the `Celluloid` module namespace. It then sets up a Celluloid singleton class which will contain utility functions that need to be accessed from anywhere. Think of these singleton methods as global methods. These specific methods should be considered private to the library and should not be directly called by user code.
+
+From here it continues to `extend` and `include` other modules so that any Ruby object that executes `include Celluloid` as part of its class definition automatically gains all of the Celluloid magic. 
+
+Next, it defines regular methods within the Celluloid namespace. These are also global methods but they are essentially the public API to the outside world. These methods (such as `current_actor` and `terminate`) can be called by user code.
+
+Next we have a list of `require`'d subfiles. This loads the remainder of the library in preparation to start running.
+
+Next, the code sets up two global default settings for the `task_class` and `group_class`. I don't know what these are yet but by exposing them this way it's clearly intended for these items to be defined in such a way that user code can override them with use-case-specific code. The code here can also read names from the environment variables to set the defaults. This is likely intended for use by the spec/test system.
+
+Lastly, the code registers some methods for shutdown to terminate all actors `at_exit` and then initializes the system.
+
+To boot the system, call `require 'celluloid'`.
+
+## Supervision Lifecycle
+The final call to `Actor::System.new.start` kicks off the top level supervisor. The supervisor container is an actor and it will keep track of all defined actors as they are added for supervision. A user may create an actor that is not supervised, so the top-level supervisor does not necessarily have a reference to every actor in the system.
+
+The Registry is also created at this time and lives within the main container. Actors can be added to the registry even if they are not supervised. The two concepts are separate even though the code is somewhat comingled. 
+
+## Classes / Modules
+
+### Celluloid Module
+* Sets up class accessors used throughout/globally such as `logger`
+* When using `include Celluloid` on a class, it performs the following work during `include`:
+  * Extends `ClassMethods` and `Internals::Properties`
+  * Includes `InstanceMethods`
+  * Sets properties on the class object.
+  * Removes `trap_exit` and `exclusive` if they exist on the singleton class so that Celluloid can redefine them for itself.
+* Defines class methods inside the `Celluloid` namespace such as `actor?` and `mailbox` and `cores`. These are utility functions. They are defined on the Celluloid singleton.
+* Provides the entry method `boot` to start up the whole system and its opposite `shutdown` to terminate everything.
+
+#### Depends On Classes
+* Internals::Logger
+* Internals::CallChain
+* Actor::System
+* Celluloid::Mailbox
+* Thread (primarily for Thread.current to access fiber locals like `:celluloid_actor`)
+* Future
+
+### ClassMethods Module
+This class contains class-level methods which are added to every user class that contains `include Celluloid`. 
+
+* Overrides `new` for the class object.
+
+#### Depends On Classes
+* Cell
+* Actor
+* Celluloid
+
+### InstanceMethods Module
+This module contains instance-level methods which are added to every user class that contains `include Celluloid`.
+
+#### Depends on Classes
+* Actor
+* Celluloid
+
+
+### Actor::System class
+Is created and `start`'ed as part of the entire boot sequence. This class provides essential services utilized by the rest of the library such as the Registry and the top-level Supervisor.
+
+#### Lifecycle
+Creates the `Registry` and initializes the `Celluloid.group_class`. Upon `start` it makes sure that it switches the `Thread.current[:celluloid_actor_system]` to itself, then defines and deploys the `Root` services.
+
+#### Depends On Classes
+* Supervision::Service::Root which is in gem `celluloid-supervision`
+* Celluloid::Notifications::Fanout
+* Celluloid::IncidentReporter
+* Celluloid::Supervision::Service::Public
+* Celluloid::Actor::Manager
+* Celluloid
+* Internals::Registry
+* Celluloid.group_class
+
+## Gem - celluloid-supervision
+Necessary for the core system to boot.
+
+Really has only two classes/modules of note. One is Supervision::Container which is an actor that keeps track of all actors under supervision. It also handles restart. Two is Supervision::Configuration. This class manages the several different ways that an actor may be placed under supervision, arguments passed to it, and other data.
+
+Be careful when reading the code. Each file in the gem relies on open Ruby classes. These files reopen previously defined classes and add more behavior, so to get a complete picture for what the Configuration and Container classes can do you must look through all of the files. While this logical separation of business logic to its own file is neat, it adds to the cognitive load when reading the code since the entire class defintion is spread over multiple files.
+
+### Supervision::Service::Root
+
+#### Depends On Classes
+* Supervision::Container
+
+
+### Supervision::Container
+Stores references to Actors on behalf of a Supervisor.
+
+This is the only class under the `Supervision` namespace that is an Actor. Every other class is a regular Ruby class.
+
+#### Depends On Classes
+* Supervision::Configuration
+* 

data/examples/basic_usage.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 Counter

data/examples/configurations.rb

@@ -0,0 +1,78 @@
+require "celluloid"
+
+puts "Use Supervision::Configuration objects!"
+
+class Hello
+  include Celluloid
+
+  finalizer :ceasing
+
+  def initialize(to)
+    @to = to
+    puts "Created Hello #{@to}"
+  end
+
+  def ceasing
+    puts "Hello #{@to} go buhbye"
+  end
+end
+
+class FooBar
+  include Celluloid
+
+  finalizer :ceasing
+
+  def initialize(i = 0)
+    @i = i
+    puts "Created FooBar: #{@i}"
+  end
+
+  def ceasing
+    puts "FooBar FooBar: #{@i} go buhbye"
+  end
+end
+
+puts "\nInstantiated in bulk, using #deploy"
+
+config = Celluloid::Supervision::Configuration.define([
+                                                        { type: FooBar, as: :foobar },
+                                                        { type: Hello, as: :hello, args: ["World"] }
+                                                      ])
+
+config.deploy
+puts "...shut it down"
+config.shutdown
+
+puts "\nInstantiated in bulk, using .deploy"
+
+config = Celluloid::Supervision::Configuration.deploy([
+                                                        { type: FooBar, as: :foobar, args: [1] },
+                                                        { type: Hello, as: :hello, args: ["World"] }
+                                                      ])
+
+puts "...shut it down"
+config.shutdown
+
+puts "\nInstantiated two actors individually, using a local configuration object"
+
+config = Celluloid::Supervision::Configuration.new
+config.define type: FooBar, as: :foobar11, args: [11]
+config.define type: FooBar, as: :foobar33, args: [33]
+config.deploy
+
+puts "Instantiated another, which starts automatically."
+puts "... using the local configuration object"
+puts "... using a lazy loaded argument"
+config.add type: Hello, as: :hello, args: -> { "Spinning World" }
+
+config.shutdown
+
+puts "\nReuse our last configuration!"
+
+config.deploy
+puts "...shut it down"
+config.shutdown
+
+puts "Thinking for 4 seconds, and 4 seconds only."
+sleep 4
+puts "Use Supervision::Configuration objects. Really!"

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