celluloid 0.16.0 → 0.17.3

data/lib/celluloid/group/spawner.rb

@@ -0,0 +1,68 @@
+require "thread"
+
+module Celluloid
+  class Group
+    class Spawner < Group
+      attr_accessor :finalizer
+
+      def initialize
+        super
+      end
+
+      def get(&block)
+        assert_active
+        fail ArgumentError.new("No block sent to Spawner.get()") unless block_given?
+        instantiate block
+      end
+
+      def shutdown
+        @running = false
+        queue = []
+        @mutex.synchronize do
+          loop do
+            break if @group.empty?
+            th = @group.shift
+            th.kill
+            queue << th
+          end
+        end
+        Thread.pass unless queue.empty?
+        loop do
+          break if queue.empty?
+          queue.pop.join
+        end
+      end
+
+      def idle?
+        to_a.select { |t| t[:celluloid_thread_state] == :running }.empty?
+      end
+
+      def busy?
+        to_a.select { |t| t[:celluloid_thread_state] == :running }.any?
+      end
+
+      private
+
+      def instantiate(proc)
+        thread = Thread.new do
+          Thread.current[:celluloid_thread_state] = :running
+          begin
+            proc.call
+          rescue ::Exception => ex
+            Internals::Logger.crash("thread crashed", ex)
+            Thread.current[:celluloid_thread_state] = :error
+          ensure
+            unless Thread.current[:celluloid_thread_state] == :error
+              Thread.current[:celluloid_thread_state] = :finished
+            end
+            @mutex.synchronize { @group.delete Thread.current }
+            Thread.exit
+          end
+        end
+
+        @mutex.synchronize { @group << thread }
+        thread
+      end
+    end
+  end
+end

data/lib/celluloid/group.rb

@@ -0,0 +1,61 @@
+module Celluloid
+  class Group
+    attr_accessor :group
+
+    def initialize
+      @mutex = Mutex.new
+      @group = []
+      @running = true
+    end
+
+    def assert_active
+      fail Celluloid::NotActive unless active?
+    end
+
+    def assert_inactive
+      return unless active?
+      if RUBY_PLATFORM == "java"
+        Celluloid.logger.warn "Group is still active"
+      else
+        fail Celluloid::StillActive
+      end
+    end
+
+    def each
+      to_a.each { |thread| yield thread }
+    end
+
+    def to_a
+      res = nil
+      @mutex.synchronize { res = @group.dup }
+      res
+    end
+
+    def purge(thread)
+      @mutex.synchronize do
+        @group.delete(thread)
+        thread.kill rescue nil
+      end
+    end
+
+    def each_actor(&block)
+      to_a.lazy.select { |t| t[:celluloid_role] == :actor }.each(&block)
+    end
+
+    def active?
+      @running
+    end
+
+    def get
+      fail NotImplementedError
+    end
+
+    def create
+      fail NotImplementedError
+    end
+
+    def shutdown
+      fail NotImplementedError
+    end
+  end
+end

data/lib/celluloid/logging.rb

@@ -1,5 +1,5 @@
-require 'celluloid/logging/log_event'
-require 'celluloid/logging/incident'
-require 'celluloid/logging/ring_buffer'
-require 'celluloid/logging/incident_logger'
-require 'celluloid/logging/incident_reporter'
+require "celluloid/logging/log_event"
+require "celluloid/logging/incident"
+require "celluloid/logging/ring_buffer"
+require "celluloid/logging/incident_logger"
+require "celluloid/logging/incident_reporter"

data/lib/celluloid/mailbox/evented.rb

@@ -0,0 +1,74 @@
+module Celluloid
+  class Mailbox
+    # An alternative implementation of Celluloid::Mailbox using Reactor
+    class Evented < Celluloid::Mailbox
+      attr_reader :reactor
+
+      def initialize(reactor_class)
+        super()
+        # @condition won't be used in the class.
+        @reactor = reactor_class.new
+      end
+
+      # Add a message to the Mailbox
+      def <<(message)
+        @mutex.lock
+        begin
+          if mailbox_full || @dead
+            dead_letter(message)
+            return
+          end
+          if message.is_a?(SystemEvent)
+            # SystemEvents are high priority messages so they get added to the
+            # head of our message queue instead of the end
+            @messages.unshift message
+          else
+            @messages << message
+          end
+        ensure
+          @mutex.unlock rescue nil
+        end
+        begin
+          current_actor = Thread.current[:celluloid_actor]
+          @reactor.wakeup unless current_actor && current_actor.mailbox == self
+        rescue
+          Internals::Logger.crash "reactor crashed", $ERROR_INFO
+          dead_letter(message)
+        end
+        nil
+      end
+
+      # Receive a message from the Mailbox
+      def check(timeout = nil, &block)
+        # Get a message if it is available and process it immediately if possible:
+        if message = next_message(block)
+          return message
+        end
+
+        # ... otherwise, run the reactor once, either blocking or will return
+        # after the given timeout:
+        @reactor.run_once(timeout)
+
+        # No message was received:
+        return nil
+      end
+
+      # Obtain the next message from the mailbox that matches the given block
+      def next_message(block)
+        @mutex.lock
+        begin
+          super(&block)
+        ensure
+          @mutex.unlock rescue nil
+        end
+      end
+
+      # Cleanup any IO objects this Mailbox may be using
+      def shutdown
+        super do
+          @reactor.shutdown
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/mailbox.rb

@@ -1,4 +1,4 @@
-require 'thread'
+require "thread"
 
 module Celluloid
   class MailboxDead < Celluloid::Error; end # you can't receive from the dead
@@ -52,37 +52,38 @@ module Celluloid
 
       @mutex.lock
       begin
-        raise MailboxDead, "attempted to receive from a dead mailbox" if @dead
+        fail MailboxDead, "attempted to receive from a dead mailbox" if @dead
 
+        message = nil
         Timers::Wait.for(timeout) do |remaining|
           message = next_message(&block)
 
-          break message if message
+          break if message
 
           @condition.wait(@mutex, remaining)
         end
       ensure
         @mutex.unlock rescue nil
       end
-      
-      return message
+
+      message
     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|
-        if message = check(timeout, &block)
-          return message
-        end
+        message = check(timeout, &block)
+        break if message
       end
-      
-      raise TimeoutError.new("receive timeout exceeded")
+      return message if message
+      fail TaskTimeout.new("receive timeout exceeded")
     end
 
     # Shut down this mailbox and clean up its contents
     def shutdown
-      raise MailboxDead, "mailbox already shutdown" if @dead
+      fail MailboxDead, "mailbox already shutdown" if @dead
 
       @mutex.lock
       begin
@@ -118,7 +119,7 @@ module Celluloid
 
     # Inspect the contents of the Mailbox
     def inspect
-      "#<#{self.class}:#{object_id.to_s(16)} @messages=[#{map { |m| m.inspect }.join(', ')}]>"
+      "#<#{self.class}:#{object_id.to_s(16)} @messages=[#{map(&:inspect).join(', ')}]>"
     end
 
     # Number of messages in the Mailbox
@@ -146,7 +147,7 @@ module Celluloid
     end
 
     def dead_letter(message)
-      Logger.debug "Discarded message (mailbox is dead): #{message}" if $CELLULOID_DEBUG
+      Internals::Logger.debug "Discarded message (mailbox is dead): #{message}" if $CELLULOID_DEBUG
     end
 
     def mailbox_full

data/lib/celluloid/managed.rb

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

data/lib/celluloid/notices.rb

@@ -0,0 +1,15 @@
+module Celluloid
+  module Notices
+    class << self
+      @@notices = []
+
+      def backported
+        @@notices << [:info, "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,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

data/lib/celluloid/proxy/abstract.rb

@@ -0,0 +1,50 @@
+module Celluloid::Proxy
+  # Looks up the actual class of instance, even if instance is a proxy.
+  def self.class_of(instance)
+    (class << instance; self; end).superclass
+  end
+end
+
+# Base class of Celluloid proxies
+class Celluloid::Proxy::Abstract < BasicObject
+  # Needed for storing proxies in data structures
+  needed = [:object_id, :__id__, :hash, :eql?, :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
+  
+  def __class__
+    @class ||= ::Celluloid::Proxy.class_of(self)
+  end
+end
+
+class Celluloid::Proxy::AbstractCall < Celluloid::Proxy::Abstract
+  attr_reader :mailbox
+  
+  def initialize(mailbox, klass)
+    @mailbox = mailbox
+    @klass = klass
+  end
+  
+  def eql?(other)
+    self.__class__.eql?(::Celluloid::Proxy.class_of(other)) and @mailbox.eql?(other.mailbox)
+  end
+
+  def hash
+    @mailbox.hash
+  end
+  
+  def __klass__
+    @klass
+  end
+  
+  def inspect
+    "#<#{self.__class__}(#{@klass})>"
+  end
+end

data/lib/celluloid/proxy/actor.rb

@@ -0,0 +1,37 @@
+# A proxy which controls the Actor lifecycle
+class Celluloid::Proxy::Actor < Celluloid::Proxy::Abstract
+  attr_reader :thread, :mailbox
+
+  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 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 ::Celluloid::DeadActorError, "actor already terminated" unless alive?
+    @mailbox << ::Celluloid::TerminationRequest.new
+  end
+end

data/lib/celluloid/proxy/async.rb

@@ -0,0 +1,15 @@
+# A proxy which sends asynchronous calls to an actor
+class Celluloid::Proxy::Async < Celluloid::Proxy::AbstractCall
+  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 << ::Celluloid::Call::Async.new(meth, args, block)
+    self
+  end
+end

data/lib/celluloid/proxy/block.rb

@@ -0,0 +1,28 @@
+class Celluloid::Proxy::Block
+  attr_writer :execution
+  attr_reader :call, :block
+  
+  def initialize(mailbox, call, block)
+    @mailbox = mailbox
+    @call = call
+    @block = block
+    @execution = :sender
+  end
+
+  def to_proc
+    if @execution == :sender
+      lambda do |*values|
+        if task = Thread.current[:celluloid_task]
+          @mailbox << ::Celluloid::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

data/lib/celluloid/proxy/cell.rb

@@ -0,0 +1,66 @@
+# A proxy object returned from Celluloid::Actor.new/new_link which converts
+# the normal Ruby method protocol into an inter-actor message protocol
+class Celluloid::Proxy::Cell < Celluloid::Proxy::Sync
+  def initialize(mailbox, actor_proxy, klass)
+    super(mailbox, klass)
+    @actor_proxy  = actor_proxy
+    @async_proxy  = ::Celluloid::Proxy::Async.new(mailbox, klass)
+    @future_proxy = ::Celluloid::Proxy::Future.new(mailbox, klass)
+  end
+
+  def _send_(meth, *args, &block)
+    method_missing :__send__, meth, *args, &block
+  end
+
+  def inspect
+    method_missing :inspect
+  rescue ::Celluloid::DeadActorError
+    "#<::Celluloid::Proxy::Cell(#{@klass}) dead>"
+  end
+
+  def method(name)
+    ::Celluloid::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

data/lib/celluloid/proxy/future.rb

@@ -0,0 +1,20 @@
+# A proxy which creates future calls to an actor
+class Celluloid::Proxy::Future < Celluloid::Proxy::AbstractCall
+  def method_missing(meth, *args, &block)
+    unless @mailbox.alive?
+      fail ::Celluloid::DeadActorError, "attempted to call a dead actor: #{meth}"
+    end
+
+    if block_given?
+      # FIXME: nicer exception
+      fail "Cannot use blocks with futures yet"
+    end
+
+    future = ::Celluloid::Future.new
+    call = ::Celluloid::Call::Sync.new(future, meth, args, block)
+
+    @mailbox << call
+
+    future
+  end
+end

data/lib/celluloid/proxy/sync.rb

@@ -0,0 +1,24 @@
+# A proxy which sends synchronous calls to an actor
+class Celluloid::Proxy::Sync < Celluloid::Proxy::AbstractCall
+  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 ::Celluloid::DeadActorError, "attempted to call a dead actor: #{meth}"
+    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 = ::Celluloid::Call::Sync.new(::Celluloid.mailbox, meth, args, block)
+    @mailbox << call
+    call.value
+  end
+end

data/lib/celluloid/rspec.rb

@@ -1,13 +1,71 @@
-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
+require "dotenv"
+require "nenv"
+
+require "celluloid/test"
+
+# To help produce better bug reports in Rubinius
+if RUBY_ENGINE == "rbx"
+  # $DEBUG = true # would be nice if this didn't fail ... :(
+  require "rspec/matchers"
+  require "rspec/matchers/built_in/be"
+end
+
+require "rspec/retry"
+
+module Specs
+
+  CHECK_LOOSE_THREADS = !Nenv.ci? unless defined? CHECK_LOOSE_THREADS
+  ALLOW_RETRIES = 3 unless defined? ALLOW_RETRIES
+
+  INCLUDE_SUPPORT = [
+    "env",
+    "logging",
+    "sleep_and_wait",
+    "reset_class_variables",
+    "crash_checking",
+    "loose_threads",
+    "stubbing",
+    "coverage",
+    "includer",
+    "configure_rspec"
+  ]
+
+  INCLUDE_PATHS = [
+    "./spec/support/*.rb",
+    "./spec/support/examples/*.rb",
+    "./spec/shared/*.rb"
+  ]
+
+  MAX_EXECUTION = 13
+  MAX_ATTEMPTS = 20
+
+  TIMER_QUANTUM = 0.05 # Timer accuracy enforced by the tests (50ms)
+
+  BACKTRACE_OMITTED = [
+    "rspec-expectations",
+    "rspec-core",
+    "rspec-mocks",
+    "rspec-retry",
+    "rubysl-thread",
+    "rubysl-timeout"
+  ]
 end
 
 $CELLULOID_DEBUG = true
 
-require 'celluloid/test'
+# Require but disable, so it has to be explicitly enabled in tests
+require "celluloid/probe"
+$CELLULOID_MONITORING = false
+
+Celluloid.shutdown_timeout = 1
+
+# Load shared examples and test support code for other gems to use.
+
+Specs::INCLUDE_SUPPORT.each { |f|
+  require "#{File.expand_path('../../../spec/support', __FILE__)}/#{f}.rb"
+}
+
+Specs.reset_probe(nil)
+
+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 }