legion-cache 1.4.2 → 1.4.3

data/lib/legion/cache/helper.rb

@@ -310,10 +310,11 @@ module Legion
       end
 
       def memcached_hash_merge(full_key, new_fields)
-        current = memcached_hash_load(full_key) || {}
-        merged = current.merge(new_fields.transform_keys(&:to_s))
-        Legion::Cache.set(full_key, Legion::JSON.dump(merged), ttl: cache_default_ttl, async: false)
-        true
+        result = Legion::Cache.cas(full_key, ttl: cache_default_ttl) do |raw|
+          current = raw.nil? ? {} : Legion::JSON.load(raw).transform_keys(&:to_s)
+          Legion::JSON.dump(current.merge(new_fields.transform_keys(&:to_s)))
+        end
+        !!result
       end
 
       def memcached_hash_load(full_key)
@@ -329,14 +330,15 @@ module Legion
       end
 
       def memcached_hash_delete_fields(full_key, fields)
-        current = memcached_hash_load(full_key)
-        return 0 if current.nil?
-
-        str_fields = fields.map(&:to_s)
-        removed = str_fields.count { |f| current.key?(f) }
-        str_fields.each { |f| current.delete(f) }
-        Legion::Cache.set(full_key, Legion::JSON.dump(current), ttl: cache_default_ttl, async: false)
-        removed
+        removed = 0
+        result = Legion::Cache.cas(full_key, ttl: cache_default_ttl) do |raw|
+          current = raw.nil? ? {} : Legion::JSON.load(raw).transform_keys(&:to_s)
+          str_fields = fields.map(&:to_s).uniq
+          removed = str_fields.count { |field| current.key?(field) }
+          str_fields.each { |field| current.delete(field) }
+          Legion::JSON.dump(current)
+        end
+        result ? removed : 0
       end
 
       def raise_sorted_set_unsupported(method)

data/lib/legion/cache/local.rb

@@ -3,55 +3,58 @@
 require 'concurrent'
 require 'legion/logging/helper'
 require 'legion/cache/settings'
+require 'legion/cache/async_writer'
+require 'legion/cache/pool'
 
 module Legion
   module Cache
     module Local
       @connected = Concurrent::AtomicBoolean.new(false)
+      @async_writer = Legion::Cache::AsyncWriter.new(settings_key: :cache_local)
 
       class << self
         include Legion::Logging::Helper
+        include Legion::Cache::Pool
 
-        def setup(**)
-          return unless enabled?
-          return if connected?
-
-          settings = local_settings
-          return unless settings[:enabled]
+        def setup(**opts)
+          return false unless enabled?
+          return true if connected?
 
+          @connection_options = Legion::Cache::Settings.connection_options(@connection_options || {}, opts)
+          settings = Legion::Cache::Settings.connection_options(local_settings, @connection_options)
           driver_name = settings[:driver] || Legion::Cache::Settings.driver
           @driver_name = Legion::Cache::Settings.normalize_driver(driver_name)
           @driver = build_driver(driver_name)
-          @driver.client(**settings, logger: log, **)
-          @connected.make_true
-          servers = Array(settings[:servers]).join(', ')
-          log.info "Legion::Cache::Local connected (#{driver_name}) to #{servers}"
+          @driver.instance_variable_set(:@cache_settings, settings)
+          @driver.instance_variable_set(:@cache_failure_callback, ->(error) { cache_backend_failed(error) })
+          @driver.client(**settings, logger: log)
+          @async_writer.start
+          cache_mark_connected(true)
+          true
         rescue StandardError => e
+          @driver&.close
+          @driver = nil
+          cache_mark_connected(false)
           handle_exception(e, level: :warn, handled: true, operation: :cache_local_setup, driver: driver_name)
-          @connected.make_false
+          raise unless cache_connection_error?(e)
+
+          false
         end
 
         def shutdown
-          return unless @connected
-
-          log.info 'Shutting down Legion::Cache::Local'
+          @async_writer.stop
           @driver&.close
           @driver = nil
           @driver_name = nil
-          @connected.make_false
+          cache_mark_connected(false)
         end
 
         def enabled?
-          return true unless defined?(Legion::Settings)
-
-          Legion::Settings.dig(:cache_local, :enabled) != false
-        rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true, operation: :cache_local_enabled)
-          true
+          !defined?(Legion::Settings) || Legion::Settings.dig(:cache_local, :enabled) != false
         end
 
         def connected?
-          @connected&.true? || false
+          enabled? && @connected.value
         end
 
         def driver_name
@@ -59,154 +62,160 @@ module Legion
         end
 
         def get(key)
-          result = @driver.get(key)
-          log.debug { "[cache:local] GET #{key} hit=#{!result.nil?}" }
-          result
-        rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true, operation: :cache_local_get, key: key)
-          nil
+          local_operation(:get, key, failure: nil)
         end
 
-        def set(key, value, ttl: nil, **)
-          set_sync(key, value, ttl: ttl, **)
+        def set(key, value, ttl: nil, async: true, phi: false, **) # rubocop:disable Metrics/ParameterLists
+          return false unless enabled? && connected?
+
+          ttl = local_write_ttl(ttl, phi: phi)
+          if async
+            @async_writer.enqueue(key: key) { set_sync(key, value, ttl: ttl) }
+          else
+            set_sync(key, value, ttl: ttl)
+          end
         end
 
-        def set_sync(key, value, ttl: nil, **)
-          effective_ttl = ttl || local_default_ttl
-          result = @driver.set_sync(key, value, ttl: effective_ttl)
-          log.debug { "[cache:local] SET #{key} ttl=#{effective_ttl} success=#{result}" }
-          result
-        rescue StandardError => e
-          handle_exception(e, level: :error, handled: false, operation: :cache_local_set_sync, key: key, ttl: effective_ttl)
-          raise
+        def set_sync(key, value, ttl: nil, phi: false, **)
+          local_operation(:set_sync, key, value, ttl: local_write_ttl(ttl, phi: phi), failure: false)
         end
 
-        def fetch(key, ttl: nil, &)
-          result = @driver.fetch(key, ttl: ttl, &)
-          log.debug { "[cache:local] FETCH #{key} hit=#{!result.nil?}" }
-          result
-        rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true, operation: :cache_local_fetch, key: key, ttl: ttl)
-          nil
+        def set_nx(key, value, ttl: nil, phi: false)
+          local_operation(:set_nx, key, value, ttl: local_write_ttl(ttl, phi: phi), failure: false)
+        end
+
+        def cas(key, ttl: nil, phi: false, &)
+          local_operation(:cas, key, ttl: local_write_ttl(ttl, phi: phi), failure: false, &)
+        end
+
+        def fetch(key, ttl: nil)
+          cached = get(key)
+          return cached unless cached.nil?
+          return nil unless block_given?
+
+          value = yield
+          set_sync(key, value, ttl: ttl)
+          value
         end
 
-        def delete(key, **)
-          delete_sync(key)
+        def delete(key, async: true, **)
+          return false unless enabled? && connected?
+
+          if async
+            @async_writer.enqueue(key: key) { delete_sync(key) }
+          else
+            delete_sync(key)
+          end
         end
 
         def delete_sync(key)
-          result = @driver.delete_sync(key)
-          log.debug { "[cache:local] DELETE #{key} success=#{result}" }
-          result
-        rescue StandardError => e
-          handle_exception(e, level: :error, handled: false, operation: :cache_local_delete_sync, key: key)
-          raise
+          local_operation(:delete_sync, key, failure: false)
         end
 
         def flush
-          result = @driver.flush
-          log.debug { '[cache:local] FLUSH completed' }
-          result
-        rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true, operation: :cache_local_flush)
-          nil
+          local_operation(:flush, failure: false)
         end
 
         def mget(*keys)
-          keys = keys.flatten
-          return {} if keys.empty?
+          return {} unless enabled?
 
-          keys.to_h { |key| [key, get(key)] }
+          keys.flatten.to_h { |key| [key, get(key)] }
         end
 
-        def mset(hash, ttl: nil, **)
-          return true if hash.empty?
+        def mset(hash, ttl: nil, async: true, phi: false, **)
+          return false unless enabled?
 
-          hash.each { |key, value| set(key, value, ttl: ttl) }
-          true
+          accepted = true
+          hash.each do |key, value|
+            result = set(key, value, ttl: ttl, async: async, phi: phi)
+            accepted = false unless result
+          end
+          accepted
+        end
+
+        def mset_sync(hash, ttl: nil, phi: false, **)
+          mset(hash, ttl: ttl, async: false, phi: phi)
         end
 
         def stats
-          {
-            driver:    driver_name,
-            servers:   local_servers,
-            enabled:   enabled?,
-            connected: connected?
-          }.freeze
-        rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true, operation: :cache_local_stats)
-          { error: e.message }.freeze
+          { driver: driver_name, servers: Array(local_settings[:servers]), enabled: enabled?, connected: connected? }.freeze
         end
 
-        def client
-          @driver&.client
+        def client(**)
+          return nil unless enabled?
+
+          setup(**) unless @driver
+          @driver&.client if connected?
         end
 
         def close
-          @driver&.close
-          @driver = nil
-          @driver_name = nil
-          @connected.make_false
-          log.info 'Legion::Cache::Local pool closed'
-          @connected
+          shutdown
         end
 
-        def restart(**opts)
-          settings = local_settings
-          @driver&.restart(**settings.merge(opts, logger: log))
-          @connected.make_true
-          log.info 'Legion::Cache::Local pool restarted'
-          @connected
+        def restart(**)
+          shutdown
+          setup(**)
         end
 
         def size
-          @driver.size
+          connected? ? @driver.size : 0
         end
 
         def available
-          @driver.available
+          connected? ? @driver.available : 0
         end
 
         def pool_size
-          @driver.pool_size
+          connected? ? @driver.pool_size : 0
         end
 
         def timeout
-          @driver.timeout
+          connected? ? @driver.timeout : 0
         end
 
         def reset!
-          @driver = nil
-          @driver_name = nil
-          @connected.make_false
-          log.debug 'Legion::Cache::Local state reset'
-          @connected
+          shutdown
+          @connection_options = nil
         end
 
         private
 
-        def local_servers
-          Array(local_settings[:servers])
-        rescue StandardError
-          []
+        def local_operation(operation, *, failure:, **, &block)
+          return failure unless enabled? && connected? && @driver
+
+          user_error = nil
+          guarded = if block
+                      proc do |value|
+                        block.call(value)
+                      rescue StandardError => e
+                        user_error = e
+                        raise
+                      end
+                    end
+          @driver.public_send(operation, *, **, &guarded)
+        rescue StandardError => e
+          raise if e.equal?(user_error) || !cache_connection_error?(e)
+
+          cache_backend_failed(e)
+          handle_exception(e, level: :warn, handled: true, operation: operation)
+          failure
         end
 
-        def local_default_ttl
-          return 21_600 unless defined?(Legion::Settings)
+        def local_write_ttl(ttl, phi:)
+          effective = ttl || local_settings[:default_ttl] || 21_600
+          return effective unless phi
 
-          Legion::Settings.dig(:cache_local, :default_ttl) || 21_600
-        rescue StandardError
-          21_600
+          Legion::Cache.enforce_phi_ttl(effective, phi: phi)
         end
 
         def build_driver(driver_name)
           case Legion::Cache::Settings.normalize_driver(driver_name)
           when 'redis'
             require 'legion/cache/redis'
-            Legion::Cache::Redis.dup
+            Object.new.extend(Legion::Cache::Redis, Legion::Logging::Helper)
           else
             require 'legion/cache/memcached'
-            Legion::Cache::Memcached.dup
+            Object.new.extend(Legion::Cache::Memcached, Legion::Logging::Helper)
           end
         end
 

data/lib/legion/cache/memcached.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'openssl'
+require 'timeout'
 require 'dalli'
 require 'legion/logging/helper'
 require 'legion/cache/pool'
@@ -16,12 +17,17 @@ module Legion
                  username: nil, password: nil, logger: nil, **opts)
         return @client unless @client.nil?
 
-        settings = defined?(Legion::Settings) ? Legion::Settings[:cache] : {}
-        servers ||= settings[:servers] || []
+        settings = @cache_settings || (defined?(Legion::Settings) ? Legion::Settings[:cache] : {})
+        if server.nil? && servers.nil?
+          server = settings[:server]
+          servers = settings[:servers]
+        end
         @component_logger = logger || log
 
         @pool_size = pool_size || settings[:pool_size] || 10
         @timeout = timeout || settings[:timeout] || 5
+        health_timeout = Float(@timeout)
+        raise ArgumentError, 'memcached timeout must be finite and positive' unless health_timeout.finite? && health_timeout.positive?
 
         resolved = Legion::Cache::Settings.resolve_servers(
           driver: 'memcached', server: server, servers: Array(servers)
@@ -33,22 +39,29 @@ module Legion
         cache_opts[:serializer] ||= Legion::JSON
         cache_opts[:username] = username unless username.nil?
         cache_opts[:password] = password unless password.nil?
+        cache_opts[:socket_timeout] ||= health_timeout
+        @memcached_settings = cache_opts
 
         tls_ctx = memcached_tls_context(port: resolved.first.split(':').last.to_i)
-        cache_opts[:ssl_context] = tls_ctx if tls_ctx
+        cache_opts[:ssl_context] ||= tls_ctx if tls_ctx
 
         checkout_timeout = opts[:pool_checkout_timeout] || settings[:pool_checkout_timeout] || @timeout
-        @client = ConnectionPool.new(size: @pool_size, timeout: checkout_timeout) do
+        pool = ConnectionPool.new(size: @pool_size, timeout: checkout_timeout) do
           Dalli::Client.new(resolved, cache_opts)
         end
 
-        @connected = true
+        Timeout.timeout(health_timeout) { pool.with(&:alive!) }
+        @client = pool
+        cache_mark_connected(true)
         log.info "Memcached connected to #{resolved.join(', ')}"
         @client
       rescue StandardError => e
         handle_exception(e, level: :error, handled: false, operation: :memcached_client,
                             server: server, servers: Array(servers))
-        @connected = false
+        cache_mark_connected(false)
+        cache_backend_failed(e)
+        memcached_discard_pool(pool)
+        @client = nil
         raise
       end
 
@@ -57,31 +70,50 @@ module Legion
         log.debug { "[cache] GET #{key} hit=#{!result.nil?}" }
         result
       rescue StandardError => e
+        cache_backend_failed(e)
         handle_exception(e, level: :warn, handled: true, operation: :memcached_get, key: key)
         nil
       end
 
-      def fetch(key, ttl: nil, &)
-        result = client.with do |conn|
-          if block_given?
-            conn.fetch(key, ttl, &)
-          else
-            conn.fetch(key, ttl)
-          end
+      def fetch(key, ttl: nil)
+        result = get(key)
+        return result unless result.nil? && block_given?
+
+        result = yield
+        begin
+          set_nx(key, result, ttl: ttl)
+        rescue StandardError => e
+          handle_exception(e, level: :warn, handled: true, operation: :memcached_fetch, key: key, ttl: ttl)
         end
-        log.debug { "[cache] FETCH #{key} hit=#{!result.nil?}" }
         result
-      rescue StandardError => e
-        handle_exception(e, level: :warn, handled: true, operation: :memcached_fetch, key: key, ttl: ttl)
-        nil
+      end
+
+      def cas(key, ttl: nil)
+        raise ArgumentError, 'a block is required' unless block_given?
+
+        effective_ttl = ttl || default_ttl
+        20.times do
+          value, token = memcached_cas_request(key) { |conn| conn.get_cas(key) }
+          updated = yield value
+          committed = memcached_cas_request(key) do |conn|
+            if token.nil?
+              conn.add(key, updated, effective_ttl)
+            else
+              conn.set_cas(key, updated, token, effective_ttl)
+            end
+          end
+          return updated if committed
+        end
+        raise 'Memcached CAS contention exceeded the retry limit'
       end
 
       def set_nx(key, value, ttl: nil)
         effective_ttl = ttl || default_ttl
-        result = client.with { |conn| conn.add(key, value, effective_ttl) == true }
+        result = client.with { |conn| conn.add(key, value, effective_ttl) }
         log.debug { "[cache] SET_NX #{key} ttl=#{effective_ttl.inspect} result=#{result}" }
-        result
+        !!result
       rescue StandardError => e
+        cache_backend_failed(e)
         handle_exception(e, level: :error, handled: false, operation: :memcached_set_nx, key: key, ttl: effective_ttl)
         raise
       end
@@ -92,10 +124,11 @@ module Legion
 
       def set_sync(key, value, ttl: nil, **)
         effective_ttl = ttl || default_ttl
-        result = client.with { |conn| conn.set(key, value, effective_ttl).positive? }
+        result = client.with { |conn| conn.set(key, value, effective_ttl) }
         log.debug { "[cache] SET #{key} ttl=#{effective_ttl} success=#{result} value_class=#{value.class}" }
-        result
+        !!result
       rescue StandardError => e
+        cache_backend_failed(e)
         handle_exception(e, level: :error, handled: false, operation: :memcached_set_sync, key: key, ttl: effective_ttl)
         raise
       end
@@ -109,6 +142,7 @@ module Legion
         log.debug { "[cache] DELETE #{key} success=#{result}" }
         result
       rescue StandardError => e
+        cache_backend_failed(e)
         handle_exception(e, level: :error, handled: false, operation: :memcached_delete_sync, key: key)
         raise
       end
@@ -118,6 +152,7 @@ module Legion
         log.debug { '[cache] FLUSH completed' }
         result
       rescue StandardError => e
+        cache_backend_failed(e)
         handle_exception(e, level: :warn, handled: true, operation: :memcached_flush)
         nil
       end
@@ -130,6 +165,7 @@ module Legion
         log.debug { "[cache] MGET keys=#{keys.size} hits=#{result.size}" }
         result
       rescue StandardError => e
+        cache_backend_failed(e)
         handle_exception(e, level: :warn, handled: true, operation: :memcached_mget, key_count: keys.size)
         {}
       end
@@ -138,24 +174,49 @@ module Legion
         mset_sync(hash, ttl: ttl)
       end
 
-      def mset_sync(hash, ttl: nil, **) # rubocop:disable Lint/UnusedMethodArgument
+      def mset_sync(hash, ttl: nil, **)
         return true if hash.empty?
 
-        client.with { |conn| conn.set_multi(hash) }
-        log.debug { "[cache] MSET keys=#{hash.size}" }
-        true
+        effective_ttl = ttl || default_ttl
+        # Dalli 3 has no set_multi; newer quiet batches do not acknowledge each write.
+        result = client.with do |conn|
+          success = true
+          hash.each { |key, value| success = false unless conn.set(key, value, effective_ttl) }
+          success
+        end
+        log.debug { "[cache] MSET keys=#{hash.size} success=#{result}" }
+        result
       rescue StandardError => e
+        cache_backend_failed(e)
         handle_exception(e, level: :error, handled: false, operation: :memcached_mset_sync, key_count: hash.size)
         raise
       end
 
       private
 
+      def memcached_discard_pool(pool)
+        pool&.shutdown(&:close)
+      rescue StandardError => e
+        handle_exception(e, level: :warn, handled: true, operation: :memcached_close_failed_pool)
+      end
+
+      def memcached_cas_request(key, &)
+        client.with(&)
+      rescue StandardError => e
+        cache_backend_failed(e)
+        handle_exception(e, level: :error, handled: false, operation: :memcached_cas, key: key)
+        raise
+      end
+
       def default_ttl
+        return @memcached_settings[:default_ttl] || 3600 if @memcached_settings
+        return @cache_settings[:default_ttl] || 3600 if @cache_settings
+
         return 3600 unless defined?(Legion::Settings)
 
         Legion::Settings.dig(:cache, :default_ttl) || 3600
-      rescue StandardError
+      rescue StandardError => e
+        handle_exception(e, level: :warn, handled: true, operation: :memcached_default_ttl)
         3600
       end
 
@@ -172,6 +233,9 @@ module Legion
       end
 
       def memcached_tls_settings
+        return @memcached_settings[:tls] || {} if @memcached_settings
+        return @cache_settings[:tls] || {} if @cache_settings
+
         return {} unless defined?(Legion::Settings)
 
         Legion::Settings[:cache][:tls] || {}