juno 0.1.0 → 0.1.1

data/.gitignore

@@ -2,3 +2,4 @@ test/tmp
 *~
 *.swp
 *.rdb
+benchmarks/bench.*

data/.travis.yml

@@ -2,7 +2,7 @@ rvm:
   - 1.8.7
   - 1.9.3
 #  - ruby-head
-#  - jruby
+  - jruby
   - rbx-18mode
   - rbx-19mode
 services:
@@ -18,8 +18,5 @@ before_install:
   - memcached -d -p 22122
 matrix:
   allow_failures:
-    - rvm: 1.8.7
 #    - rvm: ruby-head
-    - rvm: rbx-18mode
-    - rvm: rbx-19mode
-
+    - rvm: jruby

data/Gemfile

@@ -1,19 +1,32 @@
 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
+
+gem 'fog'
 gem 'activerecord'
-gem 'sqlite3'
 gem 'redis'
-gem 'datamapper'
-gem 'dm-sqlite-adapter'
-gem 'ripple'
-gem 'tokyocabinet'
 gem 'mongo'
-gem 'couchrest'
 gem 'sequel'
 gem 'dalli'
-gem 'memcached'
+gem 'json' # Ripple/Riak needs json
+gem 'ripple'
+
+if defined?(JRUBY_VERSION)
+  gem 'jdbc-sqlite3'
+  gem 'activerecord-jdbc-adapter'
+  gem 'activerecord-jdbcsqlite3-adapter'
+else
+  gem 'tokyocabinet'
+  gem 'memcached'
+  gem 'sqlite3'
+end
+
 #gem 'cassandra'
 #gem 'localmemcache'
-#gem 'fog'
 #gem 'tokyotyrant'

data/README.md

@@ -27,6 +27,8 @@ Out of the box, it supports:
 * LocalMemCache
 * Sequel
 * Sqlite3
+* Fog cloud storage (Amazon S3, Rackspace, ...)
+* Cassandra
 
 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.
@@ -61,7 +63,7 @@ The API
 Proxy store & Expiry
 ====================
 
-The memcached backend supports expires values directly:
+The memcached and redis backends supports expires values directly:
 
 ```ruby
 cache = Juno::Memcached.new

data/{unsupported/benchmarks.rb → benchmarks/run.rb}

@@ -1,6 +1,9 @@
 #!/usr/bin/env ruby
 require 'benchmark'
-require "rubygems"
+require 'juno'
+require 'dm-core'
+
+DataMapper.setup(:default, :adapter => :in_memory)
 
 # Hacked arrays
 # Array modifications
@@ -30,27 +33,26 @@ class HackedArray < Array
   end
 end
 
-require "../lib/juno"
-require "juno/memcache"
-require "juno/tyrant"
-require "juno/berkeley"
-
-
 stores = {
   'Redis' => { },
-  'Memcached' => { :class_name => "Memcache", :server => "localhost:11211", :namespace => 'juno_bench' },
-  'Tyrant' => { :host => 'localhost', :port => 1978 }, # Breaks for any n > 50 on my machine
-  'MongoDB' => { :host => 'localhost', :port => 27017, :db => 'juno_bench' },
-  'LMC' => { :filename => "bench.lmc" },
-  'Berkeley' => { :file => "bench.bdb" },
-  'Rufus' => {:file => "bench.rufus"},
+  '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"},
-  'TC (Tyrant)' => 
-    {:name => "test.tieredtyrant", :backup => Juno::Tyrant.new(:host => "localhost", :port => 1978), :class_name => "TieredCache"},
-  'TC (Memcached)' => 
-    {:name => "test.tieredmc", :backup => Juno::Memcache.new(:server => "localhost:11211", :namespace => "various"), :class_name => "TieredCache"}
 }
 
 stats, keys, data, errors, summary = {}, [], HackedArray.new, HackedArray.new, HackedArray.new
@@ -90,66 +92,12 @@ puts "                  Minimum    Maximum      Total    Average        xps "
 puts "----------------------------------------------------------------------"
 puts "Lenght Stats   % 10i % 10i % 10i % 10i " % [vlen_min, vlen_max, vlen_ttl, vlen_avg]
 
-module Juno
-  class TieredCache
-    include Juno::Defaults
-  
-    def initialize(options)
-      @bdb = Juno::Berkeley.new(:file => File.join(File.dirname(__FILE__), options[:name]))
-      @mc = options[:backup]
-      # @mc = Juno::Tyrant.new(:host => "localhost", :port => 1978)
-      # @mc  = Juno::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/juno/#{cname.downcase}"
-  rescue LoadError
-  end
   klass = Juno.const_get(cname)
   @cache = klass.new(options)
   stats[name] = {
@@ -164,7 +112,7 @@ stores.each do |name, options|
     m1 = Benchmark.measure do
       n.times do
         key, value = data.random
-          
+
         @cache[key] = value
       end
     end
@@ -221,14 +169,3 @@ 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/lib/juno.rb

@@ -1,15 +1,13 @@
 module Juno
   autoload :ActiveRecord,    'juno/activerecord'
   autoload :Base,            'juno/base'
-  #autoload :Cassandra,       'juno/cassandra'
+  autoload :Cassandra,       'juno/cassandra'
   autoload :Couch,           'juno/couch'
   autoload :DataMapper,      'juno/datamapper'
   autoload :DBM,             'juno/dbm'
   autoload :Expires,         'juno/expires'
   autoload :File,            'juno/file'
-  #autoload :Fog,             'juno/fog'
-  #autoload :S3,              'juno/fog'
-  #autoload :Rackspace,       'juno/fog'
+  autoload :Fog,             'juno/fog'
   autoload :GDBM,            'juno/gdbm'
   autoload :HashFile,        'juno/hashfile'
   autoload :LocalMemCache,   'juno/localmemcache'
@@ -18,12 +16,14 @@ module Juno
   autoload :MemcachedNative, 'juno/memcached_native'
   autoload :Memory,          'juno/memory'
   autoload :MongoDB,         'juno/mongodb'
+  autoload :Null,            'juno/null'
   autoload :Proxy,           'juno/proxy'
   autoload :PStore,          'juno/pstore'
   autoload :Redis,           'juno/redis'
   autoload :Riak,            'juno/riak'
   autoload :SDBM,            'juno/sdbm'
   autoload :Sequel,          'juno/sequel'
+  autoload :Stack,           'juno/stack'
   autoload :Sqlite,          'juno/sqlite'
   autoload :TokyoCabinet,    'juno/tokyocabinet'
   #autoload :TokyoTyrant,     'juno/tokyotyrant'

data/lib/juno/activerecord.rb

@@ -16,12 +16,9 @@ module Juno
                                               c
                                             end
       @table.establish_connection(options[:connection]) if options[:connection]
-    end
-
-    def migrate
       @table.connection.create_table @table.table_name do |t|
-        t.string 'key', :primary => :true
-        t.string 'value'
+        t.binary 'key', :primary => :true
+        t.binary 'value'
       end unless @table.table_exists?
     end
 

data/lib/juno/base.rb

@@ -13,6 +13,10 @@ module Juno
       @store.has_key?(key_for(key))
     end
 
+    def has_key?(key, options = {})
+      key?(key, options)
+    end
+
     # Fetch value with key. Return nil if the key doesn't exist
     #
     # @param [Object] key

data/{unsupported → lib/juno}/cassandra.rb

@@ -9,30 +9,30 @@ module Juno
       options[:keyspace] ||= 'Juno'
       options[:host]     ||= '127.0.0.1'
       options[:port]     ||=  9160
-      @client = ::Cassandra.new(options[:keyspace], "#{options[:host]}:#{options[:port]}")
       @column_family = options[:column_family] || :Juno
+      @client = ::Cassandra.new(options[:keyspace], "#{options[:host]}:#{options[:port]}")
     end
 
     def key?(key, options = {})
-      key = key_for(key)
-      @client.exists?(@column_family, key)
+      @client.exists?(@column_family, key_for(key))
     end
 
     def [](key)
-      key = key_for(key)
-      deserialize(@client.get(@column_family, key)['value'])
+      value = @client.get(@column_family, key_for(key))
+      value ? deserialize(value['value']) : nil
     end
 
     def delete(key, options = {})
-      key = key_for(key)
-      value = self[key]
-      @client.remove(@column_family, key)
-      value
+      if value = self[key]
+        @client.remove(@column_family, key_for(key))
+        value
+      end
     end
 
     def store(key, value, options = {})
-      key = key_for(key)
-      @client.insert(@column_family, key, {'value' => serialize(value)})
+      @client.insert(@column_family, key_for(key),
+                     {'value' => serialize(value)}, :ttl => options[:expires])
+      value
     end
 
     def clear(options = {})

data/lib/juno/datamapper.rb

@@ -12,7 +12,7 @@ module Juno
     def initialize(options = {})
       raise 'No option :setup specified' unless options[:setup]
       @repository = options.delete(:repository) || :juno
-      Store.storage_names[@repository] = options.delete(:table) || :juno
+      Store.storage_names[@repository] = (options.delete(:table) || :juno).to_s
       ::DataMapper.setup(@repository, options[:setup])
       context { Store.auto_upgrade! }
     end

data/{unsupported → lib/juno}/fog.rb

@@ -3,13 +3,13 @@ require 'fog'
 module Juno
   class Fog < Base
     def initialize(options = {})
-      bucket = options.delete(:namespace)
-      cloud = options.delete(:cloud).new(options)
-      @directory = cloud.directories.create(:key => bucket)
+      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_for(key)).nil?
+      !!@directory.files.head(key_for(key))
     end
 
     def [](key)
@@ -21,13 +21,15 @@ module Juno
     def delete(key, options = {})
       value = get(key)
       if value
+        body = deserialize(value.body)
         value.destroy
-        deserialize(value.body)
+        body
       end
     end
 
     def store(key, value, options = {})
       @directory.files.create(:key => key_for(key), :body => serialize(value))
+      value
     end
 
     def clear(options = {})
@@ -43,18 +45,4 @@ module Juno
       @directory.files.get(key_for(key))
     end
   end
-
-  class S3 < Fog
-    def initialize(options = {})
-      options[:cloud] = ::Fog::AWS::S3
-      super
-    end
-  end
-
-  class Rackspace < Fog
-    def initialize(options = {})
-      options[:cloud] = ::Fog::Rackspace::Files
-      super
-    end
-  end
 end

data/lib/juno/null.rb

@@ -0,0 +1,23 @@
+module Juno
+  class Null < Base
+    def key?(key, options = {})
+      false
+    end
+
+    def [](key)
+      nil
+    end
+
+    def store(key, value, options = {})
+      value
+    end
+
+    def delete(key, options = {})
+      nil
+    end
+
+    def clear(options = {})
+      nil
+    end
+  end
+end

data/lib/juno/redis.rb

@@ -10,6 +10,14 @@ module Juno
       @store.exists(key_for(key))
     end
 
+    def fetch(key, value = nil, options = {})
+      result = super
+      if result && expires = options[:expires]
+        @store.expire(key_for(key), expires)
+      end
+      result
+    end
+
     def [](key)
       deserialize(@store.get(key_for(key)))
     end
@@ -22,7 +30,11 @@ module Juno
     end
 
     def store(key, value, options = {})
-      @store.set(key_for(key), serialize(value))
+      key = key_for(key)
+      @store.set(key, serialize(value))
+      if expires = options[:expires]
+        @store.expire(key, expires)
+      end
       value
     end