dalli 2.7.11 → 3.0.6

data/lib/dalli/servers_arg_normalizer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Dalli
+  ##
+  # This module contains methods for validating and normalizing the servers
+  # argument passed to the client.  This argument can be nil, a string, or
+  # an array of strings.  Each string value in the argument can represent
+  # a single server or a comma separated list of servers.
+  #
+  # If nil, it falls back to the values of ENV['MEMCACHE_SERVERS'] if the latter is
+  # defined.  If that environment value is not defined, a default of '127.0.0.1:11211'
+  # is used.
+  #
+  # A server config string can take one of three forms:
+  #   * A colon separated string of (host, port, weight) where both port and
+  #     weight are optional (e.g. 'localhost', 'abc.com:12345', 'example.org:22222:3')
+  #   * A colon separated string of (UNIX socket, weight) where the weight is optional
+  #     (e.g. '/var/run/memcached/socket', '/tmp/xyz:3') (not supported on Windows)
+  #   * A URI with a 'memcached' protocol, which will typically include a username/password
+  #
+  # The methods in this module do not validate the format of individual server strings, but
+  # rather normalize the argument into a compact array, wherein each array entry corresponds
+  # to a single server config string.  If that normalization is not possible, then an
+  # ArgumentError is thrown.
+  ##
+  module ServersArgNormalizer
+    ENV_VAR_NAME = 'MEMCACHE_SERVERS'
+    DEFAULT_SERVERS = ['127.0.0.1:11211'].freeze
+
+    ##
+    # Normalizes the argument into an array of servers.
+    # If the argument is a string, or an array containing strings, it's expected that the URIs are comma separated e.g.
+    # "memcache1.example.com:11211,memcache2.example.com:11211,memcache3.example.com:11211"
+    def self.normalize_servers(arg)
+      arg = apply_defaults(arg)
+      validate_type(arg)
+      Array(arg).flat_map { |s| s.split(',') }.reject(&:empty?)
+    end
+
+    def self.apply_defaults(arg)
+      return arg unless arg.nil?
+
+      ENV[ENV_VAR_NAME] || DEFAULT_SERVERS
+    end
+
+    def self.validate_type(arg)
+      return if arg.is_a?(String)
+      return if arg.is_a?(Array) && arg.all?(String)
+
+      raise ArgumentError,
+            'An explicit servers argument must be a comma separated string or an array containing strings.'
+    end
+  end
+end

data/lib/dalli/socket.rb

@@ -1,170 +1,148 @@
 # frozen_string_literal: true
-require 'rbconfig'
 
-module Dalli::Server::TCPSocketOptions
-  def setsockopts(sock, options)
-    sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
-    sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true) if options[:keepalive]
-    sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVBUF, options[:rcvbuf]) if options[:rcvbuf]
-    sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDBUF, options[:sndbuf]) if options[:sndbuf]
-  end
-end
+require 'openssl'
+require 'rbconfig'
 
-begin
-  require 'kgio'
-  puts "Using kgio socket IO" if defined?($TESTING) && $TESTING
+module Dalli
+  ##
+  # Various socket implementations used by Dalli.
+  ##
+  module Socket
+    ##
+    # Common methods for all socket implementations.
+    ##
+    module InstanceMethods
+      def readfull(count)
+        value = +''
+        loop do
+          result = read_nonblock(count - value.bytesize, exception: false)
+          value << result if append_to_buffer?(result)
+          break if value.bytesize == count
+        end
+        value
+      end
 
-  class Dalli::Server::KSocket < Kgio::Socket
-    attr_accessor :options, :server
+      def read_available
+        value = +''
+        loop do
+          result = read_nonblock(8196, exception: false)
+          break if WAIT_RCS.include?(result)
+          raise Errno::ECONNRESET, "Connection reset: #{logged_options.inspect}" unless result
 
-    def kgio_wait_readable
-      IO.select([self], nil, nil, options[:socket_timeout]) || raise(Timeout::Error, "IO timeout")
-    end
+          value << result
+        end
+        value
+      end
 
-    def kgio_wait_writable
-      IO.select(nil, [self], nil, options[:socket_timeout]) || raise(Timeout::Error, "IO timeout")
-    end
+      WAIT_RCS = %i[wait_writable wait_readable].freeze
 
-    alias :write :kgio_write
+      def append_to_buffer?(result)
+        raise Timeout::Error, "IO timeout: #{logged_options.inspect}" if nonblock_timed_out?(result)
+        raise Errno::ECONNRESET, "Connection reset: #{logged_options.inspect}" unless result
 
-    def readfull(count)
-      value = String.new('')
-      while true
-        value << kgio_read!(count - value.bytesize)
-        break if value.bytesize == count
+        !WAIT_RCS.include?(result)
       end
-      value
-    end
 
-    def read_available
-      value = String.new('')
-      while true
-        ret = kgio_tryread(8196)
-        case ret
-        when nil
-          raise EOFError, 'end of stream'
-        when :wait_readable
-          break
-        else
-          value << ret
-        end
-      end
-      value
-    end
-  end
+      def nonblock_timed_out?(result)
+        return true if result == :wait_readable && !wait_readable(options[:socket_timeout])
 
-  class Dalli::Server::KSocket::TCP < Dalli::Server::KSocket
-    extend Dalli::Server::TCPSocketOptions
-
-    def self.open(host, port, server, options = {})
-      addr = Socket.pack_sockaddr_in(port, host)
-      sock = start(addr)
-      setsockopts(sock, options)
-      sock.options = options
-      sock.server = server
-      sock.kgio_wait_writable
-      sock
-    rescue Timeout::Error
-      sock.close if sock
-      raise
-    end
-  end
+        # TODO: Do we actually need this?  Looks to be only used in read_nonblock
+        result == :wait_writable && !wait_writable(options[:socket_timeout])
+      end
 
-  class Dalli::Server::KSocket::UNIX < Dalli::Server::KSocket
-    def self.open(path, server, options = {})
-      addr = Socket.pack_sockaddr_un(path)
-      sock = start(addr)
-      sock.options = options
-      sock.server = server
-      sock.kgio_wait_writable
-      sock
-    rescue Timeout::Error
-      sock.close if sock
-      raise
+      FILTERED_OUT_OPTIONS = %i[username password].freeze
+      def logged_options
+        options.reject { |k, _| FILTERED_OUT_OPTIONS.include? k }
+      end
     end
-  end
-
-  if ::Kgio.respond_to?(:wait_readable=)
-    ::Kgio.wait_readable = :kgio_wait_readable
-    ::Kgio.wait_writable = :kgio_wait_writable
-  end
 
-rescue LoadError
+    ##
+    # Wraps the below TCP socket class in the case where the client
+    # has configured a TLS/SSL connection between Dalli and the
+    # Memcached server.
+    ##
+    class SSLSocket < ::OpenSSL::SSL::SSLSocket
+      include Dalli::Socket::InstanceMethods
+      def options
+        io.options
+      end
 
-  puts "Using standard socket IO (#{RUBY_DESCRIPTION})" if defined?($TESTING) && $TESTING
-  module Dalli::Server::KSocket
-    module InstanceMethods
-      def readfull(count)
-        value = String.new('')
-        begin
-          while true
-            value << read_nonblock(count - value.bytesize)
-            break if value.bytesize == count
-          end
-        rescue Errno::EAGAIN, Errno::EWOULDBLOCK
-          if IO.select([self], nil, nil, options[:socket_timeout])
-            retry
-          else
-            safe_options = options.reject{|k,v| [:username, :password].include? k}
-            raise Timeout::Error, "IO timeout: #{safe_options.inspect}"
-          end
+      unless method_defined?(:wait_readable)
+        def wait_readable(timeout = nil)
+          to_io.wait_readable(timeout)
         end
-        value
       end
 
-      def read_available
-        value = String.new('')
-        while true
-          begin
-            value << read_nonblock(8196)
-          rescue Errno::EAGAIN, Errno::EWOULDBLOCK
-            break
-          end
+      unless method_defined?(:wait_writable)
+        def wait_writable(timeout = nil)
+          to_io.wait_writable(timeout)
         end
-        value
       end
     end
 
-    def self.included(receiver)
-      receiver.send(:attr_accessor, :options, :server)
-      receiver.send(:include, InstanceMethods)
-    end
-  end
+    ##
+    # A standard TCP socket between the Dalli client and the Memcached server.
+    ##
+    class TCP < TCPSocket
+      include Dalli::Socket::InstanceMethods
+      attr_accessor :options, :server
+
+      def self.open(host, port, server, options = {})
+        Timeout.timeout(options[:socket_timeout]) do
+          sock = new(host, port)
+          sock.options = { host: host, port: port }.merge(options)
+          sock.server = server
+          init_socket_options(sock, options)
 
-  class Dalli::Server::KSocket::TCP < TCPSocket
-    extend Dalli::Server::TCPSocketOptions
-    include Dalli::Server::KSocket
-
-    def self.open(host, port, server, options = {})
-      Timeout.timeout(options[:socket_timeout]) do
-        sock = new(host, port)
-        setsockopts(sock, options)
-        sock.options = {:host => host, :port => port}.merge(options)
-        sock.server = server
-        sock
+          options[:ssl_context] ? wrapping_ssl_socket(sock, host, options[:ssl_context]) : sock
+        end
+      end
+
+      def self.init_socket_options(sock, options)
+        sock.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, true)
+        sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true) if options[:keepalive]
+        sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_RCVBUF, options[:rcvbuf]) if options[:rcvbuf]
+        sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_SNDBUF, options[:sndbuf]) if options[:sndbuf]
       end
-    end
-  end
 
-  if RbConfig::CONFIG['host_os'] =~ /mingw|mswin/
-    class Dalli::Server::KSocket::UNIX
-      def initialize(*args)
-        raise Dalli::DalliError, "Unix sockets are not supported on Windows platform."
+      def self.wrapping_ssl_socket(tcp_socket, host, ssl_context)
+        ssl_socket = Dalli::Socket::SSLSocket.new(tcp_socket, ssl_context)
+        ssl_socket.hostname = host
+        ssl_socket.sync_close = true
+        ssl_socket.connect
+        ssl_socket
       end
     end
-  else
-    class Dalli::Server::KSocket::UNIX < UNIXSocket
-      include Dalli::Server::KSocket
 
-      def self.open(path, server, options = {})
-        Timeout.timeout(options[:socket_timeout]) do
-          sock = new(path)
-          sock.options = {:path => path}.merge(options)
-          sock.server = server
-          sock
+    if /mingw|mswin/.match?(RbConfig::CONFIG['host_os'])
+      ##
+      # UNIX domain sockets are not supported on Windows platforms.
+      ##
+      class UNIX
+        def initialize(*_args)
+          raise Dalli::DalliError, 'Unix sockets are not supported on Windows platform.'
+        end
+      end
+    else
+
+      ##
+      # UNIX represents a UNIX domain socket, which is an interprocess communication
+      # mechanism between processes on the same host.  Used when the Memcached server
+      # is running on the same machine as the Dalli client.
+      ##
+      class UNIX < UNIXSocket
+        include Dalli::Socket::InstanceMethods
+        attr_accessor :options, :server
+
+        def self.open(path, server, options = {})
+          Timeout.timeout(options[:socket_timeout]) do
+            sock = new(path)
+            sock.options = { path: path }.merge(options)
+            sock.server = server
+            sock
+          end
         end
       end
     end
-
   end
 end

data/lib/dalli/version.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+
 module Dalli
-  VERSION = '2.7.11'
+  VERSION = '3.0.6'
+
+  MIN_SUPPORTED_MEMCACHED_VERSION = '1.4'
 end

data/lib/dalli.rb

@@ -1,39 +1,45 @@
 # frozen_string_literal: true
-require 'dalli/compressor'
-require 'dalli/client'
-require 'dalli/ring'
-require 'dalli/server'
-require 'dalli/socket'
-require 'dalli/version'
-require 'dalli/options'
-require 'dalli/railtie' if defined?(::Rails::Railtie)
 
+##
+# Namespace for all Dalli code.
+##
 module Dalli
+  autoload :Server, 'dalli/server'
+
   # generic error
   class DalliError < RuntimeError; end
+
   # socket/server communication error
   class NetworkError < DalliError; end
+
   # no server available/alive error
   class RingError < DalliError; end
+
   # application error in marshalling serialization
   class MarshalError < DalliError; end
+
   # application error in marshalling deserialization or decompression
   class UnmarshalError < DalliError; end
+
   # payload too big for memcached
   class ValueOverMaxSize < DalliError; end
 
+  # Implements the NullObject pattern to store an application-defined value for 'Key not found' responses.
+  class NilObject; end # rubocop:disable Lint/EmptyClass
+  NOT_FOUND = NilObject.new
+
   def self.logger
     @logger ||= (rails_logger || default_logger)
   end
 
   def self.rails_logger
     (defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger) ||
-    (defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER.respond_to?(:debug) && RAILS_DEFAULT_LOGGER)
+      (defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER.respond_to?(:debug) && RAILS_DEFAULT_LOGGER)
   end
 
   def self.default_logger
     require 'logger'
-    l = Logger.new(STDOUT)
+    l = Logger.new($stdout)
     l.level = Logger::INFO
     l
   end
@@ -41,9 +47,21 @@ module Dalli
   def self.logger=(logger)
     @logger = logger
   end
-
 end
 
-if defined?(RAILS_VERSION) && RAILS_VERSION < '3'
-  raise Dalli::DalliError, "Dalli #{Dalli::VERSION} does not support Rails version < 3.0"
-end
+require_relative 'dalli/version'
+
+require_relative 'dalli/compressor'
+require_relative 'dalli/client'
+require_relative 'dalli/key_manager'
+require_relative 'dalli/ring'
+require_relative 'dalli/protocol'
+require_relative 'dalli/protocol/binary'
+require_relative 'dalli/protocol/server_config_parser'
+require_relative 'dalli/protocol/ttl_sanitizer'
+require_relative 'dalli/protocol/value_compressor'
+require_relative 'dalli/protocol/value_marshaller'
+require_relative 'dalli/protocol/value_serializer'
+require_relative 'dalli/servers_arg_normalizer'
+require_relative 'dalli/socket'
+require_relative 'dalli/options'

data/lib/rack/session/dalli.rb

@@ -1,16 +1,23 @@
 # frozen_string_literal: true
+
 require 'rack/session/abstract/id'
 require 'dalli'
+require 'connection_pool'
+require 'English'
 
 module Rack
   module Session
-    class Dalli < defined?(Abstract::Persisted) ? Abstract::Persisted : Abstract::ID
-      attr_reader :pool, :mutex
+    # Rack::Session::Dalli provides memcached based session management.
+    class Dalli < Abstract::Persisted
+      attr_reader :pool
 
+      # Don't freeze this until we fix the specs/implementation
+      # rubocop:disable Style/MutableConstant
       DEFAULT_DALLI_OPTIONS = {
-        :namespace => 'rack:session',
-        :memcache_server => 'localhost:11211'
+        namespace: 'rack:session',
+        memcache_server: 'localhost:11211'
       }
+      # rubocop:enable Style/MutableConstant
 
       # Brings in a new Rack::Session::Dalli middleware with the given
       # `:memcache_server`. The server is either a hostname, or a
@@ -66,7 +73,7 @@ module Rack
       # for more information about it and its default options (which would only
       # be applicable if you supplied one of the two options, but not both).
       #
-      def initialize(app, options={})
+      def initialize(app, options = {})
         # Parent uses DEFAULT_OPTIONS to build @default_options for Rack::Session
         super
 
@@ -74,28 +81,17 @@ module Rack
         @default_ttl = ttl @default_options[:expire_after]
 
         # Normalize and validate passed options
-        cache, mserv, mopts, popts = extract_dalli_options options
-
-        @pool =
-          if cache # caller passed a Dalli::Client or ConnectionPool instance
-            cache
-          elsif popts # caller passed ConnectionPool options
-            ConnectionPool.new(popts) { ::Dalli::Client.new(mserv, mopts) }
-          else
-            ::Dalli::Client.new(mserv, mopts)
-          end
-
-        if @pool.respond_to?(:alive!) # is a Dalli::Client
-          @mutex = Mutex.new
+        mserv, mopts, popts = extract_dalli_options(options)
 
-          @pool.alive!
-        end
+        @pool = ConnectionPool.new(popts || {}) { ::Dalli::Client.new(mserv, mopts) }
       end
 
-      def get_session(env, sid)
-        with_block(env, [nil, {}]) do |dc|
-          unless sid and !sid.empty? and session = dc.get(sid)
-            old_sid, sid, session = sid, generate_sid_with(dc), {}
+      def get_session(_env, sid)
+        with_block([nil, {}]) do |dc|
+          unless sid && !sid.empty? && (session = dc.get(sid))
+            old_sid = sid
+            sid = generate_sid_with(dc)
+            session = {}
             unless dc.add(sid, session, @default_ttl)
               sid = old_sid
               redo # generate a new sid and try again
@@ -105,77 +101,72 @@ module Rack
         end
       end
 
-      def set_session(env, session_id, new_session, options)
+      def set_session(_env, session_id, new_session, options)
         return false unless session_id
 
-        with_block(env, false) do |dc|
+        with_block(false) do |dc|
           dc.set(session_id, new_session, ttl(options[:expire_after]))
           session_id
         end
       end
 
-      def destroy_session(env, session_id, options)
-        with_block(env) do |dc|
+      def destroy_session(_env, session_id, options)
+        with_block do |dc|
           dc.delete(session_id)
           generate_sid_with(dc) unless options[:drop]
         end
       end
 
-      if defined?(Abstract::Persisted)
-        def find_session(req, sid)
-          get_session req.env, sid
-        end
+      def find_session(req, sid)
+        get_session req.env, sid
+      end
 
-        def write_session(req, sid, session, options)
-          set_session req.env, sid, session, options
-        end
+      def write_session(req, sid, session, options)
+        set_session req.env, sid, session, options
+      end
 
-        def delete_session(req, sid, options)
-          destroy_session req.env, sid, options
-        end
+      def delete_session(req, sid, options)
+        destroy_session req.env, sid, options
       end
 
       private
 
       def extract_dalli_options(options)
-        return [options[:cache]] if options[:cache]
+        raise 'Rack::Session::Dalli no longer supports the :cache option.' if options[:cache]
 
         # Filter out Rack::Session-specific options and apply our defaults
-        mopts = DEFAULT_DALLI_OPTIONS.merge \
-          options.reject {|k, _| DEFAULT_OPTIONS.key? k }
+        # Filter out Rack::Session-specific options and apply our defaults
+        filtered_opts = options.reject { |k, _| DEFAULT_OPTIONS.key? k }
+        mopts = DEFAULT_DALLI_OPTIONS.merge(filtered_opts)
         mserv = mopts.delete :memcache_server
 
+        popts = {}
         if mopts[:pool_size] || mopts[:pool_timeout]
-          popts = {}
           popts[:size] = mopts.delete :pool_size if mopts[:pool_size]
           popts[:timeout] = mopts.delete :pool_timeout if mopts[:pool_timeout]
-
-          # For a connection pool, locking is handled at the pool level
-          mopts[:threadsafe] = false unless mopts.key? :threadsafe
+          mopts[:threadsafe] = true
         end
 
-        [nil, mserv, mopts, popts]
+        [mserv, mopts, popts]
       end
 
-      def generate_sid_with(dc)
-        while true
+      def generate_sid_with(client)
+        loop do
           sid = generate_sid
-          break sid unless dc.get(sid)
+          break sid unless client.get(sid)
         end
       end
 
-      def with_block(env, default=nil, &block)
-        @mutex.lock if @mutex and env['rack.multithread']
+      def with_block(default = nil, &block)
         @pool.with(&block)
       rescue ::Dalli::DalliError, Errno::ECONNREFUSED
-        raise if $!.message =~ /undefined class/
+        raise if /undefined class/.match?($ERROR_INFO.message)
+
         if $VERBOSE
           warn "#{self} is unable to find memcached server."
-          warn $!.inspect
+          warn $ERROR_INFO.inspect
         end
         default
-      ensure
-        @mutex.unlock if @mutex and @mutex.locked?
       end
 
       def ttl(expire_after)