archipelago 0.1.0

data/lib/hashish.rb

@@ -0,0 +1,199 @@
+# 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 'current'
+require 'bdb'
+
+module Archipelago
+
+  #
+  # The module containing the persistence default provider.
+  #
+  module Hashish
+
+    #
+    # In essence a Berkeley Database backed Hash.
+    #
+    # Will cache all values having been written or read
+    # in a normal Hash cache for fast access.
+    #
+    # Will save the last update timestamp for all keys
+    # in a separate Hash cache AND a separate Berkeley Database.
+    #
+    class BerkeleyHashish
+      include Archipelago::Current::Synchronized
+      #
+      # Initialize an instance with the +name+ and BDB::Env +env+.
+      #
+      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
+      end
+      #
+      # Returns a deep ( Marshal.load(Marshal.dump(o)) ) clone
+      # of the object represented by +key+.
+      #
+      def get_deep_clone(key)
+        return Marshal.load(@content_db[Marshal.dump(key)])
+      end
+      #
+      # Simply get the value for the +key+.
+      #
+      def [](key)
+        @lock.synchronize_on(key) do
+
+          value = @content[key]
+          return value if value
+          
+          return get_from_db(key)
+ 
+        end
+      end
+      #
+      # Insert +value+ under +key+.
+      #
+      def []=(key, value)
+        @lock.synchronize_on(key) do
+
+          @content[key] = value
+
+          write_to_db(key, Marshal.dump(key), Marshal.dump(value))
+
+          return value
+
+        end
+      end
+      #
+      # Stores whatever is under +key+ if it is not the same as
+      # whats in the persistent db.
+      #
+      def store_if_changed(key)
+        @lock.synchronize_on(key) do
+          
+          serialized_key = Marshal.dump(key)
+          serialized_value = Marshal.dump(@content[key])
+          
+          write_to_db(key, serialized_key, serialized_value) if @content_db[serialized_key] != serialized_value
+
+        end
+      end
+      #
+      # Returns the last time the value under +key+ was changed.
+      #
+      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
+      end
+      #
+      # Delete +key+ and its value and timestamp.
+      #
+      def delete(key)
+        @lock.synchronize_on(key) do
+
+          serialized_key = Marshal.dump(key)
+
+          @content.delete(key)
+          @content_db[serialized_key] = nil
+          @timestamps.delete(key)
+          @timestamps_db[serialized_key] = nil
+          
+        end
+      end
+
+      private
+
+      #
+      # Write +key+, serialized as +serialized_key+ and 
+      # +serialized_value+ to the db.
+      #
+      def 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
+      end
+      
+      #
+      # Read +key+ from db and if it is found
+      # put it in the cache Hash.
+      #
+      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)
+        @content[key] = value
+        return value
+      end
+    end
+
+    #
+    # A simple persistence provider backed by Berkeley db.
+    #
+    class BerkeleyHashishProvider
+      #
+      # Initialize an instance with the given
+      # +env_path+ to its database dir.
+      #
+      def initialize(env_path)
+        env_path.mkpath
+        @env = BDB::Env.open(env_path, BDB::CREATE | BDB::INIT_MPOOL)
+      end
+      #
+      # Returns a cleverly cached (but slightly inefficient)
+      # hash-like instance (see Archipelago::Hashish::BerkeleyHashish)
+      # using +name+.
+      #
+      def get_cached_hashish(name)
+        BerkeleyHashish.new(name, @env)
+      end
+      #
+      # Returns a normal hash-like instance using +name+.
+      #
+      def get_hashish(name)
+        @env.open_db(BDB::HASH, name, nil, BDB::CREATE | BDB::NOMMAP)
+      end
+      #
+      # Removes the persistent files of this instance.
+      #
+      def unlink
+        p = Pathname.new(@env.home)
+        p.rmtree if p.exist?
+      end
+    end
+    
+  end
+
+end

data/lib/pirate.rb

@@ -0,0 +1,205 @@
+# 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 'disco'
+require 'tranny'
+require 'treasure'
+require 'pp'
+require 'drb'
+require 'digest/sha1'
+
+module Archipelago
+
+  #
+  # The client library that knows about
+  # all remote databases and handles reads
+  # and write to them.
+  #
+  module Pirate
+
+    #
+    # Raised when you try to begin a transaction but have no managers
+    # available.
+    #
+    class NoTransactionManagerAvailableException < RuntimeError
+      def initialize(pirate)
+        super("#{pirate} can not find any transaction manager for you")
+      end
+    end
+
+    #
+    # Raised when you try to do stuff without any remote database
+    # available.
+    #
+    class NoRemoteDatabaseAvailableException < RuntimeError
+      def initialize(pirate)
+        super("#{pirate} can not find any remote database for you")
+      end
+    end
+
+    INITIAL_SERVICE_UPDATE_INTERVAL = 1
+    MAXIMUM_SERVICE_UPDATE_INTERVAL = 60
+    CHEST_DESCRIPTION = {
+      :class => 'Archipelago::Treasure::Chest'
+    }
+    TRANNY_DESCRIPTION = {
+      :class => 'Archipelago::Tranny::Manager'
+    }
+
+    #
+    # The class that actually keeps track of the Archipelago::Treasure:Chests and the
+    # Archipelago::Treasure:Dubloons in them.
+    #
+    class Captain
+      attr_reader :chests, :treasure_map, :trannies, :transaction
+      #
+      # Initialize an instance using an Archipelago::Disco::Jockey with <i>:jockey_options</i> 
+      # if given, that looks for new services <i>:initial_service_update_interval</i> or INITIAL_SERVICE_UPDATE_INTERVAL,
+      # when it starts and never slower than every <i>:maximum_service_update_interval</i> or MAXIMUM_SERVICE_UPDATE_INTERVAL.
+      #
+      # Will look for Archipelago::Treasure::Chests matching <i>:chest_description</i> or CHEST_DESCRIPTION and 
+      # Archipelago::Tranny::Managers matching <i>:tranny_description</i> or TRANNY_DESCRIPTION.
+      #
+      def initialize(options = {})
+        @treasure_map = Archipelago::Disco::Jockey.new(options[:jockey_options] || {})
+
+        @chest_description = CHEST_DESCRIPTION.merge(options[:chest_description] || {})
+        @tranny_description = TRANNY_DESCRIPTION.merge(options[:tranny_description] || {})
+        @jockey_options = options[:jockey_options] || {}
+
+        start_service_updater(options[:initial_service_update_interval] || INITIAL_SERVICE_UPDATE_INTERVAL,
+                              options[:maximum_service_update_interval] || MAXIMUM_SERVICE_UPDATE_INTERVAL)
+
+        @yar_counter = 0
+
+        @transaction = nil
+      end
+      
+      #
+      # Get a value from the distributed database network using a +key+,
+      # optionally within a +transaction+.
+      #
+      def [](key, transaction = nil)
+        responsible_chest(key)[:service][key, transaction || @transaction]
+      end
+
+      #
+      # Write a value to the distributed database network,
+      # optionally inside a transaction.
+      #
+      # Usage:
+      # * p["my key", transaction] = value
+      # * p["my key"] = value
+      #
+      def []=(key, p1, p2 = nil)
+        if @transaction && p2.nil?
+          p2 = p1
+          p1 = @transaction 
+        end
+        responsible_chest(key)[:service][key, p1] = p2
+      end
+
+      #
+      # Delete a value from the distributed database network,
+      # optionally inside a transaction.
+      #
+      def delete(key, transaction = nil)
+        responsible_chest(key)[:service].delete(key, transaction || @transaction)
+      end
+
+      #
+      # Return a clone of this instance bound to a newly created transaction.
+      #
+      def begin
+        raise NoTransactionManagerAvailableException.new(self) if @trannies.empty?
+
+        rval = self.clone
+        rval.instance_eval do
+          @transaction = @trannies.values.first[:service].begin
+        end
+
+        return rval
+      end
+
+      #
+      # Commit the transaction we are a member of and forget about it.
+      #
+      def commit!
+        @transaction.commit!
+        @transaction = nil
+      end
+
+      #
+      # Abort the transaction we are a member of and forget about it.
+      #
+      def abort!
+        @transaction.abort!
+        @transaction = nil
+      end
+
+      #
+      # Yarrr!
+      #
+      def yar!
+        @yar_counter += 1
+        'yar!'
+      end
+
+      private
+
+      #
+      # Get the chest responsible for +key+.
+      #
+      def responsible_chest(key)
+        raise NoRemoteDatabaseAvailableException.new(self) if @chests.empty?
+
+        key_id = Digest::SHA1.new(Marshal.dump(key)).to_s
+        sorted_chest_ids = @chests.keys.sort
+        sorted_chest_ids.each do |id|
+          return @chests[id] if id > key_id
+        end
+        return @chests[sorted_chest_ids.first]
+      end
+
+      #
+      # Start a thread looking up existing chests between every
+      # +initial+ and +maximum+ seconds.
+      #
+      def start_service_updater(initial, maximum)
+        @chests = @treasure_map.lookup(Archipelago::Disco::Query.new(@chest_description), 0)
+        @trannies = @treasure_map.lookup(Archipelago::Disco::Query.new(@tranny_description), 0)
+        Thread.start do
+          standoff = initial
+          loop do
+            begin
+              sleep(standoff)
+              standoff *= 2
+              standoff = maximum if standoff > maximum
+              @chests = @treasure_map.lookup(Archipelago::Disco::Query.new(@chest_description), 0)
+              @trannies = @treasure_map.lookup(Archipelago::Disco::Query.new(@tranny_description), 0)
+            rescue Exception => e
+              puts e
+              pp e.backtrace
+            end
+          end
+        end
+      end
+    end
+
+  end
+
+end