drbdump 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b3f2cd54ef03808d4d62ec58bbf6988a5a40657e
+  data.tar.gz: c83c65fb484a4aa329aa943b08c6b63f95061d68
+SHA512:
+  metadata.gz: f8a8f622a06fdadd9495f13136bfc9c8acbb8a1e43d2a427c0cba184830324919f235916ecfb6249cb8637d7207ad7ef5c27fb29d6e19e7552a0cc39d2674af7
+  data.tar.gz: 8ff6002c16d643c7e88300ab91546595a247dc0e5b46a666c8f42bf08e2d89b6ad69f6991db645b4d8a0acb2e41674aba752065ac0b04fde9460ad83547d957c

data/.autotest

@@ -0,0 +1,8 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+Autotest.add_hook :initialize do |at|
+  at.testlib = 'minitest/autorun'
+end
+

data/History.rdoc

@@ -0,0 +1,4 @@
+=== 1.0 / 2013-05-31
+
+* Birthday!
+

data/Manifest.txt

@@ -0,0 +1,30 @@
+.autotest
+History.rdoc
+Manifest.txt
+README.rdoc
+Rakefile
+bin/drbdump
+example/ping.rb
+example/service_primes.rb
+example/tuplespace_primes.rb
+lib/drbdump.rb
+lib/drbdump/loader.rb
+lib/drbdump/message.rb
+lib/drbdump/message_result.rb
+lib/drbdump/message_send.rb
+lib/drbdump/statistic.rb
+lib/drbdump/statistics.rb
+lib/drbdump/test_case.rb
+test/arg.dump
+test/drb_fin.dump
+test/http.dump
+test/ping.dump
+test/ring.dump
+test/test_drbdump.rb
+test/test_drbdump_loader.rb
+test/test_drbdump_message.rb
+test/test_drbdump_message_result.rb
+test/test_drbdump_message_send.rb
+test/test_drbdump_statistic.rb
+test/test_drbdump_statistics.rb
+test/too_large_packet.pcap

data/README.rdoc

@@ -0,0 +1,71 @@
+= drbdump
+
+home :: https://github.com/drbrain/drbdump
+rdoc :: http://docs.seattlerb.org/drbdump
+bugs :: https://github.com/drbrain/drbdump/issues
+
+== Description
+
+drbdump is a tcpdump-like tool for the dRuby protocol.  It allows you to
+inspect the message and analyze the messages sent between your DRb-using
+processes.
+
+== Features
+
+* Displays DRb message sends and results
+* Displays Rinda service discovery announcements
+* Records DRb message statistics including allocations and latency
+
+== Problems
+
+* Does not handle out-of-order or resent TCP packets
+* Does not handle mDNS
+* Does not support filtering
+* TCP only
+
+== Usage
+
+To show DRb messages:
+
+  sudo drbdump
+
+See the DRbDump class documentation for a full description of drbdump
+
+== Installation
+
+  sudo gem install drbdump
+
+== Developers
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== License
+
+(The MIT License)
+
+Copyright (c) Eric Hodel
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Rakefile

@@ -0,0 +1,30 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.plugin :git
+Hoe.plugin :minitest
+Hoe.plugin :travis
+
+namespace :travis do
+  task :install_libpcap do
+    sh 'sudo apt-get install libpcap-dev'
+  end
+
+  task before: %w[install_libpcap]
+end
+
+Hoe.spec 'drbdump' do
+  developer 'Eric Hodel', 'drbrain@segment7.net'
+
+  rdoc_locations << 'docs.seattlerb.org:/data/www/docs.seattlerb.org/drbdump/'
+
+  self.readme_file = 'README.rdoc'
+  self.licenses << 'MIT'
+
+  self.extra_deps << ['capp', '~> 1.0']
+  self.extra_deps << ['marshal-structure', '~> 2.0']
+end
+
+# vim: syntax=ruby

data/bin/drbdump

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'drbdump'
+
+DRbDump.run ARGV
+

data/example/ping.rb

@@ -0,0 +1,241 @@
+require 'drb'
+require 'drbdump'
+require 'optparse'
+
+class Ping
+
+  class Responder
+    def ping i, data
+      return i, data
+    end
+  end
+
+  def self.process_args argv
+    options = {
+      client:    nil,
+      count:     Float::INFINITY,
+      flood:     false,
+      interval:  1,
+      reconnect: false,
+      server:    false,
+      size:      0,
+    }
+
+    interval_set = false
+
+    op = OptionParser.new do |opt|
+      opt.banner = <<-BANNER
+Usage: ping.rb [options] [druby://...]
+
+  With no arguments, spawns a child process and sends DRb messages to it
+
+  To ping across multiple machines start a server with:
+
+    ping.rb --server
+
+  And submit the given URI to a client:
+
+    ping.rb druby://...
+      BANNER
+
+      opt.separator nil
+      opt.separator 'Options:'
+
+      opt.on('-c', '--count COUNT', Integer,
+             'Number of packets to send') do |count|
+        options[:count] = count
+      end
+
+      opt.on('-f', '--flood',
+             'Send packets as fast as possible',
+             'Prints one . per 1000 messages') do
+        options[:flood] = true
+      end
+
+      opt.on('-i', '--interval SECONDS', Float,
+             'Time between non-flood packets') do |interval|
+        options[:interval] = interval
+        interval_set = true
+      end
+
+      opt.on('-s', '--packet-size SIZE', Integer,
+             'Size of extra data to send') do |size|
+        options[:size] = size
+      end
+
+      opt.on(      '--reconnect',
+             'Reconnect for each ping') do
+        options[:reconnect] = true
+      end
+
+      opt.on(      '--server',
+             'Run only as a server') do |value|
+        options[:server] = true
+      end
+    end
+
+    op.parse! argv
+
+    raise OptionParser::ParseError, '--flood with --interval is nonsense' if
+      options[:flood] and interval_set
+
+    raise OptionParser::ParseError, '--server with --flood is nonsense' if
+      options[:server] and options[:flood]
+
+    raise OptionParser::ParseError, '--server with --count is nonsense' if
+      options[:server] and options[:count]
+
+    options[:client] = argv.shift if /\Adruby:/ =~ argv.first
+
+    raise OptionParser::ParseError, '--server with client URI is nonsense' if
+      options[:server] and options[:client]
+
+    options
+  rescue OptionParser::ParseError => e
+    $stderr.puts op
+    $stderr.puts
+    $stderr.puts e.message
+
+    abort
+  end
+
+  def self.run argv = ARGV
+    options = process_args argv
+
+    ping = new options
+
+    ping.run
+  end
+
+  def initialize options
+    @count     = options[:count]
+    @client    = options[:client]
+    @flood     = options[:flood]
+    @interval  = options[:interval]
+    @reconnect = options[:reconnect]
+    @remote    = nil
+    @server    = options[:server]
+    @size      = options[:size]
+    @uri       = nil
+
+    @data = ('a'..'z').cycle.first(@size).join
+  end
+
+  def delay_ping
+    statistic = DRbDump::Statistic.new
+    seq = 0
+
+    until (seq += 1) > @count do
+      send_message seq, statistic
+    end
+  ensure
+    puts
+    puts delay_statistics statistic
+  end
+
+  def delay_statistics statistic
+    '%d messages, min/avg/max/stddev = %0.3f/%0.3f/%0.3f/%0.3f ms' % [
+      statistic.count, statistic.min, statistic.mean, statistic.max,
+      statistic.standard_deviation
+    ]
+  end
+
+  def flood_ping
+    start = Time.now
+    seq = 0
+
+    until (seq += 1) > @count do
+      begin
+        @remote.ping seq, @data
+      rescue DRb::DRbConnError
+      end
+
+      reconnect
+
+      print '.' if seq % 1000 == 0
+    end
+  ensure
+    elapsed = Time.now - start
+    puts
+    puts flood_statistics(elapsed, seq - 1)
+  end
+
+  def flood_statistics elapsed, messages
+    '%d messages in %0.3f seconds, %d messages/sec' % [
+      messages, elapsed, messages / elapsed
+    ]
+  end
+
+  def loopback
+    uri = DRb.uri
+
+    pid = fork do
+      DRb.stop_service
+
+      DRb.start_service
+
+      ping uri
+    end
+
+    trap 'INT'  do Process.kill 'INT',  pid end
+    trap 'TERM' do Process.kill 'TERM', pid end
+
+    Process.wait pid
+  end
+
+  def ping uri
+    @uri = uri
+    @remote = DRb::DRbObject.new_with_uri @uri
+
+    if @flood then
+      flood_ping
+    else
+      delay_ping
+    end
+  end
+
+  def reconnect
+    return unless @reconnect
+
+    DRb::DRbConn.open @uri do [false, false] end
+  end
+
+  def run
+    DRb.start_service nil, Responder.new
+
+    if @server then
+      puts DRb.uri
+
+      DRb.thread.join
+    elsif @client then
+      ping @client
+    else
+      loopback
+    end
+  end
+
+  def send_message seq, statistic
+    message = 'success'
+    start = Time.now
+
+    begin
+      @remote.ping seq, @data
+    rescue DRb::DRbConnError => e
+      message = e
+    end
+
+    elapsed = (Time.now - start) * 1000
+
+    statistic.add elapsed
+
+    puts '%s %s: seq=%d time=%0.3f ms' % [@uri, message, seq, elapsed]
+
+    reconnect
+
+    sleep @interval
+  end
+
+end
+
+Ping.run ARGV if $0 == __FILE__
+

data/example/service_primes.rb

@@ -0,0 +1,212 @@
+require 'drb'
+require 'observer'
+require 'thread'
+
+##
+# Generates primes using multiple independent services.  This prime number
+# generator is purposefully ridiculous in its separation of services.
+#
+# == Implementation Notes
+#
+# ServicePrimes contains the following services:
+#
+# :primes::
+#   NumberStore holding prime numbers and Observable for notification of newly
+#   added prime numbers.
+# :candidates::
+#   Enumerator from 3 to infinity for candidates.
+# :discover::
+#   Consumes an item from the :candidates service and adds the number to the
+#   :primes service if it is found to be prime.
+# :show_primes::
+#   Observer for the :primes NumberStore that prints added primes to standard
+#   output
+#
+# ServicePrimes can be collapsed back to a single process by removing
+# fork_child and assigning each service to the instance variable used by each
+# service.
+#
+# == Analyzing with drbdump
+#
+# Setup and finding the first prime (3) occurs within the first 15 messages.
+#
+# Comparing short message capture (100 messages) at the beginning of prime
+# generation followed by later (around 70001) shows test_prime doing more work
+# as the number of +call+ messages becomes a larger fraction of the messages
+# sent.
+#
+# Removing DrbUndumped from NumberStore and NumberShower gives an interesting
+# failure where the Observer fails to register.
+
+class ServicePrimes
+
+  ##
+  # An observer for NumberStore that prints numbers as they are added.
+
+  class NumberShower
+    include DRb::DRbUndumped
+
+    ##
+    # Prints the number to standard output
+
+    def update number
+      puts number
+    end
+  end
+
+  ##
+  # Stores primes and allows access to generated primes.  The NumberStore is
+  # pre-primed with the first prime number (2).  The NumberStore is Observable
+  # and will notify observers when a new prime is added.
+
+  class NumberStore
+    include DRb::DRbUndumped
+    include Enumerable
+    include Observable
+
+    def initialize # :nodoc:
+      @primes = [2]
+    end
+
+    ##
+    # Adds a number +value+ and notifies observers
+
+    def add value
+      changed
+      @primes << value
+      notify_observers value
+    end
+
+    ##
+    # Iterates through stored primes
+
+    def each
+      @primes.each do |prime|
+        yield prime
+      end
+    end
+  end
+
+  def initialize # :nodoc:
+    @services = {}
+
+    DRb.start_service nil, @services
+
+    @uri = DRb.uri
+  end
+
+  ##
+  # Creates a candidate numbers service which is enumerator of integers from 3
+  # to infinity.
+
+  def candidates
+    fork_child :candidates do
+      @services[:candidates] = 3.upto Float::INFINITY
+
+      DRb.thread.join
+    end
+  end
+
+  ##
+  # Creates a prime number discovery service which consumes a candidate number
+  # and uses +test_prime+ to determine if the candidate number is prime.  If
+  # the candidate is prime it is added to the prime number list.
+
+  def discover
+    fork_child :discover do
+      candidates = @services[:candidates]
+      @primes    = @services[:primes]
+
+      candidates.each do |candidate|
+        prime = test_prime candidate
+
+        @primes.add candidate if prime
+      end
+    end
+  end
+
+  ##
+  # Forks a worker child named +service+ and waits for its registration before
+  # returning.
+
+  def fork_child service
+    Thread.start do
+      pid = fork do
+        DRb.stop_service
+
+        DRb.start_service
+
+        @services = DRb::DRbObject.new_with_uri @uri
+
+        yield
+      end
+
+      Process.wait pid
+    end
+
+    Thread.pass until @services[service]
+  end
+
+  ##
+  # Creates a prime number storage service named primes.
+
+  def primes
+    fork_child :primes do
+      @services[:primes] = NumberStore.new
+
+      DRb.thread.join
+    end
+  end
+
+  ##
+  # Starts the prime number generator
+
+  def run
+    candidates
+
+    primes
+
+    show_primes
+
+    discover
+
+    DRb.thread.join
+  end
+
+  ##
+  # Creates a prime number display service that observes the addition of new
+  # prime numbers to the primes service.
+
+  def show_primes
+    fork_child :show_primes do
+      prime_shower = NumberShower.new
+
+      @services[:primes].add_observer prime_shower
+
+      @services[:show_primes] = prime_shower
+
+      DRb.thread.join
+    end
+  end
+
+  ##
+  # Determines if +candidate+ is a prime number by dividing it by all primes
+  # below the square root of the +candidate+.
+
+  def test_prime candidate
+    max = Math.sqrt(candidate).ceil
+
+    is_prime = @primes.each do |prime|
+      break true if prime > max
+
+      _, remainder = candidate.divmod prime
+
+      break false if remainder.zero?
+    end
+
+    is_prime
+  end
+
+end
+
+ServicePrimes.new.run if $0 == __FILE__