moneta 0.6.0 → 0.7.0

data/lib/moneta/net.rb

@@ -0,0 +1,18 @@
+module Moneta
+  # @api private
+  module Net
+    DEFAULT_PORT = 9000
+
+    class Error < Exception; end
+
+    def read(io)
+      size = io.read(4).unpack('N').first
+      Marshal.load(io.read(size))
+    end
+
+    def write(io, o)
+      s = Marshal.dump(o)
+      io.write([s.bytesize].pack('N') << s)
+    end
+  end
+end

data/lib/moneta/optionmerger.rb

@@ -0,0 +1,39 @@
+module Moneta
+  # @api private
+  class OptionMerger < Wrapper
+    METHODS = [:key?, :load, :store, :delete, :increment, :clear].freeze
+
+    attr_reader :default_options
+
+    def initialize(adapter, options = {})
+      super(adapter, options)
+
+      @default_options = adapter.respond_to?(:default_options) ? adapter.default_options.dup : {}
+
+      if options.include?(:only)
+        raise ArgumentError, 'Either :only or :except is allowed' if options.include?(:except)
+        methods = [options.delete(:only)].compact.flatten
+      elsif options.include?(:except)
+        methods = METHODS - [options.delete(:except)].compact.flatten
+      else
+        methods = METHODS
+      end
+
+      methods.each do |method|
+        if oldopts = @default_options[method]
+          newopts = (@default_options[method] = oldopts.merge(options))
+          newopts[:prefix] = "#{oldopts[:prefix]}#{options[:prefix]}" if oldopts[:prefix] || options[:prefix]
+        else
+          @default_options[method] = options
+        end
+      end
+    end
+
+    def wrap(method, *args)
+      options = args.last
+      options.merge!(@default_options[method]) if Hash === options && @default_options.include?(method)
+      yield
+    end
+  end
+end
+

data/lib/moneta/proxy.rb

@@ -0,0 +1,86 @@
+module Moneta
+  # Proxy base class
+  # @api public
+  class Proxy < Base
+    attr_reader :adapter
+
+    # Constructor
+    #
+    # @param [Moneta store] underlying adapter
+    # @param [Hash] options
+    def initialize(adapter, options = {})
+      @adapter = adapter
+    end
+
+    # Exists the value with key
+    #
+    # @param [Object] key
+    # @return [Boolean]
+    # @param [Hash] options
+    # @api public
+    def key?(key, options = {})
+      @adapter.key?(key, options)
+    end
+
+    # Fetch value with key. Return nil if the key doesn't exist
+    #
+    # @param [Object] key
+    # @param [Hash] options
+    # @return [Object] value
+    # @api public
+    def load(key, options = {})
+      @adapter.load(key, options)
+    end
+
+    # Store value with key
+    #
+    # @param [Object] key
+    # @param [Object] value
+    # @param [Hash] options
+    # @return value
+    # @api public
+    def store(key, value, options = {})
+      @adapter.store(key, value, options)
+    end
+
+    # Delete the key from the store and return the current value
+    #
+    # @param [Object] key
+    # @return [Object] current value
+    # @param [Hash] options
+    # @api public
+    def delete(key, options = {})
+      @adapter.delete(key, options)
+    end
+
+    # Atomically increment integer value with key
+    #
+    # Not every Moneta store implements this method,
+    # a NotImplementedError if it is not supported.
+    #
+    # @param [Object] key
+    # @param [Integer] amount
+    # @param [Hash] options
+    # @return [Object] value from store
+    # @api public
+    def increment(key, amount = 1, options = {})
+      @adapter.increment(key, amount, options)
+    end
+
+    # Clear all keys in this store
+    #
+    # @param [Hash] options
+    # @return [void]
+    # @api public
+    def clear(options = {})
+      @adapter.clear(options)
+      self
+    end
+
+    # Close this store
+    # @api public
+    def close
+      @adapter.close
+    end
+  end
+end

data/lib/moneta/server.rb

@@ -0,0 +1,81 @@
+require 'socket'
+
+module Moneta
+  # Moneta server
+  # @api public
+  class Server
+    TIMEOUT = 1
+    include Net
+
+    # Constructor
+    #
+    # @param [Hash] options
+    #
+    # Options:
+    # * :port - TCP port (default 9000)
+    # * :file - Unix socket file name (default none)
+    def initialize(store, options = {})
+      @store = store
+      @server = options[:file] ? UNIXServer.open(options[:file]) :
+        TCPServer.open(options[:port] || DEFAULT_PORT)
+      @clients = [@server]
+      @running = true
+      @thread = Thread.new do
+        mainloop while @running
+        File.unlink(options[:file]) if options[:file]
+      end
+    end
+
+    def stop
+      if @thread
+        @running = false
+        @server.close
+        @server = nil
+        @thread.join
+        @thread = nil
+      end
+    end
+
+    private
+
+    def mainloop
+      client = accept
+      handle(client) if client
+    rescue Exception => ex
+      puts "#{ex.message}\n#{ex.backtrace.join("\n")}"
+      write(client, Error.new(ex.message)) if client
+    end
+
+    def accept
+      ios = IO.select(@clients, nil, @clients, TIMEOUT)
+      return nil unless ios
+      ios[2].each do |io|
+        io.close
+        @clients.delete(io)
+      end
+      ios[0].each do |io|
+        if io == @server
+          client = @server.accept
+          @clients << client if client
+        else
+          return io unless io.eof?
+          @clients.delete(io)
+        end
+      end
+      nil
+    end
+
+    def handle(client)
+      method, *args = read(client)
+      case method
+      when :key?, :load, :delete, :increment
+        write(client, @store.send(method, *args))
+      when :store, :clear
+        @store.send(method, *args)
+        write(client, nil)
+      else
+        raise 'Invalid method call'
+      end
+    end
+  end
+end

data/lib/moneta/shared.rb

@@ -0,0 +1,60 @@
+module Moneta
+  # Shares a store between processes
+  #
+  # @example Share a store
+  #   Moneta.build do
+  #     use :Transformer, :key => :marshal, :value => :marshal
+  #     use :Shared do
+  #       adapter :GDBM, :file => 'shared.db'
+  #     end
+  #   end
+  #
+  # @api public
+  class Shared < Wrapper
+    # Constructor
+    #
+    # @param [Hash] options
+    #
+    # Options:
+    # * :port - TCP port (default 9000)
+    # * :host - Hostname (default empty)
+    # * :file - Unix socket file name (default none)
+    def initialize(options = {}, &block)
+      @options = options
+      @builder = Builder.new(&block)
+    end
+
+    def close
+      if @server
+        @server.stop
+        @server = nil
+      end
+      if @adapter
+        @adapter.close
+        @adapter = nil
+      end
+    end
+
+    private
+
+    def wrap(*args)
+      tries ||= 0
+      @adapter ||= Adapters::Client.new(@options)
+      yield
+    rescue Exception => ex
+      puts "Failed to connect: #{ex.message}"
+      begin
+        @adapter = Lock.new(@builder.build.last)
+        @server = Server.new(@adapter, @options)
+      rescue Exception => ex
+        puts "Failed to start server: #{ex.message}"
+        @adapter = nil
+      end
+      if (tries += 1) > 2
+        raise
+      else
+        retry
+      end
+    end
+  end
+end

data/lib/moneta/stack.rb

@@ -0,0 +1,78 @@
+module Moneta
+  # Combines multiple stores. Reads return the result from the first store,
+  # writes go to all stores.
+  #
+  # @example Add stack to chain
+  #   Moneta.build do
+  #     use(:Stack) do
+  #       add { adapter :Redis }
+  #       add { adapter :File, :dir => 'data' }
+  #       add { adapter :File, :dir => 'replicate' }
+  #     end
+  #   end
+  #
+  # @api public
+  class Stack < Base
+    # @api private
+    class DSL
+      attr_reader :stack
+
+      def initialize(options, &block)
+        @stack = options[:stack].to_a
+        instance_eval(&block)
+      end
+
+      def add(store = nil, &block)
+        raise ArgumentError, 'Only argument or block allowed' if store && block
+        @stack << (store || Moneta.build(&block))
+        nil
+      end
+    end
+
+    attr_reader :stack
+
+    def initialize(options = {}, &block)
+      @stack = DSL.new(options, &block).stack
+    end
+
+    def key?(key, options = {})
+      @stack.any? {|s| s.key?(key) }
+    end
+
+    def load(key, options = {})
+      @stack.each do |s|
+        value = s.load(key, options)
+        return value if value
+      end
+      nil
+    end
+
+    def store(key, value, options = {})
+      @stack.each {|s| s.store(key, value, options) }
+      value
+    end
+
+    def delete(key, options = {})
+      @stack.inject(nil) do |value, s|
+        v = s.delete(key, options)
+        value || v
+      end
+    end
+
+    def increment(key, amount = 1, options = {})
+      last = nil
+      @stack.each {|s| last = s.increment(key, amount, options) }
+      last
+    end
+
+    def clear(options = {})
+      @stack.each {|s| s.clear }
+      self
+    end
+
+    def close
+      @stack.each {|s| s.close }
+      nil
+    end
+  end
+end

data/lib/moneta/transformer.rb

@@ -0,0 +1,159 @@
+module Moneta
+  # Transforms keys and values (Marshal, YAML, JSON, Base64, MD5, ...).
+  # You can bypass the transformer (e.g. serialization) by using the `:raw` option.
+  #
+  # @example Add transformer to chain
+  #   Moneta.build do
+  #     transformer :key => [:marshal, :escape], :value => [:marshal]
+  #     adapter :File, :dir => 'data'
+  #   end
+  #
+  # @example Bypass serialization
+  #   store.store('key', 'value', :raw => true)
+  #   store['key'] => Error
+  #   store.load('key', :raw => true) => 'value'
+  #
+  #   store['key'] = 'value'
+  #   store.load('key', :raw => true) => "\x04\bI\"\nvalue\x06:\x06ET"
+  #
+  # @api public
+  class Transformer < Proxy
+    class << self
+      alias_method :original_new, :new
+
+      # Constructor
+      #
+      # @param [Moneta store] adapter The underlying store
+      # @param [Hash] options
+      #
+      # Options:
+      # * :key - List of key transformers in the order in which they should be applied
+      # * :value - List of value transformers in the order in which they should be applied
+      # * :prefix - Prefix string for key namespacing (Used by the :prefix key transformer)
+      # * :secret - HMAC secret to verify values (Used by the :hmac value transformer)
+      # * :maxlen - Maximum key length (Used by the :truncate key transformer)
+      # * :quiet - Disable error message
+      def new(adapter, options = {})
+        keys = [options[:key]].flatten.compact
+        values = [options[:value]].flatten.compact
+        raise ArgumentError, 'Option :key or :value is required' if keys.empty? && values.empty?
+        options[:prefix] ||= '' if keys.include?(:prefix)
+        name = class_name(options[:quiet] ? 'Quiet' : '', keys, values)
+        const_set(name, compile(options, keys, values)) unless const_defined?(name)
+        const_get(name).original_new(adapter, options)
+      end
+
+      private
+
+      def compile(options, keys, values)
+        raise ArgumentError, 'Invalid key transformer chain' if KEY_TRANSFORMER !~ keys.map(&:inspect).join
+        raise ArgumentError, 'Invalid value transformer chain' if VALUE_TRANSFORMER !~ values.map(&:inspect).join
+
+        key = compile_transformer(keys, 'key')
+
+        klass = Class.new(self)
+        klass.class_eval <<-end_eval, __FILE__, __LINE__
+          def initialize(adapter, options = {})
+            super
+            #{compile_initializer('key', keys)}
+            #{compile_initializer('value', values)}
+          end
+          def key?(key, options = {})
+            @adapter.key?(#{key}, options)
+          end
+          def increment(key, amount = 1, options = {})
+            @adapter.increment(#{key}, amount, options)
+          end
+        end_eval
+
+        if values.empty?
+          klass.class_eval <<-end_eval, __FILE__, __LINE__
+            def load(key, options = {})
+              options.delete(:raw)
+              @adapter.load(#{key}, options)
+            end
+            def store(key, value, options = {})
+              options.delete(:raw)
+              @adapter.store(#{key}, value, options)
+            end
+            def delete(key, options = {})
+              options.delete(:raw)
+              @adapter.delete(#{key}, options)
+            end
+          end_eval
+        else
+          dump = compile_transformer(values, 'value')
+          load = compile_transformer(values.reverse, 'value', 1)
+
+          klass.class_eval <<-end_eval, __FILE__, __LINE__
+            def load(key, options = {})
+              raw = options.delete(:raw)
+              value = @adapter.load(#{key}, options)
+              begin
+                return #{load} if value && !raw
+              rescue Exception => ex
+                #{options[:quiet] ? '' : 'puts "Tried to load invalid value: #{ex.message}"'}
+              end
+              value
+            end
+            def store(key, value, options = {})
+              raw = options.delete(:raw)
+              @adapter.store(#{key}, raw ? value : #{dump}, options)
+              value
+            end
+            def delete(key, options = {})
+              raw = options.delete(:raw)
+              value = @adapter.delete(#{key}, options)
+              begin
+                return #{load} if value && !raw
+              rescue Exception => ex
+                #{options[:quiet] ? '' : 'puts "Tried to delete invalid value: #{ex.message}"'}
+              end
+              value
+            end
+          end_eval
+        end
+        klass
+      end
+
+      # Compile option initializer
+      def compile_initializer(type, transformers)
+        transformers.map do |name|
+          t = TRANSFORMER[name]
+          (t[1].to_s + t[2].to_s).scan(/@\w+/).uniq.map do |opt|
+            "raise ArgumentError, \"Option #{opt[1..-1]} is required for #{name} #{type} transformer\" unless #{opt} = options[:#{opt[1..-1]}]\n"
+          end
+        end.join("\n")
+      end
+
+      # Compile transformer validator regular expression
+      def compile_validator(s)
+        Regexp.new(s.gsub(/\w+/) do
+                     '(' + TRANSFORMER.select {|k,v| v.first.to_s == $& }.map {|v| ":#{v.first}" }.join('|') + ')'
+                   end.gsub(/\s+/, '').sub(/\A/, '\A').sub(/\Z/, '\Z'))
+      end
+
+      # Returned compiled transformer code string
+      def compile_transformer(transformer, var, i = 2)
+        transformer.inject(var) do |value, name|
+          raise ArgumentError, "Unknown transformer #{name}" unless t = TRANSFORMER[name]
+          require t[3] if t[3]
+          code = t[i]
+          if t[0] == :serialize && var == 'key'
+            "(tmp = #{value}; String === tmp ? tmp : #{code.gsub('value', 'tmp')})"
+          else
+            code.gsub('value', value)
+          end
+        end
+      end
+
+      def class_name(prefix, keys, values)
+        prefix << (keys.empty? ? '' : keys.map(&:to_s).map(&:capitalize).join << 'Key') <<
+          (values.empty? ? '' : values.map(&:to_s).map(&:capitalize).join << 'Value')
+      end
+    end
+  end
+end
+
+require 'moneta/transformer/helper'
+require 'moneta/transformer/config'