moneta 1.3.0 → 1.4.0

data/lib/moneta/adapters/mongo/base.rb

@@ -1,103 +0,0 @@
-require 'bson'
-
-module Moneta
-  module Adapters
-    # @api private
-    class MongoBase
-      include Defaults
-      include ExpiresSupport
-
-      supports :each_key, :create, :increment
-      attr_reader :backend
-
-      DEFAULT_PORT = 27017
-
-      def initialize(options = {})
-        self.default_expires = options.delete(:expires)
-        @expires_field = options.delete(:expires_field) || 'expiresAt'
-        @value_field = options.delete(:value_field) || 'value'
-        @type_field = options.delete(:type_field) || 'type'
-      end
-
-      # (see Proxy#fetch_values)
-      def fetch_values(*keys, **options)
-        return values_at(*keys, **options) unless block_given?
-        hash = Hash[slice(*keys, **options)]
-        keys.map do |key|
-          if hash.key?(key)
-            hash[key]
-          else
-            yield key
-          end
-        end
-      end
-
-      # (see Proxy#values_at)
-      def values_at(*keys, **options)
-        hash = Hash[slice(*keys, **options)]
-        keys.map { |key| hash[key] }
-      end
-
-      protected
-
-      def doc_to_value(doc)
-        case doc[@type_field]
-        when 'Hash'
-          doc = doc.dup
-          doc.delete('_id')
-          doc.delete(@type_field)
-          doc.delete(@expires_field)
-          doc
-        when 'Number'
-          doc[@value_field]
-        else
-          # In ruby_bson version 2 (and probably up), #to_s no longer returns the binary data
-          from_binary(doc[@value_field])
-        end
-      end
-
-      def value_to_doc(key, value, options)
-        case value
-        when Hash
-          value.merge('_id' => key,
-                      @type_field => 'Hash',
-                      # @expires_field must be a Time object (BSON date datatype)
-                      @expires_field => expires_at(options) || nil)
-        when Float, Integer
-          { '_id' => key,
-            @type_field => 'Number',
-            @value_field => value,
-            # @expires_field must be a Time object (BSON date datatype)
-            @expires_field => expires_at(options) || nil }
-        when String
-          intvalue = value.to_i
-          { '_id' => key,
-            @type_field => 'String',
-            @value_field => intvalue.to_s == value ? intvalue : to_binary(value),
-            # @expires_field must be a Time object (BSON date datatype)
-            @expires_field => expires_at(options) || nil }
-        else
-          raise ArgumentError, "Invalid value type: #{value.class}"
-        end
-      end
-
-      # BSON will use String#force_encoding to make the string 8-bit
-      # ASCII.  This could break unicode text so we should dup in this
-      # case, and it also fails with frozen strings.
-      def to_binary(str)
-        str = str.dup if str.frozen? || str.encoding != Encoding::ASCII_8BIT
-        ::BSON::Binary.new(str)
-      end
-
-      if defined?(::BSON::VERSION) and ::BSON::VERSION[0].to_i >= 2
-        def from_binary(binary)
-          binary.is_a?(::BSON::Binary) ? binary.data : binary.to_s
-        end
-      else
-        def from_binary(binary)
-          binary.to_s
-        end
-      end
-    end
-  end
-end

data/lib/moneta/adapters/mongo/moped.rb

@@ -1,166 +0,0 @@
-require 'moneta/adapters/mongo/base'
-require 'moped'
-
-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/}).
-    #
-    # You can store hashes directly using this adapter.
-    #
-    # @example Store hashes
-    #     db = Moneta::Adapters::MongoMoped.new
-    #     db['key'] = {a: 1, b: 2}
-    #
-    # @api public
-    class MongoMoped < MongoBase
-      # @param [Hash] options
-      # @option options [String] :collection ('moneta') MongoDB collection name
-      # @option options [String] :host ('127.0.0.1') MongoDB server host
-      # @option options [String] :user Username used to authenticate
-      # @option options [String] :password Password used to authenticate
-      # @option options [Integer] :port (MongoDB default port) MongoDB server port
-      # @option options [String] :db ('moneta') MongoDB database
-      # @option options [Integer] :expires Default expiration time
-      # @option options [String] :expires_field ('expiresAt') Document field to store expiration time
-      # @option options [String] :value_field ('value') Document field to store value
-      # @option options [String] :type_field ('type') Document field to store value type
-      # @option options [::Moped::Session] :backend Use existing backend instance
-      # @option options Other options passed to `Moped::Session#new`
-      def initialize(options = {})
-        super(options)
-        collection = options.delete(:collection) || 'moneta'
-        db = options.delete(:db) || 'moneta'
-        user = options.delete(:user)
-        password = options.delete(:password)
-        @backend = options[:backend] ||
-          begin
-            host = options.delete(:host) || '127.0.0.1'
-            port = options.delete(:port) || DEFAULT_PORT
-            ::Moped::Session.new(["#{host}:#{port}"])
-          end
-        @backend.use(db)
-        @backend.login(user, password) if user && password
-        @collection = @backend[collection]
-        if @backend.command(buildinfo: 1)['version'] >= '3.0'
-          # Moped creates indexes in the system.indexes collection which is not writable anymore since Mongo v3
-          warn 'Moneta::Adapters::MongoMoped - You are using the unmaintained Moped gem, expired documents will not be deleted'
-        elsif @backend.command(buildinfo: 1)['version'] >= '2.2'
-          @collection.indexes.create({ @expires_field => 1 }, expireAfterSeconds: 0)
-        else
-          warn 'Moneta::Adapters::Mongo - You are using MongoDB version < 2.2, expired documents will not be deleted'
-        end
-      end
-
-      # (see Proxy#load)
-      def load(key, options = {})
-        key = to_binary(key)
-        doc = @collection.find(_id: key).one
-        if doc && (!doc[@expires_field] || doc[@expires_field] >= Time.now)
-          # @expires_field must be a Time object (BSON date datatype)
-          expires = expires_at(options, nil)
-          @collection.find(_id: key).update(:$set => { @expires_field => expires || nil }) if expires != nil
-          doc_to_value(doc)
-        end
-      end
-
-      # (see Proxy#store)
-      def store(key, value, options = {})
-        key = to_binary(key)
-        @collection.find(_id: key).upsert(value_to_doc(key, value, options))
-        value
-      end
-
-      # (see Proxy#each_key)
-      def each_key
-        return enum_for(:each_key) unless block_given?
-        @collection.find.each { |doc| yield from_binary(doc[:_id]) }
-        self
-      end
-
-      # (see Proxy#delete)
-      def delete(key, options = {})
-        value = load(key, options)
-        @collection.find(_id: to_binary(key)).remove if value
-        value
-      end
-
-      # (see Proxy#increment)
-      def increment(key, amount = 1, options = {})
-        @backend.with(safe: true, consistency: :strong) do |safe|
-          safe[@collection.name]
-            .find(_id: to_binary(key))
-            .modify({ :$inc => { @value_field => amount } },
-                    new: true, upsert: true)[@value_field]
-        end
-      rescue ::Moped::Errors::OperationFailure
-        tries ||= 0
-        tries += 1
-        retry if tries < 3
-        raise # otherwise
-      end
-
-      # (see Proxy#create)
-      def create(key, value, options = {})
-        key = to_binary(key)
-        @backend.with(safe: true, consistency: :strong) do |safe|
-          safe[@collection.name].insert(value_to_doc(key, value, options))
-        end
-        true
-      rescue ::Moped::Errors::MongoError => ex
-        raise if ex.details['code'] != 11000 # duplicate key error
-        false
-      end
-
-      # (see Proxy#clear)
-      def clear(options = {})
-        @collection.find.remove_all
-        self
-      end
-
-      # (see Proxy#slice)
-      def slice(*keys, **options)
-        query = @collection.find(_id: { :$in => keys.map(&method(:to_binary)) })
-        pairs = query.map do |doc|
-          next if doc[@expires_field] && doc[@expires_field] < Time.now
-          [from_binary(doc[:_id]), doc_to_value(doc)]
-        end.compact
-
-        if (expires = expires_at(options, nil)) != nil
-          query.update_all(:$set => { @expires_field => expires || nil })
-        end
-
-        pairs
-      end
-
-      # (see Proxy#merge!)
-      def merge!(pairs, options = {})
-        @backend.with(safe: true, consistency: :strong) do |safe|
-          collection = safe[@collection.name]
-          existing = collection
-            .find(_id: { :$in => pairs.map { |key, _| to_binary(key) }.to_a })
-            .map { |doc| [from_binary(doc[:_id]), doc_to_value(doc)] }
-            .to_h
-
-          update_pairs, insert_pairs = pairs.partition { |key, _| existing.key?(key) }
-          unless insert_pairs.empty?
-            collection.insert(insert_pairs.map do |key, value|
-              value_to_doc(to_binary(key), value, options)
-            end)
-          end
-
-          update_pairs.each do |key, value|
-            value = yield(key, existing[key], value) if block_given?
-            binary = to_binary(key)
-            collection
-              .find(_id: binary)
-              .update(value_to_doc(binary, value, options))
-          end
-        end
-        self
-      end
-    end
-  end
-end

data/lib/moneta/adapters/mongo/official.rb

@@ -1,156 +0,0 @@
-require 'moneta/adapters/mongo/base'
-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/}).
-    #
-    # You can store hashes directly using this adapter.
-    #
-    # @example Store hashes
-    #     db = Moneta::Adapters::MongoOfficial.new
-    #     db['key'] = {a: 1, b: 2}
-    #
-    # @api public
-    class MongoOfficial < MongoBase
-      # @param [Hash] options
-      # @option options [String] :collection ('moneta') MongoDB collection name
-      # @option options [String] :host ('127.0.0.1') MongoDB server host
-      # @option options [String] :user Username used to authenticate
-      # @option options [String] :password Password used to authenticate
-      # @option options [Integer] :port (MongoDB default port) MongoDB server port
-      # @option options [String] :db ('moneta') MongoDB database
-      # @option options [Integer] :expires Default expiration time
-      # @option options [String] :expires_field ('expiresAt') Document field to store expiration time
-      # @option options [String] :value_field ('value') Document field to store value
-      # @option options [String] :type_field ('type') Document field to store value type
-      # @option options [::Mongo::Client] :backend Use existing backend instance
-      # @option options Other options passed to `Mongo::MongoClient#new`
-      def initialize(options = {})
-        super(options)
-        collection = options.delete(:collection) || 'moneta'
-        db = options.delete(:db) || 'moneta'
-        @backend = options[:backend] ||
-          begin
-            host = options.delete(:host) || '127.0.0.1'
-            port = options.delete(:port) || DEFAULT_PORT
-            options[:logger] ||= ::Logger.new(STDERR).tap do |logger|
-              logger.level = ::Logger::ERROR
-            end
-            ::Mongo::Client.new(["#{host}:#{port}"], options)
-          end
-        @backend.use(db)
-        @collection = @backend[collection]
-        if @backend.command(buildinfo: 1).documents.first['version'] >= '2.2'
-          @collection.indexes.create_one({ @expires_field => 1 }, expire_after: 0)
-        else
-          warn 'Moneta::Adapters::Mongo - You are using MongoDB version < 2.2, expired documents will not be deleted'
-        end
-      end
-
-      # (see Proxy#load)
-      def load(key, options = {})
-        key = to_binary(key)
-        doc = @collection.find(_id: key).limit(1).first
-        if doc && (!doc[@expires_field] || doc[@expires_field] >= Time.now)
-          expires = expires_at(options, nil)
-          # @expires_field must be a Time object (BSON date datatype)
-          @collection.update_one({ _id: key },
-                                 '$set' => { @expires_field => expires }) unless expires == nil
-          doc_to_value(doc)
-        end
-      end
-
-      # (see Proxy#store)
-      def store(key, value, options = {})
-        key = to_binary(key)
-        @collection.replace_one({ _id: key },
-                                value_to_doc(key, value, options),
-                                upsert: true)
-        value
-      end
-
-      # (see Proxy#each_key)
-      def each_key
-        return enum_for(:each_key) unless block_given?
-        @collection.find.each { |doc| yield from_binary(doc[:_id]) }
-        self
-      end
-
-      # (see Proxy#delete)
-      def delete(key, options = {})
-        key = to_binary(key)
-        if doc = @collection.find(_id: key).find_one_and_delete and
-            !doc[@expires_field] || doc[@expires_field] >= Time.now
-          doc_to_value(doc)
-        end
-      end
-
-      # (see Proxy#increment)
-      def increment(key, amount = 1, options = {})
-        @collection.find_one_and_update({ _id: to_binary(key) },
-                                        { '$inc' => { @value_field => amount } },
-                                        return_document: :after,
-                                        upsert: true)[@value_field]
-      end
-
-      # (see Proxy#create)
-      def create(key, value, options = {})
-        key = to_binary(key)
-        @collection.insert_one(value_to_doc(key, value, options))
-        true
-      rescue ::Mongo::Error::OperationFailure => ex
-        raise unless ex.message =~ /^E11000 / # duplicate key error
-        false
-      end
-
-      # (see Proxy#clear)
-      def clear(options = {})
-        @collection.delete_many
-        self
-      end
-
-      # (see Proxy#close)
-      def close
-        @backend.close
-        nil
-      end
-
-      # (see Proxy#slice)
-      def slice(*keys, **options)
-        query = @collection.find(_id: { :$in => keys.map(&method(:to_binary)) })
-        pairs = query.map do |doc|
-          next if doc[@expires_field] && doc[@expires_field] < Time.now
-          [from_binary(doc[:_id]), doc_to_value(doc)]
-        end.compact
-
-        if (expires = expires_at(options, nil)) != nil
-          query.update_many(:$set => { @expires_field => expires || nil })
-        end
-
-        pairs
-      end
-
-      # (see Proxy#merge!)
-      def merge!(pairs, options = {})
-        existing = Hash[slice(*pairs.map { |key, _| key })]
-        update_pairs, insert_pairs = pairs.partition { |key, _| existing.key?(key) }
-
-        @collection.insert_many(insert_pairs.map do |key, value|
-          value_to_doc(to_binary(key), value, options)
-        end)
-
-        update_pairs.each do |key, value|
-          value = yield(key, existing[key], value) if block_given?
-          binary = to_binary(key)
-          @collection.replace_one({ _id: binary }, value_to_doc(binary, value, options))
-        end
-
-        self
-      end
-    end
-  end
-end

data/spec/moneta/adapters/mongo/adapter_mongo_moped_spec.rb

@@ -1,26 +0,0 @@
-describe 'adapter_mongo_moped', adapter: :Mongo do
-  let(:t_res) { 0.125 }
-  let(:min_ttl) { t_res }
-
-  moneta_build do
-    Moneta::Adapters::MongoMoped.new(mongo_config(
-      db: File.basename(__FILE__, '.rb'), collection: 'moped'
-    ))
-  end
-
-  moneta_specs ADAPTER_SPECS.with_each_key.with_native_expires.simplevalues_only
-
-  it 'automatically deletes expired document', unsupported: true do
-    store.store('key', 'val', expires: 5)
-
-    i = 0
-    query = store.instance_variable_get(:@collection).find(_id: ::BSON::Binary.new('key'))
-    while i < 70 && query.first
-      i += 1
-      sleep 1 # Mongo needs up to 60 seconds
-    end
-
-    i.should be > 0 # Indicates that it took at least one sleep to expire
-    query.count.should == 0
-  end
-end