moneta 0.7.6 → 0.7.8

data/lib/moneta/adapters/sqlite.rb

@@ -20,7 +20,8 @@ module Moneta
           [@select = @db.prepare("select v from #{table} where k = ?"),
            @replace = @db.prepare("replace into #{table} values (?, ?)"),
            @delete = @db.prepare("delete from #{table} where k = ?"),
-           @clear = @db.prepare("delete from #{table}")]
+           @clear = @db.prepare("delete from #{table}"),
+           @create = @db.prepare("insert into #{table} values (?, ?)")]
       end
 
       # (see Proxy#key?)
@@ -58,6 +59,17 @@ module Moneta
         self
       end
 
+      # (see Default#create)
+      def create(key, value, options = {})
+        @create.execute!(key,value)
+        true
+      rescue SQLite3::ConstraintException
+        # If you know a better way to detect whether an insert-ignore
+        # suceeded, please tell me.
+        @create.reset!
+        false
+      end
+
       # (see Proxy#close)
       def close
         @stmts.each {|s| s.close }

data/lib/moneta/adapters/tokyocabinet.rb

@@ -29,6 +29,11 @@ module Moneta
         end
       end
 
+      # (see Proxy#create)
+      def create(key, value, options = {})
+        @hash.putkeep(key, value)
+      end
+
       # (see Proxy#close)
       def close
         @hash.close

data/lib/moneta/cache.rb

@@ -73,6 +73,16 @@ module Moneta
       @backend.increment(key, amount, options)
     end
 
+    # (see Proxy#create)
+    def create(key, value, options = {})
+      if @backend.create(key, value, options)
+        @cache.store(key, value, options)
+        true
+      else
+        false
+      end
+    end
+
     # (see Proxy#delete)
     def delete(key, options = {})
       @cache.delete(key, options)

data/lib/moneta/expires.rb

@@ -21,8 +21,7 @@ module Moneta
       # Transformer might raise exception
       load_entry(key, options) != nil
     rescue Exception
-      options.include?(:expires) && (options = options.dup; options.delete(:expires))
-      super(key, options)
+      super(key, Utils.without(options, :expires))
     end
 
     # (see Proxy#load)
@@ -36,11 +35,7 @@ module Moneta
     def store(key, value, options = {})
       return super if options.include?(:raw)
       expires = expires_at(options)
-      if options.include?(:expires)
-        options = options.dup
-        options.delete(:expires)
-      end
-      store_entry(key, value, expires, options)
+      super(key, new_entry(value, expires), Utils.without(options, :expires))
       value
     end
 
@@ -51,14 +46,18 @@ module Moneta
       value if !expires || Time.now.to_i <= expires
     end
 
+    # (see Proxy#store)
+    def create(key, value, options = {})
+      return super if options.include?(:raw)
+      expires = expires_at(options)
+      @adapter.create(key, new_entry(value, expires), Utils.without(options, :expires))
+    end
+
     private
 
     def load_entry(key, options)
       new_expires = expires_at(options, nil)
-      if options.include?(:expires)
-        options = options.dup
-        options.delete(:expires)
-      end
+      options = Utils.without(options, :expires)
       entry = @adapter.load(key, options)
       if entry != nil
         value, expires = entry
@@ -66,7 +65,7 @@ module Moneta
           delete(key)
           nil
         elsif new_expires != nil
-          store_entry(key, value, new_expires, options)
+          @adapter.store(key, new_entry(value, new_expires), options)
           entry
         else
           entry
@@ -74,16 +73,14 @@ module Moneta
       end
     end
 
-    def store_entry(key, value, expires, options)
-      entry =
-        if expires
-          [value, expires.to_i]
-        elsif Array === value || value == nil
-          [value]
-        else
-          value
-        end
-      @adapter.store(key, entry, options)
+    def new_entry(value, expires)
+      if expires
+        [value, expires.to_i]
+      elsif Array === value || value == nil
+        [value]
+      else
+        value
+      end
     end
   end
 end

data/lib/moneta/lock.rb

@@ -6,10 +6,10 @@ module Moneta
   class Lock < Wrapper
     # @param [Moneta store] adapter The underlying store
     # @param [Hash] options
-    # @option options [String] :mutex (Mutex.new) Mutex object
+    # @option options [String] :mutex (::Mutex.new) Mutex object
     def initialize(adapter, options = {})
       super
-      @lock = options[:mutex] || Mutex.new
+      @lock = options[:mutex] || ::Mutex.new
     end
 
     protected

data/lib/moneta/mixins.rb

@@ -24,7 +24,7 @@ module Moneta
     def raw
       @raw_store ||=
         begin
-          store = with(:raw => true, :only => [:load, :store, :delete])
+          store = with(:raw => true, :only => [:load, :store, :create, :delete])
           store.instance_variable_set(:@raw_store, store)
           store
         end
@@ -45,7 +45,7 @@ module Moneta
     # @return [OptionMerger]
     # @api public
     def expires(expires)
-      with(:expires => expires, :only => [:store, :increment])
+      with(:expires => expires, :only => [:store, :create, :increment])
     end
   end
 
@@ -58,8 +58,8 @@ module Moneta
     #
     # @param [Object] key
     # @param [Hash] options
-    # @option options [Integer] :expires Update expiration time (See `Moneta::Expires`)
-    # @option options [String] :prefix Prefix key (See `Moneta::Transformer`)
+    # @option options [Integer] :expires Update expiration time (See {Expires})
+    # @option options [String] :prefix Prefix key (See {Transformer})
     # @option options Other options as defined by the adapters or middleware
     # @return [Boolean]
     # @api public
@@ -149,6 +149,19 @@ module Moneta
     def []=(key, value)
       store(key, value)
     end
+
+    # Atomically sets a key to value if it's not set.
+    #
+    # @note Not every Moneta store implements this method,
+    #       a NotImplementedError is raised if it is not supported.
+    # @param [Object] key
+    # @param [Object] value
+    # @param [Hash] options
+    # @return [Boolean] key was set
+    # @api public
+    def create(key, value, options = {})
+      raise NotImplementedError, 'create is not supported'
+    end
   end
 
   # @api private
@@ -156,17 +169,26 @@ module Moneta
     # (see Defaults#increment)
     # @api public
     def increment(key, amount = 1, options = {})
-      value = convert_for_increment(load(key, options)) + amount
+      value = Utils.to_int(load(key, options)) + amount
       store(key, value.to_s, options)
       value
     end
+  end
 
-    protected
-
-    def convert_for_increment(value)
-      intvalue = value.to_i
-      raise 'Tried to increment non integer value' unless value == nil || intvalue.to_s == value.to_s
-      intvalue
+  # Implements simple create using key? and store.
+  #
+  # This is sufficient for non-shared stores or if atomicity is not required.
+  # @api private
+  module CreateSupport
+    # (see Default#create)
+    # @api public
+    def create(key, value, options = {})
+      if key? key
+        false
+      else
+        store(key, value, options)
+        true
+      end
     end
   end
 

data/lib/moneta/optionmerger.rb

@@ -1,7 +1,7 @@
 module Moneta
   # @api private
   class OptionMerger < Wrapper
-    METHODS = [:key?, :load, :store, :delete, :increment, :clear].freeze
+    METHODS = [:key?, :load, :store, :create, :delete, :increment, :clear].freeze
 
     attr_reader :default_options
 

data/lib/moneta/proxy.rb

@@ -22,6 +22,11 @@ module Moneta
       adapter.increment(key, amount, options)
     end
 
+    # (see Defaults#create)
+    def create(key, value, options = {})
+      adapter.create(key, value, options)
+    end
+
     # (see Defaults#close)
     def close
       adapter.close
@@ -31,9 +36,9 @@ module Moneta
     #
     # @param [Object] key
     # @param [Hash] options
-    # @option options [Integer] :expires Update expiration time (See `Moneta::Expires`)
-    # @option options [Boolean] :raw Raw access without value transformation (See `Moneta::Transformer`)
-    # @option options [String] :prefix Prefix key (See `Moneta::Transformer`)
+    # @option options [Integer] :expires Update expiration time (See {Expires})
+    # @option options [Boolean] :raw Raw access without value transformation (See {Transformer})
+    # @option options [String] :prefix Prefix key (See {Transformer})
     # @option options Other options as defined by the adapters or middleware
     # @return [Object] value
     # @api public
@@ -46,9 +51,9 @@ module Moneta
     # @param [Object] key
     # @param [Object] value
     # @param [Hash] options
-    # @option options [Integer] :expires Set expiration time (See `Moneta::Expires`)
-    # @option options [Boolean] :raw Raw access without value transformation (See `Moneta::Transformer`)
-    # @option options [String] :prefix Prefix key (See `Moneta::Transformer`)
+    # @option options [Integer] :expires Set expiration time (See {Expires})
+    # @option options [Boolean] :raw Raw access without value transformation (See {Transformer})
+    # @option options [String] :prefix Prefix key (See {Transformer})
     # @option options Other options as defined by the adapters or middleware
     # @return value
     # @api public
@@ -61,8 +66,8 @@ module Moneta
     # @param [Object] key
     # @return [Object] current value
     # @param [Hash] options
-    # @option options [Boolean] :raw Raw access without value transformation (See `Moneta::Transformer`)
-    # @option options [String] :prefix Prefix key (See `Moneta::Transformer`)
+    # @option options [Boolean] :raw Raw access without value transformation (See {Transformer})
+    # @option options [String] :prefix Prefix key (See {Transformer})
     # @option options Other options as defined by the adapters or middleware
     # @api public
     def delete(key, options = {})

data/lib/moneta/server.rb

@@ -6,12 +6,12 @@ module Moneta
   class Server
     # @param [Hash] options
     # @option options [Integer] :port (9000) TCP port
-    # @option options [String] :file Alternative Unix socket file name
+    # @option options [String] :socket Alternative Unix socket file name
     def initialize(store, options = {})
       @store = store
       @server =
-        if @file = options[:file]
-          UNIXServer.open(@file)
+        if @socket = options[:socket]
+          UNIXServer.open(@socket)
         else
           TCPServer.open(options[:port] || DEFAULT_PORT)
         end
@@ -38,7 +38,7 @@ module Moneta
           mainloop
         end
       ensure
-        File.unlink(@file) if @file
+        File.unlink(@socket) if @socket
       end
     end
 
@@ -58,8 +58,15 @@ module Moneta
     def mainloop
       client = accept
       handle(client) if client
+    rescue SignalException => ex
+      warn "Moneta::Server - #{ex.message}"
+      raise if ex.signo == 15 # SIGTERM
+    rescue IOError => ex
+      warn "Moneta::Server - #{ex.message}" unless ex.message =~ /closed/
+      @clients.delete(client) if client
+      @clients.reject!(&:closed?)
     rescue Exception => ex
-      warn ex.message
+      warn "Moneta::Server - #{ex.message}"
       write(client, Error.new(ex.message)) if client
     end
 
@@ -85,7 +92,7 @@ module Moneta
     def handle(client)
       method, *args = read(client)
       case method
-      when :key?, :load, :delete, :increment
+      when :key?, :load, :delete, :increment, :create
         write(client, @store.send(method, *args))
       when :store, :clear
         @store.send(method, *args)

data/lib/moneta/shared.rb

@@ -14,7 +14,7 @@ module Moneta
     # @param [Hash] options
     # @option options [Integer] :port (9000) TCP port
     # @option options [String] :host Server hostname
-    # @option options [String] :file Unix socket file name
+    # @option options [String] :socket Unix socket file name
     def initialize(options = {}, &block)
       @options = options
       @builder = Builder.new(&block)
@@ -38,8 +38,9 @@ module Moneta
     def wrap(*args)
       @adapter ||= Adapters::Client.new(@options)
       yield
-    rescue Exception => ex
-      warn "Failed to connect: #{ex.message}"
+    rescue Errno::ECONNREFUSED, Errno::ENOENT => ex
+      tries ||= 0
+      warn "Moneta::Shared - Failed to connect: #{ex.message}" if tries > 0
       begin
         # TODO: Implement this using forking (MRI) and threading (JRuby)
         # to get maximal performance
@@ -48,16 +49,11 @@ module Moneta
         @thread = Thread.new { @server.run }
         sleep 0.1 until @server.running?
       rescue Exception => ex
-        warn "Failed to start server: #{ex.message}"
+        warn "Moneta::Shared - Failed to start server: #{ex.message}"
         @adapter.close if @adapter
         @adapter = nil
       end
-      tries ||= 0
-      if (tries += 1) > 2
-        raise
-      else
-        retry
-      end
+      (tries += 1) < 3 ? retry : raise
     end
   end
 end

data/lib/moneta/synchronize.rb

@@ -0,0 +1,125 @@
+module Moneta
+  # Base class for {Mutex} and {Semaphore}
+  # @api private
+  class SynchronizePrimitive
+    # Synchronize block
+    #
+    # @api public
+    # @yieldparam Synchronized block
+    # @return [Object] result of block
+    def synchronize
+      enter
+      yield
+    ensure
+      leave
+    end
+
+    # Try to enter critical section (nonblocking)
+    #
+    # @api public
+    # @return [Boolean] true if the lock was acquired
+    def try_enter
+      raise 'Already locked' if @locked
+      enter_primitive ? @locked = true : false
+    end
+    alias_method :try_lock, :try_enter
+
+    # 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
+    def enter(timeout = nil, wait = 0.01)
+      total = 0
+      while !timeout || total < timeout
+        return true if try_enter
+        sleep(wait)
+        total += wait
+      end
+      false
+    end
+    alias_method :lock, :enter
+
+    # Leave critical section
+    #
+    # @api public
+    def leave
+      raise 'Not locked' unless @locked
+      leave_primitive
+      @locked = false
+      nil
+    end
+    alias_method :unlock, :leave
+
+    # Is the lock acquired?
+    #
+    # @api public
+    def locked?
+      @locked
+    end
+  end
+
+  # Distributed/shared store-wide mutex
+  #
+  # @example Use `Moneta::Mutex`
+  #     mutex = Moneta::Mutex.new(store, 'mutex')
+  #     mutex.synchronize do
+  #       # Synchronized access
+  #       store['counter'] += 1
+  #     end
+  #
+  # @api public
+  class Mutex < SynchronizePrimitive
+    # @param [Moneta store] store The store we want to lock
+    # @param [Object] lock Key of the lock entry
+    def initialize(store, lock)
+      @store, @lock = store, lock
+    end
+
+    protected
+
+    def enter_primitive
+      @store.create(@lock, '', :expires => false)
+    end
+
+    def leave_primitive
+      @store.delete(@lock)
+    end
+  end
+
+  # Distributed/shared store-wide semaphore
+  #
+  # @example Use `Moneta::Semaphore`
+  #     semaphore = Moneta::Semaphore.new(store, 'semaphore', 2)
+  #     semaphore.synchronize do
+  #       # Synchronized access
+  #       ...
+  #     end
+  #
+  # @api public
+  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
+    def initialize(store, counter, max = 1)
+      @store, @counter, @max = store, counter, max
+      @store.increment(@counter, 0, :expires => false) # Ensure that counter exists
+    end
+
+    protected
+
+    def enter_primitive
+      if @store.increment(@counter, 1) <= @max
+        true
+      else
+        @store.decrement(@counter)
+        false
+      end
+    end
+
+    def leave_primitive
+      @store.decrement(@counter)
+    end
+  end
+end