moneta 0.7.9 → 0.7.10

data/.travis.yml

@@ -8,9 +8,9 @@ rvm:
   - rbx-19mode
 before_install:
   - script/kill-travis
-  - script/start-services
   - script/install-kyotocabinet
-  - sudo apt-get install -qq libtokyocabinet8 libtokyocabinet-dev liblzo2-dev libtdb-dev
+  - sudo apt-get install -qq libtokyocabinet8 libtokyocabinet-dev liblzo2-dev libtdb-dev tokyotyrant
+  - script/start-services
   - script/install-bundle
   - script/upload-bundle
 install: 'echo "Bundle installed"'

data/CHANGES

@@ -1,3 +1,9 @@
+0.7.10
+
+* Adapters::TokyoTyrant added
+* Add attr_reader :backend and option :backend to some adapters
+* Cache rename #backend to #adapter
+
 0.7.9
 
 * Adapters::KyotoCabinet added

data/Gemfile

@@ -4,6 +4,7 @@ gemspec
 # Testing
 gem 'rake'
 gem 'rspec'
+gem 'rspec-retry'
 
 # Serializer used by Transformer
 gem 'tnetstring'
@@ -37,6 +38,7 @@ gem 'sequel'
 gem 'dalli'
 gem 'riak-client'
 gem 'cassandra'
+gem 'tokyotyrant'
 #gem 'hbaserb'
 #gem 'localmemcache'
 gem 'tdb', :platforms => :ruby

data/README.md

@@ -107,6 +107,7 @@ Out of the box, it supports the following backends. Use the backend name symbol
     * [SDBM](http://www.ruby-doc.org/stdlib/libdoc/sdbm/rdoc/SDBM.html) (`:SDBM`)
     * [KyotoCabinet](http://fallabs.com/kyotocabinet/) (`:KyotoCabinet`)
     * [TokyoCabinet](http://fallabs.com/tokyocabinet/) (`:TokyoCabinet`)
+    * [TokyoTyrant](http://fallabs.com/tokyotyrant/) (`:TokyoTyrant`)
     * [Simple Samba database TDB](http://tdb.samba.org/) (`:TDB`)
 * Document databases:
     * [CouchDB](http://couchdb.apache.org/) (`:Couch`)
@@ -147,6 +148,8 @@ __NOTE:__ <a name="backend-matrix">The backend matrix</a> is much more readable
 
 <tr><td>PStore</td><td>-</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td><a href="http://ruby-doc.org/stdlib/libdoc/pstore/rdoc/PStore.html">PStore</a> store</td></tr>
 
+<tr><td>TokyoTyrant</td><td>tokoytyrant</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td><a href="http://fallabs.com/tokyotyrant/">TokyoTyrant</a> database</td></tr>
+
 <tr><td>YAML</td><td>-</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td><a href="http://www.ruby-doc.org/stdlib/libdoc/yaml/rdoc/YAML/Store.html">YAML</a> store</td></tr>
 
 <tr><td>Daybreak</td><td>daybreak</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#55F">(✓)<sup>[7]</sup></td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td>Incredibly fast pure-ruby key/value store <a href="http://propublica.github.com/daybreak/">Daybreak</a></td></tr>
@@ -204,7 +207,7 @@ __NOTE:__ <a name="backend-matrix">The backend matrix</a> is much more readable
 * [1]: Make adapters thread-safe by using `Moneta::Lock` or by passing the option `:threadsafe => true` to `Moneta#new`. There is also `Moneta::Pool` which can be used to share a store between multiple threads if the store is multi-process safe. I recommend to add the option `:threadsafe` to ensure thread-safety since for example under JRuby and Rubinius even the basic datastructures are not thread safe due to the lack of a global interpreter lock (GIL). This differs from MRI where some adapters might appear thread safe already but only due to the GIL.
 * [2]: Share a Moneta store between multiple processes using `Moneta::Shared` (See below).
 * [3]: Add expiration support by using `Moneta::Expires` or by passing the option `:expires => true` to `Moneta#new`.
-* [4]: There are some servers which use the memcached protocol but which are persistent (e.g. [MemcacheDB](http://memcachedb.org/), [Kai](http://sourceforge.net/apps/mediawiki/kai), [IronCache](http://dev.iron.io/cache/reference/memcache/), [Roma](https://github.com/roma/roma/tree))
+* [4]: There are some servers which use the memcached protocol but which are persistent (e.g. [MemcacheDB](http://memcachedb.org/), [Kai](http://sourceforge.net/apps/mediawiki/kai), [IronCache](http://dev.iron.io/cache/reference/memcache/), [Roma](https://github.com/roma/roma/tree) and [Flare](http://labs.gree.jp/Top/OpenSource/Flare-en.html))
 * [5]: Depends on server
 * [6]: Store is multi-process safe because it is an in-memory store, values are not shared between multiple processes
 * [7]: Store is multi-process safe, but not synchronized automatically between multiple processes
@@ -454,7 +457,7 @@ end
 begin
   mutex.lock
   mutex.locked? # returns true
-  ...
+  # ...
 ensure
   mutex.unlock
 end
@@ -467,13 +470,13 @@ semaphore = Moneta::Semaphore.new(store, 'semaphore_counter', max_concurrent)
 
 semaphore.synchronize do
    semaphore.locked? # returns true
-   ...
+   # ...
 end
 
 begin
   semaphore.enter
   semaphore.locked? # returns true
-  ...
+  # ...
 ensure
   semaphore.leave
 end

data/Rakefile

@@ -35,13 +35,13 @@ task :test do
     specs.shuffle!
     srand(old_seed)
 
-    unstable = specs.select {|s| s =~ /quicklz|cassandra|action_dispatch/ }
+    unstable = specs.select {|s| s =~ /quicklz|action_dispatch/ }
     specs -= unstable
   end
 
   # Memcached and Redis specs cannot be used in parallel
   # because of flushing and lacking namespaces
-  parallel = specs.reject {|s| s =~ /memcached|redis|client|shared|riak/ }
+  parallel = specs.reject {|s| s =~ /memcached|redis|client|shared|riak|tokyotyrant|couch|cassandra/ }
   serial = specs - parallel
 
   if ENV['TEST_GROUP'] =~ /^(\d+)\/(\d+)$/

data/lib/moneta.rb

@@ -57,6 +57,7 @@ module Moneta
     autoload :Sqlite,          'moneta/adapters/sqlite'
     autoload :TDB,             'moneta/adapters/tdb'
     autoload :TokyoCabinet,    'moneta/adapters/tokyocabinet'
+    autoload :TokyoTyrant,     'moneta/adapters/tokyotyrant'
     autoload :YAML,            'moneta/adapters/yaml'
   end
 

data/lib/moneta/adapters/activerecord.rb

@@ -8,13 +8,12 @@ module Moneta
       include Defaults
 
       supports :create, :increment
+      attr_reader :table
 
       def self.tables
         @tables ||= {}
       end
 
-      attr_reader :table
-
       # @param [Hash] options
       # @option options [String] :table ('moneta') Table name
       # @option options [Hash]   :connection ActiveRecord connection configuration

data/lib/moneta/adapters/cassandra.rb

@@ -11,43 +11,48 @@ module Moneta
       include Defaults
       include ExpiresSupport
 
+      attr_reader :backend
+
       # @param [Hash] options
       # @option options [String] :keyspace ('moneta') Cassandra keyspace
       # @option options [String] :column_family ('moneta') Cassandra column family
       # @option options [String] :host ('127.0.0.1') Server host name
       # @option options [Integer] :port (9160) Server port
       # @option options [Integer] :expires Default expiration time
+      # @option options [::Cassandra] :backend Use existing backend instance
       def initialize(options = {})
-        options[:host] ||= '127.0.0.1'
-        options[:port] ||=  9160
         self.default_expires = options[:expires]
-        keyspace = (options[:keyspace] ||= 'moneta')
         @cf = (options[:column_family] || 'moneta').to_sym
-        @client = ::Cassandra.new('system', "#{options[:host]}:#{options[:port]}")
-        unless @client.keyspaces.include?(keyspace)
-          cf_def = ::Cassandra::ColumnFamily.new(:keyspace => keyspace, :name => @cf.to_s)
-          ks_def = ::Cassandra::Keyspace.new(:name => keyspace,
-                                             :strategy_class => 'SimpleStrategy',
-                                             :strategy_options => { 'replication_factor' => '1' },
-                                             :replication_factor => 1,
-                                             :cf_defs => [cf_def])
-          # Wait for keyspace to be created (issue #24)
-          10.times do
-            begin
-              @client.add_keyspace(ks_def)
-            rescue Exception => ex
-              warn "Moneta::Adapters::Cassandra - #{ex.message}"
+        if options[:backend]
+          @backend = options[:backend]
+        else
+          keyspace = options[:keyspace] || 'moneta'
+          @backend = ::Cassandra.new('system', "#{options[:host] || '127.0.0.1'}:#{options[:port] || 9160}")
+          unless @backend.keyspaces.include?(keyspace)
+            cf_def = ::Cassandra::ColumnFamily.new(:keyspace => keyspace, :name => @cf.to_s)
+            ks_def = ::Cassandra::Keyspace.new(:name => keyspace,
+                                               :strategy_class => 'SimpleStrategy',
+                                               :strategy_options => { 'replication_factor' => '1' },
+                                               :replication_factor => 1,
+                                               :cf_defs => [cf_def])
+            # Wait for keyspace to be created (issue #24)
+            10.times do
+              begin
+                @backend.add_keyspace(ks_def)
+              rescue Exception => ex
+                warn "Moneta::Adapters::Cassandra - #{ex.message}"
+              end
+              break if @backend.keyspaces.include?(keyspace)
+              sleep 0.1
             end
-            break if @client.keyspaces.include?(keyspace)
-            sleep 0.1
           end
+          @backend.keyspace = keyspace
         end
-        @client.keyspace = keyspace
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        if @client.exists?(@cf, key)
+        if @backend.exists?(@cf, key)
           load(key, options) if options.include?(:expires)
           true
         else
@@ -57,31 +62,31 @@ module Moneta
 
       # (see Proxy#load)
       def load(key, options = {})
-        value = @client.get(@cf, key)
+        value = @backend.get(@cf, key)
         if value
           expires = expires_value(options, nil)
-          @client.insert(@cf, key, {'value' => value['value'] }, :ttl => expires || nil) if expires != nil
+          @backend.insert(@cf, key, {'value' => value['value'] }, :ttl => expires || nil) if expires != nil
           value['value']
         end
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        @client.insert(@cf, key, {'value' => value}, :ttl => expires_value(options) || nil)
+        @backend.insert(@cf, key, {'value' => value}, :ttl => expires_value(options) || nil)
         value
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
         if value = load(key, options)
-          @client.remove(@cf, key)
+          @backend.remove(@cf, key)
           value
         end
       end
 
       # (see Proxy#clear)
       def clear(options = {})
-        @client.each_key(@cf) do |key|
+        @backend.each_key(@cf) do |key|
           delete(key)
         end
         self

data/lib/moneta/adapters/cookie.rb

@@ -27,7 +27,7 @@ module Moneta
 
       # (see Proxy#clear)
       def clear(options = {})
-        @hash.each_key { |key| @cookies[key] = nil }
+        @backend.each_key { |key| @cookies[key] = nil }
         super
         self
       end
@@ -35,7 +35,7 @@ module Moneta
       # Reset the cookie store
       # This method is used by the middleware.
       def reset(cookies)
-        @cookies, @hash = {}, cookies
+        @cookies, @backend = {}, cookies
       end
     end
   end

data/lib/moneta/adapters/couch.rb

@@ -7,13 +7,15 @@ module Moneta
     class Couch
       include Defaults
 
+      attr_reader :backend
+
       # @param [Hash] options
       # @option options [String] :host ('http://127.0.0.1:5984') Couch host
       # @option options [String] :db ('moneta') Couch database
+      # @option options [::CouchRest] :backend Use existing backend instance
       def initialize(options = {})
-        options[:db] ||= 'moneta'
-        options[:host] ||= '127.0.0.1:5984'
-        @db = CouchRest.new(options[:host]).database!(options[:db])
+        @backend = options[:backend] || CouchRest.new(options[:host] || '127.0.0.1:5984')
+        @db = @backend.database!(options[:db] || 'moneta')
       end
 
       # (see Proxy#key?)

data/lib/moneta/adapters/daybreak.rb

@@ -7,37 +7,41 @@ module Moneta
     class Daybreak < Memory
       # @param [Hash] options
       # @option options [String] :file Database file
+      # @option options [::Daybreak] :backend Use existing backend instance
       def initialize(options = {})
-        raise ArgumentError, 'Option :file is required' unless options[:file]
-        @hash = ::Daybreak::DB.new(options[:file], :serializer => ::Daybreak::Serializer::None)
+        @backend = options[:backend] ||
+          begin
+            raise ArgumentError, 'Option :file is required' unless options[:file]
+            ::Daybreak::DB.new(options[:file], :serializer => ::Daybreak::Serializer::None)
+          end
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        @hash.load if options[:sync]
-        @hash[key]
+        @backend.load if options[:sync]
+        @backend[key]
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        @hash[key] = value
-        @hash.flush if options[:sync]
+        @backend[key] = value
+        @backend.flush if options[:sync]
         value
       end
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        @hash.lock { super }
+        @backend.lock { super }
       end
 
       # (see Proxy#create)
       def create(key, value, options = {})
-        @hash.lock { super }
+        @backend.lock { super }
       end
 
       # (see Proxy#close)
       def close
-        @hash.close
+        @backend.close
       end
     end
   end

data/lib/moneta/adapters/dbm.rb

@@ -7,14 +7,18 @@ module Moneta
     class DBM < Memory
       # @param [Hash] options
       # @option options [String] :file Database file
+      # @option options [::DBM] :backend Use existing backend instance
       def initialize(options = {})
-        raise ArgumentError, 'Option :file is required' unless options[:file]
-        @hash = ::DBM.new(options[:file])
+        @backend = options[:backend] ||
+          begin
+            raise ArgumentError, 'Option :file is required' unless options[:file]
+            ::DBM.new(options[:file])
+          end
       end
 
       # (see Proxy#close)
       def close
-        @hash.close
+        @backend.close
         nil
       end
     end

data/lib/moneta/adapters/file.rb

@@ -1,5 +1,4 @@
 require 'fileutils'
-require 'fcntl'
 
 module Moneta
   module Adapters
@@ -72,8 +71,10 @@ module Moneta
       def create(key, value, options = {})
         path = store_path(key)
         FileUtils.mkpath(::File.dirname(path))
-        fd = ::File.sysopen(path, Fcntl::O_WRONLY | Fcntl::O_EXCL | Fcntl::O_CREAT)
-        ::File.open(fd, 'wb') {|file| file.write(value) }
+        ::File.open(path, ::File::WRONLY | ::File::CREAT | ::File::EXCL) do |file|
+          file.binmode
+          file.write(value)
+        end
         true
       rescue Errno::EEXIST
         false

data/lib/moneta/adapters/fog.rb

@@ -7,13 +7,16 @@ module Moneta
     class Fog
       include Defaults
 
+      attr_reader :backend
+
       # @param [Hash] options
       # @option options [String] :dir Fog directory
+      # @option options [::Fog::Storage] :backend Use existing backend instance
       # @option options Other options passed to `Fog::Storage#new`
       def initialize(options = {})
         raise ArgumentError, 'Option :dir is required' unless dir = options.delete(:dir)
-        storage = ::Fog::Storage.new(options)
-        @directory = storage.directories.get(dir) || storage.directories.create(:key => dir)
+        @backend = options[:backend] || ::Fog::Storage.new(options)
+        @directory = @backend.directories.get(dir) || @backend.directories.create(:key => dir)
       end
 
       # (see Proxy#key?)

data/lib/moneta/adapters/gdbm.rb

@@ -7,14 +7,18 @@ module Moneta
     class GDBM < Memory
       # @param [Hash] options
       # @option options [String] :file Database file
+      # @option options [::GDBM] :backend Use existing backend instance
       def initialize(options = {})
-        raise ArgumentError, 'Option :file is required' unless options[:file]
-        @hash = ::GDBM.new(options[:file])
+        @backend = options[:backend] ||
+          begin
+            raise ArgumentError, 'Option :file is required' unless options[:file]
+            ::GDBM.new(options[:file])
+          end
       end
 
       # (see Proxy#close)
       def close
-        @hash.close
+        @backend.close
         nil
       end
     end

data/lib/moneta/adapters/hbase.rb

@@ -7,22 +7,24 @@ module Moneta
     class HBase
       include Defaults
 
+      attr_reader :backend
+
       # @param [Hash] options
       # @option options [String] :host ('127.0.0.1') Server host name
       # @option options [Integer] :port (9090) Server port
       # @option options [String] :table ('moneta') Table name
       # @option options [String] :column_family ('moneta') Column family
       # @option options [String] :column ('value') Column
+      # @option options [::HBaseRb::Client] :backend Use existing backend instance
       def initialize(options = {})
-        options[:host] ||= '127.0.0.1'
-        options[:port] ||= '9090'
-        options[:table] ||= 'moneta'
         options[:column] ||= 'value'
+        options[:table] ||= 'moneta'
         cf = (options[:column_family] || 'moneta')
-        @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]}"
+        @backend = options[:backend] ||
+          HBaseRb::Client.new(options[:host] || '127.0.0.1', options[:port] || '9090')
+        @backend.create_table(options[:table], cf) unless @backend.has_table?(options[:table])
+        @table = @backend.get_table(options[:table])
       end
 
       # (see Proxy#key?)
@@ -54,7 +56,7 @@ module Moneta
       def delete(key, options = {})
         if value = load(key, options)
           @table.delete_row(key)
-          unpack(value)
+          value
         end
       end
 
@@ -68,7 +70,7 @@ module Moneta
 
       # (see Proxy#close)
       def close
-        @db.close
+        @backend.close
         nil
       end
 
@@ -81,7 +83,7 @@ module Moneta
           [intvalue].pack('Q>')
         elsif value.bytesize >= 8
           # Add nul character to make value distinguishable from integer
-          value << "\0"
+          value + "\0"
         else
           value
         end