archipelago 0.2.5 → 0.2.6

data/lib/archipelago/treasure.rb

@@ -23,7 +23,7 @@ require 'pp'
 require 'set'
 require 'archipelago/hashish'
 require 'archipelago/tranny'
-require 'archipelago/disco'
+require 'archipelago/pirate'
 
 module Archipelago
 
@@ -51,6 +51,16 @@ module Archipelago
       end
     end
 
+    #
+    # Raised when a Dubloon tries to connect to this Archipelago::Treasure::Chest while
+    # we know that we are not the proper destination.
+    #
+    class WrongChestException < RuntimeError
+      def initialize(chest_id, predecessor_id, key)
+        super("#{key.inspect} is not between #{predecessor_id} and #{chest_id}, and should not be here")
+      end
+    end
+
     #
     # Raised whenever a method is called on an object that we dont know about.
     #
@@ -162,7 +172,7 @@ module Archipelago
       end
       #
       # Load some instance variables and replace @chest if we know that
-      # it actually is not correct.
+      # it is incorrect.
       #
       def self._load(s)
         key, chest, transaction, chest_id = Marshal.load(s)
@@ -189,7 +199,7 @@ module Archipelago
       end
       #
       # This Dubloon will always have the same object_id, based on 
-      # @chest_id and @key and possibly @transaction.
+      # @chest_id, @key and possibly @transaction.
       #
       def object_id
         id = "#{@chest_id}:#{@key}"
@@ -211,20 +221,58 @@ module Archipelago
       def method_missing(meth, *args, &block)
         begin
           return @chest.call_instance_method(@key, meth, @transaction, *args, &block)
+        rescue WrongChestException => e
+          #
+          # We just have to find the new chest we belong at now...
+          #
+          new_chest_record = nil
+          if defined?(Archipelago::Pirate::BLACKBEARD)
+            Archipelago::Pirate::BLACKBEARD.update_services!
+            new_chest_record = Archipelago::Pirate::BLACKBEARD.responsible_chest(@key)
+            new_chest_record = nil unless new_chest_record[:service].include?(@key, @transaction)
+          end
+          raise e unless new_chest_record
+
+          chest = new_chest_record
+
+          retry
         rescue DRb::DRbConnError => e
+          #
+          # Here is some fancy rescuing being done.
+          #
+          # First: If we have an MC we will try to reconnect to our actual chest.
+          #
+          # Second: If that failed, we will try to reconnect to the chest that (according to the BLACKBEARD)
+          # is responsible for our key - if it actually HAS our key.
+          #
+          # If this fails, lets raise hell.
+          #
+          new_chest_record = nil
           if defined?(Archipelago::Disco::MC)
-            possible_replacements = Archipelago::Disco::MC.lookup(Archipelago::Disco::Query.new({:service_id => @chest_id}))
-            raise e if possible_replacements.empty?
-            
-            @chest = possible_replacements[@chest_id][:service]
-            CHEST_BY_SERVICE_ID[@chest_id] = @chest
-            
-            retry
-          else
-            raise e
+            new_chest_record = Archipelago::Disco::MC.lookup(Archipelago::Disco::Query.new({
+                                                                                             :service_id => @chest_id
+                                                                                           }))[@chest_id]
+          end
+          if new_chest_record.nil? && defined?(Archipelago::Pirate::BLACKBEARD)
+            Archipelago::Pirate::BLACKBEARD.update_services!(:validate => true)
+            new_chest_record = Archipelago::Pirate::BLACKBEARD.responsible_chest(@key)
+            new_chest_record = nil unless new_chest_record[:service].include?(@key, @transaction)
           end
+          raise e unless new_chest_record
+
+          chest = new_chest_record
+
+          retry
         end
       end
+
+      private
+
+      def chest=(record)
+        @chest = record[:service]
+        @chest_id = record[:service_id]
+        CHEST_BY_SERVICE_ID[@chest_id] = @chest 
+      end
             
     end
 
@@ -245,19 +293,17 @@ module Archipelago
       # Initialize a Chest
       #
       # Will use a BerkeleyHashishProvider using treasure_chest.db in the same dir to get its hashes
-      # if not <i>:persistence_provider</i> is given.
+      # if not <i>:persistence_directory</i> is given.
       #
       # Will try to recover crashed transaction every <i>:transaction_recovery_interval</i> seconds
       # or TRANSACTION_RECOVERY_INTERVAL if none is given.
       #
+      # Will store the actual data in a remote Archipelago::Dump network if <i>:officer</i> is given
+      # or in a local hash if not.
+      #
       # Will use Archipelago::Disco::Publishable by calling <b>initialize_publishable</b> with +options+.
       #
       def initialize(options = {})
-        #
-        # The provider of happy magic persistent hashes of different kinds.
-        #
-        @persistence_provider = options[:persistence_provider] || Archipelago::Hashish::BerkeleyHashishProvider.new(Pathname.new(File.expand_path(__FILE__)).parent.join("treasure_chest.db"))
-        
         #
         # Use the given options to initialize the publishable
         # instance variables.
@@ -290,11 +336,39 @@ module Archipelago
         # The magical persistent map that defines how we actually 
         # store our data.
         #
-        @db = @persistence_provider.get_cached_hashish("db")
+        if options[:officer]
+          @db = @persistence_provider.get_cached_hashish(:officer => options[:officer])
+        else
+          @db = @persistence_provider.get_cached_hashish(:name => "db")
+        end
 
         initialize_prepared(options[:transaction_recovery_interval] || TRANSACTION_RECOVERY_INTERVAL)
 
         CHEST_BY_SERVICE_ID[self.service_id] = self
+
+        #
+        # The provider of Chest index and other magic.
+        #
+        @captain = options[:captain] || (defined?(Archipelago::Pirate::BLACKBEARD) ? Archipelago::Pirate::BLACKBEARD : Archipelago::Pirate::Captain.new)
+
+        #
+        # Our predecessor. We will NOT accept remote calls for keys before this one.
+        #
+        @predecessor_id = nil
+      end
+      
+      #
+      # Our predecessor is making itself public,
+      # so make sure we dont know about any keys we shouldnt.
+      #
+      def notify!(predecessor_id)
+        @predecessor_id = predecessor_id
+        while (to_check = @db.first) && !between?(to_check.first, @predecessor_id, service_id)
+          @db.forget(to_check.first)
+        end
+        while (to_check = @db.last) && !between?(to_check.first, @predecessor_id, service_id)
+          @db.forget(to_check.first)
+        end
       end
 
       #
@@ -434,6 +508,8 @@ module Archipelago
       # will be wrapped within the block sent to <b>with_transaction(transaction, &block)</b>.
       #
       def call_instance_method(key, method, transaction, *arguments, &block)
+        assert_mine(key)
+
         if transaction
           return call_with_transaction(key, method, transaction, *arguments, &block)
         else
@@ -562,10 +638,12 @@ module Archipelago
           # Copy each key and value from our private space to the real space
           #
           snapshot.each do |key, value|
-            if value == :deleted
-              @db.delete(key)
-            else
-              @db[key] = value
+            @db.without_lock do
+              if value == :deleted
+                @db.delete(key)
+              else
+                @db[key] = value
+              end
             end
           end
 
@@ -579,6 +657,62 @@ module Archipelago
 
       private
 
+      #
+      # Asserts that +key+ (as far as I know) belongs here.
+      #
+      # Raises WrongChestException if not.
+      #
+      def assert_mine(key)
+        unless between?(key, @predecessor_id, service_id)
+          raise WrongChestException.new(service_id, @predecessor_id, key) 
+        end
+      end
+
+      #
+      # We don't want to publish until we have notified our successor of our id,
+      # and we need to repeat that when chests are lost or found.
+      #
+      def around_publish(&block)
+        notify_successor!
+        @jockey.subscribe(:lost, @captain.service_descriptions[:chests], service_id) do |record|
+          notify_successor!
+        end
+        @jockey.subscribe(:found, @captain.service_descriptions[:chests], service_id) do |record|
+          notify_successor!
+        end
+        yield
+      end
+      
+      #
+      # We want to unsubscribe from the lost and found channel.
+      #
+      def around_unpublish(&block)
+        @jockey.unsubscribe(:lost, @captain.service_descriptions[:chests], service_id)
+        @jockey.unsubscribe(:found, @captain.service_descriptions[:chests], service_id)
+        yield
+      end
+
+      #
+      # We want to notify our successor when stuff happens.
+      #
+      def notify_successor!
+        successor = (@captain.successor(service_id) || {:service => self})[:service]
+        successor.notify!(service_id)
+      end
+
+      #
+      # Returns whether key is between id1 and id2 on the big service circle.
+      #
+      def between?(key, id1, id2)
+        if id1 == id2
+          return true
+        elsif id1 < id2
+          return key < id2 && key >= id1
+        elsif id1 > id2
+          return key < id2 || key >= id1
+        end
+      end
+
       #
       # Evaluates all data we have been told to evaluate in earlier runs.
       #
@@ -656,6 +790,7 @@ module Archipelago
             instance.with_transaction(transaction) do
               return_value = instance.send(method, *arguments, &block)
             end
+            return_value = Dubloon.new(key, self, transaction, service_id) if return_value == instance
             return return_value
           else
             return instance.send(method, *arguments, &block)
@@ -678,10 +813,12 @@ module Archipelago
       def call_without_transaction(key, method, *arguments, &block)
         instance = @db[key]
 
-        raise UnknownObjectException(self, key) unless instance
+        raise UnknownObjectException.new(self, key) unless instance
 
         begin
-          return instance.send(method, *arguments, &block)
+          return_value = instance.send(method, *arguments, &block)
+          return_value = Dubloon.new(key, self, nil, service_id) if return_value == instance
+          return return_value
         ensure
           @db.store_if_changed(key)
         end
@@ -704,10 +841,13 @@ module Archipelago
         #
         @snapshot_by_transaction_db = @persistence_provider.get_hashish("prepared")
         @snapshot_by_transaction_db.each do |serialized_transaction, serialized_snapshot|
-          transaction = Marshal.load(transaction)
+          transaction = Marshal.load(serialized_transaction)
 
           @crashed << transaction
           @snapshot_by_transaction[transaction] = Marshal.load(serialized_snapshot)
+          @snapshot_by_transaction[transaction].each do |key, value|
+            @db.lock_on(key)
+          end
         end
         start_recovery_thread(transaction_recovery_interval)
       end
@@ -750,7 +890,13 @@ module Archipelago
       #
       def set(key, value, transaction)
         join!(transaction)
-        value.assert_transaction(transaction) if Dubloon === value
+        if Dubloon === value
+          value.assert_transaction(transaction)
+          #
+          # Return the value if the value is in fact a proxy to what we are trying overwrite.
+          #
+          return value if value.object_id == Dubloon.new(key, self, transaction, self.service_id).object_id
+        end
 
         if transaction
           snapshot = @snapshot_by_transaction[transaction]

data/script/{console → console.rb}

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

data/script/officer.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'archipelago/sanitation'
+
+begin
+  DRb.uri
+rescue DRb::DRbServerNotFound
+  DRb.start_service(ENV["DRBURI"])
+end
+@o = Archipelago::Sanitation::Officer.new

data/script/pirate.rb

@@ -2,6 +2,10 @@
 
 require 'archipelago/pirate'
 
-DRb.start_service
+begin
+  DRb.uri
+rescue DRb::DRbServerNotFound
+  DRb.start_service(ENV["DRBURI"])
+end
 @p = Archipelago::Pirate::Captain.new
 @p.evaluate!(File.join(File.dirname(__FILE__), 'overloads.rb'))

data/script/services.rb

@@ -9,7 +9,7 @@ $: << File.join(File.dirname(__FILE__), "..", "lib")
 
 require 'archipelago/treasure'
 require 'archipelago/tranny'
-require 'archipelago/cove'
+require 'archipelago/dump'
 
 if ARGV.size > 1
   DRb.start_service(ARGV[1])
@@ -19,12 +19,19 @@ if ARGV.size > 1
 else
   DRb.start_service
 end
+puts "using URI #{DRb.uri}"
 
-t = Archipelago::Tranny::Manager.new(:persistence_provider => Archipelago::Hashish::BerkeleyHashishProvider.new(Pathname.new(File.join(ARGV[0], "tranny"))))
+t = Archipelago::Tranny::Manager.new(:persistence_directory => Pathname.new(File.join(ARGV[0], "tranny")))
 t.publish!
-c = Archipelago::Treasure::Chest.new(:persistence_provider => Archipelago::Hashish::BerkeleyHashishProvider.new(Pathname.new(File.join(ARGV[0], "chest"))))
+puts "published #{t.class} with id #{t.service_id}"
+
+d = Archipelago::Dump::Site.new(:persistence_directory => Pathname.new(File.join(ARGV[0], "dump")))
+d.publish!
+puts "published #{d.class} with id #{d.service_id}"
+
+c = Archipelago::Treasure::Chest.new(:persistence_directory => Pathname.new(File.join(ARGV[0], "chest")),
+                                     :officer => Archipelago::Sanitation::CLEANER)
 c.publish!
-tank = Archipelago::Cove::Tanker.new(:persistence_provider => Archipelago::Hashish::BerkeleyHashishProvider.new(Pathname.new(File.join(ARGV[0], "tanker"))))
-tank.publish!
+puts "published #{c.class} with id #{c.service_id}"
 
 DRb.thread.join

data/tests/disco_benchmark.rb

@@ -8,8 +8,8 @@ class DiscoBenchmark < Test::Unit::TestCase
     dj2 = TestJockey.new
     x = 0
     bm("Jockey#publish/lookup", :n => 10) do
-      dj1.publish(Archipelago::Disco::Record.new({:service_id => x, :validator => Archipelago::Disco::MockValidator.new}))
-      assert(!dj2.lookup(Archipelago::Disco::Query.new({:service_id => x})).empty?)
+      dj1.publish(Archipelago::Disco::Record.new({:service_id => x.to_s, :validator => Archipelago::Disco::MockValidator.new}))
+      assert(!dj2.lookup(Archipelago::Disco::Query.new({:service_id => x.to_s})).empty?)
       x += 1
     end
     dj1.publish(Archipelago::Disco::Record.new({:service_id => "brappa", :validator => Archipelago::Disco::MockValidator.new}))

data/tests/disco_test.rb

@@ -15,7 +15,6 @@ end
 class DiscoTest < Test::Unit::TestCase
 
   def setup
-    DRb.start_service
     @d1 = TestJockey.new(:thrifty_publishing => false, 
                          :thrifty_replying => false,
                          :thrifty_caching => false)
@@ -47,7 +46,8 @@ class DiscoTest < Test::Unit::TestCase
     @lt = Thread.new do
       loop do
         begin
-          @ltq << @listener.recv(1024)
+          d = @listener.recv(1024)
+          @ltq << d unless d =~ /UnPublish/
         rescue Exception => e
           puts e
           pp e.backtrace
@@ -59,31 +59,63 @@ class DiscoTest < Test::Unit::TestCase
   def teardown
     @d1.stop!
     @d2.stop!
-    DRb.stop_service
     @lt.kill
     @listener.close
   end
 
   def test_publish_lookup
+    found_it = false
+    found_wrong = false
+
+    @d2.subscribe(:found, Archipelago::Disco::Query.new(:epa => "blar2"), 1) do
+      found_it = true
+    end
+    @d2.subscribe(:found, Archipelago::Disco::Query.new(:epa => "blar2x"), 1) do
+      found_wrong = true
+    end
+
     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, 
+    
+    @d1.publish(Archipelago::Disco::Record.new(:service_id => 100, 
                                                :validator => Archipelago::Disco::MockValidator.new, 
                                                :epa => "blar2"))
 
     assert_within(0.5) do
       !empty
     end
+
+    assert(found_it)
+    assert(!found_wrong)
   end
 
   def test_publish_invalidate
     @v1.valid = false
-    assert(@d2.lookup(Archipelago::Disco::Query.new(:epa => "blar"), 0).empty?)
+
+    lost_it = false
+    lost_wrong = false
+    
+    @d2.subscribe(:lost, Archipelago::Disco::Query.new(:epa => "blar"), 1) do
+      lost_it = true
+    end
+    @d2.subscribe(:lost, Archipelago::Disco::Query.new(:epa => "blarx"), 1) do
+      lost_wrong = true
+    end
+    @d2.subscribe(:lost, Archipelago::Disco::Query.new(:epa => "blarx"), 2) do
+      lost_wrong = true
+    end
+    @d2.unsubscribe(:lost, Archipelago::Disco::Query.new(:epa => "blarx"), 2)
+
+    assert(@d2.lookup(Archipelago::Disco::Query.new(:epa => "blar"), 0).validate!.empty?)
+
+    @d2.validate!
+
+    assert(lost_it)
+    assert(!lost_wrong)
   end
 
   def test_thrifty_publishing
@@ -112,7 +144,7 @@ class DiscoTest < Test::Unit::TestCase
                                               :validator => Archipelago::Disco::MockValidator.new, 
                                               :service_id => 33))
     sleep 0.1
-    assert(@ltq.empty?)
+    assert(@ltq.empty?, "we got messages while we shouldnt: #{@ltq.inspect}")
 
     c1 = Archipelago::Disco::Jockey.new(:thrifty_publishing => true)
     assert(!c1.lookup(Archipelago::Disco::Query.new(:glad => "ja")).empty?)