xamplr 1.2.0

data/lib/xamplr/persisters/caching.rb

@@ -0,0 +1,172 @@
+module Xampl
+
+  require "fileutils"
+  require "xamplr/persisters/caches"
+
+  class AbstractCachingPersister < Persister
+
+    def initialize(root, name=nil, format=nil, capacity=DEFAULT_CAPACITY)
+      super(name, format)
+
+      raise XamplException.new(:name_required) unless name
+
+      @root_dir = File.join(root, name)
+      @repo_root = root
+      @repo_name = name
+
+      @capacity = capacity
+      @cache = {}
+      @new_cache = {}
+    end
+
+    def fresh_cache
+      return XamplCache.new(@capacity)
+    end
+
+    def sync_done
+      if @new_cache then
+        @new_cache.each do |name1, map1|
+          if map1 then
+            cache_map1 = @cache[name1]
+            @cache[name1] = cache_map1 = {} unless cache_map1
+            map1.each do |name2, map2|
+              if map2 then
+                cache_map2 = cache_map1[name2]
+                #cache_map1[name2] = cache_map2 = {} unless cache_map2
+                cache_map1[name2] = cache_map2 = fresh_cache unless cache_map2
+
+                #cache_map2.merge!(map2)
+                map2.each do |pid, xampl|
+                  cache_map2[pid] = xampl
+                end
+              end
+            end
+          end
+        end
+      end
+      @new_cache = {}
+    end
+
+    def rollback_cleanup
+      @new_cache.each do |name, map|
+        if map then
+          map.each do |name2, map2|
+            if map2 then
+              map2.each do |pid, xampl|
+                @changed.delete(xampl)
+              end
+            end
+          end
+        end
+        @changed.each do |xampl, ignore|
+          xampl.force_load
+        end
+        @new_cache = {}
+        super
+      end
+    end
+
+    def cache(xampl)
+      Xampl.store_in_map(@new_cache, xampl) { xampl }
+      xampl.introduce_persister(self)
+    end
+
+    def uncache(xampl)
+      @changed.delete(xampl)
+      Xampl.remove_from_map(@cache, xampl)
+      return Xampl.remove_from_map(@new_cache, xampl)
+    end
+
+    def clear_cache
+      @cache = {}
+      @new_cache = {}
+    end
+
+    def write_to_cache(xampl)
+      # puts "WRITE TO CACHE (#{xampl})"
+      return Xampl.store_in_cache(@cache, xampl, self) { xampl }
+    end
+
+    def read_from_cache(klass, pid, target=nil)
+      xampl = Xampl.lookup_in_map(@cache, klass, pid)
+      if xampl then
+        if target and target != xampl then
+
+          puts "#{File.basename(__FILE__)} #{__LINE__} CACHE CONFLICT:: klass: #{ klass }, pid: #{ pid }, target: #{ target }, cached: #{ xampl }"
+          dump(@cache)
+          caller(0).each { | trace | puts "  #{trace}"}
+
+          target.invalidate
+          raise XamplException.new(:cache_conflict)
+        end
+        unless xampl.load_needed then
+          @cache_hits = @cache_hits + 1
+          return xampl, target
+        end
+        return xampl, xampl
+      end
+
+      xampl = Xampl.lookup_in_map(@new_cache, klass, pid)
+      if xampl then
+        if target and target != xampl then
+          target.invalidate
+          raise XamplException.new(:cache_conflict)
+        end
+        unless xampl.load_needed then
+          @cache_hits = @cache_hits + 1
+          return xampl, target
+        end
+        return xampl, xampl
+      end
+
+      return nil, target
+    end
+
+    def dump(cache)
+      puts "DUMP CACHE"
+      cache.each do | k, v |
+        puts "--- [[#{k}]]"
+        v.each do | kk, vv |
+          puts "--- --- [[#{kk}]]"
+          puts vv.print
+        end
+      end
+    end
+
+    def read(klass, pid, target=nil)
+      #      puts "#{File.basename(__FILE__)} #{__LINE__} READ:: klass: #{klass} pid: #{pid} target: [[#{target}]], PM: #{ self }"
+
+      xampl, target = read_from_cache(klass, pid, target)
+      return xampl if xampl and !target
+
+      representation = read_representation(klass, pid)
+      return nil unless representation
+
+      xampl = nil
+      begin
+        #puts "ABSTRACT_READ[#{__LINE__}]:: klass: #{klass} pid: #{pid} target: #{target}"
+        xampl = realise(representation, target)
+        return nil unless xampl
+      rescue Exception => e
+        puts "FAILED TO READ -- persister: #{name} klass: #{klass} pid: #{pid} target: #{target}"
+        puts "Exception: #{e}"
+        print e.backtrace.join("\n")
+        #sleep 10
+        raise e
+      end
+
+      #      puts "#{File.basename(__FILE__)} #{__LINE__} STORE IN CACHE:: xampl: #{xampl }, persister: #{ self }"
+      #      dump(@cache)
+
+      Xampl.store_in_cache(@cache, xampl, self) { xampl }
+      xampl.introduce_persister(self)
+
+      @read_count = @read_count + 1
+      xampl.changes_accepted
+      @changed.delete(xampl)
+
+      return xampl
+    end
+  end
+end
+

data/lib/xamplr/persisters/filesystem.rb

@@ -0,0 +1,60 @@
+module Xampl
+
+  require 'xamplr/version'
+
+  require "fileutils"
+  require "xamplr/persisters/caching"
+
+  class FilesystemPersister < AbstractCachingPersister
+
+    def initialize(name=nil, format=nil, root=File.join(".", "repo"))
+      super(root, name, format)
+    end
+
+    def FilesystemPersister.kind
+      :filesystem
+    end
+
+    def kind
+      FilesystemPersister.kind
+    end
+
+    def version(stream)
+      catch(:refuse_to_version) do
+        Version.new(@repo_name, @repo_root).make(stream)
+      end
+    end
+
+
+    def write(xampl)
+      #raise XamplException.new(:no_index_so_no_persist) unless xampl.get_the_index or xampl.ignore_when_no_index
+      raise XamplException.new("no_index_so_no_persist [#{xampl.class.name}]") unless xampl.get_the_index or xampl.ignore_when_no_index
+      return unless xampl.get_the_index
+
+      place = File.join(@root_dir, xampl.class.name.split("::"))
+
+      FileUtils.mkdir_p(place) unless File.exist?(place)
+
+      place = File.join(place, xampl.get_the_index)
+
+      representation = represent(xampl)
+      if representation then
+        File.open(place, "w"){ | out | out.puts representation }
+        @write_count = @write_count + 1
+      end
+      xampl.changes_accepted
+      return true
+    end
+
+    def read_representation(klass, pid)
+      place = File.join(@root_dir, klass.name.split("::"), pid)
+
+      return nil unless File.exist?(place)
+      representation = File.read(place)
+      return representation
+    end
+  end
+
+  Xampl.register_persister_kind(FilesystemPersister)
+end
+

data/lib/xamplr/persisters/in-memory.rb

@@ -0,0 +1,180 @@
+module Xampl
+
+  require "xamplr/persisters/caches"
+
+  class InMemoryPersister < Persister
+
+    def initialize(name=nil, format=nil, capacity=20)
+      super(name, format)
+
+      @module_map = {}
+      @capacity = capacity
+      @cache = {}
+      @new_cache = {}
+    end
+
+    def InMemoryPersister.kind
+      :in_memory
+    end
+
+    def kind
+      InMemoryPersister.kind
+    end
+
+    def fresh_cache
+      return XamplCache.new(@capacity)
+    end
+
+    def sync_done
+      if @new_cache then
+        @new_cache.each{ | name1, map1 |
+          if map1 then
+            cache_map1 = @cache[name1]
+            @cache[name1] = cache_map1 = {} unless cache_map1
+            map1.each{ | name2, map2 |
+              if map2 then
+                cache_map2 = cache_map1[name2]
+                cache_map1[name2] = cache_map2 = self.fresh_cache unless cache_map2
+
+                map2.each{ | pid, xampl |
+                  cache_map2[pid] = xampl
+                }
+              end
+            }
+          end
+        }
+      end
+      @new_cache = {}
+    end
+
+    def rollback_cleanup
+      @new_cache.each{ | name, map |
+        if map then
+          map.each{ | name2, map2 |
+            if map2 then
+              map2.each{ | pid, xampl |
+                @changed.delete(xampl)
+                xampl.invalidate
+              }
+            end
+          }
+        end
+      }
+      @changed.each{ | xampl, ignore|
+        xampl.force_load
+      }
+      @new_cache = {}
+      super
+    end
+
+    def cache(xampl)
+      return Xampl.store_in_map(@new_cache, xampl) { xampl }
+    end
+
+    def uncache(xampl)
+      @changed.delete(xampl)
+      Xampl.remove_from_map(@cache, xampl)
+      return Xampl.remove_from_map(@new_cache, xampl)
+    end
+
+    def clear_cache
+      @new_cache = {}
+      @cache = {}
+    end
+
+    def write(xampl)
+      raise XamplException.new(:no_index_so_no_persist) unless xampl.get_the_index
+      #return false unless xampl.get_the_index
+
+      if Xampl.store_in_map(@module_map, xampl) { represent(xampl) } then
+        @write_count = @write_count + 1
+        xampl.changes_accepted
+        return true
+      else
+        return false
+      end
+    end
+
+    def read_from_cache(klass, pid, target=nil)
+      xampl = Xampl.lookup_in_map(@cache, klass, pid)
+      if xampl then
+        if target and target != xampl then
+          target.invalidate
+          raise XamplException.new(:cache_conflict)
+        end
+        unless xampl.load_needed then
+          @cache_hits = @cache_hits + 1
+          return xampl, target
+        end
+        return xampl, xampl
+      end
+
+      xampl = Xampl.lookup_in_map(@new_cache, klass, pid)
+      if xampl then
+        if target and target != xampl then
+          target.invalidate
+          raise XamplException.new(:cache_conflict)
+        end
+        unless xampl.load_needed then
+          @cache_hits = @cache_hits + 1
+          return xampl, target
+        end
+        return xampl, xampl
+      end
+
+      return nil, target
+    end
+
+    def xxread_from_cache(klass, pid, target=nil)
+      xampl = Xampl.lookup_in_map(@cache, klass, pid)
+      if (nil != xampl) then
+        puts "READ CACHE pid #{pid} -- #{target} #{xampl}" if target and  target != xampl
+        if target and target != xampl then
+          target.invalidate
+          raise XamplException.new(:cache_conflict)
+        end
+        unless xampl.load_needed then
+          @cache_hits = @cache_hits + 1
+          return xampl
+        end
+        target = xampl
+      end
+
+      xampl = Xampl.lookup_in_map(@new_cache, klass, pid)
+      if (nil != xampl) then
+        puts "READ CACHE pid #{pid} -- #{target} #{xampl}" if target and  target != xampl
+        if target and target != xampl then
+          target.invalidate
+          raise XamplException.new(:cache_conflict)
+        end
+        unless xampl.load_needed then
+          @cache_hits = @cache_hits + 1
+          return xampl
+        end
+        target = xampl
+      end
+
+      return xampl
+    end
+
+    def read(klass, pid, target=nil)
+      xampl, target = read_from_cache(klass, pid, target)
+      return xampl if xampl and !target
+
+      representation = Xampl.lookup_in_map(@module_map, klass, pid)
+      return nil unless representation
+
+      xampl = realise(representation, target)
+      Xampl.store_in_cache(@cache, xampl, self) { xampl }
+      xampl.introduce_persister(self)
+
+      @read_count = @read_count + 1
+      xampl.changes_accepted
+      @changed.delete(xampl)
+      return xampl
+    end
+  end
+
+  Xampl.register_persister_kind(InMemoryPersister)
+end
+

data/lib/xamplr/persisters/simple.rb

@@ -0,0 +1,59 @@
+module Xampl
+
+  class SimplePersister < Persister
+
+    def initialize(name=nil, format=nil)
+      super(name, format)
+
+      @module_map = {}
+      @cache = {}
+    end
+
+    def SimplePersister.kind
+      :simple
+    end
+
+    def kind
+      SimplePersister.kind
+    end
+
+    def sync_done
+    end
+
+    def has_changed(xampl)
+      throw :mixed_persisters unless self == xampl.persister
+    end
+
+    def cache(xampl)
+      return Xampl.store_in_map(@cache, xampl) { xampl }
+    end
+
+    def uncache(xampl)
+    end
+
+    def clear_cache
+      throw :really_bad_idea, "clearing the cache in a simple persister looses information"
+    end
+
+    def write(xampl)
+      return true
+    end
+
+    def read(klass, pid, target=nil)
+      xampl = Xampl.lookup_in_map(@cache, klass, pid)
+
+      if (nil != xampl) then
+        if target and target != xampl then
+          target.invalidate
+          throw(:cache_conflict)
+        end
+        throw(:load_unsupported) if xampl.load_needed
+      end
+
+      return xampl
+    end
+  end
+
+  Xampl.register_persister_kind(SimplePersister)
+end
+