juno 0.3.0 → 0.3.1

data/Gemfile

@@ -24,6 +24,7 @@ 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'
@@ -41,8 +42,8 @@ gem 'couchrest'
 gem 'sequel'
 gem 'dalli'
 gem 'riak-client'
-gem 'hashery'
 gem 'cassandra'
+#gem 'hbaserb'
 #gem 'localmemcache'
 alternatives :mri => 'leveldb-ruby'
 alternatives :mri => 'tokyocabinet'

data/README.md

@@ -26,7 +26,7 @@ Out of the box, it supports the following backends:
 
 * Memory:
     * In-memory store (`:Memory`)
-    * LRU hash (`:LRUHash`)
+    * LRU hash - prefer this over :Memory! (`:LRUHash`)
     * LocalMemCache (`:LocalMemCache`)
     * Memcached store (`:Memcached`, `:MemcachedNative` and `:MemcachedDalli`)
 * Relational Databases:
@@ -41,13 +41,14 @@ Out of the box, it supports the following backends:
     * Filesystem directory store which spreads files in subdirectories using md5 hash (`:HashFile`)
 * Key/value databases:
     * Berkeley DB (`:DBM`)
+    * Cassandra (`:Cassandra`)
     * GDBM (`:GDBM`)
-    * SDBM (`:SDBM`)
+    * HBase (`:HBase`)
+    * LevelDB (`:LevelDB`)
     * Redis (`:Redis`)
     * Riak (`:Riak`)
+    * SDBM (`:SDBM`)
     * TokyoCabinet (`:TokyoCabinet`)
-    * Cassandra (`:Cassandra`)
-    * LevelDB (`:LevelDB`)
 * Document databases:
     * CouchDB (`:Couch`)
     * MongoDB (`:Mongo`)
@@ -181,6 +182,10 @@ end
 
 # Expires in 60 seconds
 cache.store(key, value, :expires => 60)
+
+# Update expires time if value is found
+cache.load(key, :expires => 30)
+cache.key?(key, :expires => 30)
 ~~~
 
 You can add the expires feature to other backends using the Expires proxy:

data/lib/juno.rb

@@ -19,6 +19,7 @@ module Juno
     autoload :File,            'juno/adapters/file'
     autoload :Fog,             'juno/adapters/fog'
     autoload :GDBM,            'juno/adapters/gdbm'
+    autoload :HBase,           'juno/adapters/hbase'
     autoload :LevelDB,         'juno/adapters/leveldb'
     autoload :LocalMemCache,   'juno/adapters/localmemcache'
     autoload :LRUHash,         'juno/adapters/lruhash'
@@ -52,9 +53,9 @@ module Juno
   # * :threadsafe - If true, ensure that the store is thread safe by inserting Juno::Lock
   # * :logger - If true or Hash, add logger to chain (Hash is passed to logger as options)
   # * :compress - If true, compress value with zlib, or specify custom compress, e.g. :quicklz
-  # * :serializer - Serializer used for key and value (default :marshal, disable with nil)
-  # * :key_serializer - Serializer used for key (default options[:serializer])
-  # * :value_serializer - Serializer used for key (default options[:serializer])
+  # * :serializer - Serializer used for key and value, disable with nil (default :marshal)
+  # * :key_serializer - Serializer used for key, disable with nil (default options[:serializer] if not provided)
+  # * :value_serializer - Serializer used for key, disable with nil (default options[:serializer] if not provided)
   # * :prefix - Key prefix used for namespacing (default none)
   # * All other options passed to the adapter
   #
@@ -68,15 +69,15 @@ module Juno
     logger = options.delete(:logger)
     threadsafe = options.delete(:threadsafe)
     compress = options.delete(:compress)
-    serializer = options.delete(:serializer) || :marshal
-    key_serializer = options.delete(:key_serializer) || serializer
-    value_serializer = options.delete(:value_serializer) || serializer
+    serializer = options.include?(:serializer) ? options.delete(:serializer) : :marshal
+    key_serializer = options.include?(:key_serializer) ? options.delete(:key_serializer) : serializer
+    value_serializer = options.include?(:value_serializer) ? options.delete(:value_serialiizer) : serializer
     transformer = { :key => [key_serializer], :value => [value_serializer], :prefix => options.delete(:prefix) }
     transformer[:key] << :prefix if transformer[:prefix]
     transformer[:value] << (Symbol === compress ? compress : :zlib) if compress
     raise ArgumentError, 'Name must be Symbol' unless Symbol === name
     case name
-    when :Sequel, :ActiveRecord, :Couch
+    when :Sequel, :ActiveRecord, :Couch, :DataMapper
       # Sequel accept only base64 keys and values
       # FIXME: Couch should work only with :marshal but this raises an error on 1.9
       transformer[:key] << :base64
@@ -85,8 +86,8 @@ module Juno
       # Memcached accept only base64 keys, expires already supported
       expires = false
       transformer[:key] << :base64
-    when :PStore, :YAML, :DataMapper, :Null
-      # For PStore, YAML and DataMapper only the key has to be a string
+    when :PStore, :YAML, :Null
+      # For PStore and YAML only the key has to be a string
       transformer.delete(:value) if transformer[:value] == [:marshal]
     when :HashFile
       # Use spreading hashes

data/lib/juno/adapters/activerecord.rb

@@ -39,7 +39,7 @@ module Juno
       end
 
       def key?(key, options = {})
-        !!@table.find_by_k(key)
+        @table.find_by_k(key) != nil
       end
 
       def load(key, options = {})

data/lib/juno/adapters/cassandra.rb

@@ -45,7 +45,14 @@ module Juno
       end
 
       def key?(key, options = {})
-        @client.exists?(@cf, key)
+        if @client.exists?(@cf, key)
+          if options.include?(:expires) && (value = load(key))
+            store(key, value, options)
+          end
+          true
+        else
+          false
+        end
       end
 
       def load(key, options = {})

data/lib/juno/adapters/couch.rb

@@ -17,7 +17,7 @@ module Juno
       end
 
       def key?(key, options = {})
-        !!@db.get(key)
+        @db.get(key) != nil
       rescue RestClient::ResourceNotFound
         false
       end

data/lib/juno/adapters/datamapper.rb

@@ -8,8 +8,8 @@ module Juno
     class DataMapper < Base
       class Store
         include ::DataMapper::Resource
-        property :k, String, :key => true
-        property :v, Object, :lazy => false
+        property :k, Text, :key => true
+        property :v, Text, :lazy => false
       end
 
       # Constructor
@@ -29,7 +29,7 @@ module Juno
       end
 
       def key?(key, options = {})
-        context { !!Store.get(key) }
+        context { Store.get(key) != nil }
       end
 
       def load(key, options = {})

data/lib/juno/adapters/fog.rb

@@ -19,7 +19,7 @@ module Juno
       end
 
       def key?(key, options = {})
-        !!@directory.files.head(key)
+        @directory.files.head(key) != nil
       end
 
       def load(key, options = {})

data/lib/juno/adapters/hbase.rb

@@ -0,0 +1,64 @@
+require 'hbaserb'
+
+module Juno
+  module Adapters
+    # HBase thrift backend
+    # @api public
+    class HBase < Base
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :host - Server host name (default 127.0.0.1)
+      # * :port - Server port (default 9090)
+      # * :table - Table name (default juno)
+      # * :column_family - Column family (default juno)
+      # * :column - Column (default value)
+      def initialize(options = {})
+        options[:host] ||= '127.0.0.1'
+        options[:port] ||= '9090'
+        options[:table] ||= 'juno'
+        options[:column] ||= 'value'
+        cf = (options[:column_family] || 'juno')
+        @db = HBaseRb::Client.new(options[:host], options[:port])
+        @db.create_table(options[:table], cf) unless @db.has_table?(options[:table])
+        @table = @db.get_table(options[:table])
+        @column = "#{cf}:#{options[:column]}"
+      end
+
+      def key?(key, options = {})
+        @table.get(key, @column).first != nil
+      end
+
+      def load(key, options = {})
+        value = @table.get(key, @column).first
+        value ? value.value : nil
+      end
+
+      def delete(key, options = {})
+        if value = load(key, options)
+          @table.delete_row(key)
+          value
+        end
+      end
+
+      def store(key, value, options = {})
+        @table.mutate_row(key, @column => value)
+        value
+      end
+
+      def clear(options = {})
+        @table.create_scanner do |row|
+          @table.delete_row(row.row)
+        end
+        self
+      end
+
+      def close
+        @db.close
+        nil
+      end
+    end
+  end
+end

data/lib/juno/adapters/lruhash.rb

@@ -1,18 +1,82 @@
-require 'hashery/lru_hash'
-
 module Juno
   module Adapters
     # LRUHash backend
+    #
+    # Based on Hashery::LRUHash but simpler and measures memory usage instead of hash size.
+    #
     # @api public
-    class LRUHash < Memory
+    class LRUHash < Base
       # Constructor
       #
       # @param [Hash] options
       #
       # Options:
-      # * :max_size - Maximum size of hash (default 1024)
+      # * :max_size - Maximum byte size of hash values (default 1024000)
       def initialize(options = {})
-        @memory = Hashery::LRUHash.new(options[:max_size] || 1024)
+        @max_size = options[:max_size] || 1024000
+        clear
+      end
+
+      def key?(key, options = {})
+        @entry.key?(key)
+      end
+
+      def load(key, options = {})
+        if entry = @entry[key]
+          entry.insert_after(@list)
+          entry.value
+        end
+      end
+
+      def store(key, value, options = {})
+        if entry = @entry[key]
+          @size -= entry.value.bytesize
+        else
+          @entry[key] = entry = Entry.new
+          entry.key = key
+        end
+        entry.value = value
+        @size += entry.value.bytesize
+        entry.insert_after(@list)
+        delete(@list.prev.key) while @list.next != @list.prev && @size > @max_size
+        value
+      end
+
+      def delete(key, options = {})
+        if entry = @entry.delete(key)
+          @size -= entry.value.bytesize
+          entry.unlink
+          entry.value
+        end
+      end
+
+      def clear(options = {})
+        @entry, @size = {}, 0
+        @list = Entry.new
+        @list.prev = @list.next = @list
+        self
+      end
+
+      private
+
+      class Entry
+        attr_accessor :key, :value, :prev, :next
+
+        def unlink
+          @prev.next = @next if @prev
+          @next.prev = @prev if @next
+          @prev = @next = nil
+        end
+
+        def insert_after(entry)
+          if entry.next != self
+            unlink
+            @next = entry.next
+            @prev = entry
+            entry.next.prev = self
+            entry.next = self
+          end
+        end
       end
     end
   end

data/lib/juno/adapters/memcached_dalli.rb

@@ -17,10 +17,6 @@ module Juno
         @cache = ::Dalli::Client.new(server, options)
       end
 
-      def key?(key, options = {})
-        !!@cache.get(key)
-      end
-
       def load(key, options = {})
         value = @cache.get(key)
         if value && options.include?(:expires)

data/lib/juno/adapters/memcached_native.rb

@@ -20,13 +20,6 @@ module Juno
         @cache = ::Memcached.new(server, options)
       end
 
-      def key?(key, options = {})
-        @cache.get(key, false)
-        true
-      rescue ::Memcached::NotFound
-        false
-      end
-
       def load(key, options = {})
         value = @cache.get(key, false)
         if value && options.include?(:expires)

data/lib/juno/adapters/mongo.rb

@@ -23,10 +23,6 @@ module Juno
         @collection = connection.db(db).collection(collection)
       end
 
-      def key?(key, options = {})
-        !!load(key, options)
-      end
-
       def load(key, options = {})
         value = @collection.find_one('_id' => key)
         value ? value['value'].to_s : nil

data/lib/juno/adapters/redis.rb

@@ -13,7 +13,14 @@ module Juno
       end
 
       def key?(key, options = {})
-        @redis.exists(key)
+        if @redis.exists(key)
+          if expires = options[:expires]
+            @redis.expire(key, expires)
+          end
+          true
+        else
+          false
+        end
       end
 
       def load(key, options = {})

data/lib/juno/adapters/sequel.rb

@@ -24,7 +24,7 @@ module Juno
       end
 
       def key?(key, options = {})
-        !!sequel_table[:k => key]
+        sequel_table[:k => key] != nil
       end
 
       def load(key, options = {})

data/lib/juno/adapters/tokyocabinet.rb

@@ -24,10 +24,6 @@ module Juno
         end or raise @memory.errmsg(@memory.ecode)
       end
 
-      def key?(key, options = {})
-        !!load(key, options)
-      end
-
       def delete(key, options = {})
         value = load(key, options)
         if value

data/lib/juno/base.rb

@@ -2,6 +2,16 @@ module Juno
   # Simple interface to key/value stores with Hash-like interface.
   # @api public
   class Base
+    # Exists the value with key
+    #
+    # @param [Object] key
+    # @return [Boolean]
+    # @param [Hash] options
+    # @api public
+    def key?(key, options = {})
+      load(key, options) != nil
+    end
+
     # Explicitly close the store
     # @api public
     def close

data/lib/juno/expires.rb

@@ -7,7 +7,7 @@ module Juno
   # @api public
   class Expires < Proxy
     def key?(key, options = {})
-      !!load(key, options)
+      load(key, options) != nil
     end
 
     def load(key, options = {})

data/lib/juno/transformer.rb

@@ -126,6 +126,7 @@ module Juno
       :ox       => [ :serialize, '::Ox.parse_obj(value)',           '::Ox.dump(value)',                  'ox'            ],
       :tnet     => [ :serialize, '::TNetstring.parse(value).first', '::TNetstring.dump(value)',          'tnetstring'    ],
       :yaml     => [ :serialize, '::YAML.load(value)',              '::YAML.dump(value)',                'yaml'          ],
+      :bzip2    => [ :compress,  '::Bzip2.uncompress(value)',       '::Bzip2.compress(value)',           'bzip2'         ],
       :lzma     => [ :compress,  '::LZMA.decompress(value)',        '::LZMA.compress(value)',            'lzma'          ],
       :lzo      => [ :compress,  '::LZO.decompress(value)',         '::LZO.compress(value)',             'lzoruby'       ],
       :snappy   => [ :compress,  '::Snappy.inflate(value)',         '::Snappy.deflate(value)',           'snappy'        ],

data/lib/juno/version.rb

@@ -1,5 +1,5 @@
 module Juno
   # Juno version number
   # @api public
-  VERSION = '0.3.0'
+  VERSION = '0.3.1'
 end