cloud-toaster 1.1.2

data/lib/toaster/db/cache.rb

@@ -0,0 +1,98 @@
+
+
+#
+# Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+#
+
+module Toaster
+  class Cache
+
+    KEY_OBJECTS = "__objects__"
+    KEY_QUERIES = "__queries__"
+
+    @@active_cache = nil
+
+    def by_db_type(db_type)
+      # should be overwritten by subclasses
+    end
+
+    def by_id(id)
+      # should be overwritten by subclasses
+    end
+
+    def by_key(key)
+      load_cache()
+    end
+
+    def set(value, key=KEY_OBJECTS)
+      # should be overwritten by subclasses
+    end
+
+    def by_obj_props(props_hash)
+      # should be overwritten by subclasses
+    end
+
+    def clear()
+      # should be overwritten by subclasses
+    end
+
+    def flush()
+      # should be overwritten by subclasses
+    end
+
+    def get_hits()
+      # should be overwritten by subclasses
+    end
+
+    def get_misses()
+      # should be overwritten by subclasses
+    end
+
+
+
+    def self.by_obj_props(props_hash)
+      return @@active_cache.by_obj_props(props_hash) if @@active_cache
+    end
+
+    def self.by_db_type(db_type)
+      return @@active_cache.by_db_type(db_type) if @@active_cache
+    end
+
+    def self.by_id(id)
+      return @@active_cache.by_id(id) if @@active_cache
+    end
+
+    def self.by_key(key)
+      return @@active_cache.by_key(key) if @@active_cache
+    end
+
+    def self.set(value, key=KEY_OBJECTS)
+      return @@active_cache.set(value, key) if @@active_cache
+    end
+
+    def self.set_cache(cache)
+      @@active_cache = cache
+    end
+
+    def self.get_cache()
+      @@active_cache
+    end
+
+    def self.get_hits()
+      return @@active_cache.get_hits() if @@active_cache
+    end
+
+    def self.get_misses()
+      return @@active_cache.get_misses() if @@active_cache
+    end
+
+    def self.clear()
+      @@active_cache.clear() if @@active_cache
+    end
+
+    def self.flush()
+      @@active_cache.flush() if @@active_cache
+    end
+
+  end
+end

data/lib/toaster/db/cached_db.rb

@@ -0,0 +1,53 @@
+
+
+#
+# Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+#
+
+require "toaster/db/cache"
+
+module Toaster
+  class CachedDB
+
+    def initialize(actual_db, config={})
+      @db = actual_db
+      @cache_result_lists = config["cache_result_lists"]
+    end
+
+    def find(criteria = {})
+      if !@cache_result_lists
+        return @db.find(criteria)
+      end
+
+      cached = Cache.by_obj_props(criteria)
+      if cached
+        #puts "DEBUG: Found cached object for criteria: #{criteria}"
+        @db.fix_db_object(cached)
+        return cached
+      end
+
+      obj = @db.find(criteria)
+      Cache.set(obj)
+      Cache.set(obj, [Cache::KEY_QUERIES, criteria.inspect])
+      return obj
+    end
+    def find_one(criteria)
+      cached = Cache.by_obj_props(criteria)
+      if cached
+        cached = [cached] if !cached.kind_of?(Array)
+        @db.fix_db_object(cached)
+        return cached[0] if cached.size == 1
+      end
+
+      obj = @db.find_one(criteria)
+      Cache.set(obj)
+      Cache.set(obj, [Cache::KEY_QUERIES, criteria.inspect])
+      return obj
+    end
+
+    def method_missing(meth, *args, &block)
+      @db.send(meth, *args, &block)
+    end
+
+  end
+end

data/lib/toaster/db/cgi_session_cache.rb

@@ -0,0 +1,209 @@
+
+
+#
+# Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+#
+
+require "toaster/db/cache"
+require "toaster/markup/markup_util"
+
+module Toaster
+  class CGISessionCache < Cache
+
+    KEY_CACHE = "__cache__"
+    KEY_CACHE_SIZE = "__cachesize__"
+    KEY_QUERY_KEYS = "__keys__"
+
+    DO_CACHE_OBJECTS = false
+    DO_CACHE_QUERIES = true
+
+    def initialize(cgi_session)
+      @session = cgi_session
+      @cache = nil
+      @hits = []
+      @misses = []
+      @dirty = false
+    end
+
+    def by_db_type(db_type)
+      load_cache()
+
+      return by_obj_prop("db_type", db_type)
+    end
+
+    def by_id(id)
+      load_cache()
+
+      return by_obj_props({"id" => id})
+    end
+
+    def by_obj_props(props_hash)
+      load_cache()
+
+      if DO_CACHE_QUERIES
+        props_str = props_hash.inspect
+        cached = @cache[KEY_QUERIES][props_str]
+        if cached
+          @hits << props_hash
+          return cached
+        end
+      end
+
+      if DO_CACHE_OBJECTS
+        @cache[KEY_OBJECTS] = [] if !@cache[KEY_OBJECTS]
+        puts "size: #{@cache[KEY_OBJECTS].size}"
+        objs = @cache[KEY_OBJECTS]
+        result = []
+        objs.each do |o|
+          arr = o.kind_of?(Array) ? o : [o]
+          all_match = true
+          arr.each do |item|
+            if !item || !matches(item, props_hash)
+              all_match = false
+              break
+            end
+          end
+          result << o if all_match
+        end
+        if result.size == 0
+          @misses << props_hash
+          return nil 
+        end
+        @hits << props_hash
+        return result
+      end
+
+      @misses << props_hash
+      return nil
+    end
+
+    def by_key(key_path_array)
+      load_cache()
+
+      if DO_CACHE_QUERIES
+        key_path_str = key_path_array.inspect
+        cached = @cache[KEY_QUERIES][key_path_str]
+        if cached
+          @hits << key_path_array
+          return cached
+        end
+      end
+
+      if DO_CACHE_OBJECTS
+        key_path_array = [key_path_array] if !key_path_array.kind_of?(Array)
+        obj = @cache
+        key_path_array.each do |k|
+          obj = obj[k]
+          if !obj
+            @misses << key_path_array
+            return nil
+          end
+        end
+        @hits << key_path_array
+        #@cache[KEY_QUERIES][key_path_str] = obj
+        return obj
+      end
+
+      @misses << key_path_array
+      return nil
+    end
+
+    def set(value, key=KEY_OBJECTS)
+      load_cache()
+
+      if key.kind_of?(Array) && key[0] == KEY_QUERIES
+        #puts "setting cache value: #{value}"
+        @cache[KEY_QUERIES][key[1]] = value
+        @dirty = true
+        return
+      end
+
+      if DO_CACHE_OBJECTS
+        i = next_index(key)
+        obj_key = "#{KEY_CACHE}.#{key}.#{i}"
+        #key = "#{KEY_CACHE}.#{key}"
+        #puts "setting '#{obj_key}'"
+        value = value[0] if value.kind_of?(Array) && value.size == 1
+        @session[obj_key] = value
+
+        @cache[key] = [] if !@cache[key]
+        value = [value] if !value.kind_of?(Array)
+        @cache[key].concat(value)
+        #@cache[key] = @cache[key][0] if @cache[key].size == 1
+        @dirty = true
+      end
+
+    end
+
+    def clear()
+      @cache = nil
+      @session[KEY_CACHE] = "{}"
+      begin
+        @session.update()
+      rescue
+        # fix for ruby on rails
+      end
+      load_cache()
+    end
+
+    def get_hits()
+      @hits
+    end
+
+    def get_misses()
+      @misses
+    end
+
+    def flush()
+      return if !@dirty
+      @session[KEY_CACHE] = MarkupUtil.to_json(@cache)
+      @session.update()
+    end
+
+    private
+
+    def load_cache()
+      return @cache if @cache
+
+      begin
+        @cache = @session[KEY_CACHE] ? MarkupUtil.parse_json(@session[KEY_CACHE]) : {}
+      rescue => ex
+        puts "Unable to parse session cache JSON: #{ex}"
+        @session[KEY_CACHE] = "{}"
+        @cache = @session[KEY_CACHE] ? MarkupUtil.parse_json(@session[KEY_CACHE]) : {}
+      end
+
+      @cache = {} if !@cache
+      @cache[KEY_QUERIES] = {} if !@cache[KEY_QUERIES]
+      @cache[KEY_OBJECTS] = [] if !@cache[KEY_OBJECTS]
+
+    end
+
+    def next_index(key=KEY_OBJECTS)
+      key = "#{KEY_CACHE_SIZE}.#{key}"
+      @session[key] = "0" if !@session[key]
+      i = @session[key].to_i + 1
+      @session[key] = i.to_s
+      return i - 1 # subtract 1 from cache size for 0-based cache index
+    end
+
+    def by_obj_prop(prop, value)
+      return by_obj_props({prop => value})
+    end
+
+    def matches(obj, props)
+      props.each do |prop,value|
+        if !obj.kind_of?(Hash)
+          puts "WARN: Expected object of type Hash but got object of type #{obj.class}"
+          #puts "#{obj} "
+        end
+        value1 = obj[prop]
+        if value1 != value
+          return false
+        end
+      end
+      return true
+    end
+
+  end
+end

data/lib/toaster/db/db.rb

@@ -0,0 +1,98 @@
+
+
+#
+# Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+#
+
+require "toaster/db/cached_db"
+require "toaster/util/util"
+
+module Toaster
+
+  # TODO deprecated, remove?
+
+  class DB
+
+    class << self;
+      attr_accessor :DEFAULT_HOST, :DEFAULT_PORT, :DEFAULT_DB, :DEFAULT_COLL, 
+        :IMPL_CLASSES, :USE_CACHE, :DEFAULT_REQUIRE, :DEFAULT_TYPE, :REQUIRE_PATH
+    end
+    @DEFAULT_HOST = "localhost"
+    @DEFAULT_PORT = 27017
+    @DEFAULT_DB = "toaster"
+    @DEFAULT_TYPE = "mysql"
+
+    @REQUIRE_PATH = "toaster/db/"
+    @IMPL_CLASSES = { 
+      "mongodb" => "Toaster::MongoDB",
+      "mysql" => "Toaster::MysqlDB"
+    }
+    @USE_CACHE = false
+
+    @@instance = nil
+
+    def self.instance(host = nil, port = nil, db = nil, collection = nil, type = nil)
+      host = self.DEFAULT_HOST if Util.empty?(host)
+      port = self.DEFAULT_PORT if Util.empty?(port)
+      db = self.DEFAULT_DB if Util.empty?(db)
+      collection = self.DEFAULT_COLL if Util.empty?(collection)
+      type = self.DEFAULT_TYPE if Util.empty?(type)
+
+      @@instances ||= {}
+      key = get_key(type, host, port, db, collection)
+      return @@instances[key] if @@instances[key]
+
+      #puts "Using DB connection #{host}:#{port}, db '#{db}', collection '#{collection}'"
+
+      init_instance(type, host, port, db, collection)
+    end
+
+    def self.find_activerecord(clazz, criteria)
+      if criteria.kind_of?(String)
+        criteria = criteria.to_i
+      end
+      if numeric?(criteria)
+        return clazz.find_by(:id => criteria)
+      elsif !criteria || criteria.empty?
+        return clazz.all
+      else
+        return clazz.where(criteria)
+      end
+    end
+
+    attr_accessor :db_host, :db_port, :db_name, :db_collection
+
+    private
+
+    def self.numeric?(str)
+      return true if str =~ /^\d+$/
+      true if Float(str) rescue false
+    end
+
+    def self.init_instance(type, host, port, db, collection)
+      # setup default instance
+
+      key = get_key(type, host, port, db, collection)
+
+      clazz = DB.IMPL_CLASSES[type]
+
+      #puts "#{host} - #{port} - #{db} - #{collection} - #{type}"
+
+      require "#{DB.REQUIRE_PATH}/#{type}"
+
+      @@instances[key] = eval(clazz).new(host, port)
+      @@instances[key].db_name = db
+      @@instances[key].db_collection = collection
+      if DB.USE_CACHE
+        cache_config = DB.USE_CACHE
+        @@instances[key] = CachedDB.new(@@instances[key], cache_config)
+      end
+      return @@instances[key]
+    end
+
+    def self.get_key(type, host, port, db, collection)
+      return "#{host}:#{port} - #{db}:#{collection} - cached:#{DB.USE_CACHE}"
+    end
+
+  end
+end

data/lib/toaster/db/mysql.rb

@@ -0,0 +1,18 @@
+
+
+#
+# Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+#
+
+module Toaster
+  class MysqlDB < Toaster::DB
+    
+    # empty class. DB access handled by active_record gem
+
+    def initialize(host = nil, port = nil, db = nil)
+      db_host = host
+      db_port = port
+    end
+
+  end
+end

data/lib/toaster/db/ram_cache.rb

@@ -0,0 +1,203 @@
+
+
+#
+# Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+#
+
+require "toaster/db/cache"
+require "toaster/markup/markup_util"
+
+module Toaster
+  class RAMCache < Cache
+
+    KEY_CACHE = "__cache__"
+    KEY_CACHE_SIZE = "__cachesize__"
+    KEY_QUERY_KEYS = "__keys__"
+
+    DO_CACHE_OBJECTS = false
+    DO_CACHE_QUERIES = true
+
+    def initialize()
+      @cache = nil
+      @hits = nil
+      @misses = nil
+      @dirty = false
+    end
+
+    def by_db_type(db_type)
+      load_cache()
+
+      return by_obj_prop("db_type", db_type)
+    end
+
+    def by_id(id)
+      load_cache()
+
+      return by_obj_props({"id" => id})
+    end
+
+    def by_obj_props(props_hash)
+      load_cache()
+
+      if DO_CACHE_QUERIES
+        props_str = props_hash.inspect
+        cached = @cache[KEY_QUERIES][props_str]
+        if cached
+          @hits << props_hash if @hits
+          return cached
+        end
+      end
+
+      if DO_CACHE_OBJECTS
+        @cache[KEY_OBJECTS] = [] if !@cache[KEY_OBJECTS]
+        puts "size: #{@cache[KEY_OBJECTS].size}"
+        objs = @cache[KEY_OBJECTS]
+        result = []
+        objs.each do |o|
+          arr = o.kind_of?(Array) ? o : [o]
+          all_match = true
+          arr.each do |item|
+            if !item || !matches(item, props_hash)
+              all_match = false
+              break
+            end
+          end
+          result << o if all_match
+        end
+        if result.size == 0
+          @misses << props_hash if @misses
+          return nil 
+        end
+        @hits << props_hash if @hits
+        return result
+      end
+
+      props_str = props_hash.inspect
+      cached = @cache[KEY_CACHE][props_str]
+      if cached
+        #puts "DEBUG: Found cached object for key '#{props_str}'"
+        @hits << props_hash if @hits
+        return cached
+      end
+
+      @misses << props_hash if @misses
+      return nil
+    end
+
+    def by_key(key_path_array)
+      load_cache()
+
+      if DO_CACHE_QUERIES
+        key_path_str = key_path_array.inspect
+        cached = @cache[KEY_QUERIES][key_path_str]
+        if cached
+          @hits << key_path_array if @hits
+          return cached
+        end
+      end
+
+      if DO_CACHE_OBJECTS
+        key_path_array = [key_path_array] if !key_path_array.kind_of?(Array)
+        obj = @cache
+        key_path_array.each do |k|
+          obj = obj[k]
+          if !obj
+            @misses << key_path_array if @misses
+            return nil
+          end
+        end
+        @hits << key_path_array if @hits
+        #@cache[KEY_QUERIES][key_path_str] = obj
+        return obj
+      end
+
+      @misses << key_path_array if @misses
+      return nil
+    end
+
+    def set(value, key=KEY_OBJECTS)
+      load_cache()
+
+      if key.kind_of?(Array) && key[0] == KEY_QUERIES
+        #puts "setting cache value: #{value}"
+        @cache[KEY_QUERIES][key[1]] = value
+        @dirty = true
+        return
+      end
+
+      if DO_CACHE_OBJECTS && key == KEY_OBJECTS
+
+        value = value[0] if value.kind_of?(Array) && value.size == 1
+
+        @cache[key] = [] if !@cache[key]
+        value = [value] if !value.kind_of?(Array)
+        @cache[key].concat(value)
+        #@cache[key] = @cache[key][0] if @cache[key].size == 1
+        @dirty = true
+
+        return
+      end
+
+      if key != KEY_OBJECTS
+        key = key.inspect if !key.kind_of?(String)
+        @cache[KEY_CACHE][key] = value
+        @dirty = true
+        return
+      end
+
+    end
+
+    def clear()
+      @cache = nil
+      @hits = nil
+      @misses = nil
+      load_cache()
+    end
+
+    def get_hits()
+      @hits = [] if !@hits
+      @hits
+    end
+
+    def get_misses()
+      @misses = [] if !@misses
+      @misses
+    end
+
+    def flush()
+      return if !@dirty
+      @cache = {}
+    end
+
+    private
+
+    def load_cache()
+      return @cache if @cache
+      @cache = {}
+
+      @cache[KEY_QUERIES] = {} if !@cache[KEY_QUERIES]
+      @cache[KEY_OBJECTS] = [] if !@cache[KEY_OBJECTS]
+      @cache[KEY_CACHE] = {} if !@cache[KEY_CACHE]
+
+    end
+
+    def by_obj_prop(prop, value)
+      return by_obj_props({prop => value})
+    end
+
+    def matches(obj, props)
+      props.each do |prop,value|
+        if !obj.kind_of?(Hash)
+          puts "WARN: Expected object of type Hash but got object of type #{obj.class}"
+          #puts "#{obj} "
+        end
+        value1 = obj[prop]
+        if value1 != value
+          return false
+        end
+      end
+      return true
+    end
+
+  end
+end