celluloid 0.6.0 → 0.6.1

data/README.md

@@ -329,6 +329,35 @@ working, freshly-restarted version.
 The main use of the registry is for interfacing with actors that are
 automatically restarted by supervisors when they crash.
 
+Applications
+------------
+
+Celluloid provides a DSL for describing all of the actors in a given
+application. This lets you start a group of actors in one swoop and
+also provides an additional level of supervision: applications supervise
+the supervisors of all the actors in your system, an approach known
+as supervision trees.
+
+Define Celluloid::Applications with the following syntax:
+
+    class MyApplication < Celluloid::Application
+      supervise MyActor, :as => :my_actor
+      supervise AnotherActor, :as => :another_actor
+    end
+
+This will start the MyActor and AnotherActor actors under a supervisor and
+automatically register them as Celluloid::Actor[:my_actor] and
+Celluloid::Actor[:another_actor].
+
+To launch your application, do:
+
+    MyApplication.run
+
+This launches your application in the foreground. To launch in in the
+background, do:
+
+    MyApplication.run!
+
 Signaling
 ---------
 
@@ -458,9 +487,11 @@ Here are a few rules you can follow to keep this from happening:
 
 1. ***NEVER RETURN SELF*** (or pass self as an argument to other actors): in
    cases where you want to pass an actor around to other actors or threads,
-   use Celluloid.current_actor. If you grab the latest master of Celluloid
-   off of Github, you can just use the #current_actor method when you are
-   inside of an actor itself.
+   use Celluloid.current_actor, or if you're within an actor itself, you can
+   just call the #current_actor method. If you really need to get ahold of
+   "self" in order to add instance-specific behavior, e.g for metaprogramming
+   purposes or adding stubs during tests, call MyActor#wrapped_object to
+   obtain the actual object an actor is wrapping.
 
 2. Don't mutate the state of objects you've sent in calls to other actors:
    This means you must think about data in one of two different ways: either

data/lib/celluloid.rb

@@ -1,6 +1,5 @@
 require 'logger'
 require 'thread'
-require 'celluloid/fibers_are_hard'
 
 module Celluloid
   @logger = Logger.new STDERR
@@ -9,8 +8,7 @@ module Celluloid
     attr_accessor :logger # Thread-safe logger class
 
     def included(klass)
-      klass.send :extend,  ClassMethods
-      klass.send :include, Linking
+      klass.send :extend, ClassMethods
     end
 
     # Are we currently inside of an actor?
@@ -20,10 +18,10 @@ module Celluloid
 
     # Obtain the currently running actor (if one exists)
     def current_actor
-      actor = Thread.current[:actor_proxy]
+      actor = Thread.current[:actor]
       raise NotActorError, "not in actor scope" unless actor
 
-      actor
+      actor.proxy
     end
 
     # Receive an asynchronous message
@@ -32,33 +30,13 @@ module Celluloid
       if actor
         actor.receive(&block)
       else
-        Thread.current.mailbox.receive(&block)
-      end
-    end
-
-    # Create a fiber that participates in the Celluloid protocol
-    def fiber(*args)
-      actor   = Thread.current[:actor]
-      proxy   = Thread.current[:actor_proxy]
-      mailbox = Thread.current[:mailbox]
-
-      Fiber.new do
-        Thread.current[:actor]       = actor
-        Thread.current[:actor_proxy] = proxy
-        Thread.current[:mailbox]     = mailbox
-
-        yield(*args)
+        Thread.mailbox.receive(&block)
       end
     end
 
     # Resume a fiber that participates in the Celluloid protocol
     def resume_fiber(fiber, value = nil)
-      actor = Thread.current[:actor]
-      if actor
-        actor.run_fiber fiber, value
-      else
-        fiber.resume value
-      end
+      fiber.resume value
     end
   end
 
@@ -74,7 +52,7 @@ module Celluloid
 
     # Create a new actor and link to the current one
     def new_link(*args, &block)
-      current_actor = Thread.current[:actor]
+      current_actor = Celluloid.current_actor
       raise NotActorError, "can't link outside actor context" unless current_actor
 
       proxy = Celluloid::Actor.new(allocate).proxy
@@ -165,6 +143,36 @@ module Celluloid
   # be shared with at least the actor thread. Tread carefully.
   def wrapped_object; self; end
 
+  # Obtain the Celluloid::Links for this actor
+  def links
+    Thread.current[:actor].links
+  end
+
+  # Link this actor to another, allowing it to crash or react to errors
+  def link(actor)
+    actor.notify_link current_actor
+    notify_link actor
+  end
+
+  # Remove links to another actor
+  def unlink(actor)
+    actor.notify_unlink current_actor
+    notify_unlink actor
+  end
+
+  def notify_link(actor)
+    links << actor
+  end
+
+  def notify_unlink(actor)
+    links.delete actor
+  end
+
+  # Is this actor linked to another?
+  def linked_to?(actor)
+    Thread.current[:actor].links.include? actor
+  end
+
   # Receive an asynchronous message via the actor protocol
   def receive(&block)
     Celluloid.receive(&block)
@@ -207,7 +215,8 @@ require 'celluloid/actor_proxy'
 require 'celluloid/calls'
 require 'celluloid/core_ext'
 require 'celluloid/events'
-require 'celluloid/linking'
+require 'celluloid/fiber'
+require 'celluloid/links'
 require 'celluloid/mailbox'
 require 'celluloid/receivers'
 require 'celluloid/registry'

data/lib/celluloid/actor.rb

@@ -20,7 +20,6 @@ module Celluloid
   # messages.
   class Actor
     extend Registry
-    include Linking
 
     attr_reader :proxy
     attr_reader :links
@@ -28,8 +27,7 @@ module Celluloid
 
     # Invoke a method on the given actor via its mailbox
     def self.call(mailbox, meth, *args, &block)
-      our_mailbox = Thread.current.mailbox
-      call = SyncCall.new(our_mailbox, meth, args, block)
+      call = SyncCall.new(Thread.mailbox, meth, args, block)
 
       begin
         mailbox << call
@@ -42,8 +40,8 @@ module Celluloid
         response = Fiber.yield(call)
       else
         # Otherwise we're inside a normal thread, so block
-        response = our_mailbox.receive do |msg|
-          msg.is_a? Response and msg.call_id == call.id
+        response = Thread.mailbox.receive do |msg|
+          msg.respond_to?(:call_id) and msg.call_id == call.id
         end
       end
 
@@ -52,9 +50,8 @@ module Celluloid
 
     # Invoke a method asynchronously on an actor via its mailbox
     def self.async(mailbox, meth, *args, &block)
-      our_mailbox = Thread.current.mailbox
       begin
-        mailbox << AsyncCall.new(our_mailbox, meth, args, block)
+        mailbox << AsyncCall.new(Thread.mailbox, meth, args, block)
       rescue MailboxError
         # Silently swallow asynchronous calls to dead actors. There's no way
         # to reliably generate DeadActorErrors for async calls, so users of
@@ -76,14 +73,13 @@ module Celluloid
       @links     = Links.new
       @signals   = Signals.new
       @receivers = Receivers.new
-      @proxy     = ActorProxy.new(@mailbox)
+      @proxy     = ActorProxy.new(@mailbox, self.class.to_s)
       @running   = true
       @pending_calls = {}
 
       @thread = Pool.get do
-        Thread.current[:actor]       = self
-        Thread.current[:actor_proxy] = @proxy
-        Thread.current[:mailbox]     = @mailbox
+        Thread.current[:actor]   = self
+        Thread.current[:mailbox] = @mailbox
 
         run
       end
@@ -121,8 +117,7 @@ module Celluloid
         begin
           message = @mailbox.receive
         rescue ExitEvent => exit_event
-          fiber = Celluloid.fiber { handle_exit_event exit_event; nil }
-          run_fiber fiber
+          Celluloid::Fiber.new { handle_exit_event exit_event; nil }.resume
           retry
         end
 
@@ -140,29 +135,22 @@ module Celluloid
       Pool.put @thread
     end
 
-    # Run a method, handling when its Fiber is suspended
-    def run_fiber(fiber, value = nil)
-      result = fiber.resume value
-      if result.is_a? Celluloid::Call
-        @pending_calls[result.id] = fiber if fiber.alive?
-      elsif result
-        warning = "non-call returned from fiber: #{result.class}"
-        Celluloid.logger.debug warning if Celluloid.logger
-      end
-      nil
+    # Register a fiber waiting for the response to a Celluloid::Call
+    def register_fiber(call, fiber)
+      raise ArgumentError, "attempted to register a dead fiber" unless fiber.alive?
+      @pending_calls[call.id] = fiber
     end
 
     # Handle an incoming message
     def handle_message(message)
       case message
       when Call
-        fiber = Celluloid.fiber { message.dispatch(@subject); nil }
-        run_fiber fiber
+        Celluloid::Fiber.new { message.dispatch(@subject); nil }.resume
       when Response
         fiber = @pending_calls.delete(message.call_id)
 
         if fiber
-          run_fiber fiber, message
+          fiber.resume message
         else
           warning = "spurious response to call #{message.call_id}"
           Celluloid.logger.debug if Celluloid.logger

data/lib/celluloid/actor_proxy.rb

@@ -13,6 +13,10 @@ module Celluloid
       Actor.call @mailbox, :send, meth, *args, &block
     end
 
+    def class
+      Actor.call @mailbox, :send, :class
+    end
+
     def respond_to?(meth)
       Actor.call @mailbox, :respond_to?, meth
     end

data/lib/celluloid/calls.rb

@@ -87,7 +87,7 @@ module Celluloid
       obj.send(@method, *@arguments, &@block)
     rescue AbortError => ex
       # Swallow aborted async calls, as they indicate the caller made a mistake
-      obj.log_error ex, "#{obj.class}: async call aborted!"
+      log_error ex, "#{obj.class}: async call aborted!"
     end
     
     def log_error(ex, message)

data/lib/celluloid/core_ext.rb

@@ -1,13 +1,7 @@
 # Monkeypatch Thread to allow lazy access to its Celluloid::Mailbox
 class Thread
-  # Retrieve the current mailbox or lazily initialize it
-  def mailbox
-    self[:mailbox] || begin
-      if Thread.current != self
-        raise "attempt to access an uninitialized mailbox"
-      end
-
-      self[:mailbox] = Celluloid::Mailbox.new
-    end
+  # Retrieve the mailbox for the current thread or lazily initialize it
+  def self.mailbox
+    current[:mailbox] ||= Celluloid::Mailbox.new
   end
 end

data/lib/celluloid/{fibers_are_hard.rb → fiber.rb}

@@ -1,4 +1,4 @@
-# Let's go shopping!
+# Every time I look at this code a little part of me dies...
 begin
   require 'fiber'
 rescue LoadError => ex
@@ -31,3 +31,33 @@ rescue LoadError => ex
     raise ex
   end
 end
+
+module Celluloid
+  class Fiber < ::Fiber
+    def initialize(*args)
+      actor   = Thread.current[:actor]
+      mailbox = Thread.current[:mailbox]
+
+      super do
+        Thread.current[:actor]   = actor
+        Thread.current[:mailbox] = mailbox
+
+        yield(*args)
+      end
+    end
+
+    def resume(value = nil)
+      result = super
+      actor = Thread.current[:actor]
+      return result unless actor
+
+      if result.is_a? Celluloid::Call
+        actor.register_fiber result, self
+      elsif result
+        warning = "non-call returned from fiber: #{result.class}"
+        Celluloid.logger.debug warning if Celluloid.logger
+      end
+      nil
+    end
+  end
+end

data/lib/celluloid/io/reactor.rb

@@ -32,7 +32,7 @@ module Celluloid
         [[readers, @readers], [writers, @writers]].each do |ios, registered|
           ios.each do |io|
             fiber = registered.delete io
-            Celluloid.resume_fiber(fiber) if fiber
+            fiber.resume if fiber
           end
         end
       end

data/lib/celluloid/links.rb

@@ -0,0 +1,61 @@
+require 'thread'
+
+module Celluloid
+  # Thread safe storage of inter-actor links
+  class Links
+    include Enumerable
+
+    def initialize
+      @links = {}
+      @lock  = Mutex.new
+    end
+
+    # Add an actor to the current links
+    def <<(actor)
+      @lock.synchronize do
+        @links[actor.mailbox.address] = actor
+      end
+      actor
+    end
+
+    # Do links include the given actor?
+    def include?(actor)
+      @lock.synchronize do
+        @links.has_key? actor.mailbox.address
+      end
+    end
+
+    # Remove an actor from the links
+    def delete(actor)
+      @lock.synchronize do
+        @links.delete actor.mailbox.address
+      end
+      actor
+    end
+
+    # Iterate through all links
+    def each
+      @lock.synchronize do
+        @links.each { |_, actor| yield(actor) }
+      end
+    end
+
+    # Map across links
+    def map
+      result = []
+      each { |actor| result << yield(actor) }
+      result
+    end
+
+    # Send an event message to all actors
+    def send_event(event)
+      each { |actor| actor.mailbox.system_event event }
+    end
+
+    # Generate a string representation
+    def inspect
+      links = self.map(&:inspect).join(',')
+      "#<#{self.class}[#{links}]>"
+    end
+  end
+end

data/lib/celluloid/mailbox.rb

@@ -9,6 +9,9 @@ module Celluloid
   class Mailbox
     include Enumerable
 
+    # A unique address at which this mailbox can be found
+    alias_method :address, :object_id
+
     def initialize
       @messages = []
       @lock  = Mutex.new

data/lib/celluloid/receivers.rb

@@ -26,7 +26,7 @@ module Celluloid
 
       if handler
         fiber, _ = @handlers.delete_at handler
-        Celluloid.resume_fiber fiber, message
+        fiber.resume message
         true
       else
         false

data/lib/celluloid/signals.rb

@@ -18,10 +18,8 @@ module Celluloid
       fibers = @waiting.delete name
       return unless fibers
       
-      fibers.each do |fiber|
-        Celluloid.resume_fiber fiber, value
-      end
-      true
+      fibers.each { |fiber| fiber.resume value }
+      value
     end
   end
 end

data/lib/celluloid/supervisor.rb

@@ -26,11 +26,16 @@ module Celluloid
 
       begin
         @actor = @klass.new_link(*@args, &@block)
-      rescue
+      rescue => ex
         failures += 1
         if failures >= start_attempts
           failures = 0
-          Celluloid.logger.warn "#{@klass} is crashing on initialize repeatedly, sleeping for #{sleep_interval} seconds"
+
+          warning = "#{@klass} is crashing on initialize repeatedly, sleeping for #{sleep_interval} seconds\n"
+          warning << "#{ex.class}: #{ex}\n  "
+          warning << "#{ex.backtrace.join("\n  ")}"
+
+          Celluloid.logger.warn warning if Celluloid.logger
           sleep sleep_interval
         end
         retry

data/lib/celluloid/version.rb

@@ -1,4 +1,4 @@
 module Celluloid
-  VERSION = '0.6.0'
+  VERSION = '0.6.1'
   def self.version; VERSION; end
 end

metadata

@@ -1,38 +1,38 @@
 --- !ruby/object:Gem::Specification
 name: celluloid
 version: !ruby/object:Gem::Version
-  prerelease:
-  version: 0.6.0
+  version: 0.6.1
+  prerelease: 
 platform: ruby
 authors:
 - Tony Arcieri
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-19 00:00:00.000000000Z
+date: 2011-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  version_requirements: &2056 !ruby/object:Gem::Requirement
+  requirement: &70242345718900 !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  requirement: *2056
-  prerelease: false
   type: :development
+  prerelease: false
+  version_requirements: *70242345718900
 - !ruby/object:Gem::Dependency
   name: rspec
-  version_requirements: &2074 !ruby/object:Gem::Requirement
+  requirement: &70242345718300 !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.7.0
-    none: false
-  requirement: *2074
-  prerelease: false
   type: :development
+  prerelease: false
+  version_requirements: *70242345718300
 description: Celluloid is a concurrent object framework inspired by the Actor Model
 email:
 - tony@medioh.com
@@ -41,7 +41,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
-- lib/celluloid.rb
 - lib/celluloid/actor.rb
 - lib/celluloid/actor_pool.rb
 - lib/celluloid/actor_proxy.rb
@@ -49,10 +48,13 @@ files:
 - lib/celluloid/calls.rb
 - lib/celluloid/core_ext.rb
 - lib/celluloid/events.rb
-- lib/celluloid/fibers_are_hard.rb
+- lib/celluloid/fiber.rb
 - lib/celluloid/future.rb
+- lib/celluloid/io/mailbox.rb
+- lib/celluloid/io/reactor.rb
+- lib/celluloid/io/waker.rb
 - lib/celluloid/io.rb
-- lib/celluloid/linking.rb
+- lib/celluloid/links.rb
 - lib/celluloid/mailbox.rb
 - lib/celluloid/receivers.rb
 - lib/celluloid/registry.rb
@@ -62,34 +64,31 @@ files:
 - lib/celluloid/supervisor.rb
 - lib/celluloid/tcp_server.rb
 - lib/celluloid/version.rb
-- lib/celluloid/io/mailbox.rb
-- lib/celluloid/io/reactor.rb
-- lib/celluloid/io/waker.rb
+- lib/celluloid.rb
 homepage: https://github.com/tarcieri/celluloid
 licenses:
 - MIT
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.3.6
-  none: false
 requirements: []
-rubyforge_project:
-rubygems_version: 1.8.9
-signing_key:
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
 specification_version: 3
 summary: Celluloid is a concurrent object framework inspired by the Actor Model
 test_files: []
-has_rdoc:
-...
+has_rdoc: 

data/lib/celluloid/linking.rb

@@ -1,89 +0,0 @@
-require 'set'
-require 'thread'
-
-module Celluloid
-  # Thread safe storage of inter-actor links
-  class Links
-    include Enumerable
-
-    def initialize
-      @links = Set.new
-      @lock  = Mutex.new
-    end
-
-    # Add an actor to the current links
-    def <<(actor)
-      @lock.synchronize do
-        @links << actor
-      end
-      actor
-    end
-
-    # Do links include the given actor?
-    def include?(actor)
-      @lock.synchronize do
-        @links.include? actor
-      end
-    end
-
-    # Remove an actor from the links
-    def delete(actor)
-      @lock.synchronize do
-        @links.delete actor
-      end
-      actor
-    end
-
-    # Iterate through all links
-    def each(&block)
-      @lock.synchronize do
-        @links.each(&block)
-      end
-    end
-
-    # Send an event message to all actors
-    def send_event(event)
-      each { |actor| actor.mailbox.system_event event }
-    end
-
-    # Generate a string representation
-    def inspect
-      @lock.synchronize do
-        links = @links.to_a.map { |l| "#{l.class}:#{l.object_id}" }.join(',')
-        "#<#{self.class}[#{links}]>"
-      end
-    end
-  end
-
-  # Support for linking actors together so they can crash or react to errors
-  module Linking
-    # Link this actor to another, allowing it to crash or react to errors
-    def link(actor)
-      current_actor = Thread.current[:actor]
-
-      actor.notify_link(current_actor.proxy)
-      current_actor.notify_link(actor)
-    end
-
-    # Remove links to another actor
-    def unlink(actor)
-      current_actor = Thread.current[:actor]
-
-      actor.notify_unlink(current_actor.proxy)
-      current_actor.notify_unlink(actor)
-    end
-
-    def notify_link(actor)
-      Thread.current[:actor].links << actor
-    end
-
-    def notify_unlink(actor)
-      Thread.current[:actor].links.delete actor
-    end
-
-    # Is this actor linked to another?
-    def linked_to?(actor)
-      Thread.current[:actor].links.include? actor
-    end
-  end
-end