dalli-elasticache 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66afce9165ca020c9c46d25f12901919968d33ec9de15be287a9f589497a042e
-  data.tar.gz: e67a94f65b45ecaf034ba6bfd67c574c3275100d43b8f893d52181606dfdeb1e
+  metadata.gz: 1da71566964e9f17cacf29d2c670d15d7adb80e4b4cc86f8371ea98eb2b80928
+  data.tar.gz: 7b58a9dc5efb77773c0da4de9b1891bbdc5c98d8d4012e13fd432a7906ea6e16
 SHA512:
-  metadata.gz: 92399afd4065a1bdb8f387eb6e04d47152c3e4e2e25fe8449713258409d84986014c2c71ad67a0aa90d8a2bd8a3df9721aca6862ac456c908d1fee4901b4465f
-  data.tar.gz: 379dce4897d563f6811133aaef02c724da76a0bc6f31973b324241d913c5dae2bb53aa15f0536518de6f7e42d1526ff3f3efbfc83f13fc7d3610cff5277d44b0
+  metadata.gz: 04cf01bc3a0ff7c14c3173b05be796038bbe3ad45292bffdacb95834900bd8c40ecd224c206f676f3bdfde2e256beb3812d73b156723235daeabace027de704d
+  data.tar.gz: 13668d4ead1f6e6fd5e2288d5124a1cb47751d7f97dd4a2f50f288c3db123a7c2228d88b4264ea499091e9ebe0fd1db4167b71cd0b8ba8224793847f6dc4f94a

data/README.md

@@ -89,6 +89,57 @@ elasticache.refresh
 elasticache.refresh.client
 ```
 
+### TLS
+
+Pass an `OpenSSL::SSL::SSLContext` via `ssl_context:` to enable TLS for the auto-discovery connection. This uses the same interface as Dalli's own TLS support.
+
+```ruby
+ssl_context = OpenSSL::SSL::SSLContext.new
+ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+elasticache = Dalli::ElastiCache.new(
+  "my-cluster.abc123.cfg.use1.cache.amazonaws.com:11211",
+  { expires_in: 1.day },
+  ssl_context: ssl_context
+)
+```
+
+Note that `ssl_context:` controls TLS for the auto-discovery endpoint only. To also encrypt traffic to the cache nodes themselves, pass `ssl_context:` in the Dalli options as well:
+
+```ruby
+elasticache = Dalli::ElastiCache.new(endpoint, { ssl_context: ssl_context }, ssl_context: ssl_context)
+```
+
+### Refreshing the Node List
+
+The node list is fetched once and cached. Call `#refresh` to re-query the endpoint, which creates a new `Dalli::Client` with the current node list.
+
+Two common patterns for keeping the node list up to date:
+
+**On failure** — rescue `Dalli::RingError` (raised when no nodes are reachable) and refresh before retrying:
+
+```ruby
+begin
+  cache.get("key")
+rescue Dalli::RingError
+  elasticache.refresh
+  retry
+end
+```
+
+**On a schedule** — refresh periodically in a background thread or job. AWS does not publish exact timing for node replacement, but the process typically takes a few minutes, so refreshing every 60 seconds is a reasonable default:
+
+```ruby
+Thread.new do
+  loop do
+    sleep 60
+    elasticache.refresh
+  end
+end
+```
+
+A combination of both approaches is reasonable for production use.
+
 License
 -------
 

data/lib/dalli/elasticache/auto_discovery/base_command.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'openssl'
+
 module Dalli
   module Elasticache
     module AutoDiscovery
@@ -8,24 +10,26 @@ module Dalli
       # command.  Contains the network logic.
       ##
       class BaseCommand
-        attr_reader :host, :port, :timeout
+        attr_reader :host, :port, :timeout, :ssl_context
 
-        def initialize(host, port, timeout = nil)
+        def initialize(host, port, timeout = nil, ssl_context: nil)
           @host = host
           @port = port
           @timeout = timeout
+          @ssl_context = ssl_context
         end
 
         # Send an ASCII command to the endpoint
         #
         # Returns the raw response as a String
         def send_command
-          socket = ::Socket.tcp(@host, @port, connect_timeout: timeout)
+          tcp_socket = ::Socket.tcp(@host, @port, connect_timeout: timeout)
           begin
+            socket = ssl_context ? wrap_with_ssl(tcp_socket) : tcp_socket
             socket.puts command
             response_from_socket(socket)
           ensure
-            socket.close
+            (socket || tcp_socket).close
           end
         end
 
@@ -44,6 +48,14 @@ module Dalli
 
         private
 
+        def wrap_with_ssl(tcp_socket)
+          ssl_socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context)
+          ssl_socket.hostname = @host
+          ssl_socket.sync_close = true
+          ssl_socket.connect
+          ssl_socket
+        end
+
         def wait_for_data(socket)
           return unless timeout
 

data/lib/dalli/elasticache/auto_discovery/endpoint.rb

@@ -15,9 +15,10 @@ module Dalli
         # Matches DNS/IPv4 like "my-host.cache.aws.com:11211" or bracketed IPv6 like "[::1]:11211"
         ENDPOINT_REGEX = /^([-_.a-zA-Z0-9]+|\[[a-fA-F0-9:]+\])(?::(\d+))?$/
 
-        def initialize(addr, timeout: nil)
+        def initialize(addr, timeout: nil, ssl_context: nil)
           @host, @port = parse_endpoint_address(addr)
           @timeout = timeout
+          @ssl_context = ssl_context
         end
 
         DEFAULT_PORT = 11_211
@@ -30,12 +31,12 @@ module Dalli
 
         # A cached ElastiCache::StatsResponse
         def stats
-          @stats ||= StatsCommand.new(@host, @port, @timeout).response
+          @stats ||= StatsCommand.new(@host, @port, @timeout, ssl_context: @ssl_context).response
         end
 
         # A cached ElastiCache::ConfigResponse
         def config
-          @config ||= ConfigCommand.new(@host, @port, @timeout).response
+          @config ||= ConfigCommand.new(@host, @port, @timeout, ssl_context: @ssl_context).response
         end
 
         # The memcached engine version

data/lib/dalli/elasticache/version.rb

@@ -2,6 +2,6 @@
 
 module Dalli
   class ElastiCache
-    VERSION = '2.0.0'
+    VERSION = '2.0.1'
   end
 end

data/lib/dalli/elasticache.rb

@@ -38,9 +38,10 @@ module Dalli
     # timeout: - connect and read timeout in seconds for auto-discovery TCP calls.
     # Defaults to 5 seconds.
     ##
-    def initialize(config_endpoint, dalli_options = {}, timeout: DEFAULT_TIMEOUT)
+    def initialize(config_endpoint, dalli_options = {}, timeout: DEFAULT_TIMEOUT, ssl_context: nil)
       @timeout = timeout
-      @endpoint = Dalli::Elasticache::AutoDiscovery::Endpoint.new(config_endpoint, timeout:)
+      @ssl_context = ssl_context
+      @endpoint = Dalli::Elasticache::AutoDiscovery::Endpoint.new(config_endpoint, timeout:, ssl_context:)
       @options = dalli_options
     end
 
@@ -72,8 +73,8 @@ module Dalli
     # Clear all cached data from the cluster endpoint
     def refresh
       config_endpoint = "#{endpoint.host}:#{endpoint.port}"
-      @endpoint = Dalli::Elasticache::AutoDiscovery::Endpoint.new(config_endpoint, timeout: @timeout)
-
+      @endpoint = Dalli::Elasticache::AutoDiscovery::Endpoint.new(config_endpoint, timeout: @timeout,
+                                                                                   ssl_context: @ssl_context)
       self
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli-elasticache
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Aaron Suggs
@@ -69,7 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.5
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.14
 specification_version: 4
 summary: Configure Dalli clients with ElastiCache's AutoDiscovery
 test_files: []