benschwarz-smoke 0.5.6 → 0.5.7

data/vendor/moneta/benchmarks/various.rb

@@ -1,234 +0,0 @@
-#!/usr/bin/env ruby
-require 'benchmark'
-require "rubygems"
-
-# Hacked arrays
-# Array modifications
-class HackedArray < Array
-  # Random keys/values
-  attr_reader :keys_used
-  def random_key(no_repeat = true, clean_keys_used = false)
-    @keys_used = [] if clean_keys_used or @keys_used.nil? or @keys_used.size == self.size
-    begin key = rand(self.size) end while no_repeat and @keys_used.include?(key)
-    @keys_used << key
-    return key
-  end
-
-  def random_value(no_repeat = true, clean_keys_used = false)
-    values_at(random_key(no_repeat, clean_keys_used)).first
-  end
-  alias_method :random, :random_value
-
-  def random_subset(n, no_repeat = true, clean_keys_used = true)
-    (1..n).map{|x| random_value(no_repeat, (clean_keys_used && x == 1))}
-  end
-
-  def self.new_from_string(str)
-    res = new
-    str.split('').each{|x| res << x}
-    res
-  end
-end
-
-require "../lib/moneta"
-require "moneta/memcache"
-require "moneta/tyrant"
-require "moneta/berkeley"
-
-
-stores = {
-  'Redis' => { },
-  'Memcached' => { :class_name => "Memcache", :server => "localhost:11211", :namespace => 'moneta_bench' },
-  'Tyrant' => { :host => 'localhost', :port => 1978 }, # Breaks for any n > 50 on my machine
-  'MongoDB' => { :host => 'localhost', :port => 27017, :db => 'moneta_bench' },
-  'LMC' => { :filename => "bench.lmc" },
-  'Berkeley' => { :file => "bench.bdb" },
-  'Rufus' => {:file => "bench.rufus"},
-  'Memory' => { },
-  'DataMapper' => { :setup => "sqlite3::memory:" },
-  # 'Couch' => {:db => "couch_test"},
-  'TC (Tyrant)' => 
-    {:name => "test.tieredtyrant", :backup => Moneta::Tyrant.new(:host => "localhost", :port => 1978), :class_name => "TieredCache"},
-  'TC (Memcached)' => 
-    {:name => "test.tieredmc", :backup => Moneta::Memcache.new(:server => "localhost:11211", :namespace => "various"), :class_name => "TieredCache"}
-}
-
-stats, keys, data, errors, summary = {}, [], HackedArray.new, HackedArray.new, HackedArray.new
-dict = HackedArray.new_from_string 'abcdefghijklnopq123456789'
-n = ARGV[0] ? ARGV[0].to_i : 100
-m = ARGV[1] ? ARGV[1].to_i : 10
-c = ARGV[2] ? ARGV[2].to_i : 3
-vlen_min, vlen_max, vlen_ttl, vlen_avg = 99999, 0, 0, 0
-ds = dict.size
-
-puts "======================================================================"
-puts "Comparison of write/read between Moneta Stores"
-puts "======================================================================"
-
-puts "Data loading..."
-n.times do |x|
-  klen = 6 + rand(3)
-  vlen = (rand(m) + 1) * (rand(m) + rand(m) + 1)
-  key = dict.random_subset(klen).join
-  keys << key
-  value = key * vlen
-  data << [key, value]
-  vs = value.size
-  vlen_min = vs if vs < vlen_min
-  vlen_max = vs if vs > vlen_max
-  vlen_ttl = vlen_ttl + vs
-end
-vlen_avg = vlen_ttl / n
-
-puts "----------------------------------------------------------------------"
-#puts data.inspect
-puts "Total keys: #{keys.size}, unique: #{keys.uniq.size}"
-#puts keys.sort.inspect
-
-puts "----------------------------------------------------------------------"
-puts "                  Minimum    Maximum      Total    Average        xps "
-puts "----------------------------------------------------------------------"
-puts "Lenght Stats   % 10i % 10i % 10i % 10i " % [vlen_min, vlen_max, vlen_ttl, vlen_avg]
-
-module Moneta
-  class TieredCache
-    include Moneta::Defaults
-  
-    def initialize(options)
-      @bdb = Moneta::Berkeley.new(:file => File.join(File.dirname(__FILE__), options[:name]))
-      @mc = options[:backup]
-      # @mc = Moneta::Tyrant.new(:host => "localhost", :port => 1978)
-      # @mc  = Moneta::Memcache.new(:server => "localhost:11211", :namespace => options[:name])
-    end
-  
-    def [](key)
-      val = @bdb[key]
-      unless val
-        @bdb[key] = val if val = @mc[key]
-      end
-      val
-    end
-  
-    def []=(key, val)
-      @bdb[key] = val
-      @mc[key]  = val
-    end
-  
-    def store(key, value, options = {})
-      @bdb.store(key, value, options)
-      @mc.store(key, value, options)
-    end
-  
-    def delete(key)
-      bdb_val = @bdb.delete(key)
-      mc_val  = @mc.delete(key)
-      bdb_val || mc_val
-    end
-  
-    def clear
-      @mc.clear
-      @bdb.clear
-    end
-  
-    def update_key(name, options)
-      @mc.update_key(name, options)
-      @bdb.update_key(name, options)
-    end
-  
-    def key?(key)
-      @bdb.key?(key) || @mc.key?(key)
-    end
-  end
-end
-
-stores.each do |name, options|
-  cname = options.delete(:class_name) || name
-  puts "======================================================================"
-  puts name
-  puts "----------------------------------------------------------------------"
-  begin
-    require "../lib/moneta/#{cname.downcase}"
-  rescue LoadError
-  end
-  klass = Moneta.const_get(cname)
-  @cache = klass.new(options)
-  stats[name] = {
-    :writes => [],
-    :reads => [],
-    :totals => [],
-    :avgs => [],
-  }
-  c.times do |round|
-    @cache.clear
-    print "[#{round + 1}] R"
-    m1 = Benchmark.measure do
-      n.times do
-        key, value = data.random
-          
-        @cache[key] = value
-      end
-    end
-    stats[name][:writes] << m1.real
-    print "W "
-    m2 = Benchmark.measure do
-      n.times do
-        key, value = data.random
-        res = @cache[key]
-        errors << [name, key, value, res] unless res == value
-      end
-    end
-    stats[name][:reads] << m2.real
-    stats[name][:totals] << (m1.real + m2.real)
-    stats[name][:avgs] << (m1.real + m2.real)
-  end
-  print "\n"
-  puts "----------------------------------------------------------------------"
-  puts "                  Minimum    Maximum      Total    Average        xps "
-  puts "----------------------------------------------------------------------"
-  tcmin, tcmax, tctot, tcavg = 99999, 0, 0, 0
-  [:writes, :reads].each do |sname|
-    cmin, cmax, ctot, cavg = 99999, 0, 0, 0
-    stats[name][sname].each do |val|
-      cmin = val if val < cmin
-      tcmin = val if val < tcmin
-      cmax = val if val > cmax
-      tcmax = val if val > tcmax
-      ctot = ctot + val
-      tctot = tctot + val
-    end
-    cavg = ctot / c
-    puts "%-14.14s % 10.4f % 10.4f % 10.4f % 10.4f % 10.4f " % ["#{name} #{sname}", cmin, cmax, ctot, cavg, n / cavg]
-  end
-  tcavg = tctot / (c * 2)
-  puts "%-14.14s % 10.4f % 10.4f % 10.4f % 10.4f % 10.4f " % ["#{name} avgs", tcmin, tcmax, tctot, tcavg, n / tcavg]
-  summary << [name, tcmin, tcmax, tctot, tcavg, n / tcavg]
-end
-puts "----------------------------------------------------------------------"
-if errors.size > 0
-  puts "Errors : #{errors.size}"
-#  puts errors.inspect
-else
-  puts "No errors in reading!"
-end
-puts "======================================================================"
-puts "Summary :: #{c} runs, #{n} keys"
-puts "======================================================================"
-puts "                  Minimum    Maximum      Total    Average        xps "
-puts "----------------------------------------------------------------------"
-summary.each do |sry|
-  puts "%-14.14s % 10.4f % 10.4f % 10.4f % 10.4f % 10.4f " % sry
-end
-puts "======================================================================"
-puts "THE END"
-puts "======================================================================"
-
-#======================================================================
-#Summary :: 3 runs, 1000 keys
-#======================================================================
-#                  Minimum    Maximum      Total    Average       xps
-#----------------------------------------------------------------------
-#MemcacheDB         0.6202     2.7850     7.0099     1.1683   855.9366
-#Memcached          0.4483     0.6563     3.3251     0.5542  1804.4385
-#Redis              0.3282     0.5221     2.2965     0.3828  2612.6444
-#MongoDB            0.6660     1.0539     5.1667     0.8611  1161.2745
-#======================================================================

data/vendor/moneta/lib/moneta/basic_file.rb

@@ -1,111 +0,0 @@
-#
-#  Basic File Store
-#  by Hampton Catlin
-#
-#  This cache simply uses a directory that it creates
-#  and manages to keep your file stores.
-#
-#  Specify :skip_expires => true if you aren't using 
-#  expiration as this will slightly decrease your file size
-#  and memory footprint of the library
-#
-#  You can optionally also specify a :namespace
-#  option that will create a subfolder.
-#
-
-
-require 'fileutils'
-require File.join(File.dirname(__FILE__), "..", "moneta.rb")
-
-module Moneta
-  class BasicFile
-    include Defaults
-    
-    def initialize(options = {})
-      @namespace = options[:namespace]
-      @directory = ::File.join(options[:path], @namespace.to_s)
-      
-      @expires = !options[:skip_expires]
-
-      ensure_directory_created(@directory)
-    end
-    
-    def key?(key)
-      !self[key].nil?
-    end
-    
-    alias has_key? key?
-    
-    def [](key)
-      if ::File.exist?(path(key))
-        data = raw_get(key)
-        if @expires
-          if data[:expires_at].nil? || data[:expires_at] > Time.now
-            data[:value]
-          else
-            delete!(key)
-          end
-        end
-      end
-    end
-    
-    def raw_get(key)
-      Marshal.load(::File.read(path(key)))
-    end
-    
-    def []=(key, value)
-      store(key, value)
-    end
-    
-    def store(key, value, options = {})
-      ensure_directory_created(::File.dirname(path(key)))
-      ::File.open(path(key), "w") do |file|
-        if @expires
-          data = {:value => value}
-          if options[:expires_in]
-            data[:expires_at] = Time.now + options[:expires_in]
-          end
-          contents = Marshal.dump(data)
-        else
-          contents = Marshal.dump(value)
-        end
-        file.puts(contents)
-      end
-    end
-    
-    def update_key(key, options)
-      store(key, self[key], options)
-    end
-    
-    def delete!(key)
-      FileUtils.rm(path(key))
-      nil
-    rescue Errno::ENOENT
-    end
-          
-    def delete(key)
-      value = self[key]
-      delete!(key)
-      value
-    end
-          
-    def clear
-      FileUtils.rm_rf(@directory)
-      FileUtils.mkdir(@directory)
-    end
-    
-    private
-    def path(key)
-      ::File.join(@directory, key.to_s)
-    end
-    
-    def ensure_directory_created(directory_path)
-      if ::File.file?(directory_path)
-        raise StandardError, "The path you supplied #{directory_path} is a file"
-      elsif !::File.exists?(directory_path)
-        FileUtils.mkdir_p(directory_path)
-      end
-    end
-      
-  end
-end

data/vendor/moneta/lib/moneta/berkeley.rb

@@ -1,53 +0,0 @@
-begin
-  require 'bdb'
-rescue LoadError
-  puts "You need bdb gem to use Bdb moneta store"
-  exit
-end
-
-module Moneta
-
-  class Berkeley
-    include Defaults
-
-    def initialize(options={})
-      file = @file = options[:file]
-      @db = Bdb::Db.new()
-      @db.open(nil, file, nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)
-      unless options[:skip_expires]
-        @expiration = Moneta::Berkeley.new(:file => "#{file}_expiration", :skip_expires => true )
-        self.extend(StringExpires)
-      end
-    end
-    
-    module Implementation
-      def key?(key)
-        nil | self[key]
-      end
-
-      alias has_key? key?
-
-      def []=(key,value)
-        @db[key] = value
-      end
-
-      def [](key)
-        @db[key]
-      end
-
-      def delete(key)
-        value = self[key]
-        @db.del(nil,key,0) if value
-        value
-      end
-
-      def clear
-        @db.truncate(nil)
-      end
-    end
-
-    include Implementation
-
-  end
-
-end

data/vendor/moneta/lib/moneta/couch.rb

@@ -1,63 +0,0 @@
-begin
-  require "couchrest"
-rescue LoadError
-  puts "You need the couchrest gem to use the CouchDB store"
-  exit
-end
-
-module Moneta
-  class Couch
-    include Defaults
-    
-    def initialize(options = {})
-      @db = ::CouchRest.database!(options[:db])
-      unless options[:skip_expires]
-        @expiration = Moneta::Couch.new(:db => "#{options[:db]}_expiration", :skip_expires => true)
-        self.extend(StringExpires)
-      end
-    end
-
-    def key?(key)
-      !self[key].nil?
-    rescue RestClient::ResourceNotFound
-      false
-    end
-
-    alias has_key? key?
-
-    def [](key)
-      @db.get(key)["data"]
-    rescue RestClient::ResourceNotFound
-      nil
-    end
-
-    def []=(key, value)
-      @db.save_doc("_id" => key, :data => value)
-    rescue RestClient::RequestFailed
-      self[key]
-    end
-
-    def delete(key)
-      value = @db.get(key)
-      @db.delete_doc({"_id" => value["_id"], "_rev" => value["_rev"]}) if value
-      value["data"]
-    rescue RestClient::ResourceNotFound
-      nil
-    end
-
-    def update_key(key, options = {})
-      val = self[key]
-      self.store(key, val, options)
-    rescue RestClient::ResourceNotFound
-      nil
-    end
-
-    def clear
-      @db.recreate!
-    end
-
-    def delete_store
-      @db.delete!
-    end
-  end
-end

data/vendor/moneta/lib/moneta/lmc.rb

@@ -1,52 +0,0 @@
-begin
-  require "localmemcache"
-rescue LoadError
-  puts "You need the localmemcache gem to use the LMC moneta store"
-  exit
-end
-
-module Moneta
-  class Expiration
-    def initialize(hash)
-      @hash = hash
-    end
-    
-    def [](key)         @hash["#{key}__!__expiration"]          end
-    def []=(key, value) @hash["#{key}__!__expiration"] = value  end
-      
-    def delete(key)
-      key = "#{key}__!__expiration"
-      value = @hash[key]
-      @hash.delete(key)
-      value
-    end
-  end
-  
-  class LMC
-    include Defaults
-
-    module Implementation
-      def initialize(options = {})
-        @hash = LocalMemCache.new(:filename => options[:filename])
-        @expiration = Expiration.new(@hash)
-      end    
-
-      def [](key)         @hash[key]          end
-      def []=(key, value) @hash[key] = value  end
-      def clear()         @hash.clear         end
-
-      def key?(key)
-        @hash.keys.include?(key)
-      end
-
-      def delete(key)
-        value = @hash[key]
-        @hash.delete(key)
-        value
-      end      
-    end
-    include Implementation
-    include StringExpires
-   
-  end
-end

data/vendor/moneta/lib/moneta/mongodb.rb

@@ -1,58 +0,0 @@
-begin
-  require "mongo"
-rescue LoadError
-  puts "You need the mongo gem to use the MongoDB moneta store"
-  exit
-end
-
-module Moneta
-  class MongoDB
-    include Defaults
-    
-    def initialize(options = {})
-      options = {
-        :host => ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
-        :port => ENV['MONGO_RUBY_DRIVER_PORT'] || XGen::Mongo::Driver::Mongo::DEFAULT_PORT,
-        :db => 'cache',
-        :collection => 'cache'
-      }.update(options)
-      conn = XGen::Mongo::Driver::Mongo.new(options[:host], options[:port])
-      @cache = conn.db(options[:db]).collection(options[:collection])
-    end
-
-    def key?(key)
-      !!self[key]
-    end
-
-    def [](key)
-      res = @cache.find_first('_id' => key)
-      res = nil if res && res['expires'] && Time.now > res['expires']
-      res && res['data']
-    end
-
-    def []=(key, value)
-      store(key, value)
-    end
-
-    def delete(key)
-      value = self[key]
-      @cache.remove('_id' => key) if value
-      value
-    end
-
-    def store(key, value, options = {})
-      exp = options[:expires_in] ? (Time.now + options[:expires_in]) : nil
-      @cache.repsert({ '_id' => key }, { '_id' => key, 'data' => value, 'expires' => exp })
-    end
-
-    def update_key(key, options = {})
-      val = self[key]
-      self.store(key, val, options)
-    end
-
-    def clear
-      @cache.clear
-    end
-  end
-end
-

data/vendor/moneta/lib/moneta/redis.rb

@@ -1,49 +0,0 @@
-begin
-  require "redis"
-rescue LoadError
-  puts "You need the redis gem to use the Redis store"
-  exit
-end
-
-module Moneta
-  class Redis
-    include Defaults
-    
-    def initialize(options = {})
-      @cache = ::Redis.new(options)
-    end
-    
-    def key?(key)
-      !@cache[key].nil?
-    end
-    
-    alias has_key? key?
-    
-    def [](key)
-      @cache.get(key)
-    end
-    
-    def []=(key, value)
-      store(key, value)
-    end
-        
-    def delete(key)
-      value = @cache[key]
-      @cache.delete(key) if value
-      value
-    end
-    
-    def store(key, value, options = {})
-      @cache.set(key, value, options[:expires_in])
-    end
-    
-    def update_key(key, options = {})
-      val = @cache[key]
-      self.store(key, val, options)
-    end
-    
-    def clear
-      @cache.flush_db
-    end
-  end
-end

data/vendor/moneta/lib/moneta/rufus.rb

@@ -1,41 +0,0 @@
-begin
-  require "rufus/tokyo"
-rescue LoadError
-  puts "You need the rufus gem to use the Rufus moneta store"
-  exit
-end
-
-module Moneta
-  class BasicRufus < ::Rufus::Tokyo::Cabinet 
-    include Defaults
-       
-    def initialize(options = {})
-      file = options[:file]
-      super("#{file}.tch")
-    end
-    
-    def key?(key)
-      !!self[key]
-    end
-    
-    def [](key)
-      if val = super
-        Marshal.load(val.unpack("m")[0])
-      end
-    end
-    
-    def []=(key, value)
-      super(key, [Marshal.dump(value)].pack("m"))
-    end    
-  end
-  
-  class Rufus < BasicRufus
-    include Expires
-    
-    def initialize(options = {})
-      file = options[:file]
-      @expiration = BasicRufus.new(:file => "#{file}_expires")
-      super
-    end
-  end
-end