celluloid 0.15.2 → 0.16.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f22a9c7d89b293484d7dcbe03cda32d7055ee42a
-  data.tar.gz: a13abc0b96f0e4931f6ff20457f9665282a4d08b
+  metadata.gz: c9c58eede0a8ebeb315bf6f2fa925e19173dd5e9
+  data.tar.gz: 525f0ae4823a55ca1e23bf1ff5b6c8493592551f
 SHA512:
-  metadata.gz: fba64fd21b7f58cf3fab69cdcfe889b4b95478a5bcad61557b1376e3965bc73583eeaf215be7003e886cc0fdd6a239aa79dd3738cd6ad831ce1c114435da4ff0
-  data.tar.gz: fea6248e5f4e1931485673a458182ca86f380820b2e18acd7d90618203f8c6a193bdf33213161d397153dd43485bb4e1907ff65fb9efd14cc7c6a70cfcb4c309
+  metadata.gz: 2ac75588d4accd17305ea04b6329563783db6972262584898e3143bdf6086ba47dc8bcf8c93ad6c7a8b44115c2c718fbcc615219da968ffdfa8a7a5f17b5f908
+  data.tar.gz: e1185014388060dcd75a41b583a6df01f7bcbb37e21e1619091e364374cb861a31df7c7110b371887540c2482ff54cfae0cf7a3df534fc188157e220d5f8cd12

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011-2014 Tony Arcieri
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -94,6 +94,28 @@ 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
+----------------
+
+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
+* [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
+* [nio4r][nio4r]: "New IO for Ruby": high performance IO selectors
+* [Timers][timers]: A generic Ruby timer library for event-based systems
+
+[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/
+[lattice]: https://github.com/celluloid/lattice/
+[nio4r]: https://github.com/celluloid/nio4r/
+[timers]: https://github.com/celluloid/timers/
+
 Installation
 ------------
 
@@ -131,7 +153,8 @@ Celluloid requires Ruby 1.9 mode on all interpreters.
 Additional Reading
 ------------------
 
-* [Concurrent Object-Oriented Programming in Python with ATOM](http://python.org/workshops/1997-10/proceedings/atom/):
+* [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
@@ -145,5 +168,5 @@ Contributing to Celluloid
 License
 -------
 
-Copyright (c) 2013 Tony Arcieri. Distributed under the MIT License. See
+Copyright (c) 2011-2014 Tony Arcieri. Distributed under the MIT License. See
 LICENSE.txt for further details.

data/lib/celluloid/actor.rb

@@ -1,56 +1,28 @@
+
 require 'timers'
 
 module Celluloid
-  # Don't do Actor-like things outside Actor scope
-  class NotActorError < Celluloid::Error; end
-
-  # Trying to do something to a dead actor
-  class DeadActorError < Celluloid::Error; end
-
-  # A timeout occured before the given request could complete
-  class TimeoutError < Celluloid::Error; end
-
-  # The sender made an error, not the current actor
-  class AbortError < Celluloid::Error
-    attr_reader :cause
-
-    def initialize(cause)
-      @cause = cause
-      super "caused by #{cause.inspect}: #{cause.to_s}"
-    end
-  end
-
-  LINKING_TIMEOUT = 5 # linking times out after 5 seconds
-  OWNER_IVAR = :@celluloid_owner # reference to owning actor
-
   # Actors are Celluloid's concurrency primitive. They're implemented as
   # normal Ruby objects wrapped in threads which communicate with asynchronous
   # messages.
   class Actor
-    attr_reader :subject, :proxy, :tasks, :links, :mailbox, :thread, :name
+    attr_reader :behavior, :proxy, :tasks, :links, :mailbox, :thread, :name, :timers
+    attr_writer :exit_handler
 
     class << self
       extend Forwardable
 
-      def_delegators "Celluloid::Registry.root", :[], :[]=
-
-      def registered
-        Registry.root.names
-      end
-
-      def clear_registry
-        Registry.root.clear
-      end
+      def_delegators "Celluloid.actor_system", :[], :[]=, :delete, :registered, :clear_registry
 
       # Obtain the current actor
       def current
         actor = Thread.current[:celluloid_actor]
         raise NotActorError, "not in actor scope" unless actor
-        actor.proxy
+        actor.behavior_proxy
       end
 
       # Obtain the name of the current actor
-      def name
+      def registered_name
         actor = Thread.current[:celluloid_actor]
         raise NotActorError, "not in actor scope" unless actor
         actor.name
@@ -76,12 +48,7 @@ module Celluloid
 
       # Obtain all running actors in the system
       def all
-        actors = []
-        Celluloid.internal_pool.each do |t|
-          next unless t.role == :actor
-          actors << t.actor.proxy if t.actor && t.actor.respond_to?(:proxy)
-        end
-        actors
+        Celluloid.actor_system.running
       end
 
       # Watch for exit events from another actor
@@ -131,34 +98,44 @@ module Celluloid
       end
     end
 
-    # Wrap the given subject with an Actor
-    def initialize(subject, options = {})
-      @subject = subject
+    def initialize(behavior, options)
+      @behavior         = behavior
 
+      @actor_system     = options.fetch(:actor_system)
       @mailbox          = options.fetch(:mailbox_class, Mailbox).new
       @mailbox.max_size = options.fetch(:mailbox_size, nil)
 
       @task_class   = options[:task_class] || Celluloid.task_class
-      @exit_handler = options[:exit_handler]
-      @exclusives   = options[:exclusive_methods]
-      @receiver_block_executions = options[:receiver_block_executions]
+      @exit_handler = method(:default_exit_handler)
+      @exclusive    = options.fetch(:exclusive, false)
 
       @tasks     = TaskSet.new
       @links     = Links.new
       @signals   = Signals.new
       @receivers = Receivers.new
-      @timers    = Timers.new
-      @running   = true
-      @exclusive = false
+      @timers    = Timers::Group.new
+      @handlers  = Handlers.new
+      @running   = false
       @name      = nil
 
-      @thread = ThreadHandle.new(:actor) do
+      handle(SystemEvent) do |message|
+        handle_system_event message
+      end
+    end
+
+    def start
+      @running = true
+      @thread = ThreadHandle.new(@actor_system, :actor) do
         setup_thread
         run
       end
 
-      @proxy = (options[:proxy_class] || ActorProxy).new(self)
-      @subject.instance_variable_set(OWNER_IVAR, self)
+      @proxy = ActorProxy.new(@thread, @mailbox)
+      Celluloid::Probe.actor_created(self) if $CELLULOID_MONITORING
+    end
+
+    def behavior_proxy
+      @behavior.proxy
     end
 
     def setup_thread
@@ -168,18 +145,16 @@ module Celluloid
 
     # Run the actor loop
     def run
-      begin
-        while @running
-          if message = @mailbox.receive(timeout_interval)
-            handle_message message
-          else
-            # No message indicates a timeout
-            @timers.fire
-            @receivers.fire_timers
-          end
+      while @running
+        begin
+          message = @mailbox.receive(timeout_interval)
+          handle_message message
+        rescue TimeoutError
+          @timers.fire
+          @receivers.fire_timers
+        rescue MailboxShutdown
+          @running = false
         end
-      rescue MailboxShutdown
-        # If the mailbox detects shutdown, exit the actor
       end
 
       shutdown
@@ -196,31 +171,37 @@ module Celluloid
     # Perform a linking request with another actor
     def linking_request(receiver, type)
       Celluloid.exclusive do
-        start_time = Time.now
+        linking_timeout = Timers::Timeout.new(LINKING_TIMEOUT)
+
         receiver.mailbox << LinkingRequest.new(Actor.current, type)
         system_events = []
 
-        loop do
-          wait_interval = start_time + LINKING_TIMEOUT - Time.now
-          message = @mailbox.receive(wait_interval) do |msg|
-            msg.is_a?(LinkingResponse) &&
-            msg.actor.mailbox.address == receiver.mailbox.address &&
-            msg.type == type
+        linking_timeout.while_time_remaining do |remaining|
+          begin
+            message = @mailbox.receive(remaining) do |msg|
+              msg.is_a?(LinkingResponse) &&
+              msg.actor.mailbox.address == receiver.mailbox.address &&
+              msg.type == type
+            end
+          rescue TimeoutError
+            next # IO reactor did something, no message in queue yet.
           end
 
-          case message
-          when LinkingResponse
+          if message.instance_of? LinkingResponse
+            Celluloid::Probe.actors_linked(self, receiver) if $CELLULOID_MONITORING
+
             # We're done!
-            system_events.each { |ev| handle_system_event(ev) }
+            system_events.each { |ev| @mailbox << ev }
+
             return
-          when NilClass
-            raise TimeoutError, "linking timeout of #{LINKING_TIMEOUT} seconds exceeded"
-          when SystemEvent
+          elsif message.is_a? SystemEvent
             # Queue up pending system events to be processed after we've successfully linked
             system_events << message
-          else raise 'wtf'
+          else raise "Unexpected message type: #{message.class}. Expected LinkingResponse, NilClass, SystemEvent."
           end
         end
+
+        raise TimeoutError, "linking timeout of #{LINKING_TIMEOUT} seconds exceeded"
       end
     end
 
@@ -234,6 +215,10 @@ module Celluloid
       @signals.wait name
     end
 
+    def handle(*patterns, &block)
+      @handlers.handle(*patterns, &block)
+    end
+
     # Receive an asynchronous message
     def receive(timeout = nil, &block)
       loop do
@@ -304,28 +289,7 @@ module Celluloid
 
     # Handle standard low-priority messages
     def handle_message(message)
-      case message
-      when SystemEvent
-        handle_system_event message
-      when Call
-        meth = message.method
-        if meth == :__send__
-          meth = message.arguments.first
-        end
-        if @receiver_block_executions && meth
-          if @receiver_block_executions.include?(meth.to_sym)
-            message.execute_block_on_receiver
-          end
-        end
-
-        task(:call, :method_name => meth, :dangerous_suspend => meth == :initialize) {
-          message.dispatch(@subject)
-        }
-      when BlockCall
-        task(:invoke_block) { message.dispatch }
-      when BlockResponse, Response
-        message.dispatch
-      else
+      unless @handlers.handle_message(message)
         unless @receivers.handle_message(message)
           Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
         end
@@ -335,17 +299,19 @@ module Celluloid
 
     # Handle high-priority system event messages
     def handle_system_event(event)
-      case event
-      when ExitEvent
-        task(:exit_handler, :method_name => @exit_handler) { handle_exit_event event }
-      when LinkingRequest
+      if event.instance_of? ExitEvent
+        handle_exit_event(event)
+      elsif event.instance_of? LinkingRequest
         event.process(links)
-      when NamingRequest
+      elsif event.instance_of? NamingRequest
         @name = event.name
-      when TerminationRequest
+        Celluloid::Probe.actor_named(self) if $CELLULOID_MONITORING
+      elsif event.instance_of? TerminationRequest
         terminate
-      when SignalConditionRequest
+      elsif event.instance_of? SignalConditionRequest
         event.call
+      else
+        Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DEBUG
       end
     end
 
@@ -353,47 +319,34 @@ module Celluloid
     def handle_exit_event(event)
       @links.delete event.actor
 
-      # Run the exit handler if available
-      return @subject.send(@exit_handler, event.actor, event.reason) if @exit_handler
+      @exit_handler.call(event)
+    end
 
-      # Reraise exceptions from linked actors
-      # If no reason is given, actor terminated cleanly
+    def default_exit_handler(event)
       raise event.reason if event.reason
     end
 
     # Handle any exceptions that occur within a running actor
     def handle_crash(exception)
-      Logger.crash("#{@subject.class} crashed!", exception)
-      shutdown ExitEvent.new(@proxy, exception)
+      # TODO: add meta info
+      Logger.crash("Actor crashed!", exception)
+      shutdown ExitEvent.new(behavior_proxy, exception)
     rescue => ex
-      Logger.crash("#{@subject.class}: ERROR HANDLER CRASHED!", ex)
+      Logger.crash("ERROR HANDLER CRASHED!", ex)
     end
 
     # Handle cleaning up this actor after it exits
-    def shutdown(exit_event = ExitEvent.new(@proxy))
-      run_finalizer
+    def shutdown(exit_event = ExitEvent.new(behavior_proxy))
+      @behavior.shutdown
       cleanup exit_event
     ensure
       Thread.current[:celluloid_actor]   = nil
       Thread.current[:celluloid_mailbox] = nil
     end
 
-    # Run the user-defined finalizer, if one is set
-    def run_finalizer
-      finalizer = @subject.class.finalizer
-      return unless finalizer && @subject.respond_to?(finalizer, true)
-
-      task(:finalizer, :method_name => finalizer, :dangerous_suspend => true) do
-        begin
-          @subject.__send__(finalizer)
-        rescue => ex
-          Logger.crash("#{@subject.class}#finalize crashed!", ex)
-        end
-      end
-    end
-
     # Clean up after this actor
     def cleanup(exit_event)
+      Celluloid::Probe.actor_died(self) if $CELLULOID_MONITORING
       @mailbox.shutdown
       @links.each do |actor|
         if actor.mailbox.alive?
@@ -401,16 +354,16 @@ module Celluloid
         end
       end
 
-      tasks.to_a.each { |task| task.terminate }
+      tasks.to_a.each(&:terminate)
     rescue => ex
-      Logger.crash("#{@subject.class}: CLEANUP CRASHED!", ex)
+      # TODO: metadata
+      Logger.crash("CLEANUP CRASHED!", ex)
     end
 
     # Run a method inside a task unless it's exclusive
     def task(task_type, meta = nil)
-      method_name = meta && meta.fetch(:method_name, nil)
       @task_class.new(task_type, meta) {
-        if @exclusives && (@exclusives == :all || (method_name && @exclusives.include?(method_name.to_sym)))
+        if @exclusive
           Celluloid.exclusive { yield }
         else
           yield

data/lib/celluloid/actor_system.rb

@@ -0,0 +1,107 @@
+module Celluloid
+  class ActorSystem
+    extend Forwardable
+
+    def initialize
+      @internal_pool = InternalPool.new
+      @registry      = Registry.new
+    end
+    attr_reader :registry
+
+    # Launch default services
+    # FIXME: We should set up the supervision hierarchy here
+    def start
+      within do
+        Celluloid::Notifications::Fanout.supervise_as :notifications_fanout
+        Celluloid::IncidentReporter.supervise_as :default_incident_reporter, STDERR
+      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
+      @internal_pool.get do
+        Thread.current[:celluloid_actor_system] = self
+        yield
+      end
+    end
+
+    def stack_dump
+      Celluloid::StackDump.new(@internal_pool)
+    end
+
+    def_delegators "@registry", :[], :get, :[]=, :set, :delete
+
+    def registered
+      @registry.names
+    end
+
+    def clear_registry
+      @registry.clear
+    end
+
+    def running
+      actors = []
+      @internal_pool.each do |t|
+        next unless t.role == :actor
+        actors << t.actor.behavior_proxy if t.actor && t.actor.respond_to?(:behavior_proxy)
+      end
+      actors
+    end
+
+    def running?
+      @internal_pool.running?
+    end
+
+    # Shut down all running actors
+    def shutdown
+      actors = running
+      Timeout.timeout(shutdown_timeout) do
+        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
+
+        @internal_pool.shutdown
+      end
+    rescue Timeout::Error
+      Logger.error("Couldn't cleanly terminate all actors in #{shutdown_timeout} seconds!")
+      actors.each do |actor|
+        begin
+          Actor.kill(actor)
+        rescue DeadActorError, MailboxDead
+        end
+      end
+    ensure
+      @internal_pool.kill
+      clear_registry
+    end
+
+    def assert_inactive
+      @internal_pool.assert_inactive
+    end
+
+    def shutdown_timeout
+      Celluloid.shutdown_timeout
+    end
+  end
+end

data/lib/celluloid/call_chain.rb

@@ -10,4 +10,4 @@ module Celluloid
       Thread.current[:celluloid_chain_id]
     end
   end
- end
+end

data/lib/celluloid/calls.rb

@@ -21,32 +21,28 @@ module Celluloid
     end
 
     def dispatch(obj)
+      check(obj)
       _block = @block && @block.to_proc
       obj.public_send(@method, *@arguments, &_block)
-    rescue NoMethodError => ex
-      # Abort if the sender made a mistake
-      raise AbortError.new(ex) unless obj.respond_to? @method
-
-      # Otherwise something blew up. Crash this actor
-      raise
-    rescue ArgumentError => ex
-      # Abort if the sender made a mistake
+    end
+
+    def check(obj)
+      raise NoMethodError, "undefined method `#{@method}' for #{obj.inspect}" unless obj.respond_to? @method
+
       begin
         arity = obj.method(@method).arity
       rescue NameError
-        # In theory this shouldn't happen, but just in case
-        raise AbortError.new(ex)
+        return
       end
 
       if arity >= 0
-        raise AbortError.new(ex) if @arguments.size != arity
+        raise ArgumentError, "wrong number of arguments (#{@arguments.size} for #{arity})" if @arguments.size != arity
       elsif arity < -1
         mandatory_args = -arity - 1
-        raise AbortError.new(ex) if arguments.size < mandatory_args
+        raise ArgumentError, "wrong number of arguments (#{@arguments.size} for #{mandatory_args}+)" if arguments.size < mandatory_args
       end
-
-      # Otherwise something blew up. Crash this actor
-      raise
+    rescue => ex
+      raise AbortError.new(ex)
     end
   end
 
@@ -88,8 +84,12 @@ module Celluloid
       @sender << message
     end
 
+    def response
+      Celluloid.suspend(:callwait, self)
+    end
+
     def value
-      Celluloid.suspend(:callwait, self).value
+      response.value
     end
 
     def wait