dalli-elasticache 0.2.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3223c4e9eb1fd636a8841a415905203022f03276
-  data.tar.gz: b853a9d5674e3d4335cd8b6046f3dfa3eba5ef0f
+SHA256:
+  metadata.gz: 1da71566964e9f17cacf29d2c670d15d7adb80e4b4cc86f8371ea98eb2b80928
+  data.tar.gz: 7b58a9dc5efb77773c0da4de9b1891bbdc5c98d8d4012e13fd432a7906ea6e16
 SHA512:
-  metadata.gz: aa250e3c5c9aa4e55434c7d05b76deaea939735414dafac2cd5b2a3dbf42b46042c7931420f872e837a79384394f15a1f1e48f32d9d44eca529f4896e6fc9063
-  data.tar.gz: 627f5c1718932bcbfd7cd661a8c03b55e1ccbb714478598ffffcb28e247f07b503a2e3208f3c90b3778a2a62bbf9496f5ae884f5e470a702f9cd6451d22ddefb
+  metadata.gz: 04cf01bc3a0ff7c14c3173b05be796038bbe3ad45292bffdacb95834900bd8c40ecd224c206f676f3bdfde2e256beb3812d73b156723235daeabace027de704d
+  data.tar.gz: 13668d4ead1f6e6fd5e2288d5124a1cb47751d7f97dd4a2f50f288c3db123a7c2228d88b4264ea499091e9ebe0fd1db4167b71cd0b8ba8224793847f6dc4f94a

data/README.md

@@ -1,46 +1,63 @@
-Dalli ElastiCache [![Gem Version](https://badge.fury.io/rb/dalli-elasticache.svg)](http://badge.fury.io/rb/dalli-elasticache) [![Build Status](https://travis-ci.org/ktheory/dalli-elasticache.svg)](https://travis-ci.org/ktheory/dalli-elasticache) [![Code Climate](https://codeclimate.com/github/ktheory/dalli-elasticache.png)](https://codeclimate.com/github/ktheory/dalli-elasticache)
+Dalli ElastiCache [![Gem Version](https://badge.fury.io/rb/dalli-elasticache.svg)](http://badge.fury.io/rb/dalli-elasticache) [![Build Status](https://github.com/ktheory/dalli-elasticache/actions/workflows/tests.yml/badge.svg)](https://github.com/ktheory/dalli-elasticache/actions/workflows/tests.yml) [![Code Climate](https://codeclimate.com/github/ktheory/dalli-elasticache.png)](https://codeclimate.com/github/ktheory/dalli-elasticache)
 =================
 
-Use [AWS ElastiCache AutoDiscovery](http://docs.aws.amazon.com/AmazonElastiCache/latest/UserGuide/AutoDiscovery.html) to automatically configure your [Dalli memcached client](https://github.com/mperham/dalli) with all the nodes in your cluster.
+Use [AWS ElastiCache AutoDiscovery](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/AutoDiscovery.html) or [Google Cloud MemoryStore Auto Discovery](https://cloud.google.com/memorystore/docs/memcached/using-auto-discovery) to automatically configure your [Dalli memcached client](https://github.com/petergoldstein/dalli) with all the nodes in your cluster.
 
 Installation
 ------------
 
-Install the [rubygem](https://rubygems.org/gems/dalli-elasticache):
+Install the [gem](https://rubygems.org/gems/dalli-elasticache):
 
 ```ruby
 # in your Gemfile
 gem 'dalli-elasticache'
 ```
 
-Setup for Rails 3.x and Newer
------------------------------
+Using Dalli Elasticache in Rails
+---------------------------------
 
-Configure your environment-specific application settings:
+Note that the list of memcached servers used by Rails will be refreshed each time an app server process starts.  If the list of nodes in your cluster changes, this configuration will not be reflected in the Rails configuraiton without such a server process restart.
+
+### Configuring a Cache Store
+
+The most common use of Dalli in Rails is to support a cache store.  To set up your cache store with a cluster, you'll need to generate the list of servers with Dalli ElastiCache and pass them to the `cache_store` configuration.  This needs to be done in your `config/environments/RAILS_ENV.rb` file for each Rails environment where you want to use a cluster.
 
 ```ruby
 # in config/environments/production.rb
 endpoint    = "my-cluster-name.abc123.cfg.use1.cache.amazonaws.com:11211"
 elasticache = Dalli::ElastiCache.new(endpoint)
 
-config.cache_store = :dalli_store, elasticache.servers, {:expires_in => 1.day, :compress => true}
+config.cache_store = :mem_cache_store, elasticache.servers, { expires_in: 1.day }
 ```
+### Configuring a Session Store
+
+Another use of Dalli in Rails is to support a Rails session store.  Dalli ElastiCache can also be used in this case.  The usage is very similar - first use Dalli ElastiCache to generate the list of servers, and then pass that result to the Rails configuration.  In `config/application.rb` you would write:
 
-Note that the ElastiCache server list will be refreshed each time an app server process starts.
+```ruby
+# in config/environments/production.rb
+endpoint    = "my-cluster-name.abc123.cfg.use1.cache.amazonaws.com:11211"
+elasticache = Dalli::ElastiCache.new(endpoint)
+
+config.session_store = :mem_cache_store, memcache_server: elasticache.servers, pool_size: 10, pool_timeout: 5, expire_after: 1.day
+```
 
-Client Usage
+### Dalli Considerations
+
+Please see [here](https://github.com/petergoldstein/dalli/wiki/Using-Dalli-with-Rails) for more information on configuring Dalli and Rails.
+
+
+Using Dalli ElastiCache with a Dalli Client
 ------------
 
-Create an ElastiCache instance:
+To initialize a Dalli Client for all the nodes of a cluster, one simply needs to pass the configuration endpoint and any options for the Dalli Client into the `Dalli::ElastiCache` initializer. Then one can use the methods on the `Dalli::ElastiCache` object to generate an appropriately configured `Dalli::Client`or to get information about the cluster.
 
 ```ruby
 config_endpoint = "aaron-scratch.vfdnac.cfg.use1.cache.amazonaws.com:11211"
 
 # Options for configuring the Dalli::Client
 dalli_options = {
-  :expires_in => 24 * 60 * 60,
-  :namespace => "my_app",
-  :compress => true
+  expires_in: 24 * 60 * 60,
+  namespace: "my_app"
 }
 
 elasticache = Dalli::ElastiCache.new(config_endpoint, dalli_options)
@@ -72,9 +89,58 @@ 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
 -------
 
-Copyright 2013 Aaron Suggs
-
-Released under an [MIT License](http://opensource.org/licenses/MIT)
+Copyright (2017-2022) Aaron Suggs, Peter M. Goldstein. See LICENSE for details.

data/Rakefile

@@ -1,8 +1,10 @@
-require "rubygems"
-require "bundler/setup"
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:test)
 
-task :default => :test
+task default: :test

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+module Dalli
+  module Elasticache
+    module AutoDiscovery
+      ##
+      # Base command class for configuration endpoint
+      # command.  Contains the network logic.
+      ##
+      class BaseCommand
+        attr_reader :host, :port, :timeout, :ssl_context
+
+        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
+          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 || tcp_socket).close
+          end
+        end
+
+        def response_from_socket(socket)
+          data = +''
+          loop do
+            wait_for_data(socket)
+            line = socket.readline
+            break if line.include?('END')
+
+            data << line
+          end
+
+          data
+        end
+
+        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
+
+          raise Timeout::Error, "Auto discovery read timed out after #{timeout}s" unless socket.wait_readable(timeout)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Dalli
+  module Elasticache
+    module AutoDiscovery
+      ##
+      # Encapsulates execution of the 'config' command, which is used to
+      # extract the list of nodes and determine if that list of nodes has changed.
+      ##
+      class ConfigCommand < BaseCommand
+        CONFIG_COMMAND = "config get cluster\r\n"
+
+        def response
+          ConfigResponse.new(send_command)
+        end
+
+        def command
+          CONFIG_COMMAND
+        end
+      end
+    end
+  end
+end

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

@@ -1,48 +1,45 @@
+# frozen_string_literal: true
+
 module Dalli
   module Elasticache
     module AutoDiscovery
-      
       # This class wraps the raw ASCII response from an Auto Discovery endpoint
       # and provides methods for extracting data from that response.
       #
       # http://docs.aws.amazon.com/AmazonElastiCache/latest/UserGuide/AutoDiscovery.AddingToYourClientLibrary.html
-      
       class ConfigResponse
-        
         # The raw response text
         attr_reader :text
-    
+
         # Matches the version line of the response
-        VERSION_REGEX = /^(\d+)$/
-    
+        VERSION_REGEX = /^(\d+)\r?\n/
+
         # Matches strings like "my-cluster.001.cache.aws.com|10.154.182.29|11211"
         NODE_REGEX = /(([-.a-zA-Z0-9]+)\|(\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b)\|(\d+))/
         NODE_LIST_REGEX = /^(#{NODE_REGEX}\s*)+$/
-    
+
         def initialize(response_text)
           @text = response_text.to_s
         end
-    
+
         # The number of times the configuration has been changed
         #
         # Returns an integer
         def version
-          VERSION_REGEX.match(@text)[1].to_i
+          m = VERSION_REGEX.match(@text)
+          return -1 unless m
+
+          m[1].to_i
         end
-    
+
         # Node hosts, ip addresses, and ports
         #
         # Returns an Array of Hashes with values for :host, :ip and :port
         def nodes
           NODE_LIST_REGEX.match(@text).to_s.scan(NODE_REGEX).map do |match|
-            {
-              :host => match[1],
-              :ip   => match[2],
-              :port => match[3].to_i
-            }
+            Node.new(match[1], match[2], match[3].to_i)
           end
         end
-    
       end
     end
   end

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

@@ -1,76 +1,47 @@
+# frozen_string_literal: true
+
 module Dalli
   module Elasticache
     module AutoDiscovery
+      ##
+      # This is a representation of the configuration endpoint for
+      # a memcached cluster.  It encapsulates information returned from
+      # that endpoint.
+      ##
       class Endpoint
-        
         # Endpoint configuration
-        attr_reader :host
-        attr_reader :port
-    
-        # Matches Strings like "my-host.cache.aws.com:11211"
-        ENDPOINT_REGEX = /([-.a-zA-Z0-9]+):(\d+)/
-    
-        STATS_COMMAND  = "stats\r\n"
-        CONFIG_COMMAND = "config get cluster\r\n"
-        # Legacy command for version < 1.4.14
-        OLD_CONFIG_COMMAND = "get AmazonElastiCache:cluster\r\n"
-    
-        def initialize(endpoint)
-          ENDPOINT_REGEX.match(endpoint) do |m|
-            @host = m[1]
-            @port = m[2].to_i
-          end
-        end
-    
+        attr_reader :host, :port
+
+        # 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, ssl_context: nil)
+          @host, @port = parse_endpoint_address(addr)
+          @timeout = timeout
+          @ssl_context = ssl_context
+        end
+
+        DEFAULT_PORT = 11_211
+        def parse_endpoint_address(addr)
+          m = ENDPOINT_REGEX.match(addr)
+          raise ArgumentError, "Unable to parse configuration endpoint address - #{addr}" unless m
+
+          [m[1], (m[2] || DEFAULT_PORT).to_i]
+        end
+
         # A cached ElastiCache::StatsResponse
         def stats
-          @stats ||= get_stats_from_remote
+          @stats ||= StatsCommand.new(@host, @port, @timeout, ssl_context: @ssl_context).response
         end
-    
+
         # A cached ElastiCache::ConfigResponse
         def config
-          @config ||= get_config_from_remote
+          @config ||= ConfigCommand.new(@host, @port, @timeout, ssl_context: @ssl_context).response
         end
-    
+
         # The memcached engine version
         def engine_version
-          stats.version
-        end
-    
-        protected
-    
-        def with_socket(&block)
-          TCPSocket.new(config_host, config_port)
-        end
-    
-        def get_stats_from_remote
-          data = remote_command(STATS_COMMAND)
-          StatsResponse.new(data)
-        end
-    
-        def get_config_from_remote
-          if engine_version < Gem::Version.new("1.4.14")
-            data = remote_command(OLD_CONFIG_COMMAND)
-          else
-            data = remote_command(CONFIG_COMMAND)
-          end
-          ConfigResponse.new(data)
-        end
-      
-        # Send an ASCII command to the endpoint
-        #
-        # Returns the raw response as a String
-        def remote_command(command)
-          socket = TCPSocket.new(@host, @port)
-          socket.puts command
-        
-          data = ""
-          until (line = socket.readline) =~ /END/
-            data << line
-          end
-        
-          socket.close
-          data
+          stats.engine_version
         end
       end
     end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Dalli
+  module Elasticache
+    module AutoDiscovery
+      ##
+      # Represents a single memcached node in the
+      # cluster.
+      ##
+      class Node
+        attr_reader :host, :ip, :port
+
+        def initialize(host, ip, port)
+          @host = host
+          @ip = ip
+          @port = port
+        end
+
+        def ==(other)
+          host == other.host &&
+            ip == other.ip &&
+            port == other.port
+        end
+
+        def eql?(other)
+          self == other
+        end
+
+        def hash
+          [host, ip, port].hash
+        end
+
+        def to_s
+          "#{@host}:#{@port}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Dalli
+  module Elasticache
+    module AutoDiscovery
+      ##
+      # Encapsulates execution of the 'stats' command, which is used to
+      # extract the engine_version
+      ##
+      class StatsCommand < BaseCommand
+        STATS_COMMAND = "stats\r\n"
+
+        def response
+          StatsResponse.new(send_command)
+        end
+
+        def command
+          STATS_COMMAND
+        end
+      end
+    end
+  end
+end

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

@@ -1,29 +1,32 @@
+# frozen_string_literal: true
+
 module Dalli
   module Elasticache
     module AutoDiscovery
-      
-      # This class wraps the raw ASCII response from an Auto Discovery endpoint
-      # and provides methods for extracting data from that response.
+      # This class wraps the raw ASCII response from a stats call to an
+      # Auto Discovery endpoint and provides methods for extracting data
+      # from that response.
       #
       # http://docs.aws.amazon.com/AmazonElastiCache/latest/UserGuide/AutoDiscovery.AddingToYourClientLibrary.html
-      
       class StatsResponse
-        
         # The raw response text
         attr_reader :text
-        
+
         # Matches the version line of the response
-        VERSION_REGEX = /^STAT version ([0-9.]+)\s*$/
-        
+        VERSION_REGEX = /^STAT version ([0-9.]+|unknown)\s*/i
+
         def initialize(response_text)
           @text = response_text.to_s
         end
-        
+
         # Extract the engine version stat
         #
-        # Returns a Gem::Version
-        def version
-          Gem::Version.new(VERSION_REGEX.match(@text)[1])
+        # Returns a string
+        def engine_version
+          m = VERSION_REGEX.match(@text)
+          return '' unless m && m[1]
+
+          m[1]
         end
       end
     end

data/lib/dalli/elasticache/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Dalli
   class ElastiCache
-    VERSION = "0.2.0"
+    VERSION = '2.0.1'
   end
 end

data/lib/dalli/elasticache.rb

@@ -1,47 +1,80 @@
+# frozen_string_literal: true
+
 require 'dalli'
 require 'socket'
-require 'dalli/elasticache/version'
-require 'dalli/elasticache/auto_discovery/endpoint'
-require 'dalli/elasticache/auto_discovery/config_response'
-require 'dalli/elasticache/auto_discovery/stats_response'
+require 'timeout'
+require_relative 'elasticache/version'
+require_relative 'elasticache/auto_discovery/endpoint'
+require_relative 'elasticache/auto_discovery/base_command'
+require_relative 'elasticache/auto_discovery/node'
+require_relative 'elasticache/auto_discovery/config_response'
+require_relative 'elasticache/auto_discovery/config_command'
+require_relative 'elasticache/auto_discovery/stats_response'
+require_relative 'elasticache/auto_discovery/stats_command'
 
 module Dalli
+  ##
+  # Dalli::Elasticache provides an interface for providing a configuration
+  # endpoint for a memcached cluster on ElasticCache and retrieving the
+  # list of addresses (hostname and port) for the individual nodes of that cluster.
+  #
+  # This allows the caller to pass that server list to Dalli, which then
+  # distributes cached items consistently over the nodes.
+  ##
   class ElastiCache
+    DEFAULT_TIMEOUT = 5
+
     attr_reader :endpoint, :options
-    
-    def initialize(config_endpoint, options={})
-      @endpoint = Dalli::Elasticache::AutoDiscovery::Endpoint.new(config_endpoint)
-      @options = options
+
+    ##
+    # Creates a new Dalli::ElasticCache instance.
+    #
+    # config_endpoint - a String containing the host and (optionally) port of the
+    # configuration endpoint for the cluster.  If not specified the port will
+    # default to 11211.  The host must be either a DNS name, an IPv4 address, or
+    # a bracketed IPv6 address.
+    # dalli_options - a set of options passed to the Dalli::Client that is returned
+    # by the client method.  Otherwise unused.
+    # 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, ssl_context: nil)
+      @timeout = timeout
+      @ssl_context = ssl_context
+      @endpoint = Dalli::Elasticache::AutoDiscovery::Endpoint.new(config_endpoint, timeout:, ssl_context:)
+      @options = dalli_options
     end
-    
+
     # Dalli::Client configured to connect to the cluster's nodes
     def client
       Dalli::Client.new(servers, options)
     end
-    
+
     # The number of times the cluster configuration has been changed
     #
     # Returns an integer
     def version
       endpoint.config.version
     end
-    
+
     # The cache engine version of the cluster
+    #
+    # Returns a string
     def engine_version
       endpoint.engine_version
     end
-    
+
     # List of cluster server nodes with ip addresses and ports
     # Always use host name instead of private elasticache IPs as internal IPs can change after a node is rebooted
     def servers
-      endpoint.config.nodes.map{ |h| "#{h[:host]}:#{h[:port]}" }
+      endpoint.config.nodes.map(&:to_s)
     end
-    
+
     # Clear all cached data from the cluster endpoint
     def refresh
       config_endpoint = "#{endpoint.host}:#{endpoint.port}"
-      @endpoint = Dalli::Elasticache::AutoDiscovery::Endpoint.new(config_endpoint)
-      
+      @endpoint = Dalli::Elasticache::AutoDiscovery::Endpoint.new(config_endpoint, timeout: @timeout,
+                                                                                   ssl_context: @ssl_context)
       self
     end
   end

data/lib/dalli-elasticache.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 # Support default bundler require path
-require 'dalli/elasticache'
+require_relative 'dalli/elasticache'

metadata

@@ -1,58 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: dalli-elasticache
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Aaron Suggs
 - Zach Millman
-autorequire: 
+- Peter M. Goldstein
 bindir: bin
 cert_chain: []
-date: 2016-02-24 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: dalli
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 5.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 5.0.0
 description: |2
       This gem provides an interface for fetching cluster information from an AWS
       ElastiCache AutoDiscovery server and configuring a Dalli client to connect
@@ -60,6 +32,7 @@ description: |2
 email:
 - aaron@ktheory.com
 - zach@magoosh.com
+- peter.m.goldstein@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -68,20 +41,19 @@ files:
 - Rakefile
 - lib/dalli-elasticache.rb
 - lib/dalli/elasticache.rb
+- lib/dalli/elasticache/auto_discovery/base_command.rb
+- lib/dalli/elasticache/auto_discovery/config_command.rb
 - lib/dalli/elasticache/auto_discovery/config_response.rb
 - lib/dalli/elasticache/auto_discovery/endpoint.rb
+- lib/dalli/elasticache/auto_discovery/node.rb
+- lib/dalli/elasticache/auto_discovery/stats_command.rb
 - lib/dalli/elasticache/auto_discovery/stats_response.rb
 - lib/dalli/elasticache/version.rb
-- spec/config_response_spec.rb
-- spec/elasticache_spec.rb
-- spec/endpoint_spec.rb
-- spec/spec_helper.rb
-- spec/stats_response_spec.rb
 homepage: http://github.com/ktheory/dalli-elasticache
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
 rdoc_options:
 - "--charset=UTF-8"
 require_paths:
@@ -90,21 +62,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.2
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: 1.3.5
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2
-signing_key: 
+rubygems_version: 4.0.14
 specification_version: 4
 summary: Configure Dalli clients with ElastiCache's AutoDiscovery
-test_files:
-- spec/config_response_spec.rb
-- spec/elasticache_spec.rb
-- spec/endpoint_spec.rb
-- spec/spec_helper.rb
-- spec/stats_response_spec.rb
+test_files: []

data/spec/config_response_spec.rb

@@ -1,32 +0,0 @@
-require_relative 'spec_helper'
-
-describe 'Dalli::Elasticache::AutoDiscovery::ConfigResponse' do
-  let :response do
-    text = "CONFIG cluster 0 141\r\n12\nmycluster.0001.cache.amazonaws.com|10.112.21.1|11211 mycluster.0002.cache.amazonaws.com|10.112.21.2|11211 mycluster.0003.cache.amazonaws.com|10.112.21.3|11211\n\r\n"
-    Dalli::Elasticache::AutoDiscovery::ConfigResponse.new(text)
-  end
-  
-  describe '#version' do
-    it 'parses version' do
-      response.version.should == 12
-    end
-  end
-
-  describe '#nodes' do
-    it 'parses hosts' do
-      response.nodes.map{|s| s[:host]}.should == [
-        "mycluster.0001.cache.amazonaws.com",
-        "mycluster.0002.cache.amazonaws.com",
-        "mycluster.0003.cache.amazonaws.com"
-      ]
-    end
-  
-    it 'parses ip addresses' do
-      response.nodes.map{|s| s[:ip]}.should == ["10.112.21.1", "10.112.21.2", "10.112.21.3"]
-    end
-  
-    it 'parses ports' do
-      response.nodes.map{|s| s[:port]}.should == [11211, 11211, 11211]
-    end
-  end
-end

data/spec/elasticache_spec.rb

@@ -1,62 +0,0 @@
-require_relative 'spec_helper'
-
-describe 'Dalli::ElastiCache::Endpoint' do
-  let(:cache) do
-    options = {
-      :expires_in => 24*60*60,
-      :namespace => "my_app",
-      :compress => true
-    }
-    Dalli::ElastiCache.new("my-cluster.cfg.use1.cache.amazonaws.com:11211", options)
-  end
-
-  let(:config_text) { "CONFIG cluster 0 141\r\n12\nmycluster.0001.cache.amazonaws.com|10.112.21.1|11211 mycluster.0002.cache.amazonaws.com|10.112.21.2|11211 mycluster.0003.cache.amazonaws.com|10.112.21.3|11211\n\r\n" }
-  let(:response) { Dalli::Elasticache::AutoDiscovery::ConfigResponse.new(config_text) }
-
-  describe '.new' do
-    it 'builds endpoint' do
-      cache.endpoint.host.should == "my-cluster.cfg.use1.cache.amazonaws.com"
-      cache.endpoint.port.should == 11211
-    end
-    
-    it 'stores Dalli options' do
-      cache.options[:expires_in].should == 24*60*60
-      cache.options[:namespace].should == "my_app"
-      cache.options[:compress].should == true
-    end
-  end
-  
-  describe '#client' do
-    it 'builds with node list'
-    it 'builds with options'
-  end
-  
-  describe '#servers' do
-    before { Dalli::Elasticache::AutoDiscovery::Endpoint.any_instance.should_receive(:get_config_from_remote).and_return(response) }
-
-    it 'lists addresses and ports' do
-      cache.servers.should == ["mycluster.0001.cache.amazonaws.com:11211", "mycluster.0002.cache.amazonaws.com:11211", "mycluster.0003.cache.amazonaws.com:11211"]
-    end
-  end
-  
-  describe '#version' do
-  end
-  
-  describe '#engine_version' do
-  end
-  
-  describe '#refresh' do
-    it 'clears endpoint configuration' do
-      stale_endpoint = cache.endpoint
-      cache.refresh.endpoint.should_not === stale_endpoint
-    end
-    
-    it 'builds endpoint with same configuration' do
-      stale_endpoint = cache.endpoint
-      cache.refresh
-      cache.endpoint.host.should == stale_endpoint.host
-      cache.endpoint.port.should == stale_endpoint.port
-    end
-  end
-  
-end

data/spec/endpoint_spec.rb

@@ -1,16 +0,0 @@
-require_relative 'spec_helper'
-
-describe 'Dalli::Elasticache::AutoDiscovery::Endpoint' do
-  let(:endpoint) do
-    Dalli::Elasticache::AutoDiscovery::Endpoint.new("my-cluster.cfg.use1.cache.amazonaws.com:11211")
-  end
-  
-  describe '.new' do
-    it 'parses host' do
-      endpoint.host.should == "my-cluster.cfg.use1.cache.amazonaws.com"
-    end
-    it 'parses port' do
-      endpoint.port.should == 11211
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,12 +0,0 @@
-require "bundler/setup"
-
-require "dalli/elasticache"
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |c|
-    c.syntax = :should
-  end
-  config.mock_with :rspec do |c|
-    c.syntax = :should
-  end
-end

data/spec/stats_response_spec.rb

@@ -1,14 +0,0 @@
-require_relative 'spec_helper'
-
-describe 'Dalli::Elasticache::AutoDiscovery::StatsResponse' do
-  let :response do
-    text = "STAT pid 1\r\nSTAT uptime 68717\r\nSTAT time 1398885375\r\nSTAT version 1.4.14\r\nSTAT libevent 1.4.13-stable\r\nSTAT pointer_size 64\r\nSTAT rusage_user 0.136008\r\nSTAT rusage_system 0.424026\r\nSTAT curr_connections 5\r\nSTAT total_connections 1159\r\nSTAT connection_structures 6\r\nSTAT reserved_fds 5\r\nSTAT cmd_get 0\r\nSTAT cmd_set 0\r\nSTAT cmd_flush 0\r\nSTAT cmd_touch 0\r\nSTAT cmd_config_get 4582\r\nSTAT cmd_config_set 2\r\nSTAT get_hits 0\r\nSTAT get_misses 0\r\nSTAT delete_misses 0\r\nSTAT delete_hits 0\r\nSTAT incr_misses 0\r\nSTAT incr_hits 0\r\nSTAT decr_misses 0\r\nSTAT decr_hits 0\r\nSTAT cas_misses 0\r\nSTAT cas_hits 0\r\nSTAT cas_badval 0\r\nSTAT touch_hits 0\r\nSTAT touch_misses 0\r\nSTAT auth_cmds 0\r\nSTAT auth_errors 0\r\nSTAT bytes_read 189356\r\nSTAT bytes_written 2906615\r\nSTAT limit_maxbytes 209715200\r\nSTAT accepting_conns 1\r\nSTAT listen_disabled_num 0\r\nSTAT threads 1\r\nSTAT conn_yields 0\r\nSTAT curr_config 1\r\nSTAT hash_power_level 16\r\nSTAT hash_bytes 524288\r\nSTAT hash_is_expanding 0\r\nSTAT expired_unfetched 0\r\nSTAT evicted_unfetched 0\r\nSTAT bytes 0\r\nSTAT curr_items 0\r\nSTAT total_items 0\r\nSTAT evictions 0\r\nSTAT reclaimed 0\r\n"
-    Dalli::Elasticache::AutoDiscovery::StatsResponse.new(text)
-  end
-  
-  describe '#version' do
-    it 'parses version' do
-      response.version.should == Gem::Version.new("1.4.14")
-    end
-  end
-end