manveru-innate 2009.02.06

data/lib/innate/adapter.rb

@@ -0,0 +1,89 @@
+module Rack
+  module Handler
+    autoload :Thin,               'rack/handler/thin'
+    autoload :Ebb,                'ebb'
+    autoload :SwiftipliedMongrel, 'rack/handler/swiftiplied_mongrel'
+
+    register 'thin',     'Rack::Handler::Thin'
+    register 'ebb',      'Rack::Handler::Ebb'
+    register 'smongrel', 'Rack::Handler::SwiftipliedMongrel'
+  end
+end
+
+module Innate
+
+  # Lightweight wrapper around Rack::Handler, will apply our options in a
+  # unified manner and deal with adapters that don't like to do what we want or
+  # where Rack doesn't want to take a stand.
+
+  module Adapter
+    class << self
+
+      # Pass given app to the Handler, handler is chosen based on
+      # config.adapter option.
+      # If there is a method named start_name_of_adapter it will be run instead
+      # of the default run method of the handler, this makes it easy to define
+      # custom startup of handlers for your server of choice
+      def start(app, options = Innate.options)
+        adapter_name = options[:adapter].to_s.downcase
+        config = { :Host => options[:host], :Port => options[:port] }
+        Log.debug "Innate uses #{adapter_name}"
+
+        if respond_to?(method = "start_#{adapter_name}")
+          send(method, app, config)
+        else
+          Rack::Handler.get(adapter_name).run(app, config)
+        end
+      end
+
+      # Due to buggy autoload on Ruby 1.8 we have to require 'ebb' manually.
+      # This most likely happens because autoload doesn't respect the require
+      # of rubygems and uses the C require directly.
+      def start_ebb(app, config)
+        require 'ebb'
+        Rack::Handler.get('ebb').run(app, config)
+      end
+
+      # We want webrick to use our logger.
+
+      def start_webrick(app, config)
+        handler = Rack::Handler.get('webrick')
+        config = {
+          :BindAddress => config[:Host],
+          :Port => config[:Port],
+          :Logger => Log,
+          :AccessLog => [
+            [Log, ::WEBrick::AccessLog::COMMON_LOG_FORMAT],
+            [Log, ::WEBrick::AccessLog::REFERER_LOG_FORMAT]]
+        }
+
+        handler.run(app, config)
+      end
+
+      # Thin shouldn't give excessive output, especially not to $stdout
+
+      def start_thin(app, config)
+        require 'thin'
+        handler = Rack::Handler.get('thin')
+        ::Thin::Logging.silent = true
+        handler.run(app, config)
+      end
+
+      # swiftcore has its own handler outside of rack
+
+      def start_emongrel(app, config)
+        require 'swiftcore/evented_mongrel'
+        handler = Rack::Handler.get('emongrel')
+        handler.run(app, config)
+      end
+
+      # swiftcore has its own handler outside of rack
+
+      def start_smongrel(app, config)
+        require 'swiftcore/swiftiplied_mongrel'
+        handler = Rack::Handler.get('smongrel')
+        handler.run(app, config)
+      end
+    end
+  end
+end

data/lib/innate/cache.rb

@@ -0,0 +1,117 @@
+module Innate
+  # Cache manager and wrapper.
+  #
+  # Provides a convenient wrapper around caches to keep method name confusion
+  # at a minimum while still having short and meaningful method names for every
+  # cache instance.
+  #
+  # The default caching is specified in lib/innate.rb in the config section.
+  # At the time of writing it defaults to Innate::Cache::Memory but can be
+  # changed easily.
+  #
+  # Configuration has to be done before Innate::setup_dependencies is being
+  # called.
+  #
+  # Configuration:
+  #
+  #   Innate.options.cache do |cache|
+  #     cache.names = [:session, :user]
+  #     cache.session = Innate::Cache::Marshal
+  #     cache.user = Innate::Cache::YAML
+  #   end
+  #
+  # Usage for storing:
+  #
+  #   # Storing with a time to live (10 seconds)
+  #   Innate::Cache.user.store(:manveru, "Michael Fellinger", :ttl => 10)
+  #
+  #   # Storing indefinitely
+  #   Innate::Cache.user[:Pistos] = "unknown"
+  #   # or without :ttl argument
+  #   Innate::Cache.user.store(:Pistos, "unknown")
+  #
+  # Usage for retrieving:
+  #
+  #   # we stored this one for 10 seconds
+  #   Innate::Cache.user.fetch(:manveru, 'not here anymore')
+  #   # => "Michael Fellinger"
+  #   sleep 11
+  #   Innate::Cache.user.fetch(:manveru, 'not here anymore')
+  #   # => "not here anymore"
+  #
+  #   Innate::Cache.user[:Pistos]
+  #   # => "unknown"
+  #   Innate::Cache.user.fetch(:Pistos)
+  #   # => "unknown"
+  #
+  #
+  # For more details and to find out how to implement your own cache please
+  # read the documentation of Innate::Cache::API
+  #
+  # NOTE:
+  #   * Some caches might expose their contents for everyone else on the same
+  #     system, or even on connected systems. The rule as usual is, not to
+  #     cache sensitive information.
+
+  class Cache
+    autoload :API,       'innate/cache/api'
+    autoload :DRb,       'innate/cache/drb'
+    autoload :YAML,      'innate/cache/yaml'
+    autoload :Memory,    'innate/cache/memory'
+    autoload :Marshal,   'innate/cache/marshal'
+    autoload :FileBased, 'innate/cache/file_based'
+
+    attr_reader :name, :instance
+
+    def initialize(name, klass = nil)
+      @name = name.to_s.dup.freeze
+
+      options = Innate.options
+
+      klass ||= options[:cache, @name.to_sym]
+      @instance = klass.new
+
+      @instance.cache_setup(
+        options.env.host,
+        options.env.user,
+        options.app.name,
+        @name
+      )
+    end
+
+    def self.setup
+      Innate.options.cache.names.each{|name| add(name) }
+    end
+
+    def self.register(cache)
+      key = cache.name
+      source = "def self.%s() @%s; end
+                def self.%s=(o) @%s = o; end" % [key, key, key, key]
+      self.class_eval(source, __FILE__, __LINE__)
+
+      self.send("#{key}=", cache)
+    end
+
+    def self.add(name)
+      register(new(name))
+    end
+
+    def clear
+      instance.cache_clear
+    end
+
+    def delete(*keys)
+      instance.cache_delete(*keys)
+    end
+
+    def fetch(key, default = nil)
+      instance.cache_fetch(key, default)
+    end
+    alias [] fetch
+
+    def store(key, value, options = {})
+      instance.cache_store(key, value, options)
+    end
+    alias []= store
+  end
+end

data/lib/innate/cache/api.rb

@@ -0,0 +1,106 @@
+module Innate
+  class Cache
+
+    # This is the API every Cache has to conform to.
+    #
+    # The default behaviour is tailored for the Memory cache, override any
+    # behaviour as you need.
+    #
+    # +key+ may be a String or Symbol
+    # +value+ is a Hash of serializable (as according to Marshal) objects
+    #
+    # Every cache instance has to respond to:
+    #
+    #   ::new()
+    #   #cache_setup(hostname, username, appname, cachename)
+    #   #cache_clear()
+    #   #cache_delete(*keys)
+    #   #cache_fetch(key, default = nil)
+    #   #cache_store(key, value, options = {})
+    #
+    # We are prefixing cache_ to make the intent clear and implementation
+    # easier, as there may be existing behaviour associated with the
+    # non-prefixed version.
+    #
+    # Also note that we create one instance per cache name-space.
+    module API
+      # Executed after #initialize and before any other method.
+      #
+      # Some parameters identifying the current process will be passed so
+      # caches that act in one global name-space can use them as a prefix.
+      #
+      # Treat all arguments as Strings.
+      #
+      # +hostname+  the hostname of the machine.
+      # +username+  user executing this process.
+      # +appname+   identifier for the application being executed.
+      # +cachename+ name-space of the cache, like 'session' or 'action'
+      def cache_setup(hostname, username, appname, cachename)
+      end
+
+      # Remove all key/value pairs from the cache.
+      # Should behave as if #delete had been called with all +keys+ as argument.
+      def cache_clear
+        clear
+      end
+
+      # Remove the corresponding key/value pair for each key passed.
+      # If removing is not an option it should set the corresponding value to nil.
+      #
+      # If only one key was deleted, answer with the corresponding value.
+      # If multiple keys were deleted, answer with an Array containing the values.
+      def cache_delete(key, *keys)
+        if keys.empty?
+          if value = yield(key)
+            value[:value]
+          end
+        else
+          [key, *keys].map{|k| cache_delete(k) }
+        end
+      end
+
+      # Answer with the value associated with the +key+, +nil+ if not found or
+      # expired.
+      def cache_fetch(key, default = nil)
+        value = default
+
+        if entry = yield(key)
+          if expires = entry[:expires]
+            if expires > Time.now
+              value = entry[:value]
+            else
+              cache_delete(key)
+            end
+          else
+            value = entry[:value]
+          end
+        end
+
+        return value
+      end
+
+      # Set +key+ to +value+.
+      #
+      # +options+ may be one of:
+      #   :ttl => time to live in seconds if given in Numeric
+      #                        infinite or maximum if not given
+      #
+      # Usage:
+      #   Cache.value.store(:num, 3, :ttl => 20)
+      #   Cache.value.fetch(:num) # => 3
+      #   sleep 21
+      #   Cache.value.fetch(:num) # => nil
+      #
+      def cache_store(key, value, options = {})
+        ttl = options[:ttl]
+
+        value_hash = {:value => value}
+        value_hash[:expires] = Time.now + ttl if ttl
+
+        yield(key, value_hash)
+
+        return value
+      end
+    end
+  end
+end

data/lib/innate/cache/drb.rb

@@ -0,0 +1,58 @@
+require 'drb'
+
+module Innate
+  module Cache
+
+    # Cache utilizing a DRb server.
+    #
+    # You will need to run a corresponding DRb server to use this cache. The
+    # example below is using a normal Hash, but it is recommended to use a
+    # thread-safe alternative like SyncHash.
+    #
+    # Example for DRb server:
+    #
+    #   require 'drb'
+    #
+    #   URI = "druby://127.0.0.1:9069"
+    #   CACHE = {}
+    #
+    #   $SAFE = 1 # disable eval and friends
+    #
+    #   DRb.start_service(URI, CACHE)
+    #   DRb.thread.join
+    #
+    # Usage for all caches:
+    #
+    #   Innate.options.cache.default = Innate::Cache::DRb
+    #
+    # Usage for sessions only:
+    #
+    #   Innate.options.cache.session = Innate::Cache::DRb
+    class DRb
+      include Cache::API
+
+      OPTIONS = {:address => '127.0.0.1', :port => 9069}
+
+      def cache_setup(*args)
+        address, port = OPTIONS.values_at(:address, :port)
+        @store = DRbObject.new(nil, "druby://#{address}:#{port}")
+      end
+
+      def cache_clear
+        @store.clear
+      end
+
+      def cache_store(*args)
+        super{|key, value| @store[key] = value }
+      end
+
+      def cache_fetch(*args)
+        super{|key| @store[key] }
+      end
+
+      def cache_delete(*args)
+        super{|key| @store.delete(key) }
+      end
+    end
+  end
+end

data/lib/innate/cache/file_based.rb

@@ -0,0 +1,39 @@
+module Innate
+  class Cache
+
+    # Used by caches that serialize their contents to the filesystem.
+    module FileBased
+      def cache_setup(*args)
+        @prefix = args.compact.join('-')
+
+        @dir = File.join(Dir.tmpdir, self.class::DIR)
+        FileUtils.mkdir_p(@dir)
+
+        @filename = File.join(@dir, @prefix + self.class::EXT)
+        @store = self.class::STORE.new(@filename)
+      end
+
+      def cache_clear
+        FileUtils.mkdir_p(@dir)
+        FileUtils.rm_f(@filename)
+        @store = self.class::STORE.new(@filename)
+      end
+
+      def cache_store(*args)
+        super{|key, value| transaction{|store| store[key] = value } }
+      end
+
+      def cache_fetch(*args)
+        super{|key| transaction{|store| store[key] } }
+      end
+
+      def cache_delete(*args)
+        super{|key| transaction{|store| store.delete(key) } }
+      end
+
+      def transaction(&block)
+        Innate.sync{ @store.transaction(&block) }
+      end
+    end
+  end
+end

data/lib/innate/cache/marshal.rb

@@ -0,0 +1,17 @@
+require 'pstore'
+
+module Innate
+  class Cache
+    # Keeps every cache in a separate file like this:
+    #
+    # /tmp/innate-cache-marshal/delta-manveru-session.marshal
+    class Marshal
+      include Cache::API
+      include Cache::FileBased
+
+      STORE = ::PStore
+      DIR = 'innate-cache-marshal'
+      EXT = '.marshal'
+    end
+  end
+end

data/lib/innate/cache/memory.rb

@@ -0,0 +1,22 @@
+module Innate
+  class Cache
+    # Memory cache is simply a Hash with the Cache::API, it's the reference
+    # implementation for every other cache.
+
+    class Memory < Hash
+      include Cache::API
+
+      def cache_store(*args)
+        super{|key, value| self[key] = value }
+      end
+
+      def cache_fetch(*args)
+        super{|key| self[key] }
+      end
+
+      def cache_delete(*args)
+        super{|key| delete(key) }
+      end
+    end
+  end
+end