celluloid 0.17.0 → 0.17.1

data/lib/celluloid/call/sync.rb

@@ -15,7 +15,7 @@ module Celluloid
         Internals::CallChain.current_id = @chain_id
         result = super(obj)
         respond Internals::Response::Success.new(self, result)
-      rescue Exception => ex
+      rescue ::Exception => ex
         # Exceptions that occur during synchronous calls are reraised in the
         # context of the sender
         respond Internals::Response::Error.new(self, ex)

data/lib/celluloid/calls.rb

@@ -12,7 +12,7 @@ module Celluloid
           # FIXME: nicer exception
           fail "Cannot execute blocks on sender in exclusive mode"
         end
-        @block = Proxy::Block.new(self, Celluloid.mailbox, block)
+        @block = Proxy::Block.new(Celluloid.mailbox, self, block)
       else
         @block = nil
       end
@@ -26,10 +26,10 @@ module Celluloid
       check(obj)
       _b = @block && @block.to_proc
       obj.public_send(@method, *@arguments, &_b)
-      #     rescue Celluloid::TimeoutError => ex
+      #     rescue Celluloid::TaskTimeout => ex
       #       raise ex unless ( @retry += 1 ) <= RETRY_CALL_LIMIT
       #       puts "retrying"
-      #       Internals::Logger.warn("TimeoutError at Call dispatch. Retrying in #{RETRY_CALL_WAIT} seconds. ( Attempt #{@retry} of #{RETRY_CALL_LIMIT} )")
+      #       Internals::Logger.warn("TaskTimeout at Call dispatch. Retrying in #{RETRY_CALL_WAIT} seconds. ( Attempt #{@retry} of #{RETRY_CALL_LIMIT} )")
       #       sleep RETRY_CALL_WAIT
       #       retry
     end

data/lib/celluloid/cell.rb

@@ -41,7 +41,7 @@ module Celluloid
       end
 
       @actor.start
-      @proxy = (options[:proxy_class] || Proxy::Cell).new(@actor.proxy, @actor.mailbox, @subject.class.to_s)
+      @proxy = (options[:proxy_class] || Proxy::Cell).new(@actor.mailbox, @actor.proxy, @subject.class.to_s)
     end
     attr_reader :proxy, :subject
 

data/lib/celluloid/condition.rb

@@ -1,6 +1,4 @@
 module Celluloid
-  class ConditionError < Celluloid::Error; end
-
   # ConditionVariable-like signaling between tasks and threads
   class Condition
     class Waiter
@@ -21,7 +19,7 @@ module Celluloid
           message = @mailbox.receive(@timeout) do |msg|
             msg.is_a?(SignalConditionRequest) && msg.task == Thread.current
           end
-        rescue TimeoutError
+        rescue TimedOut
           raise ConditionError, "timeout after #{@timeout.inspect} seconds"
         end until message
 
@@ -59,7 +57,8 @@ module Celluloid
 
       result = Celluloid.suspend :condwait, waiter
       timer.cancel if timer
-      fail result if result.is_a? ConditionError
+      fail result if result.is_a?(ConditionError)
+      return yield(result) if block_given?
       result
     end
 

data/lib/celluloid/debug.rb

@@ -0,0 +1 @@
+$CELLULOID_DEBUG = true

data/lib/celluloid/deprecate.rb

@@ -15,4 +15,7 @@ module Celluloid
   InternalPool = Group::Pool
   TaskThread = Task::Threaded
   TaskFiber = Task::Fibered
+  ActorSystem = Actor::System
+  Task::TerminatedError = TaskTerminated
+  Task::TimeoutError = TaskTimeout
 end

data/lib/celluloid/exceptions.rb

@@ -1,23 +1,28 @@
 module Celluloid
-  # Base class of all Celluloid errors
-  Error = Class.new(StandardError)
-
-  # Don't do Actor-like things outside Actor scope
-  NotActorError = Class.new(Celluloid::Error)
-
-  # Trying to do something to a dead actor
-  DeadActorError = Class.new(Celluloid::Error)
-
-  # A timeout occured before the given request could complete
-  TimeoutError = Class.new(Celluloid::Error)
-
-  # The sender made an error, not the current actor
-  class AbortError < Celluloid::Error
+  class Error < StandardError; end
+  class Interruption < Exception; end
+  class TimedOut < Celluloid::Interruption; end # Distinguished from `Timeout`
+  class StillActive < Celluloid::Error; end
+  class NotActive < Celluloid::Error; end
+  class NotActorError < Celluloid::Error; end # Don't do Actor-like things outside Actor scope
+  class DeadActorError < Celluloid::Error; end # Trying to do something to a dead actor
+  class NotTaskError < Celluloid::Error; end # Asked to do task-related things outside a task
+  class DeadTaskError < Celluloid::Error; end # Trying to resume a dead task
+  class TaskTerminated < Celluloid::Interruption; end # Kill a running task after terminate
+  class TaskTimeout < Celluloid::TimedOut; end # A timeout occured before the given request could complete
+  class ConditionError < Celluloid::Error; end
+  class AbortError < Celluloid::Error # The sender made an error, not the current actor
     attr_reader :cause
-
     def initialize(cause)
       @cause = cause
       super "caused by #{cause.inspect}: #{cause}"
     end
   end
+  module Feature
+    module Requires
+      class RubiniusOrJRuby < Celluloid::Error; end
+      class Rubinius < Celluloid::Error; end
+      class JRuby < Celluloid::Error; end
+    end
+  end
 end

data/lib/celluloid/future.rb

@@ -8,8 +8,12 @@ module Celluloid
       return super unless block
 
       future = new
+      task = Thread.current[:celluloid_task]
+      actor = Thread.current[:celluloid_actor]
       Internals::ThreadHandle.new(Celluloid.actor_system, :future) do
         begin
+          Thread.current[:celluloid_task] = task
+          Thread.current[:celluloid_actor] = actor
           call = Call::Sync.new(future, :call, args)
           call.dispatch(block)
         rescue
@@ -21,12 +25,36 @@ module Celluloid
 
     attr_reader :address
 
-    def initialize
+    def initialize(&block)
       @address = Celluloid.uuid
       @mutex = Mutex.new
       @ready = false
       @result = nil
       @forwards = nil
+      @cancelled = false
+
+      if block
+        @call = Call::Sync.new(self, :call, args)
+        Celluloid.internal_pool.get do
+          begin
+            @call.dispatch(block)
+          rescue
+            # Exceptions in blocks will get raised when the value is retrieved
+          end
+        end
+      else
+        @call = nil
+      end
+    end
+
+    # Execute the given method in future context
+    def execute(receiver, method, args, block)
+      @mutex.synchronize do
+        fail "already calling" if @call
+        @call = Call::Sync.new(self, method, args, block)
+      end
+
+      receiver << @call
     end
 
     # Check if this future has a value yet
@@ -65,15 +93,16 @@ module Celluloid
       end
 
       if result
-        result.value
+        (result.respond_to?(:value)) ? result.value : result
       else
-        fail TimeoutError, "Timed out"
+        fail TimedOut, "Timed out"
       end
     end
     alias_method :call, :value
 
     # Signal this future with the given result value
     def signal(value)
+      return if @cancelled
       result = Result.new(value, self)
 
       @mutex.synchronize do
@@ -89,6 +118,14 @@ module Celluloid
     end
     alias_method :<<, :signal
 
+    def cancel(error)
+      response = ErrorResponse.new(@call, error)
+      signal response
+      @mutex.synchronize do
+        @cancelled = true
+      end
+    end
+
     # Inspect this Celluloid::Future
     alias_method :inspect, :to_s
 

data/lib/celluloid/group.rb

@@ -1,9 +1,5 @@
 module Celluloid
   class Group
-    class NotImplemented < StandardError; end
-    class StillActive < StandardError; end
-    class NotActive < StandardError; end
-
     attr_accessor :group
 
     def initialize
@@ -13,7 +9,7 @@ module Celluloid
     end
 
     def assert_active
-      fail NotActive unless active?
+      fail Celluloid::NotActive unless active?
     end
 
     def assert_inactive
@@ -21,7 +17,7 @@ module Celluloid
       if RUBY_PLATFORM == "java"
         Celluloid.logger.warn "Group is still active"
       else
-        fail StillActive
+        fail Celluloid::StillActive
       end
     end
 
@@ -51,15 +47,15 @@ module Celluloid
     end
 
     def get
-      fail NotImplemented
+      fail NotImplementedError
     end
 
     def create
-      fail NotImplemented
+      fail NotImplementedError
     end
 
     def shutdown
-      fail NotImplemented
+      fail NotImplementedError
     end
   end
 end

data/lib/celluloid/group/pool.rb

@@ -93,7 +93,7 @@ module Celluloid
           while proc = queue.pop
             begin
               proc.call
-            rescue Exception => ex
+            rescue ::Exception => ex
               Internals::Logger.crash("thread crashed", ex)
             ensure
               put thread

data/lib/celluloid/group/spawner.rb

@@ -25,7 +25,6 @@ module Celluloid
             th.kill
             queue << th
           end
-
           loop do
             break if queue.empty?
             queue.pop.join
@@ -52,7 +51,7 @@ module Celluloid
 
           begin
             proc.call
-          rescue Exception => ex
+          rescue ::Exception => ex
             Internals::Logger.crash("thread crashed", ex)
             Thread.current[:celluloid_meta][:state] = :error
           ensure

data/lib/celluloid/mailbox.rb

@@ -70,7 +70,7 @@ module Celluloid
     end
 
     # Receive a letter from the mailbox. Guaranteed to return a message. If
-    # timeout is exceeded, raise a TimeoutError.
+    # timeout is exceeded, raise a TaskTimeout.
     def receive(timeout = nil, &block)
       message = nil
       Timers::Wait.for(timeout) do |remaining|
@@ -78,7 +78,7 @@ module Celluloid
         break if message
       end
       return message if message
-      fail TimeoutError.new("receive timeout exceeded")
+      fail TaskTimeout.new("receive timeout exceeded")
     end
 
     # Shut down this mailbox and clean up its contents

data/lib/celluloid/managed.rb

@@ -0,0 +1,3 @@
+$CELLULOID_BACKPORTED = false
+$CELLULOID_MANAGED = true
+require "celluloid/autostart"

data/lib/celluloid/notices.rb

@@ -4,7 +4,7 @@ module Celluloid
       @@notices = []
 
       def backported
-        @@notices << [:debug, "Celluloid #{Celluloid::VERSION} is running in BACKPORTED mode. [ http://git.io/vJf3J ]"]
+        @@notices << [:info, "Celluloid #{Celluloid::VERSION} is running in BACKPORTED mode. [ http://git.io/vJf3J ]"]
       end
 
       def output

data/lib/celluloid/proxies.rb

@@ -1,12 +1,11 @@
 module Celluloid
   module Proxy
+    require "celluloid/proxy/abstract"
+    require "celluloid/proxy/sync"
+    require "celluloid/proxy/cell"
+    require "celluloid/proxy/actor"
+    require "celluloid/proxy/async"
+    require "celluloid/proxy/future"
+    require "celluloid/proxy/block"
   end
 end
-
-require "celluloid/proxy/abstract"
-require "celluloid/proxy/sync"
-require "celluloid/proxy/cell"
-require "celluloid/proxy/actor"
-require "celluloid/proxy/async"
-require "celluloid/proxy/future"
-require "celluloid/proxy/block"

data/lib/celluloid/proxy/abstract.rb

@@ -1,24 +1,19 @@
-module Celluloid
-  module Proxy
-    # Base class of all Celluloid proxies
-    class Abstract < BasicObject
-      # Used for reflecting on proxy objects themselves
-      def __class__
-        Proxy::Abstract
-      end
-
-      # Needed for storing proxies in data structures
-      needed = [:object_id, :__id__, :hash, :private_methods] - instance_methods
-      if needed.any?
-        include ::Kernel.dup.module_eval {
-          undef_method(*(instance_methods - needed))
-          self
-        }
+# Base class of Celluloid proxies
+class Celluloid::Proxy::Abstract < BasicObject
+  # Used for reflecting on proxy objects themselves
+  def __class__
+    ::Celluloid::Proxy::Abstract
+  end
 
-        # rubinius bug?  These methods disappear when we include hacked kernel
-        define_method :==, ::BasicObject.instance_method(:==) unless instance_methods.include?(:==)
-        alias_method(:equal?, :==) unless instance_methods.include?(:equal?)
-      end
-    end
+  # Needed for storing proxies in data structures
+  needed = [:object_id, :__id__, :hash, :private_methods] - instance_methods
+  if needed.any?
+    include ::Kernel.dup.module_eval {
+      undef_method(*(instance_methods - needed))
+      self
+    }
+    # rubinius bug?  These methods disappear when we include hacked kernel
+    define_method :==, ::BasicObject.instance_method(:==) unless instance_methods.include?(:==)
+    alias_method(:equal?, :==) unless instance_methods.include?(:equal?)
   end
 end

data/lib/celluloid/proxy/actor.rb

@@ -1,46 +1,42 @@
-module Celluloid
-  module Proxy
-    # A proxy which controls the Actor lifecycle
-    class Actor < Abstract
-      attr_reader :thread, :mailbox
+# A proxy which controls the Actor lifecycle
+class Celluloid::Proxy::Actor < Celluloid::Proxy::Abstract
+  attr_reader :thread, :mailbox
 
-      # Used for reflecting on proxy objects themselves
-      def __class__
-        Proxy::Actor
-      end
+  # Used for reflecting on proxy objects themselves
+  def __class__
+    ::Celluloid::Proxy::Actor
+  end
 
-      def initialize(thread, mailbox)
-        @thread = thread
-        @mailbox = mailbox
-      end
+  def initialize(mailbox, thread)
+    @mailbox = mailbox
+    @thread = thread
+  end
 
-      def inspect
-        # TODO: use a system event to fetch actor state: tasks?
-        "#<Celluloid::Proxy::Actor(#{@mailbox.address}) alive>"
-      rescue DeadActorError
-        "#<Celluloid::Proxy::Actor(#{@mailbox.address}) dead>"
-      end
+  def inspect
+    # TODO: use a system event to fetch actor state: tasks?
+    "#<Celluloid::Proxy::Actor(#{@mailbox.address}) alive>"
+  rescue DeadActorError
+    "#<Celluloid::Proxy::Actor(#{@mailbox.address}) dead>"
+  end
 
-      def alive?
-        @mailbox.alive?
-      end
+  def alive?
+    @mailbox.alive?
+  end
 
-      def dead?
-        !alive?
-      end
+  def dead?
+    !alive?
+  end
 
-      # Terminate the associated actor
-      def terminate
-        terminate!
-        ::Celluloid::Actor.join(self)
-        nil
-      end
+  # Terminate the associated actor
+  def terminate
+    terminate!
+    ::Celluloid::Actor.join(self)
+    nil
+  end
 
-      # Terminate the associated actor asynchronously
-      def terminate!
-        ::Kernel.raise DeadActorError, "actor already terminated" unless alive?
-        @mailbox << TerminationRequest.new
-      end
-    end
+  # Terminate the associated actor asynchronously
+  def terminate!
+    ::Kernel.raise ::Celluloid::DeadActorError, "actor already terminated" unless alive?
+    @mailbox << ::Celluloid::TerminationRequest.new
   end
 end