drbdump 1.0

data/lib/drbdump/loader.rb

@@ -0,0 +1,75 @@
+require 'marshal/structure'
+
+##
+# A DRb protocol message chunk loader.
+#
+# Based on DRb::DRbMessage
+
+class DRbDump::Loader
+
+  ##
+  # Base Loader error class
+
+  class Error < DRbDump::Error; end
+
+  ##
+  # Raised when the message content is missing or too short
+
+  class DataError < Error; end
+
+  ##
+  # Raised when the packet is too large
+
+  class TooLarge < Error; end
+
+  ##
+  # Raised when the packet is not large enough to complete a message
+
+  class Premature < Error; end
+
+  ##
+  # Raised when the message size is incorrect or missing
+
+  class SizeError < Error; end
+
+  ##
+  # Creates a new loader with the given +config+ Hash.  The loader uses only
+  # the :load_limit key to limit the maximum message size.
+
+  def initialize config
+    @load_limit = config[:load_limit]
+  end
+
+  ##
+  # Returns the next component from a DRb message +stream+ as a
+  # Marshal::Structure object.
+
+  def load stream
+    begin
+      size = stream.read 4
+    rescue => e
+      raise SizeError, e.message, e.backtrace
+    end
+
+    raise SizeError, 'connection closed' unless size
+    raise Premature, 'header' if size.size < 4
+
+    size, = size.unpack 'N'
+
+    raise TooLarge, "#{size} bytes (#{@load_limit} allowed)" if
+      size >= @load_limit
+
+    begin
+      data = stream.read size
+    rescue => e
+      raise DataError, e.message, e.backtrace
+    end
+
+    raise DataError, 'connection closed' unless data
+    raise Premature, 'Marshal' if data.bytesize < size
+
+    Marshal::Structure.new data
+  end
+
+end
+

data/lib/drbdump/message.rb

@@ -0,0 +1,72 @@
+##
+# Contains common parts of MessageSend and MessageResult
+
+class DRbDump::Message
+
+  ##
+  # Creates the appropriate message instance from the next +packet+ which was
+  # captured by +drbdump+ on the given +stream+.
+
+  def self.from_stream drbdump, packet, stream
+    loader = drbdump.loader
+
+    first_chunk = loader.load stream
+
+    case first_chunk.load
+    when nil, Integer then
+      DRbDump::MessageSend.new drbdump, packet, first_chunk, stream
+    when true, false then
+      DRbDump::MessageResult.new drbdump, packet, first_chunk, stream
+    end
+  end
+
+  ##
+  # Initializes a message from +packet+ captured by a +drbdump+
+
+  def initialize drbdump, packet
+    @drbdump     = drbdump
+    @loader      = drbdump.loader
+    @packet      = packet
+    @statistics  = drbdump.statistics
+
+    @source      = nil
+    @destination = nil
+  end
+
+  ##
+  # The resolved destination for the message.
+
+  def destination
+    return @destination if @destination
+
+    resolve_addresses
+
+    @destination
+  end
+
+  ##
+  # Resolves source and destination addresses
+
+  def resolve_addresses # :nodoc:
+    resolver = @drbdump.resolver
+
+    source = @packet.source resolver
+    @source = "\"druby://#{source.sub(/\.(\d+)$/, ':\1')}\""
+
+    destination = @packet.destination resolver
+    @destination = "\"druby://#{destination.sub(/\.(\d+)$/, ':\1')}\""
+  end
+
+  ##
+  # The resolved source of the message
+
+  def source
+    return @source if @source
+
+    resolve_addresses
+
+    @source
+  end
+
+end
+

data/lib/drbdump/message_result.rb

@@ -0,0 +1,84 @@
+##
+# Wraps a DRb message-result after consuming it from a stream.
+
+class DRbDump::MessageResult < DRbDump::Message
+
+  ##
+  # Creates a new MessageResult for the creating +drbdump+ instance.  The last
+  # packet in the message is +packet+ and the Marshal::Structure for the
+  # result type is +status+.  The rest of the message will be loaded from
+  # +stream+.
+
+  def initialize drbdump, packet, status, stream
+    super drbdump, packet
+
+    @result     = nil
+    @status     = nil
+    @stream     = stream
+
+    @raw_result = @loader.load stream
+    @raw_status = status
+  end
+
+  ##
+  # The number of allocations required to load the result.
+
+  def allocations
+    @raw_status.count_allocations + @raw_result.count_allocations
+  end
+
+  ##
+  # Prints the message information to standard output
+
+  def display
+    update_statistics
+
+    return if @drbdump.quiet
+
+    message   = status ? 'success' : 'exception'
+    arrow     = status ? "\u21d0"  : "\u2902"
+    timestamp = self.timestamp.strftime DRbDump::TIMESTAMP_FORMAT
+
+    puts "%s %s %s %s %s: %s" % [
+      timestamp, destination, arrow, source, message, result
+    ]
+  end
+
+  ##
+  # The loaded result object
+
+  def result
+    return @result if @result
+
+    result = @drbdump.load_marshal_data @raw_result
+
+    @result = if DRb::DRbObject === result then
+               "(\"druby://#{result.__drburi}\", #{result.__drbref})"
+             else
+               result.inspect
+             end
+  end
+
+  ##
+  # The loaded status object
+
+  def status
+    @status ||= @raw_status.load
+  end
+
+  ##
+  # The timestamp of the last packet in the result
+
+  def timestamp
+    @packet.timestamp
+  end
+
+  ##
+  # Updates the drbdump's statistics with information from this result.
+
+  def update_statistics # :nodoc:
+    @statistics.add_result self
+  end
+
+end
+

data/lib/drbdump/message_send.rb

@@ -0,0 +1,146 @@
+##
+# Wraps a DRb message-send after consuming it from a stream.
+
+class DRbDump::MessageSend < DRbDump::Message
+
+  ##
+  # The number of arguments, not including the block
+
+  attr_reader :argc
+
+  ##
+  # The arguments, each as a Marshal::Structure
+
+  attr_reader :raw_argv
+
+  ##
+  # The block as a Marshal::Structure
+
+  attr_reader :raw_block
+
+  ##
+  # The message sent as a Marshal::Structure
+
+  attr_reader :raw_message
+
+  ##
+  # Creates a new MessageSend for the creating +drbdump+ instance.  The last
+  # packet in the message is +packet+ and the Marshal::Structure for the first
+  # argument is +receiver+.  The rest of the message will be loaded from
+  # +stream+.
+
+  def initialize drbdump, packet, receiver, stream
+    super drbdump, packet
+
+    @argc         = nil
+    @argv         = nil
+    @block        = nil
+    @message      = nil
+    @raw_receiver = receiver
+    @stream       = stream
+
+    load_message if stream
+  end
+
+  ##
+  # The number of allocations required to load the message.
+
+  def allocations
+    allocations = 0
+
+    allocations += @raw_receiver.count_allocations
+    allocations += @raw_message.count_allocations
+    @raw_argv.each { |arg| allocations += arg.count_allocations }
+    allocations += @raw_block.count_allocations
+
+    allocations
+  end
+
+  ##
+  # A string containing all loaded arguments including the block.
+
+  def arguments
+    arguments = argv.map { |obj| obj.inspect }
+    (arguments << '&block') if block
+    arguments.join ', '
+  end
+
+  ##
+  # Number of arguments including the block
+
+  def argument_count
+    @argc + (block ? 1 : 0)
+  end
+
+  ##
+  # The loaded arguments
+
+  def argv
+    @argv ||= @raw_argv.map { |obj| @drbdump.load_marshal_data obj }
+  end
+
+  ##
+  # The loaded block
+
+  def block
+    @block ||= @raw_block.load
+  end
+
+  ##
+  # Prints the message information to standard output
+
+  def display
+    update_statistics
+
+    return if @drbdump.quiet
+
+    timestamp = self.timestamp.strftime DRbDump::TIMESTAMP_FORMAT
+
+    puts "%s %s \u21d2 (%s, %p).%s(%s)" % [
+      timestamp, source, destination, receiver, message, arguments
+    ]
+  end
+
+  ##
+  # Returns the message, arguments and block for the DRb message-send in
+  # +stream+.
+
+  def load_message # :nodoc:
+    @raw_message = @loader.load @stream
+    @argc        = @loader.load(@stream).load
+    @raw_argv    = @argc.times.map { @loader.load @stream }
+    @raw_block   = @loader.load @stream
+  end
+
+  ##
+  # The loaded message
+
+  def message
+    @message ||= @raw_message.load
+  end
+
+  ##
+  # The loaded receiver for the message
+
+  def receiver
+    @receiver ||= @raw_receiver.load
+  end
+
+  ##
+  # Returns the timestamp for the first packet in the incomplete stream for
+  # +packet+ or the packet's timestamp if this is the only packet in the
+  # stream.
+
+  def timestamp
+    @drbdump.incomplete_timestamps.delete(@packet.source) || @packet.timestamp
+  end
+
+  ##
+  # Updates the drbdump's statistics with information from this message.
+
+  def update_statistics # :nodoc:
+    @statistics.add_message_send self
+  end
+
+end
+

data/lib/drbdump/statistic.rb

@@ -0,0 +1,90 @@
+##
+# Stores the minimum, maximum, mean, count and standard deviation for a set of
+# values but not the values themselves.
+
+class DRbDump::Statistic
+
+  ##
+  # The number of items in the set
+
+  attr_reader :count
+
+  ##
+  # The maximum value added
+
+  attr_reader :max
+
+  ##
+  # The mean of all values
+
+  attr_reader :mean
+
+  ##
+  # The minimum value added
+
+  attr_reader :min
+
+  def initialize # :nodoc:
+    @M_2   = 0.0
+    @count = 0
+    @max   = -Float::INFINITY
+    @mean  = 0.0
+    @min   = Float::INFINITY
+  end
+
+  ##
+  # Adds +value+ to the set of values.  Returns the number of values.
+
+  def add value
+    @min = value if value < @min
+    @max = value if value > @max
+    @count += 1
+
+    delta  = value - @mean
+    @mean += delta / @count
+    @M_2  += delta * (value - @mean)
+
+    @count
+  end
+
+  ##
+  # The average of all values
+
+  alias average mean
+
+  ##
+  # The maximum value added
+
+  alias maximum max
+
+  ##
+  # The minimum value added
+
+  alias minimum min
+
+  ##
+  # The sample variance for all values
+
+  def sample_variance
+    sv = @M_2 / (@count - 1)
+    return 0.0 if sv.nan?
+    sv
+  end
+
+  ##
+  # The standard deviation of all values
+
+  def standard_deviation
+    Math.sqrt sample_variance
+  end
+
+  ##
+  # An array containing the number of values in the set, the mean and the
+  # standard deviation
+
+  def to_a
+    [@count, @min, @mean, @max, standard_deviation]
+  end
+
+end
+