celluloid 0.7.2 → 0.8.0

data/README.md

@@ -12,7 +12,7 @@ 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:
 
-* __Look ma, no mutexes:__ Celluloid automatically synchronizes access to instance
+* __Automatic synchronization:__ Celluloid synchronizes access to instance
   variables by using a special proxy object system and messaging model.
 * __[Futures](https://github.com/tarcieri/celluloid/wiki/futures):__
   Ever wanted to call a method "in the background" and retrieve the
@@ -40,12 +40,15 @@ _asynchronously_, so the receiver to do things in the background for you
 without the caller having to sit around waiting for the result.
 
 You can also build distributed systems with Celluloid using its
-[sister project DCell](https://github.com/tarcieri/dcell).
+[sister project DCell](https://github.com/tarcieri/dcell). Evented IO similar
+to EventMachine (albeit with a synchronous API) is available through the
+[Celluloid::IO](https://github.com/tarcieri/celluloid-io) library.
 
 [Please see the Celluloid Wiki](https://github.com/tarcieri/celluloid/wiki)
 for more detailed documentation and usage notes.
 
 Like Celluloid? [Join the Google Group](http://groups.google.com/group/celluloid-ruby)
+or visit us on IRC at #celluloid on freenode
 
 Supported Platforms
 -------------------
@@ -144,5 +147,5 @@ Contributing to Celluloid
 License
 -------
 
-Copyright (c) 2011 Tony Arcieri. Distributed under the MIT License. See
+Copyright (c) 2012 Tony Arcieri. Distributed under the MIT License. See
 LICENSE.txt for further details.

data/lib/celluloid.rb

@@ -43,13 +43,6 @@ module Celluloid
         Kernel.sleep interval
       end
     end
-
-    # Obtain a hash of active tasks to their current activities
-    def tasks
-      actor = Thread.current[:actor]
-      raise NotActorError, "not in actor scope" unless actor
-      actor.tasks
-    end
   end
 
   # Class methods added to classes which include Celluloid
@@ -150,7 +143,7 @@ module Celluloid
 
   # Obtain the running tasks for this actor
   def tasks
-    Celluloid.tasks
+    Thread.current[:actor].tasks.to_a
   end
 
   # Obtain the Ruby object the actor is wrapping. This should ONLY be used
@@ -208,12 +201,17 @@ module Celluloid
   # Perform a blocking or computationally intensive action inside an
   # asynchronous thread pool, allowing the caller to continue processing other
   # messages in its mailbox in the meantime
-  def async(&block)
+  def defer(&block)
     # This implementation relies on the present implementation of
     # Celluloid::Future, which uses an Actor to run the block
     Future.new(&block).value
   end
 
+  # Deprecated, do not use
+  def async
+    raise "Celluloid#async is defunct. Please use #defer instead"
+  end
+
   # Process async calls via method_missing
   def method_missing(meth, *args, &block)
     # bang methods are async calls
@@ -253,9 +251,9 @@ require 'celluloid/responses'
 require 'celluloid/signals'
 require 'celluloid/task'
 require 'celluloid/timers'
+require 'celluloid/thread_pool'
 
 require 'celluloid/actor'
-require 'celluloid/actor_pool'
-require 'celluloid/supervisor'
 require 'celluloid/future'
-require 'celluloid/application'
+require 'celluloid/group'
+require 'celluloid/supervisor'

data/lib/celluloid/actor.rb

@@ -20,10 +20,7 @@ module Celluloid
   # messages.
   class Actor
     extend Registry
-
-    attr_reader :proxy
-    attr_reader :links
-    attr_reader :mailbox
+    attr_reader :proxy, :tasks, :links, :mailbox
 
     # Invoke a method on the given actor via its mailbox
     def self.call(mailbox, meth, *args, &block)
@@ -36,15 +33,16 @@ module Celluloid
       end
 
       if Celluloid.actor?
-        response = Thread.current[:actor].wait [:call, call.id]
+        # The current task will be automatically resumed when we get a response
+        Task.suspend :callwait
       else
         # Otherwise we're inside a normal thread, so block
         response = Thread.mailbox.receive do |msg|
-          msg.respond_to?(:call_id) and msg.call_id == call.id
+          msg.respond_to?(:call) and msg.call == call
         end
-      end
 
-      response.value
+        response.value
+      end
     end
 
     # Invoke a method asynchronously on an actor via its mailbox
@@ -59,6 +57,13 @@ module Celluloid
       end
     end
 
+    # Call a method asynchronously and retrieve its value later
+    def self.future(mailbox, meth, *args, &block)
+      future = Future.new
+      future.execute(mailbox, meth, args, block)
+      future
+    end
+
     # Wrap the given subject with an Actor
     def initialize(subject)
       @subject = subject
@@ -69,14 +74,15 @@ module Celluloid
         @mailbox = Mailbox.new
       end
 
+      @proxy     = ActorProxy.new(@mailbox, subject.class.to_s)
+      @tasks     = Set.new
       @links     = Links.new
       @signals   = Signals.new
       @receivers = Receivers.new
       @timers    = Timers.new
-      @proxy     = ActorProxy.new(@mailbox, subject.class.to_s)
       @running   = true
 
-      @thread = Pool.get do
+      @thread = ThreadPool.get do
         Thread.current[:actor]   = self
         Thread.current[:mailbox] = @mailbox
 
@@ -137,7 +143,7 @@ module Celluloid
       @running = false
       handle_crash(ex)
     ensure
-      Pool.put @thread
+      ThreadPool.put @thread
     end
 
     # How long to wait until the next timer fires
@@ -154,27 +160,6 @@ module Celluloid
       end
     end
 
-    # Obtain a hash of tasks that are currently waiting
-    def tasks
-      # A hash of tasks to what they're waiting on is more meaningful to the
-      # end-user, and lets us make a copy of the tasks table, rather than
-      # handing them the one we're using internally across threads, a definite
-      # thread safety shared state no-no
-      tasks = {}
-      current_task = Task.current rescue nil
-      tasks[current_task] = :running if current_task
-
-      @signals.waiting.each do |waitable, waiters|
-        if waiters.is_a? Enumerable
-          waiters.each { |waiter| tasks[waiter] = waitable }
-        else
-          tasks[waiters] = waitable
-        end
-      end
-
-      tasks
-    end
-
     # Schedule a block to run at the given time
     def after(interval)
       @timers.add(interval) do
@@ -186,7 +171,7 @@ module Celluloid
     def sleep(interval)
       task = Task.current
       @timers.add(interval) { task.resume }
-      Task.suspend
+      Task.suspend :sleeping
     end
 
     # Handle an incoming message
@@ -195,11 +180,7 @@ module Celluloid
       when Call
         Task.new(:message_handler) { message.dispatch(@subject) }.resume
       when Response
-        handled_successfully = signal [:call, message.call_id], message
-
-        unless handled_successfully
-          Logger.debug("anomalous message! spurious response to call #{message.call_id}")
-        end
+        message.call.task.resume message.value
       else
         @receivers.handle_message(message)
       end
@@ -230,7 +211,7 @@ module Celluloid
     def cleanup(exit_event)
       @mailbox.shutdown
       @links.send_event exit_event
-      tasks.each { |task, _| task.terminate }
+      tasks.each { |task| task.terminate }
 
       begin
         @subject.finalize if @subject.respond_to? :finalize

data/lib/celluloid/actor_proxy.rb

@@ -41,7 +41,7 @@ module Celluloid
 
     # Create a Celluloid::Future which calls a given method
     def future(method_name, *args, &block)
-      Future.new { Actor.call @mailbox, method_name, *args, &block }
+      Actor.future @mailbox, method_name, *args, &block
     end
 
     # Terminate the associated actor
@@ -62,14 +62,15 @@ module Celluloid
 
     # method_missing black magic to call bang predicate methods asynchronously
     def method_missing(meth, *args, &block)
+      meth = meth.to_s
+
       # bang methods are async calls
-      if meth.to_s.match(/!$/)
-        unbanged_meth = meth.to_s.sub(/!$/, '')
-        Actor.async @mailbox, unbanged_meth, *args, &block
-        return
+      if meth.match(/!$/)
+        meth.sub!(/!$/, '')
+        Actor.async @mailbox, meth, *args, &block
+      else
+        Actor.call  @mailbox, meth, *args, &block
       end
-
-      Actor.call @mailbox, meth, *args, &block
     end
   end
 end

data/lib/celluloid/calls.rb

@@ -1,10 +1,9 @@
 module Celluloid
   # Calls represent requests to an actor
   class Call
-    attr_reader :id, :caller, :method, :arguments, :block
+    attr_reader :caller, :method, :arguments, :block
 
-    def initialize(caller, method, arguments, block)
-      @id = object_id # memoize object ID for serialization
+    def initialize(caller, method, arguments = [], block = nil)
       @caller, @method, @arguments, @block = caller, method, arguments, block
     end
 
@@ -29,11 +28,18 @@ module Celluloid
 
   # Synchronous calls wait for a response
   class SyncCall < Call
+    attr_reader :task
+
+    def initialize(caller, method, arguments = [], block = nil, task = Fiber.current.task)
+      super(caller, method, arguments, block)
+      @task = task
+    end
+
     def dispatch(obj)
       begin
         check_signature(obj)
       rescue Exception => ex
-        respond ErrorResponse.new(@id, AbortError.new(ex))
+        respond ErrorResponse.new(self, AbortError.new(ex))
         return
       end
 
@@ -42,7 +48,7 @@ module Celluloid
       rescue Exception => exception
         # Exceptions that occur during synchronous calls are reraised in the
         # context of the caller
-        respond ErrorResponse.new(@id, exception)
+        respond ErrorResponse.new(self, exception)
 
         if exception.is_a? AbortError
           # Aborting indicates a protocol error on the part of the caller
@@ -54,12 +60,12 @@ module Celluloid
         end
       end
 
-      respond SuccessResponse.new(@id, result)
+      respond SuccessResponse.new(self, result)
     end
 
     def cleanup
       exception = DeadActorError.new("attempted to call a dead actor")
-      respond ErrorResponse.new(@id, exception)
+      respond ErrorResponse.new(self, exception)
     end
 
     #######

data/lib/celluloid/core_ext.rb

@@ -6,6 +6,15 @@ class Thread
   def self.mailbox
     current[:mailbox] ||= Celluloid::Mailbox.new
   end
+
+  # Receive a message either as an actor or through the local mailbox
+  def self.receive(&block)
+    if Celluloid.actor?
+      Celluloid.receive(&block)
+    else
+      mailbox.receive(&block)
+    end
+  end
 end
 
 class Fiber

data/lib/celluloid/fsm.rb

@@ -2,29 +2,16 @@ module Celluloid
   # Turn concurrent objects into finite state machines
   # Inspired by Erlang's gen_fsm. See http://www.erlang.org/doc/man/gen_fsm.html
   module FSM
+    class UnattachedError < StandardError; end # Not attached to an actor
+
     DEFAULT_STATE = :default # Default state name unless one is explicitly set
 
     # Included hook to extend class methods
     def self.included(klass)
-      klass.send :include, Celluloid
-      klass.send :extend,  ClassMethods
+      klass.send :extend, ClassMethods
     end
 
     module ClassMethods
-      # Ensure FSMs transition into the default state after they're initialized
-      def new(*args, &block)
-        fsm = super
-        fsm.transition default_state
-        fsm
-      end
-
-      # Ensure FSMs transition into the default state after they're initialized
-      def new_link(*args, &block)
-        fsm = super
-        fsm.transition default_state
-        fsm
-      end
-
       # Obtain or set the default state
       # Passing a state name sets the default state
       def default_state(new_default = nil)
@@ -45,6 +32,7 @@ module Celluloid
       # * to: a state or array of states this state can transition to
       def state(*args, &block)
         if args.last.is_a? Hash
+          # Stringify keys :/
           options = args.pop.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
         else
           options = {}
@@ -52,16 +40,29 @@ module Celluloid
 
         args.each do |name|
           name = name.to_sym
+          default_state name if options['default']
           states[name] = State.new(name, options['to'], &block)
         end
       end
     end
 
+    attr_reader :actor
+
+    # Be kind and call super if you must redefine initialize
+    def initialize(actor = nil)
+      @state = self.class.default_state
+      @actor = actor
+    end
+
     # Obtain the current state of the FSM
-    def current_state
-      defined?(@state) ? @state : @state = self.class.default_state
+    attr_reader :state
+
+    # Attach this FSM to an actor. This allows FSMs to wait for and initiate
+    # events in the context of a particular actor
+    def attach(actor)
+      @actor = actor
     end
-    alias_method :state, :current_state
+    alias_method :actor=, :attach
 
     # Transition to another state
     # Options:
@@ -83,33 +84,30 @@ module Celluloid
 
       new_state = self.class.states[state_name]
 
-      if !new_state and state_name == self.class.default_state
-        # FIXME This probably isn't thread safe... or wise
-        new_state = self.class.states[state_name] = State.new(state_name)
+      unless new_state
+        return if state_name == self.class.default_state
+        raise ArgumentError, "invalid state for #{self.class}: #{state_name}"
       end
 
-      if new_state
-        if options[:delay]
-          @delayed_transition.cancel if @delayed_transition
+      if options[:delay]
+        raise UnattachedError, "can't delay unless attached" unless @actor
+        @delayed_transition.cancel if @delayed_transition
 
-          @delayed_transition = after(options[:delay]) do
-            transition! new_state.name
-            new_state.call(self)
-          end
-
-          return @delayed_transition
+        @delayed_transition = @actor.after(options[:delay]) do
+          transition! new_state.name
+          new_state.call(self)
         end
 
-        if defined?(@delayed_transition) and @delayed_transition
-          @delayed_transition.cancel
-          @delayed_transition = nil
-        end
+        return @delayed_transition
+      end
 
-        transition! new_state.name
-        new_state.call(self)
-      else
-        raise ArgumentError, "invalid state for #{self.class}: #{state_name}"
+      if defined?(@delayed_transition) and @delayed_transition
+        @delayed_transition.cancel
+        @delayed_transition = nil
       end
+
+      transition! new_state.name
+      new_state.call(self)
     end
 
     # Immediate state transition with no sanity checks. "Dangerous!"

data/lib/celluloid/future.rb

@@ -4,56 +4,104 @@ module Celluloid
   # Celluloid::Future objects allow methods and blocks to run in the
   # background, their values requested later
   class Future
-    # Create a new Celluloid::Future object, allowing a block to be computed in
-    # the background and its return value obtained later
+    # Create a future bound to a given receiver, or with a block to compute
     def initialize(*args, &block)
-      @lock = Mutex.new
-      @value_obtained = false
+      @mutex = Mutex.new
+      @ready = false
+      @result = nil
+      @forwards = nil
 
-      @runner = Runner.new(*args, &block)
-      @runner.run!
+      if block
+        @call = SyncCall.new(self, :call, args)
+        ThreadPool.get do
+          begin
+            @call.dispatch(block)
+          rescue
+            # Exceptions in blocks will get raised when the value is retrieved
+          ensure
+            ThreadPool.put Thread.current
+          end
+        end
+      else
+        @call = nil
+      end
+    end
+
+    # Execute the given method in future context
+    def execute(receiver, method, args, block)
+      @mutex.synchronize do
+        raise "already calling" if @call
+        @call = SyncCall.new(self, method, args, block)
+      end
+
+      receiver << @call
     end
 
     # Obtain the value for this Future
     def value
-      @lock.synchronize do
-        unless @value_obtained
-          @value = @runner.value
-          @runner.terminate
-          @value_obtained = true
+      ready = result = nil
+
+      begin
+        @mutex.lock
+        raise "no call requested" unless @call
+
+        if @ready
+          ready = true
+          result = @result
+        else
+          case @forwards
+          when Array
+            @forwards << Thread.mailbox
+          when NilClass
+            @forwards = Thread.mailbox
+          else
+            @forwards = [@forwards, Thread.mailbox]
+          end
         end
+      ensure
+        @mutex.unlock
+      end
 
-        @value
+      unless ready
+        result = Thread.receive do |msg|
+          msg.is_a?(Future::Result) && msg.future == self
+        end
       end
+
+      result.value
     end
     alias_method :call, :value
 
-    # Inspect this Celluloid::Future
-    alias_method :inspect, :to_s
+    # Signal this future with the given result value
+    def signal(value)
+      result = Result.new(value, self)
 
-    # Runner is an internal class which executes the given block/method
-    class Runner
-      include Celluloid
+      @mutex.synchronize do
+        raise "the future has already happened!" if @ready
 
-      def initialize(*args, &block)
-        @args, @block = args, block
-        @called = nil
-        @error = nil
+        if @forwards
+          @forwards.is_a?(Array) ? @forwards.each { |f| f << result } : @forwards << result
+        end
+
+        @result = result
+        @ready = true
       end
+    end
+    alias_method :<<, :signal
 
-      def run
-        @value = @block.call(*@args)
-      rescue Exception => error
-        @error = error
-      ensure
-        @called = true
-        signal :finished
+    # Inspect this Celluloid::Future
+    alias_method :inspect, :to_s
+
+    # Wrapper for result values to distinguish them in mailboxes
+    class Result
+      attr_reader :future
+
+      def initialize(result, future)
+        @result, @future = result, future
       end
 
       def value
-        wait :finished unless @called
-        abort @error if @error
-        @value
+        @result.value
       end
     end
   end

data/lib/celluloid/{application.rb → group.rb}

@@ -1,6 +1,6 @@
 module Celluloid
-  # Applications describe and manage networks of Celluloid actors
-  class Application
+  # Supervise collections of actors as a group
+  class Group
     include Celluloid
     trap_exit :restart_supervisor
 
@@ -75,4 +75,7 @@ module Celluloid
       end
     end
   end
+
+  # Legacy support for the old name. Going away soon!
+  Application = Group
 end

data/lib/celluloid/mailbox.rb

@@ -21,52 +21,52 @@ module Celluloid
 
     # Add a message to the Mailbox
     def <<(message)
-      @lock.synchronize do
-        raise MailboxError, "dead recipient" if @dead
+      @lock.lock
+      raise MailboxError, "dead recipient" if @dead
 
-        @messages << message
-        @condition.signal
-      end
+      @messages << message
+      @condition.signal
       nil
+    ensure @lock.unlock
     end
 
     # Add a high-priority system event to the Mailbox
     def system_event(event)
-      @lock.synchronize do
-        unless @dead # Silently fail if messages are sent to dead actors
-          @messages.unshift event
-          @condition.signal
-        end
+      @lock.lock
+      unless @dead # Silently fail if messages are sent to dead actors
+        @messages.unshift event
+        @condition.signal
       end
       nil
+    ensure @lock.unlock
     end
 
     # Receive a message from the Mailbox
     def receive(timeout = nil, &block)
       message = nil
 
-      @lock.synchronize do
-        raise MailboxError, "attempted to receive from a dead mailbox" if @dead
-
-        begin
-          message = next_message(&block)
+      @lock.lock
+      raise MailboxError, "attempted to receive from a dead mailbox" if @dead
 
-          unless message
-            if timeout
-              now = Time.now
-              wait_until ||= now + timeout
-              wait_interval = wait_until - now
-              return if wait_interval < 0
-            else
-              wait_interval = nil
-            end
+      begin
+        message = next_message(&block)
 
-            @condition.wait(@lock, wait_interval)
+        unless message
+          if timeout
+            now = Time.now
+            wait_until ||= now + timeout
+            wait_interval = wait_until - now
+            return if wait_interval < 0
+          else
+            wait_interval = nil
           end
-        end until message
-      end
+
+          @condition.wait(@lock, wait_interval)
+        end
+      end until message
 
       message
+    ensure @lock.unlock
     end
 
     # Retrieve the next message in the mailbox
@@ -91,14 +91,14 @@ module Celluloid
     def shutdown
       messages = nil
 
-      @lock.synchronize do
-        messages = @messages
-        @messages = []
-        @dead = true
-      end
+      @lock.lock
+      messages = @messages
+      @messages = []
+      @dead = true
 
       messages.each { |msg| msg.cleanup if msg.respond_to? :cleanup }
       true
+    ensure @lock.unlock
     end
 
     # Is the mailbox alive?
@@ -108,7 +108,9 @@ module Celluloid
 
     # Cast to an array
     def to_a
-      @lock.synchronize { @messages.dup }
+      @lock.lock
+      @messages.dup
+    ensure @lock.unlock
     end
 
     # Iterate through the mailbox

data/lib/celluloid/receivers.rb

@@ -20,7 +20,7 @@ module Celluloid
       end
 
       @receivers << receiver
-      Task.suspend
+      Task.suspend :receiving
     end
 
     # How long to wait until the next timer fires
@@ -56,7 +56,7 @@ module Celluloid
 
     # Match a message with this receiver's block
     def match(message)
-      @block.call(message) if @block
+      @block ? @block.call(message) : true
     end
 
     def resume(message = nil)

data/lib/celluloid/responses.rb

@@ -1,10 +1,10 @@
 module Celluloid
   # Responses to calls
   class Response
-    attr_reader :call_id, :value
+    attr_reader :call, :value
     
-    def initialize(call_id, value)
-      @call_id, @value = call_id, value
+    def initialize(call, value)
+      @call, @value = call, value
     end
   end
   

data/lib/celluloid/signals.rb

@@ -20,7 +20,7 @@ module Celluloid
         @waiting[signal] = [tasks, Task.current]
       end
 
-      Task.suspend
+      Task.suspend :sigwait
     end
 
     # Send a signal to all method calls waiting for the given name
@@ -31,20 +31,20 @@ module Celluloid
       case tasks
       when Array
         tasks.each { |task| run_task task, value }
+        true if tasks.size > 0
       when NilClass
-        Logger.debug("spurious signal: #{name}")
+        false
       else
         run_task tasks, value
+        true
       end
-
-      value
     end
 
     # Run the given task, reporting errors that occur
     def run_task(task, value)
       task.resume(value)
     rescue => ex
-      Celluloid::Logger.crash("signaling error", ex)
+      Logger.crash("signaling error", ex)
     end
   end
 end

data/lib/celluloid/task.rb

@@ -6,39 +6,47 @@ module Celluloid
   class Task
     class TerminatedError < StandardError; end # kill a running fiber
 
-    attr_reader :type # what type of task is this?
+    attr_reader   :type
+    attr_accessor :status
 
     # Obtain the current task
     def self.current
-      task = Fiber.current.task
-      raise "not in task scope" unless task
-      task
+      Fiber.current.task or raise "no task for this Fiber"
     end
 
     # Suspend the running task, deferring to the scheduler
-    def self.suspend(value = nil)
-      result = Fiber.yield(value)
+    def self.suspend(status)
+      task = Task.current
+      task.status = status
+
+      result = Fiber.yield
       raise TerminatedError, "task was terminated" if result == TerminatedError
+      task.status = :running
+
       result
     end
 
     # Run the given block within a task
     def initialize(type)
-      @type = type
+      @type   = type
+      @status = :new
 
       actor   = Thread.current[:actor]
       mailbox = Thread.current[:mailbox]
 
       @fiber = Fiber.new do
+        @status = :running
         Thread.current[:actor]   = actor
         Thread.current[:mailbox] = mailbox
-
         Fiber.current.task = self
+        actor.tasks << self
 
         begin
           yield
         rescue TerminatedError
           # Task was explicitly terminated
+        ensure
+          actor.tasks.delete self
         end
       end
     end
@@ -67,7 +75,7 @@ module Celluloid
 
     # Nicer string inspect for tasks
     def inspect
-      "<Celluloid::Task:0x#{object_id.to_s(16)} @type=#{@type.inspect}, @running=#{@fiber.alive?}>"
+      "<Celluloid::Task:0x#{object_id.to_s(16)} @type=#{@type.inspect}, @status=#{@status.inspect}, @running=#{@fiber.alive?}>"
     end
   end
 end

data/lib/celluloid/thread_pool.rb

@@ -0,0 +1,57 @@
+require 'thread'
+
+module Celluloid
+  # Maintain a thread pool FOR SPEED!!
+  module ThreadPool
+    @pool = []
+    @lock = Mutex.new
+
+    # TODO: should really adjust this based on usage
+    @max_idle = 16
+
+    class << self
+      attr_accessor :max_idle
+
+      # Get a thread from the pool, running the given block
+      def get(&block)
+        @lock.synchronize do
+          if @pool.empty?
+            thread = create
+          else
+            thread = @pool.shift
+          end
+
+          thread[:queue] << block
+          thread
+        end
+      end
+
+      # Return a thread to the pool
+      def put(thread)
+        @lock.synchronize do
+          if @pool.size >= @max_idle
+            thread[:queue] << nil
+          else
+            @pool << thread
+          end
+        end
+      end
+
+      # Create a new thread with an associated queue of procs to run
+      def create
+        queue = Queue.new
+        thread = Thread.new do
+          begin
+            while func = queue.pop
+              func.call
+            end
+          rescue Exception => ex
+            Logger.crash("#{self} internal failure", ex)
+          end
+        end
+        thread[:queue] = queue
+        thread
+      end
+    end
+  end
+end

data/lib/celluloid/version.rb

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

data/spec/support/actor_examples.rb

@@ -327,17 +327,21 @@ shared_context "a Celluloid Actor" do |included_module|
       end
     end
 
+    let(:receiver) { @receiver.new }
+    let(:message) { Object.new }
+
+    it "allows unconditional receive" do
+      receiver.signal_myself(message).should == message
+    end
+
     it "allows arbitrary selective receive" do
-      obj = Object.new
-      receiver = @receiver.new
-      received_obj = receiver.signal_myself(obj) { |o| o == obj }
-      received_obj.should == obj
+      received_obj = receiver.signal_myself(message) { |o| o == message }
+      received_obj.should == message
     end
 
     it "times out after the given interval" do
       interval = 0.1
       started_at = Time.now
-      receiver = @receiver.new
 
       receiver.receive(interval) { false }.should be_nil
       (Time.now - started_at).should be_within(Celluloid::Timer::QUANTUM).of interval
@@ -448,7 +452,7 @@ shared_context "a Celluloid Actor" do |included_module|
       # an alias for Celluloid::Actor#waiting_tasks
       tasks = actor.tasks
       tasks.size.should == 1
-      tasks.values.first.should == :running
+      tasks.first.status.should == :running
 
       future = actor.future(:blocking_call)
       sleep 0.1 # hax! waiting for ^^^ call to actually start
@@ -456,14 +460,9 @@ shared_context "a Celluloid Actor" do |included_module|
       tasks = actor.tasks
       tasks.size.should == 2
 
-      blocking_task = nil
-      tasks.each do |task, waitable|
-        next if waitable == :running
-        blocking_task = task
-        break
-      end
-
-      tasks[blocking_task].first.should == :call
+      blocking_task = tasks.find { |t| t.status != :running }
+      blocking_task.should be_a Celluloid::Task
+      blocking_task.status.should == :callwait
 
       actor.blocker.unblock
       sleep 0.1 # hax again :(

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: celluloid
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-08 00:00:00.000000000 Z
+date: 2012-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70197910788100 !ruby/object:Gem::Requirement
+  requirement: &70145052114120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70197910788100
+  version_requirements: *70145052114120
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70197910787320 !ruby/object:Gem::Requirement
+  requirement: &70145052113520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,25 +32,35 @@ dependencies:
         version: 2.7.0
   type: :development
   prerelease: false
-  version_requirements: *70197910787320
+  version_requirements: *70145052113520
+- !ruby/object:Gem::Dependency
+  name: benchmark_suite
+  requirement: &70145052113020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70145052113020
 description: Celluloid is a concurrent object framework inspired by the Actor Model
 email:
-- tony@medioh.com
+- tony.arcieri@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - README.md
 - lib/celluloid/actor.rb
-- lib/celluloid/actor_pool.rb
 - lib/celluloid/actor_proxy.rb
-- lib/celluloid/application.rb
 - lib/celluloid/calls.rb
 - lib/celluloid/core_ext.rb
 - lib/celluloid/events.rb
 - lib/celluloid/fiber.rb
 - lib/celluloid/fsm.rb
 - lib/celluloid/future.rb
+- lib/celluloid/group.rb
 - lib/celluloid/links.rb
 - lib/celluloid/logger.rb
 - lib/celluloid/mailbox.rb
@@ -61,6 +71,7 @@ files:
 - lib/celluloid/signals.rb
 - lib/celluloid/supervisor.rb
 - lib/celluloid/task.rb
+- lib/celluloid/thread_pool.rb
 - lib/celluloid/timers.rb
 - lib/celluloid/version.rb
 - lib/celluloid.rb

data/lib/celluloid/actor_pool.rb

@@ -1,54 +0,0 @@
-require 'thread'
-
-module Celluloid
-  class Actor
-    # Maintain a thread pool of actors FOR SPEED!!
-    class Pool
-      @pool = []
-      @lock = Mutex.new
-      @max_idle = 16
-
-      class << self
-        attr_accessor :max_idle
-
-        def get(&block)
-          @lock.synchronize do
-            if @pool.empty?
-              thread = create
-            else
-              thread = @pool.shift
-            end
-
-            thread[:queue] << block
-            thread
-          end
-        end
-
-        def put(thread)
-          @lock.synchronize do
-            if @pool.size >= @max_idle
-              thread[:queue] << nil
-            else
-              @pool << thread
-            end
-          end
-        end
-
-        def create
-          queue = Queue.new
-          thread = Thread.new do
-            begin
-              while func = queue.pop
-                func.call
-              end
-            rescue Exception => ex
-              Logger.crash("#{self} internal failure", ex)
-            end
-          end
-          thread[:queue] = queue
-          thread
-        end
-      end
-    end
-  end
-end