legion-cache 1.4.1 → 1.4.3

data/lib/legion/cache/redis.rb

@@ -2,6 +2,7 @@
 
 require 'openssl'
 require 'redis'
+require 'uri'
 require 'legion/logging/helper'
 require 'legion/cache/pool'
 require 'legion/cache/settings'
@@ -13,67 +14,69 @@ module Legion
       extend self
       extend Legion::Logging::Helper
 
-      def client(server: nil, servers: [], pool_size: nil, timeout: nil, # rubocop:disable Metrics/ParameterLists
-                 username: nil, password: nil, logger: nil, **opts)
+      def client(**opts)
         return @client unless @client.nil?
 
-        settings = defined?(Legion::Settings) ? Legion::Settings[:cache] : {}
-        pool_size ||= settings[:pool_size] || 10
-        timeout ||= settings[:timeout] || 5
-
-        cluster = opts.delete(:cluster)
-        replica = opts.delete(:replica) || false
-        fixed_hostname = opts.delete(:fixed_hostname)
-        db = opts.delete(:db)
-        reconnect_attempts = opts.delete(:reconnect_attempts) || [0, 0.5, 1]
-
-        @pool_size = pool_size
-        @timeout   = timeout
-        @cluster_mode = Array(cluster).compact.any?
-        @component_logger = logger || log
-
-        @connection_opts = { username: username, password: password, timeout: @timeout }.compact
-        @connection_opts.merge!(redis_tls_options(port: resolve_primary_port(server: server, servers: servers, cluster: cluster)))
-
-        checkout_timeout = opts[:pool_checkout_timeout] || settings[:pool_checkout_timeout] || @timeout
-        @client = ConnectionPool.new(size: pool_size, timeout: checkout_timeout) do
-          build_redis_client(server: server, servers: servers, cluster: cluster,
-                             replica: replica, fixed_hostname: fixed_hostname,
-                             username: username, password: password, db: db,
-                             reconnect_attempts: reconnect_attempts)
+        settings = redis_settings.merge(opts)
+        if opts.key?(:server) || opts.key?(:servers)
+          settings[:server] = opts[:server]
+          settings[:servers] = opts.fetch(:servers, [])
+          settings[:cluster] = nil unless opts.key?(:cluster)
         end
-        @connected = true
-        log.info "Redis connected to #{resolved_redis_address(server: server, servers: servers, cluster: cluster)}"
+        @redis_settings = settings
+        @pool_size = settings[:pool_size] || 10
+        @timeout = settings[:timeout] || 5
+        raise ArgumentError, 'Redis timeout must be positive' unless @timeout.positive?
+
+        @cluster_mode = Array(settings[:cluster]).compact.any?
+        @component_logger = settings[:logger] || log
+        checkout_timeout = settings[:pool_checkout_timeout] || @timeout
+        pending_pool = ConnectionPool.new(size: @pool_size, timeout: checkout_timeout) do
+          build_redis_client(**settings.slice(:server, :servers, :cluster, :replica, :fixed_hostname,
+                                              :username, :password, :db, :reconnect_attempts))
+        end
+        pending_pool.with do |conn|
+          raise ::Redis::ConnectionError, 'Redis health check failed' unless conn.ping == 'PONG'
+        end
+        @client = pending_pool
+        cache_mark_connected(true)
         @client
       rescue StandardError => e
-        handle_exception(e, level: :error, handled: false, operation: :redis_client,
-                            server: server, servers: Array(servers), cluster_nodes: Array(cluster))
-        @connected = false
+        cache_mark_connected(false)
+        @client = nil
+        begin
+          pending_pool&.shutdown(&:close)
+        rescue StandardError => close_error
+          handle_exception(close_error, level: :warn, handled: true, operation: :redis_failed_pool_close)
+        end
+        handle_exception(e, level: :error, handled: false, operation: :redis_client)
         raise
       end
 
       def build_redis_client(server: nil, servers: [], cluster: nil, replica: false, fixed_hostname: nil, # rubocop:disable Metrics/ParameterLists
                              username: nil, password: nil, db: nil, reconnect_attempts: [0, 0.5, 1])
         nodes = Array(cluster).compact
+        options = { username: username, password: password, db: db, timeout: @timeout || 5,
+                    reconnect_attempts: reconnect_attempts }.compact
         if nodes.any?
-          opts = { cluster: nodes, reconnect_attempts: reconnect_attempts, timeout: @timeout }
-          opts[:replica] = true if replica
-          opts[:fixed_hostname] = fixed_hostname unless fixed_hostname.nil?
-          opts[:username] = username unless username.nil?
-          opts[:password] = password unless password.nil?
-          ::Redis.new(**opts)
+          require 'redis-clustering'
+          raise ArgumentError, 'Redis Cluster only supports database 0' unless db.nil? || db.to_i.zero?
+
+          options.merge!(redis_tls_options(port: resolve_primary_port(cluster: nodes)))
+          options[:replica] = replica
+          options[:fixed_hostname] = fixed_hostname unless fixed_hostname.nil?
+          ::Redis::Cluster.new(nodes: nodes, **options)
         else
-          resolved = Legion::Cache::Settings.resolve_servers(
-            driver: 'redis', server: server, servers: servers
-          )
-          host, port = Legion::Cache::Settings.parse_server_address(resolved.first, default_port: 6379)
-          redis_opts = { host: host, port: port.to_i, reconnect_attempts: reconnect_attempts,
-                         timeout: @timeout }
-          redis_opts[:username] = username unless username.nil?
-          redis_opts[:password] = password unless password.nil?
-          redis_opts[:db] = db unless db.nil?
-          redis_opts.merge!(redis_tls_options(port: port.to_i))
-          ::Redis.new(**redis_opts)
+          address = (Array(servers) + Array(server)).first
+          if address.to_s.start_with?('redis://', 'rediss://')
+            options[:url] = address
+            port = URI.parse(address).port || 6379
+          else
+            host, port = Legion::Cache::Settings.parse_server_address(address, default_port: 6379)
+            options.merge!(host: host, port: port)
+          end
+          options.merge!(redis_tls_options(port: port))
+          ::Redis.new(**options)
         end
       end
 
@@ -81,23 +84,47 @@ module Legion
         @cluster_mode == true
       end
 
+      def redis_key(key)
+        namespace = redis_settings[:namespace].to_s
+        namespace.empty? ? key.to_s : "#{namespace}:#{key}"
+      end
+
       def get(key)
-        raw = client.with { |conn| conn.get(key) }
+        raw = client.with { |conn| conn.get(redis_key(key)) }
         result = deserialize_value(raw)
         log.debug { "[cache] GET #{key} hit=#{!result.nil?}" }
         result
       rescue StandardError => e
+        cache_backend_failed(e)
         handle_exception(e, level: :warn, handled: true, operation: :redis_get, key: key)
         nil
       end
 
       def fetch(key, ttl: nil)
+        redis_ttl(ttl)
         result = get(key)
         return result unless result.nil? && block_given?
 
         result = yield
-        set(key, result, ttl: ttl)
+        begin
+          set(key, result, ttl: ttl)
+        rescue StandardError => e
+          handle_exception(e, level: :warn, handled: true, operation: :redis_fetch_store, key: key)
+        end
+        result
+      end
+
+      def set_nx(key, value, ttl: nil)
+        effective_ttl = redis_ttl(ttl)
+        serialized = serialize_value(value)
+        args = effective_ttl ? { ex: effective_ttl } : {}
+        result = client.with { |conn| conn.set(redis_key(key), serialized, nx: true, **args) == 'OK' }
+        log.debug { "[cache] SET_NX #{key} ttl=#{effective_ttl.inspect} result=#{result}" }
         result
+      rescue StandardError => e
+        cache_backend_failed(e)
+        handle_exception(e, level: :error, handled: false, operation: :redis_set_nx, key: key, ttl: effective_ttl)
+        raise
       end
 
       def set(key, value, ttl: nil, **)
@@ -105,42 +132,77 @@ module Legion
       end
 
       def set_sync(key, value, ttl: nil, **)
-        effective_ttl = ttl || default_ttl
+        effective_ttl = redis_ttl(ttl)
         args = {}
         args[:ex] = effective_ttl unless effective_ttl.nil?
         serialized = serialize_value(value)
-        result = client.with { |conn| conn.set(key, serialized, **args) == 'OK' }
+        result = client.with { |conn| conn.set(redis_key(key), serialized, **args) == 'OK' }
         log.debug { "[cache] SET #{key} ttl=#{effective_ttl.inspect} success=#{result}" }
         result
       rescue StandardError => e
+        cache_backend_failed(e)
         handle_exception(e, level: :error, handled: false, operation: :redis_set_sync, key: key, ttl: effective_ttl)
         raise
       end
 
+      def cas(key, ttl: nil)
+        effective_ttl = redis_ttl(ttl)
+        args = effective_ttl ? { ex: effective_ttl } : {}
+        qualified = redis_key(key)
+        user_error = nil
+        client.with do |conn|
+          10.times do
+            value = nil
+            committed = conn.watch(qualified) do |watched|
+              current = deserialize_value(watched.get(qualified))
+              begin
+                value = yield current
+              rescue StandardError => e
+                user_error = e
+                raise
+              end
+              serialized = serialize_value(value)
+              watched.multi { |transaction| transaction.set(qualified, serialized, **args) }
+            end
+            return value unless committed.nil?
+          end
+          raise ::Redis::CommandError, 'Redis CAS conflicted after 10 attempts'
+        end
+      rescue StandardError => e
+        raise if e.equal?(user_error)
+
+        cache_backend_failed(e)
+        handle_exception(e, level: :error, handled: false, operation: :redis_cas, key: key)
+        raise
+      end
+
       def delete(key, **)
         delete_sync(key)
       end
 
       def delete_sync(key)
-        result = client.with { |conn| conn.del(key) == 1 }
+        result = client.with { |conn| conn.del(redis_key(key)) == 1 }
         log.debug { "[cache] DELETE #{key} success=#{result}" }
         result
       rescue StandardError => e
+        cache_backend_failed(e)
         handle_exception(e, level: :error, handled: false, operation: :redis_delete_sync, key: key)
         raise
       end
 
       def flush
         result = client.with do |conn|
-          if cluster_mode?
-            cluster_flush(conn)
-          else
-            conn.flushdb == 'OK'
-          end
+          prefix = redis_key('')
+          raise ArgumentError, 'Redis flush requires a namespace' if prefix.empty?
+
+          pattern = prefix.gsub(/[\\*?\[\]]/) { |character| "\\#{character}" }
+          conn.scan_each(match: "#{pattern}*", count: 100) { |key| conn.del(key) }
+          true
         end
         log.debug { '[cache] FLUSH completed' }
         result
       rescue StandardError => e
+        cache_backend_failed(e)
         handle_exception(e, level: :warn, handled: true, operation: :redis_flush)
         nil
       end
@@ -149,18 +211,19 @@ module Legion
         keys = keys.flatten
         return {} if keys.empty?
 
-        result = client.with do |conn|
+        qualified = keys.map { |key| redis_key(key) }
+        values = client.with do |conn|
           if cluster_mode?
-            cluster_mget(conn, keys)
+            cluster_mget(conn, qualified).values_at(*qualified)
           else
-            values = conn.mget(*keys)
-            keys.zip(values).to_h
+            conn.mget(*qualified)
           end
         end
-        result = result.transform_values { |v| deserialize_value(v) }
+        result = keys.zip(values.map { |value| deserialize_value(value) }).to_h
         log.debug { "[cache] MGET keys=#{keys.size}" }
         result
       rescue StandardError => e
+        cache_backend_failed(e)
         handle_exception(e, level: :warn, handled: true, operation: :redis_mget, key_count: keys.size)
         {}
       end
@@ -209,12 +272,16 @@ module Legion
         raw
       end
 
-      def default_ttl
-        return 3600 unless defined?(Legion::Settings)
+      def redis_settings
+        return @redis_settings if @redis_settings
+        return @cache_settings if @cache_settings
 
-        Legion::Settings.dig(:cache, :default_ttl) || 3600
-      rescue StandardError
-        3600
+        shared = defined?(Legion::Settings) ? Legion::Settings[:cache] : nil
+        Legion::Cache::Settings.default.merge(shared || {})
+      end
+
+      def default_ttl
+        redis_settings[:default_ttl]
       end
 
       def cluster_mget(conn, keys)
@@ -227,61 +294,34 @@ module Legion
         result
       end
 
-      def cluster_mset(conn, hash)
-        groups = group_keys_by_slot(hash.keys)
-        groups.each_value do |group_keys|
-          pairs = group_keys.flat_map { |k| [k, hash[k]] }
-          conn.mset(*pairs)
-        end
-        true
-      end
-
-      def cluster_flush(conn)
-        node_info = conn.cluster('nodes')
-        primaries = node_info.lines.select { |l| l.include?('master') }.map { |l| l.split[1].split('@').first }
-        primaries.each do |addr|
-          host, port = Legion::Cache::Settings.parse_server_address(addr, default_port: 6379)
-          node = ::Redis.new(host: host, port: port.to_i, **(@connection_opts || {}))
-          node.flushdb
-          node.close
-        end
-        true
-      rescue StandardError => e
-        handle_exception(e, level: :warn, handled: true, operation: :cluster_flush, fallback: :single_flushdb)
-        conn.flushdb == 'OK'
-      end
-
       def group_keys_by_slot(keys)
-        if defined?(::Redis::Cluster::KeySlotConverter)
-          keys.group_by { |k| ::Redis::Cluster::KeySlotConverter.convert(k) }
-        else
-          { 0 => keys }
-        end
+        keys.group_by { |key| ::RedisClient::Cluster::KeySlotConverter.convert(key) }
       end
 
-      def resolved_redis_address(server:, servers:, cluster:)
-        nodes = Array(cluster).compact
-        return nodes.join(', ') if nodes.any?
+      def redis_ttl(ttl)
+        value = ttl.nil? ? default_ttl : ttl
+        return nil if value.nil?
 
-        Legion::Cache::Settings.resolve_servers(driver: 'redis', server: server, servers: Array(servers)).first
-      rescue StandardError => e
-        handle_exception(e, level: :warn, handled: true, operation: :resolved_redis_address)
-        'unknown'
+        raise ArgumentError, 'TTL must not be negative' if value.negative?
+
+        value.zero? ? nil : value
       end
 
       def resolve_primary_port(server: nil, servers: [], cluster: nil)
-        nodes = Array(cluster).compact
-        return 6379 if nodes.any?
+        address = Array(cluster).compact.first || (Array(servers) + Array(server)).first
+        return address.fetch(:port, 6379).to_i if address.is_a?(Hash)
+        return URI.parse(address).port || 6379 if address.to_s.start_with?('redis://', 'rediss://')
 
-        resolved = Legion::Cache::Settings.resolve_servers(driver: 'redis', server: server, servers: Array(servers))
-        _, port = Legion::Cache::Settings.parse_server_address(resolved.first, default_port: 6379)
-        port.to_i
-      rescue StandardError
-        6379
+        Legion::Cache::Settings.parse_server_address(address, default_port: 6379).last
       end
 
       def redis_tls_options(port:)
-        return {} unless defined?(Legion::Crypt::TLS)
+        unless defined?(Legion::Crypt::TLS)
+          settings = cache_tls_settings
+          return {} if settings.empty? || settings[:enabled] == false
+
+          raise ArgumentError, 'Legion::Crypt::TLS is required for configured Redis TLS'
+        end
 
         tls = Legion::Crypt::TLS.resolve(cache_tls_settings, port: port)
         return {} unless tls[:enabled]
@@ -290,17 +330,14 @@ module Legion
           verify_mode: tls[:verify] == :none ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
         }
         ssl_params[:ca_file] = tls[:ca] if tls[:ca]
+        ssl_params[:cert] = OpenSSL::X509::Certificate.new(File.read(tls[:cert])) if tls[:cert]
+        ssl_params[:key] = OpenSSL::PKey.read(File.read(tls[:key])) if tls[:key]
 
         { ssl: true, ssl_params: ssl_params }
       end
 
       def cache_tls_settings
-        return {} unless defined?(Legion::Settings)
-
-        Legion::Settings[:cache][:tls] || {}
-      rescue StandardError => e
-        handle_exception(e, level: :warn, handled: true, operation: :cache_tls_settings)
-        {}
+        redis_settings[:tls] || {}
       end
     end
   end

data/lib/legion/cache/redis_hash.rb

@@ -28,7 +28,7 @@ module Legion
 
         Legion::Cache.pool.with do |conn|
           flat = hash.flat_map { |k, v| [k.to_s, v.to_s] }
-          conn.hset(key, *flat)
+          conn.hset(Legion::Cache.redis_key(key), *flat)
         end
         log.debug "[cache:redis_hash] HSET #{key} fields=#{hash.size}"
         true
@@ -42,7 +42,7 @@ module Legion
         return nil unless redis_available?
 
         result = Legion::Cache.pool.with do |conn|
-          conn.hgetall(key)
+          conn.hgetall(Legion::Cache.redis_key(key))
         end
         log.debug "[cache:redis_hash] HGETALL #{key} fields=#{result.size}"
         result
@@ -56,7 +56,7 @@ module Legion
         return 0 unless redis_available?
 
         result = Legion::Cache.pool.with do |conn|
-          conn.hdel(key, *fields)
+          conn.hdel(Legion::Cache.redis_key(key), *fields)
         end
         log.debug "[cache:redis_hash] HDEL #{key} fields=#{fields.size} removed=#{result}"
         result
@@ -70,7 +70,7 @@ module Legion
         return false unless redis_available?
 
         Legion::Cache.pool.with do |conn|
-          conn.zadd(key, score.to_f, member.to_s)
+          conn.zadd(Legion::Cache.redis_key(key), score.to_f, member.to_s)
         end
         log.debug "[cache:redis_hash] ZADD #{key} member=#{member}"
         true
@@ -88,7 +88,7 @@ module Legion
         opts[:limit] = limit if limit
 
         result = Legion::Cache.pool.with do |conn|
-          conn.zrangebyscore(key, min, max, **opts)
+          conn.zrangebyscore(Legion::Cache.redis_key(key), min, max, **opts)
         end
         log.debug "[cache:redis_hash] ZRANGEBYSCORE #{key} results=#{result.size}"
         result
@@ -102,7 +102,7 @@ module Legion
         return false unless redis_available?
 
         Legion::Cache.pool.with do |conn|
-          conn.zrem(key, member.to_s)
+          conn.zrem(Legion::Cache.redis_key(key), member.to_s)
         end
         log.debug "[cache:redis_hash] ZREM #{key} member=#{member}"
         true
@@ -113,19 +113,22 @@ module Legion
 
       # Set a TTL (in seconds) on a key.
       def expire(key, seconds)
+        raise ArgumentError, 'TTL must not be negative' if seconds.negative?
         return false unless redis_available?
 
-        result = Legion::Cache.pool.with do |conn|
-          conn.expire(key, seconds.to_i) == 1
+        begin
+          Legion::Cache.pool.with do |conn|
+            qualified = Legion::Cache.redis_key(key)
+            seconds.zero? ? conn.persist(qualified) : conn.expire(qualified, seconds)
+          end
+        rescue StandardError => e
+          log_redis_error('expire', e)
+          false
         end
-        log.debug "[cache:redis_hash] EXPIRE #{key} seconds=#{seconds} success=#{result}"
-        result
-      rescue StandardError => e
-        log_redis_error('expire', e)
-        false
       end
 
       def log_redis_error(method, error)
+        Legion::Cache.send(:cache_backend_failed, error)
         handle_exception(error, level: :warn, handled: true, operation: method)
       end
     end

data/lib/legion/cache/settings.rb

@@ -81,6 +81,14 @@ module Legion
 
       DEFAULT_PORTS = { 'dalli' => 11_211, 'redis' => 6379 }.freeze
 
+      def self.connection_options(settings, overrides)
+        resolved = settings.merge(overrides)
+        resolved[:servers] = [] if overrides.key?(:server) && !overrides.key?(:servers)
+        resolved[:server] = nil if overrides.key?(:servers) && !overrides.key?(:server)
+        resolved[:cluster] = nil if (overrides.key?(:server) || overrides.key?(:servers)) && !overrides.key?(:cluster)
+        resolved
+      end
+
       def self.resolve_servers(driver:, server: nil, servers: [], port: nil)
         gem_driver = normalize_driver(driver)
         port ||= DEFAULT_PORTS.fetch(gem_driver, 11_211)

data/lib/legion/cache/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Cache
-    VERSION = '1.4.1'
+    VERSION = '1.4.3'
   end
 end