juno 0.1.1 → 0.2.0

data/.gitignore

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

data/.travis.yml

@@ -16,7 +16,13 @@ before_install:
   - sudo apt-get install -qq libtokyocabinet8 libtokyocabinet-dev # tokyotyrant
   - sudo /bin/bash /etc/init.d/mongodb start
   - memcached -d -p 22122
+env:
+  - "TASK=test:parallel"
+  - "TASK=test:non_parallel"
 matrix:
   allow_failures:
 #    - rvm: ruby-head
     - rvm: jruby
+    - rvm: rbx-18mode
+    - rvm: rbx-19mode
+script: "bundle exec rake $TASK"

data/Gemfile

@@ -1,21 +1,29 @@
 source :rubygems
 gemspec
 
-if RUBY_VERSION > '1.9'
-  # HACK - Juno::DataMapper and CouchRest don't work currently on 1.8
-  gem 'datamapper'
-  gem 'dm-sqlite-adapter'
-  gem 'couchrest'
-end
+# Testing
+gem 'rake'
+gem 'rspec'
+gem 'parallel_tests'
+
+# Serializer
+#gem 'tnetstring'
+gem 'msgpack'
+gem 'bson'
+gem 'multi_json'
+gem 'json' # Ripple/Riak needs json
 
+# Backends
+gem 'datamapper'
+gem 'dm-sqlite-adapter'
 gem 'fog'
 gem 'activerecord'
 gem 'redis'
 gem 'mongo'
+gem 'couchrest'
 gem 'sequel'
 gem 'dalli'
-gem 'json' # Ripple/Riak needs json
-gem 'ripple'
+gem 'riak-client'
 
 if defined?(JRUBY_VERSION)
   gem 'jdbc-sqlite3'
@@ -29,4 +37,3 @@ end
 
 #gem 'cassandra'
 #gem 'localmemcache'
-#gem 'tokyotyrant'

data/README.md

@@ -9,38 +9,64 @@ fork was that Moneta was unmaintained for a long time.
 
 Out of the box, it supports:
 
-* File Store
-* Memcached store (memcached and dalli)
-* In-memory store
-* DataMapper
-* BerkeleyDB (dbm)
-* GDBM
-* SDBM
-* Redis
-* Riak
-* TokyoCabinet
-* CouchDB
-* MongoDB
-* ActiveRecord
-* YAML store
-* PStore
-* LocalMemCache
-* Sequel
-* Sqlite3
-* Fog cloud storage (Amazon S3, Rackspace, ...)
-* Cassandra
+* Memory:
+    * In-memory store (:Memory)
+    * LocalMemCache (:LocalMemCache)
+    * Memcached store (:Memcached, :MemcachedNative and :MemcachedDalli)
+* Relational Databases:
+    * DataMapper (:DataMapper)
+    * ActiveRecord (:ActiveRecord)
+    * Sequel (:Sequel)
+    * Sqlite3 (:Sqlite)
+* Filesystem:
+    * PStore (:PStore)
+    * YAML store (:YAML)
+    * Filesystem directory store (:File)
+    * Filesystem directory store which spreads files in subdirectories using md5 hash (:HashFile)
+* Key/value databases:
+    * Berkeley DB (:DBM)
+    * GDBM (:GDBM)
+    * SDBM (:SDBM)
+    * Redis (:Redis)
+    * Riak (:Riak)
+    * TokyoCabinet (:TokyoCabinet)
+    * Cassandra (:Cassandra)
+* Document databases:
+    * CouchDB (:Couch)
+    * MongoDB (:Mongo)
+* Other
+    * Fog cloud storage which supports Amazon S3, Rackspace, etc. (:Fog)
+    * Storage which doesn't store anything (:Null)
+
+Special proxies:
+* Juno::Expires to add expiration support to stores
+* Juno::Stack to stack multiple stores
+* Juno::Proxy basic proxy class
+* Juno::Transformer transforms keys and values (Marshal, YAML, JSON, Base64, MD5, ...)
+* Juno::Cache combine two stores, one as backend and one as cache (e.g. Juno::Adapters::File + Juno::Adapters::Memory)
 
 The Juno API is purposely extremely similar to the Hash API. In order so support an
 identical API across stores, it does not support iteration or partial matches.
 
-The API
-=======
+Links
+-----
 
-```
+* Source: <http://github.com/minad/juno>
+* Bugs:   <http://github.com/minad/juno/issues>
+* API documentation:
+    * Latest Gem: <http://rubydoc.info/gems/juno/frames>
+    * GitHub master: <http://rubydoc.info/github/minad/juno/master/frames>
+
+Store API
+---------
+
+~~~
 #initialize(options)              options differs per-store, and is used to set up the store
 
 #[](key)                          retrieve a key. if the key is not available, return nil
 
+#load(key, options = {})          retrieve a key. if the key is not available, return nil
+
 #fetch(key, options = {}, &block) retrieve a key. if the key is not available, execute the
                                   block and return its return value.
 
@@ -58,28 +84,60 @@ The API
 #clear(options = {})              clear all keys in this store
 
 #close                            close database connection
-```
+~~~
+
+Creating a Store
+----------------
+
+There is a simple interface to create a store using `Juno.new`:
 
-Proxy store & Expiry
-====================
+~~~ ruby
+store = Juno.new(:Memcached, :server => 'localhost:11211')
+~~~
 
-The memcached and redis backends supports expires values directly:
+If you want to have control over the proxies, you have to use `Juno.build`:
 
-```ruby
-cache = Juno::Memcached.new
+~~~ ruby
+store = Juno.build do
+  # Adds expires proxy
+  use :Expires
+  # Transform key and value using Marshal
+  use :Transformer, :key => :marshal, :value => :marshal
+  # Memory backend
+  adapter :Memory
+end
+
+Expiration
+----------
+
+The Cassandra, Memcached and Redis backends supports expires values directly:
+
+~~~ ruby
+cache = Juno::Adapters::Memcached.new
 # Expires in 10 seconds
 cache.store(key, value, :expires => 10)
-```
+
+# Or using the builder...
+cache = Juno.build do
+  adapter :Memcached
+end
+~~~
 
 You can add the expires feature to other backends using the Expires proxy:
 
-```ruby
-cache = Juno::Expires.new(Juno::File.new(...))
+~~~ ruby
+cache = Juno::Expires.new(Juno::Adapters::File.new(:dir => '...'))
 cache.store(key, value, :expires => 10)
-```
+
+# Or using the builder...
+cache = Juno.build do
+  use :Expires
+  adapter :File, :dir => '...'
+end
+~~~
 
 Authors
-=======
+-------
 
 * Moneta originally by wycats
 * Juno by Daniel Mendler

data/Rakefile

@@ -4,12 +4,30 @@ begin
 rescue Exception
 end
 
-require 'rake/testtask'
+task :test => %w(test:parallel test:non_parallel)
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib' << 'test'
-  t.test_files = FileList['test/test_*.rb']
-  t.verbose = true
+# 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 15 #{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/benchmarks/run.rb

@@ -34,25 +34,24 @@ class HackedArray < Array
 end
 
 stores = {
-  'Redis' => { },
-  'MemcachedDalli' => { :server => "localhost:11211", :namespace => 'juno_dalli' },
-  'MemcachedNative' => { :server => "localhost:11211", :namespace => 'juno_native' },
-  #'MongoDB' => { :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' => { :db => "sqlite:/" },
-  'ActiveRecord' => { :connection => { :adapter  => 'sqlite3', :database => ':memory:' } },
-  'Sequel' => { :db => "sqlite:/" },
-  # 'Couch' => {:db => "couch_test"},
+  :Redis => { },
+  :MemcachedDalli => { :server => "localhost:11211", :namespace => 'juno_dalli' },
+  :MemcachedNative => { :server => "localhost:11211", :namespace => 'juno_native' },
+  #:MongoDB => { :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
@@ -94,12 +93,10 @@ puts "Lenght Stats   % 10i % 10i % 10i % 10i " % [vlen_min, vlen_max, vlen_ttl,
 
 
 stores.each do |name, options|
-  cname = options.delete(:class_name) || name
   puts "======================================================================"
   puts name
   puts "----------------------------------------------------------------------"
-  klass = Juno.const_get(cname)
-  @cache = klass.new(options)
+  @cache = Juno.new(name, options)
   stats[name] = {
     :writes => [],
     :reads => [],

data/juno.gemspec

@@ -16,7 +16,4 @@ Gem::Specification.new do |s|
   s.homepage = 'http://github.com/minad/juno'
   s.require_paths = ['lib']
   s.summary = %{A unified interface to key/value stores, including MongoDB, Redis, Tokyo, and ActiveRecord}
-
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'minitest'
 end

data/lib/juno/adapters/activerecord.rb

@@ -0,0 +1,58 @@
+require 'active_record'
+
+module Juno
+  module Adapters
+    class ActiveRecord < Base
+      def self.tables
+        @tables ||= {}
+      end
+
+      attr_reader :table
+
+      def initialize(options = {})
+        table = options[:table] || 'juno'
+        @table = self.class.tables[table] ||= begin
+                                                c = Class.new(::ActiveRecord::Base)
+                                                c.table_name = table
+                                                c
+                                              end
+        @table.establish_connection(options[:connection]) if options[:connection]
+        @table.connection.create_table @table.table_name do |t|
+          t.binary 'key', :primary => true
+          t.binary 'value'
+        end unless @table.table_exists?
+      end
+
+      def key?(key, options = {})
+        !!@table.find_by_key(key)
+      end
+
+      def load(key, options = {})
+        record = @table.find_by_key(key)
+        record ? record.value : nil
+      end
+
+      def delete(key, options = {})
+        record = @table.find_by_key(key)
+        if record
+          value = record.value
+          record.destroy
+          value
+        end
+      end
+
+      def store(key, value, options = {})
+        record = @table.find_by_key(key)
+        record ||= @table.new(:key => key)
+        record.value = value
+        record.save!
+        value
+      end
+
+      def clear(options = {})
+        @table.delete_all
+        self
+      end
+    end
+  end
+end

data/lib/juno/adapters/cassandra.rb

@@ -0,0 +1,47 @@
+# Copyright: 2011 TMX Credit
+# Author: Potapov Sergey (aka Blake)
+
+require 'cassandra'
+
+module Juno
+  module Adapters
+    class Cassandra < Base
+      def initialize(options = {})
+        options[:keyspace] ||= 'Juno'
+        options[:host]     ||= '127.0.0.1'
+        options[:port]     ||=  9160
+        @column_family = options[:column_family] || :Juno
+        @client = ::Cassandra.new(options[:keyspace], "#{options[:host]}:#{options[:port]}")
+      end
+
+      def key?(key, options = {})
+        @client.exists?(@column_family, key)
+      end
+
+      def load(key, options = {})
+        value = @client.get(@column_family, key)
+        value ? value['value'] : nil
+      end
+
+      def delete(key, options = {})
+        if value = load(key, options)
+          @client.remove(@column_family, key)
+          value
+        end
+      end
+
+      def store(key, value, options = {})
+        @client.insert(@column_family, key,
+                       {'value' => value}, :ttl => options[:expires])
+        value
+      end
+
+      def clear(options = {})
+        @client.each_key(@column_family) do |key|
+          delete(key)
+        end
+        self
+      end
+    end
+  end
+end

data/lib/juno/adapters/couch.rb

@@ -0,0 +1,43 @@
+require 'couchrest'
+
+module Juno
+  module Adapters
+    class Couch < Base
+      def initialize(options = {})
+        @db = ::CouchRest.database!(options[:db])
+      end
+
+      def key?(key, options = {})
+        !!@db.get(key)
+      rescue RestClient::ResourceNotFound
+        false
+      end
+
+      def load(key, options = {})
+        @db.get(key)['data']
+      rescue RestClient::ResourceNotFound
+        nil
+      end
+
+      def store(key, value, options = {})
+        @db.save_doc('_id' => key, 'data' => value)
+        value
+      rescue RestClient::RequestFailed
+        value
+      end
+
+      def delete(key, options = {})
+        value = @db.get(key)
+        @db.delete_doc('_id' => value['_id'], '_rev' => value['_rev'])
+        value['data']
+      rescue RestClient::ResourceNotFound
+        nil
+      end
+
+      def clear(options = {})
+        @db.recreate!
+        self
+      end
+    end
+  end
+end

data/lib/juno/adapters/datamapper.rb

@@ -0,0 +1,64 @@
+require 'dm-core'
+require 'dm-migrations'
+
+module Juno
+  module Adapters
+    class DataMapper < Base
+      class Store
+        include ::DataMapper::Resource
+        property :k, String, :key => true
+        property :v, Object, :lazy => false
+      end
+
+      def initialize(options = {})
+        raise 'No option :setup specified' unless options[:setup]
+        @repository = options.delete(:repository) || :juno
+        Store.storage_names[@repository] = (options.delete(:table) || :juno).to_s
+        ::DataMapper.setup(@repository, options[:setup])
+        context { Store.auto_upgrade! }
+      end
+
+      def key?(key, options = {})
+        context { !!Store.get(key) }
+      end
+
+      def load(key, options = {})
+        context do
+          record = Store.get(key)
+          record ? record.v : nil
+        end
+      end
+
+      def store(key, value, options = {})
+        context do
+          record = Store.get(key)
+          if record
+            record.update(key, value)
+          else
+            Store.create(:k => key, :v => value)
+          end
+        end
+        value
+      end
+
+      def delete(key, options = {})
+        context do
+          value = load(key, options)
+          Store.all(:k => key).destroy!
+          value
+        end
+      end
+
+      def clear(options = {})
+        context { Store.all.destroy! }
+        self
+      end
+
+      private
+
+      def context
+        ::DataMapper.repository(@repository) { yield }
+      end
+    end
+  end
+end

data/lib/juno/adapters/dbm.rb

@@ -0,0 +1,17 @@
+require 'dbm'
+
+module Juno
+  module Adapters
+    class DBM < Memory
+      def initialize(options = {})
+        raise 'No option :file specified' unless options[:file]
+        @memory = ::DBM.new(options[:file])
+      end
+
+      def close
+        @memory.close
+        nil
+      end
+    end
+  end
+end

data/lib/juno/adapters/file.rb

@@ -0,0 +1,58 @@
+require 'fileutils'
+
+module Juno
+  module Adapters
+    class File < Base
+      def initialize(options = {})
+        raise 'No option :dir specified' unless @dir = options[:dir]
+        FileUtils.mkpath(@dir)
+        raise "#{@dir} is not a dir" unless ::File.directory?(@dir)
+      end
+
+      def key?(key, options = {})
+        ::File.exist?(store_path(key))
+      end
+
+      def load(key, options = {})
+        ::File.read(store_path(key))
+      rescue Errno::ENOENT
+      end
+
+      def store(key, value, options = {})
+        path = store_path(key)
+        temp_file = ::File.join(@dir, "value-#{$$}-#{Thread.current.object_id}")
+        FileUtils.mkpath(::File.dirname(path))
+        ::File.open(temp_file, 'wb') {|file| file.write(value) }
+        ::File.unlink(path) if ::File.exist?(path)
+        ::File.rename(temp_file, path)
+        value
+      rescue Errno::ENOENT
+        ::File.unlink(temp_file) rescue nil
+        value
+      end
+
+      def delete(key, options = {})
+        value = load(key, options)
+        ::File.unlink(store_path(key))
+        value
+      rescue Errno::ENOENT
+      end
+
+      def clear(options = {})
+        temp_dir = "#{@dir}-#{$$}-#{Thread.current.object_id}"
+        ::File.rename(@dir, temp_dir)
+        FileUtils.mkpath(@dir)
+        FileUtils.rm_rf(temp_dir)
+        self
+      rescue Errno::ENOENT
+        self
+      end
+
+      protected
+
+      def store_path(key)
+        ::File.join(@dir, key)
+      end
+    end
+  end
+end

data/lib/juno/adapters/fog.rb

@@ -0,0 +1,42 @@
+require 'fog'
+
+module Juno
+  module Adapters
+    class Fog < Base
+      def initialize(options = {})
+        raise 'No option :dir specified' unless dir = options.delete(:dir)
+        storage = ::Fog::Storage.new(options)
+        @directory = storage.directories.create(:key => dir)
+      end
+
+      def key?(key, options = {})
+        !!@directory.files.head(key)
+      end
+
+      def load(key, options = {})
+        value = @directory.files.get(key)
+        value ? value.body : nil
+      end
+
+      def delete(key, options = {})
+        if value = @directory.files.get(key)
+          body = value.body
+          value.destroy
+          body
+        end
+      end
+
+      def store(key, value, options = {})
+        @directory.files.create(:key => key, :body => value)
+        value
+      end
+
+      def clear(options = {})
+        @directory.files.all.each do |file|
+          file.destroy
+        end
+        self
+      end
+    end
+  end
+end

data/lib/juno/adapters/gdbm.rb

@@ -0,0 +1,17 @@
+require 'gdbm'
+
+module Juno
+  module Adapters
+    class GDBM < Memory
+      def initialize(options = {})
+        raise 'No option :file specified' unless options[:file]
+        @memory = ::GDBM.new(options[:file])
+      end
+
+      def close
+        @memory.close
+        nil
+      end
+    end
+  end
+end