boogaloo 0.1

data/examples/boogaloo.conf

@@ -0,0 +1,17 @@
+# Example Boogaloo configuration.
+
+Server:
+  host: localhost
+  port: 7777
+  worker_threads: 3
+  
+PersistentCaches:
+
+  MainCache:
+    instance_name: main_cache
+
+TemporaryCaches:
+
+  TempCache:
+    instance_name: temp_cache
+    check_frequency: 10

data/lib/boogaloo/cache/base.rb

@@ -0,0 +1,222 @@
+module Boogaloo
+
+    module Cache
+    
+        # Provides fundemental cache operations such as add, set, get and various statistical operations.
+        class Base
+
+            include DRbUndumped
+                    
+            # Initialize a new base cache instance.
+            #
+            # Parameters:
+            # name:	The name of the cache
+            # config: A Hash containing configuration for the cache.    
+            def initialize(name, config)
+            
+                @name = name
+                @config = config
+                reset
+            
+            end
+            
+            # Get an object from the cache.
+            # 
+            # Parameters:
+            # +namespace+:: The namespace to get the object from. Use <tt>nil</tt> if global namespace should be used.
+            # +key+:: A uniqeue identifier for the object relative to the given namespace.
+            def get(namespace, key)
+
+                debug("[#{@name}] GET: #{namespace or 'nil'}, #{key}") if $debug
+
+                if namespace.nil?
+
+                    @global_store.key?(key) ? @hit += 1 : @miss += 1
+                    @global_store[key]
+                            
+                else
+                    
+                    @miss += 1 and return nil if not @namespace_store.key?(namespace)
+                    @namespace_store[namespace].key?(key) ? @hit += 1 : @miss += 1
+                    @namespace_store[namespace][key]                        
+                    
+                end
+
+            end
+            
+            # Pull and object from the cache (get and delete).
+            # 
+            # Parameters:
+            # +namespace+:: The namespace to get the object from. Use <tt>nil</tt> if global namespace should be used.
+            # +key+:: A uniqeue identifier for the object relative to the given namespace.
+            def pull(namespace, key)
+
+                debug("[#{@name}] PULL: #{namespace or 'nil'}, #{key}") if $debug
+            
+                if namespace.nil?
+                
+                    @global_store.key?(key) ? @hit += 1 : @miss += 1
+                    @global_store.delete(key)
+                
+                else
+                
+                    @miss += 1 and return nil if not @namespace_store.key?(namespace)
+                    @namespace_store[namespace].key?(key) ? @hit += 1 : @miss += 1
+                    ret = @namespace_store[namespace].delete(key)
+                    @namespace_store.delete(namespace) if @namespace_store[namespace].size == 0
+                    ret
+                
+                end
+            
+            end
+                   
+            # Add an object to the cache only if it doesn't already exist.
+            # 
+            # Parameters:
+            # +namespace+:: The namespace in which the object will exist. Use <tt>nil</tt> if global namespace should be used.
+            # +key+:: A uniqeue identifier for the object relative to the given namespace.
+            # +obj+:: The object to add to the cache.           
+            def add(namespace, key, obj)
+                
+                return nil_error if obj.nil?
+                debug("[#{@name}] ADD: #{namespace or 'nil'}, #{key}") if $debug
+                
+                if namespace.nil?
+                    
+                    @global_store[key] = obj if not @global_store.key?(key)
+                    
+                else
+                        
+                    create_namespace(namespace)
+                    @namespace_store[namespace][key] = obj if not @namespace_store[namespace].key?(key)
+                        
+                end
+                
+            end
+            
+            # Add an object to the cache, overwriting if one already exists.
+            # 
+            # Parameters:
+            # +namespace+:: The namespace in which the object will exist. Use <tt>nil</tt> if global namespace should be used.
+            # +key+:: A uniqeue identifier for the object relative to the given namespace.
+            # +obj+:: The object to add to the cache.
+            def set(namespace, key, obj)
+                
+                return nil_error if obj.nil?
+                debug("[#{@name}] SET: #{namespace or 'nil'}, #{key}") if $debug
+                
+                if namespace.nil?
+
+                    @global_store[key] = obj                
+                
+                else
+                    
+                    create_namespace(namespace)
+                    @namespace_store[namespace][key] = obj
+                    
+                end
+                
+            end
+
+            # Returns all available statistics in an Array.
+            # 
+            # Array elements:
+            # 
+            # <tt>0</tt>:: stat_reset_at
+            # <tt>1</tt>:: stat_hits
+            # <tt>2</tt>:: stat_misses
+            # <tt>3</tt>:: stat_namespaces
+            # <tt>4</tt>:: stat_objects
+            def stat_all
+                
+                return [stat_reset_at, stat_hits, stat_misses, stat_namespaces, stat_objects]
+                
+            end
+            
+            # The time the cache was created or last reset.
+            def stat_reset_at
+            
+                @reset_at
+            
+            end
+            
+            # The number of successful cache gets.
+            def stat_hits
+            
+                @hit
+            
+            end
+            
+            # The number of unsuccessful cache gets.
+            def stat_misses
+            
+                @miss
+            
+            end
+            
+            # The number of namespaces (plus the global namespace).
+            def stat_namespaces
+            
+                @namespace_store.size + 1
+            
+            end
+            
+            # The number of objects stored in the cache.
+            def stat_objects
+            
+                get_obj_count
+            
+            end
+            
+            # Returns an Array of all object keys currently contained in the cache.
+            # 
+            # Array elements:
+            # 
+            # <tt>0</tt>:: Keys in global scope (Array).
+            # <tt>1</tt>:: Namespaces and their respective keys (Hash).
+            def inspect_keys
+                
+                tmp = {}
+                @namespace_store.keys.each { |key| tmp[key] = @namespace_store[key].keys }
+                [@global_store.keys, tmp]
+                
+            end
+            
+            # Reset the cache to an empty state.     
+            def reset
+                
+                @hit = 0
+                @miss = 0
+                @global_store = {}
+                @namespace_store = {}
+                @reset_at = Time.now                
+                
+            end
+            
+            protected
+                
+            def get_obj_count #:nodoc:
+            
+                i = 0
+                @namespace_store.each { |key, value| i += value.size}
+                i + @global_store.size
+            
+            end
+                
+            def create_namespace(namespace) #:nodoc:
+                
+                @namespace_store[namespace] = {} if not @namespace_store.key?(namespace)
+                
+            end
+            
+            def nil_error #:nodoc:
+            
+                return TypeError.new("nil objects cannot be stored in the cache.")
+            
+            end
+            
+        end
+        
+    end
+    
+end

data/lib/boogaloo/cache/persistent.rb

@@ -0,0 +1,15 @@
+require 'boogaloo/cache/base'
+
+module Boogaloo
+
+    module Cache
+    
+        # A persistent cache in which objects persist for the lifetime of the server.
+        # 
+        # See Boogaloo::Cache::Base[link:classes/Boogaloo/Cache/Base.html] for common cache methods.
+        class Persistent < Boogaloo::Cache::Base       
+        end
+    
+    end
+
+end

data/lib/boogaloo/cache/temporary.rb

@@ -0,0 +1,173 @@
+module Boogaloo
+
+    module Cache
+    
+        # A temporary cache in which objects can expire and are subsequently deleted when they do.
+        # The frequency at which the cache is checked for objects to delete is determined by the <tt>check_frequency</tt> parameter.
+        # 
+        # See Boogaloo::Cache::Base[link:classes/Boogaloo/Cache/Base.html] for common cache methods.
+        class Temporary < Boogaloo::Cache::Base
+        
+            # Initialize a new temporary cache instance.
+            # 
+            # Parameters:
+            # +name+:: The name of the cache
+            # +config+:: A Hash containing configuration for the cache.
+            # Configuration options:
+            # +check_frequency+:: The frequency in seconds at which the cache will check for objects to delete.
+            def initialize(name, config)
+            
+                super
+                
+                Thread.new {
+                    
+                    while true
+                    
+                        sleep @config['check_frequency'].to_f
+
+                        @global_store.keys.each do |key|
+                        
+                            times_key = "#{key}_#{@global_store[key].object_id}"
+
+                            if @times[times_key][:time] <= Time.now
+
+                                @global_store.delete(key)
+                                @times.delete(key)
+                            
+                            end
+                        
+                        end
+
+                        @namespace_store.keys.each do |nskey|
+                          
+                            @namespace_store[nskey].keys.each do |key|
+
+                                times_key = "#{nskey}_#{key}_#{@namespace_store[nskey][key].object_id}"
+
+                                if @times[times_key][:time] <= Time.now
+                                
+                                    @namespace_store[nskey].delete(key)
+                                    @times.delete(times_key)
+                                
+                                end
+                            
+                            end
+                        
+                        end
+                    
+                    end
+                
+                }                
+            
+            end
+        
+            # Add an object to the cache only if it doesn't already exist.
+            # 
+            # Parameters:
+            # +namespace+:: The namespace in which the object will exist. Use <tt>nil</tt> if global namespace is desired.
+            # +key+:: A uniqeue identifier for the object relative to the given namespace.
+            # +obj+:: The object to add to the cache.
+            # +expires+:: The time in seconds which the object should exist in the cache without being touched before it is deleted.
+            def add(namespace, key, obj, expires)
+
+                check_expires(expires)
+                super(namespace, key, obj)
+                set_expiration(namespace, key, obj, expires)
+                               
+            end
+            
+            # Add an object to the cache, overwriting if one already exists.
+            # 
+            # Parameters:
+            # +namespace+:: The namespace in which the object will exist. Use <tt>nil</tt> if global namespace should be used.
+            # +key+:: A uniqeue identifier for the object relative to the given namespace.
+            # +obj+:: The object to add to the cache.
+            # +expires+:: The time in seconds which the object should exist in the cache without being touched before it is deleted.
+            def set(namespace, key, obj, expires)
+
+                check_expires(expires)
+                super(namespace, key, obj)
+                set_expiration(namespace, key, obj, expires)
+
+            end
+            
+            # Get an object from the cache.
+            # 
+            # Parameters:
+            # +namespace+:: The namespace to get the object from. Use <tt>nil</tt> if global namespace should be used.
+            # +key+:: A uniqeue identifier for the object relative to the given namespace.
+            def get(namespace, key)
+            
+                ret = super            
+                reset_expiration(namespace, key, ret) if not ret.nil?
+                ret
+            
+            end
+            
+            # Pull and object from the cache (get and delete).
+            # 
+            # Parameters:
+            # +namespace+:: The namespace to get the object from. Use <tt>nil</tt> if global namespace should be used.
+            # +key+:: A uniqeue identifier for the object relative to the given namespace.
+            def pull(namespace, key)
+            
+                ret = super
+                @times.delete(format_times_key(namespace, key, ret)) if not ret.nil?
+                ret
+            
+            end
+            
+            def __times_size #:nodoc: Only used by unit test.
+            
+                @times.size
+            
+            end
+            
+            def reset
+            
+                @times = {}
+                super
+            
+            end
+
+            protected
+            
+            def check_expires(expires) #:nodoc:
+            
+                raise TypeError.new("Expected Fixnum or Float as expiration.") if not expires.is_a?(Fixnum) and not expires.is_a?(Float)
+            
+            end
+            
+            def set_expiration(namespace, key, obj, expires) #:nodoc:
+                
+                warning("Expiration time (#{expires}) less than check frequency (#{@config['check_frequency'].to_f}) for key '#{key}'#{" in namespace '#{namespace}'" if namespace}.") if expires.to_f < @config['check_frequency'].to_f
+                @times[format_times_key(namespace, key, obj)] = { :time => Time.now + expires, :duration => expires }
+            
+            end
+            
+            def reset_expiration(namespace, key, obj) #:nodoc:
+            
+                times_key = format_times_key(namespace, key, obj)
+                @times[times_key][:time] = Time.now + @times[times_key][:duration]
+            
+            end
+            
+            def format_times_key(namespace, key, obj) #:nodoc:
+
+                if namespace.nil?
+                
+                    times_key = "#{key}_#{obj.object_id}"
+                
+                else
+                
+                    times_key = "#{namespace}_#{key}_#{obj.object_id}"
+                
+                end
+               
+            end
+                                    
+        end
+        
+    end
+    
+end

data/lib/boogaloo/client/connection.rb

@@ -0,0 +1,55 @@
+module Boogaloo
+
+    module Client
+    
+        # A wrapper around DRb for connecting to the boogaloo server.
+        # 
+        # Example usage:
+        # 
+        #   boogaloo_cache = Boogaloo::Client::Connection.new('localhost', 7777, true)
+        class Connection
+        
+            # Create a new connection to the boogaloo server.
+            # 
+            # Parameters:
+            # 
+            # +host+:: The host name or IP address to bind the socket to.
+            # +port+:: The port to bind the socket to.
+            # +wrap+:: If true, attempts to access the server when it is offline will result in a _nil_ being returned instead of an exception being raised.
+            def initialize(host, port, wrap=false)
+            
+                @wrap = wrap
+                druby_str = "druby://#{host}:#{port}"
+                DRb.start_service
+                @conn = DRbObject.new(nil, druby_str)
+                
+            end
+            
+            # Forwards all method calls to the server.
+            def method_missing(msg_id, *a, &b)
+                        
+                if @wrap
+                
+                    begin
+                    
+                        return @conn.method_missing(msg_id, a, b)
+                    
+                    rescue DRb::DRbConnError
+                    
+                        return nil
+                    
+                    end
+                
+                else
+                
+                    return @conn.method_missing(msg_id, a, b)
+                    
+                end
+            
+            end
+        
+        end
+    
+    end
+
+end