moneta 0.6.0 → 0.7.0

data/lib/moneta/adapters/activerecord.rb

@@ -0,0 +1,87 @@
+require 'active_record'
+
+module Moneta
+  module Adapters
+    # ActiveRecord as key/value stores
+    # @api public
+    class ActiveRecord < Base
+      def self.tables
+        @tables ||= {}
+      end
+
+      attr_reader :table
+
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :table - Table name (default moneta)
+      # * :connection - ActiveRecord connection
+      def initialize(options = {})
+        table = options[:table] || 'moneta'
+        @table = self.class.tables[table] ||=
+          begin
+            c = Class.new(::ActiveRecord::Base)
+            c.table_name = table
+            c.primary_key = :k
+            c
+          end
+        @table.establish_connection(options[:connection]) if options[:connection]
+        unless @table.table_exists?
+          @table.connection.create_table(@table.table_name, :id => false) do |t|
+            # Do not use binary columns (Issue #17)
+            t.string :k, :null => false
+            t.string :v
+          end
+          @table.connection.add_index(@table.table_name, :k, :unique => true)
+        end
+      end
+
+      def key?(key, options = {})
+        !@table.where(:k => key).empty?
+      end
+
+      def load(key, options = {})
+        record = @table.where(:k => key).first
+        record && record.v
+      end
+
+      def store(key, value, options = {})
+        @table.transaction do
+          record = @table.where(:k => key).first_or_initialize
+          record.update_attributes(:v => value)
+          value
+        end
+      end
+
+      def delete(key, options = {})
+        @table.transaction do
+          if record = @table.where(:k => key).first
+            record.destroy
+            record.v
+          end
+        end
+      end
+
+      def increment(key, amount = 1, options = {})
+        @table.transaction do
+          record = @table.where(:k => key).first_or_initialize
+          record.lock!
+          value = record.v
+          intvalue = value.to_i
+          raise 'Tried to increment non integer value' unless value == nil || intvalue.to_s == value.to_s
+          intvalue += amount
+          record.v = intvalue.to_s
+          record.save!
+          intvalue
+        end
+      end
+
+      def clear(options = {})
+        @table.delete_all
+        self
+      end
+    end
+  end
+end

data/lib/moneta/adapters/cassandra.rb

@@ -0,0 +1,91 @@
+# Copyright: 2011 TMX Credit
+# Author: Potapov Sergey (aka Blake)
+
+require 'cassandra'
+
+module Moneta
+  module Adapters
+    # Cassandra backend
+    # @api public
+    class Cassandra < Base
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :keyspace - Cassandra keyspace (default 'moneta')
+      # * :column_family - Cassandra column family (default 'moneta')
+      # * :host - Server host name (default 127.0.0.1)
+      # * :port - Server port (default 9160)
+      # * :expires - Default expiration time (default none)
+      def initialize(options = {})
+        options[:host] ||= '127.0.0.1'
+        options[:port] ||=  9160
+        @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
+              puts "Cassandra: #{ex.message}"
+            end
+            break if @client.keyspaces.include?(keyspace)
+            sleep 0.1
+          end
+        end
+        @client.keyspace = keyspace
+      end
+
+      def key?(key, options = {})
+        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 = {})
+        value = @client.get(@cf, key)
+        if value
+          if options.include?(:expires)
+            store(key, value['value'], options)
+          else
+            value['value']
+          end
+        end
+      end
+
+      def store(key, value, options = {})
+        @client.insert(@cf, key, {'value' => value}, :ttl => (options[:expires] || @expires))
+        value
+      end
+
+      def delete(key, options = {})
+        if value = load(key, options)
+          @client.remove(@cf, key)
+          value
+        end
+      end
+
+      def clear(options = {})
+        @client.each_key(@cf) do |key|
+          delete(key)
+        end
+        self
+      end
+    end
+  end
+end

data/lib/moneta/adapters/client.rb

@@ -0,0 +1,69 @@
+require 'socket'
+
+module Moneta
+  module Adapters
+    # Moneta client backend
+    # @api public
+    class Client < Base
+      include Net
+
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :port - TCP port (default 9000)
+      # * :host - Hostname (default empty)
+      # * :file - Unix socket file name (default none)
+      def initialize(options = {})
+        @socket = options[:file] ? UNIXSocket.open(options[:file]) :
+          TCPSocket.open(options[:host] || '127.0.0.1', options[:port] || DEFAULT_PORT)
+      end
+
+      def key?(key, options = {})
+        write(@socket, [:key?, key, options])
+        read_result
+      end
+
+      def load(key, options = {})
+        write(@socket, [:load, key, options])
+        read_result
+      end
+
+      def store(key, value, options = {})
+        write(@socket, [:store, key, value, options])
+        read_result
+        value
+      end
+
+      def delete(key, options = {})
+        write(@socket, [:delete, key, options])
+        read_result
+      end
+
+      def increment(key, amount = 1, options = {})
+        write(@socket, [:increment, key, amount, options])
+        read_result
+      end
+
+      def clear(options = {})
+        write(@socket, [:clear, options])
+        read_result
+        self
+      end
+
+      def close
+        @socket.close
+        nil
+      end
+
+      private
+
+      def read_result
+        result = read(@socket)
+        raise result if Error === result
+        result
+      end
+    end
+  end
+end

data/lib/moneta/adapters/cookie.rb

@@ -0,0 +1,35 @@
+module Moneta
+  module Adapters
+    class Cookie < Memory
+      attr_reader :cookies
+
+      def initialize(options = {})
+        super
+        @options, @cookies = options, {}
+      end
+
+      def store(key, value, options = {})
+        cookie = @options.merge(options)
+        cookie[:value] = value
+        cookie[:expires] += Time.now.to_i if cookie[:expires]
+        @cookies[key] = cookie
+        super
+      end
+
+      def delete(key, options = {})
+        @cookies[key] = nil
+        super
+      end
+
+      def clear(options = {})
+        @hash.each_key { |key| @cookies[key] = nil }
+        super
+        self
+      end
+
+      def reset(cookies)
+        @cookies, @hash = {}, cookies
+      end
+    end
+  end
+end

data/lib/moneta/adapters/couch.rb

@@ -0,0 +1,57 @@
+require 'couchrest'
+
+module Moneta
+  module Adapters
+    # CouchDB backend
+    # @api public
+    class Couch < Base
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :db - Couch database (default moneta)
+      def initialize(options = {})
+        options[:db] ||= 'moneta'
+        @db = ::CouchRest.database!(options[:db])
+      end
+
+      def key?(key, options = {})
+        @db.get(key) != nil
+      rescue RestClient::ResourceNotFound
+        false
+      end
+
+      def load(key, options = {})
+        @db.get(key)['value']
+      rescue RestClient::ResourceNotFound
+        nil
+      end
+
+      def store(key, value, options = {})
+        doc = {'_id' => key, 'value' => value}
+        begin
+          doc['_rev'] = @db.get(key)['_rev']
+        rescue RestClient::ResourceNotFound
+        end
+        @db.save_doc(doc)
+        value
+      rescue RestClient::RequestFailed
+        value
+      end
+
+      def delete(key, options = {})
+        value = @db.get(key)
+        @db.delete_doc('_id' => value['_id'], '_rev' => value['_rev'])
+        value['value']
+      rescue RestClient::ResourceNotFound
+        nil
+      end
+
+      def clear(options = {})
+        @db.recreate!
+        self
+      end
+    end
+  end
+end

data/lib/moneta/adapters/datamapper.rb

@@ -0,0 +1,75 @@
+require 'dm-core'
+require 'dm-migrations'
+
+module Moneta
+  module Adapters
+    # Datamapper backend
+    # @api public
+    class DataMapper < Base
+      class Store
+        include ::DataMapper::Resource
+        property :k, Text, :key => true
+        property :v, Text, :lazy => false
+      end
+
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :setup - Datamapper setup string
+      # * :repository - Repository name (default :moneta)
+      # * :table - Table name (default :moneta)
+      def initialize(options = {})
+        raise ArgumentError, 'Option :setup is required' unless options[:setup]
+        @repository = options.delete(:repository) || :moneta
+        Store.storage_names[@repository] = (options.delete(:table) || :moneta).to_s
+        ::DataMapper.setup(@repository, options[:setup])
+        context { Store.auto_upgrade! }
+      end
+
+      def key?(key, options = {})
+        context { Store.get(key) != nil }
+      end
+
+      def load(key, options = {})
+        context do
+          record = Store.get(key)
+          record && record.v
+        end
+      end
+
+      def store(key, value, options = {})
+        context do
+          if record = Store.get(key)
+            record.update(:k => key, :v => value)
+          else
+            Store.create(:k => key, :v => value)
+          end
+          value
+        end
+      end
+
+      def delete(key, options = {})
+        context do
+          if record = Store.get(key)
+            value = record.v
+            record.destroy!
+            value
+          end
+        end
+      end
+
+      def clear(options = {})
+        context { Store.all.destroy! }
+        self
+      end
+
+      private
+
+      def context
+        ::DataMapper.repository(@repository) { yield }
+      end
+    end
+  end
+end

data/lib/moneta/adapters/dbm.rb

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

data/lib/moneta/adapters/file.rb

@@ -0,0 +1,79 @@
+require 'fileutils'
+
+module Moneta
+  module Adapters
+    # Filesystem backend
+    # @api public
+    class File < Base
+      include Mixins::IncrementSupport
+
+      def initialize(options = {})
+        raise ArgumentError, 'Option :dir is required' unless @dir = options[:dir]
+        FileUtils.mkpath(@dir)
+        raise "#{@dir} is not a directory" 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
+
+      def increment(key, amount = 1, options = {})
+        lock(key) { super }
+      end
+
+      protected
+
+      def lock(key, &block)
+        path = store_path(key)
+        return yield unless ::File.exist?(path)
+        ::File.open(path, 'r+') do |f|
+          begin
+            f.flock ::File::LOCK_EX
+            yield
+          ensure
+            f.flock ::File::LOCK_UN
+          end
+        end
+      end
+
+      def store_path(key)
+        ::File.join(@dir, key)
+      end
+    end
+  end
+end