boogaloo 0.1

data/CHANGELOG

@@ -0,0 +1,2 @@
+* October 14th 2006 - Ian Leitch
+	- Release 0.1

data/DEBUGGING

@@ -0,0 +1,4 @@
+== Debugging Boogaloo
+
+You can either enable debugging via the configuration file by putting 'debug = true' in the _Server_ section, or enable it as the server is running by sending a USR1 signal:
+  kill -SIGUSR1 `pidof boogaloo`

data/MIT-LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2006 Refreshing Software
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,106 @@
+= Boogaloo Simple Cache Server
+
+Boogaloo is a very simple cache server that provides permanent and temporary object persistence, with the ability for objects to "expire".
+Boogaloo can also be used for housing custom services, such as a registry or specialized cache implementation.
+
+Boogaloo was initially developed for a RubyOnRails application that needed basic persistant object caching across multiple web nodes
+and a mechanism for caching objects related to a user temporarily rather than storing them in the session.
+
+== Getting Started
+
+Caches are created in Boogaloo by specifying them in the configuration file. For example, to host one persistent and one temporary cache,
+your config may look something like this:
+
+  Server:
+    host: localhost
+    port: 7777
+    worker_threads: 3
+  
+  PersistentCaches:
+
+    MyPersistentCache:
+      instance_name: main_cache
+
+  TemporaryCaches:
+
+    MyTempCache:
+      instance_name: temp_cache
+      check_frequency: 10
+   
+1. +instance_name+ is the method via which the cache instance will be accessed by the client.
+2. +check_frequency+ is the frequency in seconds at which the cache will check for stale objects to delete.
+
+An example configuration file can be found in examples/boogalooo.conf[link:files/examples/boogaloo_conf.html].
+
+Next start the Boogaloo server:
+
+  boogaloo -d -f boogaloo.conf
+
+Now on the client we access the caches like this:
+
+  boogaloo_cache = Boogaloo::Client::Connection.new('localhost', 7777, true)
+  boogaloo_cache.main_cache.set(nil, "some_string", "Hello, World!")
+  boogaloo_cache.temp_cache.set(nil, "some_string", "Hello, World!", 20)
+
+"Hello, World!" will persist for the lifetime of the server in _main_cache_, yet will be deleted in 20 seconds unless touched in _temp_cache_. By "unless touched" we mean that if the object is fetched from the cache with get() 10 seconds after being added, it's expiration
+time will be reset to 20 seconds from the time it was fetched.
+
+The boolean value passed into Connection[link:classes/Boogaloo/Client/Connection.html] tells the connection to return nil for all requests if the cache server
+is offline rather than throwing an exception.
+
+== Command Line Options
+
+[<tt>--config -c</tt>]
+    The configuration file to use.
+[<tt>--daemon -d</tt>]
+    Run as a stand-alone process. 
+
+== Custom Services
+
+You can also use Boogaloo to house your own custom services. These services can perform any task you want them to, all Boogaloo cares about is that you provide it with an interface to use.
+
+Let say we create a new service called _MyService_ and put it in a folder called /home/me/BoogalooServices/MyService, the only required file is an interface.rb
+
+  module MyService
+
+    class Interface
+	
+      def initialize(arg1, arg2)
+	
+        self.arg1 = arg1
+        self.arg2 = arg2
+
+      end
+		
+      def arg1
+		
+        self.arg1
+		
+      end
+		
+      def arg2
+		
+        self.arg2
+			
+      end
+	
+    end
+
+  end
+  
+And then in our configuration file we put something like:
+
+  Services:
+  
+    MyService:
+      instance_name: my_service
+      path: /home/me/BoogalooServices/MyService
+      arguments:
+        - Hello
+        - World
+       
+Restart Boogaloo and you'll your service will be available as _my_service_ on the client.
+
+Boogaloo requires that your _Interface_ class is contained within a module with the same name as specified in the configuration, in this case its _MyService_.
+
+Boogaloo can also manage your $LOAD_PATH for you, see the detailed configuration documentation[link:classes/Boogaloo/Config.html] for more information.

data/RUNNING_UNIT_TESTS

@@ -0,0 +1,5 @@
+== Running Unit Tests
+
+To run Boogaloo's unit tests:
+
+  rake test

data/Rakefile

@@ -0,0 +1,44 @@
+require 'test/unit'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'lib/boogaloo/version'
+
+
+Rake::RDocTask.new do |rd|
+    
+    rd.main = "README"
+    rd.rdoc_dir = "doc"
+    rd.options << "--inline-source"
+    rd.title = "Boogaloo Documentation"
+    rd.rdoc_files.include("README", "MIT-LICENSE", "DEBUGGING", "lib/**/*.rb", "examples/*")
+    
+end
+
+task :release => [ :clean, :rerdoc, :build_gem, :create_archive ]
+
+task :build_gem do
+
+    system "gem build boogaloo.gemspec"
+
+end
+
+task :create_archive do
+
+    system "tar cvf boogaloo-#{PKG_VERSION}.tar lib/ examples/ doc/ bin/ test/ README MIT-LICENSE CHANGELOG Rakefile RUNNING_UNIT_TESTS"
+    system "gzip boogaloo-#{PKG_VERSION}.tar"
+
+end
+
+task :clean do
+
+    system "rm examples/*~"
+
+end
+
+task :test do
+
+    runner = Test::Unit::AutoRunner.new(true)
+    runner.to_run << "test"
+    runner.run
+
+end

data/bin/boogaloo

@@ -0,0 +1,159 @@
+#!/usr/bin/ruby
+# Boogaloo Simple Cache Server
+# Copyright 2006 Ian Leitch, Refreshing Software.
+
+require 'drb'
+require 'getoptlong'
+require 'rdoc/usage'
+
+require 'boogaloo/config'
+require 'boogaloo/thread_pool'
+require 'boogaloo/service_gateway'
+require 'boogaloo/cache/persistent'
+require 'boogaloo/cache/temporary'
+
+opts = GetoptLong.new(
+    [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
+    [ '--config', '-c', GetoptLong::OPTIONAL_ARGUMENT ],
+    [ '--daemon', '-d', GetoptLong::OPTIONAL_ARGUMENT ]
+    )
+
+$debug = false
+config_file = '/etc/boogaloo.conf'
+daemon = false
+
+opts.each do |opt, arg|
+
+    case opt
+    
+        when '--help'
+
+            RDoc::usage
+    
+        when '--config'
+
+            config_file = arg
+            
+        when '--daemon'
+
+            daemon = true
+
+    end
+      
+end
+
+config = Boogaloo::Config.new(config_file)
+thread_pool = Boogaloo::ThreadPool.new(config.server_worker_threads)
+services = {}
+
+def register_caches(services, conf, klass, type)
+
+	conf.each do |name, cache_config|
+
+    	notice("Registering #{type} cache '#{name}' as '#{cache_config['instance_name']}'")
+	    services[cache_config['instance_name']] = klass.new(name, cache_config)
+
+	end
+
+end
+
+register_caches(services, config.persistent_caches, Boogaloo::Cache::Persistent, 'persistent')
+register_caches(services, config.temporary_caches, Boogaloo::Cache::Temporary, 'temporary')
+
+config.services.each do |name, service_config|
+
+	paths = []
+	base_path = File.join(service_config['path'], '..')
+	$LOAD_PATH << base_path	
+	require File.join(service_config['path'], 'interface')
+	$LOAD_PATH.delete(base_path)
+		
+	if service_config.key?('require_path')
+
+		if service_config.key?('require_path').is_a?(Array)
+
+			service_config.key?('require_path').each do |path|
+
+				$LOAD_PATH << path
+				paths << path
+			
+			end
+		
+		elsif service_config.key?('require_path').is_a?(String)
+		
+				$LOAD_PATH << service_config.key?('require_path')
+				paths << path
+	
+		end
+		
+	end
+
+   	notice("Registering service '#{name}' as '#{service_config['instance_name']}'")
+   	
+   	if service_config.key?('parameters')
+   	
+	    services[service_config['instance_name']] = eval("#{name}::Interface").new(*service_config['parameters'])
+	    
+	else
+	
+		services[service_config['instance_name']] = eval("#{name}::Interface").new()
+	
+	end
+	
+	paths.each { |path| $LOAD_PATH.delete(path) }
+	
+end
+
+def shutdown(pool)
+
+	if $shutingdown
+	
+		notice("Shutdown forced.")
+		exit 1
+	
+	else
+	
+		$shutingdown = true
+		notice("Shuting down...")
+		warning("Not all threads joined") if not pool.shutdown
+		exit 0
+
+	end
+
+end
+
+Signal.trap("INT") { shutdown(thread_pool) }
+Signal.trap("TERM") { shutdown(thread_pool) }
+Signal.trap("SEGV") { shutdown(thread_pool) }
+Signal.trap("KILL") { shutdown(thread_pool) }
+Signal.trap("USR1") { $debug = $debug ? false : true; notice("Debugging #{$debug ? 'enabled' : 'disabled'}") }
+
+gateway = Boogaloo::ServiceGateway.new(thread_pool, services)
+gateway.freeze
+
+proto_str = "druby://#{config.server_host}:#{config.server_port}"
+
+if daemon
+
+	Process.fork {
+  
+		DRb.start_service(proto_str, gateway)
+		$SAFE = 1
+  		notice("Online (#{proto_str}) (PID: #{Process.pid})")
+		[ STDIN, STDOUT, STDERR ].each { |io|
+        	io.reopen("/dev/null", "r+")
+			}
+	    $0 = "boogaloo"
+		DRb.thread.join
+		exit!
+		
+    }
+    
+else
+
+	DRb.start_service(proto_str, gateway)
+	$SAFE = 1
+	notice("Online (#{proto_str})")
+	DRb.thread.join
+
+end

data/doc/classes/Boogaloo.html

@@ -0,0 +1,149 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html 
+     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <title>Module: Boogaloo</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+  <meta http-equiv="Content-Script-Type" content="text/javascript" />
+  <link rel="stylesheet" href=".././rdoc-style.css" type="text/css" media="screen" />
+  <script type="text/javascript">
+  // <![CDATA[
+
+  function popupCode( url ) {
+    window.open(url, "Code", "resizable=yes,scrollbars=yes,toolbar=no,status=no,height=150,width=400")
+  }
+
+  function toggleCode( id ) {
+    if ( document.getElementById )
+      elem = document.getElementById( id );
+    else if ( document.all )
+      elem = eval( "document.all." + id );
+    else
+      return false;
+
+    elemStyle = elem.style;
+    
+    if ( elemStyle.display != "block" ) {
+      elemStyle.display = "block"
+    } else {
+      elemStyle.display = "none"
+    }
+
+    return true;
+  }
+  
+  // Make codeblocks hidden by default
+  document.writeln( "<style type=\"text/css\">div.method-source-code { display: none }</style>" )
+  
+  // ]]>
+  </script>
+
+</head>
+<body>
+
+
+
+    <div id="classHeader">
+        <table class="header-table">
+        <tr class="top-aligned-row">
+          <td><strong>Module</strong></td>
+          <td class="class-name-in-header">Boogaloo</td>
+        </tr>
+        <tr class="top-aligned-row">
+            <td><strong>In:</strong></td>
+            <td>
+                <a href="../files/lib/boogaloo/config_rb.html">
+                lib/boogaloo/config.rb
+                </a>
+        <br />
+                <a href="../files/lib/boogaloo/service_gateway_rb.html">
+                lib/boogaloo/service_gateway.rb
+                </a>
+        <br />
+                <a href="../files/lib/boogaloo/service_request_rb.html">
+                lib/boogaloo/service_request.rb
+                </a>
+        <br />
+                <a href="../files/lib/boogaloo/worker_thread_rb.html">
+                lib/boogaloo/worker_thread.rb
+                </a>
+        <br />
+                <a href="../files/lib/boogaloo/thread_pool_rb.html">
+                lib/boogaloo/thread_pool.rb
+                </a>
+        <br />
+                <a href="../files/lib/boogaloo/cache/temporary_rb.html">
+                lib/boogaloo/cache/temporary.rb
+                </a>
+        <br />
+                <a href="../files/lib/boogaloo/cache/persistent_rb.html">
+                lib/boogaloo/cache/persistent.rb
+                </a>
+        <br />
+                <a href="../files/lib/boogaloo/cache/base_rb.html">
+                lib/boogaloo/cache/base.rb
+                </a>
+        <br />
+                <a href="../files/lib/boogaloo/client/connection_rb.html">
+                lib/boogaloo/client/connection.rb
+                </a>
+        <br />
+            </td>
+        </tr>
+
+        </table>
+    </div>
+  <!-- banner header -->
+
+  <div id="bodyContent">
+
+
+
+  <div id="contextContent">
+
+
+
+   </div>
+
+
+  </div>
+
+
+    <!-- if includes -->
+
+    <div id="section">
+
+    <div id="class-list">
+      <h3 class="section-bar">Classes and Modules</h3>
+
+      Module <a href="Boogaloo/Cache.html" class="link">Boogaloo::Cache</a><br />
+Module <a href="Boogaloo/Client.html" class="link">Boogaloo::Client</a><br />
+Class <a href="Boogaloo/Config.html" class="link">Boogaloo::Config</a><br />
+Class <a href="Boogaloo/ServiceGateway.html" class="link">Boogaloo::ServiceGateway</a><br />
+Class <a href="Boogaloo/ServiceRequest.html" class="link">Boogaloo::ServiceRequest</a><br />
+Class <a href="Boogaloo/ThreadPool.html" class="link">Boogaloo::ThreadPool</a><br />
+Class <a href="Boogaloo/WorkerThread.html" class="link">Boogaloo::WorkerThread</a><br />
+
+    </div>
+
+
+
+
+      
+
+
+    <!-- if method_list -->
+
+
+  </div>
+
+
+<div id="validator-badges">
+  <p><small><a href="http://validator.w3.org/check/referer">[Validate]</a></small></p>
+</div>
+
+</body>
+</html>