moneta 1.0.0 → 1.1.0

data/lib/moneta/transformer/helper.rb

@@ -35,14 +35,14 @@ module Moneta
 
       def bzip2(value)
         io = ::StringIO.new
-        bz = ::RBzip2::Compressor.new(io)
+        bz = ::RBzip2.default_adapter::Compressor.new(io)
         bz.write(value)
         bz.close
         io.string
       end
 
       def bunzip2(value)
-        ::RBzip2::Decompressor.new(::StringIO.new(value)).read
+        ::RBzip2.default_adapter::Decompressor.new(::StringIO.new(value)).read
       end
 
       autoload :BSON, 'moneta/transformer/helper/bson'

data/lib/moneta/version.rb

@@ -1,5 +1,5 @@
 module Moneta
   # Moneta version number
   # @api public
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/lib/moneta/weak_each_key.rb

@@ -0,0 +1,74 @@
+require 'set'
+
+module Moneta
+  # Adds weak key enumeration support to the underlying store
+  #
+  # @note This class wraps methods that store and retrieve entries in order to
+  #   track which keys are in the store, and uses this list when doing key
+  #   traversal.  This means that {#each_key each_key} will only yield keys
+  #   which have been accessed previously via the present store object.  This
+  #   wrapper is therefore best suited to adapters which are not persistent, and
+  #   which cannot be shared.
+  #
+  # @api public
+  class WeakEachKey < Wrapper
+    supports :each_key
+
+    # @param [Moneta store] adapter The underlying store
+    # @param [Hash] options
+    def initialize(adapter, options = {})
+      raise 'Store already supports feature :each_key' if adapter.supports?(:each_key)
+      @all_keys = Set.new
+      super
+    end
+
+    # (see Proxy#each_key)
+    def each_key
+      return enum_for(:each_key) { all_keys.size } unless block_given?
+      all_keys.each { |key| yield key }
+      self
+    end
+
+    protected
+
+    def wrap(name, *args)
+      case name
+      when :create, :store, :increment, :create
+        each_key_save(args[0])
+        yield
+      when :key?
+        if found = yield
+          each_key_save(args[0])
+        else
+          all_keys.delete(args[0])
+        end
+        found
+      when :load
+        key?(*args)
+        yield
+      when :delete
+        all_keys.delete(args[0])
+        yield
+      when :clear, :close
+        all_keys.clear
+        yield
+      when :values_at, :fetch_values, :slice
+        args[0].each { |key| key?(key) }
+        yield
+      when :merge!
+        args[0].each { |key, _| each_key_save(key) }
+        yield
+      else
+        yield
+      end
+    end
+
+    def all_keys
+      @all_keys
+    end
+
+    def each_key_save(key)
+      @all_keys = Set.new(@all_keys).add(key)
+    end
+  end
+end

data/lib/moneta/wrapper.rb

@@ -46,5 +46,30 @@ module Moneta
     def features
       wrap(:features) { super }
     end
+
+    # (see Proxy#each_key)
+    def each_key(&block)
+      wrap(:each_key) { super }
+    end
+
+    # (see Proxy#values_at)
+    def values_at(*keys, **options)
+      wrap(:values_at, keys, options) { super }
+    end
+
+    # (see Proxy#fetch_values)
+    def fetch_values(*keys, **options, &defaults)
+      wrap(:fetch_values, keys, options, defaults) { super }
+    end
+
+    # (see Proxy#slice)
+    def slice(*keys, **options)
+      wrap(:slice, keys, options) { super }
+    end
+
+    # (see Proxy#merge!)
+    def merge!(pairs, options = {})
+      wrap(:merge!, pairs, options) { super }
+    end
   end
 end

data/moneta.gemspec

@@ -13,9 +13,9 @@ Gem::Specification.new do |s|
   s.files            = `git ls-files`.split("\n")
   s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.homepage         = 'http://github.com/minad/moneta'
+  s.homepage         = 'http://github.com/moneta-rb/moneta'
   s.licenses         = %w(MIT)
   s.require_paths    = %w(lib)
   s.summary          = %{A unified interface to key/value stores, including Redis, Memcached, TokyoCabinet, ActiveRecord and many more}
-  s.required_ruby_version = '>= 1.9'
+  s.required_ruby_version = '>= 2.2.2'
 end

data/script/benchmarks

@@ -4,6 +4,7 @@ $: << File.join(File.dirname(__FILE__), '..', 'lib')
 require 'benchmark'
 require 'moneta'
 require 'fileutils'
+require 'active_support'
 
 class String
   def random(n)
@@ -11,63 +12,156 @@ class String
   end
 end
 
-class Array
-  def sum
-    inject(0, &:+)
-  end
-
-  def mean
-    sum / size
-  end
+def mean arr
+  arr.sum / arr.length
+end
 
-  def stddev
-    m = mean
-    Math.sqrt(map {|s| (s - m) ** 2 }.mean)
-  end
+def stddev arr
+  m = mean(arr)
+  Math.sqrt(mean(arr.map {|s| (s - m) ** 2 }))
 end
 
 class MonetaBenchmarks
   DIR = __FILE__ + '.tmp'
 
-  STORES = {
+  mysql_username = ENV['MONETA_MYSQL_USERNAME'] || 'root'
+  mysql_password = ENV['MONETA_MYSQL_PASSWORD']
+  mysql_database1 = ENV['MONETA_MYSQL_DATABSASE1'] || 'moneta'
+  mysql_database2 = ENV['MONETA_MYSQL_DATABSASE2'] || 'moneta2'
+
+  postgres_username = ENV['MONETA_POSTGRES_USERNAME'] || 'postgres'
+  postgres_database1 = ENV['MONETA_POSTGRES_DATABSASE1'] || 'moneta1'
+  postgres_database2 = ENV['MONETA_POSTGRES_DATABSASE1'] || 'moneta2'
+
+  STORES = [
     # SDBM accepts only very short key/value pairs (1k for both)
-    # SDBM: { file: "#{DIR}/sdbm" },
+    {name: "SDBM", sizes: [:small], options: {file: "#{DIR}/sdbm"}},
     # YAML is too slow
-    # YAML: { file: "#{DIR}/yaml" },
-    ActiveRecord: { table: 'activerecord', connection: { adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), username: 'root', database: 'moneta' } },
-    Cassandra: {},
-    Client: {},
-    Couch: {},
-    DBM: { file: "#{DIR}/dbm" },
-    DataMapper: { setup: 'mysql://root:@localhost/moneta', table: 'datamapper' },
-    Daybreak: { file: "#{DIR}/daybreak" },
-    File: { dir: "#{DIR}/file" },
-    GDBM: { file: "#{DIR}/gdbm" },
-    HBase: {},
-    HashFile: { dir: "#{DIR}/hashfile" },
-    KyotoCabinet: { file: "#{DIR}/kyotocabinet.kch" },
-    LRUHash: {},
-    LevelDB: { dir: "#{DIR}/leveldb" },
-    LocalMemCache: { file: "#{DIR}/lmc" },
-    LMDB: { dir: "#{DIR}/lmdb" },
-    MemcachedDalli: {},
-    MemcachedNative: {},
-    Memory: {},
-    MongoMoped: {},
-    MongoOfficial: {},
-    PStore: { file: "#{DIR}/pstore" },
-    Redis: {},
-    RestClient: { url: 'http://localhost:8808/' },
-    Riak: {},
-    Sequel: { table: 'sequel',
-      db: (defined?(JRUBY_VERSION) ?
-              'jdbc:mysql://localhost/moneta?user=root' :
-              'mysql2://root:@localhost/moneta') },
-    Sqlite: { file: ':memory:' },
-    TDB: { file: "#{DIR}/tdb" },
-    TokyoCabinet: { file: "#{DIR}/tokyocabinet" },
-    TokyoTyrant: {},
-  }
+    #{name: "YAML", options: {file: "#{DIR}/yaml"}},
+    {
+      name: "ActiveRecord (MySQL)",
+      adapter: :ActiveRecord,
+      options: {
+        table: 'activerecord',
+        connection: {
+          adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'),
+          username: mysql_username,
+          database: mysql_database1
+        }
+      }
+    },
+    {
+      name: "ActiveRecord (Postgres)",
+      adapter: :ActiveRecord,
+      options: {
+        table: 'activerecord',
+        connection: {
+          adapter: (defined?(JRUBY_VERSION) ? 'jdbcpostgresql' : 'postgresql'),
+          database: postgres_database1,
+          username: postgres_username
+        }
+      }
+    },
+    {
+      name: "ActiveSupportCache (Memory)",
+      adapter: :ActiveSupportCache,
+      options: {
+        backend: ::ActiveSupport::Cache::MemoryStore.new
+      }
+    },
+    {
+      name: "ActiveSupportCache (Redis)",
+      adapter: :ActiveSupportCache,
+      options: {
+        backend: ::ActiveSupport::Cache::RedisCacheStore.new
+      }
+    },
+    {name: "Cassandra"},
+    {name: "Client (Memory)", adapter: :Client},
+    {name: "Couch"},
+    {
+      name: "DBM",
+      options: {file: "#{DIR}/dbm"}
+    },
+    {
+      name: "DataMapper",
+      options: {
+        setup: "mysql://#{mysql_username}:@localhost/#{mysql_database1}",
+        table: 'datamapper'
+      }
+    },
+    {
+      name: "Daybreak",
+      options: { file: "#{DIR}/daybreak" },
+    },
+    {
+      name: "File",
+      options: {
+        dir: "#{DIR}/file"
+      }
+    },
+    {name: "GDBM", options: {file: "#{DIR}/gdbm"}},
+    {name: "HBase"},
+    {name: "HashFile", options: { dir: "#{DIR}/hashfile" }},
+    {name: "KyotoCabinet", options: { file: "#{DIR}/kyotocabinet.kch" }},
+    {name: "LRUHash"},
+    {name: "LevelDB", options: { dir: "#{DIR}/leveldb" }},
+    {name: "LocalMemCache", options: { file: "#{DIR}/lmc" }},
+    {
+      name: "LMDB",
+      options: {
+        dir: "#{DIR}/lmdb",
+        writemap: true,
+        mapasync: true,
+        nometasync: true,
+        mapsize: 4096 * 3e2
+      }
+    },
+    {name: "MemcachedDalli"},
+    unless defined?(JRUBY_VERSION)
+      {name: "MemcachedNative"}
+    end,
+    {name: "Memory"},
+    {name: "MongoMoped"},
+    {name: "MongoOfficial"},
+    {name: "PStore", options: { file: "#{DIR}/pstore" }},
+    {name: "Redis"},
+    {name: "RestClient", options: { url: 'http://localhost:8808/' }},
+    {name: "Riak"},
+    {
+      name: "Sequel (MySQL)",
+      adapter: :Sequel,
+      options: {
+        table: 'sequel',
+        db: (defined?(JRUBY_VERSION) ?
+          "jdbc:mysql://localhost/#{mysql_database1}?user=#{mysql_username}" :
+          "mysql2://#{mysql_username}:@localhost/#{mysql_database1}")
+      }
+    },
+    {
+      name: "Sequel (Postgres)",
+      adapter: :Sequel,
+      options:
+        if defined?(JRUBY_VERSION)
+          {db: "jdbc:postgresql://localhost/#{postgres_database1}?user=#{postgres_username}"}
+        else
+          {
+            db: "postgres://localhost/#{postgres_database1}",
+            user: postgres_username
+          }
+        end.merge(table: 'sequel')
+    },
+    {
+      name: "Sqlite (Memory)",
+      adapter: :Sqlite,
+      options: {
+        file: ':memory:'
+      }
+    },
+    {name: "TDB", options: { file: "#{DIR}/tdb" }},
+    {name: "TokyoCabinet", options: { file: "#{DIR}/tokyocabinet" }},
+    {name: "TokyoTyrant"},
+  ].compact
 
   CONFIGS = {
     uniform_small: {
@@ -223,25 +317,28 @@ class MonetaBenchmarks
   end
 
   def test_stores
-    STORES.each do |name, options|
+    @stores.select! do |spec|
+      adapter = spec[:adapter] || spec[:name].to_sym
+      options = spec[:options] || {}
       begin
-        if name == :DataMapper
+        if adapter == :DataMapper
           begin
             require 'dm-core'
             DataMapper.setup(:default, adapter: :in_memory)
           rescue LoadError => ex
             puts "\e[31mFailed to load DataMapper - #{ex.message}\e[0m"
           end
-        elsif name == :Riak
+        elsif adapter == :Riak
           require 'riak'
           Riak.disable_list_keys_warnings = true
         end
 
-        cache = Moneta.new(name, options.dup)
+        cache = Moneta.new(adapter, options.dup)
         cache['test'] = 'test'
+        true
       rescue Exception => ex
-        puts "\e[31m#{name} not benchmarked - #{ex.message}\e[0m"
-        STORES.delete(name)
+        puts "\e[31m#{spec[:name]} not benchmarked - #{ex.message}\e[0m"
+        false
       ensure
         (cache.close rescue nil) if cache
       end
@@ -262,8 +359,8 @@ class MonetaBenchmarks
 
     puts "\n\e[1m\e[34m#{SEPARATOR}\n\e[34mComputing keys and values...\n\e[34m#{SEPARATOR}\e[0m"
     puts %{                         Minimum  Maximum    Total     Mean   Stddev}
-    puts 'Key Length              % 8d % 8d % 8d % 8d % 8d' % [key_lens.min, key_lens.max, key_lens.sum, key_lens.mean, key_lens.stddev]
-    puts 'Value Length            % 8d % 8d % 8d % 8d % 8d' % [val_lens.min, val_lens.max, val_lens.sum, val_lens.mean, val_lens.stddev]
+    puts 'Key Length              % 8d % 8d % 8d % 8d % 8d' % [key_lens.min, key_lens.max, key_lens.sum, mean(key_lens), stddev(key_lens)]
+    puts 'Value Length            % 8d % 8d % 8d % 8d % 8d' % [val_lens.min, val_lens.max, val_lens.sum, mean(val_lens), stddev(val_lens)]
   end
 
   def print_config
@@ -279,7 +376,7 @@ class MonetaBenchmarks
       ops = (1000 * @config[:runs] * @data.size) / @stats[name][i].sum
       line = '%-17.17s %-5s % 8d % 8d % 8d % 8d % 8d % 8d' %
         [name, i, @stats[name][i].min, @stats[name][i].max, @stats[name][i].sum,
-         @stats[name][i].mean, @stats[name][i].stddev, ops]
+         mean(@stats[name][i]), mean(@stats[name][i]), ops]
       @summary << [-ops, line << "\n"] if i == :sum
       puts line
     end
@@ -293,10 +390,13 @@ class MonetaBenchmarks
     end
   end
 
-  def benchmark_store(name, options)
+  def benchmark_store(spec)
+    name = spec[:name]
+    adapter = spec[:adapter] || spec[:name].to_sym
+    options = spec[:options] || {}
     puts "\n\e[1m\e[34m#{SEPARATOR}\n\e[34m#{name}\n\e[34m#{SEPARATOR}\e[0m"
 
-    store = Moneta.new(name, options.dup)
+    store = Moneta.new(adapter, options.dup)
 
     @stats[name] = {
       write: [],
@@ -346,8 +446,8 @@ class MonetaBenchmarks
   end
 
   def run_benchmarks
-    STORES.each do |name, options|
-      benchmark_store(name, options)
+    @stores.each do |spec|
+      benchmark_store(spec)
       sleep 1
     end
   end
@@ -366,6 +466,18 @@ class MonetaBenchmarks
       exit
     end
 
+    @size = @config_name.to_s.split('_').last.to_sym
+    @stores =
+      if ENV['MONETA_STORES']
+        store_names = ENV['MONETA_STORES'].split(/,\s*/)
+        STORES.select { |spec| store_names.any? { |name| name == spec[:name] } }
+      elsif ENV['MONETA_STORES_MATCHING']
+        r = Regexp.new(ENV['MONETA_STORES_MATCHING'])
+        STORES.select { |spec| spec[:name].match(r) }
+      else
+        STORES
+      end.select { |spec| !spec.key?(:sizes) || spec[:sizes].include?(@size) }
+
     # Disable jruby stdout pollution by memcached
     if defined?(JRUBY_VERSION)
       require 'java'