moneta 1.0.0 → 1.1.0

data/lib/moneta/pool.rb

@@ -14,7 +14,6 @@ module Moneta
   #
   # @api public
   class Pool < Wrapper
-    # @param [Moneta store] adapter The underlying store
     # @param [Hash] options
     # @option options [String] :mutex (::Mutex.new) Mutex object
     def initialize(options = {}, &block)
@@ -39,7 +38,19 @@ module Moneta
       Thread.current[@id]
     end
 
-    def wrap(*args)
+    def wrap(*args, &block)
+      if checked_out?
+        yield
+      else
+        check_out!(&block)
+      end
+    end
+
+    def checked_out?
+      Thread.current.key?(@id) && Thread.current[@id] != nil
+    end
+
+    def check_out!
       store = Thread.current[@id] = pop
       yield
     ensure
@@ -48,13 +59,11 @@ module Moneta
     end
 
     def pop
-      if @mutex.synchronize { @pool.empty? }
+      unless store = @mutex.synchronize { @pool.pop }
         store = @builder.build.last
         @mutex.synchronize { @all << store }
-        store
-      else
-        @mutex.synchronize { @pool.pop }
       end
+      store
     end
   end
 end

data/lib/moneta/proxy.rb

@@ -17,6 +17,16 @@ module Moneta
       adapter.key?(key, options)
     end
 
+    # (see Defaults#each_key)
+    def each_key(&block)
+      raise NotImplementedError, "each_key is not supported on this proxy" \
+        unless supports? :each_key
+
+      return enum_for(:each_key) unless block_given?
+      adapter.each_key(&block)
+      self
+    end
+
     # (see Defaults#increment)
     def increment(key, amount = 1, options = {})
       adapter.increment(key, amount, options)
@@ -85,9 +95,43 @@ module Moneta
       self
     end
 
-    # (see Default#features)
+    # (see Defaults#values_at)
+    def values_at(*keys, **options)
+      adapter.values_at(*keys, **options)
+    end
+
+    # (see Defaults#fetch_values)
+    def fetch_values(*keys, **options, &defaults)
+      adapter.fetch_values(*keys, **options, &defaults)
+    end
+
+    # (see Defaults#slice)
+    def slice(*keys, **options)
+      adapter.slice(*keys, **options)
+    end
+
+    # (see Defaults#merge!)
+    def merge!(pairs, options = {}, &block)
+      adapter.merge!(pairs, options, &block)
+      self
+    end
+
+    # (see Defaults#features)
     def features
-      @features ||= (self.class.features + adapter.features).uniq.freeze
+      @features ||= (self.class.features | adapter.features - self.class.features_mask).freeze
+    end
+
+    class << self
+      # @api private
+      def features_mask
+        @features_mask ||= [].freeze
+      end
+
+      # (see Defaults::ClassMethods#not_supports)
+      def not_supports *features
+        @features_mask = (self.features_mask | features).freeze
+        super
+      end
     end
   end
 end

data/lib/moneta/server.rb

@@ -35,6 +35,7 @@ module Moneta
         end
       ensure
         File.unlink(@socket) if @socket
+        @ios.each{ |io| io.close rescue nil }
       end
     end
 
@@ -99,8 +100,11 @@ module Moneta
       buffer.slice!(0, 4)
       method, *args = Marshal.load(buffer.slice!(0, size))
       case method
-      when :key?, :load, :delete, :increment, :create, :features
+      when :key?, :load, :delete, :increment, :create
         io.write(pack @store.send(method, *args))
+      when :features
+        # all features except each_key are supported
+        io.write(pack(@store.features - [:each_key]))
       when :store, :clear
         @store.send(method, *args)
         io.write(@nil ||= pack(nil))

data/lib/moneta/shared.rb

@@ -11,6 +11,8 @@ module Moneta
   #
   # @api public
   class Shared < Wrapper
+    not_supports :each_key
+
     # @param [Hash] options
     # @option options [Integer] :port (9000) TCP port
     # @option options [String] :host Server hostname
@@ -18,6 +20,7 @@ module Moneta
     def initialize(options = {}, &block)
       @options = options
       @builder = Builder.new(&block)
+      @connect_lock = ::Mutex.new
     end
 
     # (see Proxy#close)
@@ -38,10 +41,17 @@ module Moneta
     def wrap(*args)
       connect
       yield
+    rescue Errno::ECONNRESET, Errno::EPIPE, IOError, SystemCallError
+      @connect_lock.synchronize{ close unless @server }
+      tries ||= 0
+      (tries += 1) < 3 ? retry : raise
     end
 
     def connect
-      @adapter ||= Adapters::Client.new(@options)
+      return if @adapter
+      @connect_lock.synchronize do
+        @adapter ||= Adapters::Client.new(@options)
+      end
     rescue Errno::ECONNREFUSED, Errno::ENOENT => ex
       start_server
       tries ||= 0
@@ -52,16 +62,22 @@ module Moneta
     # TODO: Implement this using forking (MRI) and threading (JRuby)
     # to get maximal performance
     def start_server
-      @adapter = Lock.new(@builder.build.last)
-      @server = Server.new(@adapter, @options)
-      @thread = Thread.new { @server.run }
-      sleep 0.1 until @server.running?
-    rescue Exception => ex
-      @adapter.close if @adapter
-      @adapter = nil
-      @server = nil
-      @thread = nil
-      warn "Moneta::Shared - Failed to start server: #{ex.message}"
+      @connect_lock.synchronize do
+        begin
+          raise "Adapter already set" if @adapter
+          @adapter = Lock.new(@builder.build.last)
+          raise "Server already set" if @server
+          @server = Server.new(@adapter, @options)
+          @thread = Thread.new { @server.run }
+          sleep 0.1 until @server.running?
+        rescue => ex
+          @adapter.close if @adapter
+          @adapter = nil
+          @server = nil
+          @thread = nil
+          warn "Moneta::Shared - Failed to start server: #{ex.message}"
+        end
+      end
     end
   end
 end

data/lib/moneta/stack.rb

@@ -99,7 +99,7 @@ module Moneta
       @features ||=
         begin
           features = @stack.map(&:features)
-          features.inject(features.first, &:&).freeze
+          (features.inject(features.first, &:&) - [:each_key]).freeze
         end
     end
   end

data/lib/moneta/synchronize.rb

@@ -1,6 +1,6 @@
 module Moneta
   # Base class for {Mutex} and {Semaphore}
-  # @api private
+  # @abstract
   class SynchronizePrimitive
     # Synchronize block
     #
@@ -16,7 +16,6 @@ module Moneta
 
     # Try to enter critical section (nonblocking)
     #
-    # @api public
     # @return [Boolean] true if the lock was acquired
     def try_enter
       raise 'Already locked' if @locked
@@ -26,7 +25,6 @@ module Moneta
 
     # Enter critical section (blocking)
     #
-    # @api public
     # @param [Number] timeout Maximum time to wait
     # @param [Number] wait Sleep time between tries to acquire lock
     # @return [Boolean] true if the lock was aquired
@@ -41,8 +39,6 @@ module Moneta
     alias_method :lock, :enter
 
     # Leave critical section
-    #
-    # @api public
     def leave
       raise 'Not locked' unless @locked
       leave_primitive
@@ -52,8 +48,6 @@ module Moneta
     alias_method :unlock, :leave
 
     # Is the lock acquired?
-    #
-    # @api public
     def locked?
       @locked
     end
@@ -101,7 +95,7 @@ module Moneta
   class Semaphore < SynchronizePrimitive
     # @param [Moneta store] store The store we want to lock
     # @param [Object] counter Key of the counter entry
-    # @param [Fixnum] max Maximum number of threads which are allowed to enter the critical section
+    # @param [Integer] max Maximum number of threads which are allowed to enter the critical section
     def initialize(store, counter, max = 1)
       raise 'Store must support feature :increment' unless store.supports?(:increment)
       @store, @counter, @max = store, counter, max

data/lib/moneta/transformer.rb

@@ -79,6 +79,8 @@ module Moneta
 
       def compile_key_transformer(klass, key, key_opts)
         klass.class_eval <<-end_eval, __FILE__, __LINE__
+          not_supports :each_key
+
           def key?(key, options = {})
             @adapter.key?(#{key}, #{without key_opts})
           end
@@ -97,6 +99,36 @@ module Moneta
           def create(key, value, options = {})
             @adapter.create(#{key}, value, #{without :raw, key_opts})
           end
+          def values_at(*keys, **options)
+            t_keys = keys.map { |key| #{key} }
+            @adapter.values_at(*t_keys, **#{without :raw, key_opts})
+          end
+          def fetch_values(*keys, **options)
+            t_keys = keys.map { |key| #{key} }
+
+            block = if block_given?
+                      key_lookup = Hash[t_keys.zip(keys)]
+                      lambda { |t_key| yield key_lookup[t_key] }
+                    end
+            @adapter.fetch_values(*t_keys, **#{without :raw, key_opts}, &block)
+          end
+          def slice(*keys, **options)
+            t_keys = keys.map { |key| #{key} }
+            key_lookup = Hash[t_keys.zip(keys)]
+            @adapter.slice(*t_keys, **#{without :raw, key_opts}).map do |key, value|
+              [key_lookup[key], value]
+            end
+          end
+          def merge!(pairs, options = {})
+            keys, values = pairs.to_a.transpose
+            t_keys = keys.map { |key| #{key} }
+            block = if block_given?
+                      key_lookup = Hash[t_keys.zip(keys)]
+                      lambda { |k, old, new| yield(key_lookup[k], old, new) }
+                    end
+            @adapter.merge!(t_keys.zip(values), #{without :raw, key_opts}, &block)
+            self
+          end
         end_eval
       end
 
@@ -117,11 +149,61 @@ module Moneta
           def create(key, value, options = {})
             @adapter.create(key, options[:raw] ? value : #{dump}, #{without :raw, dump_opts})
           end
+          def values_at(*keys, **options)
+            values = @adapter.values_at(*keys, **#{without :raw, load_opts})
+            values.map do |value|
+              value && !options[:raw] ? #{load} : value
+            end
+          end
+          def fetch_values(*keys, **options, &orig_block)
+            substituted = {}
+            block = if block_given?
+                      lambda { |key| substituted[key] = true; yield key }
+                    end
+
+            values = @adapter.fetch_values(*keys, **#{without :raw, load_opts}, &block)
+            if options[:raw]
+              values
+            else
+              keys.map(&substituted.method(:key?)).zip(values).map do |substituted, value|
+                if substituted || !value
+                  value
+                else
+                  #{load}
+                end
+              end
+            end
+          end
+          def slice(*keys, **options)
+            @adapter.slice(*keys, **#{without :raw, load_opts}).map do |key, value|
+              [key, value && !options[:raw] ? #{load} : value]
+            end
+          end
+          def merge!(pairs, options = {}, &orig_block)
+            block = if block_given?
+                      if options[:raw]
+                        orig_block
+                      else
+                        lambda do |k, old_val, new_val|
+                          value = old_val; old_val = #{load}
+                          value = new_val; new_val = #{load}
+                          value = yield(k, old_val, new_val)
+                          #{dump}
+                        end
+                      end
+                    end
+
+            t_pairs = options[:raw] ? pairs : pairs.map { |key, value| [key, #{dump}] }
+            @adapter.merge!(t_pairs, #{without :raw, dump_opts}, &block)
+            self
+          end
         end_eval
       end
 
       def compile_key_value_transformer(klass, key, key_opts, load, load_opts, dump, dump_opts)
         klass.class_eval <<-end_eval, __FILE__, __LINE__
+          not_supports :each_key
+
           def key?(key, options = {})
             @adapter.key?(#{key}, #{without key_opts})
           end
@@ -143,6 +225,73 @@ module Moneta
           def create(key, value, options = {})
             @adapter.create(#{key}, options[:raw] ? value : #{dump}, #{without :raw, key_opts, dump_opts})
           end
+          def values_at(*keys, **options)
+            t_keys = keys.map { |key| #{key} }
+            values = @adapter.values_at(*t_keys, **#{without :raw, key_opts, load_opts})
+            values.map do |value|
+              value && !options[:raw] ? #{load} : value
+            end
+          end
+          def fetch_values(*keys, **options)
+            t_keys = keys.map { |key| #{key} }
+            key_lookup = Hash[t_keys.zip(keys)]
+            substituted = {}
+            block = if block_given?
+                      lambda do |t_key|
+                        key = key_lookup[t_key]
+                        substituted[key] = true
+                        yield key
+                      end
+                    end
+
+            values = @adapter.fetch_values(*t_keys, **#{without :raw, key_opts, load_opts}, &block)
+
+            if options[:raw]
+              values
+            else
+              keys.map(&substituted.method(:key?)).zip(values).map do |substituted, value|
+                if substituted || !value
+                  value
+                else
+                  #{load}
+                end
+              end
+            end
+          end
+          def slice(*keys, **options)
+            t_keys = keys.map { |key| #{key} }
+            key_lookup = Hash[t_keys.zip(keys)]
+            @adapter.slice(*t_keys, **#{without :raw, key_opts, load_opts}).map do |key, value|
+              [key_lookup[key], value && !options[:raw] ? #{load} : value]
+            end
+          end
+          def merge!(pairs, options = {})
+            keys, values = pairs.to_a.transpose
+            t_keys = keys.map { |key| #{key} }
+            key_lookup = Hash[t_keys.zip(keys)]
+
+            block = if block_given?
+                      if options[:raw]
+                        lambda do |k, old_val, new_val|
+                          yield(key_lookup[k], old_val, new_val)
+                        end
+                      else
+                        lambda do |k, old_val, new_val|
+                          value = old_val; old_val = #{load}
+                          value = new_val; new_val = #{load}
+                          value = yield(key_lookup[k], old_val, new_val)
+                          #{dump}
+                        end
+                      end
+                    end
+            t_pairs = if options[:raw]
+                        t_keys.zip(values)
+                      else
+                        t_keys.zip(values.map { |value| #{dump} })
+                      end
+            @adapter.merge!(t_pairs, #{without :raw, key_opts, dump_opts}, &block)
+            self
+          end
         end_eval
       end
 
@@ -181,8 +330,9 @@ module Moneta
       end
 
       def class_name(keys, values)
-        (keys.empty? ? '' : keys.map(&:to_s).map(&:capitalize).join + 'Key') +
-          (values.empty? ? '' : values.map(&:to_s).map(&:capitalize).join + 'Value')
+        camel_case = lambda{ |sym| sym.to_s.split('_').map(&:capitalize).join }
+        (keys.empty? ? '' : keys.map(&camel_case).join + 'Key') +
+          (values.empty? ? '' : values.map(&camel_case).join + 'Value')
       end
     end
   end

data/lib/moneta/transformer/config.rb

@@ -21,6 +21,8 @@ module Moneta
       quicklz:  [ :compress,  '::QuickLZ.decompress(%s)',     '::QuickLZ.compress(%s)',          'qlzruby'       ],
       zlib:     [ :compress,  '::Zlib::Inflate.inflate(%s)',  '::Zlib::Deflate.deflate(%s)',     'zlib'          ],
       base64:   [ :encode,    "%s.unpack('m0').first",        "[%s].pack('m0')"                                  ],
+      urlsafe_base64: [
+                  :encode,    'Base64.urlsafe_decode64(%s)',  'Base64.urlsafe_encode64(%s)',     'base64'        ],
       escape:   [ :encode,    'Helper.unescape(%s)',          'Helper.escape(%s)'                                ],
       hex:      [ :encode,    "[%s].pack('H*')",              "%s.unpack('H*').first"                            ],
       qp:       [ :encode,    "%s.unpack('M').first",         "[%s].pack('M')"                                   ],