lore 0.4.2

data/cache/cacheable.rb

@@ -0,0 +1,202 @@
+
+require('pstore')
+
+require('lore/cache/bits')
+require('lore/exception/cache_exception')
+
+module Lore
+module Cache
+
+  module Cacheable
+
+    @@cache_control      = Hash.new
+    @@cache_on_pkeys     = Hash.new
+    @@distinctive_params = Hash.new
+    @@cache_entities     = false
+
+    @@logger = Lore.logger
+    
+  public
+  
+    def is_cacheable(controller)
+      controller = controller.intern unless controller.instance_of? Symbol
+      return !@@cache_control[controller].nil? && @@cache_control[controller]
+    end
+
+    # Returns whether a Table_Accessor state 
+    # is cached or not. 
+    def is_cached(controller, mode, keys)
+      
+      store_filename = Lore::Cache::store_name(self.name.to_s, controller, mode, keys)
+      if store_filename.nil? then
+        excep_mesg  = 'Cannot resolve store filename for ['+self.name.to_s+'|'+controller+'|'+mode+']'
+        excep_mesg += ' Keys: '+keys.to_s
+        raise ::Exception.new(excep_mesg)
+      end
+
+      if FileTest.exist?(store_filename) then
+        true
+      else 
+        false
+      end
+
+    end
+
+  protected
+
+    def cache(controller, additional_params=nil)
+      controller = controller.intern unless controller.instance_of? Symbol
+      @@cache_control[controller] = true
+      if !additional_params.nil? then
+        @@distinctive_params[controller] = Array.new unless !@@distinctive_params[controller].nil?
+        @@distinctive_params[controller] += additional_params
+      end
+
+    end
+
+    def cache_select_entities
+      @@cache_entities = true
+    end
+
+    def cache_entities
+      @@cache_entities
+    end
+
+    def cache_on_pkeys(controller, additional_params=nil)
+      @@logger.log('Caching depending from pkeys only, controller: ' << controller.to_s << ', params: ' << additional_params.to_s)
+      cache(controller, additional_params)
+      @@cache_on_pkeys[controller] = true
+    end
+
+    def cache_pkeys_only?(controller)
+      !@@cache_on_pkeys[controller].nil? && @@cache_on_pkeys[controller]
+    end
+    
+    def nocache(controller)
+      controller = controller.intern unless controller.instance_of? Symbol
+      @@cache_control[controller] = false
+    end
+    
+  public
+
+    def cache_params(controller)
+      return @@distinctive_params[controller] unless @@distinctive_params[controller].nil?
+      return Hash.new
+    end
+
+    def create_cache(controller, mode, keys, output)
+
+      @@logger.log('cache_on_pkeys: '+@@cache_on_pkeys.inspect)
+      if !@@cache_on_pkeys[controller.intern].nil? && 
+         @@cache_on_pkeys[controller.intern] 
+      then
+        keys = filter_pkeys(self, controller, keys)
+        @@logger.log('Filtered keys: '+keys.inspect)
+      end
+
+      if !@@cache_control[controller.intern].nil? && 
+         @@cache_control[controller.intern] 
+      then
+      
+        if !@@cache_control[:self].nil? && 
+           @@cache_control[:self]
+        then 
+          class_copy = self
+        end
+
+        if is_cached(controller, mode, keys) then 
+          return 
+        end
+
+        store = create_store(controller, mode, keys, output)
+        store.transaction do
+          store['klass']      = class_copy unless class_copy.nil?
+          store['controller'] = controller
+          store['mode']       = mode
+          store['keys']       = keys
+          store['output']     = output
+        end
+        
+      else 
+        raise Cache_Write_Exception.new(self.name.to_s, controller, mode, keys)
+      end
+      
+    end
+
+  public
+
+    def create_cache!(controller, mode, keys, output)
+      invalidate(controller, mode, keys)
+      create_cache(controller, mode, keys)
+    end
+
+  public
+    
+    def read_cache(controller, mode, keys)
+      
+      if !@@cache_control[controller.intern].nil? && 
+         @@cache_control[controller.intern] &&
+         is_cached(controller, mode, keys) 
+      then
+      
+        output = ''
+        store = create_store(controller, mode, keys, output)
+        store.transaction do
+          output = store['output']
+        end
+
+        return output
+
+      else 
+        raise Cache_Read_Exception.new(self.name.to_s, controller, mode, keys)
+      end
+
+    end
+    
+    def invalidate(controller, mode, keys)
+      File.unlink(Lore::Cache::store_name(self.name.to_s, controller, mode, keys))
+    end
+    def invalidate_all(controller=:all, mode=:all, keys=:all)
+      cwd = Dir.getwd
+      Dir.chdir('/tmp/')
+      if keys == :all then keys = Hash.new end
+      invalid_cache_pattern = Lore::Cache::store_name(self.name.to_s, controller, mode, keys)
+      @@logger.log('Deleting cache for: '+invalid_cache_pattern)
+      invalid_cache_files = Dir.glob(invalid_cache_pattern)
+      invalid_cache_files.each { |cache_file|
+        @@logger.log('Deleting '+cache_file)
+        File.delete(cache_file)
+      }
+      Dir.chdir(cwd)
+    end
+
+  private
+
+    def create_store(controller, mode, keys, output)
+      store_file = Lore::Cache::store_name(self.to_s, controller, mode, keys)
+      store = PStore.new(store_file) unless store_file.nil?
+      return store
+    end
+
+    def filter_pkeys(model_klass, controller, keys)
+      if !model_klass.respond_to? 'key_array' then
+        @@logger.log('could not filter for pkeys')
+        return keys
+      end
+      result = Hash.new
+      model_klass.key_array.each { |pkey|
+        result[pkey] = keys[pkey]
+      }
+      if !@@distinctive_params[controller].nil? then
+        @@distinctive_params[controller].each { |param|
+          result[param] = keys[param]
+        } 
+      end
+
+      return result
+    end
+
+  end
+
+end # module
+end # module

data/cache/cached_entities.rb

@@ -0,0 +1,116 @@
+
+require('logger')
+
+module Lore
+module Cache
+
+  class Cached_Entities
+
+    @@logger = Lore.logger
+    @@mmap_cache = Hash.new
+    @@file_index = Hash.new
+
+  public
+
+    def self.flush(type)
+      index = type.table_name
+      return if (!Lore.cache_entities() || @@file_index[index].nil?)
+      @@file_index[index].each { |cache_file|
+        @@logger.debug { 'Clearing cache file ' << cache_file }
+        File.unlink(cache_file)
+      }
+      @@file_index.delete(type.table_name)
+    end
+
+    def self.[]=(query_string, result)
+      if $cb__use_pstore_cache then
+        create_pstore_cache(query_string, result) 
+      else
+        create_mmap_cache(query_string, result) 
+      end
+    end
+
+    def self.create(accessor, query_string, result)
+      if $cb__use_pstore_cache then
+        file = create_pstore_cache(query_string, result) 
+      else
+        file = create_mmap_cache(query_string, result) 
+      end
+      @@file_index[accessor.table_name] = Array.new unless @@file_index[accessor.table_name]
+      @@file_index[accessor.table_name] << file
+    end
+
+    def self.[](query_string)
+      if $cb__use_pstore_cache then
+        return read_pstore_cache(query_string)
+      else 
+        return read_mmap_cache(query_string)
+      end
+    end
+
+    def self.include?(query_string)
+      FileTest.exist?(storefile_of(query_string))
+    end
+
+  private
+
+    def self.create_pstore_cache(query_string, result)
+      storefile = storefile_of(query_string)
+      store = create_store(storefile)
+      store.transaction do
+        store['dump'] = result
+      end
+      return storefile
+    end
+
+    def self.read_pstore_cache(query_string)
+      store = create_store(storefile_of(query_string))
+      result = Array.new
+      store.transaction do
+        result = store['dump']
+      end
+      return result
+    end
+
+    def self.create_mmap_cache(query_string, result)
+      storefile = storefile_of(query_string)
+      store = create_store(storefile)
+      store.transaction do
+        store['dump'] = result
+      end
+      @@mmap_cache[index_for(query_string)] = Mmap.new(storefile)
+      return storefile
+    end
+
+    def self.read_mmap_cache(query_string)
+      @@logger.debug { 'Loading from cache: ' << index_for(query_string) }
+      store = @@mmap_cache[index_for(query_string)]
+      @@logger.debug { 'STORE: ' << store.inspect }
+      return [] unless store
+      result = Marshal::load(store)
+      return result['dump']
+    end
+
+    def self.delete_mmap_cache(index)
+      @@mmap_cache[index].munmap
+    end
+
+  private
+
+    def self.index_for(query)
+      Digest::MD5.hexdigest(query)
+    end
+
+    def self.storefile_of(query)
+      '/tmp/cb__cache__entities__' << Digest::MD5.hexdigest(query)
+    end
+
+    def self.create_store(storefile_name)
+      store = PStore.new(storefile_name) unless storefile_name.nil?
+      return store
+    end
+
+  end
+
+end
+end

data/cache/file_index.rb

@@ -0,0 +1,35 @@
+
+require 'lore/model'
+
+Lore.disable_cache
+
+module Lore
+module Cache
+
+  class File_Index < Lore::Model
+    context :lore
+    table :file_index, :public
+    primary_key :file_index_id, :file_index_id_seq
+
+    # Return array of cache file names depending 
+    # from model
+    def self.for(table_name)
+      select { |i|
+        i.where(i.model == table_name)
+      }.collect { |index| 
+        index.file
+      }
+    end
+
+    def self.delete_entry(table_name)
+      delete { |i| 
+        i.where(i.model == table_name)
+      }
+    end
+
+  end
+
+end
+end
+
+Lore.enable_cache

data/cache/mmap_entity_cache.rb

@@ -0,0 +1,67 @@
+
+require 'lore'
+require 'lore/cache/abstract_entity_cache'
+require 'mmap'
+
+module Lore
+module Cache
+
+
+  # Implementation of entity cache using MMapped PStor files. 
+  # Derived from Abstract_Entity_Cache. 
+  # Uses Lore::Cache::Cache_Helpers for generating PStor files. 
+  class Mmap_Entity_Cache < Abstract_Entity_Cache
+  extend Cache_Helpers
+
+    @@logger = Logger.new('/tmp/lore_cache.log')
+
+
+    def self.flush(accessor)
+      index = accessor.table_name
+      return unless Lore.cache_enabled? 
+      Dir.glob("/tmp/lore_cache__#{index}*").each { |cache_file|
+        @@logger.debug('Clearing cache file ' << cache_file)
+        begin
+          File.unlink(cache_file)
+        rescue ::Exception => excep
+          # Another process already killed this file
+        end
+      }
+    end
+
+    def self.read(accessor, query_string)
+      @@logger.debug('Loading from cache: ' << index_for(query_string))
+      store = Mmap.new(storefile_of(accessor.table_name, query_string))
+      @@logger.debug('STORE: ' << store.inspect)
+      return [] unless store
+      result = Marshal::load(store)
+      return result['dump']
+    end
+
+    def self.create(accessor, query_string, result)
+      storefile = create_mmap(accessor, query_string, result)
+    end
+    def self.create_mmap(accessor, query_string, result)
+      storefile = storefile_of(accessor.table_name, query_string)
+      store = create_store(storefile)
+      store.transaction do
+        store['dump'] = result
+      end
+      @@logger.debug('Creating cache entry for ' << storefile )
+      Mmap.new(storefile)
+      return storefile
+    end
+
+    def self.include?(accessor, query_string)
+      FileTest.exist?(storefile_of(accessor.table_name, query_string))
+    end
+
+    def self.delete(index)
+    end
+
+  end
+
+end
+end
+
+