drbdump 1.0

data/lib/drbdump/statistics.rb

@@ -0,0 +1,318 @@
+##
+# Collects and displays statistics on captured packets.
+
+class DRbDump::Statistics
+
+  ##
+  # Number of DRb exceptions raised
+
+  attr_accessor :drb_exceptions_raised
+
+  ##
+  # Number of DRb results received
+
+  attr_accessor :drb_results_received
+
+  ##
+  # Number of DRb messages sent
+
+  attr_accessor :drb_messages_sent
+
+  ##
+  # Number of DRb packets seen
+
+  attr_accessor :drb_packet_count
+
+  ##
+  # Records the last timestamp for a message sent between peers
+
+  attr_accessor :last_peer_send
+
+  ##
+  # Records the last message sent between peers
+
+  attr_accessor :last_sent_message
+
+  ##
+  # Records statistics about allocations required to send a message.  The
+  # outer key is the message name while the inner key is the argument count
+  # (including block).
+
+  attr_accessor :message_allocations
+
+  ##
+  # Records statistics about latencies for sent messages.  The outer key is
+  # the message name while the inner key is the argument count (including
+  # block).
+  #
+  # The recorded latency is from the first packet in the message-send to the
+  # last packet in the message result.
+
+  attr_accessor :message_latencies
+
+  ##
+  # Records statistics about latencies for messages sent between peers
+
+  attr_accessor :peer_latencies
+
+  ##
+  # Number of Rinda packets seen
+
+  attr_accessor :rinda_packet_count
+
+  ##
+  # Number of packets seen, including non-DRb traffic
+
+  attr_accessor :total_packet_count
+
+  def initialize # :nodoc:
+    @drb_exceptions_raised = 0
+    @drb_results_received  = 0
+    @drb_messages_sent     = 0
+    @drb_packet_count      = 0
+    @rinda_packet_count    = 0
+    @total_packet_count    = 0
+
+    # [message][argc]
+    @message_allocations = two_level_statistic_hash
+    @message_latencies   = two_level_statistic_hash
+
+    # [source][destination]
+    @peer_latencies = two_level_statistic_hash
+
+    @last_peer_send = Hash.new do |sources, source|
+      sources[source] = Hash.new
+    end
+
+    @last_sent_message = Hash.new do |sources, source|
+      sources[source] = Hash.new
+    end
+  end
+
+  ##
+  # Adds information from +message+
+
+  def add_message_send message
+    @drb_messages_sent += 1
+
+    msg  = message.message
+    argc = message.argument_count
+
+    source      = message.source
+    destination = message.destination
+
+    @last_peer_send[source][destination] = message.timestamp
+    @last_sent_message[source][destination] = msg, argc, message.allocations
+  end
+
+  ##
+  # Adds information from +result+
+
+  def add_result result
+    source      = result.source
+    destination = result.destination
+
+    @drb_results_received += 1
+    @drb_exceptions_raised += 1 unless result.status
+
+    sent_timestamp = @last_peer_send[destination].delete source
+    message, argc, allocations = @last_sent_message[destination].delete source
+
+    return unless sent_timestamp
+
+    latency = result.timestamp - sent_timestamp
+
+    @peer_latencies[destination][source].add latency
+    @message_latencies[message][argc].add latency
+    @message_allocations[message][argc].add allocations + result.allocations
+  end
+
+  ##
+  # Adjusts units in +stats+ from +unit+ to milli-unit if the minimum value is
+  # below the required threshold
+
+  def adjust_units stats, unit # :nodoc:
+    if stats.first > 0.05 then
+      stats << unit
+      return stats
+    end
+
+    unit.replace "m#{unit}"
+
+    stats = stats.map { |stat| stat * 1000 }
+
+    stats << unit
+  end
+
+  ##
+  # Extracts data and column widths from +data+
+
+  def extract_and_size data # :nodoc:
+    max_outer_size = 0
+    max_inner_size = 0
+    max_count      = 0
+
+    rows = []
+
+    data.each do |outer_key, inner|
+      max_outer_size = [max_outer_size, outer_key.to_s.size].max
+
+      inner.each do |inner_key, stat|
+        count, *rest = stat.to_a
+
+        rows << [outer_key, inner_key, count, *rest]
+
+        max_inner_size = [max_inner_size, inner_key.to_s.size].max
+        max_count      = [max_count, count].max
+      end
+    end
+
+    max_count_size = max_count.to_s.size
+
+    return max_outer_size, max_inner_size, max_count_size, rows
+  end
+
+  ##
+  # Merges +allocation_rows+ and +latency_rows+ into a single data set.
+
+  def merge_results allocation_rows, latency_rows # :nodoc:
+    allocations = allocation_rows.group_by { |message, argc,| [message, argc] }
+    latencies   = latency_rows.group_by { |message, argc,| [message, argc] }
+
+    allocations.map do |group, (row, _)|
+      latency_row, = latencies.delete(group)
+
+      if latency_row then
+        row.concat latency_row.last 4
+      else
+        row.concat [0, 0, 0, 0]
+      end
+    end
+  end
+
+  ##
+  # Collapses multiple single-message peers in +rows+ to a single row.
+
+  def multiple_peers count_size, source_size, destination_size, rows # :nodoc:
+    rows = rows.sort_by { |_, _, count| -count }
+
+    rows.map do |source, destination, count, *stats|
+      stats = adjust_units stats, 's'
+
+      '%2$*1$d messages: %4$*3$s to %6$*5$s; ' % [
+        count_size, count, source_size, source, destination_size, destination
+      ] +
+      '%0.3f, %0.3f, %0.3f, %0.3f %s' % stats
+    end
+  end
+
+  def per_message_results # :nodoc:
+    name_size, argc_size, sends_size, allocation_rows =
+      extract_and_size @message_allocations
+
+    _, _, _, latency_rows = extract_and_size @message_latencies
+
+    rows = merge_results allocation_rows, latency_rows
+
+    rows = rows.sort_by { |message, argc, count,| [-count, message, argc] }
+
+    return name_size, argc_size, sends_size, rows
+  end
+
+  ##
+  # Creates a two-level statistic hash with a DRbDump::Statistic as the inner
+  # object for the keys.
+
+  def two_level_statistic_hash # :nodoc:
+    Hash.new do |outer, outer_key|
+      outer[outer_key] = Hash.new do |inner, inner_key|
+        inner[inner_key] = DRbDump::Statistic.new
+      end
+    end
+  end
+
+  ##
+  # Writes all statistics on packets and messages processesed to $stdout
+
+  def show
+    show_basic
+    puts
+    show_messages
+    puts
+    show_peers
+  end
+
+  ##
+  # Writes basic statistics on packets and messages processed to $stdout
+
+  def show_basic
+    puts "#{@total_packet_count} total packets captured"
+    puts "#{@rinda_packet_count} Rinda packets captured"
+    puts "#{@drb_packet_count} DRb packets captured"
+    puts "#{@drb_messages_sent} messages sent"
+    puts "#{@drb_results_received} results received"
+    puts "#{@drb_exceptions_raised} exceptions raised"
+  end
+
+  ##
+  # Shows peer statistics
+
+  def show_peers
+    source_size, destination_size, count_size, rows =
+      extract_and_size @peer_latencies
+
+    multiple, single = rows.partition { |_, _, count| count > 1 }
+
+    multiple << single.pop if single.length == 1
+
+    count_size = [count_size, single.length.to_s.size].max
+
+    puts 'Peers min, avg, max, stddev:'
+    puts multiple_peers count_size, source_size, destination_size, multiple
+    puts single_peers count_size, single unless single.empty?
+  end
+
+  ##
+  # Shows message-send statistics including arguments per calls, count of
+  # calls and average and standard deviation of allocations.
+
+  def show_messages # :nodoc:
+    name_size, argc_size, sends_size, rows = per_message_results
+
+    output = rows.map do |message, argc, count, *stats|
+      allocation_stats = stats.first 4
+      latency_stats   = adjust_units stats.last(4), 's'
+
+      '%-2$*1$s (%4$*3$s args) %6$*5$d sent; ' % [
+          name_size, message, argc_size, argc, sends_size, count,
+      ] +
+      '%0.1f, %0.1f, %0.1f, %0.1f allocations; ' % allocation_stats +
+      '%0.3f, %0.3f, %0.3f, %0.3f %s' % latency_stats
+    end
+
+    puts 'Messages sent min, avg, max, stddev:'
+    puts output
+  end
+
+  ##
+  # Displays single peers
+
+  def single_peers count_size, rows # :nodoc:
+    return if rows.empty?
+
+    statistic = DRbDump::Statistic.new
+
+    rows.each do |_, _, _, value|
+      statistic.add value
+    end
+
+    count, *stats = statistic.to_a
+
+    stats = adjust_units stats, 's'
+
+    '%2$*1$d single-message peers ' % [count_size, count] +
+    '%0.3f, %0.3f, %0.3f, %0.3f %s' % stats
+  end
+
+end
+

data/lib/drbdump/test_case.rb

@@ -0,0 +1,91 @@
+require 'minitest/autorun'
+require 'drbdump'
+require 'pp'
+require 'tempfile'
+
+# force time zone to mine
+ENV['TZ'] = 'PST8PDT'
+
+##
+# A test case for writing DRbDump tests.
+
+class DRbDump::TestCase < MiniTest::Unit::TestCase
+
+  test = File.expand_path '../../../test', __FILE__
+
+  ##
+  # Dump containing DRb messages with arguments
+
+  ARG_DUMP       = File.join test, 'arg.dump'
+
+  ##
+  # Dump containing a packet with a FIN flag
+
+  FIN_DUMP       = File.join test, 'drb_fin.dump'
+
+  ##
+  # Dump containing HTTP packets
+
+  HTTP_DUMP      = File.join test, 'http.dump'
+
+  ##
+  # Dump containing messages from example/ping.rb
+
+  PING_DUMP      = File.join test, 'ping.dump'
+
+  ##
+  # Dump containing Rinda::RingFinger lookups
+
+  RING_DUMP      = File.join test, 'ring.dump'
+
+  ##
+  # Dump containing a DRb message that is too large
+
+  TOO_LARGE_DUMP = File.join test, 'too_large_packet.pcap'
+
+  ##
+  # Creates a new drbdump for +file+ and makes it available as @drbdump.
+  # Calling this again will create a brand new instance.
+
+  def drbdump file = PING_DUMP
+    @drbdump = DRbDump.new devices: [file]
+    @drbdump.instance_variable_set :@running, true
+    @drbdump.resolver = resolver
+
+    @statistics = @drbdump.statistics
+
+    @drbdump
+  end
+
+  ##
+  # Pretty-print minitest diff output
+
+  def mu_pp obj # :nodoc:
+    s = ''
+    s = PP.pp obj, s
+    s.chomp
+  end
+
+  ##
+  # Returns a Capp packet Enumerator for +file+
+
+  def packets file
+    Capp.open(file).loop
+  end
+
+  ##
+  # Creates a resolver for addresses in *_DUMP files
+
+  def resolver
+    Tempfile.open 'hosts' do |io|
+      io.puts '10.101.28.77 kault'
+      io.flush
+
+      resolver = Resolv::Hosts.new io.path
+      resolver.getname '10.101.28.77' # initialize
+      resolver
+    end
+  end
+
+end
+

data/test/test_drbdump.rb

@@ -0,0 +1,283 @@
+require 'drbdump/test_case'
+
+class TestDRbDump < DRbDump::TestCase
+
+  def test_class_process_args_count
+    options = DRbDump.process_args %w[--count 50]
+
+    assert_equal 50, options[:count]
+
+    options = DRbDump.process_args %w[-c 49]
+
+    assert_equal 49, options[:count]
+  end
+
+  def test_class_process_args_defaults
+    options = DRbDump.process_args []
+
+    assert_equal Float::INFINITY,  options[:count]
+    assert_equal [],               options[:devices]
+    assert_equal true,             options[:resolve_names]
+    assert_equal nil,              options[:run_as_directory]
+    assert_equal nil,              options[:run_as_user]
+  end
+
+  def test_class_process_args_devices
+    options = DRbDump.process_args %w[--interface lo0]
+
+    assert_equal %w[lo0], options[:devices]
+
+    options = DRbDump.process_args %w[-i lo0]
+
+    assert_equal %w[lo0], options[:devices]
+
+    options = DRbDump.process_args %w[-i lo0 -i en0]
+
+    assert_equal %w[lo0 en0], options[:devices]
+  end
+
+  def test_class_process_args_invalid
+    e = nil
+    out, err = capture_io do
+      e = assert_raises SystemExit do
+        DRbDump.process_args %w[--no-such-option]
+      end
+    end
+
+    assert_empty out
+    assert_match 'Usage', err
+    assert_match 'no-such-option', err
+
+    assert_equal 1, e.status
+  end
+
+  def test_class_process_args_quiet
+    options = DRbDump.process_args %w[--quiet]
+
+    assert options[:quiet]
+
+    options = DRbDump.process_args %w[-q]
+
+    assert options[:quiet]
+  end
+
+  def test_class_process_args_resolve_names
+    options = DRbDump.process_args %w[-n]
+
+    refute options[:resolve_names]
+  end
+
+  def test_class_process_args_run_as_directory
+    options = DRbDump.process_args %w[--run-as-directory /]
+
+    assert_equal '/', options[:run_as_directory]
+  end
+
+  def test_class_process_args_run_as_user
+    options = DRbDump.process_args %w[--run-as-user nobody]
+
+    assert_equal 'nobody', options[:run_as_user]
+  end
+
+  def test_close_stream
+    drbdump FIN_DUMP
+
+    packet = packets(FIN_DUMP).first
+    @drbdump.drb_streams[packet.source] = true
+    @drbdump.incomplete_streams[packet.source] = ''
+    @drbdump.incomplete_timestamps[packet.source] = Time.now
+
+    @drbdump.close_stream packet.source
+
+    assert_empty @drbdump.drb_streams
+    assert_empty @drbdump.incomplete_streams
+    assert_empty @drbdump.incomplete_timestamps
+  end
+
+  def test_create_capp
+    drbdump RING_DUMP
+
+    packets = @drbdump.create_capp(RING_DUMP).loop.to_a
+
+    refute_empty packets
+
+    packet = packets.first
+
+    assert packet.udp?
+
+    assert_equal Rinda::Ring_PORT, packet.udp_header.destination_port
+  end
+
+  def test_display_drb_count
+    send_msg = packets(ARG_DUMP).find { |packet| packet.payload =~ /ping/ }
+
+    drbdump
+
+    @drbdump.count = 1
+
+    capture_io do
+      @drbdump.display_drb send_msg
+      @drbdump.display_drb send_msg
+    end
+
+    assert_equal 1, @statistics.drb_packet_count
+    assert_equal 1, @statistics.drb_messages_sent
+
+    source, destination = @drbdump.resolve_addresses send_msg
+
+    assert_equal send_msg.timestamp,
+                 @statistics.last_peer_send[source][destination]
+  end
+
+  def test_display_drb_http
+    drbdump
+
+    assert_silent do
+      packets(HTTP_DUMP).each do |packet|
+        @drbdump.display_drb packet
+      end
+    end
+
+    assert_equal 0, @statistics.drb_packet_count
+
+    expected = {
+      '17.149.160.49.80'   => false,
+      '10.101.28.77.53600' => false,
+    }
+
+    assert_equal expected, @drbdump.drb_streams
+  end
+
+  def test_display_drb_incomplete
+    drbdump
+
+    out, = capture_io do
+      packets(FIN_DUMP).each do |packet|
+        @drbdump.display_drb packet
+      end
+    end
+
+    expected = <<-EXPECTED
+22:19:38.279650 "druby://kault:56128" \u21d2 ("druby://kault:56126", nil).ping(1)
+22:19:38.280108 "druby://kault:56128" \u21d0 "druby://kault:56126" success: 1
+22:19:38.280472 "druby://kault:56128" \u2902 "druby://kault:56126" exception: #<DRb::DRbConnError: connection closed>
+22:19:38.280713 "druby://kault:56129" \u21d2 ("druby://kault:56126", nil).ping(2)
+22:19:38.280973 "druby://kault:56129" \u21d0 "druby://kault:56126" success: 2
+22:19:38.281197 "druby://kault:56129" \u2902 "druby://kault:56126" exception: #<DRb::DRbConnError: connection closed>
+    EXPECTED
+
+    assert_equal expected, out
+
+    assert_empty @drbdump.incomplete_streams
+    assert_empty @drbdump.incomplete_timestamps
+
+    assert_equal 4, @statistics.drb_results_received
+    assert_equal 2, @statistics.drb_messages_sent
+  end
+
+  def test_display_drb_too_large
+    out, = capture_io do
+      packets(TOO_LARGE_DUMP).each do |packet|
+        drbdump.display_drb packet
+      end
+    end
+
+    innards = "\x04\bI\"\x04\x00\x00\xE0\x01"
+    innards << ' ' * 468
+
+    expected = <<-EXPECTED
+22:41:07.060619 "druby://kault:56430" to "druby://kault:56428" packet too large, valid: [nil, "<<", 1] too big (31457294 bytes): #{innards.dump}
+    EXPECTED
+
+    assert_equal expected, out
+
+    assert_equal 0, @statistics.drb_packet_count
+  end
+
+  def test_display_drb_too_large_quiet
+    drbdump
+    @drbdump.quiet = true
+
+    assert_silent do
+      packets(TOO_LARGE_DUMP).each do |packet|
+        @drbdump.display_drb packet
+      end
+    end
+  end
+
+  def test_display_ring_finger
+    out, = capture_io do
+      drbdump.display_ring_finger packets(RING_DUMP).first
+    end
+
+    expected = <<-EXPECTED
+19:39:25.877246 find ring on 255.255.255.255.7647 for druby://kault.jijo.segment7.net:53578 timeout: 5
+    EXPECTED
+
+    assert_equal expected, out
+
+    assert_equal 1, @statistics.rinda_packet_count
+  end
+
+  def test_display_ring_finger_quiet
+    drbdump
+    @drbdump.quiet = true
+
+    assert_silent do
+      @drbdump.display_ring_finger packets(RING_DUMP).first
+    end
+
+    assert_equal 1, @statistics.rinda_packet_count
+  end
+
+  def test_load_marshal_data
+    drbdump
+
+    marshal_structure = Marshal::Structure.new "\x04\x08i\x06"
+
+    assert_equal 1, @drbdump.load_marshal_data(marshal_structure)
+
+    marshal_structure = Marshal::Structure.new "\x04\x08o:\x06C\x00"
+
+    loaded = @drbdump.load_marshal_data marshal_structure
+
+    assert_kind_of DRb::DRbUnknown, loaded
+  end
+
+  def test_start_capture
+    drbdump RING_DUMP
+
+    capp = @drbdump.create_capp RING_DUMP
+
+    thread, = @drbdump.start_capture [capp]
+
+    thread.join
+
+    refute_empty @drbdump.incoming_packets
+
+    packet = @drbdump.incoming_packets.deq
+
+    assert packet.udp?
+
+    assert_equal Rinda::Ring_PORT, packet.udp_header.destination_port
+
+    assert_equal packets(RING_DUMP).count, @statistics.total_packet_count
+  end
+
+  def test_start_capture_rst_fin
+    drbdump FIN_DUMP
+
+    packet = packets(FIN_DUMP).first
+    @drbdump.drb_streams[packet.source] = true
+
+    capp = @drbdump.create_capp FIN_DUMP
+
+    thread, = @drbdump.start_capture [capp]
+
+    thread.join
+
+    assert_empty @drbdump.drb_streams
+  end
+
+end
+