juno 0.3.1 → 0.4.0

data/.gitignore

@@ -1,6 +0,0 @@
-spec/tmp
-*~
-*.swp
-*.rdb
-benchmarks/bench.*
-Gemfile.lock

data/.travis.yml

@@ -1,30 +0,0 @@
-rvm:
-  - 1.8.7
-  - 1.9.3
-#  - ruby-head
-  - jruby
-  - rbx-18mode
-  - rbx-19mode
-services:
-  - riak
-  - couchdb
-  - redis-server
-  - cassandra
-  - memcached
-  - mongodb
-before_install:
-  - sudo apt-get install -qq libtokyocabinet8 libtokyocabinet-dev liblzo2-dev
-env:
-  - "TASK=test:parallel"
-  - "TASK=test:non_parallel"
-matrix:
-  allow_failures:
-#    - rvm: ruby-head
-    - rvm: jruby
-    - rvm: rbx-18mode
-    - rvm: rbx-19mode
-  # Parallel tests do not work on jruby
-  exclude:
-    - rvm: jruby
-      env: "TASK=test:parallel"
-script: "bundle exec rake $TASK"

data/Gemfile

@@ -1,56 +0,0 @@
-source :rubygems
-gemspec
-
-def alternatives(gems)
-  if defined?(JRUBY_VERSION)
-    [gems[:jruby]].flatten.compact.each {|g| gem g }
-  else
-    [gems[:mri]].flatten.compact.each {|g| gem g }
-  end
-end
-
-# Testing
-gem 'rake'
-gem 'rspec'
-gem 'parallel_tests'
-
-# Serializer used by Transformer
-gem 'tnetstring'
-gem 'bencode'
-gem 'multi_json'
-alternatives :mri => 'bson_ext', :jruby => 'bson'
-alternatives :mri => 'ox'
-alternatives :mri => 'msgpack', :jruby => 'msgpack-jruby'
-alternatives :mri => 'bert'
-
-# Compressors used by Transformer
-alternatives :mri => 'bzip2-ruby'
-alternatives :mri => 'ruby-lzma'
-alternatives :mri => 'qlzruby'
-alternatives :mri => 'lzoruby'
-alternatives :mri => 'snappy'
-
-# Backends
-gem 'dm-core'
-gem 'dm-migrations'
-gem 'dm-sqlite-adapter'
-gem 'fog'
-gem 'activerecord', '>= 3.2.9'
-gem 'redis'
-gem 'mongo'
-gem 'couchrest'
-gem 'sequel'
-gem 'dalli'
-gem 'riak-client'
-gem 'cassandra'
-#gem 'hbaserb'
-#gem 'localmemcache'
-alternatives :mri => 'leveldb-ruby'
-alternatives :mri => 'tokyocabinet'
-alternatives :mri => 'memcached', :jruby => 'jruby-memcached'
-alternatives :mri => 'sqlite3', :jruby => %w(jdbc-sqlite3 activerecord-jdbc-adapter activerecord-jdbcsqlite3-adapter)
-alternatives :jruby => %w(ffi gdbm) # gdbm for jruby needs ffi
-
-# Integration
-gem 'rack'
-gem 'rack-cache'

data/LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2009 Yehuda Katz, 2012 Daniel Mendler
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -1,33 +0,0 @@
-begin
-  require 'bundler'
-  Bundler::GemHelper.install_tasks
-rescue Exception
-end
-
-task :test => %w(test:parallel test:non_parallel)
-
-# memcached and redis specs cannot be used in parallel
-# because of flushing and namespace lacking in redis
-
-namespace :test do
-  task :parallel do
-    if defined?(JRUBY_VERSION)
-      puts 'No tests executed in parallel in JRuby'
-    else
-      specs = Dir['spec/*/*_spec.rb'].reject {|s| s =~ /memcached|redis/ }
-      sh("parallel_rspec -m 5 #{specs.join(' ')}")
-    end
-  end
-
-  task :non_parallel do
-    if defined?(JRUBY_VERSION)
-      # Run all tests in jruby non-parallel
-      sh('rspec spec/*/*_spec.rb')
-    else
-      specs = Dir['spec/*/*_spec.rb'].select {|s| s =~ /memcached|redis/ }
-      sh("rspec #{specs.join(' ')}")
-    end
-  end
-end
-
-task :default => :test

data/SPEC.md

@@ -1,71 +0,0 @@
-# Juno Specification
-
-The purpose of the juno specification is to create a general-purpose API for interacting with key-value stores. In general, libraries that need to interact with key-value stores should be able to specify that they can use any "juno-compliant store".
-
-# Juno Executable Specs
-
-Juno ships with a set of executable specs which you can use to verify spec-compliance with your juno adapter.
-
-# Requirements for a Juno Adapter
-
-(See RFC 2119 for use of MUST, SHOULD, MAY, MUST NOT, and SHOULD NOT)
-
-A Juno adapter must expose a class with the following characteristics:
-
-## Class Methods
-
-### <code>new(options[Hash]) => Object</code>
-
-Return an instance of the juno adapter, with the instance methods listed below. The <code>options</code> hash is a required parameter, and the adapter may specify whatever additional requirements it needs to properly instantiate it.
-
-## Instance Methods
-
-### <code>\[\](key[Object]) => Object</code>
-
-Return the value stored in the key-value-store under the provided key. Adapters MUST return a duplicate of the original value, and consumers should expect that adapters might serialize and deserialize the key and value. As a result, both the key and value MUST be objects that can be serialized using Ruby's Marshal system.
-
-### <code>\[\]=(key[Object], value[Object]) => Object(value)</code>
-
-Store the value in the key-value-store under the provided key. Adapters MAY serialize the value using Ruby's Marshal system, and MUST NOT store a reference to the original value in the store, unless Ruby disallows duplication of the original value. Adapters SHOULD NOT simply call <code>dup</code> on the value, unless the value stores no references to other Object. For example, an adapter MAY store a <code>dup</code> of a String, but SHOULD NOT store a <code>dup</code> of <code>["hello", "world"]</code>.
-
-### <code>fetch(key[Object], &block) => Object</code>
-
-Return the value stored in the key-value-store under the provided key. If no value is stored under the provided key, the adapter MUST yield to the block, and return the value. The adapter MUST NOT store the value returned from the block in the key-value-store.
-
-### <code>fetch(key[Object], value[Object]) => Object</code>
-
-Return the value stored in the key-value-store under the provided key. If no value is stored under the provided key, the adapter MUST return the default value provided. The adapter MUST NOT store the default value in the key-value-store.
-
-### <code>delete(key[Object]) => Object</code>
-
-Delete the value stored in the key-value-store for the key provided, and return the value previously stored there. After this operation, the key-value-store MUST behave as though no value was stored for the provided key.
-
-### <code>key?(key[Object]) => [TrueClass, FalseClass]</code>
-
-Determine whether a value exists in the key-value-store for the key provided. If a value exists, the adapter MUST return <code>true</code>. Otherwise, the adapter MUST return <code>false</code>.
-
-### <code>store(key[Object], value[Object]) => Object(value)</code>
-
-Behaves the same as <code>[]=</code>, but allows the client to send additional options which can be specified by the adapter (and which may be specified by extensions to this specification).
-
-### <code>clear</code>
-
-Completely empty all keys and values from the key-value-store. Adapters MAY allow a namespace during initialization, which can scope this operation to a particular subset of keys. After calling <code>clear</code>, a <code>[]</code> operation MUST return nil for every possible key, and a <code>key?</code> query MUST return false for every possible key.
-
-# Additional Options Hashes
-
-The following methods may all take an additional Hash as a final argument. This allows the client to send additional options which can be specified by the adapter (and which may be specified by extensions to this specification).
-
-* fetch
-* load
-* store
-* delete
-* key?
-* clear
-
-In the case of methods with optional arguments, the Hash MUST be provided as the final argument. Keys in this Hash MUST be Symbols.
-
-# Atomicity
-
-The base Juno specification does not specify any atomicity guarantees. However, extensions to this spec may specify extensions that define additional guarantees for any of the defined operations.
-

data/benchmarks/run.rb

@@ -1,180 +0,0 @@
-#!/usr/bin/env ruby
-
-$: << File.join(File.dirname(__FILE__), '..', 'lib')
-require 'benchmark'
-require 'juno'
-
-begin
-  require 'dm-core'
-  DataMapper.setup(:default, :adapter => :in_memory)
-rescue LoadError
-end
-
-# 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
-
-stores = {
-  :Redis => { },
-  :MemcachedDalli => { :server => "localhost:11211", :namespace => 'juno_dalli' },
-  :MemcachedNative => { :server => "localhost:11211", :namespace => 'juno_native' },
-  :Mongo => { :host => 'localhost', :port => 27017, :db => 'juno_bench' },
-  :LocalMemCache => { :file => "bench.lmc" },
-  :DBM => { :file => "bench.dbm" },
-  :SDBM => { :file => "bench.sdbm" },
-  :GDBM => { :file => "bench.gdbm" },
-  :Sqlite => { :file => ":memory:" },
-  :Memory => { },
-  :YAML => { :file => "bench.yaml" },
-  :PStore => { :file => "bench.pstore" },
-  :File => { :dir => "bench.file" },
-  :HashFile => { :dir => "bench.hashfile" },
-  :DataMapper => { :setup => "sqlite3::memory:" },
-  :ActiveRecord => { :connection => { :adapter  => 'sqlite3', :database => ':memory:' } },
-  :Sequel => { :db => "sqlite:/" },
-  :Couch => {:db => "couch_test"},
-}
-
-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 Juno 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]
-
-
-stores.each do |name, options|
-  begin
-    @cache = Juno.new(name, options)
-    @cache['test'] = 'test'
-    @cache.clear
-  rescue Exception => ex
-    puts "#{name} not benchmarked - #{ex.message}"
-    next
-  end
-  puts "======================================================================"
-  puts name
-  puts "----------------------------------------------------------------------"
-  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 "======================================================================"

data/lib/juno/adapters/activerecord.rb

@@ -1,74 +0,0 @@
-require 'active_record'
-
-module Juno
-  module Adapters
-    # ActiveRecord as key/value stores
-    # @api public
-    class ActiveRecord < Base
-      def self.tables
-        @tables ||= {}
-      end
-
-      attr_reader :table
-
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :table - Table name (default juno)
-      # * :connection - ActiveRecord connection
-      def initialize(options = {})
-        table = options[:table] || 'juno'
-        @table = self.class.tables[table] ||=
-          begin
-            c = Class.new(::ActiveRecord::Base)
-            c.table_name = table
-            c.primary_key = :k
-            c
-          end
-        @table.establish_connection(options[:connection]) if options[:connection]
-        unless @table.table_exists?
-          @table.connection.create_table(@table.table_name, :id => false) do |t|
-            # Do not use binary columns (Issue #17)
-            t.string :k, :null => false
-            t.string :v
-          end
-          @table.connection.add_index(@table.table_name, :k, :unique => true)
-        end
-      end
-
-      def key?(key, options = {})
-        @table.find_by_k(key) != nil
-      end
-
-      def load(key, options = {})
-        record = @table.find_by_k(key)
-        record ? record.v : nil
-      end
-
-      def delete(key, options = {})
-        @table.transaction do
-          record = @table.find_by_k(key)
-          if record
-            record.destroy
-            record.v
-          end
-        end
-      end
-
-      def store(key, value, options = {})
-        @table.transaction do
-          record = @table.find_or_initialize_by_k(key)
-          record.update_attributes(:v => value)
-          value
-        end
-      end
-
-      def clear(options = {})
-        @table.delete_all
-        self
-      end
-    end
-  end
-end