moneta 1.0.0 → 1.1.0

data/lib/moneta.rb

@@ -3,6 +3,7 @@ module Moneta
   autoload :Cache,             'moneta/cache'
   autoload :CreateSupport,     'moneta/mixins'
   autoload :Defaults,          'moneta/mixins'
+  autoload :EachKeySupport,    'moneta/mixins'
   autoload :ExpiresSupport,    'moneta/mixins'
   autoload :Expires,           'moneta/expires'
   autoload :HashAdapter,       'moneta/mixins'
@@ -21,11 +22,13 @@ module Moneta
   autoload :Transformer,       'moneta/transformer'
   autoload :Utils,             'moneta/utils'
   autoload :WeakCreate,        'moneta/weak'
+  autoload :WeakEachKey,       'moneta/weak_each_key'
   autoload :WeakIncrement,     'moneta/weak'
   autoload :Wrapper,           'moneta/wrapper'
 
   module Adapters
     autoload :ActiveRecord,    'moneta/adapters/activerecord'
+    autoload :ActiveSupportCache,'moneta/adapters/activesupportcache'
     autoload :Cassandra,       'moneta/adapters/cassandra'
     autoload :Client,          'moneta/adapters/client'
     autoload :Cookie,          'moneta/adapters/cookie'
@@ -93,7 +96,7 @@ module Moneta
   # @api public
   def self.new(name, options = {})
     expires = options[:expires]
-    options.delete(:expires) unless Integer === expires
+    options.delete(:expires) unless Numeric === expires
     logger = options.delete(:logger)
     threadsafe = options.delete(:threadsafe)
     compress = options.delete(:compress)
@@ -107,10 +110,14 @@ module Moneta
     when :Sequel
       # Sequel accept only base64 keys
       transformer[:key] << :base64
-    when :ActiveRecord, :DataMapper, :Couch
+    when :ActiveRecord, :DataMapper
       # DataMapper and AR accept only base64 keys and values
       transformer[:key] << :base64
       transformer[:value] << :base64
+    when :Couch
+      # CouchDB needs to use URL-safe Base64 for its keys
+      transformer[:key] << :urlsafe_base64
+      transformer[:value] << :base64
     when :PStore, :YAML, :Null
       # For PStore and YAML only the key has to be a string
       transformer.delete(:value) if transformer[:value] == [:marshal]

data/lib/moneta/adapters/activerecord.rb

@@ -1,5 +1,5 @@
 require 'active_record'
-require 'thread'
+require 'uri'
 
 module Moneta
   module Adapters
@@ -8,167 +8,327 @@ module Moneta
     class ActiveRecord
       include Defaults
 
-      supports :create, :increment
-      attr_reader :table
+      supports :create, :increment, :each_key
 
-      @table_mutex = ::Mutex.new
-      @table_refcount = {}
+      attr_reader :table, :key_column, :value_column
+      delegate :with_connection, to: :connection_pool
 
+      @connection_lock = ::Mutex.new
       class << self
-        def release(table)
-          @table_mutex.synchronize do
-            if (@table_refcount[table] -= 1) <= 0
-              remove_const(table.name.sub(/^.*::/, ''))
-              @table_refcount.delete(table)
+        attr_reader :connection_lock
+        delegate :configurations, :configurations=, :connection_handler, to: ::ActiveRecord::Base
+
+        def retrieve_connection_pool(spec_name)
+          connection_handler.retrieve_connection_pool(spec_name.to_s)
+        end
+
+        def establish_connection(spec_name)
+          connection_lock.synchronize do
+            if connection_pool = retrieve_connection_pool(spec_name)
+              connection_pool
+            else
+              connection_handler.establish_connection(spec_name.to_sym)
             end
           end
         end
 
-        def get(options)
-          name = 'Table_' << options.inspect.gsub(/[^\w]+/) do
-            $&.unpack('H2' * $&.bytesize).join.upcase
-          end
-          @table_mutex.synchronize do
-            table =
-              if const_defined?(name)
-                const_get(name)
-              else
-                create(name, options)
-              end
-            @table_refcount[table] ||= 0
-            @table_refcount[table] += 1
-            table
-          end
+        def retrieve_or_establish_connection_pool(spec_name)
+          retrieve_connection_pool(spec_name) || establish_connection(spec_name)
         end
+      end
 
-        private
+      # @param [Hash] options
+      # @option options [Object]               :backend A class object inheriting from ActiveRecord::Base to use as a table
+      # @option options [String]               :table ('moneta') Table name
+      # @option options [Hash/String/Symbol]   :connection ActiveRecord connection configuration (`Hash` or `String`), or symbol giving the name of a Rails connection (e.g. :production)
+      # @option options [Proc, Boolean]        :create_table Proc called with a connection if table
+      #   needs to be created.  Pass false to skip the create table check all together.
+      # @option options [Symbol]               :key_column (:k) The name of the column to use for keys
+      # @option options [Symbol]               :value_column (:v) The name of the column to use for values
+      def initialize(options = {})
+        @key_column = options.delete(:key_column) || :k
+        @value_column = options.delete(:value_column) || :v
 
-        def create(name, options)
-          table = Class.new(::ActiveRecord::Base)
-          const_set(name, table)
-          table.table_name = options[:table] || 'moneta'
-          table.primary_key = :k
+        if backend = options.delete(:backend)
+          @spec = backend.connection_pool.spec
+          @table = ::Arel::Table.new(backend.table_name.to_sym)
+        else
+          # Feed the connection info into ActiveRecord and get back a name to use for getting the
+          # connection pool
+          connection = options.delete(:connection)
+          @spec =
+            case connection
+            when Symbol
+              connection
+            when Hash, String
+              # Normalize the connection specification to a hash
+              resolver = ::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new \
+                'dummy' => connection
 
-          if options[:connection]
-            begin
-              table.establish_connection(options[:connection])
-            rescue
-              tries ||= 0
-              (tries += 1) < 3 ? retry : raise
-            end
-          end
-
-          table.connection_pool.with_connection do |conn|
-            unless table.table_exists?
-              conn.create_table(table.table_name, id: false) do |t|
-                # Do not use binary key (Issue #17)
-                t.string :k, null: false
-                t.binary :v
+              # Turn the config into a standardised hash, sans a couple of bits
+              hash = resolver.resolve(:dummy)
+              hash.delete('name')
+              hash.delete(:password) # For security
+              # Make a name unique to this config
+              name = 'moneta?' + URI.encode_www_form(hash.to_a.sort)
+              # Add into configurations unless its already there (initially done without locking for
+              # speed)
+              unless self.class.configurations.key? name
+                self.class.connection_lock.synchronize do
+                  self.class.configurations[name] = connection \
+                    unless self.class.configurations.key? name
+                end
               end
-              conn.add_index(table.table_name, :k, unique: true)
+
+              name.to_sym
+            else
+              ::ActiveRecord::Base.connection_pool.spec.name.to_s
             end
+
+          table_name = (options.delete(:table) || :moneta).to_sym
+          create_table_proc = options.delete(:create_table)
+          if create_table_proc.nil?
+            create_table(table_name)
+          elsif create_table_proc
+            with_connection(&create_table_proc)
           end
 
-          table
-        rescue
-          remove_const(name)
-          raise
+          @table = ::Arel::Table.new(table_name)
         end
       end
 
-      # @param [Hash] options
-      # @option options [String] :table ('moneta') Table name
-      # @option options [Hash]   :connection ActiveRecord connection configuration
-      def initialize(options = {})
-        @table = self.class.get(options)
-      end
-
       # (see Proxy#key?)
       def key?(key, options = {})
-        @table.connection_pool.with_connection do
-          !@table.where(k: key).empty?
+        with_connection do |conn|
+          sel = arel_sel_key(key).project(::Arel.sql('1'))
+          result = conn.select_all(sel)
+          !result.empty?
+        end
+      end
+
+      # (see Proxy#each_key)
+      def each_key(&block)
+        with_connection do |conn|
+          return enum_for(:each_key) { conn.select_value(arel_sel.project(table[key_column].count)) } unless block_given?
+          conn.select_values(arel_sel.project(table[key_column])).each { |k| yield(k) }
         end
+        self
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        @table.connection_pool.with_connection do
-          record = @table.select(:v).where(k: key).first
-          record && record.v
+        with_connection do |conn|
+          conn_sel_value(conn, key)
         end
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        @table.connection_pool.with_connection do
-          record = @table.select(:k).where(k: key).first_or_initialize
-          record.v = value
-          record.save
-          value
+        with_connection do |conn|
+          encoded = encode(conn, value)
+          conn_ins(conn, key, encoded) unless conn_upd(conn, key, encoded) == 1
         end
-      rescue
-        tries ||= 0
-        (tries += 1) < 10 ? retry : raise
+        value
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        @table.connection_pool.with_connection do
-          if record = @table.where(k: key).first
-            record.destroy
-            record.v
+        with_connection do |conn|
+          conn.transaction do
+            sel = arel_sel_key(key).project(table[value_column]).lock
+            value = decode(conn, conn.select_value(sel))
+
+            del = arel_del.where(table[key_column].eq(key))
+            conn.delete(del)
+
+            value
           end
         end
       end
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        @table.connection_pool.with_connection do
-          @table.transaction do
-            if record = @table.where(k: key).lock.first
-              value = Utils.to_int(record.v) + amount
-              record.v = value.to_s
-              record.save
+        with_connection do |conn|
+          begin
+            conn_ins(conn, key, amount.to_s)
+            amount
+          rescue ::ActiveRecord::RecordNotUnique
+            conn.transaction do
+              sel = arel_sel_key(key).project(table[value_column]).lock
+              value = decode(conn, conn.select_value(sel))
+              value = (value ? Integer(value) : 0) + amount
+              # Re-raise if the upate affects no rows (i.e. row deleted after attempted insert,
+              # before select for update)
+              raise unless conn_upd(conn, key, value.to_s) == 1
               value
-            elsif create(key, amount.to_s, options)
-              amount
-            else
-              raise 'Concurrent modification'
             end
           end
         end
-      rescue
+      rescue ::ActiveRecord::RecordNotUnique
+        # This handles the "no row updated" issue, above
         tries ||= 0
-        (tries += 1) < 10 ? retry : raise
+        if (tries += 1) <= 3; retry else raise end
       end
 
       # (see Proxy#create)
       def create(key, value, options = {})
-        @table.connection_pool.with_connection do
-          record = @table.new
-          record.k = key
-          record.v = value
-          record.save
+        with_connection do |conn|
+          conn_ins(conn, key, value)
           true
         end
-      rescue
-        # FIXME: This catches too many errors
-        # it should only catch a not-unique-exception
+      rescue ::ActiveRecord::RecordNotUnique
         false
       end
 
       # (see Proxy#clear)
       def clear(options = {})
-        @table.connection_pool.with_connection do
-          @table.delete_all
+        with_connection do |conn|
+          conn.delete(arel_del)
         end
         self
       end
 
       # (see Proxy#close)
       def close
-        self.class.release(@table)
         @table = nil
+        @spec = nil
+      end
+
+      # (see Proxy#slice)
+      def slice(*keys, lock: false, **options)
+        with_connection do |conn|
+          sel = arel_slice(keys).project(table[key_column], table[value_column])
+          sel = sel.lock if lock
+          result = conn.select_all(sel)
+
+          k = key_column.to_s
+          v = value_column.to_s
+          result.map do |row|
+            [row[k], decode(conn, row[v])]
+          end
+        end
+      end
+
+      # (see Proxy#values_at)
+      def values_at(*keys, **options)
+        hash = Hash[slice(*keys, **options)]
+        keys.map { |key| hash[key] }
+      end
+
+      # (see Proxy#fetch_values)
+      def fetch_values(*keys, **options)
+        return values_at(*keys, **options) unless block_given?
+        hash = Hash[slice(*keys, **options)]
+        keys.map do |key|
+          if hash.key?(key)
+            hash[key]
+          else
+            yield key
+          end
+        end
+      end
+
+      # (see Proxy#merge!)
+      def merge!(pairs, options = {})
+        with_connection do |conn|
+          conn.transaction do
+            existing = Hash[slice(*pairs.map { |k, _| k }, lock: true, **options)]
+            update_pairs, insert_pairs = pairs.partition { |k, _| existing.key?(k) }
+            insert_pairs.each { |key, value| conn_ins(conn, key, encode(conn, value)) }
+
+            if block_given?
+              update_pairs.map! do |key, new_value|
+                [key, yield(key, existing[key], new_value)]
+              end
+            end
+
+            update_pairs.each { |key, value| conn_upd(conn, key, encode(conn, value)) }
+          end
+        end
+
+        self
+      end
+
+      private
+
+      def connection_pool
+        self.class.retrieve_or_establish_connection_pool(@spec)
+      end
+
+      def create_table table_name
+        with_connection do |conn|
+          return if conn.table_exists?(table_name)
+
+          # Prevent multiple connections from attempting to create the table simultaneously.
+          self.class.connection_lock.synchronize do
+            conn.create_table(table_name, id: false) do |t|
+              # Do not use binary key (Issue #17)
+              t.string key_column, null: false
+              t.binary value_column
+            end
+            conn.add_index(table_name, key_column, unique: true)
+          end
+        end
+      end
+
+      def arel_del
+        ::Arel::DeleteManager.new.from(table)
+      end
+
+      def arel_sel
+        ::Arel::SelectManager.new.from(table)
+      end
+
+      def arel_upd
+        ::Arel::UpdateManager.new.table(table)
+      end
+
+      def arel_sel_key(key)
+        arel_sel.where(table[key_column].eq(key))
+      end
+
+      def arel_slice(keys)
+        arel_sel.where(table[key_column].eq_any(keys))
+      end
+
+      def conn_ins(conn, key, value)
+        ins = ::Arel::InsertManager.new.into(table)
+        ins.insert([[table[key_column], key], [table[value_column], value]])
+        conn.insert ins
+      end
+
+      def conn_upd(conn, key, value)
+        conn.update arel_upd.where(table[key_column].eq(key)).set([[table[value_column], value]])
+      end
+
+      def conn_sel_value(conn, key)
+        decode(conn, conn.select_value(arel_sel_key(key).project(table[value_column])))
+      end
+
+      def encode(conn, value)
+        if value == nil
+          nil
+        elsif conn.respond_to?(:escape_bytea)
+          conn.escape_bytea(value)
+        elsif defined?(::ActiveRecord::ConnectionAdapters::SQLite3Adapter) &&
+              conn.is_a?(::ActiveRecord::ConnectionAdapters::SQLite3Adapter)
+          Arel::Nodes::SqlLiteral.new("X'#{value.unpack('H*').first}'")
+        else
+          value
+        end
+      end
+
+      def decode(conn, value)
+        if value == nil
+          nil
+        elsif defined?(::ActiveModel::Type::Binary::Data) &&
+          value.is_a?(::ActiveModel::Type::Binary::Data)
+          value.to_s
+        elsif conn.respond_to?(:unescape_bytea)
+          conn.unescape_bytea(value)
+        else
+          value
+        end
       end
     end
   end