boogaloo 0.1

data/lib/boogaloo/config.rb

@@ -0,0 +1,206 @@
+require 'yaml'
+require 'boogaloo/util'
+
+module Boogaloo
+
+    # See examples/boogalooo.conf[link:files/examples/boogaloo_conf.html] for an example configuration file.
+    # 
+    # = Available Configuration Options
+    # 
+    # == Section: Server
+    # 
+    # +host+:: (required) The host name or IP address to bind the socket to.
+    # +port+:: (required) The port to bind the socket to.
+    # +worker_threads+:: (required) Boogaloo uses a pool of threads created at start-up that wait for requests to handle. 3 is a reasonable default.
+    # +debug+:: (optional) Enable/disable debugging. See DEBUGGING[link:files/DEBUGGING.html] for for information.
+    # 
+    # == Section: PersistentCaches
+    # 
+    # +instance_name+:: (required) The name to use for accessing the cache on the client.
+    # 
+    # Example:
+    # 
+    #   PersistentCaches:
+    #   
+    #     MyPersistentCache:
+    #       instance_name: main_cache
+    # 
+    # == Section: TemporaryCaches
+    # 
+    # +instance_name+:: (required) The name to use for accessing the cache on the client.
+    # +check_frequency+:: (required) The frequency in seconds at which the cache will check for expired objects to delete.
+    # 
+    # Example:
+    #   
+    #   TemporaryCaches:
+    #   
+    #     MyTempCache:
+    #       instance_name: temp_cache
+    #       check_frequency: 10
+    # 
+    # == Section: Services
+    # 
+    # +instance_name+:: (required) The name to use for accessing the service on the client.
+    # +path+:: (required) The path to the directory containing your interface.rb file.
+    # +parameters+:: (optional) If your interface constructor accepts parameters you can specify them hear.
+    # +require_path+:: (optional) If your service needs to require files not in the standard $LOAD_PATH, you can specify directories to add to the $LOAD_PATH here either as a list or in singular form.
+    # 
+    # Example:
+    # 
+    #   Services:
+    #   
+    #     MyService:
+    #       instance_name: my_service
+    #       path: /home/me/BoogalooServices/MyService
+    #       parameters:
+    #         - Hello
+    #         - World
+    #       require_path:
+    #         - /some/dir
+    #         - /some/other/dir
+    #         
+    class Config
+    
+        # Initialize a new cofig instance.
+        # 
+        # Parameters:
+        # 
+        # +file+:: The configuration file to read.
+        def initialize(file)
+        
+            @config = YAML.load File.read(file)
+            error("Server configuration not found.") if not @config.key?('Server')
+            error("host attribute missing for Server configuration.") if not @config['Server'].key?('host')
+            error("port attribute missing for Server configuration.") if not @config['Server'].key?('port')
+            error("worker_threads attribute missing for Server configuration.") if not @config['Server'].key?('worker_threads')            
+            
+            @persistent_caches = {}
+            @temporary_caches = {}
+            @services = {}
+            
+            if @config['PersistentCaches']
+            
+                @config['PersistentCaches'].each do |name, config|
+    
+                    error "name attribute missing for persistent cache." if not name or not name.is_a?(String)
+                    error "configration missing for persistent cache '#{name}'." if not config.is_a?(Hash)
+                    error "instance_name attribute missing for persistent cache '#{name}'." if not config.key?('instance_name') 
+    
+                    conflict = nil
+                    @persistent_caches.each { |key, value| conflict = key and break if value['instance_name'].eql?(config['instance_name'])}
+                    error "instance name '#{config['instance_name']}' for '#{name}' conflicts with persistent cache '#{conflict}'." if conflict
+                
+                    @persistent_caches[name] = config
+                
+                end
+
+            end
+                     
+            if @config['TemporaryCaches']
+            
+                @config['TemporaryCaches'].each do |name, config|
+                
+                    error "name attribute missing for temporary cache." if not name or not name.is_a?(String)
+                    error "configration missing for temporary cache '#{name}'." if not config.is_a?(Hash)
+                    error "instance_name attribute missing for temporary cache '#{name}'." if not config.key?('instance_name') 
+                    error "check_frequency attribute missing for temporary cache '#{name}'." if not config.key?('check_frequency') 
+
+                    conflict = nil
+                    @temporary_caches.each { |key, value| conflict = key and break if value['instance_name'].eql?(config['instance_name'])}
+                    error "instance name '#{config['instance_name']}' for '#{name}' conflicts with temporary cache '#{conflict}'." if conflict
+
+                    @persistent_caches.each { |key, value| conflict = key and break if value['instance_name'].eql?(config['instance_name'])}
+                    error "instance name '#{config['instance_name']}' for '#{name}' conflicts with persistent cache '#{conflict}'." if conflict                
+
+                    @temporary_caches[name] = config
+                
+                end
+            
+            end
+            
+            if @config['Services']
+            
+                @config['Services'].each do |name, config|
+                
+                    error "name attribute missing for service." if not name or not name.is_a?(String)
+                    error "configration missing for service cache '#{name}'." if not config.is_a?(Hash)
+                    error "path attribute missing for service '#{name}'." if not config.key?('path') 
+                    error "instance_name attribute missing for service '#{name}'." if not config.key?('instance_name') 
+                
+                    conflict = nil
+                    @services.each { |key, value| conflict = key and break if value['instance_name'].eql?(config['instance_name'])}
+                    error "instance name '#{config['instance_name']}' for '#{name}' conflicts with service '#{conflict}'." if conflict
+
+                    @temporary_caches.each { |key, value| conflict = key and break if value['instance_name'].eql?(config['instance_name'])}
+                    error "instance name '#{config['instance_name']}' for '#{name}' conflicts with temporary cache '#{conflict}'." if conflict
+
+                    @persistent_caches.each { |key, value| conflict = key and break if value['instance_name'].eql?(config['instance_name'])}
+                    error "instance name '#{config['instance_name']}' for '#{name}' conflicts with persistent cache '#{conflict}'." if conflict                
+
+                    @services[name] = config
+                
+                end
+            
+            end
+            
+            if @config['Server']['debug'] == true
+            
+                $debug = true
+                notice("Debugging enabled")
+            
+            end
+         
+        end
+        
+        # The entire _Server_ configuration section.
+        def server
+        
+            @config['Server']
+        
+        end
+        
+        # The server host.
+        def server_host
+        
+            server['host']
+        
+        end
+        
+        # The server port.
+        def server_port
+        
+            server['port']
+        
+        end
+        
+        # The number of worker threads.
+        def server_worker_threads
+        
+            server['worker_threads']
+        
+        end
+        
+        # The entire _PersistentCaches_ configuration section.
+        def persistent_caches
+            
+            @persistent_caches
+        
+        end
+
+        # The entire _TemporaryCaches_ configuration section.        
+        def temporary_caches
+        
+            @temporary_caches
+        
+        end
+        
+        # The entire _Services_ configuration section.
+        def services
+        
+            @services
+        
+        end
+    
+    end
+
+end

data/lib/boogaloo/service_gateway.rb

@@ -0,0 +1,37 @@
+require 'boogaloo/thread_pool'
+require 'boogaloo/worker_thread'
+require 'boogaloo/service_request'
+
+module Boogaloo
+           
+    class ServiceGateway
+    
+        # Initialize a new service gateway.
+        # 
+        # Parameters:
+        # 
+        # +pool+:: A reference to a ThreadPool
+        # +services+:: A Hash of instance_name/instance pairs.
+        def initialize(pool, services)        
+            
+            services.each do |name, instance|
+
+                instance_variable_set("@"+name, instance)
+                    
+                self.class.instance_eval do
+    
+                    define_method(name) do
+                        
+                        Boogaloo::ServiceRequest.new(instance_variable_get("@"+name), pool)
+                  
+                    end
+                              
+                end
+            
+            end
+              
+        end
+       
+    end
+   
+end

data/lib/boogaloo/service_request.rb

@@ -0,0 +1,39 @@
+require 'boogaloo/util'
+
+module Boogaloo
+
+    # Handles server requests using threads from the thread pool.
+    class ServiceRequest
+    
+        # Initialize a new ServiceRequest instance.
+        # 
+        # Parameters:
+        # 
+        # +obj+:: The service instance for which to handle the request.
+        # +pool+:: A reference to the thread pool.
+        def initialize(obj, pool)
+        
+            @obj = obj
+            @pool = pool
+        
+        end
+        
+        # Forward method calls to the service instance via a WorkerThread.
+        def method_missing(meth, *a, &b)
+        
+            (t_start = Time.now) if $debug
+            worker = @pool.pop
+            debug("Waited #{"%.5f" % (Time.now - t_start)} seconds for available WorkerThread") if $debug and not t_start.nil?
+            worker.use_instance(@obj)
+            ret = worker.perform(meth, *a)
+            @pool.push worker
+            
+            raise ret if (ret.is_a?(NoMethodError) or ret.is_a?(TypeError))
+            
+            ret
+        
+        end
+    
+    end
+
+end

data/lib/boogaloo/thread_pool.rb

@@ -0,0 +1,40 @@
+module Boogaloo
+
+    class ThreadPool < Queue
+        
+        # Initailize a new thread pool.
+        # 
+        # Parameters:
+        # 
+        # +threads+:: The number of threads to populate the pool with.
+        def initialize(threads)
+        
+            super()
+        
+            @threads = threads
+        
+            for i in 1..@threads
+
+                push(Boogaloo::WorkerThread.new)
+    
+            end
+        
+        end
+    
+        # Shutdown the pool.
+        def shutdown
+               
+            for i in 1..@threads
+            
+                worker = pop
+                worker.exit
+                
+            end
+            
+            size == 0 ? true : false
+        
+        end
+    
+    end
+    
+end

data/lib/boogaloo/util.rb

@@ -0,0 +1,29 @@
+APP_NAME = 'Boogaloo'
+
+# Output an error message to stderr and perform an immediate ungraceful server shutdown.
+def error(msg)
+
+    $stderr.puts "[#{APP_NAME}] ERROR: #{msg}"
+    exit 1
+    
+end
+
+# Output an information message.
+def notice(msg)
+
+    puts "[#{APP_NAME}] #{msg}"
+
+end
+
+# Output a warning message to stderr.
+def warning(msg)
+
+    $stderr.puts "[#{APP_NAME}] WARNING: #{msg}"
+
+end
+
+def debug(msg)
+
+    puts "[#{APP_NAME}] DEBUG: #{msg}"
+
+end

data/lib/boogaloo/version.rb

@@ -0,0 +1 @@
+PKG_VERSION = "0.1"

data/lib/boogaloo/worker_thread.rb

@@ -0,0 +1,46 @@
+module Boogaloo
+
+    # Handles method calls to a service instance in a thread.
+    class WorkerThread < Thread
+
+        # Initialize a new WorkerThread instance.
+        def initialize
+        
+            super {}
+            @obj = nil
+
+        end
+        
+        # Tells the WorkerThread to forward method calls to the given service instance.
+        # 
+        # Parameters:
+        # 
+        # +obj+:: The service instance to forward to.
+        def use_instance(obj)
+        
+            @obj = obj
+        
+        end
+               
+        # Perform method calls on the service instance.
+        def perform(meth, *a, &b)
+        
+            ret = nil
+            
+            begin
+            
+                ret = @obj.send(meth, *a)
+            
+            rescue NoMethodError, TypeError => e
+            
+                return e
+            
+            end
+
+            ret
+        
+        end
+        
+    end
+    
+end

data/test/test_persistent_cache.rb

@@ -0,0 +1,99 @@
+require 'drb'
+require 'lib/boogaloo/cache/persistent'
+require 'lib/boogaloo/util'
+
+class TestPersistentCache < Test::Unit::TestCase
+
+    def test_persistent_cache
+       
+        @cache = Boogaloo::Cache::Persistent.new('TestCache', nil)
+        do_cache_stats_test
+
+        # Test cache add
+        @cache.set("test_namespace", "test_key_1", "Hello, World!")
+        assert_equal @cache.stat_namespaces, 2
+        assert_equal @cache.stat_objects, 1
+        assert @cache.get("test_namespace", "test_key_1")
+        assert_equal @cache.get("test_namespace", "test_key_1"), "Hello, World!"
+        assert_equal @cache.stat_hits, 2
+
+        # Test cache set
+        @cache.set("test_namespace", "test_key_1", "Hello again, World!")
+        assert_equal @cache.stat_namespaces, 2
+        assert_equal @cache.stat_objects, 1
+        # set should overwrite the previous add
+        assert @cache.get("test_namespace", "test_key_1")
+        assert_equal @cache.get("test_namespace", "test_key_1"), "Hello again, World!"
+        assert_equal @cache.stat_hits, 4
+        
+        # Test global namespace
+        @cache.set(nil, "test_key_2", "Hey")
+        assert_equal @cache.stat_namespaces, 2
+        assert_equal @cache.stat_objects, 2
+        assert @cache.get(nil, "test_key_2")
+        assert_equal @cache.get(nil, "test_key_2"), "Hey"
+        assert_equal @cache.stat_hits, 6
+        
+        # Test cache miss
+        @cache.get("non_existent", "not there!")
+        @cache.get(nil, "booo")
+        assert_equal @cache.stat_misses, 2
+               
+        # Test reset
+        @cache.reset
+        do_cache_stats_test
+
+        # Test inspect_keys
+        @cache.set(nil, "test_key_3", "hello!")
+        @cache.set("test_namespace", "test_key_4", "umbongo")
+        keys = @cache.inspect_keys
+        assert keys
+        assert keys.is_a?(Array)
+        assert_equal keys.size, 2
+        assert keys[0].is_a?(Array)
+        assert keys[1].is_a?(Hash)        
+        assert_equal keys[0][0], "test_key_3"
+        assert keys[1].key?("test_namespace")
+        assert_equal keys[1]['test_namespace'][0], "test_key_4"
+        
+        @cache.reset
+        
+        # Test cache pull
+        @cache.set(nil, "test_key_4", "hello!")
+        assert_equal @cache.pull(nil, "test_key_4"), "hello!"
+        assert_equal @cache.get(nil, "test_key_4"), nil
+        assert_equal @cache.pull(nil, "test_key_4"), nil
+        
+        # Test cache pull with namespace cleanup
+        @cache.set("pull_ns", "test_key_5", "hello!")
+        assert_equal @cache.stat_namespaces, 2
+        assert_equal @cache.pull("pull_ns", "test_key_5"), "hello!"
+        assert_equal @cache.get("pull_ns", "test_key_5"), nil
+        assert_equal @cache.pull("pull_ns", "test_key_5"), nil
+        assert_equal @cache.stat_namespaces, 1
+    
+        # Test nil error add/set
+        assert_kind_of TypeError, @cache.set(nil, "test_key_6", nil)
+        assert_kind_of TypeError, @cache.add(nil, "test_key_6", nil)
+
+    end
+    
+    def do_cache_stats_test
+    
+        stats = @cache.stat_all
+        assert @cache.stat_all.size == 5
+        assert stats[0].is_a?(Time)
+        assert stats[1] == 0
+        assert stats[2] == 0
+        assert stats[3] == 1
+        assert stats[4] == 0
+    
+        assert @cache.stat_reset_at == stats[0]
+        assert @cache.stat_hits == stats[1]
+        assert @cache.stat_misses == stats[2]
+        assert @cache.stat_namespaces == stats[3]
+        assert @cache.stat_objects == stats[4]    
+    
+    end
+    
+end