dalli-elasticache 2.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66afce9165ca020c9c46d25f12901919968d33ec9de15be287a9f589497a042e
-  data.tar.gz: e67a94f65b45ecaf034ba6bfd67c574c3275100d43b8f893d52181606dfdeb1e
+  metadata.gz: c0afff12dcbecd681d00446e7a792cb82f356f28e02bfaac78a1962180e7973e
+  data.tar.gz: 2918dfeefec59bf0c663c15ecc2d981a1b16a51d8b653d2df710290f379945f8
 SHA512:
-  metadata.gz: 92399afd4065a1bdb8f387eb6e04d47152c3e4e2e25fe8449713258409d84986014c2c71ad67a0aa90d8a2bd8a3df9721aca6862ac456c908d1fee4901b4465f
-  data.tar.gz: 379dce4897d563f6811133aaef02c724da76a0bc6f31973b324241d913c5dae2bb53aa15f0536518de6f7e42d1526ff3f3efbfc83f13fc7d3610cff5277d44b0
+  metadata.gz: 0acf68cd09b9bf0bda5e1e77a4c8aff7925edf1e1a51e26adf8773e7a86df0e69fdf9d285d6ee965b24648d0feeb6406cb9bfca6a1187f7ffb652ab117b275fc
+  data.tar.gz: 05702c86d429beea0759bde3682068986b7b0da1f54c55155e3b9ce2f228e95d9b979c8c8ffdf8a35e1a2b752a3e3523624aa8940454f073fd2c6cb79311f1b5

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,8 @@
 # frozen_string_literal: true
 
+require 'openssl'
+require 'timeout'
+
 module Dalli
   module Elasticache
     module AutoDiscovery
@@ -8,46 +11,61 @@ 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
 
+        # `timeout` bounds the entire multi-line read as a single wall-clock deadline,
+        # not each individual `readline`. A per-line readiness check (e.g. `wait_readable`)
+        # can't tell buffered-but-unread bytes apart from an empty socket once a buffering
+        # layer (Ruby's IO buffer, or OpenSSL::Buffering for TLS) sits between the fd and
+        # `readline`, so it can't be used to gate individual lines reliably.
         def response_from_socket(socket)
+          return read_lines(socket) unless timeout
+
+          Timeout.timeout(timeout, Timeout::Error, "Auto discovery read timed out after #{timeout}s") do
+            read_lines(socket)
+          end
+        end
+
+        private
+
+        def read_lines(socket)
           data = +''
           loop do
-            wait_for_data(socket)
             line = socket.readline
             break if line.include?('END')
 
             data << line
           end
-
           data
         end
 
-        private
-
-        def wait_for_data(socket)
-          return unless timeout
-
-          raise Timeout::Error, "Auto discovery read timed out after #{timeout}s" unless socket.wait_readable(timeout)
+        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
       end
     end

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.2'
   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.2
 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.18
 specification_version: 4
 summary: Configure Dalli clients with ElastiCache's AutoDiscovery
 test_files: []