archipelago 0.2.5 → 0.2.6

data/lib/archipelago/dump.rb

@@ -0,0 +1,279 @@
+# Archipelago - a distributed computing toolkit for ruby
+# Copyright (C) 2006  Martin Kihlgren <zond at troja dot ath dot cx>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+require 'rubygems'
+require 'oneliner'
+require 'archipelago/disco'
+require 'archipelago/hashish'
+require 'archipelago/sanitation'
+require 'pathname'
+require 'bdb'
+require 'drb'
+
+module Archipelago
+
+  module Dump
+
+    #
+    # The server class in the Archipipelago::Dump network.
+    #
+    # Uses an Archipelago::Sanitation::Officer to keep track of what is
+    # needed to be done for redundancy, but Site does the actual work.
+    #
+    class Site
+
+      #
+      # The minimum pause between checking if keys belong with us.
+      #
+      CHECK_INTERVAL = 30
+
+      #
+      # The Site can be published.
+      #
+      include Archipelago::Disco::Publishable
+
+      attr_accessor :db, :debug_callable, :officer, :persistence_provider
+
+      def initialize(options = {})
+        initialize_publishable(options)
+        #
+        # The callable object that will get sent our debug messages if it exists.
+        #
+        @debug_callable = options[:debug_callable]
+
+        #
+        # The provider of checksumming magic and chunk distribution.
+        #
+        @officer = options[:officer] || (defined?(Archipelago::Sanitation::CLEANER) ? Archipelago::Sanitation::CLEANER : Archipelago::Sanitation::Officer.new)
+
+        #
+        # The database where the data lives.
+        #
+        @db = @persistence_provider.get_dup_tree("db")
+
+        #
+        # The minimum pause between checking if keys belong with us.
+        #
+        @check_interval = options[:check_interval] || CHECK_INTERVAL
+      end
+
+      #
+      # Will insert the array +values+ under +key+ in the db.
+      #
+      # Will insert them with the +timestamp+ or "\000\000\000\000".
+      #
+      # If values with the same timestamp already exists, it will 
+      # overwrite them if they are greater in number than the given 
+      # +values+. If they are fewer enough of the given +values+ 
+      # will be inserted to get the same number of values in the 
+      # database as in +values.
+      #
+      # Any values with a different timestamp will be deleted.
+      #
+      def insert!(key, values, timestamp = "\000\000\000\000")
+        if (duplicates = @db.duplicates(key)).empty?
+          values.each do |value|
+            @db[key] = timestamp + value
+          end
+        else
+          my_timestamp = duplicates.first[0...4]
+          if timestamp != my_timestamp || duplicates.size > values.size
+            @db.env.begin(BDB::TXN_COMMIT, @db) do |txn, db|
+              db.delete(key)
+              values.each do |value|
+                db[key] = timestamp + value
+              end
+            end
+          else
+            values[0...(values.size - duplicates.size)].each do |value|
+              @db[key] = timestamp + value
+            end
+          end
+        end
+      end
+
+      #
+      # Fetches all duplicates of +key+.
+      #
+      # Returns [[TIMESTAMP0, VALUE0],...,[TIMESTAMPn, VALUEn]]
+      #
+      def fetch(key)
+        values = @db.duplicates(key).collect do |value|
+          [value[0...4], value[4..-1]]
+        end
+        return values
+      end
+
+      #
+      # Deletes +key+ from the db.
+      #
+      def delete!(key)
+        return @db.delete(key)
+      end
+
+      private
+
+      #
+      # After we have been published we will subscribe to other Archipelago::Dump::Site
+      # changes and start a thread that checks our edge keys.
+      #
+      def around_publish(&publish_block)
+        yield
+        @jockey.subscribe(:lost, @officer.service_descriptions[:sites], service_id) do |record|
+          lost_peer(record)
+        end
+        start_edge_check
+      end
+
+      #
+      # Before we stop we will unsubscribe from other Archipelago::Dump::Site
+      # changes and kill our @edge_check_thread.
+      #
+      def around_unpublish(&block)
+        @jockey.unsubscribe(:lost, @officer.service_descriptions[:sites], service_id)
+        @edge_check_thread.kill
+        yield
+      end
+
+      #
+      # Will ask our Archipelago::Sanitation::Officer to
+      # redistribute it.
+      #
+      # If that succeeded will delete it from our database.
+      #
+      def redistribute_and_delete(key)
+        begin
+          @debug_callable.call("#{service_id}.redistribute_and_delete(#{key}) gonna redist and delete") if @debug_callable
+          @officer.redistribute(key)
+          @db.delete(key)
+          @debug_callable.call("#{service_id}.redistribute_and_delete(#{key}) done redistributing") if @debug_callable
+        rescue Exception => e
+          @debug_callable.call("#{service_id}.redistribute_and_delete(#{key}) got #{e}: #{PP.pp(e.backtrace, "")}") if @debug_callable
+          # What shall we do in this case? 
+          # * Nothing, and wait for the admins to make a manual check?
+          # * Send an email someplace?
+          # * Store it somewhere so that the manual check goes faster?
+        end
+      end
+
+      #
+      # Asks our Archipelago::Sanitation::Officer if +key+
+      # should reside with us.
+      #
+      def belongs_here?(key)
+        @officer.belongs_at?(self.service_id, key)
+      end
+
+      #
+      # Starts a Thread that checks our first and last keys.
+      #
+      def start_edge_check
+        @edge_check_thread = Thread.new do
+          loop do
+            begin
+              @debug_callable.call("#{service_id}.start_edge_check doing its thang") if @debug_callable
+              keys_to_check = Set.new
+              @db.reverse_each_key do |key|
+                break if belongs_here?(key)
+                keys_to_check << key
+              end
+              @db.each_key do |key|
+                break if belongs_here?(key)
+                keys_to_check << key
+              end
+              @officer.update_services!(:validate => true) unless keys_to_check.empty?
+              keys_to_check.each do |key|
+                redistribute_and_delete(key)
+              end
+              sleep(@check_interval)
+            rescue Exception => e
+              @debug_callable.call("#{service_id}.start_edge_check() got #{e}: #{PP.pp(e.backtrace, "")}") if @debug_callable
+            end
+          end
+        end
+      end
+
+      #
+      # Returns whether we are right after +other_service_id+
+      # in the big scheme of things.
+      #
+      def right_after?(other_service_id)
+        @officer.next_to?(other_service_id, service_id)
+      end
+
+      #
+      # Returns whether we are right before +other_service_id+
+      # in the big scheme of things.
+      #
+      def right_before?(other_service_id)
+        @officer.next_to?(service_id, other_service_id)
+      end
+
+      #
+      # Tell the officer to redistribute +key+ and ignore any errors.
+      #
+      def redistribute(key)
+        begin
+          @officer.redistribute(key)
+        rescue Exception => e
+          @debug_callable.call("#{service_id}.redistribute(#{key}) got #{e}: #{PP.pp(e.backtrace, "")}") if @debug_callable
+          # What shall we do in this case? 
+          # * Nothing, and wait for the admins to make a manual check?
+          # * Send an email someplace?
+          # * Store it somewhere so that the manual check goes faster?
+        end
+      end
+
+      #
+      # When we have lost a peer +record+ we must check if it was a neighbour of ours.
+      #
+      # If it was, then we must redistribute its keys.
+      #
+      # If it was our forward neighbour we will redistribute everything that
+      # we hold that we know that it as well held - everything from and including
+      # our second to first master upto and including ourselves.
+      #
+      # If it was our backward neighbour we will redistribute everything that
+      # it was master to.
+      #
+      def lost_peer(record)
+        @debug_callable.call("#{service_id}.lost_peer(#{record[:service_id]}) called") if @debug_callable
+        keys_to_redistribute = Set.new
+        if right_before?(record[:service_id])
+          @debug_callable.call("#{service_id}.lost_peer(#{record[:service_id]}) is right_before, redistributing from #{@officer.second_master_to(service_id)}") if @debug_callable
+          @db.each_key(@officer.second_master_to(service_id)) do |key|
+            keys_to_redistribute << key
+          end
+        end
+        if right_after?(record[:service_id])
+          @debug_callable.call("#{service_id}.lost_peer(#{record[:service_id]}) is right_after, redistributing up to #{record[:service_id]}") if @debug_callable
+          @db.each_key(@officer.predecessor(record[:service_id])) do |key|
+            keys_to_redistribute << key
+            break if key > record[:service_id]
+          end
+        end
+        @officer.update_services!(:validate => true)
+        keys_to_redistribute.each do |key|
+          redistribute(key)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/archipelago/hashish.rb

@@ -17,6 +17,7 @@
 
 require 'archipelago/current'
 require 'bdb'
+require 'rbtree'
 
 module Archipelago
 
@@ -26,46 +27,88 @@ module Archipelago
   module Hashish
 
     #
-    # In essence a Berkeley Database backed Hash.
+    # In essence a persistence backed Hash (with certain BTree behaviours).
     #
-    # Will cache all values having been written or read
-    # in a normal Hash cache for fast access.
+    # Will cache everything including timestamps for last
+    # modification in normal Hashes, but keep everything stored
+    # in a persistency backer defined by the subclass.
     #
-    # Will save the last update timestamp for all keys
-    # in a separate Hash cache AND a separate Berkeley Database.
-    #
-    class BerkeleyHashish
+    module CachedHashish
       include Archipelago::Current::Synchronized
       #
-      # Initialize an instance with the +name+ and BDB::Env +env+.
+      # Returns true if what +key+ points to is no longer +value+.
       #
-      def initialize(name, env)
-        super()
-        @content_db = env.open_db(BDB::HASH, name, "content", BDB::CREATE)
-        @content = {}
-        @timestamps_db = env.open_db(BDB::HASH, name, "timestamps", BDB::CREATE | BDB::NOMMAP)
-        @timestamps = {}
-        @lock = Archipelago::Current::Lock.new
+      def changed?(key, value)
+        raise "You have to implement me!"
+      end
+      #
+      # Get the serialized timestamp for +serialized_key+ from the persistent backer.
+      #
+      def do_get_timestamp_from_db(serialized_key)
+        raise "You have to implement me!"
+      end
+      #
+      # Actually writes +key+ serialized as +serialized_key+ an
+      # +serialized_value+ to the db, and +timestamp+ to the 
+      # timestamp db.
+      #
+      # Used by <b>write_to_db</b>.
+      #
+      def do_write_to_db(key, serialized_key, serialized_value, timestamp)
+        raise "You have to implement me!"
       end
       #
-      # Close the @content_db and @timestamps_db behind this BerkeleyHashish
+      # Close the persistent backers behind this CachedHashish.
       #
       def close!
-        @content_db.close
-        @timestamps_db.close
+        raise "You have to implement me!"
       end
       #
-      # Returns a deep ( Marshal.load(Marshal.dump(o)) ) clone
-      # of the object represented by +key+.
+      # Returns whether the persistent backer contains +key+.
       #
-      def get_deep_clone(key)
-        return Marshal.load(@content_db[Marshal.dump(key)])
+      def db_include?
+        raise "You have to implement me!"
       end
       #
-      # Returns true if this BerkeleyHashish include +key+.
+      # Will perform an actual fetching of +serialized_key+ from the persistent backer.
       #
-      def include?(key)
-        @content.include?(key) || !@content_db[Marshal.dump(key)].nil?
+      def do_get_from_db(serialized_key)
+        raise "You have to implement me!"
+      end
+      #
+      # Actually deletes +serialized_key+ from the persistent backer.
+      #
+      def do_delete_from_persistence(serialized_key)
+        raise "You have to implement me!"
+      end
+      #
+      # Will do +callable+.call(key, value) for each
+      # key-and-value pair in this Hashish.
+      #
+      # NB: This is totaly thread-unsafe, only do this
+      # for management or rescue!
+      #
+      def each(callable)
+        raise "You have to implement me!"
+      end
+      #
+      # Get the first key/value pair from our cache tree.
+      #
+      def first
+        @content.first
+      end
+      #
+      # Get the last key/value pair from our cache tree.
+      #
+      def last
+        @content.last
+      end
+      #
+      # Forget the given +key+ in the cache tree.
+      #
+      def forget(key)
+        @content.delete(key)
+        @timestamps.delete(key)
       end
       #
       # Simply get the value for the +key+.
@@ -76,7 +119,7 @@ module Archipelago
       # if the value didnt exist in the live hash yet.
       #
       def [](key)
-        @lock.synchronize_on(key) do
+        synchronize_on(key) do
 
           value = @content[key]
           return value if value
@@ -85,6 +128,14 @@ module Archipelago
  
         end
       end
+      def without_lock(&block)
+        @unlocked_thread = Thread.current
+        begin
+          yield
+        ensure
+          @unlocked_thread = nil
+        end
+      end
       #
       # Insert +value+ under +key+.
       #
@@ -93,7 +144,7 @@ module Archipelago
       # <b>value.respond_to?(:save_hook)</b>.
       #
       def []=(key, value)
-        @lock.synchronize_on(key) do
+        synchronize_on(key, @unlocked_thread != Thread.current) do
 
           @content[key] = value
 
@@ -114,7 +165,7 @@ module Archipelago
       # a save is actually performed.
       #
       def store_if_changed(key)
-        @lock.synchronize_on(key) do
+        synchronize_on(key) do
 
           value = @content[key]
 
@@ -131,64 +182,88 @@ module Archipelago
 
             serialized_value = Marshal.dump(value)
             serialized_key = Marshal.dump(key)
-            old_serialized_value = @content_db[serialized_key]
-            
-            write_to_db(key, serialized_key, serialized_value, value) if old_serialized_value && old_serialized_value != serialized_value
+            write_to_db(key, serialized_key, serialized_value, value) if changed?(serialized_key, serialized_value)
             
           end
 
         end
       end
       #
-      # Returns the last time the value under +key+ was changed.
+      # Returns a deep ( Marshal.load(Marshal.dump(o)) ) clone
+      # of the object represented by +key+.
       #
-      def timestamp(key)
-        @lock.synchronize_on(key) do
-          
-          timestamp = @timestamps[key]
-          return timestamp if timestamp
-          
-          serialized_key = Marshal.dump(key)
-          serialized_timestamp = @timestamps_db[serialized_key]
-          return nil unless serialized_timestamp
-          
-          timestamp = Marshal.load(serialized_timestamp)
-          @timestamps[key] = timestamp
-          return timestamp
-
-        end
+      def get_deep_clone(key)
+        return Marshal.load(Marshal.dump(@content[key]))
       end
       #
-      # Will do +callable+.call(key, value) for each
-      # key-and-value pair in this Hashish.
-      #
-      # NB: This is totaly thread-unsafe, only do this
-      # for management or rescue!
+      # Initializes the cache hashes for this CachedHashish.
       #
-      def each(callable)
-        @content_db.each do |serialized_key, serialized_value|
-          key = Marshal.load(serialized_key)
-          callable.call(key, self.[](key))
-        end
+      def initialize_cached_hashish
+        @content = RBTree.new
+        @timestamps = {}
+        @unlocked_thread = nil
       end
       #
       # Delete +key+ and its value and timestamp.
       #
       def delete(key)
-        @lock.synchronize_on(key) do
+        synchronize_on(key, @unlocked_thread != Thread.current) do
 
           serialized_key = Marshal.dump(key)
 
           @content.delete(key)
-          @content_db[serialized_key] = nil
           @timestamps.delete(key)
-          @timestamps_db[serialized_key] = nil
-          
+          do_delete_from_persistence(serialized_key)
         end
       end
+      #
+      # Read +key+ from db and if it is found
+      # put it in the cache Hash.
+      #
+      # Will call <b>value.load_hook</b> and send it
+      # a block that does the actuall insertion of the value
+      # into the live hash if <b>value.respond_to?(:load_hook)</b>.
+      #
+      def get_from_db(key)
+        serialized_key = Marshal.dump(key)
+        serialized_value = do_get_from_db(serialized_key)
+        return nil unless serialized_value
+        
+        value = Marshal.load(serialized_value)
+        if value.respond_to?(:load_hook)
+          value.load_hook do
+            @content[key] = value
+          end
+        else
+          @content[key] = value
+        end
+        return value
+      end
+      #
+      # Returns true if this BerkeleyHashish include +key+.
+      #
+      def include?(key)
+        @content.include?(key) || db_include?(key)
+      end
+      #
+      # Returns the last time the value under +key+ was changed.
+      #
+      def timestamp(key)
+        synchronize_on(key) do
+          
+          timestamp = @timestamps[key]
+          return timestamp if timestamp
+          
+          serialized_key = Marshal.dump(key)
+          serialized_timestamp = do_get_timestamp_from_db(serialized_key)
+          return nil unless serialized_timestamp
+          
+          timestamp = Marshal.load(serialized_timestamp)
+          @timestamps[key] = timestamp
+          return timestamp
 
-      private
-
+        end
+      end
       #
       # Write +key+, serialized as +serialized_key+ and 
       # +serialized_value+ to the db.
@@ -199,50 +274,113 @@ module Archipelago
       #
       def write_to_db(key, serialized_key, serialized_value, value)
         if value.respond_to?(:save_hook)
-          old_serialized_value = @content_db[serialized_key]
+          old_serialized_value = do_get_from_db(serialized_key)
           old_value = old_serialized_value ? Marshal.load(old_serialized_value) : nil
           value.save_hook(old_value) do
-            do_write_to_db(key, serialized_key, serialized_value)            
+            now = Time.now
+            do_write_to_db(key, serialized_key, serialized_value, now)
+            @timestamps[key] = now
           end
         else
-          do_write_to_db(key, serialized_key, serialized_value)
+          now = Time.now
+          do_write_to_db(key, serialized_key, serialized_value, now)
+          @timestamps[key] = now
         end
       end
+    end
 
+    #
+    # An Archipelago::Dump network backed CachedHashish.
+    #
+    class DumpHashish
+      include Archipelago::Hashish::CachedHashish
       #
-      # Actually writes +key+ serialized as +serialized_key+ an
-      # +serialized_value+ to the db. Used by <b>write_to_db</b>.
+      # Initialize a new DumpHashish with the given +officer+ to find Dumps.
       #
-      def do_write_to_db(key, serialized_key, serialized_value)
-        now = Time.now
-
-        @content_db[serialized_key] = serialized_value
-        @timestamps_db[serialized_key] = Marshal.dump(now)
-        @timestamps[key] = now
+      def initialize(officer)
+        super()
+        initialize_cached_hashish
+        @officer = officer
+        @hash_by_key = {}
       end
-      
-      #
-      # Read +key+ from db and if it is found
-      # put it in the cache Hash.
+      def changed?(serialized_key, serialized_value)
+        return (old_hash = @hash_by_key[serialized_key]) && old_hash != Digest::SHA1.hexdigest(serialized_value)
+      end
+      def do_get_timestamp_from_db(serialized_key)
+        return @officer[officer_key(serialized_key, "timestamp")]
+      end
+      def do_write_to_db(key, serialized_key, serialized_value, now)
+        @officer[officer_key(serialized_key, "content")] = serialized_value
+        @officer[officer_key(serialized_key, "timestamp")] = Marshal.dump(now)
+        @hash_by_key[serialized_key] = Digest::SHA1.hexdigest(serialized_value)
+      end
+      def close!
+      end
+      def officer_key(serialized_key, space)
+        Digest::SHA1.hexdigest("Archipelago::Hashish::DumpHashish:#{space}:#{serialized_key}")
+      end
+      def db_include?(key)
+        return !@officer[officer_key(Marshal.dump(key), "content")].nil?
+      end
+      def do_get_from_db(serialized_key)
+        serialized_value = @officer[officer_key(serialized_key, "content")]
+        @hash_by_key[serialized_key] = Digest::SHA1.hexdigest(serialized_value) if serialized_value
+        return serialized_value
+      end
+      def do_delete_from_persistence(serialized_key)
+        @officer.delete(officer_key(serialized_key, "content"))
+        @officer.delete(officer_key(serialized_key, "timestamp"))
+        @hash_by_key[serialized_key] = Digest::SHA1.hexdigest(serialized_value)
+      end
+      def each(callable)
+        raise "You have to implement me!"
+      end
+    end
+
+    #
+    # A CachedHashish backed by a few BDB::Hashes.
+    #
+    class BerkeleyHashish
+      include Archipelago::Hashish::CachedHashish
       #
-      # Will call <b>value.load_hook</b> and send it
-      # a block that does the actuall insertion of the value
-      # into the live hash if <b>value.respond_to?(:load_hook)</b>.
+      # Initialize an instance with the +name+ and BDB::Env +env+.
       #
-      def get_from_db(key)
-        serialized_key = Marshal.dump(key)
-        serialized_value = @content_db[serialized_key]
-        return nil unless serialized_value
-        
-        value = Marshal.load(serialized_value)
-        if value.respond_to?(:load_hook)
-          value.load_hook do
-            @content[key] = value
-          end
-        else
-          @content[key] = value
+      def initialize(name, env)
+        super()
+        initialize_cached_hashish
+        @content_db = env.open_db(BDB::HASH, name, "content", BDB::CREATE)
+        @timestamps_db = env.open_db(BDB::HASH, name, "timestamps", BDB::CREATE | BDB::NOMMAP)
+      end
+      def close!
+        @content_db.close
+        @timestamps_db.close
+      end
+      def each(callable)
+        @content_db.each do |serialized_key, serialized_value|
+          key = Marshal.load(serialized_key)
+          callable.call(key, self.[](key))
         end
-        return value
+      end
+      def do_get_timestamp_from_db(serialized_key)
+        return @timestamps_db[serialized_key]
+      end
+      def do_delete_from_persistence(serialized_key)
+        @timestamps_db[serialized_key] = nil
+        @content_db[serialized_key] = nil
+      end
+      def changed?(serialized_key, serialized_value)
+        old_serialized_value = @content_db[serialized_key]
+        return old_serialized_value && old_serialized_value != serialized_value
+      end
+      def do_write_to_db(key, serialized_key, serialized_value, now)
+        @content_db[serialized_key] = serialized_value
+        @timestamps_db[serialized_key] = Marshal.dump(now)
+      end
+      def db_include?(key)
+        return !@content_db[Marshal.dump(key)].nil?
+      end
+      def do_get_from_db(serialized_key)
+        return @content_db[serialized_key]
       end
     end
 
@@ -256,30 +394,48 @@ module Archipelago
       #
       def initialize(env_path)
         env_path.mkpath
-        @env = BDB::Env.open(env_path, BDB::CREATE | BDB::INIT_MPOOL)
+        @env = BDB::Env.open(env_path, BDB::CREATE | BDB::INIT_MPOOL | BDB::INIT_TRANSACTION)
         @berkeley_hashishes = []
         @bdb_dbs = []
       end
       #
-      # Returns a cleverly cached (but slightly inefficient)
-      # hash-like instance (see Archipelago::Hashish::BerkeleyHashish)
-      # using +name+.
+      # Get a CachedHashish either backed by a Berkeley Database (if +:name+ is given)
+      # or by an Archipelago::Sanitation network (if +:officer+ is given).
+      #
+      def get_cached_hashish(options)
+        if options[:officer]
+          hashish = DumpHashish.new(options[:officer])
+          @berkeley_hashishes << hashish
+          return hashish
+        elsif options[:name]
+          hashish = BerkeleyHashish.new(options[:name], @env)
+          @berkeley_hashishes << hashish
+          return hashish
+        end
+      end
+      #
+      # Get a BDB::Btree allowing duplicates with +name+ and +flags+.
       #
-      def get_cached_hashish(name)
-        hashish = BerkeleyHashish.new(name, @env)
-        @berkeley_hashishes << hashish
-        return hashish
+      def get_dup_tree(name, flags = BDB::CREATE | BDB::NOMMAP)
+        db = BDB::Btree.open(Pathname.new(File.join(@env.home, name)).expand_path, 
+                            nil, 
+                            flags,
+                            0,
+                            "env" => @env,
+                            "set_flags" => BDB::DUP)
+        @bdb_dbs << db
+        return db
       end
       #
-      # Returns a normal hash-like instance using +name+.
+      # Get a BDB::Hash with +name+ and +flags+.
       #
-      def get_hashish(name)
-        db = @env.open_db(BDB::HASH, name, nil, BDB::CREATE | BDB::NOMMAP)
+      def get_hashish(name, flags = BDB::CREATE | BDB::NOMMAP)
+        db = @env.open_db(BDB::HASH, name, nil, flags)
         @bdb_dbs << db
         return db
       end
       #
-      # Closes databases opened by this instance.
+      # Close all our databases.
       #
       def close!
         @berkeley_hashishes.each do |h|
@@ -290,11 +446,11 @@ module Archipelago
         end
       end
       #
-      # Closes databases opened by this instance and removes the persistent files.
+      # Close and remove all our databases.
       #
       def unlink!
         close!
-        home = Pathname.new(@env.home)
+        home = Pathname.new(@env.home).expand_path
         @env.close
         home.rmtree if home.exist?
       end