moneta 1.4.1 → 1.5.1

data/lib/moneta/adapters/sqlite.rb

@@ -4,12 +4,16 @@ module Moneta
   module Adapters
     # Sqlite3 backend
     # @api public
-    class Sqlite
-      include Defaults
+    class Sqlite < Adapter
       include IncrementSupport
 
       supports :create, :each_key
-      attr_reader :backend
+
+      config :table, default: 'moneta'
+      config :busy_timeout, default: 1000
+      config :journal_mode
+
+      backend { |file:| ::SQLite3::Database.new(file) }
 
       # @param [Hash] options
       # @option options [String] :file Database file
@@ -18,31 +22,29 @@ module Moneta
       # @option options [::Sqlite3::Database] :backend Use existing backend instance
       # @option options [String, Symbol] :journal_mode Set the journal mode for the connection
       def initialize(options = {})
-        @table = options[:table] || 'moneta'
-        @backend = options[:backend] ||
-          begin
-            raise ArgumentError, 'Option :file is required' unless options[:file]
-            ::SQLite3::Database.new(options[:file])
-          end
-        @backend.busy_timeout(options[:busy_timeout] || 1000)
-        @backend.execute("create table if not exists #{@table} (k blob not null primary key, v blob)")
-        if journal_mode = options[:journal_mode]
-          @backend.journal_mode = journal_mode.to_s
+        super
+
+        backend.busy_timeout(config.busy_timeout)
+        backend.execute("create table if not exists #{config.table} (k blob not null primary key, v blob)")
+
+        if journal_mode = config.journal_mode
+          backend.journal_mode = journal_mode.to_s
         end
+
         @stmts =
-          [@exists = @backend.prepare("select exists(select 1 from #{@table} where k = ?)"),
-           @select = @backend.prepare("select v from #{@table} where k = ?"),
-           @replace = @backend.prepare("replace into #{@table} values (?, ?)"),
-           @delete = @backend.prepare("delete from #{@table} where k = ?"),
-           @clear = @backend.prepare("delete from #{@table}"),
-           @create = @backend.prepare("insert into #{@table} values (?, ?)"),
-           @keys = @backend.prepare("select k from #{@table}"),
-           @count = @backend.prepare("select count(*) from #{@table}")]
-
-        version = @backend.execute("select sqlite_version()").first.first
+          [@exists = backend.prepare("select exists(select 1 from #{config.table} where k = ?)"),
+           @select = backend.prepare("select v from #{config.table} where k = ?"),
+           @replace = backend.prepare("replace into #{config.table} values (?, ?)"),
+           @delete = backend.prepare("delete from #{config.table} where k = ?"),
+           @clear = backend.prepare("delete from #{config.table}"),
+           @create = backend.prepare("insert into #{config.table} values (?, ?)"),
+           @keys = backend.prepare("select k from #{config.table}"),
+           @count = backend.prepare("select count(*) from #{config.table}")]
+
+        version = backend.execute("select sqlite_version()").first.first
         if @can_upsert = ::Gem::Version.new(version) >= ::Gem::Version.new('3.24.0')
-          @stmts << (@increment = @backend.prepare <<-SQL)
-            insert into #{@table} values (?, ?)
+          @stmts << (@increment = backend.prepare <<-SQL)
+            insert into #{config.table} values (?, ?)
             on conflict (k)
             do update set v = cast(cast(v as integer) + ? as blob)
             where v = '0' or v = X'30' or cast(v as integer) != 0
@@ -76,8 +78,8 @@ module Moneta
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        @backend.transaction(:exclusive) { return super } unless @can_upsert
-        @backend.transaction do
+        backend.transaction(:exclusive) { return super } unless @can_upsert
+        backend.transaction do
           @increment.execute!(key, amount.to_s, amount)
           return Integer(load(key))
         end
@@ -103,14 +105,14 @@ module Moneta
       # (see Proxy#close)
       def close
         @stmts.each { |s| s.close }
-        @backend.close
+        backend.close
         nil
       end
 
       # (see Proxy#slice)
       def slice(*keys, **options)
-        query = "select k, v from #{@table} where k in (#{(['?'] * keys.length).join(',')})"
-        @backend.execute(query, keys)
+        query = "select k, v from #{config.table} where k in (#{(['?'] * keys.length).join(',')})"
+        backend.execute(query, keys)
       end
 
       # (see Proxy#values_at)
@@ -134,7 +136,7 @@ module Moneta
 
       # (see Proxy#merge!)
       def merge!(pairs, options = {})
-        transaction = @backend.transaction if block_given?
+        transaction = backend.transaction if block_given?
 
         if block_given?
           existing = Hash[slice(*pairs.map { |k, _| k }.to_a)]
@@ -146,13 +148,13 @@ module Moneta
           pairs = pairs.to_a
         end
 
-        query = "replace into #{@table} (k, v) values" + (['(?, ?)'] * pairs.length).join(',')
-        @backend.query(query, pairs.flatten).close
+        query = "replace into #{config.table} (k, v) values" + (['(?, ?)'] * pairs.length).join(',')
+        backend.query(query, pairs.flatten).close
       rescue
-        @backend.rollback if transaction
+        backend.rollback if transaction
         raise
       else
-        @backend.commit if transaction
+        backend.commit if transaction
         self
       end
 

data/lib/moneta/adapters/tdb.rb

@@ -4,34 +4,28 @@ module Moneta
   module Adapters
     # TDB backend
     # @api public
-    class TDB
-      include Defaults
+    class TDB < Adapter
       include HashAdapter
       include IncrementSupport
       include EachKeySupport
 
       supports :create
 
-      # @param [Hash] options
-      # @option options [String] :file Database file
-      # @option options [::TDB] :backend Use existing backend instance
-      def initialize(options)
-        @backend = options[:backend] ||
-          begin
-            raise ArgumentError, 'Option :file is required' unless file = options.delete(:file)
-            ::TDB.new(file, options)
-          end
-      end
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :file Database file
+      #   @option options [::TDB] :backend Use existing backend instance
+      backend { |file:, **options| ::TDB.new(file, options) }
 
       # (see Proxy#close)
       def close
-        @backend.close
+        backend.close
         nil
       end
 
       # (see Proxy#create)
       def create(key, value, options = {})
-        @backend.insert!(key, value)
+        backend.insert!(key, value)
         true
       rescue ::TDB::ERR::EXISTS
         false

data/lib/moneta/adapters/tokyocabinet.rb

@@ -4,29 +4,31 @@ module Moneta
   module Adapters
     # TokyoCabinet backend
     # @api public
-    class TokyoCabinet
-      include Defaults
+    class TokyoCabinet < Adapter
       include HashAdapter
       include IncrementSupport
       include CreateSupport
       include EachKeySupport
 
-      # @param [Hash] options
-      # @option options [String] :file Database file
-      # @option options [Symbol] :type (:hdb) Database type (:bdb and :hdb possible)
-      # @option options [::TokyoCabinet::*DB] :backend Use existing backend instance
-      def initialize(options = {})
-        if options[:backend]
-          @backend = options[:backend]
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :file Database file
+      #   @option options [Symbol] :type (:hdb) Database type (:bdb and :hdb possible)
+      #   @option options [::TokyoCabinet::*DB] :backend Use existing backend instance
+      backend do |file:, type: :hdb|
+        case type
+        when :bdb
+          ::TokyoCabinet::BDB.new.tap do |backend|
+            backend.open(file, ::TokyoCabinet::BDB::OWRITER | ::TokyoCabinet::BDB::OCREAT) or
+              raise backend.errmsg(backend.ecode)
+          end
+        when :hdb
+          ::TokyoCabinet::HDB.new.tap do |backend|
+            backend.open(file, ::TokyoCabinet::HDB::OWRITER | ::TokyoCabinet::HDB::OCREAT) or
+              raise backend.errmsg(backend.ecode)
+          end
         else
-          raise ArgumentError, 'Option :file is required' unless options[:file]
-          if options[:type] == :bdb
-            @backend = ::TokyoCabinet::BDB.new
-            @backend.open(options[:file], ::TokyoCabinet::BDB::OWRITER | ::TokyoCabinet::BDB::OCREAT)
-          else
-            @backend = ::TokyoCabinet::HDB.new
-            @backend.open(options[:file], ::TokyoCabinet::HDB::OWRITER | ::TokyoCabinet::HDB::OCREAT)
-          end or raise @backend.errmsg(@backend.ecode)
+          raise ArgumentError, ":type must be :bdb or :hdb"
         end
       end
 

data/lib/moneta/adapters/tokyotyrant.rb

@@ -10,51 +10,50 @@ module Moneta
   module Adapters
     # TokyoTyrant backend
     # @api public
-    class TokyoTyrant
-      include Defaults
+    class TokyoTyrant < Adapter
       include HashAdapter
 
       # error code: no record found
       ENOREC = 7
 
       supports :create, :increment
-      attr_reader :backend
+
+      backend do |host: '127.0.0.1', port: 1978|
+        if defined?(::TokyoTyrant::RDB)
+          # Use ruby client
+          ::TokyoTyrant::RDB.new.tap do |backend|
+            backend.open(host, port) or raise backend.errmsg
+          end
+        else
+          # Use native client
+          ::TokyoTyrant::DB.new(host, port)
+        end
+      end
 
       # @param [Hash] options
       # @option options [String] :host ('127.0.0.1') Server host name
       # @option options [Integer] :port (1978) Server port
       # @option options [::TokyoTyrant::RDB] :backend Use existing backend instance
       def initialize(options = {})
-        options[:host] ||= '127.0.0.1'
-        options[:port] ||= 1978
-        if options[:backend]
-          @backend = options[:backend]
-        elsif defined?(::TokyoTyrant::RDB)
-          # Use ruby client
-          @backend = ::TokyoTyrant::RDB.new
-          @backend.open(options[:host], options[:port]) or error
-        else
-          # Use native client
-          @backend = ::TokyoTyrant::DB.new(options[:host], options[:port])
-        end
-        @native = @backend.class.name != 'TokyoTyrant::RDB'
+        super
+        @native = backend.class.name != 'TokyoTyrant::RDB'
         probe = '__tokyotyrant_endianness_probe'
-        @backend.delete(probe)
-        @backend.addint(probe, 1)
-        @pack = @backend.delete(probe) == [1].pack('l>') ? 'l>' : 'l<'
+        backend.delete(probe)
+        backend.addint(probe, 1)
+        @pack = backend.delete(probe) == [1].pack('l>') ? 'l>' : 'l<'
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        value = @backend[key]
+        value = backend[key]
         # raise if there is an error and the error is not "no record"
-        error if value == nil && @backend.ecode != ENOREC
+        error if value == nil && backend.ecode != ENOREC
         value && unpack(value)
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        @backend.put(key, pack(value)) or error
+        backend.put(key, pack(value)) or error
         value
       end
 
@@ -62,14 +61,14 @@ module Moneta
       def delete(key, options = {})
         value = load(key, options)
         if value
-          @backend.delete(key) or error
+          backend.delete(key) or error
           value
         end
       end
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        @backend.addint(key, amount) or error
+        backend.addint(key, amount) or error
       end
 
       # (see Proxy#create)
@@ -77,18 +76,18 @@ module Moneta
         if @native
           begin
             # Native client throws an exception
-            @backend.putkeep(key, pack(value))
+            backend.putkeep(key, pack(value))
           rescue TokyoTyrantError
             false
           end
         else
-          @backend.putkeep(key, pack(value))
+          backend.putkeep(key, pack(value))
         end
       end
 
       # (see Proxy#close)
       def close
-        @backend.close
+        backend.close
         nil
       end
 
@@ -96,10 +95,10 @@ module Moneta
       def slice(*keys, **options)
         hash =
           if @native
-            @backend.mget(*keys)
+            backend.mget(*keys)
           else
             hash = Hash[keys.map { |key| [key] }]
-            raise unless @backend.mget(hash) >= 0
+            raise unless backend.mget(hash) >= 0
             hash
           end
 
@@ -142,7 +141,7 @@ module Moneta
       end
 
       def error
-        raise "#{@backend.class.name} error: #{@backend.errmsg}"
+        raise "#{backend.class.name} error: #{backend.errmsg}"
       end
     end
   end

data/lib/moneta/adapters/yaml.rb

@@ -5,11 +5,7 @@ module Moneta
     # YAML::Store backend
     # @api public
     class YAML < PStore
-      protected
-
-      def new_store(options)
-        ::YAML::Store.new(options[:file])
-      end
+      backend { |file:| ::YAML::Store.new(file) }
     end
   end
 end

data/lib/moneta/config.rb

@@ -0,0 +1,101 @@
+require 'set'
+
+module Moneta
+  # Some docs here
+  module Config
+    # @api private
+    module ClassMethods
+      def config(name, coerce: nil, default: nil, required: false, &block)
+        raise ArgumentError, 'name must be a symbol' unless Symbol === name
+
+        defaults = config_defaults
+
+        raise ArgumentError, "#{name} is already a config option" if defaults.key?(name)
+        raise ArgumentError, "coerce must respond to :to_proc" if coerce && !coerce.respond_to?(:to_proc)
+
+        defaults.merge!(name => default.freeze).freeze
+        instance_variable_set :@config_defaults, defaults
+
+        instance_variable_set :@config_coercions, config_coercions.merge!(name => coerce.to_proc) if coerce
+        instance_variable_set :@config_required_keys, config_required_keys.add(name).freeze if required
+        instance_variable_set :@config_blocks, config_blocks.merge!(name => block) if block
+      end
+
+      def config_variable(name)
+        if instance_variable_defined?(name)
+          instance_variable_get(name).dup
+        elsif superclass.respond_to?(:config_variable)
+          superclass.config_variable(name)
+        end
+      end
+
+      def config_defaults
+        config_variable(:@config_defaults) || {}
+      end
+
+      def config_required_keys
+        config_variable(:@config_required_keys) || Set.new
+      end
+
+      def config_coercions
+        config_variable(:@config_coercions) || {}
+      end
+
+      def config_blocks
+        config_variable(:@config_blocks) || {}
+      end
+
+      def config_struct
+        unless @config_struct
+          keys = config_defaults.keys
+          @config_struct = Struct.new(*keys) unless keys.empty?
+        end
+
+        @config_struct
+      end
+    end
+
+    def config
+      raise "Not configured" unless defined?(@config)
+      @config
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    protected
+
+    def configure(**options)
+      raise 'Already configured' if defined?(@config)
+
+      self.class.config_required_keys.each do |key|
+        raise ArgumentError, "#{key} is required" unless options.key? key
+      end
+
+      defaults = self.class.config_defaults
+
+      overrides, remainder = options
+        .partition { |key,| defaults.key? key }
+        .map { |pairs| pairs.to_h }
+
+      self.class.config_coercions.each do |key, coerce|
+        overrides[key] = coerce.call(overrides[key]) if overrides.key?(key)
+      end
+
+      overridden = defaults.merge!(overrides)
+
+      config_blocks = self.class.config_blocks
+      values = overridden.map do |key, value|
+        if config_block = config_blocks[key]
+          instance_exec(**overridden, &config_block)
+        else
+          value
+        end
+      end
+
+      @config = self.class.config_struct&.new(*values).freeze
+      remainder
+    end
+  end
+end

data/lib/moneta/expires.rb

@@ -14,7 +14,6 @@ module Moneta
     def initialize(adapter, options = {})
       raise 'Store already supports feature :expires' if adapter.supports?(:expires)
       super
-      self.default_expires = options[:expires]
     end
 
     # (see Proxy#key?)

data/lib/moneta/expires_support.rb

@@ -3,8 +3,6 @@ module Moneta
   #
   #
   module ExpiresSupport
-    attr_accessor :default_expires
-
     protected
 
     # Calculates the time when something will expire.
@@ -19,7 +17,7 @@ module Moneta
     # @return [false] if it should not expire
     # @return [Time] the time when something should expire
     # @return [nil] if it is not known
-    def expires_at(options, default = @default_expires)
+    def expires_at(options, default = config.expires)
       value = expires_value(options, default)
       Numeric === value ? Time.now + value : value
     end
@@ -36,7 +34,7 @@ module Moneta
     # @return [false] if it should not expire
     # @return [Numeric] seconds until expiration
     # @return [nil] if it is not known
-    def expires_value(options, default = @default_expires)
+    def expires_value(options, default = config.expires)
       case value = options[:expires]
       when 0, false
         false
@@ -54,6 +52,7 @@ module Moneta
     class << self
       def included(base)
         base.supports(:expires) if base.respond_to?(:supports)
+        base.config :expires
       end
     end
   end

data/lib/moneta/pool.rb

@@ -87,6 +87,7 @@ module Moneta
         @waiting_since = [] if @timeout
         @last_checkout = nil
         @stopping = false
+        @idle_time = nil
 
         # Launch the manager thread
         @thread = run
@@ -126,10 +127,16 @@ module Moneta
             populate_stores
 
             until @stopping && @stores.empty?
+              loop_start = Time.now
+
               # Block until a message arrives, or until we time out for some reason
-              if request = pop
-                handle_request(request)
-              end
+              request = pop
+
+              # Record how long we were idle, for stats purposes
+              @idle_time = Time.now - loop_start
+
+              # If a message arrived, handle it
+              handle_request(request) if request
 
               # Handle any stale checkout requests
               handle_timed_out_requests
@@ -186,7 +193,7 @@ module Moneta
       # @return [Integer, nil]
       def timeout
         # Time to wait before there will be stores that should be closed
-        ttl = if @ttl && @last_checkout && !@available.empty?
+        ttl = if @ttl && @last_checkout && stores_available? && stores_unneeded?
                 [@ttl - (Time.now - @last_checkout), 0].max
               end
 
@@ -199,6 +206,18 @@ module Moneta
         [ttl, timeout].compact.min
       end
 
+      def stores_available?
+        !@available.empty?
+      end
+
+      def stores_unneeded?
+        @stores.length > @min
+      end
+
+      def stores_maxed?
+        @max != nil && @stores.length == @max
+      end
+
       def pop
         @mutex.synchronize do
           @resource.wait(@mutex, timeout) if @inbox.empty?
@@ -218,7 +237,7 @@ module Moneta
           reply.resolve(ShutdownError.new("Shutting down"))
         elsif !@available.empty?
           reply.resolve(@available.pop)
-        elsif !@max || @stores.length < @max
+        elsif !stores_maxed?
           begin
             reply.resolve(add_store)
           rescue => e
@@ -258,7 +277,8 @@ module Moneta
                       waiting: @waiting.length,
                       longest_wait: @timeout && !@waiting_since.empty? ? @waiting_since.first.dup : nil,
                       stopping: @stopping,
-                      last_checkout: @last_checkout && @last_checkout.dup)
+                      last_checkout: @last_checkout && @last_checkout.dup,
+                      idle_time: @idle_time.dup)
       end
 
       def handle_request(request)
@@ -289,9 +309,9 @@ module Moneta
     #   store to become available.  If not specified, will wait forever.
     # @yield A builder context for speciying how to construct stores
     def initialize(options = {}, &block)
-      super(nil)
       @id = "Moneta::Pool(#{object_id})"
       @manager = PoolManager.new(Builder.new(&block), **options)
+      super(nil, options)
     end
 
     # Closing has no effect on the pool, as stores are closed in the background

data/lib/moneta/proxy.rb

@@ -3,6 +3,7 @@ module Moneta
   # @api public
   class Proxy
     include Defaults
+    include Config
 
     attr_reader :adapter
 
@@ -10,6 +11,7 @@ module Moneta
     # @param [Hash] options
     def initialize(adapter, options = {})
       @adapter = adapter
+      configure(**options)
     end
 
     # (see Defaults#key?)
@@ -133,5 +135,32 @@ module Moneta
         super
       end
     end
+
+    # Overrides the default implementation of the config method to:
+    #
+    # * pass the adapter's config, if this proxy has no configuration of its
+    #   own
+    # * return a merged configuration, allowing the proxy have precedence over
+    #   the adapter
+    def config
+      unless @proxy_config
+        config = super
+        adapter_config = adapter&.config
+
+        @proxy_config =
+          if config && adapter_config
+            adapter_members = adapter_config.members - config.members
+            members = config.members + adapter_members
+            struct = Struct.new(*members)
+
+            values = config.values + adapter_config.to_h.values_at(*adapter_members)
+            struct.new(*values)
+          else
+            config || adapter_config
+          end
+      end
+
+      @proxy_config
+    end
   end
 end