celluloid 0.16.0 → 0.17.0

data/lib/celluloid/notices.rb

@@ -0,0 +1,15 @@
+module Celluloid
+  module Notices
+    class << self
+      @@notices = []
+
+      def backported
+        @@notices << [:debug, "Celluloid #{Celluloid::VERSION} is running in BACKPORTED mode. [ http://git.io/vJf3J ]"]
+      end
+
+      def output
+        @@notices.each { |type, notice| Celluloid::Internals::Logger.send type, notice }
+      end
+    end
+  end
+end

data/lib/celluloid/proxies.rb

@@ -0,0 +1,12 @@
+module Celluloid
+  module Proxy
+  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

@@ -0,0 +1,24 @@
+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
+        }
+
+        # 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
+  end
+end

data/lib/celluloid/proxy/actor.rb

@@ -0,0 +1,46 @@
+module Celluloid
+  module Proxy
+    # A proxy which controls the Actor lifecycle
+    class Actor < Abstract
+      attr_reader :thread, :mailbox
+
+      # Used for reflecting on proxy objects themselves
+      def __class__
+        Proxy::Actor
+      end
+
+      def initialize(thread, mailbox)
+        @thread = thread
+        @mailbox = mailbox
+      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 dead?
+        !alive?
+      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
+  end
+end

data/lib/celluloid/proxy/async.rb

@@ -0,0 +1,36 @@
+module Celluloid
+  module Proxy
+    # A proxy which sends asynchronous calls to an actor
+    class Async < Abstract
+      attr_reader :mailbox
+
+      # Used for reflecting on proxy objects themselves
+      def __class__
+        Proxy::Async
+      end
+
+      def initialize(mailbox, klass)
+        @mailbox = mailbox
+        @klass = klass
+      end
+
+      def inspect
+        "#<Celluloid::Proxy::Async(#{@klass})>"
+      end
+
+      def method_missing(meth, *args, &block)
+        if @mailbox == ::Thread.current[:celluloid_mailbox]
+          args.unshift meth
+          meth = :__send__
+        end
+
+        if block_given?
+          # FIXME: nicer exception
+          fail "Cannot use blocks with async yet"
+        end
+
+        @mailbox << Call::Async.new(meth, args, block)
+      end
+    end
+  end
+end

data/lib/celluloid/proxy/block.rb

@@ -0,0 +1,31 @@
+module Celluloid
+  module Proxy
+    class Block
+      def initialize(call, mailbox, block)
+        @call = call
+        @mailbox = mailbox
+        @block = block
+        @execution = :sender
+      end
+      attr_writer :execution
+      attr_reader :call, :block
+
+      def to_proc
+        if @execution == :sender
+          lambda do |*values|
+            if task = Thread.current[:celluloid_task]
+              @mailbox << Call::Block.new(self, Celluloid::Actor.current.mailbox, values)
+              # TODO: if respond fails, the Task will never be resumed
+              task.suspend(:invokeblock)
+            else
+              # FIXME: better exception
+              fail "No task to suspend"
+            end
+          end
+        else
+          @block
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/proxy/cell.rb

@@ -0,0 +1,76 @@
+module Celluloid
+  module Proxy
+    # A proxy object returned from Celluloid::Actor.new/new_link which converts
+    # the normal Ruby method protocol into an inter-actor message protocol
+    class Cell < Sync
+      # Used for reflecting on proxy objects themselves
+      def __class__
+        Proxy::Cell
+      end
+
+      def initialize(actor_proxy, mailbox, klass)
+        super(mailbox, klass)
+        @actor_proxy  = actor_proxy
+        @sync_proxy   = Sync.new(mailbox, klass)
+        @async_proxy  = Async.new(mailbox, klass)
+        @future_proxy = Future.new(mailbox, klass)
+      end
+
+      def _send_(meth, *args, &block)
+        method_missing :__send__, meth, *args, &block
+      end
+
+      def inspect
+        method_missing :inspect
+      rescue DeadActorError
+        "#<Celluloid::Proxy::Cell(#{@klass}) dead>"
+      end
+
+      def method(name)
+        Internals::Method.new(self, name)
+      end
+
+      alias_method :sync, :method_missing
+
+      # Obtain an async proxy or explicitly invoke a named async method
+      def async(method_name = nil, *args, &block)
+        if method_name
+          @async_proxy.method_missing method_name, *args, &block
+        else
+          @async_proxy
+        end
+      end
+
+      # Obtain a future proxy or explicitly invoke a named future method
+      def future(method_name = nil, *args, &block)
+        if method_name
+          @future_proxy.method_missing method_name, *args, &block
+        else
+          @future_proxy
+        end
+      end
+
+      def alive?
+        @actor_proxy.alive?
+      end
+
+      def dead?
+        @actor_proxy.dead?
+      end
+
+      def thread
+        @actor_proxy.thread
+      end
+
+      # Terminate the associated actor
+      def terminate
+        @actor_proxy.terminate
+      end
+
+      # Terminate the associated actor asynchronously
+      def terminate!
+        @actor_proxy.terminate!
+      end
+    end
+  end
+end

data/lib/celluloid/proxy/future.rb

@@ -0,0 +1,40 @@
+module Celluloid
+  module Proxy
+    # A proxy which creates future calls to an actor
+    class Future < Abstract
+      attr_reader :mailbox
+
+      # Used for reflecting on proxy objects themselves
+      def __class__
+        Proxy::Future
+      end
+
+      def initialize(mailbox, klass)
+        @mailbox = mailbox
+        @klass = klass
+      end
+
+      def inspect
+        "#<Celluloid::Proxy::Future(#{@klass})>"
+      end
+
+      def method_missing(meth, *args, &block)
+        unless @mailbox.alive?
+          fail DeadActorError, "attempted to call a dead actor"
+        end
+
+        if block_given?
+          # FIXME: nicer exception
+          fail "Cannot use blocks with futures yet"
+        end
+
+        future = ::Celluloid::Future.new
+        call = Call::Sync.new(future, meth, args, block)
+
+        @mailbox << call
+
+        future
+      end
+    end
+  end
+end

data/lib/celluloid/proxy/sync.rb

@@ -0,0 +1,44 @@
+module Celluloid
+  module Proxy
+    # A proxy which sends synchronous calls to an actor
+    class Sync < Abstract
+      attr_reader :mailbox
+
+      # Used for reflecting on proxy objects themselves
+      def __class__
+        Proxy::Sync
+      end
+
+      def initialize(mailbox, klass)
+        @mailbox = mailbox
+        @klass = klass
+      end
+
+      def inspect
+        "#<Celluloid::Proxy::Sync(#{@klass})>"
+      end
+
+      def respond_to?(meth, include_private = false)
+        __class__.instance_methods.include?(meth) || method_missing(:respond_to?, meth, include_private)
+      end
+
+      def method_missing(meth, *args, &block)
+        unless @mailbox.alive?
+          fail DeadActorError, "attempted to call a dead actor"
+        end
+
+        if @mailbox == ::Thread.current[:celluloid_mailbox]
+          args.unshift meth
+          meth = :__send__
+          # actor = Thread.current[:celluloid_actor]
+          # actor = actor.behavior.subject.bare_object
+          # return actor.__send__(*args, &block)
+        end
+
+        call = Call::Sync.new(::Celluloid.mailbox, meth, args, block)
+        @mailbox << call
+        call.value
+      end
+    end
+  end
+end

data/lib/celluloid/rspec.rb

@@ -1,13 +1,12 @@
-require 'celluloid/rspec/example_actor_class'
-require 'celluloid/rspec/actor_examples'
-require 'celluloid/rspec/mailbox_examples'
-require 'celluloid/rspec/task_examples'
-
-module Celluloid
-  # Timer accuracy enforced by the tests (50ms)
-  TIMER_QUANTUM = 0.05
-end
+require "celluloid/test"
 
 $CELLULOID_DEBUG = true
 
-require 'celluloid/test'
+# Load shared examples and test support code for other gems to use.
+
+%w(env logging split_logs sleep_and_wait reset_class_variables crash_checking stubbing coverage includer).each { |f|
+  require "#{File.expand_path('../../../spec/support', __FILE__)}/#{f}.rb"
+}
+
+Dir["#{File.expand_path('../../../spec/support/examples', __FILE__)}/*.rb"].map { |f| require f }
+Dir["#{File.expand_path('../../../spec/shared', __FILE__)}/*.rb"].map { |f| require f }

data/lib/celluloid/system_events.rb

@@ -1,16 +1,20 @@
 module Celluloid
   # High-priority internal system events
-  class SystemEvent; end
+  class SystemEvent
+    class LinkingEvent < SystemEvent
+      # Shared initializer for LinkingRequest and LinkingResponse
+      def initialize(actor, type)
+        @actor = actor
+        @type = type.to_sym
+        fail ArgumentError, "type must be link or unlink" unless [:link, :unlink].include?(@type)
+      end
+    end
+  end
 
   # Request to link with another actor
-  class LinkingRequest < SystemEvent
+  class LinkingRequest < SystemEvent::LinkingEvent
     attr_reader :actor, :type
 
-    def initialize(actor, type)
-      @actor, @type = actor, type.to_sym
-      raise ArgumentError, "type must be link or unlink" unless [:link, :unlink].include?(@type)
-    end
-
     def process(links)
       case type
       when :link   then links << actor
@@ -22,13 +26,8 @@ module Celluloid
   end
 
   # Response to a link request
-  class LinkingResponse
+  class LinkingResponse < SystemEvent::LinkingEvent
     attr_reader :actor, :type
-
-    def initialize(actor, type)
-      @actor, @type = actor, type.to_sym
-      raise ArgumentError, "type must be link or unlink" unless [:link, :unlink].include?(@type)
-    end
   end
 
   # An actor has exited for the given reason
@@ -36,7 +35,8 @@ module Celluloid
     attr_reader :actor, :reason
 
     def initialize(actor, reason = nil)
-      @actor, @reason = actor, reason
+      @actor = actor
+      @reason = reason
     end
   end
 
@@ -55,7 +55,8 @@ module Celluloid
   # Signal a condition
   class SignalConditionRequest < SystemEvent
     def initialize(task, value)
-      @task, @value = task, value
+      @task = task
+      @value = value
     end
     attr_reader :task, :value
 

data/lib/celluloid/{tasks.rb → task.rb}

@@ -16,7 +16,7 @@ module Celluloid
 
     # Obtain the current task
     def self.current
-      Thread.current[:celluloid_task] or raise NotTaskError, "not within a task context"
+      Thread.current[:celluloid_task] || fail(NotTaskError, "not within a task context")
     end
 
     # Suspend the running task, deferring to the scheduler
@@ -34,13 +34,13 @@ module Celluloid
       @status   = :new
 
       @exclusive         = false
-      @dangerous_suspend = @meta ? @meta.delete(:dangerous_suspend) : false
+      @dangerous_suspend = @meta ? @meta.dup.delete(:dangerous_suspend) : false
       @guard_warnings    = false
 
       actor     = Thread.current[:celluloid_actor]
-      @chain_id = CallChain.current_id
+      @chain_id = Internals::CallChain.current_id
 
-      raise NotActorError, "can't create tasks outside of actors" unless actor
+      fail NotActorError, "can't create tasks outside of actors" unless actor
       guard "can't create tasks inside of tasks" if Thread.current[:celluloid_task]
 
       create do
@@ -51,7 +51,7 @@ module Celluloid
           name_current_thread thread_metadata
 
           Thread.current[:celluloid_task] = self
-          CallChain.current_id = @chain_id
+          Internals::CallChain.current_id = @chain_id
 
           actor.tasks << self
           yield
@@ -65,19 +65,19 @@ module Celluloid
       end
     end
 
-    def create(&block)
-      raise "Implement #{self.class}#create"
+    def create(&_block)
+      fail "Implement #{self.class}#create"
     end
 
     # Suspend the current task, changing the status to the given argument
     def suspend(status)
-      raise "Cannot suspend while in exclusive mode" if exclusive?
-      raise "Cannot suspend a task from outside of itself" unless Task.current == self
+      fail "Cannot suspend while in exclusive mode" if exclusive?
+      fail "Cannot suspend a task from outside of itself" unless Task.current == self
 
       @status = status
 
       if $CELLULOID_DEBUG && @dangerous_suspend
-        Logger.with_backtrace(caller[2...8]) do |logger|
+        Internals::Logger.with_backtrace(caller[2...8]) do |logger|
           logger.warn "Dangerously suspending task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
         end
       end
@@ -85,7 +85,7 @@ module Celluloid
       value = signal
 
       @status = :running
-      raise value if value.is_a?(Celluloid::ResumableError)
+      fail value if value.is_a?(Celluloid::ResumableError)
 
       value
     end
@@ -113,17 +113,18 @@ module Celluloid
 
     # Terminate this task
     def terminate
-      raise "Cannot terminate an exclusive task" if exclusive?
+      fail "Cannot terminate an exclusive task" if exclusive?
 
       if running?
-        Logger.with_backtrace(backtrace) do |logger|
-          logger.warn "Terminating task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}"
+        Internals::Logger.with_backtrace(backtrace) do |logger|
+          type = @dangerous_suspend ? :warn : :debug
+          logger.send(type, "Terminating task: type=#{@type.inspect}, meta=#{@meta.inspect}, status=#{@status.inspect}")
         end
         exception = Task::TerminatedError.new("task was terminated")
         exception.set_backtrace(caller)
         resume exception
       else
-        raise DeadTaskError, "task is already dead"
+        fail DeadTaskError, "task is already dead"
       end
     end
 
@@ -136,7 +137,9 @@ module Celluloid
     end
 
     # Is the current task still running?
-    def running?; @status != :dead; end
+    def running?
+      @status != :dead
+    end
 
     # Nicer string inspect for tasks
     def inspect
@@ -145,9 +148,9 @@ module Celluloid
 
     def guard(message)
       if @guard_warnings
-        Logger.warn message if $CELLULOID_DEBUG
+        Internals::Logger.warn message if $CELLULOID_DEBUG
       else
-        raise message if $CELLULOID_DEBUG
+        fail message if $CELLULOID_DEBUG
       end
     end
 
@@ -171,6 +174,3 @@ module Celluloid
     end
   end
 end
-
-require 'celluloid/tasks/task_fiber'
-require 'celluloid/tasks/task_thread'