RingyDingy 1.0.0

data/CHANGES

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

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright 2006, Eric Hodel.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the names of the authors nor the names of their contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Manifest.txt

@@ -0,0 +1,7 @@
+CHANGES
+LICENSE
+Manifest.txt
+README
+Rakefile
+lib/ringy_dingy.rb
+test/test_ringy_dingy.rb

data/README

@@ -0,0 +1,38 @@
+= RingyDingy
+
+RingyDingy is a little boat that keeps your DRb service afloat!
+
+Rubyforge Project:
+
+http://rubyforge.org/projects/seattlerb
+
+Documentation:
+
+ri RingyDingy
+
+== About
+
+RingyDingy automatically registers a service with a RingServer.  If
+communication between the RingServer and the RingyDingy is lost, RingyDingy
+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.
+
+== Installing RingyDingy
+
+Just install the gem:
+
+  $ sudo gem install RingyDingy
+
+== Using RingyDingy
+
+  require 'rubygems'
+  require 'ringy_dingy'
+  require 'my_drb_service'
+  
+  my_drb_service = MyDRbService.new
+  
+  RingyDingy.new(my_drb_service).run
+  
+  DRb.thread.join

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+$VERBOSE = nil
+
+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'
+
+  s.has_rdoc = true
+  s.files = File.read('Manifest.txt').split($/)
+  s.require_path = 'lib'
+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/lib/ringy_dingy.rb

@@ -0,0 +1,120 @@
+require 'English'
+require 'drb'
+require 'rinda/ring'
+
+##
+# RingyDingy registers a DRb service with a Rinda::RingServer and re-registers
+# the service if communication with the Rinda::RingServer is ever lost.
+#
+# Similarly, if the Rinda::RingServer should ever lose contact with the
+# service the registration will be automatically dropped after a short
+# timeout.
+#
+# = Example
+#
+#   my_service = MyService.new
+#   rd = RingyDingy.new my_service, :MyService
+#   rd.run
+#   DRb.thread.join
+
+class RingyDingy
+
+  ##
+  # Interval to check the RingServer for our registration information.
+
+  attr_accessor :check_every
+
+  ##
+  # RingyDingy service identifier.  Use this to distinguish between
+  # RingyDingys registering the same service.
+
+  attr_reader :identifier
+
+  ##
+  # RingyDingy run loop thread.
+
+  attr_reader :thread
+
+  if $TESTING then
+    attr_accessor :ring_finger, :renewer, :thread # :nodoc:
+    attr_writer :ring_server # :nodoc:
+  end
+
+  ##
+  # Creates a new RingyDingy that registers +object+ as +service+ with
+  # optional identifier +name+.
+
+  def initialize(object, service = :RingyDingy, name = nil)
+    DRb.start_service
+
+    @identifier = [Socket.gethostname.downcase, $PID, name].compact.join '_'
+    @object = object
+    @service = service || :RingyDingy
+
+    @check_every = 180
+    @renewer = Rinda::SimpleRenewer.new
+
+    @ring_finger = Rinda::RingFinger.new
+    @ring_server = nil
+
+    @thread = nil
+  end
+
+  ##
+  # Registers this service with the primary Rinda::RingServer.
+
+  def register
+    ring_server.write [:name, @service, DRbObject.new(@object), @identifier],
+                      @renewer
+    return nil
+  end
+
+  ##
+  # Looks for a registration tuple in the primary Rinda::RingServer.  If a
+  # RingServer can't be found or contacted, returns false.
+
+  def registered?
+    registrations = ring_server.read_all [:name, :RingyDingy, nil, @identifier]
+    registrations.any? { |registration| registration[2] == @object }
+  rescue DRb::DRbConnError
+    @ring_server = nil
+    return false
+  end
+
+  ##
+  # Looks up the primary Rinde::RingServer.
+
+  def ring_server
+    return @ring_server unless @ring_server.nil?
+    @ring_server = @ring_finger.lookup_ring_any
+  end
+
+  ##
+  # Starts a thread that checks for a registration tuple every #check_every
+  # seconds.
+
+  def run
+    @thread = Thread.start do
+      loop do
+        begin
+          register unless registered?
+        rescue DRb::DRbConnError
+          @ring_server = nil
+        rescue RuntimeError => e
+          raise unless e.message == 'RingNotFound'
+        end
+        sleep @check_every
+      end
+    end
+  end
+
+  ##
+  # Stops checking for registration tuples.
+
+  def stop
+    @thread.kill
+    return nil
+  end
+
+end
+

data/test/test_ringy_dingy.rb

@@ -0,0 +1,156 @@
+require 'test/unit'
+
+$TESTING = true
+
+require 'ringy_dingy'
+
+class StubRingFinger
+
+  attr_accessor :ring_server
+
+  def initialize
+    @ring_server = nil
+  end
+
+  def lookup_ring_any
+    raise RuntimeError, 'RingNotFound' if @ring_server.nil?
+    @ring_server
+  end
+
+end
+
+class StubRingServer
+
+  attr_accessor :tuples
+
+  def initialize
+    @tuples = []
+  end
+
+  def write(*args)
+    @tuples << args
+  end
+
+  def read_all(*args)
+    @tuples.map { |t,r| t }
+  end
+
+end
+
+class Rinda::SimpleRenewer
+
+  attr_reader :sec
+
+  def ==(other)
+    self.class === other and sec == other.sec
+  end
+
+end
+
+class TestRingyDingy < Test::Unit::TestCase
+
+  def setup
+    @identifier = "#{Socket.gethostname.downcase}_#{$PID}"
+    @object = ""
+    @ringy_dingy = RingyDingy.new @object
+
+    @stub_ring_server = StubRingServer.new
+    @ringy_dingy.ring_server = @stub_ring_server
+  end
+
+  def test_identifier
+    assert_equal @identifier, @ringy_dingy.identifier
+
+    @ringy_dingy = RingyDingy.new @object, nil, 'blah'
+
+    assert_equal "#{@identifier}_blah", @ringy_dingy.identifier
+  end
+
+  def test_register
+    @ringy_dingy.register
+
+    expected = [
+      [[:name, :RingyDingy, DRbObject.new(@object), @identifier],
+       Rinda::SimpleRenewer.new]
+    ]
+
+    assert_equal expected, @stub_ring_server.tuples
+  end
+
+  def test_register_service
+    @ringy_dingy = RingyDingy.new @object, :MyDRbService
+    @ringy_dingy.ring_server = @stub_ring_server
+    @ringy_dingy.register
+
+    expected = [
+      [[:name, :MyDRbService, DRbObject.new(@object), @identifier],
+       Rinda::SimpleRenewer.new]
+    ]
+
+    assert_equal expected, @stub_ring_server.tuples
+  end
+
+  def test_registered_eh
+    @stub_ring_server.tuples << [
+      [:name, :RingyDingy, @object, @identifier], nil]
+
+    assert_equal true, @ringy_dingy.registered?
+  end
+
+  def test_registered_eh_not_registered
+    assert_equal false, @ringy_dingy.registered?
+  end
+
+  def test_registered_eh_no_ring_server
+    def @stub_ring_server.read_all(*args)
+      raise DRb::DRbConnError
+    end
+
+    assert_equal false, @ringy_dingy.registered?
+
+    assert_equal nil, @ringy_dingy.instance_variable_get(:@ring_server)
+  end
+
+  def test_registered_eh_service
+    @ringy_dingy = RingyDingy.new @object, :MyDRbService
+    @ringy_dingy.ring_server = @stub_ring_server
+
+    @stub_ring_server.tuples << [
+      [:name, :MyDRbService, @object, @identifier], nil]
+
+    assert_equal true, @ringy_dingy.registered?
+  end
+
+  def test_renewer
+    assert_equal Rinda::SimpleRenewer.new, @ringy_dingy.renewer
+  end
+
+  def test_ring_server
+    util_create_stub_ring_finger :server
+
+    assert_equal :server, @ringy_dingy.ring_server
+  end
+
+  def test_ring_server_not_found
+    util_create_stub_ring_finger
+
+    assert_raise RuntimeError do @ringy_dingy.ring_server end
+  end
+
+  def test_stop
+    @ringy_dingy.thread = Thread.start do sleep end
+    assert_equal nil, @ringy_dingy.stop
+  end
+
+  def util_create_stub_ring_finger(rs = nil)
+    @ringy_dingy.ring_server = nil
+
+    ring_finger = StubRingFinger.new
+
+    ring_finger.ring_server = rs unless rs.nil?
+
+    @ringy_dingy.ring_finger = ring_finger
+  end
+
+end
+

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification 
+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
+summary: RingyDingy is a little boat that keeps your DRb service afloat!
+require_paths: 
+- lib
+email: drbrain@segment7.net
+homepage: 
+rubyforge_project: 
+description: RingyDingy automatically re-registers your DRb service with a RingServer should communication with the RingServer stop.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Eric Hodel
+files: 
+- CHANGES
+- LICENSE
+- Manifest.txt
+- README
+- Rakefile
+- lib/ringy_dingy.rb
+- test/test_ringy_dingy.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+