celluloid 0.16.0 → 0.17.0

data/lib/celluloid/group.rb

@@ -0,0 +1,65 @@
+module Celluloid
+  class Group
+    class NotImplemented < StandardError; end
+    class StillActive < StandardError; end
+    class NotActive < StandardError; end
+
+    attr_accessor :group
+
+    def initialize
+      @mutex = Mutex.new
+      @group = []
+      @running = true
+    end
+
+    def assert_active
+      fail NotActive unless active?
+    end
+
+    def assert_inactive
+      return unless active?
+      if RUBY_PLATFORM == "java"
+        Celluloid.logger.warn "Group is still active"
+      else
+        fail 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 NotImplemented
+    end
+
+    def create
+      fail NotImplemented
+    end
+
+    def shutdown
+      fail NotImplemented
+    end
+  end
+end

data/lib/celluloid/group/manager.rb

@@ -0,0 +1,27 @@
+module Celluloid
+  class Group
+    class Manager
+      include Celluloid
+
+      def manage!(group)
+        @group = group
+        every(1.26) { garbage_collector }
+      end
+
+      def garbage_collector
+        @group.each do |t|
+          puts "running Group::Manager garbage_collector"
+          #           case t[:celluloid_meta][:state]
+          #           when :finished
+          #             # puts "thread finished: #{t.inspect}"
+          #           else
+          #             # puts "thread state: #{t[:celluloid_meta]}"
+          #           end
+          #           # puts "thread: #{t[:celluloid_actor].name}"
+        end
+      rescue => ex
+        puts "#{ex.backtrace.first}"
+      end
+    end
+  end
+end

data/lib/celluloid/group/pool.rb

@@ -0,0 +1,125 @@
+require "thread"
+
+module Celluloid
+  class Group
+    class Pool < Group
+      # You do not want to use this. Truly, you do not. There is no scenario when you will.
+      # But. If you somehow do.. `Celluloid.group_class = Celluloid::Group::Pool` and weep.
+
+      attr_accessor :max_idle
+
+      def initialize
+        super
+        @mutex = Mutex.new
+        @idle_threads = []
+        @group  = []
+        @busy_size = 0
+        @idle_size = 0
+
+        # TODO: should really adjust this based on usage
+        @max_idle = 16
+      end
+
+      def idle?
+        busy_size.count == 0
+      end
+
+      def busy?
+        busy_size.count > 0
+      end
+
+      attr_reader :busy_size
+
+      attr_reader :idle_size
+
+      # Get a thread from the pool, running the given block
+      def get(&block)
+        @mutex.synchronize do
+          assert_active
+
+          begin
+            if @idle_threads.empty?
+              thread = create
+            else
+              thread = @idle_threads.pop
+              @idle_size = @idle_threads.length
+            end
+          end until thread.status # handle crashed threads
+
+          thread.busy = true
+          @busy_size += 1
+          thread[:celluloid_queue] << block
+          thread
+        end
+      end
+
+      # Return a thread to the pool
+      def put(thread)
+        @mutex.synchronize do
+          thread.busy = false
+          if idle_size + 1 >= @max_idle
+            thread[:celluloid_queue] << nil
+            @busy_size -= 1
+            @group.delete(thread)
+          else
+            @idle_threads.push thread
+            @busy_size -= 1
+            @idle_size = @idle_threads.length
+            clean_thread_locals(thread)
+          end
+        end
+      end
+
+      def shutdown
+        @running = false
+        @mutex.synchronize do
+          finalize
+          @group.each do |thread|
+            thread[:celluloid_queue] << nil
+          end
+          @group.shift.kill until @group.empty?
+          @idle_threads.clear
+          @busy_size = 0
+          @idle_size = 0
+        end
+      end
+
+      private
+
+      # Create a new thread with an associated queue of procs to run
+      def create
+        queue = Queue.new
+        thread = Thread.new do
+          while proc = queue.pop
+            begin
+              proc.call
+            rescue Exception => ex
+              Internals::Logger.crash("thread crashed", ex)
+            ensure
+              put thread
+            end
+          end
+        end
+
+        thread[:celluloid_queue] = queue
+        # @idle_threads << thread
+        @group << thread
+        thread
+      end
+
+      # Clean the thread locals of an incoming thread
+      def clean_thread_locals(thread)
+        thread.keys.each do |key|
+          next if key == :celluloid_queue
+
+          # Ruby seems to lack an API for deleting thread locals. WTF, Ruby?
+          thread[key] = nil
+        end
+      end
+
+      def finalize
+        @max_idle = 0
+      end
+    end
+  end
+end

data/lib/celluloid/group/spawner.rb

@@ -0,0 +1,71 @@
+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
+        @mutex.synchronize do
+          queue = Queue.new
+          loop do
+            break if @group.empty?
+            th = @group.shift
+            th.kill
+            queue << th
+          end
+
+          loop do
+            break if queue.empty?
+            queue.pop.join
+          end
+        end
+      end
+
+      def idle?
+        to_a.select { |t| t[:celluloid_meta] && t[:celluloid_meta][:state] == :running }.empty?
+      end
+
+      def busy?
+        to_a.select { |t| t[:celluloid_meta] && t[:celluloid_meta][:state] == :running }.any?
+      end
+
+      private
+
+      def instantiate(proc)
+        thread = Thread.new do
+          Thread.current[:celluloid_meta] = {
+            started: Time.now,
+            state: :running,
+          }
+
+          begin
+            proc.call
+          rescue Exception => ex
+            Internals::Logger.crash("thread crashed", ex)
+            Thread.current[:celluloid_meta][:state] = :error
+          ensure
+            unless Thread.current[:celluloid_meta][:state] == :error
+              Thread.current[:celluloid_meta][:state] = :finished
+            end
+            Thread.current[:celluloid_meta][:finished] = Time.now
+          end
+        end
+
+        @mutex.synchronize { @group << thread }
+        thread
+      end
+    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.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.
     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 TimeoutError.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/mailbox/evented.rb

@@ -0,0 +1,76 @@
+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 IOError
+          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
+      rescue IOError
+        raise MailboxShutdown, "mailbox shutdown called during receive"
+      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