rjspotter-innate 2009.06.29

data/lib/innate/adapter.rb

@@ -0,0 +1,76 @@
+Rack::Handler.register('ebb', 'Rack::Handler::Ebb')
+
+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.
+  #
+  # Rack handlers as of 2009.03.25:
+  # cgi, fastcgi, mongrel, emongrel, smongrel, webrick, lsws, scgi, thin
+
+  module Adapter
+    include Optioned
+
+    options.dsl do
+      o "IP address or hostname that we respond to - 0.0.0.0 for all",
+        :host, "0.0.0.0"
+
+      o "Port for the server",
+        :port, 7000
+
+      o "Web server to run on",
+        :handler, :webrick
+    end
+
+    # 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 self.start(app, given_options = nil)
+      options.merge!(given_options) if given_options
+
+      handler = options[:handler].to_s.downcase
+      config = { :Host => options[:host], :Port => options[:port] }
+
+      Log.debug "Using #{handler}"
+
+      if respond_to?(method = "start_#{handler}")
+        send(method, app, config)
+      else
+        Rack::Handler.get(handler).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 self.start_ebb(app, config)
+      require 'ebb'
+      Rack::Handler.get('ebb').run(app, config)
+    end
+
+    # We want webrick to use our logger.
+    def self.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 self.start_thin(app, config)
+      handler = Rack::Handler.get('thin')
+      ::Thin::Logging.silent = true
+      handler.run(app, config)
+    end
+  end
+end

data/lib/innate/cache.rb

@@ -0,0 +1,134 @@
+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::Cache.options 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'
+
+    include Optioned
+
+    options.dsl do
+      o "Assign a cache to each of these names on Innate::Cache::setup",
+        :names, [:session, :view]
+
+      default "If no option for the cache name exists, fall back to this",
+        Innate::Cache::Memory
+    end
+
+    attr_reader :name, :instance
+
+    def initialize(name, klass = nil)
+      @name = name.to_s.dup.freeze
+
+      klass ||= options[@name.to_sym]
+      @instance = klass.new
+
+      @instance.cache_setup(
+        ENV['HOSTNAME'],
+        ENV['USER'],
+        'pristine',
+        @name
+      )
+    end
+
+    # Add all caches from the options.
+    #
+    # @see Innate::setup_dependencies
+    # @api stable
+    # @return [Array] names of caches initialized
+    # @author manveru
+    def self.setup
+      options.names.each{|name| add(name) }
+    end
+
+    # Add accessors for cache
+    #
+    # @param [Cache] cache
+    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(*names)
+      names.each{|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,128 @@
+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.
+      #
+      # @param [String #to_s] hostname  the hostname of the machine
+      # @param [String #to_s] username  user executing the process
+      # @param [String #to_s] appname   identifier for the application
+      # @param [String #to_s] cachename namespace, like 'session' or 'action'
+      # @author manveru
+      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.
+      #
+      # @author manveru
+      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.
+      #
+      # NOTE: Due to differences in the underlying implementation in the
+      #       caches, some may not return the deleted value as it would mean
+      #       another lookup before deletion. This is the case for caches on
+      #       memcached or any database system.
+      #
+      # @param [Object] key the key for the value to delete
+      # @param [Object] keys any other keys to delete as well
+      # @return [Object Array nil]
+      # @author manveru
+      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.
+      #
+      # @param [Object] key     the key for which to fetch the value
+      # @param [Object] default will return this if no value was found
+      # @return [Object]
+      # @see Innate::Cache#fetch Innate::Cache#[]
+      # @author manveru
+      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
+      #
+      # @param [Object] key     the value is stored with this key
+      # @param [Object] value   the key points to this value
+      # @param [Hash]   options for now, only :ttl => Fixnum is used.
+      # @see Innate::Cache#store Innate::Cache#[]=
+      # @author manveru
+      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 usage of 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
+    #
+    # Please note that on some Ruby implementations, access to Hash is not
+    # atomic and you might need to lock around access to avoid race conditions.
+    #
+    # @example for all caches
+    #   Innate.options.cache.default = Innate::Cache::DRb
+    #
+    # @example 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,44 @@
+module Innate
+  class Cache
+
+    # Used by caches that serialize their contents to the filesystem.
+    # Right now we do not lock around write access to the file outside of the
+    # process, that means that all FileBased caches are not safe for use if you
+    # need more than one instance of your application.
+    module FileBased
+      attr_reader :filename
+
+      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,20 @@
+require 'pstore'
+
+module Innate
+  class Cache
+    # Keeps every cache in a separate file like this:
+    # /tmp/innate-cache-marshal/delta-manveru-session.marshal
+    #
+    # The Marshal cache is not safe for use between multiple processes, it is
+    # also slow compared to other caches, so generally the use of it is
+    # discouraged.
+    class Marshal
+      include Cache::API
+      include Cache::FileBased
+
+      STORE = ::PStore
+      DIR = 'innate-cache-marshal'
+      EXT = '.marshal'
+    end
+  end
+end