celluloid 0.17.0 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f3dcad033e3a0b6fa706d2968031433ca348ff7b
-  data.tar.gz: 7de5d781ae489a2e9887333fbdd17a008f10869c
+  metadata.gz: f6f92390f358da4f217db89db7992a0c438e0101
+  data.tar.gz: 29023b71e9a2fe46e604bd53237c33cccf9d17e8
 SHA512:
-  metadata.gz: d03a5a5da0d7bf0efe4ebf46cb76b58384e7cae02e4c9054e3d7fa15f01c35fb0e7e27f476c0e26d578555945985c1bb65cab1c7e15aeba56c9179a92666247d
-  data.tar.gz: e8d4f7cf8058919f3ef408a71d8435971e8b01ba3c60c950d38b79dec8a73e7a5c094ad36ba7f599d11fe169c75dc22951014b1584004ddac4796ee4eea7c33c
+  metadata.gz: a6420a70030cd7d033a758f05cdb267356998149c8307783c86d8d79679791dd425b971e0f81e9522dd6eb0a158884aecc02fd52c01e2872c30c167d6cfd4ccf
+  data.tar.gz: 7e84182dafbf520311afdfed411433da7b2fe8eb9fa694995bab7d5d992c751d7c9f0d4503223612046c38e8979e0d4875593cc9a8ba7f545bef4ad441cc0558

data/CHANGES.md

@@ -1,5 +1,13 @@
-0.17.0 (2015)
-----
+0.17.5 (HEAD)
+-----
+* `Celluloid::ActorSystem` moved to `Celluloid::Actor::System`, and from `celluloid/actor_system.rb` to `celluloid/actor/system.rb`
+* Added extensible API for defining new SystemEvents, and having them handled... without everyone changing `Actor#handle_system_event`.
+* Deprecated Task::TerminatedError & Task::TimeoutError... Consolidated in exceptions.rb, inherited from Exceptions vs. StandardError.
+* General round-up of all "errors" emitted throughout Celluloid, to either be derived from `Celluloid::Error` or `Celluloid::Interruption`.
+* Added ability to pass a block to `Condition#wait` which runs a `{ |value| ... }` type block if present, once the value is obtained by waiting.
+
+0.17.0 (2015-07-04)
+-----
 * Fix $CELLULOID_TEST warnings
 * Massive overhaul of test suite, end-to-end.
 * Make "Terminating task" log messages debug-level events

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2014 Tony Arcieri
+Copyright (c) 2011-2014 Tony Arcieri, Donovan Keme
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,9 +1,9 @@
 ![Celluloid](https://raw.github.com/celluloid/celluloid-logos/master/celluloid/celluloid.png)
 =========
-[![Gem Version](https://badge.fury.io/rb/celluloid.png)](http://rubygems.org/gems/celluloid)
-[![Build Status](https://secure.travis-ci.org/celluloid/celluloid.png?branch=master)](http://travis-ci.org/celluloid/celluloid)
-[![Code Climate](https://codeclimate.com/github/celluloid/celluloid.png)](https://codeclimate.com/github/celluloid/celluloid)
-[![Coverage Status](https://coveralls.io/repos/celluloid/celluloid/badge.png?branch=master)](https://coveralls.io/r/celluloid/celluloid)
+[![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)
 
 > "I thought of objects being like biological cells and/or individual
 > computers on a network, only able to communicate with messages"
@@ -100,18 +100,24 @@ 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:
 
-* [Celluloid::IO][celluloid-io]: "Evented" IO support for Celluloid actors
-* [Celluloid::ZMQ][celluloid-zmq]: "Evented" 0MQ support for Celluloid actors
+* [Reel][reel]: An "evented" web server based on `Celluloid::IO`
 * [DCell][dcell]: The Celluloid actor protocol distributed over 0MQ
-* [Reel][reel]: An "evented" web server based on Celluloid::IO
-* [Lattice][lattice]: A concurrent realtime web framework based on Celluloid::IO
+* [ECell][ecell]: Mesh strategies for `Celluloid` actors distributed over 0MQ
+* [Celluloid::IO][celluloid-io]: "Evented" IO support for `Celluloid` actors
+* [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/
 [celluloid-io]: https://github.com/celluloid/celluloid-io/
 [celluloid-zmq]: https://github.com/celluloid/celluloid-zmq/
-[dcell]: https://github.com/celluloid/dcell/
-[reel]: https://github.com/celluloid/reel/
+[celluloid-dns]: https://github.com/celluloid/celluloid-dns/
+[celluloid-smtp]: https://github.com/celluloid/celluloid-smtp/
 [lattice]: https://github.com/celluloid/lattice/
 [nio4r]: https://github.com/celluloid/nio4r/
 [timers]: https://github.com/celluloid/timers/
@@ -133,10 +139,16 @@ Or install it yourself as:
 
     $ gem install celluloid
 
-Inside of your Ruby program, require Celluloid with:
+Inside of your Ruby program, require Celluloid with [newest API](/celluloid/celluloid/wiki/DEPRECATION-WARNING):
+
+```ruby
+require 'celluloid/current'
+```
+
+Or to support the old API, use:
 
 ```ruby
-require 'celluloid/autostart'
+require 'celluloid/backported'
 ```
 
 Supported Platforms
@@ -168,5 +180,5 @@ Contributing to Celluloid
 License
 -------
 
-Copyright (c) 2011-2014 Tony Arcieri. Distributed under the MIT License. See
-LICENSE.txt for further details.
+Copyright (c) 2011-2015 Tony Arcieri, Donovan Keme.
+Distributed under the MIT License. See [LICENSE.txt](https://github.com/celluloid/celluloid/blob/master/LICENSE.txt) for further details.

data/culture/gems/dependencies.yml

@@ -8,6 +8,9 @@ benchmark_suite:
 rubocop:
   dependency: development
 
+transpec:
+  dependency: development
+
 pry:
   dependency: development
 
@@ -17,6 +20,9 @@ rake:
 rspec:
   dependency: development
 
+guard-rspec:
+  dependency: development
+
 coveralls:
   dependency: development
   gemfile:
@@ -24,10 +30,10 @@ coveralls:
 
 celluloid:
   dependency: core
-  version: ">= 0.17.0.pre12"
+  version: ">= 0.17.0"
   gemfile:
     github: celluloid/celluloid
-    branch: 0.17.0-prerelease
+    branch: master
     submodules: true
 
 celluloid-essentials:

data/examples/stack.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.push File.expand_path("../../lib", __FILE__)
+require "celluloid/autostart"
+
+# This example builds on basic_usage.rb to show two things about #async: the
+# (new) fluent API and the preservation of causality order.
+class Stack
+  include Celluloid
+
+  attr_reader :ary
+
+  def initialize
+    @ary = []
+  end
+
+  def push(x)
+    @ary.push x
+  end
+  alias_method :<<, :push
+
+  def pop
+    @ary.pop
+  end
+
+  def show
+    p @ary
+  end
+end
+
+st = Stack.new
+
+# Schedule three calls to #push some integers on the stack. They will execute
+# in order because the calls originated as a sequence of method calls in a
+# single thread.
+st.async << 1 << 2 << 3
+
+# Schedule a call to show the stack after the three push calls execute.
+st.async.show
+
+# Schedule three calls to #pop from the stack.
+st.async.pop.pop.pop
+
+# The next (non-async) call is guaranteed to execute after methods previously
+# scheduled in this thread. The causal order of calls (order as requested) is
+# preserved in the execution order.
+st.show

data/lib/celluloid.rb

@@ -4,6 +4,7 @@ require "timeout"
 require "set"
 
 $CELLULOID_DEBUG = false
+$CELLULOID_MANAGED ||= false
 
 require "celluloid/version"
 require "celluloid/notices"
@@ -147,7 +148,7 @@ module Celluloid
     end
 
     def init
-      @actor_system = ActorSystem.new
+      @actor_system = Actor::System.new
     end
 
     def start
@@ -163,6 +164,8 @@ module Celluloid
 
       # Terminate all actors at exit
       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
@@ -313,9 +316,9 @@ module Celluloid
   # Raise an exception in sender context, but stay running
   def abort(cause)
     cause = case cause
-      when String then RuntimeError.new(cause)
-      when Exception then cause
-      else fail TypeError, "Exception object/String expected, but #{cause.class} received"
+            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)
   end
@@ -480,7 +483,6 @@ 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.
 
@@ -492,7 +494,8 @@ require "celluloid/actor"
 require "celluloid/cell"
 require "celluloid/future"
 
-require "celluloid/actor_system"
+require "celluloid/actor/system"
+require "celluloid/actor/manager"
 
 require "celluloid/deprecate" unless $CELLULOID_BACKPORTED == false
 

data/lib/celluloid/actor.rb

@@ -1,4 +1,3 @@
-
 require "timers"
 
 module Celluloid
@@ -132,8 +131,9 @@ module Celluloid
         run
       end
 
-      @proxy = Proxy::Actor.new(@thread, @mailbox)
+      @proxy = Proxy::Actor.new(@mailbox, @thread)
       Celluloid::Probe.actor_created(self) if $CELLULOID_MONITORING
+      Celluloid::Actor::Manager.actor_created(self) if $CELLULOID_MANAGED
     end
 
     def behavior_proxy
@@ -167,9 +167,9 @@ module Celluloid
       end
 
       shutdown
-    rescue Exception => ex
+    rescue ::Exception => ex
       handle_crash(ex)
-      raise unless ex.is_a? StandardError
+      raise unless ex.is_a?(StandardError) || ex.is_a?(Celluloid::Interruption)
     end
 
     # Terminate this actor
@@ -190,7 +190,7 @@ module Celluloid
               msg.actor.mailbox.address == receiver.mailbox.address &&
               msg.type == type
             end
-          rescue TimeoutError
+          rescue TaskTimeout
             next # IO reactor did something, no message in queue yet.
           end
 
@@ -205,7 +205,7 @@ module Celluloid
           end
         end
 
-        fail TimeoutError, "linking timeout of #{LINKING_TIMEOUT} seconds exceeded with receiver: #{receiver}"
+        fail TaskTimeout, "linking timeout of #{LINKING_TIMEOUT} seconds exceeded with receiver: #{receiver}"
       end
     end
 
@@ -247,7 +247,7 @@ module Celluloid
       bt = caller
       task = Task.current
       timer = @timers.after(duration) do
-        exception = Task::TimeoutError.new("execution expired")
+        exception = TaskTimeout.new("execution expired")
         exception.set_backtrace bt
         task.resume exception
       end
@@ -287,31 +287,6 @@ module Celluloid
       message
     end
 
-    # Handle high-priority system event messages
-    def handle_system_event(event)
-      if event.instance_of? ExitEvent
-        handle_exit_event(event)
-      elsif event.instance_of? LinkingRequest
-        event.process(links)
-      elsif event.instance_of? NamingRequest
-        @name = event.name
-        Celluloid::Probe.actor_named(self) if $CELLULOID_MONITORING
-      elsif event.instance_of? TerminationRequest
-        terminate
-      elsif event.instance_of? SignalConditionRequest
-        event.call
-      else
-        Internals::Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
-      end
-    end
-
-    # Handle exit events received by this actor
-    def handle_exit_event(event)
-      @links.delete event.actor
-
-      @exit_handler.call(event)
-    end
-
     def default_exit_handler(event)
       fail event.reason if event.reason
     end

data/lib/celluloid/actor/manager.rb

@@ -0,0 +1,7 @@
+module Celluloid
+  class Actor
+    class Manager
+      include Celluloid
+    end
+  end
+end

data/lib/celluloid/actor/system.rb

@@ -0,0 +1,163 @@
+module Celluloid
+  extend Forwardable
+  def_delegators :actor_system, :[], :[]=
+
+  class Actor
+    class System
+      extend Forwardable
+      def_delegators :@registry, :[], :get, :[]=, :set, :delete
+
+      ROOT_SERVICES = begin
+        root_services = [
+          {
+            as: :notifications_fanout,
+            type: Celluloid::Notifications::Fanout,
+          },
+          {
+            as: :incident_reporter,
+            type: Celluloid::IncidentReporter,
+            args: [STDERR],
+          },
+          {
+            as: :public_services,
+            type: Celluloid::Supervision::Service::Public,
+            accessors: [:services],
+            supervise: [],
+          },
+        ]
+        if $CELLULOID_MANAGED
+          root_services << {
+            as: :actor_manager,
+            type: Celluloid::Actor::Manager,
+            accessors: [:manager],
+          }
+        end
+        root_services
+      end
+
+      attr_reader :registry, :group
+
+      # the root of the supervisor tree is established at supervision/root
+
+      def root_services
+        @tree
+      end
+
+      def root_configuration
+        @root
+      end
+
+      def initialize
+        @tree = nil
+        @group = Celluloid.group_class.new
+        @registry = Internals::Registry.new
+        @root = ROOT_SERVICES
+      end
+
+      # Launch default services
+      def start
+        within do
+          @root = Supervision::Service::Root.define
+          @tree = root_configuration.deploy
+          # de root_services[:group_manager].manage! @group
+        end
+        true
+      end
+
+      def within
+        old = Thread.current[:celluloid_actor_system]
+        Thread.current[:celluloid_actor_system] = self
+        yield
+      ensure
+        Thread.current[:celluloid_actor_system] = old
+      end
+
+      def get_thread
+        @group.get do
+          Thread.current[:celluloid_actor_system] = self
+          yield
+        end
+      end
+
+      def stack_dump
+        Internals::Stack::Dump.new(@group)
+      end
+
+      def stack_summary
+        Internals::Stack::Summary.new(@group)
+      end
+
+      def registered
+        @registry.names
+      end
+
+      def clear_registry
+        @registry.clear
+      end
+
+      def running
+        actors = []
+        @group.each do |t|
+          next unless t.role == :actor
+          actor = t.actor
+
+          # NOTE - these are in separate statements, since on JRuby t.actor may
+          # become nil befor .behavior_proxy() is called
+          next unless actor
+          next unless actor.respond_to?(:behavior_proxy)
+          proxy = actor.behavior_proxy
+          actors << proxy
+        end
+        actors
+      end
+
+      def running?
+        @group.active?
+      end
+
+      # Shut down all running actors
+      def shutdown
+        actors = running
+        Timeout.timeout(shutdown_timeout) do
+          Internals::Logger.debug "Terminating #{actors.size} #{(actors.size > 1) ? 'actors' : 'actor'}..." if actors.size > 0
+
+          # Actors cannot self-terminate, you must do it for them
+          actors.each do |actor|
+            begin
+              actor.terminate!
+            rescue DeadActorError
+            end
+          end
+
+          actors.each do |actor|
+            begin
+              Actor.join(actor)
+            rescue DeadActorError
+            end
+          end
+        end
+      rescue Timeout::Error
+        Internals::Logger.error("Couldn't cleanly terminate all actors in #{shutdown_timeout} seconds!")
+        unless RUBY_PLATFORM == "java" || RUBY_ENGINE == "rbx"
+          actors.each do |actor|
+            begin
+              Actor.kill(actor)
+            rescue DeadActorError, MailboxDead
+            end
+          end
+        end
+      ensure
+        @group.shutdown
+        clear_registry
+      end
+
+      def assert_inactive
+        @group.assert_inactive
+      end
+
+      def shutdown_timeout
+        Celluloid.shutdown_timeout
+      end
+    end
+  end
+end