legion-cache 1.3.4 → 1.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c04121f4d10bcc0076e189557b0036d02237fb97fd8bfa9c67779df4298d2e41
-  data.tar.gz: faaf6c6c82212257a9e99866948f57269147e0b942301893d100e580cd47e743
+  metadata.gz: 83c05e01834ac3a2715494122657a540ab6fb0fc23c4b4645f5b3ecf0198279c
+  data.tar.gz: e6f944dfa7efa6952810b50766297ce75d39cf6d07bd04af732c8f200e8db051
 SHA512:
-  metadata.gz: ee4dfdf2ac8827b26ebfe5048450b951573fdc8e548b7016f33ed1f3caf2aa6ca56310aa5107942d7b5a388644b3a881c0e8ecee5a9440ef51a79308ab9b79f7
-  data.tar.gz: 185e0503c8bfbfcd839031ffe1d8300e4f3e4d475e627841d1ca9ae5cd9965566fcf5006da522fd29d65bf7e079fd372562aefae528e7db0f892e4f1738aa48c
+  metadata.gz: 79f8620e6101271ab6eb1ec63aecba4a79f2416a2c1b970a1fa02333104a06e6818bc1c7af353a3c5b630d2769834bc9bc8c6a17a4707903cfa4519ffb3884d0
+  data.tar.gz: 41c24ca832173bce18bd4b58772426f2cb2c798443315aff4fccbd5fc460f9682c60ef15f3e5e83264f89a3bd2d52203eac2f74cd3264e06e1416338077fa5d2

data/.rubocop.yml

@@ -48,3 +48,6 @@ Style/FrozenStringLiteralComment:
 
 Naming/FileName:
   Enabled: false
+
+Naming/PredicateMethod:
+  Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [1.3.6] - 2026-03-21
+
+### Added
+- Redis Cluster mode: `cluster:`, `replica:`, `fixed_hostname:` options in `build_redis_client`
+- `cluster_mode?` predicate for runtime cluster detection
+- `mget(*keys)` and `mset(hash)` with automatic slot-aware grouping for cross-slot operations
+- Cluster-aware `flush` that iterates all primary nodes via `CLUSTER NODES`
+- Failover logging: `Redis::BaseError` rescues log via `Legion::Logging.warn` before re-raising
+- Settings defaults: `cluster: nil`, `replica: false`, `fixed_hostname: nil`
+
+### Fixed
+- `get`, `set`, `delete`, `flush` visibility changed from private to public (were inaccessible on the module directly)
+
+## [1.3.5] - 2026-03-21
+
+### Added
+- TLS support for Redis driver: `ssl: true` + `ssl_params` when TLS enabled via `Legion::Crypt::TLS.resolve`
+- TLS support for Memcached driver: `ssl_context` option when TLS enabled via `Legion::Crypt::TLS.resolve`
+- Port-based auto-detection: Redis TLS port 6380, Memcached TLS port 11207
+
 ## [1.3.3] - 2026-03-20
 
 ### Fixed

data/lib/legion/cache/memcached.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'openssl'
 require 'dalli'
 require 'legion/cache/pool'
 
@@ -7,7 +8,7 @@ module Legion
   module Cache
     module Memcached
       include Legion::Cache::Pool
-      extend self # rubocop:disable Style/ModuleFunction
+      extend self
 
       def client(server: nil, servers: nil, **opts)
         return @client unless @client.nil?
@@ -27,6 +28,9 @@ module Legion
         cache_opts[:value_max_bytes] ||= 8 * 1024 * 1024
         cache_opts[:serializer] ||= Legion::JSON
 
+        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
           Dalli::Client.new(resolved, cache_opts)
         end
@@ -62,6 +66,28 @@ module Legion
       def flush(delay = 0)
         client.with { |conn| conn.flush(delay).first }
       end
+
+      private
+
+      def memcached_tls_context(port:)
+        return nil unless defined?(Legion::Crypt::TLS)
+
+        tls = Legion::Crypt::TLS.resolve(memcached_tls_settings, port: port)
+        return nil unless tls[:enabled]
+
+        ctx = OpenSSL::SSL::SSLContext.new
+        ctx.verify_mode = tls[:verify] == :none ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+        ctx.ca_file     = tls[:ca] if tls[:ca]
+        ctx
+      end
+
+      def memcached_tls_settings
+        return {} unless defined?(Legion::Settings)
+
+        Legion::Settings[:cache][:tls] || {}
+      rescue StandardError
+        {}
+      end
     end
   end
 end

data/lib/legion/cache/redis.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'openssl'
 require 'redis'
 require 'legion/cache/pool'
 require 'legion/cache/settings'
@@ -8,36 +9,50 @@ module Legion
   module Cache
     module Redis
       include Legion::Cache::Pool
-      extend self # rubocop:disable Style/ModuleFunction
+      extend self
 
-      def client(pool_size: 20, timeout: 5, server: nil, servers: [], cluster: nil, **) # rubocop:disable Metrics/ParameterLists
+      def client(pool_size: 20, timeout: 5, server: nil, servers: [], cluster: nil, replica: false, fixed_hostname: nil, **) # rubocop:disable Metrics/ParameterLists
         return @client unless @client.nil?
 
         @pool_size = pool_size
         @timeout   = timeout
+        @cluster_mode = Array(cluster).compact.any?
 
         @client = ConnectionPool.new(size: pool_size, timeout: timeout) do
-          build_redis_client(server: server, servers: servers, cluster: cluster)
+          build_redis_client(server: server, servers: servers, cluster: cluster,
+                             replica: replica, fixed_hostname: fixed_hostname)
         end
         @connected = true
         @client
       end
 
-      def build_redis_client(server: nil, servers: [], cluster: nil)
+      def build_redis_client(server: nil, servers: [], cluster: nil, replica: false, fixed_hostname: nil)
         nodes = Array(cluster).compact
         if nodes.any?
-          ::Redis.new(cluster: nodes)
+          opts = { cluster: nodes }
+          opts[:replica] = true if replica
+          opts[:fixed_hostname] = fixed_hostname unless fixed_hostname.nil?
+          ::Redis.new(**opts)
         else
           resolved = Legion::Cache::Settings.resolve_servers(
             driver: 'redis', server: server, servers: servers
           )
           host, port = resolved.first.split(':')
-          ::Redis.new(host: host, port: port.to_i)
+          redis_opts = { host: host, port: port.to_i }
+          redis_opts.merge!(redis_tls_options(port: port.to_i))
+          ::Redis.new(**redis_opts)
         end
       end
 
+      def cluster_mode?
+        @cluster_mode == true
+      end
+
       def get(key)
         client.with { |conn| conn.get(key) }
+      rescue ::Redis::BaseError => e
+        log_cluster_error(e)
+        raise
       end
       alias fetch get
 
@@ -45,14 +60,132 @@ module Legion
         args = {}
         args[:ex] = ttl unless ttl.nil?
         client.with { |conn| conn.set(key, value, **args) == 'OK' }
+      rescue ::Redis::BaseError => e
+        log_cluster_error(e)
+        raise
       end
 
       def delete(key)
         client.with { |conn| conn.del(key) == 1 }
+      rescue ::Redis::BaseError => e
+        log_cluster_error(e)
+        raise
       end
 
       def flush
-        client.with { |conn| conn.flushdb == 'OK' }
+        client.with do |conn|
+          if cluster_mode?
+            cluster_flush(conn)
+          else
+            conn.flushdb == 'OK'
+          end
+        end
+      rescue ::Redis::BaseError => e
+        log_cluster_error(e)
+        raise
+      end
+
+      def mget(*keys)
+        keys = keys.flatten
+        return {} if keys.empty?
+
+        client.with do |conn|
+          if cluster_mode?
+            cluster_mget(conn, keys)
+          else
+            result = conn.mget(*keys)
+            keys.zip(result).to_h
+          end
+        end
+      rescue ::Redis::BaseError => e
+        log_cluster_error(e)
+        raise
+      end
+
+      def mset(hash)
+        return true if hash.empty?
+
+        client.with do |conn|
+          if cluster_mode?
+            cluster_mset(conn, hash)
+          else
+            conn.mset(*hash.flatten) == 'OK'
+          end
+        end
+      rescue ::Redis::BaseError => e
+        log_cluster_error(e)
+        raise
+      end
+
+      private
+
+      def cluster_mget(conn, keys)
+        groups = group_keys_by_slot(keys)
+        result = {}
+        groups.each_value do |group_keys|
+          values = conn.mget(*group_keys)
+          group_keys.zip(values).each { |k, v| result[k] = v }
+        end
+        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 = addr.split(':')
+          node = ::Redis.new(host: host, port: port.to_i)
+          node.flushdb
+          node.close
+        end
+        true
+      rescue StandardError
+        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
+      end
+
+      def log_cluster_error(error)
+        return unless defined?(Legion::Logging)
+
+        Legion::Logging.warn "Redis cluster error: #{error.class} — #{error.message}"
+      end
+
+      def redis_tls_options(port:)
+        return {} unless defined?(Legion::Crypt::TLS)
+
+        tls = Legion::Crypt::TLS.resolve(cache_tls_settings, port: port)
+        return {} unless tls[:enabled]
+
+        ssl_params = {
+          verify_mode: tls[:verify] == :none ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+        }
+        ssl_params[:ca_file] = tls[:ca] if tls[:ca]
+
+        { ssl: true, ssl_params: ssl_params }
+      end
+
+      def cache_tls_settings
+        return {} unless defined?(Legion::Settings)
+
+        Legion::Settings[:cache][:tls] || {}
+      rescue StandardError
+        {}
       end
     end
   end

data/lib/legion/cache/settings.rb

@@ -13,19 +13,22 @@ module Legion
       Legion::Settings.merge_settings(:cache_local, local) if Legion::Settings.method_defined? :merge_settings
       def self.default
         {
-          driver:     driver,
-          servers:    resolve_servers(driver: driver),
-          connected:  false,
-          enabled:    true,
-          namespace:  'legion',
-          compress:   false,
-          failover:   true,
-          threadsafe: true,
-          expires_in: 0,
-          cache_nils: false,
-          pool_size:  10,
-          timeout:    5,
-          serializer: Legion::JSON
+          driver:         driver,
+          servers:        resolve_servers(driver: driver),
+          connected:      false,
+          enabled:        true,
+          namespace:      'legion',
+          compress:       false,
+          failover:       true,
+          threadsafe:     true,
+          expires_in:     0,
+          cache_nils:     false,
+          pool_size:      10,
+          timeout:        5,
+          serializer:     Legion::JSON,
+          cluster:        nil,
+          replica:        false,
+          fixed_hostname: nil
         }
       end
 

data/lib/legion/cache/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Cache
-    VERSION = '1.3.4'
+    VERSION = '1.3.6'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-cache
 version: !ruby/object:Gem::Version
-  version: 1.3.4
+  version: 1.3.6
 platform: ruby
 authors:
 - Esity