moneta 0.6.0 → 0.7.0

data/lib/moneta/adapters/fog.rb

@@ -0,0 +1,51 @@
+require 'fog'
+
+module Moneta
+  module Adapters
+    # Fog backend (Cloud storage services)
+    # @api public
+    class Fog < Base
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :dir - Fog directory
+      # * 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.create(:key => dir)
+      end
+
+      def key?(key, options = {})
+        @directory.files.head(key) != nil
+      end
+
+      def load(key, options = {})
+        value = @directory.files.get(key)
+        value && value.body
+      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/moneta/adapters/gdbm.rb

@@ -0,0 +1,25 @@
+require 'gdbm'
+
+module Moneta
+  module Adapters
+    # GDBM backend
+    # @api public
+    class GDBM < Memory
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :file - Database file
+      def initialize(options = {})
+        raise ArgumentError, 'Option :file is required' unless options[:file]
+        @hash = ::GDBM.new(options[:file])
+      end
+
+      def close
+        @hash.close
+        nil
+      end
+    end
+  end
+end

data/lib/moneta/adapters/hbase.rb

@@ -0,0 +1,101 @@
+require 'hbaserb'
+
+module Moneta
+  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 moneta)
+      # * :column_family - Column family (default moneta)
+      # * :column - Column (default value)
+      def initialize(options = {})
+        options[:host] ||= '127.0.0.1'
+        options[:port] ||= '9090'
+        options[:table] ||= 'moneta'
+        options[:column] ||= 'value'
+        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]}"
+      end
+
+      def key?(key, options = {})
+        @table.get(key, @column).first != nil
+      end
+
+      def load(key, options = {})
+        cell = @table.get(key, @column).first
+        cell && unpack(cell.value)
+      end
+
+      def store(key, value, options = {})
+        @table.mutate_row(key, @column => pack(value))
+        value
+      end
+
+      def increment(key, amount = 1, options = {})
+        result = @table.atomic_increment(key, @column, amount)
+        # HACK: Throw error if applied to invalid value
+        if result == 0
+          value = load(key)
+          raise 'Tried to increment non integer value' unless value.to_s == value.to_i.to_s
+        end
+        result
+      end
+
+      def delete(key, options = {})
+        if value = load(key, options)
+          @table.delete_row(key)
+          unpack(value)
+        end
+      end
+
+      def clear(options = {})
+        @table.create_scanner do |row|
+          @table.delete_row(row.row)
+        end
+        self
+      end
+
+      def close
+        @db.close
+        nil
+      end
+
+      private
+
+      def pack(value)
+        intvalue = value.to_i
+        if intvalue >= 0 && intvalue <= 0xFFFFFFFFFFFFFFFF && intvalue.to_s == value
+          # Pack as 8 byte big endian
+          [intvalue].pack('Q>')
+        elsif value.bytesize >= 8
+          # Add nul character to make value distinguishable from integer
+          value << "\0"
+        else
+          value
+        end
+      end
+
+      def unpack(value)
+        if value.bytesize == 8
+          # Unpack 8 byte big endian
+          value.unpack('Q>').first.to_s
+        elsif value.bytesize >= 9 && value[-1] == ?\0
+          # Remove nul character
+          value[0..-2]
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/moneta/adapters/leveldb.rb

@@ -0,0 +1,35 @@
+require 'leveldb'
+
+module Moneta
+  module Adapters
+    # LevelDB backend
+    # @api public
+    class LevelDB < Memory
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :dir - Database path
+      # * All other options passed to LevelDB::DB#new
+      def initialize(options = {})
+        raise ArgumentError, 'Option :dir is required' unless options[:dir]
+        @hash = ::LevelDB::DB.new(options[:dir])
+      end
+
+      def key?(key, options = {})
+        @hash.includes?(key)
+      end
+
+      def clear(options = {})
+        @hash.each {|k,v| delete(k, options) }
+        self
+      end
+
+      def close
+        @hash.close
+        nil
+      end
+    end
+  end
+end

data/lib/moneta/adapters/localmemcache.rb

@@ -0,0 +1,28 @@
+require 'localmemcache'
+
+module Moneta
+  module Adapters
+    # LocalMemCache backend
+    # @api public
+    class LocalMemCache < Base
+      include Mixins::HashAdapter
+
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :file - Database file
+      def initialize(options = {})
+        raise ArgumentError, 'Option :file is required' unless options[:file]
+        @hash = ::LocalMemCache.new(:filename => options[:file])
+      end
+
+      def delete(key, options = {})
+        value = load(key, options)
+        @hash.delete(key)
+        value
+      end
+    end
+  end
+end

data/lib/moneta/adapters/lruhash.rb

@@ -0,0 +1,85 @@
+module Moneta
+  module Adapters
+    # LRUHash backend
+    #
+    # Based on Hashery::LRUHash but simpler and measures memory usage instead of hash size.
+    #
+    # @api public
+    class LRUHash < Base
+      include Mixins::IncrementSupport
+
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :max_size - Maximum byte size of hash values (default 1024000)
+      def initialize(options = {})
+        @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
+end

data/lib/moneta/adapters/memcached.rb

@@ -0,0 +1,11 @@
+module Moneta
+  module Adapters
+    begin
+      require 'moneta/adapters/memcached_native'
+      Memcached = MemcachedNative
+    rescue LoadError
+      require 'moneta/adapters/memcached_dalli'
+      Memcached = MemcachedDalli
+    end
+  end
+end

data/lib/moneta/adapters/memcached_dalli.rb

@@ -0,0 +1,69 @@
+require 'dalli'
+
+module Moneta
+  module Adapters
+    # Memcached backend (using gem dalli)
+    # @api public
+    class MemcachedDalli < Base
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :server - Memcached server (default localhost:11211)
+      # * :expires - Default expiration time (default none)
+      # * Other options passed to Dalli::Client#new
+      def initialize(options = {})
+        options[:expires_in] = options.delete(:expires)
+        server = options.delete(:server) || 'localhost:11211'
+        @cache = ::Dalli::Client.new(server, options)
+      end
+
+      def load(key, options = {})
+        value = @cache.get(key)
+        if value && options.include?(:expires)
+          store(key, value, options)
+        else
+          value
+        end
+      end
+
+      def store(key, value, options = {})
+        @cache.set(key, value, options[:expires], :raw => true)
+        value
+      end
+
+      def delete(key, options = {})
+        value = @cache.get(key)
+        @cache.delete(key)
+        value
+      end
+
+      def increment(key, amount = 1, options = {})
+        # FIXME: There is a Dalli bug, load(key) returns a wrong value after increment
+        # therefore we set default = nil and create the counter manually
+        result = if amount >= 0
+                   @cache.incr(key, amount, options[:expires], nil)
+                 else
+                   @cache.decr(key, -amount, options[:expires], nil)
+                 end
+        if result
+          result
+        else
+          store(key, amount, options)
+          amount
+        end
+      end
+
+      def clear(options = {})
+        @cache.flush_all
+        self
+      end
+
+      def close
+        @cache.close
+        nil
+      end
+    end
+  end
+end

data/lib/moneta/adapters/memcached_native.rb

@@ -0,0 +1,70 @@
+require 'memcached'
+
+module Moneta
+  module Adapters
+    # Memcached backend (using gem memcached)
+    # @api public
+    class MemcachedNative < Base
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :server - Memcached server (default localhost:11211)
+      # * :namespace - Key namespace
+      # * :expires - Default expiration time (default 604800)
+      # * Other options passed to Memcached#new
+      def initialize(options = {})
+        server = options.delete(:server) || 'localhost:11211'
+        @expires = options.delete(:expires) || 604800
+        options.merge!(:prefix_key => options.delete(:namespace)) if options[:namespace]
+        @cache = ::Memcached.new(server, options)
+      end
+
+      def load(key, options = {})
+        value = @cache.get(key, false)
+        if value && options.include?(:expires)
+          store(key, value, options)
+        else
+          value
+        end
+      rescue ::Memcached::NotFound
+      end
+
+      def store(key, value, options = {})
+        # TTL must be Fixnum
+        @cache.set(key, value, options[:expires] || @expires, false)
+        value
+      end
+
+      def delete(key, options = {})
+        value = @cache.get(key, false)
+        @cache.delete(key)
+        value
+      rescue ::Memcached::NotFound
+      end
+
+      def increment(key, amount = 1, options = {})
+        result = if amount >= 0
+          @cache.increment(key, amount)
+        else
+          @cache.decrement(key, -amount)
+        end
+        # HACK: Throw error if applied to invalid value
+        if result == 0
+          value = @cache.get(key, false) rescue nil
+          raise 'Tried to increment non integer value' unless value.to_s == value.to_i.to_s
+        end
+        result
+      rescue ::Memcached::NotFound => ex
+        store(key, amount.to_s, options)
+        amount
+      end
+
+      def clear(options = {})
+        @cache.flush
+        self
+      end
+    end
+  end
+end