legion-cache 1.3.22 → 1.4.2

data/lib/legion/cache/memcached.rb

@@ -12,34 +12,38 @@ module Legion
       extend self
       extend Legion::Logging::Helper
 
-      def client(server: nil, servers: nil, logger: nil, **opts)
+      def client(server: nil, servers: nil, pool_size: nil, timeout: nil, # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/ParameterLists
+                 username: nil, password: nil, logger: nil, **opts)
         return @client unless @client.nil?
 
         settings = defined?(Legion::Settings) ? Legion::Settings[:cache] : {}
         servers ||= settings[:servers] || []
         @component_logger = logger || log
 
-        @pool_size = opts.key?(:pool_size) ? opts[:pool_size] : settings[:pool_size] || 10
-        @timeout = opts.key?(:timeout) ? opts[:timeout] : settings[:timeout] || 5
+        @pool_size = pool_size || settings[:pool_size] || 10
+        @timeout = timeout || settings[:timeout] || 5
 
         resolved = Legion::Cache::Settings.resolve_servers(
           driver: 'memcached', server: server, servers: Array(servers)
         )
 
-        Dalli.logger = shared_dalli_logger
+        Dalli.logger = log
         cache_opts = settings.merge(opts)
         cache_opts[:value_max_bytes] ||= 8 * 1024 * 1024
         cache_opts[:serializer] ||= Legion::JSON
+        cache_opts[:username] = username unless username.nil?
+        cache_opts[:password] = password unless password.nil?
 
         tls_ctx = memcached_tls_context(port: resolved.first.split(':').last.to_i)
         cache_opts[:ssl_context] = tls_ctx if tls_ctx
 
-        @client = ConnectionPool.new(size: pool_size, timeout: timeout) do
+        checkout_timeout = opts[:pool_checkout_timeout] || settings[:pool_checkout_timeout] || @timeout
+        @client = ConnectionPool.new(size: @pool_size, timeout: checkout_timeout) do
           Dalli::Client.new(resolved, cache_opts)
         end
 
         @connected = true
-        cache_logger.info "Memcached connected to #{resolved.join(', ')}"
+        log.info "Memcached connected to #{resolved.join(', ')}"
         @client
       rescue StandardError => e
         handle_exception(e, level: :error, handled: false, operation: :memcached_client,
@@ -50,14 +54,14 @@ module Legion
 
       def get(key)
         result = client.with { |conn| conn.get(key) }
-        cache_logger.debug "[cache] GET #{key} hit=#{!result.nil?}"
+        log.debug { "[cache] GET #{key} hit=#{!result.nil?}" }
         result
       rescue StandardError => e
-        handle_exception(e, level: :warn, handled: false, operation: :memcached_get, key: key)
-        raise
+        handle_exception(e, level: :warn, handled: true, operation: :memcached_get, key: key)
+        nil
       end
 
-      def fetch(key, ttl = nil, &)
+      def fetch(key, ttl: nil, &)
         result = client.with do |conn|
           if block_given?
             conn.fetch(key, ttl, &)
@@ -65,38 +69,57 @@ module Legion
             conn.fetch(key, ttl)
           end
         end
-        cache_logger.debug "[cache] FETCH #{key} hit=#{!result.nil?}"
+        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 set_nx(key, value, ttl: nil)
+        effective_ttl = ttl || default_ttl
+        result = client.with { |conn| conn.add(key, value, effective_ttl) == true }
+        log.debug { "[cache] SET_NX #{key} ttl=#{effective_ttl.inspect} result=#{result}" }
         result
       rescue StandardError => e
-        handle_exception(e, level: :warn, handled: false, operation: :memcached_fetch, key: key, ttl: ttl)
+        handle_exception(e, level: :error, handled: false, operation: :memcached_set_nx, key: key, ttl: effective_ttl)
         raise
       end
 
-      def set(key, value, ttl = 180)
-        result = client.with { |conn| conn.set(key, value, ttl).positive? }
-        cache_logger.debug "[cache] SET #{key} ttl=#{ttl} success=#{result} value_class=#{value.class}"
+      def set(key, value, ttl: nil, **)
+        set_sync(key, value, ttl: ttl, **)
+      end
+
+      def set_sync(key, value, ttl: nil, **)
+        effective_ttl = ttl || default_ttl
+        result = client.with { |conn| conn.set(key, value, effective_ttl).positive? }
+        log.debug { "[cache] SET #{key} ttl=#{effective_ttl} success=#{result} value_class=#{value.class}" }
         result
       rescue StandardError => e
-        handle_exception(e, level: :warn, handled: false, operation: :memcached_set, key: key, ttl: ttl)
+        handle_exception(e, level: :error, handled: false, operation: :memcached_set_sync, key: key, ttl: effective_ttl)
         raise
       end
 
-      def delete(key)
+      def delete(key, **)
+        delete_sync(key)
+      end
+
+      def delete_sync(key)
         result = client.with { |conn| conn.delete(key) == true }
-        cache_logger.debug "[cache] DELETE #{key} success=#{result}"
+        log.debug { "[cache] DELETE #{key} success=#{result}" }
         result
       rescue StandardError => e
-        handle_exception(e, level: :warn, handled: false, operation: :memcached_delete, key: key)
+        handle_exception(e, level: :error, handled: false, operation: :memcached_delete_sync, key: key)
         raise
       end
 
-      def flush(delay = 0)
-        result = client.with { |conn| conn.flush(delay).first }
-        cache_logger.debug '[cache] FLUSH completed'
+      def flush
+        result = client.with { |conn| conn.flush.first }
+        log.debug { '[cache] FLUSH completed' }
         result
       rescue StandardError => e
-        handle_exception(e, level: :warn, handled: false, operation: :memcached_flush, delay: delay)
-        raise
+        handle_exception(e, level: :warn, handled: true, operation: :memcached_flush)
+        nil
       end
 
       def mget(*keys)
@@ -104,36 +127,36 @@ module Legion
         return {} if keys.empty?
 
         result = client.with { |conn| conn.get_multi(*keys) }
-        cache_logger.debug "[cache] MGET keys=#{keys.size} hits=#{result.size}"
+        log.debug { "[cache] MGET keys=#{keys.size} hits=#{result.size}" }
         result
       rescue StandardError => e
-        handle_exception(e, level: :warn, handled: false, operation: :memcached_mget, key_count: keys.size)
-        raise
+        handle_exception(e, level: :warn, handled: true, operation: :memcached_mget, key_count: keys.size)
+        {}
       end
 
-      def mset(hash)
+      def mset(hash, ttl: nil, **)
+        mset_sync(hash, ttl: ttl)
+      end
+
+      def mset_sync(hash, ttl: nil, **) # rubocop:disable Lint/UnusedMethodArgument
         return true if hash.empty?
 
         client.with { |conn| conn.set_multi(hash) }
-        cache_logger.debug "[cache] MSET keys=#{hash.size}"
+        log.debug { "[cache] MSET keys=#{hash.size}" }
         true
       rescue StandardError => e
-        handle_exception(e, level: :warn, handled: false, operation: :memcached_mset, key_count: hash.size)
+        handle_exception(e, level: :error, handled: false, operation: :memcached_mset_sync, key_count: hash.size)
         raise
       end
 
       private
 
-      def cache_logger
-        @component_logger || log
-      end
+      def default_ttl
+        return 3600 unless defined?(Legion::Settings)
 
-      def shared_dalli_logger
-        if defined?(Legion::Cache) && Legion::Cache.respond_to?(:log)
-          Legion::Cache.log
-        else
-          cache_logger
-        end
+        Legion::Settings.dig(:cache, :default_ttl) || 3600
+      rescue StandardError
+        3600
       end
 
       def memcached_tls_context(port:)

data/lib/legion/cache/memory.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'concurrent'
 require 'legion/logging/helper'
 
 module Legion
@@ -11,18 +12,31 @@ module Legion
       @store = {}
       @expiry = {}
       @mutex = Mutex.new
-      @connected = false
+      @connected = Concurrent::AtomicBoolean.new(false)
 
       def setup(**)
-        @connected = true
+        @connected.make_true
         log.info 'Legion::Cache::Memory connected'
-        @connected
+        true
+      rescue StandardError => e
+        @connected.make_false
+        handle_exception(e, level: :warn, handled: true, operation: :memory_setup)
+        false
       end
 
       def client(**) = self
 
       def connected?
-        @connected
+        @connected.true?
+      end
+
+      def restart(**)
+        shutdown
+        setup
+      rescue StandardError => e
+        @connected.make_false
+        handle_exception(e, level: :warn, handled: true, operation: :memory_restart)
+        false
       end
 
       def get(key)
@@ -32,9 +46,36 @@ module Legion
           log.debug { "[cache:memory] GET #{key} hit=#{!result.nil?}" }
           result
         end
+      rescue StandardError => e
+        handle_exception(e, level: :warn, handled: true, operation: :memory_get)
+        nil
       end
 
-      def set(key, value, ttl = nil)
+      def set(key, value, ttl: nil, async: true, phi: false) # rubocop:disable Lint/UnusedMethodArgument
+        set_sync(key, value, ttl: ttl, phi: phi)
+      end
+
+      def set_nx(key, value, ttl: nil)
+        @mutex.synchronize do
+          expire_if_needed(key)
+          return false if @store.key?(key)
+
+          @store[key] = value
+          if ttl&.positive?
+            @expiry[key] = Time.now + ttl
+          else
+            @expiry.delete(key)
+          end
+          log.debug { "[cache:memory] SET_NX #{key} ttl=#{ttl.inspect} result=true" }
+          true
+        end
+      rescue StandardError => e
+        handle_exception(e, level: :warn, handled: true, operation: :memory_set_nx)
+        false
+      end
+
+      def set_sync(key, value, ttl: nil, phi: false)
+        ttl = enforce_phi_ttl(ttl, phi: phi) if phi
         @mutex.synchronize do
           @store[key] = value
           if ttl&.positive?
@@ -43,55 +84,109 @@ module Legion
             @expiry.delete(key)
           end
           log.debug { "[cache:memory] SET #{key} ttl=#{ttl.inspect}" }
-          value
+          true
         end
       end
 
-      def fetch(key, ttl = nil)
+      def fetch(key, ttl: nil, &block)
         val = get(key)
         return val unless val.nil?
 
         log.debug { "[cache:memory] FETCH #{key} miss=true" }
-        val = yield if block_given?
-        set(key, val, ttl)
+        val = block&.call
+        set(key, val, ttl: ttl)
         val
+      rescue StandardError => e
+        handle_exception(e, level: :warn, handled: true, operation: :memory_fetch)
+        nil
+      end
+
+      def delete(key, async: true) # rubocop:disable Lint/UnusedMethodArgument
+        delete_sync(key)
       end
 
-      def delete(key)
+      def delete_sync(key)
         @mutex.synchronize do
           removed = @store.delete(key)
           @expiry.delete(key)
           log.debug { "[cache:memory] DELETE #{key} success=#{!removed.nil?}" }
-          removed
+          !removed.nil?
         end
       end
 
-      def flush(_delay = 0)
-        result = @mutex.synchronize do
+      def mget(*keys)
+        keys = keys.flatten
+        return {} if keys.empty?
+
+        @mutex.synchronize do
+          keys.each { |k| expire_if_needed(k) }
+          keys.to_h { |k| [k, @store[k]] }
+        end
+      rescue StandardError => e
+        handle_exception(e, level: :warn, handled: true, operation: :memory_mget)
+        {}
+      end
+
+      def mset(hash, ttl: nil, async: true)
+        return true if hash.empty?
+
+        hash.each { |k, v| set(k, v, ttl: ttl, async: async) }
+        true
+      rescue StandardError => e
+        handle_exception(e, level: :warn, handled: true, operation: :memory_mset)
+        true
+      end
+
+      def mset_sync(hash, ttl: nil, phi: false)
+        return true if hash.empty?
+
+        @mutex.synchronize do
+          hash.each do |key, value|
+            effective_ttl = phi ? enforce_phi_ttl(ttl, phi: true) : ttl
+            @store[key] = value
+            if effective_ttl&.positive?
+              @expiry[key] = Time.now + effective_ttl
+            else
+              @expiry.delete(key)
+            end
+          end
+          true
+        end
+      end
+
+      def flush
+        @mutex.synchronize do
           @store.clear
           @expiry.clear
         end
         log.info 'Legion::Cache::Memory flushed'
-        result
+        true
+      rescue StandardError => e
+        handle_exception(e, level: :warn, handled: true, operation: :memory_flush)
+        false
       end
 
       def close = nil
 
       def shutdown
         flush
-        @connected = false
+        @connected.make_false
         log.info 'Legion::Cache::Memory shut down'
-        @connected
+        false
+      rescue StandardError => e
+        @connected.make_false
+        handle_exception(e, level: :warn, handled: true, operation: :memory_shutdown)
+        false
       end
 
       def reset!
-        result = @mutex.synchronize do
+        @mutex.synchronize do
+          @connected.make_false
           @store.clear
           @expiry.clear
-          @connected = false
         end
         log.info 'Legion::Cache::Memory state reset'
-        result
+        false
       end
 
       def size = 1
@@ -106,6 +201,18 @@ module Legion
         @expiry.delete(key)
         log.debug { "[cache:memory] EXPIRE #{key}" }
       end
+
+      def enforce_phi_ttl(ttl, phi: false)
+        return ttl unless phi
+
+        max = if defined?(Legion::Settings)
+                Legion::Settings.dig(:cache, :compliance, :phi_max_ttl) || 3600
+              else
+                3600
+              end
+        result = ttl.nil? ? max : [ttl, max].min
+        [result, 1].max
+      end
     end
   end
 end

data/lib/legion/cache/pool.rb

@@ -10,7 +10,10 @@ module Legion
       extend Legion::Logging::Helper
 
       def connected?
-        @connected ||= false
+        return false unless defined?(@connected)
+        return @connected.true? if @connected.respond_to?(:true?)
+
+        @connected == true
       end
 
       def size

data/lib/legion/cache/reconnector.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+require 'legion/logging/helper'
+
+module Legion
+  module Cache
+    class Reconnector
+      include Legion::Logging::Helper
+
+      DEFAULT_INITIAL_DELAY = 1
+      DEFAULT_MAX_DELAY = 60
+
+      def initialize(tier:, connect_block:, enabled_block:, settings_key: :cache)
+        @tier = tier
+        @connect_block = connect_block
+        @enabled_block = enabled_block
+        @settings_key = settings_key
+        @attempts = Concurrent::AtomicFixnum.new(0)
+        @thread = nil
+        @mutex = Mutex.new
+        @stop_signal = Concurrent::AtomicBoolean.new(false)
+        @next_retry_at = nil
+      end
+
+      def start
+        @mutex.synchronize do
+          return if running?
+
+          @stop_signal.make_false
+          @thread = Thread.new { reconnect_loop }
+          log.info "Legion::Cache::Reconnector[#{@tier}] started"
+        end
+      end
+
+      def stop
+        thread_to_join = nil
+        @mutex.synchronize do
+          @stop_signal.make_true
+          thread_to_join = @thread
+          @thread = nil
+        end
+        thread_to_join&.join(5)
+        log.info "Legion::Cache::Reconnector[#{@tier}] stopped"
+      end
+
+      def running?
+        @thread&.alive? == true
+      end
+
+      def attempts
+        @attempts.value
+      end
+
+      attr_reader :next_retry_at
+
+      private
+
+      def reconnect_loop
+        delay = configured_initial_delay
+
+        until @stop_signal.true?
+          unless @enabled_block.call
+            sleep 1
+            next
+          end
+
+          begin
+            @next_retry_at = Time.now + delay
+            sleep delay
+            return if @stop_signal.true?
+
+            @connect_block.call
+            count = @attempts.value
+            @attempts = Concurrent::AtomicFixnum.new(0)
+            @next_retry_at = nil
+            log.info "Legion::Cache::Reconnector[#{@tier}] reconnected after #{count} attempts"
+            return
+          rescue StandardError => e
+            @attempts.increment
+            handle_exception(e, level: :warn, handled: true,
+                             operation: :"reconnector_#{@tier}",
+                             attempt: @attempts.value, next_delay: delay)
+            delay = [delay * 2, configured_max_delay].min
+          end
+        end
+      rescue StandardError => e
+        handle_exception(e, level: :error, handled: true, operation: :"reconnector_#{@tier}_loop")
+      end
+
+      def configured_initial_delay
+        return DEFAULT_INITIAL_DELAY unless defined?(Legion::Settings)
+
+        Legion::Settings.dig(@settings_key, :reconnect, :initial_delay) || DEFAULT_INITIAL_DELAY
+      rescue StandardError
+        DEFAULT_INITIAL_DELAY
+      end
+
+      def configured_max_delay
+        return DEFAULT_MAX_DELAY unless defined?(Legion::Settings)
+
+        Legion::Settings.dig(@settings_key, :reconnect, :max_delay) || DEFAULT_MAX_DELAY
+      rescue StandardError
+        DEFAULT_MAX_DELAY
+      end
+    end
+  end
+end