moneta 0.7.18 → 0.7.19

data/lib/moneta/shared.rb

@@ -36,24 +36,32 @@ module Moneta
     protected
 
     def wrap(*args)
-      @adapter ||= Adapters::Client.new(@options)
+      connect
       yield
+    end
+
+    def connect
+      @adapter ||= Adapters::Client.new(@options)
     rescue Errno::ECONNREFUSED, Errno::ENOENT => ex
+      start_server
       tries ||= 0
       warn "Moneta::Shared - Failed to connect: #{ex.message}" if tries > 0
-      begin
-        # TODO: Implement this using forking (MRI) and threading (JRuby)
-        # to get maximal performance
-        @adapter = Lock.new(@builder.build.last)
-        @server = Server.new(@adapter, @options)
-        @thread = Thread.new { @server.run }
-        sleep 0.1 until @server.running?
-      rescue Exception => ex
-        warn "Moneta::Shared - Failed to start server: #{ex.message}"
-        @adapter.close if @adapter
-        @adapter = nil
-      end
       (tries += 1) < 3 ? retry : raise
     end
+
+    # TODO: Implement this using forking (MRI) and threading (JRuby)
+    # to get maximal performance
+    def start_server
+      @adapter = Lock.new(@builder.build.last)
+      @server = Server.new(@adapter, @options)
+      @thread = Thread.new { @server.run }
+      sleep 0.1 until @server.running?
+    rescue Exception => ex
+      @adapter.close if @adapter
+      @adapter = nil
+      @server = nil
+      @thread = nil
+      warn "Moneta::Shared - Failed to start server: #{ex.message}"
+    end
   end
 end

data/lib/moneta/version.rb

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

data/lib/rack/session/moneta.rb

@@ -18,7 +18,7 @@ module Rack
           @pool = ::Moneta.new(@pool, :expires => true) if Symbol === @pool
         end
         @pool = ::Moneta::WeakCreate.new(@pool) unless @pool.supports?(:create)
-        @mutex = Mutex.new
+        @mutex = ::Mutex.new
       end
 
       def generate_sid

data/script/benchmarks

@@ -28,7 +28,6 @@ end
 
 class MonetaBenchmarks
   DIR = __FILE__ + '.tmp'
-  FileUtils.mkpath(DIR)
 
   STORES = {
     # SDBM accepts only very short key/value pairs (1k for both)
@@ -378,12 +377,15 @@ class MonetaBenchmarks
   end
 
   def run
+    FileUtils.rm_rf(DIR)
+    FileUtils.mkpath(DIR)
     start_servers
     test_stores
     print_config
     generate_data
     run_benchmarks
     print_summary
+    FileUtils.rm_rf(DIR)
   end
 end
 

data/script/generate-specs

@@ -479,7 +479,7 @@ end
     :options => ":aws_access_key_id => 'fake_access_key_id',
     :aws_secret_access_key  => 'fake_secret_access_key',
     :provider               => 'AWS',
-    :dir                    => 'moneta'",
+    :dir                    => 'simple_fog'",
     # Put Fog into testing mode
     :preamble               => "require 'fog'\nFog.mock!\n"
   },
@@ -488,27 +488,37 @@ end
     :options => ":aws_access_key_id => 'fake_access_key_id',
     :aws_secret_access_key  => 'fake_secret_access_key',
     :provider               => 'AWS',
-    :dir                    => 'moneta',
+    :dir                    => 'simple_fog_with_expires',
     :expires                => true",
     # Put Fog into testing mode
     :preamble               => "require 'fog'\nFog.mock!\n",
     :specs => STANDARD_SPECS.without_increment.without_create.with_expires
   },
   'weak_create' => {
-    :preamble => "start_restserver\n",
+    # Put Fog into testing mode
+    :preamble               => "require 'fog'\nFog.mock!\n",
     :build => %{Moneta.build do
   use :WeakCreate
-  adapter :RestClient, :url => 'http://localhost:8808/moneta/'
+  adapter :Fog,
+    :aws_access_key_id => 'fake_access_key_id',
+    :aws_secret_access_key  => 'fake_secret_access_key',
+    :provider               => 'AWS',
+    :dir                    => 'weak_create'
 end},
-    :specs => ADAPTER_SPECS.without_increment.without_concurrent
+    :specs => ADAPTER_SPECS.without_increment.without_concurrent.returnsame
   },
   'weak_increment' => {
-    :preamble => "start_restserver\n",
+    # Put Fog into testing mode
+    :preamble               => "require 'fog'\nFog.mock!\n",
     :build => %{Moneta.build do
   use :WeakIncrement
-  adapter :RestClient, :url => 'http://localhost:8808/moneta/'
+  adapter :Fog,
+    :aws_access_key_id => 'fake_access_key_id',
+    :aws_secret_access_key  => 'fake_secret_access_key',
+    :provider               => 'AWS',
+    :dir                    => 'weak_increment'
 end},
-    :specs => ADAPTER_SPECS.without_create.without_concurrent
+    :specs => ADAPTER_SPECS.without_create.without_concurrent.returnsame
   },
   'expires_memory' => {
     :build => %{Moneta.build do
@@ -1162,8 +1172,7 @@ end}
 it 'updates an existing key/value' do
   store['foo/bar'] = '1'
   store['foo/bar'] = '2'
-  records = store.table.find :all, :conditions => { :k => 'foo/bar' }
-  records.count.should == 1
+  store.table.where(:k => 'foo/bar').count.should == 1
 end
 
 it 'supports different tables same database' do
@@ -1283,7 +1292,7 @@ end
     :build => "Moneta::Adapters::Fog.new(:aws_access_key_id => 'fake_access_key_id',
     :aws_secret_access_key  => 'fake_secret_access_key',
     :provider               => 'AWS',
-    :dir                    => 'moneta')",
+    :dir                    => 'adapter_fog')",
     # Put Fog into testing mode
     :preamble               => "require 'fog'\nFog.mock!\n",
     # Fog returns same object in mocking mode (in-memory store)
@@ -1682,7 +1691,7 @@ it 'guarantees that the same value is returned when setting a key' do
   (store[#{key1}] = value).should equal(value)
 end
 
-it 'returns false from key? if a key is not available' do
+it 'returns false from #key? if a key is not available' do
   store.key?(#{key1}).should be_false
 end
 
@@ -1730,7 +1739,7 @@ end}
   store.load(#{key1}).should == #{val1}
 end
 
-it 'returns true from key? if a key is available' do
+it 'returns true from #key? if a key is available' do
   store[#{key1}] = #{val1}
   store.key?(#{key1}).should be_true
 end
@@ -1908,7 +1917,7 @@ it 'supports strict expires on store and load' do
   store.load('key1').should be_nil
 end
 
-it 'supports expires on store and key?', :retry => 3 do
+it 'supports expires on store and #key?', :retry => 3 do
   store.store('key1', 'val1', :expires => 3)
   store.key?('key1').should be_true
   sleep 1
@@ -1917,7 +1926,7 @@ it 'supports expires on store and key?', :retry => 3 do
   store.key?('key1').should be_false
 end
 
-it 'supports strict expires on store and key?' do
+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!
@@ -1950,7 +1959,7 @@ it 'supports false as no-expires in load' do
   store.load('key1').should == 'val1'
 end
 
-it 'supports updating the expiration time in key?', :retry => 3 do
+it 'supports updating the expiration time in #key?', :retry => 3 do
   store.store('key2', 'val2', :expires => 3)
   store['key2'].should == 'val2'
   sleep 1
@@ -1962,14 +1971,14 @@ it 'supports updating the expiration time in key?', :retry => 3 do
   store['key2'].should be_nil
 end
 
-it 'supports 0 as no-expires in key?' do
+it 'supports 0 as no-expires in #key?' do
   store.store('key1', 'val1', :expires => 2)
   store.key?('key1', :expires => 0).should be_true
   sleep 3
   store['key1'].should == 'val1'
 end
 
-it 'supports false as no-expires in key?' do
+it 'supports false as no-expires in #key?' do
   store.store('key1', 'val1', :expires => 2)
   store.key?('key1', :expires => false ).should be_true
   sleep 3
@@ -2034,7 +2043,7 @@ it 'supports false as no-expires on store and []' do
   store['key1'].should == 'val1'
 end
 
-it 'does not update the expiration time in key? when not asked to do so', :retry => 3 do
+it 'does not update the expiration time in #key? when not asked to do so', :retry => 3 do
   store.store('key1', 'val1', :expires => 1)
   store.key?('key1').should be_true
   store.key?('key1', :expires => nil).should be_true
@@ -2307,7 +2316,7 @@ it 'refuses to store to keys that cannot be marshalled' do
   end.to raise_error(marshal_error)
 end
 
-it 'refuses to check for key? if the key cannot be marshalled' do
+it 'refuses to check for #key? if the key cannot be marshalled' do
   expect do
     store.key? Struct.new(:foo).new(:bar)
   end.to raise_error(marshal_error)

data/script/install-bundle

@@ -16,10 +16,20 @@ end
 
 BUNDLE_FILE = "moneta-bundle-#{RUBY_VERSION}-#{ruby}.tar.gz"
 
-if system("curl -u moneta:#{ENV['DAV_PW']} -k -o #{BUNDLE_FILE} https://mendler.net/dav/#{BUNDLE_FILE}")
+if system("curl -f -u moneta:#{ENV['DAV_PW']} -k -o #{BUNDLE_FILE} https://mendler.net/dav/#{BUNDLE_FILE}")
   cmd 'rm -rf .bundle'
   cmd "tar -xpf #{BUNDLE_FILE}"
   cmd "rm -f #{BUNDLE_FILE}"
+
+  # Write newest moneta version in Gemfile.lock
+  require './lib/moneta/version'
+  File.open('Gemfile.lock', 'r+') do |fp|
+    content = fp.read
+    content.gsub!(/moneta\s*\(.*?\)/, "moneta (#{Moneta::VERSION})")
+    fp.truncate(0)
+    fp.pos = 0
+    fp.write(content)
+  end
 else
   cmd 'bundle install --path .bundle'
   cmd 'bundle update'

data/script/kill-travis

@@ -1,5 +1,5 @@
 #!/bin/bash
-# Allow Travis-CI builds to be canceled
+# Allow Travis-CI builds to be cancelled
 
 if [[ $TRAVIS ]]; then
     echo 'Started Travis-CI killer!'

data/script/parallel-tests

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+def rspec(spec)
+  if system("rspec #{spec}")
+    true
+  elsif sig = $?.termsig
+    found = Signal.list.to_a.select {|name, id| id == sig }.first
+    puts "\e[31m########## SIG#{found ? found.first : sig} rspec #{spec} ##########\e[0m"
+    false
+  else
+    puts "rspec terminated with #{$?.exitstatus}"
+    false
+  end
+end
+
+ENV['PARALLEL_TESTS'] = 'yes'
+
+specs = Dir['spec/*/*_spec.rb'].sort
+
+# Shuffle specs to ensure equal distribution over the test groups
+# We have to shuffle with the same seed every time because rake is started
+# multiple times!
+old_seed = srand(43)
+specs.shuffle!
+srand(old_seed)
+
+# FIXME:
+#
+# * QuickLZ segfaults because of an assertion
+#   QuickLZ is also not maintained on Github, but on Bitbucket
+#   and I don't know where the issue tracker is.
+#
+# * PStore increment/locking doesn't work correctly on JRuby
+#
+unstable = %w(quicklz riak cassandra)
+unstable += %w(pstore) if defined?(JRUBY_VERSION)
+
+unstable_re = /#{unstable.join('|')}/
+unstable = specs.select {|s| s =~ unstable_re }
+specs -= unstable
+
+group = ARGV.first || '1/1'
+case group
+when /^(\d+)\/(\d+)$/
+  n = $1.to_i
+  max = $2.to_i
+  if n == max
+    specs = specs[(n-1)*(specs.size/max)..-1]
+  else
+    specs = specs[(n-1)*(specs.size/max), specs.size/max]
+  end
+when 'unstable'
+  specs = unstable
+else
+  puts "Invalid test group #{group}"
+  exit 1
+end
+
+puts "The following specs will be executed:\n\t#{specs.join "\n\t"}\n\n"
+
+# Memcached and Redis specs cannot be used in parallel
+# because of flushing and lacking namespaces
+parallel = []
+%w(memcached redis client shared riak tokyotyrant couch cassandra).each do |name|
+  serial = specs.select { |s| s.include?(name) }
+  unless serial.empty?
+    specs -= serial
+    parallel << serial
+  end
+end
+parallel += specs.map {|s| [s] }
+
+threads = []
+failed = false
+parallel.each do |serial|
+  threads << Thread.new do
+    begin
+      serial.each do |spec|
+        failed = true unless rspec(spec)
+      end
+    ensure
+      threads.delete Thread.current
+    end
+  end
+  sleep 0.1
+  sleep 0.1 while threads.size >= 5
+end
+sleep 0.1 until threads.empty?
+
+if failed
+  puts "\e[31m########## MONETA TESTSUITE FAILED ##########\e[0m"
+  exit 1
+end
+
+puts "\e[32m########## MONETA TESTSUITE SUCCEDED ##########\e[0m"

data/script/upload-bundle

@@ -1,2 +1,2 @@
 #!/bin/bash
-curl -u moneta:$DAV_PW -k -T moneta-bundle-*.tar.gz https://mendler.net/dav/ || echo 'Nothing uploaded'
+curl -f -u moneta:$DAV_PW -k -T moneta-bundle-*.tar.gz https://mendler.net/dav/ || echo 'Nothing uploaded'

data/spec/helper.rb

@@ -1,23 +1,57 @@
 require 'rspec'
-require 'rspec/core/formatters/progress_formatter'
+require 'rspec/core/formatters/base_text_formatter'
 require 'rspec/retry'
 require 'moneta'
 require 'fileutils'
 require 'monetaspecs'
 
-if ENV['TRAVIS']
-  RSpec::Core::Formatters::ProgressFormatter.class_eval do
-    def example_passed(example)
-      # do nothing
+class MonetaParallelFormatter < RSpec::Core::Formatters::BaseTextFormatter
+  def start(*args)
+
+    output.puts colorise_summary("STARTING #{ARGV.join(' ')}")
+    @stopped = false
+    @passed_count = 0
+    @heartbeat = Thread.new do
+      count = 0
+      until @stopped
+        if (count += 1) % 60 == 0
+          output.puts(color("RUNNING  #{ARGV.join(' ')} - #{@passed_count} passed, #{failed_examples.size} failures",
+                            failed_examples.empty? ? RSpec.configuration.success_color : RSpec.configuration.failure_color))
+        end
+        sleep 0.5
+      end
     end
   end
+
+  def example_passed(example)
+    super
+    @passed_count += 1
+  end
+
+  def stop
+    @stopped = true
+    @heartbeat.join
+  end
+
+  def dump_summary(duration, example_count, failure_count, pending_count)
+    @duration = duration
+    @example_count = example_count
+    @failure_count = failure_count
+    @pending_count = pending_count
+    output.puts colorise_summary(summary_line(example_count, failure_count, pending_count))
+    dump_commands_to_rerun_failed_examples
+  end
+
+  def summary_line(example_count, failure_count, pending_count)
+    "FINISHED #{ARGV.join(' ')} in #{format_duration(duration)} - #{super}"
+  end
 end
 
 RSpec.configure do |config|
   config.verbose_retry = true
   config.color_enabled = true
   config.tty = true
-  config.formatter = :progress
+  config.formatter = ENV['PARALLEL_TESTS'] ? MonetaParallelFormatter : :progress
 end
 
 # Disable jruby stdout pollution by memcached
@@ -135,10 +169,9 @@ shared_context 'setup_store' do
   end
 
   after do
-    store.close.should == nil if store
-    if @log
-      @log.close
-      @log = nil
+    if store
+      store.close.should == nil
+      @store = nil
     end
   end
 end