celluloid 0.18.0.pre → 0.18.0

data/lib/celluloid/internals/responses.rb

@@ -0,0 +1,46 @@
+module Celluloid
+  module Internals
+    # Responses to calls
+    class Response
+      attr_reader :call, :value
+
+      def initialize(call, value)
+        @call = call
+        @value = value
+      end
+
+      def dispatch
+        @call.task.resume self
+      end
+
+      # Call completed successfully
+      class Success < Response; end
+
+      # Call was aborted due to sender error
+      class Error < Response
+        def value
+          ex = super
+          ex = ex.cause if ex.is_a? Celluloid::AbortError
+
+          if ex.backtrace
+            ex.backtrace << "(celluloid):0:in `remote procedure call'"
+            ex.backtrace.concat(caller)
+          end
+
+          raise ex
+        end
+      end
+
+      class Block
+        def initialize(call, result)
+          @call = call
+          @result = result
+        end
+
+        def dispatch
+          @call.task.resume(@result)
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/internals/signals.rb

@@ -0,0 +1,24 @@
+module Celluloid
+  module Internals
+    # Event signaling between methods of the same object
+    class Signals
+      def initialize
+        @conditions = {}
+      end
+
+      # Wait for the given signal and return the associated value
+      def wait(name)
+        raise "cannot wait for signals while exclusive" if Celluloid.exclusive?
+
+        @conditions[name] ||= Condition.new
+        @conditions[name].wait
+      end
+
+      # Send a signal to all method calls waiting for the given name
+      def broadcast(name, value = nil)
+        condition = @conditions.delete(name)
+        condition.broadcast(value) if condition
+      end
+    end
+  end
+end

data/lib/celluloid/internals/stack.rb

@@ -0,0 +1,74 @@
+module Celluloid
+  module Internals
+    class Stack
+      attr_accessor :actors, :threads
+
+      def initialize(threads)
+        @group = threads
+        @actors  = []
+        @threads = []
+      end
+
+      def snapshot(backtrace = nil)
+        @group.each do |thread|
+          if thread.role == :actor
+            @actors << snapshot_actor(thread.actor, backtrace) if thread.actor
+          else
+            @threads << snapshot_thread(thread, backtrace)
+          end
+        end
+      end
+
+      def snapshot_actor(actor, backtrace = nil)
+        state = ActorState.new
+        state.id = actor.object_id
+
+        # TODO: delegate to the behavior
+        state.cell = snapshot_cell(actor.behavior) if actor.behavior.is_a?(Cell)
+
+        tasks = actor.tasks
+        if tasks.empty?
+          state.status = :idle
+        else
+          state.status = :running
+          state.tasks = tasks.to_a.map { |t| TaskState.new(t.class, t.type, t.meta, t.status, t.backtrace) }
+        end
+
+        state.backtrace = actor.thread.backtrace if backtrace && actor.thread
+        state
+      end
+
+      def snapshot_cell(behavior)
+        state = CellState.new
+        state.subject_id = behavior.subject.object_id
+        state.subject_class = behavior.subject.class
+        state
+      end
+
+      def snapshot_thread(thread, backtrace = nil)
+        if backtrace
+          backtrace = begin
+                        thread.backtrace
+                      rescue NoMethodError # for Rubinius < 2.5.2.c145
+                        []
+                      end
+        end
+        ThreadState.new(thread.object_id, backtrace, thread.role)
+      end
+
+      def print(output = STDERR)
+        @actors.each do |actor|
+          output.print actor.dump
+        end
+
+        @threads.each do |thread|
+          output.print thread.dump
+        end
+      end
+    end
+  end
+end
+
+require "celluloid/internals/stack/states"
+require "celluloid/internals/stack/dump"
+require "celluloid/internals/stack/summary"

data/lib/celluloid/internals/stack/dump.rb

@@ -0,0 +1,12 @@
+module Celluloid
+  module Internals
+    class Stack
+      class Dump < Stack
+        def initialize(threads)
+          super(threads)
+          snapshot(true)
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/internals/stack/states.rb

@@ -0,0 +1,72 @@
+module Celluloid
+  module Internals
+    class Stack
+      module DisplayBacktrace
+        def display_backtrace(backtrace, output, indent = nil)
+          backtrace ||= ["EMPTY BACKTRACE"]
+          backtrace.each do |line|
+            output << indent if indent
+            output << "\t" << line << "\n"
+          end
+          output << "\n\n"
+        end
+      end
+
+      class TaskState < Struct.new(:task_class, :type, :meta, :status, :backtrace); end
+
+      class CellState < Struct.new(:subject_id, :subject_class)
+        def dump
+          "Celluloid::Cell 0x#{subject_id.to_s(16)}: #{subject_class}"
+        end
+      end
+
+      class ThreadState < Struct.new(:thread_id, :backtrace, :role)
+        include DisplayBacktrace
+        def dump
+          string = ""
+          string << "Thread 0x#{thread_id.to_s(16)} (#{role}):\n"
+          display_backtrace backtrace, string if backtrace
+          string
+        end
+      end
+
+      class ActorState
+        include DisplayBacktrace
+        attr_accessor :name, :id, :cell
+        attr_accessor :status, :tasks
+        attr_accessor :backtrace
+
+        def dump
+          string = ""
+          string << "Celluloid::Actor 0x#{id.to_s(16)}"
+          string << " [#{name}]" if name
+          string << "\n"
+
+          if cell
+            string << cell.dump
+            string << "\n"
+          end
+
+          if status == :idle
+            string << "State: Idle (waiting for messages)\n"
+            display_backtrace backtrace, string if backtrace
+          else
+            string << "State: Running (executing tasks)\n"
+            display_backtrace backtrace, string if backtrace
+            string << "\tTasks:\n"
+
+            tasks.each_with_index do |task, i|
+              string << "\t  #{i + 1}) #{task.task_class}[#{task.type}]: #{task.status}\n"
+              if task.backtrace
+                string << "\t      #{task.meta.inspect}\n"
+                display_backtrace task.backtrace, string, "\t"
+              end
+            end
+          end
+          string << "\n" unless backtrace
+          string
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/internals/stack/summary.rb

@@ -0,0 +1,12 @@
+module Celluloid
+  module Internals
+    class Stack
+      class Summary < Stack
+        def initialize(threads)
+          super(threads)
+          snapshot
+        end
+      end
+    end
+  end
+end

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