benschwarz-moneta 0.6.0 → 0.6.1

data/Rakefile

@@ -5,7 +5,7 @@ require 'spec/rake/spectask'
 require 'date'
 
 GEM = "moneta"
-GEM_VERSION = "0.5.0"
+GEM_VERSION = "0.6.1"
 AUTHOR = "Yehuda Katz"
 EMAIL = "wycats@gmail.com"
 HOMEPAGE = "http://www.yehudakatz.com"

data/lib/moneta/basic_file.rb

@@ -0,0 +1,111 @@
+#
+#  Basic File Store
+#  by Hampton Catlin
+#
+#  This cache simply uses a directory that it creates
+#  and manages to keep your file stores.
+#
+#  Specify :skip_expires => true if you aren't using 
+#  expiration as this will slightly decrease your file size
+#  and memory footprint of the library
+#
+#  You can optionally also specify a :namespace
+#  option that will create a subfolder.
+#
+
+
+require 'fileutils'
+require File.join(File.dirname(__FILE__), "..", "moneta.rb")
+
+module Moneta
+  class BasicFile
+    include Defaults
+    
+    def initialize(options = {})
+      @namespace = options[:namespace]
+      @directory = ::File.join(options[:path], @namespace.to_s)
+      
+      @expires = !options[:skip_expires]
+
+      ensure_directory_created(@directory)
+    end
+    
+    def key?(key)
+      !self[key].nil?
+    end
+    
+    alias has_key? key?
+    
+    def [](key)
+      if ::File.exist?(path(key))
+        data = raw_get(key)
+        if @expires
+          if data[:expires_at].nil? || data[:expires_at] > Time.now
+            data[:value]
+          else
+            delete!(key)
+          end
+        end
+      end
+    end
+    
+    def raw_get(key)
+      Marshal.load(::File.read(path(key)))
+    end
+    
+    def []=(key, value)
+      store(key, value)
+    end
+    
+    def store(key, value, options = {})
+      ensure_directory_created(::File.dirname(path(key)))
+      ::File.open(path(key), "w") do |file|
+        if @expires
+          data = {:value => value}
+          if options[:expires_in]
+            data[:expires_at] = Time.now + options[:expires_in]
+          end
+          contents = Marshal.dump(data)
+        else
+          contents = Marshal.dump(value)
+        end
+        file.puts(contents)
+      end
+    end
+    
+    def update_key(key, options)
+      store(key, self[key], options)
+    end
+    
+    def delete!(key)
+      FileUtils.rm(path(key))
+      nil
+    rescue Errno::ENOENT
+    end
+          
+    def delete(key)
+      value = self[key]
+      delete!(key)
+      value
+    end
+          
+    def clear
+      FileUtils.rm_rf(@directory)
+      FileUtils.mkdir(@directory)
+    end
+    
+    private
+    def path(key)
+      ::File.join(@directory, key.to_s)
+    end
+    
+    def ensure_directory_created(directory_path)
+      if ::File.file?(directory_path)
+        raise StandardError, "The path you supplied #{directory_path} is a file"
+      elsif !::File.exists?(directory_path)
+        FileUtils.mkdir_p(directory_path)
+      end
+    end
+      
+  end
+end

data/lib/moneta/berkeley.rb

@@ -0,0 +1,53 @@
+begin
+  require 'bdb'
+rescue LoadError
+  puts "You need bdb gem to use Bdb moneta store"
+  exit
+end
+
+module Moneta
+
+  class Berkeley
+    include Defaults
+
+    def initialize(options={})
+      file = @file = options[:file]
+      @db = Bdb::Db.new()
+      @db.open(nil, file, nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)
+      unless options[:skip_expires]
+        @expiration = Moneta::Berkeley.new(:file => "#{file}_expiration", :skip_expires => true )
+        self.extend(StringExpires)
+      end
+    end
+    
+    module Implementation
+      def key?(key)
+        nil | self[key]
+      end
+
+      alias has_key? key?
+
+      def []=(key,value)
+        @db[key] = value
+      end
+
+      def [](key)
+        @db[key]
+      end
+
+      def delete(key)
+        value = self[key]
+        @db.del(nil,key,0) if value
+        value
+      end
+
+      def clear
+        @db.truncate(nil)
+      end
+    end
+
+    include Implementation
+
+  end
+
+end

data/lib/moneta/couch.rb

@@ -0,0 +1,63 @@
+begin
+  require "couchrest"
+rescue LoadError
+  puts "You need the couchrest gem to use the CouchDB store"
+  exit
+end
+
+module Moneta
+  class Couch
+    include Defaults
+    
+    def initialize(options = {})
+      @db = ::CouchRest.database!(options[:db])
+      unless options[:skip_expires]
+        @expiration = Moneta::Couch.new(:db => "#{options[:db]}_expiration", :skip_expires => true)
+        self.extend(StringExpires)
+      end
+    end
+
+    def key?(key)
+      !self[key].nil?
+    rescue RestClient::ResourceNotFound
+      false
+    end
+
+    alias has_key? key?
+
+    def [](key)
+      @db.get(key)["data"]
+    rescue RestClient::ResourceNotFound
+      nil
+    end
+
+    def []=(key, value)
+      @db.save_doc("_id" => key, :data => value)
+    rescue RestClient::RequestFailed
+      self[key]
+    end
+
+    def delete(key)
+      value = @db.get(key)
+      @db.delete_doc({"_id" => value["_id"], "_rev" => value["_rev"]}) if value
+      value["data"]
+    rescue RestClient::ResourceNotFound
+      nil
+    end
+
+    def update_key(key, options = {})
+      val = self[key]
+      self.store(key, val, options)
+    rescue RestClient::ResourceNotFound
+      nil
+    end
+
+    def clear
+      @db.recreate!
+    end
+
+    def delete_store
+      @db.delete!
+    end
+  end
+end

data/lib/moneta/lmc.rb

@@ -0,0 +1,52 @@
+begin
+  require "localmemcache"
+rescue LoadError
+  puts "You need the localmemcache gem to use the LMC moneta store"
+  exit
+end
+
+module Moneta
+  class Expiration
+    def initialize(hash)
+      @hash = hash
+    end
+    
+    def [](key)         @hash["#{key}__!__expiration"]          end
+    def []=(key, value) @hash["#{key}__!__expiration"] = value  end
+      
+    def delete(key)
+      key = "#{key}__!__expiration"
+      value = @hash[key]
+      @hash.delete(key)
+      value
+    end
+  end
+  
+  class LMC
+    include Defaults
+
+    module Implementation
+      def initialize(options = {})
+        @hash = LocalMemCache.new(:filename => options[:filename])
+        @expiration = Expiration.new(@hash)
+      end    
+
+      def [](key)         @hash[key]          end
+      def []=(key, value) @hash[key] = value  end
+      def clear()         @hash.clear         end
+
+      def key?(key)
+        @hash.keys.include?(key)
+      end
+
+      def delete(key)
+        value = @hash[key]
+        @hash.delete(key)
+        value
+      end      
+    end
+    include Implementation
+    include StringExpires
+   
+  end
+end

data/lib/moneta/mongodb.rb

@@ -0,0 +1,58 @@
+begin
+  require "mongo"
+rescue LoadError
+  puts "You need the mongo gem to use the MongoDB moneta store"
+  exit
+end
+
+module Moneta
+  class MongoDB
+    include Defaults
+    
+    def initialize(options = {})
+      options = {
+        :host => ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
+        :port => ENV['MONGO_RUBY_DRIVER_PORT'] || XGen::Mongo::Driver::Mongo::DEFAULT_PORT,
+        :db => 'cache',
+        :collection => 'cache'
+      }.update(options)
+      conn = XGen::Mongo::Driver::Mongo.new(options[:host], options[:port])
+      @cache = conn.db(options[:db]).collection(options[:collection])
+    end
+
+    def key?(key)
+      !!self[key]
+    end
+
+    def [](key)
+      res = @cache.find_first('_id' => key)
+      res = nil if res && res['expires'] && Time.now > res['expires']
+      res && res['data']
+    end
+
+    def []=(key, value)
+      store(key, value)
+    end
+
+    def delete(key)
+      value = self[key]
+      @cache.remove('_id' => key) if value
+      value
+    end
+
+    def store(key, value, options = {})
+      exp = options[:expires_in] ? (Time.now + options[:expires_in]) : nil
+      @cache.repsert({ '_id' => key }, { '_id' => key, 'data' => value, 'expires' => exp })
+    end
+
+    def update_key(key, options = {})
+      val = self[key]
+      self.store(key, val, options)
+    end
+
+    def clear
+      @cache.clear
+    end
+  end
+end
+

data/lib/moneta/redis.rb

@@ -0,0 +1,49 @@
+begin
+  require "redis"
+rescue LoadError
+  puts "You need the redis gem to use the Redis store"
+  exit
+end
+
+module Moneta
+  class Redis
+    include Defaults
+    
+    def initialize(options = {})
+      @cache = ::Redis.new(options)
+    end
+    
+    def key?(key)
+      !@cache[key].nil?
+    end
+    
+    alias has_key? key?
+    
+    def [](key)
+      @cache.get(key)
+    end
+    
+    def []=(key, value)
+      store(key, value)
+    end
+        
+    def delete(key)
+      value = @cache[key]
+      @cache.delete(key) if value
+      value
+    end
+    
+    def store(key, value, options = {})
+      @cache.set(key, value, options[:expires_in])
+    end
+    
+    def update_key(key, options = {})
+      val = @cache[key]
+      self.store(key, val, options)
+    end
+    
+    def clear
+      @cache.flush_db
+    end
+  end
+end

data/lib/moneta/rufus.rb

@@ -0,0 +1,41 @@
+begin
+  require "rufus/tokyo"
+rescue LoadError
+  puts "You need the rufus gem to use the Rufus moneta store"
+  exit
+end
+
+module Moneta
+  class BasicRufus < ::Rufus::Tokyo::Cabinet 
+    include Defaults
+       
+    def initialize(options = {})
+      file = options[:file]
+      super("#{file}.tch")
+    end
+    
+    def key?(key)
+      !!self[key]
+    end
+    
+    def [](key)
+      if val = super
+        Marshal.load(val.unpack("m")[0])
+      end
+    end
+    
+    def []=(key, value)
+      super(key, [Marshal.dump(value)].pack("m"))
+    end    
+  end
+  
+  class Rufus < BasicRufus
+    include Expires
+    
+    def initialize(options = {})
+      file = options[:file]
+      @expiration = BasicRufus.new(:file => "#{file}_expires")
+      super
+    end
+  end
+end

data/lib/moneta/s3.rb

@@ -0,0 +1,162 @@
+begin
+  require "right_aws"
+rescue LoadError
+  puts "You need the RightScale AWS gem to use the S3 moneta store"
+  exit  
+end
+
+module Moneta
+  # An S3 implementation of Moneta
+  #
+  # Example usage:
+  #
+  #   require 'rubygems'
+  #   require 'moneta'
+  #   require 'moneta/s3'
+  #
+  #   store = Moneta::S3.new(
+  #     :access_key_id => 'ACCESS_KEY_ID', 
+  #     :secret_access_key => 'SECRET_ACCESS_KEY', 
+  #     :bucket => 'a_bucket'
+  #   )
+  #   store['somefile'] 
+  class S3
+    # Initialize the Moneta::S3 store.
+    #
+    # Required values passed in the options hash:
+    # * <tt>:access_key_id</tt>: The access id key
+    # * <tt>:secret_access_key</tt>: The secret key
+    # * <tt>:bucket</tt>: The name of bucket. Will be created if it doesn't
+    # exist.
+    # * <tt>:multi_thread</tt>: Set to true if using threading
+    def initialize(options = {})
+      validate_options(options)
+      s3 = RightAws::S3.new(
+        options[:access_key_id], 
+        options[:secret_access_key], 
+        {
+          :logger => logger, 
+          :multi_thread => options.delete(:multi_thread) || false
+        }
+      )
+      @bucket = s3.bucket(options.delete(:bucket), true)
+    end
+    
+    def key?(key)
+      !s3_key(key).nil?
+    end
+    
+    alias has_key? key?
+    
+    def [](key)
+      get(key)
+    end
+    
+    def []=(key, value)
+      store(key, value)
+    end
+        
+    def delete(key)
+      k = s3_key(key)
+      if k
+        value = k.get
+        k.delete
+        value
+      end
+    end
+    
+    # Store the key/value pair.
+    # 
+    # Options:
+    # *<tt>:meta_headers</tt>: Meta headers passed to S3
+    # *<tt>:perms</tt>: Permissions passed to S3
+    # *<tt>:headers</tt>: Headers sent as part of the PUT request
+    # *<tt>:expires_in</tt>: Number of seconds until expiration
+    def store(key, value, options = {})
+      debug "store(key=#{key}, value=#{value}, options=#{options.inspect})"
+      meta_headers = meta_headers_from_options(options)
+      perms = options[:perms]
+      headers = options[:headers] || {}
+      
+      case value
+      when IO
+        @bucket.put(key, value.read, meta_headers, perms, headers)
+      else
+        @bucket.put(key, value, meta_headers, perms, headers)
+      end
+    end
+    
+    def update_key(key, options = {})
+      debug "update_key(key=#{key}, options=#{options.inspect})"
+      k = s3_key(key, false)
+      k.save_meta(meta_headers_from_options(options)) unless k.nil?
+    end
+    
+    def clear
+      @bucket.clear
+    end
+    
+    protected
+    def logger
+      @logger ||= begin
+        logger = Logger.new(STDOUT)
+        logger.level = Logger::FATAL
+        logger
+      end
+    end
+    
+    private
+    def validate_options(options)
+      unless options[:access_key_id]
+        raise RuntimeError, ":access_key_id is required in options"
+      end
+      unless options[:secret_access_key]
+        raise RuntimeError, ":secret_access_key is required in options"
+      end
+      unless options[:bucket]
+        raise RuntimeError, ":bucket is required in options"
+      end
+    end
+    
+    def get(key)
+      k = s3_key(key)
+      k.nil? ? nil : k.get
+    end
+    
+    def s3_key(key, nil_if_expired=true)
+      begin
+        s3_key = @bucket.key(key, true)
+        if s3_key.exists?
+          logger.debug "[Moneta::S3] key exists: #{key}"
+          if s3_key.meta_headers.has_key?('expires-at')
+            expires_at = Time.parse(s3_key.meta_headers['expires-at'])
+            if Time.now > expires_at && nil_if_expired
+              # TODO delete the object?
+              debug "key expired: #{key} (@#{s3_key.meta_headers['expires-at']})"
+              return nil
+            end
+          end
+          return s3_key
+        else
+          debug "key does not exist: #{key}"
+        end
+      rescue RightAws::AwsError => e
+        debug "key does not exist: #{key}"
+      end
+      nil
+    end
+    
+    def meta_headers_from_options(options={})
+      meta_headers = options[:meta_headers] || {}
+      if options[:expires_in]
+        meta_headers['expires-at'] = (Time.now + options[:expires_in]).rfc2822
+      end
+      debug "setting expires-at: #{meta_headers['expires-at']}"
+      meta_headers
+    end
+    
+    def debug(message)
+      logger.debug "[Moneta::S3] #{message}"
+    end
+  end
+end

data/lib/moneta/sdbm.rb

@@ -0,0 +1,33 @@
+require "sdbm"
+
+module Moneta
+  class BasicSDBM < ::SDBM
+    include Defaults
+
+    def [](key)
+      if val = super
+        Marshal.load(val)
+      end
+    end
+
+    def []=(key, value)
+      super(key, Marshal.dump(value))
+    end
+
+    def delete(key)
+      if val = super
+        Marshal.load(val)
+      end
+    end
+  end
+
+  class SDBM < BasicSDBM
+    include Expires
+
+    def initialize(options = {})
+      raise "No :file option specified" unless file = options[:file]
+      @expiration = BasicSDBM.new("#{file}_expires")
+      super(file)
+    end
+  end
+end

data/lib/moneta/tyrant.rb

@@ -0,0 +1,58 @@
+begin
+  require "rufus/tokyo/tyrant"
+rescue LoadError
+  puts "You need the rufus gem to use the Tyrant moneta store"
+  exit
+end
+
+module Moneta
+  class Tyrant < ::Rufus::Tokyo::Tyrant
+    include Defaults
+    
+    module Implementation
+      def initialize(options = {})
+        host = options[:host]
+        port = options[:port]
+        super(host, port)
+      end      
+      
+      def key?(key)
+        !!self[key]
+      end
+    
+      def [](key)
+        if val = super
+          Marshal.load(val.unpack("m")[0])
+        end
+      end
+    
+      def []=(key, value)
+        super(key, [Marshal.dump(value)].pack("m"))
+      end    
+    end
+    
+    include Implementation
+    include Expires
+    
+    def initialize(options = {})
+      super
+      @expiration = Expiration.new(options)
+    end
+    
+    class Expiration < ::Rufus::Tokyo::Tyrant
+      include Implementation
+      
+      def [](key)
+        super("#{key}__expiration")
+      end
+      
+      def []=(key, value)
+        super("#{key}__expiration", value)
+      end
+      
+      def delete(key)
+        super("#{key}__expiration")
+      end
+    end
+  end  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: benschwarz-moneta
 version: !ruby/object:Gem::Version 
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors: 
 - Yehuda Katz
@@ -9,7 +9,7 @@ autorequire: moneta
 bindir: bin
 cert_chain: []
 
-date: 2009-02-12 00:00:00 -08:00
+date: 2009-08-25 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -29,13 +29,23 @@ files:
 - Rakefile
 - TODO
 - lib/moneta
+- lib/moneta/basic_file.rb
+- lib/moneta/berkeley.rb
+- lib/moneta/couch.rb
 - lib/moneta/datamapper.rb
 - lib/moneta/file.rb
+- lib/moneta/lmc.rb
 - lib/moneta/memcache.rb
 - lib/moneta/memory.rb
+- lib/moneta/mongodb.rb
+- lib/moneta/redis.rb
+- lib/moneta/rufus.rb
+- lib/moneta/s3.rb
+- lib/moneta/sdbm.rb
+- lib/moneta/tyrant.rb
 - lib/moneta/xattr.rb
 - lib/moneta.rb
-has_rdoc: true
+has_rdoc: false
 homepage: http://www.yehudakatz.com
 licenses: 
 post_install_message: 
@@ -60,7 +70,7 @@ requirements: []
 rubyforge_project: 
 rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: A unified interface to key/value stores
 test_files: []