RingyDingy 1.0.0 → 1.1.0

data/History.txt

@@ -0,0 +1,12 @@
+= 1.1.0
+
+* Added ring_server executable (Rinda::RingServer wrapper)
+  * Daemon mode
+  * Rinda::RingServer service listing
+  * Remote verbose mode enable-disable
+* Switched to Hoe
+
+= 1.0.0
+
+Birthday!
+

data/Manifest.txt

@@ -1,7 +1,10 @@
-CHANGES
-LICENSE
+History.txt
+LICENSE.txt
 Manifest.txt
-README
+README.txt
 Rakefile
+bin/ring_server
 lib/ringy_dingy.rb
+lib/ringy_dingy/ring_server.rb
+test/test_ring_server.rb
 test/test_ringy_dingy.rb

data/{README → README.txt}

@@ -19,6 +19,10 @@ will re-register its service with the RingServer when it reappears.
 Similarly, the RingServer will automatically drop registrations by a RingyDingy
 that it can't communicate with after a short timeout.
 
+RingyDingy also includes a RingServer wrapper that adds verbose mode to see
+what services as they register and expire and an option to list all available
+services on the network.
+
 == Installing RingyDingy
 
 Just install the gem:
@@ -36,3 +40,18 @@ Just install the gem:
   RingyDingy.new(my_drb_service).run
   
   DRb.thread.join
+
+== Using RingyDingy::RingServer
+
+To start a RingServer:
+
+  $ ring_server
+
+To list services on the network:
+
+  $ ring_server -l
+
+To enable or disable verbose mode remotely:
+
+  $ ring_server --set-logging=true/false
+

data/Rakefile

@@ -1,56 +1,17 @@
-require 'rubygems'
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
+require 'hoe'
 
-$VERBOSE = nil
+require './lib/ringy_dingy.rb'
 
-spec = Gem::Specification.new do |s|
-  s.name = 'RingyDingy'
-  s.version = '1.0.0'
-  s.summary = 'RingyDingy is a little boat that keeps your DRb service afloat!'
-  s.description = 'RingyDingy automatically re-registers your DRb service with a RingServer should communication with the RingServer stop.'
-  s.author = 'Eric Hodel'
-  s.email = 'drbrain@segment7.net'
+Hoe.new 'RingyDingy', RingyDingy::VERSION do |p|
+  p.summary = 'RingyDingy is a little boat that keeps your DRb service afloat!'
+  p.description = 'RingyDingy automatically re-registers your DRb service with a RingServer should communication with the RingServer stop.'
+  p.url = 'http://seattlerb.rubyforge.org/RingyDingy'
+  p.author = 'Eric Hodel'
+  p.email = 'drbrain@segment7.net'
+  p.rubyforge_name = 'seattlerb'
+  p.changes = File.read('History.txt').scan(/\A(=.*?)(=|\Z)/m).first.first
 
-  s.has_rdoc = true
-  s.files = File.read('Manifest.txt').split($/)
-  s.require_path = 'lib'
+  p.extra_deps << ['ZenTest', '>= 3.4.0']
 end
 
-desc 'Run tests'
-task :default => [ :test ]
-
-Rake::TestTask.new('test') do |t|
-  t.libs << 'test'
-  t.pattern = 'test/test_*.rb'
-  t.verbose = true
-end
-
-desc 'Update Manifest.txt'
-task :update_manifest do
-  sh "find . -type f | sed -e 's%./%%' | egrep -v 'svn|swp|~' | egrep -v '^(doc|pkg)/' | sort > Manifest.txt"
-end
-
-desc 'Generate RDoc'
-Rake::RDocTask.new :rdoc do |rd|
-  rd.rdoc_dir = 'doc'
-  rd.rdoc_files.add 'lib', 'README', 'LICENSE', 'CHANGES'
-  rd.main = 'README'
-  rd.options << '-d' if `which dot` =~ /\/dot/
-  rd.options << '-t RingyDingy Documentation'
-end
-
-desc 'Build Gem'
-Rake::GemPackageTask.new spec do |pkg|
-  pkg.need_tar = true
-end
-
-desc 'Clean up'
-task :clean => [ :clobber_rdoc, :clobber_package ]
-
-desc 'Clean up'
-task :clobber => [ :clean ]
-
 # vim: syntax=Ruby

data/bin/ring_server

@@ -0,0 +1,7 @@
+#!/usr/local/bin/ruby -w
+
+require 'rubygems'
+require 'ringy_dingy/ring_server'
+
+RingyDingy::RingServer.run
+

data/lib/ringy_dingy.rb

@@ -2,6 +2,8 @@ require 'English'
 require 'drb'
 require 'rinda/ring'
 
+$TESTING = defined? $TESTING
+
 ##
 # RingyDingy registers a DRb service with a Rinda::RingServer and re-registers
 # the service if communication with the Rinda::RingServer is ever lost.
@@ -19,6 +21,8 @@ require 'rinda/ring'
 
 class RingyDingy
 
+  VERSION = '1.1.0'
+
   ##
   # Interval to check the RingServer for our registration information.
 
@@ -45,7 +49,7 @@ class RingyDingy
   # optional identifier +name+.
 
   def initialize(object, service = :RingyDingy, name = nil)
-    DRb.start_service
+    DRb.start_service unless DRb.primary_server
 
     @identifier = [Socket.gethostname.downcase, $PID, name].compact.join '_'
     @object = object

data/lib/ringy_dingy/ring_server.rb

@@ -0,0 +1,278 @@
+require 'rinda/ring'
+require 'rinda/tuplespace'
+require 'ringy_dingy'
+require 'optparse'
+
+##
+# RingyDingy::RingServer provides a friendly wrapper around Rinda::RingServer.
+#
+# When running on the command line, RingyDingy::RingServer's verbose mode may
+# be toggled remotely via the --set-verbose option.
+#
+# = Usage
+#
+# == Starting a RingServer
+#
+# From the command line:
+#
+#   ring_server -d
+#
+# or from Ruby:
+#
+#   RingyDingy::RingServer.new.run
+#
+# == List Services
+#
+# From the command line (after starting a RingServer):
+#
+#   ring_server -l
+#
+# or from Ruby:
+#
+#   RingyDingy::RingServer.list
+#
+# == Verbose mode
+#
+# Changing verbose mode for the server (when not a daemon).
+#
+#   ring_server --set-verbose=true/false
+#
+# or from Ruby:
+#
+#   RingyDingy::RingServer.set_verbose true/false
+
+class RingyDingy::RingServer
+
+  ##
+  # Verbose setting for this RingyDingy::RingServer.
+
+  attr_reader :verbose
+
+  ##
+  # Print all available services on all available Rinda::RingServers to
+  # stdout.
+
+  def self.list
+    DRb.start_service unless DRb.primary_server
+
+    rf = Rinda::RingFinger.new
+
+    services = Hash.new { |h,k| h[k] = {} }
+
+    rf.lookup_ring do |ts|
+      found_services = ts.read_all [:name, nil, DRbObject, nil]
+      found_services.each do |service|
+        # #hash and #eql? will not always work
+        ref = "#{service[2].__drburi}:#{service[2].__drbref}"
+        services[ts.__drburi][ref] = service
+      end
+    end
+
+    services.each do |ring_server, services|
+      puts "Services on #{ring_server}:"
+      services.values.each do |s|
+        puts "%p, %p\n\tURI: %s ref: %d" %
+               [s[1], s[3], s[2].__drburi, s[2].__drbref]
+      end
+    end
+  end
+
+  ##
+  # Enables or disables verobse mode on all available Rinda::RingServers
+  # depending upon +boolean+.
+
+  def self.set_verbose(boolean)
+    DRb.start_service unless DRb.primary_server
+
+    rf = Rinda::RingFinger.new
+
+    rf.lookup_ring do |ts|
+      ts.write [:RingyDingy, :verbose, boolean]
+    end
+  end
+
+  ##
+  # Process +args+ into an options Hash.  See also #new.
+
+  def self.process_args(args)
+    options = {}
+    options[:Verbose] = false
+
+    op = OptionParser.new do |op|
+      op.program_name = 'ring_server'
+      op.version = RingyDingy::VERSION
+      op.release = nil
+
+      op.banner = "Usage: #{name} [options]"
+      op.separator ''
+      op.separator 'Run, find, or modify the behavior of a Rinda::RingServer.'
+      op.separator ''
+      op.separator 'With no arguments a Rinda::RingServer is started and runs in the foreground.'
+      op.separator ''
+
+      op.separator 'RingServer options:'
+      op.on("-d", "--daemon",
+            "Run a RingServer as a daemon") do |val|
+        options[:Daemon] = val
+      end
+
+      op.on("-v", "--verbose",
+            "Enable verbose mode") do |val|
+        options[:Verbose] = val
+      end
+
+      op.separator ''
+      op.separator 'Miscellaneous options:'
+
+      op.on("-l", "--list",
+            "List services on available RingServers") do |val|
+        options[:List] = val
+      end
+
+      op.on(      "--set-verbose=BOOLEAN", TrueClass,
+            "Enable or disable verbose mode on available",
+            "RingServers (except daemon RingServers)") do |val|
+        options[:SetVerbose] = val
+      end
+    end
+
+    op.parse! args
+
+    return options
+  end
+
+  ##
+  # Run appropriately.
+
+  def self.run(args = ARGV)
+    DRb.start_service unless DRb.primary_server
+
+    options = process_args args
+
+    if options.include? :List then
+      list
+      exit
+    elsif options.include? :SetVerbose then
+      set_verbose options[:SetVerbose]
+      exit
+    elsif options.include? :Daemon then
+      require 'webrick/server'
+      WEBrick::Daemon.start
+    end
+
+    new(options).run
+  end
+
+  ##
+  # Prints usage message +message+ if present then OptionParser +op+.
+
+  def self.usage(op, message = nil)
+    if message then
+      $stderr.puts message
+      $stderr.puts
+    end
+
+    $stderr.puts op
+    exit 1
+  end
+
+  ##
+  # Creates a new RingyDingy::RingServer.
+  #
+  # +options+ may contain:
+  # [:Daemon] In daemon-mode #verbose may not be changed.
+  # [:Verbose] In verbose mode service registrations and expirations are
+  #            logged to $stderr.
+
+  def initialize(options)
+    @ts = Rinda::TupleSpace.new
+
+    @registrations = nil
+    @expirations = nil
+
+    @daemon = options[:Daemon]
+
+    @verbose = false
+    self.verbose = options[:Verbose] and not @daemon
+  end
+
+  ##
+  # Disables service registration and expiration logging.
+
+  def disable_activity_logging
+    @registrations.cancel if @registrations and @registrations.alive?
+    @expirations.cancel if @expirations and @expirations.alive?
+
+    $stderr.puts 'registration and expiration logging disabled'
+  end
+
+  ##
+  # Enables service registration and expiration logging.
+
+  def enable_activity_logging
+    log 'registration and expiration logging enabled'
+
+    @registrations = @ts.notify 'write', [:name, nil, DRbObject, nil]
+    @expirations = @ts.notify 'delete', [:name, nil, DRbObject, nil]
+
+    Thread.start do
+      @registrations.each do |(_,t)|
+        $stderr.puts "registered %p, %p\n\tURI: %s ref: %d" %
+                       [t[1], t[3], t[2].__drburi, t[2].__drbref]
+      end
+    end
+
+    Thread.start do
+      @expirations.each do |(_,t)|
+        $stderr.puts "expired %p, %p\n\tURI: %s ref: %d" %
+                       [t[1], t[3], t[2].__drburi, t[2].__drbref]
+      end
+    end
+  end
+
+  ##
+  # Logs a message to $stderr when @verbose is true.
+
+  def log(message)
+    return unless @verbose
+    $stderr.puts message
+  end
+
+  ##
+  # Worker thread to monitor remote toggling of verbose mode.
+
+  def monitor_verbose
+    Thread.start do
+      loop do
+        self.verbose = @ts.take([:RingyDingy, :verbose, nil])[2]
+      end
+    end
+  end
+
+  ##
+  # Starts a new RingServer::RingyDingy.
+
+  def run
+    DRb.start_service unless DRb.primary_server
+
+    log "listening on #{DRb.uri}"
+
+    monitor_verbose
+
+    Rinda::RingServer.new @ts
+
+    DRb.thread.join
+  end
+
+  ##
+  # Sets verbose to +value+ when @daemon is not true.
+
+  def verbose=(value)
+    return if @daemon or @verbose == value
+    @verbose = value
+    @verbose ? enable_activity_logging : disable_activity_logging
+    @verbose
+  end
+
+end
+

data/test/test_ring_server.rb

@@ -0,0 +1,123 @@
+require 'test/unit'
+
+require 'rubygems'
+require 'test/zentest_assertions'
+
+$TESTING = true
+
+require 'ringy_dingy/ring_server'
+
+DRb.start_service
+
+class RingyDingy::RingServer
+  attr_accessor :expirations, :registrations, :ts
+  attr_reader :verbose
+end
+
+class TestRingServer < Test::Unit::TestCase
+
+  def setup
+    util_capture do
+      @rs = RingyDingy::RingServer.new :Verbose => true
+    end
+  end
+
+  def test_initialize_verbose_daemon
+    rs = RingyDingy::RingServer.new :Verbose => true, :Daemon => true
+    assert_equal false, rs.verbose
+  end
+
+  def test_disable_activity_logging
+    @rs.registrations = @rs.ts.notify 'write', [nil]
+    @rs.expirations = @rs.ts.notify 'delete', [nil]
+
+    out, err = util_capture do
+      @rs.disable_activity_logging
+    end
+
+    assert_equal true, @rs.registrations.canceled?
+    assert_equal true, @rs.expirations.canceled?
+
+    assert_equal "registration and expiration logging disabled\n", err.string
+  end
+
+  def test_enable_activity_logging
+    @rs.registrations.cancel
+    @rs.expirations.cancel
+
+    out, err = util_capture do
+      @rs.enable_activity_logging
+      @rs.ts.write [:name, :Test, DRbObject.new(self), ''], 0
+    end
+
+    assert_equal true, @rs.registrations.alive?
+    assert_equal true, @rs.expirations.alive?
+
+    expected = <<-EOF
+registration and expiration logging enabled
+registered :Test, ""
+\tURI: #{DRb.uri} ref: #{self.object_id}
+expired :Test, ""
+\tURI: #{DRb.uri} ref: #{self.object_id}
+    EOF
+
+    assert_equal expected, err.string
+  end
+
+  def disabled_test_monitor_verbose
+    util_capture do
+      assert_equal true, @rs.verbose
+      @rs.ts.write [:RingyDingy, :verbose, false]
+      assert_equal false, @rs.verbose
+      @rs.ts.write [:RingyDingy, :verbose, true]
+      assert_equal true, @rs.verbose
+    end
+  end
+
+  def test_verbose_equals_false
+    assert_equal true, @rs.verbose
+
+    out, err = util_capture do
+      @rs.verbose = false
+    end
+
+    assert_equal '', out.string
+    assert_equal "registration and expiration logging disabled\n", err.string
+  end
+
+  def test_verbose_equals_no_change
+    assert_equal true, @rs.verbose
+
+    out, err = util_capture do
+      @rs.verbose = true
+    end
+
+    assert_equal '', out.string
+    assert_equal '', err.string
+  end
+
+  def test_verbose_equals_true
+    util_capture do @rs.verbose = false end
+
+    out, err = util_capture do
+      @rs.verbose = true
+    end
+
+    assert_equal '', out.string
+    assert_equal "registration and expiration logging enabled\n", err.string
+  end
+
+  def test_verbose_equals_true_daemon
+    @rs.instance_variable_set :@daemon, true
+    util_capture do @rs.verbose = false end
+
+    out, err = util_capture do
+      @rs.verbose = true
+    end
+
+    assert_equal '', out.string
+    assert_equal '', err.string
+  end
+
+end
+

metadata

@@ -3,14 +3,15 @@ rubygems_version: 0.8.99
 specification_version: 1
 name: RingyDingy
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
-date: 2006-09-09 00:00:00 -07:00
+  version: 1.1.0
+date: 2006-10-21 00:00:00 -06:00
 summary: RingyDingy is a little boat that keeps your DRb service afloat!
 require_paths: 
 - lib
+- test
 email: drbrain@segment7.net
-homepage: 
-rubyforge_project: 
+homepage: http://seattlerb.rubyforge.org/RingyDingy
+rubyforge_project: seattlerb
 description: RingyDingy automatically re-registers your DRb service with a RingServer should communication with the RingServer stop.
 autorequire: 
 default_executable: 
@@ -29,12 +30,15 @@ post_install_message:
 authors: 
 - Eric Hodel
 files: 
-- CHANGES
-- LICENSE
+- History.txt
+- LICENSE.txt
 - Manifest.txt
-- README
+- README.txt
 - Rakefile
+- bin/ring_server
 - lib/ringy_dingy.rb
+- lib/ringy_dingy/ring_server.rb
+- test/test_ring_server.rb
 - test/test_ringy_dingy.rb
 test_files: []
 
@@ -42,11 +46,28 @@ rdoc_options: []
 
 extra_rdoc_files: []
 
-executables: []
-
+executables: 
+- ring_server
 extensions: []
 
 requirements: []
 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ZenTest
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.4.0
+    version: 

data/CHANGES

@@ -1,4 +0,0 @@
-= 1.0.0
-
-Birthday!
-