celluloid 0.17.4 → 0.18.0

data/lib/celluloid/internals/task_set.rb

@@ -0,0 +1,51 @@
+require "set"
+require "forwardable"
+
+module Celluloid
+  module Internals
+    if RUBY_PLATFORM == "java"
+      require "jruby/synchronized"
+
+      class TaskSet
+        extend Forwardable
+        include JRuby::Synchronized
+
+        def_delegators :@tasks, :<<, :delete, :first, :empty?, :to_a
+
+        def initialize
+          @tasks = Set.new
+        end
+      end
+    elsif RUBY_ENGINE == "rbx"
+      class TaskSet
+        def initialize
+          @tasks = Set.new
+        end
+
+        def <<(task)
+          Rubinius.synchronize(self) { @tasks << task }
+        end
+
+        def delete(task)
+          Rubinius.synchronize(self) { @tasks.delete task }
+        end
+
+        def first
+          Rubinius.synchronize(self) { @tasks.first }
+        end
+
+        def empty?
+          Rubinius.synchronize(self) { @tasks.empty? }
+        end
+
+        def to_a
+          Rubinius.synchronize(self) { @tasks.to_a }
+        end
+      end
+    else
+      # Assume we're on MRI, where we have the GIL. But what about IronRuby?
+      # Or MacRuby. Do people care? This will break Celluloid::Internals::StackDumps
+      TaskSet = Set
+    end
+  end
+end

data/lib/celluloid/internals/thread_handle.rb

@@ -0,0 +1,52 @@
+module Celluloid
+  module Internals
+    # An abstraction around threads from the InternalPool which ensures we don't
+    # accidentally do things to threads which have been returned to the pool,
+    # such as, say, killing them
+    class ThreadHandle
+      def initialize(actor_system, role = nil)
+        @mutex = Mutex.new
+        @join  = ConditionVariable.new
+
+        @thread = actor_system.get_thread do
+          Thread.current.role = role
+          begin
+            yield
+          ensure
+            @mutex.synchronize do
+              @thread = nil
+              @join.broadcast
+            end
+          end
+        end
+      end
+
+      # Is the thread running?
+      def alive?
+        @mutex.synchronize { @thread && @thread.alive? }
+      end
+
+      # Forcibly kill the thread
+      def kill
+        @mutex.synchronize { @thread && @thread.kill }
+        self
+      end
+
+      # Join to a running thread, blocking until it terminates
+      def join(limit = nil)
+        raise ThreadError, "Target thread must not be current thread" if @thread == Thread.current
+        @mutex.synchronize { @join.wait(@mutex, limit) if @thread }
+        self
+      end
+
+      # Obtain the backtrace for this thread
+      def backtrace
+        @thread.backtrace
+      rescue NoMethodError
+        # undefined method `backtrace' for nil:NilClass
+        # Swallow this in case this ThreadHandle was terminated and @thread was
+        # set to nil
+      end
+    end
+  end
+end

data/lib/celluloid/internals/uuid.rb

@@ -0,0 +1,40 @@
+require "securerandom"
+
+module Celluloid
+  module Internals
+    # Clearly Ruby doesn't have enough UUID libraries
+    # This one aims to be fast and simple with good support for multiple threads
+    # If there's a better UUID library I can use with similar multithreaded
+    # performance, I certainly wouldn't mind using a gem for this!
+    module UUID
+      values = SecureRandom.hex(9).match(/(.{8})(.{4})(.{3})(.{3})/)
+      PREFIX = "#{values[1]}-#{values[2]}-4#{values[3]}-8#{values[4]}".freeze
+      BLOCK_SIZE = 0x10000
+
+      @counter = 0
+      @counter_mutex = Mutex.new
+
+      def self.generate
+        thread = Thread.current
+
+        unless thread.uuid_limit
+          @counter_mutex.synchronize do
+            block_base = @counter
+            @counter += BLOCK_SIZE
+            thread.uuid_counter = block_base
+            thread.uuid_limit   = @counter - 1
+          end
+        end
+
+        counter = thread.uuid_counter
+        if thread.uuid_counter >= thread.uuid_limit
+          thread.uuid_counter = thread.uuid_limit = nil
+        else
+          thread.uuid_counter += 1
+        end
+
+        "#{PREFIX}-#{format('%012x', counter)}".freeze
+      end
+    end
+  end
+end

data/lib/celluloid/logging/incident.rb

@@ -0,0 +1,21 @@
+module Celluloid
+  # Wraps all events and context for a single incident.
+  class Incident
+    attr_accessor :pid
+    attr_accessor :events, :triggering_event
+
+    def initialize(events, triggering_event = nil)
+      @events = events
+      @triggering_event = triggering_event
+      @pid = $PROCESS_ID
+    end
+
+    # Merge two incidents together. This may be useful if two incidents occur at the same time.
+    def merge(*other_incidents)
+      merged_events = other_incidents.flatten.inject(events) do |events, incident|
+        events += incident.events
+      end
+      Incident.new(merged_events.sort, triggering_event)
+    end
+  end
+end

data/lib/celluloid/logging/incident_logger.rb

@@ -0,0 +1,147 @@
+require "logger"
+
+module Celluloid
+  # A logger that holds all messages in circular buffers, then flushes the buffers
+  # when an event occurs at a configurable severity threshold.
+  #
+  # Unlike ruby's Logger, this class only supports a single progname.
+  class IncidentLogger
+    module Severity
+      include ::Logger::Severity
+
+      TRACE = -1
+
+      def severity_to_string(severity)
+        case severity
+        when TRACE   then "TRACE"
+        when DEBUG   then "DEBUG"
+        when INFO    then "INFO"
+        when WARN    then "WARN"
+        when ERROR   then "ERROR"
+        when FATAL   then "FATAL"
+        when UNKNOWN then "UNKNOWN"
+        end
+      end
+    end
+    include Severity
+
+    # The progname (facility) for this instance.
+    attr_accessor :progname
+
+    # The logging level. Messages below this severity will not be logged at all.
+    attr_accessor :level
+
+    # The incident threshold. Messages at or above this severity will generate an
+    # incident and be published to incident reporters.
+    attr_accessor :threshold
+
+    # The buffer size limit. Each log level will retain this number of messages
+    # at maximum.
+    attr_accessor :sizelimit
+
+    attr_accessor :buffers
+
+    # Create a new IncidentLogger.
+    def initialize(progname = nil, options = {})
+      @progname = progname || "default"
+      @level = options[:level] || DEBUG
+      @threshold = options[:threshold] || ERROR
+      @sizelimit = options[:sizelimit] || 100
+
+      @buffer_mutex = Mutex.new
+      @buffers = Hash.new do |progname_hash, pn|
+        @buffer_mutex.synchronize do
+          progname_hash[pn] = Hash.new do |severity_hash, severity|
+            severity_hash[severity] = RingBuffer.new(@sizelimit)
+          end
+        end
+      end
+
+      # When the IncidentLogger itself encounters an error, it falls back to logging to stderr
+      @fallback_logger = ::Logger.new(STDERR)
+      @fallback_logger.progname = "FALLBACK"
+    end
+
+    # add an event.
+    def add(severity, message = nil, progname = nil, &block)
+      progname ||= @progname
+      severity ||= UNKNOWN
+
+      return event.id if severity < @level
+
+      if message.nil? && !block_given?
+        message = progname
+        progname = @progname
+      end
+
+      event = LogEvent.new(severity, message, progname, &block)
+
+      @buffers[progname][severity] << event
+
+      if severity >= @threshold
+        begin
+          Celluloid::Notifications.notifier.async.publish(incident_topic, create_incident(event))
+        rescue => ex
+          @fallback_logger.error(ex)
+        end
+      end
+      event.id
+    end
+    alias log add
+
+    # See docs for Logger#info
+    def trace(progname = nil, &block)
+      add(TRACE,   nil, progname, &block)
+    end
+
+    def debug(progname = nil, &block)
+      add(DEBUG,   nil, progname, &block)
+    end
+
+    def info(progname = nil, &block)
+      add(INFO,    nil, progname, &block)
+    end
+
+    def warn(progname = nil, &block)
+      add(WARN,    nil, progname, &block)
+    end
+
+    def error(progname = nil, &block)
+      add(ERROR,   nil, progname, &block)
+    end
+
+    def fatal(progname = nil, &block)
+      add(FATAL,   nil, progname, &block)
+    end
+
+    def unknown(progname = nil, &block)
+      add(UNKNOWN, nil, progname, &block)
+    end
+
+    def flush
+      messages = []
+      @buffer_mutex.synchronize do
+        @buffers.each do |_progname, severities|
+          severities.each do |_severity, buffer|
+            messages += buffer.flush
+          end
+        end
+      end
+      messages.sort
+    end
+
+    def clear
+      @buffer_mutex.synchronize do
+        @buffers.each(&:clear)
+      end
+    end
+
+    def create_incident(event = nil)
+      Incident.new(flush, event)
+    end
+
+    def incident_topic
+      "log.incident.#{@progname}"
+    end
+  end
+end

data/lib/celluloid/logging/incident_reporter.rb

@@ -0,0 +1,49 @@
+require "logger"
+
+module Celluloid
+  # Subscribes to log incident topics to report on them.
+  class IncidentReporter
+    include Celluloid
+    include Celluloid::Notifications
+
+    # get the time from the event
+    class Formatter < ::Logger::Formatter
+      def call(severity, _time, progname, msg)
+        super(severity, msg.time, progname, msg.message)
+      end
+    end
+
+    def initialize(*args)
+      subscribe(/log\.incident/, :report)
+      @logger = ::Logger.new(*args)
+      @logger.formatter = Formatter.new
+      @silenced = false
+    end
+
+    def report(_topic, incident)
+      return if @silenced
+
+      header = "INCIDENT"
+      header << " AT #{incident.triggering_event.time}" if incident.triggering_event
+      @logger << header
+      @logger << "\n"
+      @logger << "====================\n"
+      incident.events.each do |event|
+        @logger.add(event.severity, event, event.progname)
+      end
+      @logger << "====================\n"
+    end
+
+    def silence
+      @silenced = true
+    end
+
+    def unsilence
+      @silenced = false
+    end
+
+    def silenced?
+      @silenced
+    end
+  end
+end

data/lib/celluloid/logging/log_event.rb

@@ -0,0 +1,20 @@
+module Celluloid
+  # Wraps a single log event.
+  class LogEvent
+    attr_accessor :id, :severity, :message, :progname, :time
+
+    def initialize(severity, message, progname, time = Time.now, &_block)
+      # This id should be ordered. For now relies on Celluloid::UUID to be ordered.
+      # May want to use a generation/counter strategy for independence of uuid.
+      @id = Internals::UUID.generate
+      @severity = severity
+      @message = block_given? ? yield : message
+      @progname = progname
+      @time = time
+    end
+
+    def <=>(other)
+      @id <=> other.id
+    end
+  end
+end

data/lib/celluloid/logging/ring_buffer.rb

@@ -0,0 +1,64 @@
+module Celluloid
+  class RingBuffer
+    def initialize(size)
+      @size = size
+      @start = 0
+      @count = 0
+      @buffer = Array.new(size)
+      @mutex = Mutex.new
+    end
+
+    def full?
+      @count == @size
+    end
+
+    def empty?
+      @count == 0
+    end
+
+    def push(value)
+      @mutex.synchronize do
+        stop = (@start + @count) % @size
+        @buffer[stop] = value
+        if full?
+          @start = (@start + 1) % @size
+        else
+          @count += 1
+        end
+        value
+      end
+    end
+    alias << push
+
+    def shift
+      @mutex.synchronize do
+        remove_element
+      end
+    end
+
+    def flush
+      values = []
+      @mutex.synchronize do
+        values << remove_element until empty?
+      end
+      values
+    end
+
+    def clear
+      @buffer = Array.new(@size)
+      @start = 0
+      @count = 0
+    end
+
+    private
+
+    def remove_element
+      return nil if empty?
+      value = @buffer[@start]
+      @buffer[@start] = nil
+      @start = (@start + 1) % @size
+      @count -= 1
+      value
+    end
+  end
+end

data/lib/celluloid/mailbox/evented.rb

@@ -26,13 +26,17 @@ module Celluloid
             @messages << message
           end
         ensure
-          @mutex.unlock rescue nil
+          begin
+            @mutex.unlock
+          rescue
+            nil
+          end
         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
+        rescue => ex
+          Internals::Logger.crash "reactor crashed", ex
           dead_letter(message)
         end
         nil
@@ -50,7 +54,7 @@ module Celluloid
         @reactor.run_once(timeout)
 
         # No message was received:
-        return nil
+        nil
       end
 
       # Obtain the next message from the mailbox that matches the given block
@@ -59,7 +63,11 @@ module Celluloid
         begin
           super(&block)
         ensure
-          @mutex.unlock rescue nil
+          begin
+            @mutex.unlock
+          rescue
+            nil
+          end
         end
       end
 

data/lib/celluloid/mailbox.rb

@@ -1,5 +1,3 @@
-require "thread"
-
 module Celluloid
   class MailboxDead < Celluloid::Error; end # you can't receive from the dead
   class MailboxShutdown < Celluloid::Error; end # raised if the mailbox can no longer be used
@@ -41,7 +39,11 @@ module Celluloid
         @condition.signal
         nil
       ensure
-        @mutex.unlock rescue nil
+        begin
+          @mutex.unlock
+        rescue
+          nil
+        end
       end
     end
 
@@ -52,7 +54,7 @@ module Celluloid
 
       @mutex.lock
       begin
-        fail MailboxDead, "attempted to receive from a dead mailbox" if @dead
+        raise MailboxDead, "attempted to receive from a dead mailbox" if @dead
 
         message = nil
         Timers::Wait.for(timeout) do |remaining|
@@ -63,7 +65,11 @@ module Celluloid
           @condition.wait(@mutex, remaining)
         end
       ensure
-        @mutex.unlock rescue nil
+        begin
+          @mutex.unlock
+        rescue
+          nil
+        end
       end
 
       message
@@ -73,17 +79,17 @@ module Celluloid
     # timeout is exceeded, raise a TaskTimeout.
     def receive(timeout = nil, &block)
       message = nil
-      Timers::Wait.for(timeout) do |remaining|
+      Timers::Wait.for(timeout) do |_remaining|
         message = check(timeout, &block)
         break if message
       end
       return message if message
-      fail TaskTimeout.new("receive timeout exceeded")
+      raise TaskTimeout, "receive timeout exceeded"
     end
 
     # Shut down this mailbox and clean up its contents
     def shutdown
-      fail MailboxDead, "mailbox already shutdown" if @dead
+      raise MailboxDead, "mailbox already shutdown" if @dead
 
       @mutex.lock
       begin
@@ -92,7 +98,11 @@ module Celluloid
         @messages = []
         @dead = true
       ensure
-        @mutex.unlock rescue nil
+        begin
+          @mutex.unlock
+        rescue
+          nil
+        end
       end
 
       messages.each do |msg|
@@ -147,7 +157,10 @@ module Celluloid
     end
 
     def dead_letter(message)
+      # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+      # rubocop:disable Style/GlobalVars
       Internals::Logger.debug "Discarded message (mailbox is dead): #{message}" if $CELLULOID_DEBUG
+      # rubocop:enable Style/GlobalVars
     end
 
     def mailbox_full

data/lib/celluloid/notifications.rb

@@ -0,0 +1,95 @@
+module Celluloid
+  module Notifications
+    def self.notifier
+      Actor[:notifications_fanout] || raise(DeadActorError, "notifications fanout actor not running")
+    end
+
+    def publish(pattern, *args)
+      Celluloid::Notifications.notifier.publish(pattern, *args)
+    rescue DeadActorError
+      # Bad shutdown logic. Oh well....
+      # TODO: needs a tests
+    end
+
+    module_function :publish
+
+    def subscribe(pattern, method)
+      Celluloid::Notifications.notifier.subscribe(Actor.current, pattern, method)
+    end
+
+    def unsubscribe(*args)
+      Celluloid::Notifications.notifier.unsubscribe(*args)
+    end
+
+    class Fanout
+      include Celluloid
+      trap_exit :prune
+
+      def initialize
+        @subscribers = []
+        @listeners_for = {}
+      end
+
+      def subscribe(actor, pattern, method)
+        subscriber = Subscriber.new(actor, pattern, method).tap do |s|
+          @subscribers << s
+        end
+        link actor
+        @listeners_for.clear
+        subscriber
+      end
+
+      def unsubscribe(subscriber)
+        @subscribers.reject! { |s| s.matches?(subscriber) }
+        @listeners_for.clear
+      end
+
+      def publish(pattern, *args)
+        listeners_for(pattern).each { |s| s.publish(pattern, *args) }
+      end
+
+      def listeners_for(pattern)
+        @listeners_for[pattern] ||= @subscribers.select { |s| s.subscribed_to?(pattern) }
+      end
+
+      def listening?(pattern)
+        listeners_for(pattern).any?
+      end
+
+      def prune(actor, _reason = nil)
+        @subscribers.reject! { |s| s.actor == actor }
+        @listeners_for.clear
+      end
+    end
+
+    class Subscriber
+      attr_accessor :actor, :pattern, :method
+
+      def initialize(actor, pattern, method)
+        @actor = actor
+        @pattern = pattern
+        @method = method
+      end
+
+      def publish(pattern, *args)
+        actor.async method, pattern, *args
+      rescue DeadActorError
+        # TODO: needs a tests
+        # Bad shutdown logic. Oh well....
+      end
+
+      def subscribed_to?(pattern)
+        !pattern || @pattern === pattern.to_s || @pattern === pattern
+      end
+
+      def matches?(subscriber_or_pattern)
+        self === subscriber_or_pattern ||
+          @pattern && @pattern === subscriber_or_pattern
+      end
+    end
+  end
+
+  def self.publish(*args)
+    Notifications.publish(*args)
+  end
+end

data/lib/celluloid/pool.rb

@@ -0,0 +1,6 @@
+require "celluloid" unless defined? Celluloid
+
+require "celluloid/supervision"
+
+require "celluloid/supervision/container/pool"
+require "celluloid/supervision/container/behavior/pool"