moneta 0.7.3 → 0.7.4

data/lib/moneta.rb

@@ -2,6 +2,7 @@ module Moneta
   autoload :Builder,           'moneta/builder'
   autoload :Cache,             'moneta/cache'
   autoload :Defaults,          'moneta/mixins'
+  autoload :ExpiresSupport,    'moneta/mixins'
   autoload :Expires,           'moneta/expires'
   autoload :HashAdapter,       'moneta/mixins'
   autoload :IncrementSupport,  'moneta/mixins'
@@ -10,6 +11,7 @@ module Moneta
   autoload :Net,               'moneta/mixins'
   autoload :OptionMerger,      'moneta/optionmerger'
   autoload :OptionSupport,     'moneta/mixins'
+  autoload :Pool,              'moneta/pool'
   autoload :Proxy,             'moneta/proxy'
   autoload :Server,            'moneta/server'
   autoload :Shared,            'moneta/shared'
@@ -23,6 +25,7 @@ module Moneta
     autoload :Client,          'moneta/adapters/client'
     autoload :Cookie,          'moneta/adapters/cookie'
     autoload :Couch,           'moneta/adapters/couch'
+    autoload :Daybreak,        'moneta/adapters/daybreak'
     autoload :DBM,             'moneta/adapters/dbm'
     autoload :DataMapper,      'moneta/adapters/datamapper'
     autoload :File,            'moneta/adapters/file'
@@ -45,6 +48,7 @@ module Moneta
     autoload :SDBM,            'moneta/adapters/sdbm'
     autoload :Sequel,          'moneta/adapters/sequel'
     autoload :Sqlite,          'moneta/adapters/sqlite'
+    autoload :TDB,             'moneta/adapters/tdb'
     autoload :TokyoCabinet,    'moneta/adapters/tokyocabinet'
     autoload :YAML,            'moneta/adapters/yaml'
   end
@@ -98,10 +102,6 @@ module Moneta
       # Riak accepts only utf-8 keys over the http interface
       # We use base64 encoding therefore.
       transformer[:key] << :base64
-    when :Memcached, :MemcachedDalli, :MemcachedNative
-      # Memcached supports expires already
-      options[:expires] = expires if Integer === expires
-      expires = false
     when :PStore, :YAML, :Null
       # For PStore and YAML only the key has to be a string
       transformer.delete(:value) if transformer[:value] == [:marshal]
@@ -112,7 +112,7 @@ module Moneta
     when :File
       # Use escaping
       transformer[:key] << :escape
-    when :Cassandra, :Redis
+    when :Cassandra, :Redis, :Mongo, :Memcached, :MemcachedDalli, :MemcachedNative
       # Expires already supported
       options[:expires] = expires if Integer === expires
       expires = false

data/lib/moneta/adapters/activerecord.rb

@@ -6,6 +6,7 @@ module Moneta
     # @api public
     class ActiveRecord
       include Defaults
+      include IncrementSupport
 
       def self.tables
         @tables ||= {}
@@ -66,13 +67,10 @@ module Moneta
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         record = @table.where(:k => key).lock.first_or_initialize
-        value = record.v
-        intvalue = value.to_i
-        raise 'Tried to increment non integer value' unless value == nil || intvalue.to_s == value.to_s
-        intvalue += amount
-        record.v = intvalue.to_s
+        value = convert_for_increment(record.v) + amount
+        record.v = value.to_s
         record.save
-        intvalue
+        value
       end
 
       # (see Proxy#clear)

data/lib/moneta/adapters/cassandra.rb

@@ -9,6 +9,7 @@ module Moneta
     # @api public
     class Cassandra
       include Defaults
+      include ExpiresSupport
 
       # @param [Hash] options
       # @option options [String] :keyspace ('moneta') Cassandra keyspace
@@ -19,7 +20,7 @@ module Moneta
       def initialize(options = {})
         options[:host] ||= '127.0.0.1'
         options[:port] ||=  9160
-        @expires = options[:expires]
+        self.default_expires = options[:expires]
         keyspace = (options[:keyspace] ||= 'moneta')
         @cf = (options[:column_family] || 'moneta').to_sym
         @client = ::Cassandra.new('system', "#{options[:host]}:#{options[:port]}")
@@ -35,7 +36,7 @@ module Moneta
             begin
               @client.add_keyspace(ks_def)
             rescue Exception => ex
-              puts "Cassandra: #{ex.message}"
+              warn "Cassandra: #{ex.message}"
             end
             break if @client.keyspaces.include?(keyspace)
             sleep 0.1
@@ -47,9 +48,7 @@ module Moneta
       # (see Proxy#key?)
       def key?(key, options = {})
         if @client.exists?(@cf, key)
-          if options.include?(:expires) && (value = load(key))
-            store(key, value, options)
-          end
+          load(key, options) if options.include?(:expires)
           true
         else
           false
@@ -60,17 +59,15 @@ module Moneta
       def load(key, options = {})
         value = @client.get(@cf, key)
         if value
-          if options.include?(:expires)
-            store(key, value['value'], options)
-          else
-            value['value']
-          end
+          expires = expires_value(options, nil)
+          @client.insert(@cf, key, {'value' => value['value'] }, :ttl => expires || nil) if expires != nil
+          value['value']
         end
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        @client.insert(@cf, key, {'value' => value}, :ttl => (options[:expires] || @expires))
+        @client.insert(@cf, key, {'value' => value}, :ttl => expires_value(options) || nil)
         value
       end
 

data/lib/moneta/adapters/couch.rb

@@ -8,10 +8,12 @@ module Moneta
       include Defaults
 
       # @param [Hash] options
+      # @option options [String] :host ('http://127.0.0.1:5984') Couch host
       # @option options [String] :db ('moneta') Couch database
       def initialize(options = {})
         options[:db] ||= 'moneta'
-        @db = ::CouchRest.database!(options[:db])
+        options[:host] ||= '127.0.0.1:5984'
+        @db = CouchRest.new(options[:host]).database!(options[:db])
       end
 
       # (see Proxy#key?)

data/lib/moneta/adapters/daybreak.rb

@@ -0,0 +1,28 @@
+require 'daybreak'
+
+module Moneta
+  module Adapters
+    # Daybreak backend
+    # @api public
+    class Daybreak < Memory
+      # Disable serialization, we have `Moneta::Transformer` for that
+      class DB < ::Daybreak::DB
+        def serialize(value) value; end
+        def parse(value) value; end
+      end
+
+      # @param [Hash] options
+      # @option options [String] :file Database file
+      def initialize(options = {})
+        raise ArgumentError, 'Option :file is required' unless options[:file]
+        @hash = DB.new(options[:file])
+      end
+
+      # (see Proxy#close)
+      def close
+        @hash.close!
+        nil
+      end
+    end
+  end
+end

data/lib/moneta/adapters/fog.rb

@@ -1,4 +1,4 @@
-require 'fog'
+require 'fog/storage'
 
 module Moneta
   module Adapters
@@ -13,7 +13,7 @@ module Moneta
       def initialize(options = {})
         raise ArgumentError, 'Option :dir is required' unless dir = options.delete(:dir)
         storage = ::Fog::Storage.new(options)
-        @directory = storage.directories.create(:key => dir)
+        @directory = storage.directories.get(dir) || storage.directories.create(:key => dir)
       end
 
       # (see Proxy#key?)
@@ -38,7 +38,7 @@ module Moneta
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        @directory.files.create(:key => key, :body => value)
+        @directory.files.create(options.merge(:key => key, :body => value))
         value
       end
 

data/lib/moneta/adapters/hbase.rb

@@ -6,6 +6,7 @@ module Moneta
     # @api public
     class HBase
       include Defaults
+      include IncrementSupport
 
       # @param [Hash] options
       # @option options [String] :host ('127.0.0.1') Server host name
@@ -46,10 +47,7 @@ module Moneta
       def increment(key, amount = 1, options = {})
         result = @table.atomic_increment(key, @column, amount)
         # HACK: Throw error if applied to invalid value
-        if result == 0
-          value = load(key)
-          raise 'Tried to increment non integer value' unless value.to_s == value.to_i.to_s
-        end
+        convert_for_increment(load(key)) if result == 0
         result
       end
 

data/lib/moneta/adapters/memcached/dalli.rb

@@ -6,13 +6,14 @@ module Moneta
     # @api public
     class MemcachedDalli
       include Defaults
+      include ExpiresSupport
 
       # @param [Hash] options
       # @option options [String] :server ('127.0.0.1:11211') Memcached server
       # @option options [Integer] :expires Default expiration time
       # @option options Other options passed to `Dalli::Client#new`
       def initialize(options = {})
-        options[:expires_in] = options.delete(:expires)
+        self.default_expires = options.delete(:expires)
         server = options.delete(:server) || '127.0.0.1:11211'
         @cache = ::Dalli::Client.new(server, options)
       end
@@ -20,16 +21,16 @@ module Moneta
       # (see Proxy#load)
       def load(key, options = {})
         value = @cache.get(key)
-        if value && options.include?(:expires)
-          store(key, value, options)
-        else
+        if value
+          expires = expires_value(options, nil)
+          @cache.set(key, value, expires || nil, :raw => true) if expires != nil
           value
         end
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        @cache.set(key, value, options[:expires], :raw => true)
+        @cache.set(key, value, expires_value(options) || nil, :raw => true)
         value
       end
 
@@ -45,9 +46,9 @@ module Moneta
         # FIXME: There is a Dalli bug, load(key) returns a wrong value after increment
         # therefore we set default = nil and create the counter manually
         result = if amount >= 0
-                   @cache.incr(key, amount, options[:expires], nil)
+                   @cache.incr(key, amount, expires_value(options) || nil, nil)
                  else
-                   @cache.decr(key, -amount, options[:expires], nil)
+                   @cache.decr(key, -amount, expires_value(options) || nil, nil)
                  end
         if result
           result

data/lib/moneta/adapters/memcached/native.rb

@@ -6,6 +6,8 @@ module Moneta
     # @api public
     class MemcachedNative
       include Defaults
+      include IncrementSupport
+      include ExpiresSupport
 
       # @param [Hash] options
       # @option options [String] :server ('127.0.0.1:11211') Memcached server
@@ -14,7 +16,7 @@ module Moneta
       # @option options Other options passed to `Memcached#new`
       def initialize(options = {})
         server = options.delete(:server) || '127.0.0.1:11211'
-        @expires = options.delete(:expires) || 604800
+        self.default_expires = options.delete(:expires)
         options.merge!(:prefix_key => options.delete(:namespace)) if options[:namespace]
         # We don't want a limitation on the key charset. Therefore we use the binary protocol.
         # It is also faster.
@@ -25,9 +27,9 @@ module Moneta
       # (see Proxy#load)
       def load(key, options = {})
         value = @cache.get(key, false)
-        if value && options.include?(:expires)
-          store(key, value, options)
-        else
+        if value
+          expires = expires_value(options, nil)
+          @cache.set(key, value, expires || 0, false) if expires != nil
           value
         end
       rescue ::Memcached::NotFound
@@ -36,7 +38,7 @@ module Moneta
       # (see Proxy#store)
       def store(key, value, options = {})
         # TTL must be Fixnum
-        @cache.set(key, value, options[:expires] || @expires, false)
+        @cache.set(key, value, expires_value(options) || 0, false)
         value
       end
 
@@ -56,10 +58,7 @@ module Moneta
           @cache.decrement(key, -amount)
         end
         # HACK: Throw error if applied to invalid value
-        if result == 0
-          value = @cache.get(key, false) rescue nil
-          raise 'Tried to increment non integer value' unless value.to_s == value.to_i.to_s
-        end
+        convert_for_increment((@cache.get(key, false) rescue nil)) if result == 0
         result
       rescue ::Memcached::NotFound => ex
         store(key, amount.to_s, options)

data/lib/moneta/adapters/mongo.rb

@@ -3,28 +3,60 @@ require 'mongo'
 module Moneta
   module Adapters
     # MongoDB backend
+    #
+    # Supports expiration, documents will be automatically removed starting
+    # with mongodb >= 2.2 (see http://docs.mongodb.org/manual/tutorial/expire-data/).
+    #
     # @api public
     class Mongo
       include Defaults
+      include ExpiresSupport
 
       # @param [Hash] options
       # @option options [String] :collection ('moneta') MongoDB collection name
       # @option options [String] :host ('127.0.0.1') MongoDB server host
       # @option options [Integer] :port (MongoDB default port) MongoDB server port
       # @option options [String] :db ('moneta') MongoDB database
+      # @option options [Integer] :expires Default expiration time
       def initialize(options = {})
+        self.default_expires = options.delete(:expires)
         collection = options.delete(:collection) || 'moneta'
         host = options.delete(:host) || '127.0.0.1'
-        port = options.delete(:port) || ::Mongo::Connection::DEFAULT_PORT
+        port = options.delete(:port) || ::Mongo::MongoClient::DEFAULT_PORT
         db = options.delete(:db) || 'moneta'
-        connection = ::Mongo::Connection.new(host, port, options)
+        connection = ::Mongo::MongoClient.new(host, port, options)
         @collection = connection.db(db).collection(collection)
+        if connection.server_version >= '2.2'
+          @collection.ensure_index([['expiresAt', ::Mongo::ASCENDING]], :expireAfterSeconds => 0)
+        else
+          warn 'You are using MongoDB version < 2.2, expired documents will not be deleted'
+        end
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        value = @collection.find_one('_id' => ::BSON::Binary.new(key))
-        value && value['value'].to_s
+        key = ::BSON::Binary.new(key)
+        doc = @collection.find_one('_id' => key)
+        if doc && (!doc['expiresAt'] || doc['expiresAt'] >= Time.now)
+          expires = expires_at(options, nil)
+          @collection.update({ '_id' => key },
+                             # expiresAt must be a Time object (BSON date datatype)
+                             { '$set' => { 'expiresAt' => expires || nil } }) if expires != nil
+          doc['value'].to_s
+        end
+      end
+
+      # (see Proxy#store)
+      def store(key, value, options = {})
+        key = ::BSON::Binary.new(key)
+        intvalue = value.to_i
+        @collection.update({ '_id' => key },
+                           { '_id' => key,
+                             'value' => intvalue.to_s == value ? intvalue : ::BSON::Binary.new(value),
+                             # expiresAt must be a Time object (BSON date datatype)
+                             'expiresAt' => expires_at(options) || nil },
+                           { :upsert => true })
+        value
       end
 
       # (see Proxy#delete)
@@ -34,13 +66,12 @@ module Moneta
         value
       end
 
-      # (see Proxy#store)
-      def store(key, value, options = {})
-        key = ::BSON::Binary.new(key)
-        @collection.update({ '_id' => key },
-                           { '_id' => key, 'value' => ::BSON::Binary.new(value) },
-                           { :upsert => true })
-        value
+      # (see Proxy#increment)
+      def increment(key, amount = 1, options = {})
+        @collection.find_and_modify(:query => { '_id' => ::BSON::Binary.new(key) },
+                                    :update => { '$inc' => { 'value' => amount } },
+                                    :new => true,
+                                    :upsert => true)['value']
       end
 
       # (see Proxy#clear)

data/lib/moneta/adapters/pstore.rb

@@ -6,6 +6,7 @@ module Moneta
     # @api public
     class PStore
       include Defaults
+      include IncrementSupport
 
       # @param [Hash] options
       # @option options [String] :file PStore file
@@ -38,12 +39,9 @@ module Moneta
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         @pstore.transaction do
-          value = @pstore[key]
-          intvalue = value.to_i
-          raise 'Tried to increment non integer value' unless value == nil || intvalue.to_s == value.to_s
-          intvalue += amount
-          @pstore[key] = intvalue.to_s
-          intvalue
+          value = convert_for_increment(@pstore[key]) + amount
+          @pstore[key] = value.to_s
+          value
         end
       end
 

data/lib/moneta/adapters/redis.rb

@@ -6,21 +6,20 @@ module Moneta
     # @api public
     class Redis
       include Defaults
+      include ExpiresSupport
 
       # @param [Hash] options
       # @option options [Integer] :expires Default expiration time
       # @option options Other options passed to `Redis#new`
       def initialize(options = {})
-        @expires = options.delete(:expires)
+        self.default_expires = options.delete(:expires)
         @redis = ::Redis.new(options)
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
         if @redis.exists(key)
-          if expires = options[:expires]
-            @redis.expire(key, expires)
-          end
+          update_expires(key, options, nil)
           true
         else
           false
@@ -30,15 +29,13 @@ module Moneta
       # (see Proxy#load)
       def load(key, options = {})
         value = @redis.get(key)
-        if value && (expires = options[:expires])
-          @redis.expire(key, expires)
-        end
+        update_expires(key, options, nil)
         value
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        if expires = (options[:expires] || @expires)
+        if expires = expires_value(options)
           @redis.setex(key, expires, value)
         else
           @redis.set(key, value)
@@ -57,8 +54,7 @@ module Moneta
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         value = @redis.incrby(key, amount)
-        expires = (options[:expires] || @expires)
-        @redis.expire(key, expires) if expires
+        update_expires(key, options)
         value
       end
 
@@ -67,6 +63,17 @@ module Moneta
         @redis.flushdb
         self
       end
+
+      protected
+
+      def update_expires(key, options, default = @default_expires)
+        case expires = expires_value(options, default)
+        when false
+          @redis.persist(key)
+        when Numeric
+          @redis.expire(key, expires)
+        end
+      end
     end
   end
 end