archipelago 0.1.0

data/profiles/1000xDubloon#method_missing(t).rb

@@ -0,0 +1,21 @@
+
+require File.join(File.dirname(__FILE__), 'profile_helper')
+require 'treasure'
+require 'drb'
+
+DRb.start_service
+@c = TestChest.new
+@tm = TestManager.new
+
+tr = @tm.begin
+k = "hej"
+v = "oj"
+@c[k,tr] = v
+v = @c[k,tr]
+1000.times do |n|
+  t = v.upcase
+end
+
+@c.persistence_provider.unlink
+File.unlink(@tm.db.filename)
+DRb.stop_service

data/profiles/README

@@ -0,0 +1,3 @@
+These are just simple scripts to profile certain parts of the system.
+
+Use ruby-prof to run them and get good profiling.

data/profiles/profile_helper.rb

@@ -0,0 +1,25 @@
+
+home = File.expand_path(File.dirname(__FILE__))
+$: << File.join(home, "..", "lib")
+
+require 'pp'
+require 'tranny'
+require 'treasure'
+
+class TestManager < Archipelago::Tranny::Manager
+  attr_reader :db
+  def log_error(e)
+    puts e
+    pp e.backtrace
+  end
+end
+
+class TestChest < Archipelago::Treasure::Chest
+  attr_reader :persistence_provider
+end
+
+class TestTransaction
+  def join(o)
+  end
+end
+

data/scripts/chest.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+if ARGV.size < 1
+  puts "Usage: #{$0} DB-PATH [DRB-URI]"
+  exit 1
+end
+
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'treasure'
+
+if ARGV.size > 1
+  DRb.start_service(ARGV[1])
+else
+  DRb.start_service
+end
+c = Archipelago::Treasure::Chest.new(:persistence_provider => Archipelago::Hashish::BerkeleyHashishProvider.new(Pathname.new(ARGV[0])))
+c.publish!
+
+DRb.thread.join

data/scripts/console

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+exec 'irb', '-r', File.join(File.dirname(__FILE__), 'pirate.rb'), "-I", 'lib'

data/scripts/pirate.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'pirate'
+
+DRb.start_service("druby://localhost:#{rand(1000) + 5000}")
+@p = Archipelago::Pirate::Captain.new

data/scripts/tranny.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+if ARGV.size < 1
+  puts "Usage: #{$0} DB-PATH DRB-URI"
+  exit 1
+end
+
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'treasure'
+
+if ARGV.size > 1
+  DRb.start_service(ARGV[1])
+else
+  DRb.start_service
+end
+t = Archipelago::Tranny::Manager.new(:persistence_provider => Archipelago::Hashish::BerkeleyHashishProvider.new(Pathname.new(ARGV[0])))
+t.publish!
+
+DRb.thread.join

data/tests/current_test.rb

@@ -0,0 +1,28 @@
+
+require File.join(File.dirname(__FILE__), 'test_helper')
+require 'current'
+
+class CurrentTest < Test::Unit::TestCase
+
+  def test_synchronized
+    t = true
+
+    a = "hej"
+    a.extend(Archipelago::Current::Synchronized)
+
+    o = "gnu"
+    a.synchronize_on(o) do
+      Thread.new do
+        a.synchronize_on(o) do
+          t = false
+        end
+      end
+      Thread.pass
+      assert(t)
+    end
+    assert_within(0.5) do
+      !t
+    end
+  end
+
+end

data/tests/disco_test.rb

@@ -0,0 +1,179 @@
+
+require File.join(File.dirname(__FILE__), 'test_helper')
+require 'disco'
+require 'drb'
+require 'socket'
+require 'ipaddr'
+require 'thread'
+
+class RemoteValidator
+  include DRb::DRbUndumped
+  attr_accessor :valid
+  def initialize(valid)
+    @valid = valid
+  end
+  def valid?
+    @valid
+  end
+end
+
+class DiscoTest < Test::Unit::TestCase
+
+  def setup
+    DRb.start_service
+    @d1 = TestJockey.new(:thrifty_publishing => false, 
+                         :thrifty_replying => false,
+                         :thrifty_caching => false)
+    @d2 = TestJockey.new(:thrifty_publishing => false)
+    @v1 = RemoteValidator.new(true)
+    @p1 = Archipelago::Disco::Record.new(:service_id => 1, 
+                                          :validator => DRbObject.new(@v1),
+                                          :epa => "blar")
+    @d1.publish(@p1)
+    assert(!@d2.lookup(Archipelago::Disco::Query.new(:epa => "blar")).empty?)
+
+    @listener = UDPSocket.new
+    @listener.setsockopt(Socket::IPPROTO_IP, 
+                         Socket::IP_ADD_MEMBERSHIP, 
+                         IPAddr.new(Archipelago::Disco::ADDRESS).hton + Socket.gethostbyname("0.0.0.0")[3])
+        
+    @listener.setsockopt(Socket::SOL_SOCKET, 
+                         Socket::SO_REUSEADDR, 
+                         true)
+    begin
+      @listener.setsockopt(Socket::SOL_SOCKET, 
+                           Socket::SO_REUSEPORT, 
+                           true)
+    rescue
+          # /moo
+    end
+    @listener.bind('', Archipelago::Disco::PORT)
+    @ltq = []
+    @lt = Thread.new do
+      loop do
+        begin
+          @ltq << @listener.recv(1024)
+        rescue Exception => e
+          puts e
+          pp e.backtrace
+        end
+      end
+    end
+  end
+
+  def teardown
+    @d1.stop
+    @d2.stop
+    DRb.stop_service
+    @lt.kill
+    @listener.close
+  end
+
+  def test_publish_lookup
+    empty = true
+    Thread.new do
+      empty = @d2.lookup(Archipelago::Disco::Query.new(:epa => "blar2")).empty?
+    end
+
+    assert(empty)
+
+    @d1.publish(Archipelago::Disco::Record.new(:service_id => 1, 
+                                                :validator => Archipelago::Disco::MockValidator.new, 
+                                                :epa => "blar2"))
+
+    assert_within(0.5) do
+      !empty
+    end
+  end
+
+  def test_publish_invalidate
+    @v1.valid = false
+    assert(@d2.lookup(Archipelago::Disco::Query.new(:epa => "blar"), 0).empty?)
+  end
+
+  def test_thrifty_publishing
+    @ltq.clear
+
+    @d1.publish(Archipelago::Disco::Record.new(:glada => "jaa", :validator => Archipelago::Disco::MockValidator.new, :service_id => 344))
+    sleep 0.1
+    assert(@ltq.any? do |d|
+             o = Marshal.load(d)
+             case o
+             when Archipelago::Disco::Record
+               o[:glada] == "jaa"
+             else
+               false
+             end
+           end)
+
+    @d1.stop
+    @d2.stop
+
+    @ltq.clear
+    c3 = Archipelago::Disco::Jockey.new(:thrifty_publishing => true)
+    c3.publish(Archipelago::Disco::Record.new(:glad => "ja", :validator => Archipelago::Disco::MockValidator.new, :service_id => 33))
+    sleep 0.1
+    assert(@ltq.empty?)
+
+    c1 = Archipelago::Disco::Jockey.new(:thrifty_publishing => true)
+    assert(!c1.lookup(Archipelago::Disco::Query.new(:glad => "ja")).empty?)
+
+    c1.stop
+    c3.stop
+  end
+
+  def test_thrifty_replying
+    @d1.publish(Archipelago::Disco::Record.new(:gladaa => "jaaa", :validator => Archipelago::Disco::MockValidator.new, :service_id => 3444))
+    
+    @ltq.clear
+    assert(!@d2.lookup(Archipelago::Disco::Query.new(:gladaa => "jaaa")).empty?)
+    assert(@ltq.any? do |d|
+             o = Marshal.load(d)
+             case o
+             when Archipelago::Disco::Record
+               o[:gladaa] == "jaaa"
+             else
+               false
+             end
+           end)
+    
+    
+    @d1.stop
+    @d2.stop
+    c3 = Archipelago::Disco::Jockey.new(:thrifty_replying => true, :thrifty_publishing => true)
+    c3.publish(Archipelago::Disco::Record.new(:glad2 => "ja2", :validator => Archipelago::Disco::MockValidator.new, :service_id => 34))
+
+    @ltq.clear
+
+    c1 = Archipelago::Disco::Jockey.new
+    assert(!c1.lookup(Archipelago::Disco::Query.new(:glad2 => "ja2"), 2).empty?)
+
+    assert(!@ltq.any? do |data|
+             o = Marshal.load(data)
+             if Archipelago::Disco::Record === o
+               o[:glad2] == "ja2"
+             else
+               false
+             end
+           end)
+
+    c1.stop
+    c3.stop
+  end
+
+  def test_thrifty_caching
+    @d2.publish(Archipelago::Disco::Record.new(:bojkotta => "jag", :validator => Archipelago::Disco::MockValidator.new, :service_id => 411))
+    sleep 0.1
+    assert(@d1.remote_services.include?(411))
+
+    c1 = TestJockey.new(:thrifty_caching => true)
+    assert(!c1.local_services.include?(41))
+    assert(!c1.remote_services.include?(41))
+    @d1.publish(Archipelago::Disco::Record.new(:bojkott => "ja", :validator => Archipelago::Disco::MockValidator.new, :service_id => 41))
+    sleep 0.1
+    assert(!c1.local_services.include?(41))
+    assert(!c1.remote_services.include?(41))
+    
+  end
+
+end

data/tests/pirate_test.rb

@@ -0,0 +1,75 @@
+
+require File.join(File.dirname(__FILE__), 'test_helper')
+require 'treasure'
+require 'drb'
+require 'tranny'
+require 'hashish'
+require 'pirate'
+
+class PirateTest < Test::Unit::TestCase
+
+  def setup
+    DRb.start_service("druby://localhost:#{rand(1000) + 5000}")
+    @p = Archipelago::Pirate::Captain.new(:chest_description => {:class => "TestChest"}, 
+                                          :tranny_description => {:class => "TestManager"})
+    @c = TestChest.new(:persistence_provider => Archipelago::Hashish::BerkeleyHashishProvider.new(Pathname.new(__FILE__).parent.join("chest.db")))
+    @c.publish!
+    @c2 = TestChest.new(:persistence_provider => Archipelago::Hashish::BerkeleyHashishProvider.new(Pathname.new(__FILE__).parent.join("chest2.db")))
+    @c2.publish!
+    @tm = TestManager.new
+    @tm.publish!
+    assert_within(10) do
+      !@p.chests.empty?
+    end
+    assert_within(10) do
+      !@p.trannies.empty?
+    end
+  end
+
+  def teardown
+    @c.persistence_provider.unlink
+    @c2.persistence_provider.unlink
+    @tm.persistence_provider.unlink
+    DRb.stop_service
+  end
+
+  def test_write_read
+    0.upto(100) do |n|
+      @p["#{n}"] = "#{n}"
+    end
+    chest_ids = Set.new
+    0.upto(100) do |n|
+      chest_ids << @c.service_id if @c["#{n}"]
+      chest_ids << @c2.service_id if @c2["#{n}"]
+    end
+
+    assert(chest_ids.include?(@c.service_id), "This may fail due to bad luck, try again")
+    assert(chest_ids.include?(@c2.service_id), "This may fail due to bad luck, try again")
+
+    @p["brupp"] = "jojo"
+    assert_equal("jojo", @p["brupp"])
+    s1 = @p["brupp"]
+    s2 = @p["brupp"]
+    assert_equal(s1, s2)
+  end
+
+  def test_write_read_transaction
+    $T = true
+    @p["hej"] = "haha"
+    p2 = @p.begin
+    assert_equal(p2["hej"], @p["hej"])
+    p2["hej"] = "bums"
+    assert(p2["hej"] != @p["hej"])
+    p2.commit!
+    assert_equal("bums", p2["hej"])
+    assert_equal(p2["hej"], @p["hej"])
+
+    p2 = @p.begin
+    p2["hej"] = "glass"
+    assert(p2["hej"] != @p["hej"])
+    p2.abort!
+    assert("bums", @p["hej"])
+    $T = false
+  end
+
+end

data/tests/test_helper.rb

@@ -0,0 +1,60 @@
+
+home = File.expand_path(File.dirname(__FILE__))
+$: << File.join(home, "..", "lib")
+
+require 'pp'
+require 'test/unit'
+require 'tranny'
+require 'treasure'
+require 'benchmark'
+
+class TestTransaction
+  def join(o)
+  end
+  def state
+    :active
+  end
+end
+
+class TestManager < Archipelago::Tranny::Manager
+  attr_reader :persistence_provider
+  def log_error(e)
+    puts e
+    pp e.backtrace
+  end
+end
+
+class TestJockey < Archipelago::Disco::Jockey
+  attr_reader :remote_services, :local_services
+end
+
+class TestChest < Archipelago::Treasure::Chest
+  attr_reader :persistence_provider
+end
+
+class Test::Unit::TestCase
+
+  def bm(label, options = {})
+    n = options[:n] || 1000
+    width = options[:width] || 50
+    Benchmark.benchmark(" " * width + Benchmark::Tms::CAPTION, width, Benchmark::Tms::FMTSTR, "ms/call") do |b|
+      times = b.report("#{n}x#{label}") do
+        n.times do
+          yield
+        end
+      end
+      [times * 1000 / n.to_f]
+    end
+  end
+
+  def assert_within(timeout, &block)
+    t = Time.new
+    rval = yield
+    while !rval && t > Time.new - timeout
+      rval = yield
+      sleep(0.05)
+    end
+    assert(rval)
+  end
+
+end

data/tests/tranny_test.rb

@@ -0,0 +1,70 @@
+
+require File.join(File.dirname(__FILE__), 'test_helper')
+require 'tranny'
+require 'drb'
+
+class TrannyTest < Test::Unit::TestCase
+
+  def setup
+    DRb.start_service
+    @tm = TestManager.new(:db_path => Pathname.new(__FILE__).parent.join("tranny.db"))
+  end
+
+  def teardown
+    @tm.persistence_provider.unlink
+    DRb.stop_service
+  end
+
+  class Participant
+    include DRb::DRbUndumped
+
+    attr_accessor :state
+    attr_accessor :mode
+
+    def assert_equal(a,b)
+      raise "#{a} != #{b}" unless a == b
+    end
+    def initialize(mode)
+      @mode = mode
+      @state = :none
+    end
+    def abort!(t)
+      @state = :aborted
+    end
+    def prepare!(t)
+      assert_equal(:voting, t.state)
+      @mode
+    end
+    def commit!(t)
+      assert_equal(:commited, t.state)
+      @state = :commited
+    end
+  end
+
+  def test_successful_commit
+    p1 = Participant.new(:commit)
+    p2 = Participant.new(:commit)
+    trans = @tm.begin
+    assert_equal(:active, trans.state)
+    trans.join(DRbObject.new(p1))
+    trans.join(DRbObject.new(p2))
+    assert_equal(:commited, trans.commit!)
+    assert_equal(:commited, trans.state)
+    assert_equal(:commited, p1.state)
+    assert_equal(:commited, p2.state)
+  end
+
+  def test_aborted_commit
+    p1 = Participant.new(:commit)
+    p2 = Participant.new(:abort)
+    trans = @tm.begin
+    assert_equal(:active, trans.state)
+    trans.join(DRbObject.new(p1))
+    trans.join(DRbObject.new(p2))
+    assert_equal(:aborted, trans.commit!)
+    assert_equal(:aborted, trans.state)
+    assert_equal(:aborted, p1.state)
+    assert_equal(:none, p2.state)
+  end
+
+end