moneta 0.7.9 → 0.7.10

data/lib/moneta/mixins.rb

@@ -257,29 +257,31 @@ module Moneta
 
   # @api private
   module HashAdapter
+    attr_reader :backend
+
     # (see Proxy#key?)
     def key?(key, options = {})
-      @hash.has_key?(key)
+      @backend.has_key?(key)
     end
 
     # (see Proxy#load)
     def load(key, options = {})
-      @hash[key]
+      @backend[key]
     end
 
     # (see Proxy#store)
     def store(key, value, options = {})
-      @hash[key] = value
+      @backend[key] = value
     end
 
     # (see Proxy#delete)
     def delete(key, options = {})
-      @hash.delete(key)
+      @backend.delete(key)
     end
 
     # (see Proxy#clear)
     def clear(options = {})
-      @hash.clear
+      @backend.clear
       self
     end
   end

data/lib/moneta/version.rb

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

data/lib/rack/moneta_store.rb

@@ -38,7 +38,7 @@ module Rack
     end
 
     def call(env)
-      env['rack.moneta_store'] = @cache ? ::Moneta::Cache.new(:cache => ::Moneta::Adapters::Memory.new, :backend => @store) : @store
+      env['rack.moneta_store'] = @cache ? ::Moneta::Cache.new(:cache => ::Moneta::Adapters::Memory.new, :adapter => @store) : @store
       @app.call(env)
     end
   end

data/lib/rack/session/moneta.rb

@@ -17,6 +17,7 @@ module Rack
           raise ArgumentError, 'Block or option :store is required' unless @pool = options[:store]
           @pool = ::Moneta.new(@pool, :expires => true) if Symbol === @pool
         end
+        @pool = ::Moneta::WeakCreate.new(@pool) unless @pool.supports?(:create)
         @mutex = Mutex.new
       end
 
@@ -30,8 +31,10 @@ module Rack
       def get_session(env, sid)
         with_lock(env) do
           unless sid && session = @pool[sid]
-            sid, session = generate_sid, {}
-            @pool[sid] = session
+            session = {}
+            begin
+              sid = generate_sid
+            end until @pool.create(sid, session)
           end
           [sid, session]
         end
@@ -40,7 +43,7 @@ module Rack
       def set_session(env, session_id, new_session, options)
         with_lock(env) do
           @pool.store(session_id, new_session,
-                       options[:expire_after] ? {:expires => options[:expire_after]} : {})
+                      options[:expire_after] ? { :expires => options[:expire_after] } : {})
           session_id
         end
       end

data/script/benchmarks

@@ -31,10 +31,10 @@ class MonetaBenchmarks
   FileUtils.mkpath(DIR)
 
   STORES = {
-    # SDBM is unstable
+    # SDBM is unstable, the rest is too slow
     # :SDBM => { :file => "#{DIR}/sdbm" },
-    # YAML is so fucking slow
     # :YAML => { :file => "#{DIR}/yaml" },
+    # :RestClient => { :url => 'http://localhost:8808/' },
     :ActiveRecord => { :connection => { :adapter  => 'sqlite3', :database => ':memory:' } },
     :Cassandra => {},
     :Client => {},
@@ -56,12 +56,12 @@ class MonetaBenchmarks
     :Mongo => {},
     :PStore => { :file => "#{DIR}/pstore" },
     :Redis => {},
-    :RestClient => { :url => 'http://localhost:8808/' },
     :Riak => {},
     :Sequel => { :db => 'sqlite:/' },
     :Sqlite => { :file => ':memory:' },
     :TDB => { :file => "#{DIR}/tdb" },
     :TokyoCabinet => { :file => 'tokyocabinet' },
+    :TokyoTyrant => {},
   }
 
   CONFIGS = {
@@ -188,31 +188,31 @@ class MonetaBenchmarks
       end
     end
 
-    parallel do
-      begin
-        require 'rack'
-        require 'webrick'
-        require 'rack/moneta_rest'
-
-        # Keep webrick quiet
-        ::WEBrick::HTTPServer.class_eval do
-          def access_log(config, req, res); end
-        end
-        ::WEBrick::BasicLog.class_eval do
-          def log(level, data); end
-        end
-
-        Rack::Server.start(:app => Rack::Builder.app do
-                             use Rack::Lint
-                             run Rack::MonetaRest.new(:store => :Memory)
-                           end,
-                           :environment => :none,
-                           :server => :webrick,
-                           :Port => 8808)
-      rescue Exception => ex
-        puts "\e[31mFailed to start Rack server - #{ex.message}\e[0m"
-      end
-    end
+    # parallel do
+    #   begin
+    #     require 'rack'
+    #     require 'webrick'
+    #     require 'rack/moneta_rest'
+
+    #     # Keep webrick quiet
+    #     ::WEBrick::HTTPServer.class_eval do
+    #       def access_log(config, req, res); end
+    #     end
+    #     ::WEBrick::BasicLog.class_eval do
+    #       def log(level, data); end
+    #     end
+
+    #     Rack::Server.start(:app => Rack::Builder.app do
+    #                          use Rack::Lint
+    #                          run Rack::MonetaRest.new(:store => :Memory)
+    #                        end,
+    #                        :environment => :none,
+    #                        :server => :webrick,
+    #                        :Port => 8808)
+    #   rescue Exception => ex
+    #     puts "\e[31mFailed to start Rack server - #{ex.message}\e[0m"
+    #   end
+    # end
 
     sleep 1 # Wait for servers
   end

data/script/generate-specs

@@ -330,6 +330,15 @@ end
     :options => ':file => File.join(make_tempdir, "simple_tokyocabinet_with_expires"), :expires => true',
     :specs => STANDARD_SPECS.without_multiprocess.with_expires
   },
+  'simple_tokyotyrant' => {
+    :store => :TokyoTyrant,
+    :specs => STANDARD_SPECS
+  },
+  'simple_tokyotyrant_with_expires' => {
+    :store => :TokyoTyrant,
+    :options => ':expires => true',
+    :specs => STANDARD_SPECS.with_expires
+  },
   'simple_kyotocabinet' => {
     :store => :KyotoCabinet,
     :options => ':file => File.join(make_tempdir, "simple_kyotocabinet.kch")',
@@ -545,18 +554,18 @@ end},
   'cache_file_memory' => {
     :build => %{Moneta.build do
   use(:Cache) do
-    backend { adapter :File, :dir => File.join(make_tempdir, "cache_file_memory") }
+    adapter { adapter :File, :dir => File.join(make_tempdir, "cache_file_memory") }
     cache { adapter :Memory }
   end
 end},
     :specs => ADAPTER_SPECS.returnsame,
     :tests => %{
 it 'stores loaded values in cache' do
-  store.backend['foo'] = 'bar'
+  store.adapter['foo'] = 'bar'
   store.cache['foo'].should be_nil
   store['foo'].should == 'bar'
   store.cache['foo'].should == 'bar'
-  store.backend.delete('foo')
+  store.adapter.delete('foo')
   store['foo'].should == 'bar'
   store.delete('foo')
   store['foo'].should be_nil
@@ -566,7 +575,7 @@ end
   'cache_memory_null' => {
     :build => %{Moneta.build do
   use(:Cache) do
-    backend(Moneta::Adapters::Memory.new)
+    adapter(Moneta::Adapters::Memory.new)
     cache(Moneta::Adapters::Null.new)
   end
 end},
@@ -1301,6 +1310,10 @@ end}
     :build => 'Moneta::Adapters::TokyoCabinet.new(:file => File.join(make_tempdir, "adapter_tokyocabinet_hdb"), :type => :hdb)',
     :specs => ADAPTER_SPECS.without_multiprocess
   },
+  'adapter_tokyotyrant' => {
+    :build => 'Moneta::Adapters::TokyoTyrant.new',
+    :specs => ADAPTER_SPECS
+  },
   'adapter_yaml' => {
     :build => 'Moneta::Adapters::YAML.new(:file => File.join(make_tempdir, "adapter_yaml"))',
     :specs => STANDARD_SPECS.simplevalues_only.simplekeys_only.without_transform
@@ -1705,146 +1718,188 @@ SPECS['multiprocess'] = %{it 'supports access by multiple instances/processes' d
   store2.close
 end}
 
-SPECS['expires'] = %{it 'supports expires on store and #[]' do
-  store.store('key1', 'val1', :expires => 2)
+SPECS['expires'] = %{it 'supports expires on store and []', :retry => 3 do
+  store.store('key1', 'val1', :expires => 3)
   store['key1'].should == 'val1'
   sleep 1
   store['key1'].should == 'val1'
-  sleep 2
+  sleep 3
   store['key1'].should be_nil
 end
 
-it 'supports 0 as no-expires on store and #[]' do
+it 'supports strict expires on store and []' do
+  store.store('key1', 'val1', :expires => 2)
+  store['key1'].should == 'val1'
+  sleep 3 # Sleep 3 seconds because after 2 seconds the value can still exist!
+  store['key1'].should be_nil
+end
+
+it 'supports expires on store and fetch', :retry => 3 do
+  store.store('key1', 'val1', :expires => 3)
+  store.fetch('key1').should == 'val1'
+  sleep 1
+  store.fetch('key1').should == 'val1'
+  sleep 3
+  store.fetch('key1').should be_nil
+end
+
+it 'supports strict expires on store and fetch' do
+  store.store('key1', 'val1', :expires => 2)
+  store.fetch('key1').should == 'val1'
+  sleep 3 # Sleep 3 seconds because after 2 seconds the value can still exist!
+  store.fetch('key1').should be_nil
+end
+
+it 'supports 0 as no-expires on store and []' do
   store.store('key1', 'val1', :expires => 0)
   store['key1'].should == 'val1'
   sleep 2
   store['key1'].should == 'val1'
 end
 
-it 'supports false as no-expires on store and #[]' do
+it 'supports false as no-expires on store and []' do
   store.store('key1', 'val1', :expires => false)
   store['key1'].should == 'val1'
   sleep 2
   store['key1'].should == 'val1'
 end
 
-it 'supports expires on store and load' do
-  store.store('key1', 'val1', :expires => 2)
+it 'supports expires on store and load', :retry => 3 do
+  store.store('key1', 'val1', :expires => 3)
   store.load('key1').should == 'val1'
   sleep 1
   store.load('key1').should == 'val1'
-  sleep 2
+  sleep 3
   store.load('key1').should be_nil
 end
 
-it 'supports expires on store and key?' do
+it 'supports strict expires on store and load' do
   store.store('key1', 'val1', :expires => 2)
+  store.load('key1').should == 'val1'
+  sleep 3 # Sleep 3 seconds because after 2 seconds the value can still exist!
+  store.load('key1').should be_nil
+end
+
+it 'supports expires on store and key?', :retry => 3 do
+  store.store('key1', 'val1', :expires => 3)
   store.key?('key1').should be_true
   sleep 1
   store.key?('key1').should be_true
-  sleep 2
+  sleep 3
   store.key?('key1').should be_false
 end
 
-it 'supports updating the expiration time in load' do
-  store.store('key2', 'val2', :expires => 2)
+it 'supports strict expires on store and key?' do
+  store.store('key1', 'val1', :expires => 2)
+  store.key?('key1').should be_true
+  sleep 3 # Sleep 3 seconds because after 2 seconds the value can still exist!
+  store.key?('key1').should be_false
+end
+
+it 'supports updating the expiration time in load', :retry => 3 do
+  store.store('key2', 'val2', :expires => 3)
   store['key2'].should == 'val2'
   sleep 1
-  store.load('key2', :expires => 3).should == 'val2'
+  store.load('key2', :expires => 5).should == 'val2'
   store['key2'].should == 'val2'
-  sleep 2
+  sleep 3
   store['key2'].should == 'val2'
-  sleep 2
+  sleep 3
   store['key2'].should be_nil
 end
 
 it 'supports 0 as no-expires in load' do
   store.store('key1', 'val1', :expires => 2)
   store.load('key1', :expires => 0).should == 'val1'
-  sleep 2
+  sleep 3
   store.load('key1').should == 'val1'
 end
 
 it 'supports false as no-expires in load' do
   store.store('key1', 'val1', :expires => 2)
   store.load('key1', :expires => false).should == 'val1'
-  sleep 2
+  sleep 3
   store.load('key1').should == 'val1'
 end
 
-it 'supports updating the expiration time in key?' do
-  store.store('key2', 'val2', :expires => 2)
+it 'supports updating the expiration time in key?', :retry => 3 do
+  store.store('key2', 'val2', :expires => 3)
   store['key2'].should == 'val2'
   sleep 1
-  store.key?('key2', :expires => 3).should be_true
+  store.key?('key2', :expires => 5).should be_true
   store['key2'].should == 'val2'
-  sleep 2
+  sleep 3
   store['key2'].should == 'val2'
-  sleep 2
+  sleep 3
   store['key2'].should be_nil
 end
 
 it 'supports 0 as no-expires in key?' do
   store.store('key1', 'val1', :expires => 2)
   store.key?('key1', :expires => 0).should be_true
-  sleep 2
+  sleep 3
   store['key1'].should == 'val1'
 end
 
 it 'supports false as no-expires in key?' do
   store.store('key1', 'val1', :expires => 2)
   store.key?('key1', :expires => false ).should be_true
-  sleep 2
+  sleep 3
   store['key1'].should == 'val1'
 end
 
-it 'supports updating the expiration time in fetch' do
-  store.store('key1', 'val1', :expires => 2)
+it 'supports updating the expiration time in fetch', :retry => 3 do
+  store.store('key1', 'val1', :expires => 3)
   store['key1'].should == 'val1'
   sleep 1
-  store.fetch('key1', nil, :expires => 3).should == 'val1'
+  store.fetch('key1', nil, :expires => 5).should == 'val1'
   store['key1'].should == 'val1'
-  sleep 2
+  sleep 3
   store['key1'].should == 'val1'
-  sleep 2
+  sleep 3
   store['key1'].should be_nil
 end
 
 it 'supports 0 as no-expires in fetch' do
   store.store('key1', 'val1', :expires => 2)
   store.fetch('key1', nil, :expires => 0).should == 'val1'
-  sleep 2
+  sleep 3
   store.load('key1').should == 'val1'
 end
 
 it 'supports false as no-expires in fetch' do
   store.store('key1', 'val1', :expires => 2)
   store.fetch('key1', nil, :expires => false).should == 'val1'
-  sleep 2
+  sleep 3
   store.load('key1').should == 'val1'
 end
 
-it 'respects expires in delete' do
+it 'strictly respects expires in delete' do
   store.store('key2', 'val2', :expires => 2)
   store['key2'].should == 'val2'
+  sleep 3 # Sleep 3 seconds because after 2 seconds the value can still exist!
+  store.delete('key2').should be_nil
+end
+
+it 'respects expires in delete', :retry => 3 do
+  store.store('key2', 'val2', :expires => 3)
+  store['key2'].should == 'val2'
   sleep 1
   store['key2'].should == 'val2'
-  sleep 2
+  sleep 3
   store.delete('key2').should be_nil
 end
 
 it 'supports the #expires syntactic sugar' do
   store.store('persistent_key', 'persistent_value', :expires => 0)
-  store.expires(2).store('key2', 'val2')
-  store['key2'].should == 'val2'
-  sleep 1
+  store.expires(1).store('key2', 'val2')
   store['key2'].should == 'val2'
   sleep 2
   store.delete('key2').should be_nil
   store['persistent_key'].should == 'persistent_value'
 end
 
-it 'supports false as no-expires on store and #[]' do
+it 'supports false as no-expires on store and []' do
   store.store('key1', 'val1', :expires => false)
   store['key1'].should == 'val1'
   sleep 2

data/script/memusage

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+
+def memusage
+  `pmap #{$$} | tail -1`[10..-1].strip.to_i
+end
+
+def shrink
+  last = memusage
+  loop do
+    GC.start
+    sleep 1
+    m = memusage
+    break if m == last
+    last = m
+  end
+end
+
+$last_memusage = 0
+
+def stats
+  shrink
+  m = memusage
+  delta = m - $last_memusage
+  $last_memusage = m
+  puts "# #{m}K #{delta >= 0 ? '+' : ''}#{delta}K"
+end
+
+stats
+
+%q{require 'moneta'
+Moneta.new(:Memory)
+Moneta.new(:File, :dir => 'filestore')
+Moneta.new(:MemcachedNative)
+Moneta.new(:MemcachedDalli)}.each_line do |line|
+  puts line
+  eval(line)
+  stats
+end