dalli 3.2.13 → 4.0.0

data/lib/dalli/protocol/meta/request_formatter.rb

@@ -13,7 +13,6 @@ module Dalli
         # and introducing an intermediate object seems like overkill.
         #
         # rubocop:disable Metrics/CyclomaticComplexity
-        # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/ParameterLists
         # rubocop:disable Metrics/PerceivedComplexity
         def self.meta_get(key:, value: true, return_cas: false, ttl: nil, base64: false, quiet: false)
@@ -21,7 +20,7 @@ module Dalli
           cmd << ' v f' if value
           cmd << ' c' if return_cas
           cmd << ' b' if base64
-          cmd << " T#{integer_flag(:ttl, ttl)}" if ttl
+          cmd << " T#{ttl}" if ttl
           cmd << ' k q s' if quiet # Return the key in the response if quiet
           cmd + TERMINATOR
         end
@@ -32,19 +31,17 @@ module Dalli
           cmd << ' b' if base64
           cmd << " F#{bitflags}" if bitflags
           cmd << cas_string(cas)
-          cmd << " T#{integer_flag(:ttl, ttl)}" if ttl
+          cmd << " T#{ttl}" if ttl
           cmd << " M#{mode_to_token(mode)}"
           cmd << ' q' if quiet
           cmd << TERMINATOR
-          cmd << value
-          cmd + TERMINATOR
         end
 
         def self.meta_delete(key:, cas: nil, ttl: nil, base64: false, quiet: false)
           cmd = "md #{key}"
           cmd << ' b' if base64
           cmd << cas_string(cas)
-          cmd << " T#{integer_flag(:ttl, ttl)}" if ttl
+          cmd << " T#{ttl}" if ttl
           cmd << ' q' if quiet
           cmd + TERMINATOR
         end
@@ -52,17 +49,16 @@ module Dalli
         def self.meta_arithmetic(key:, delta:, initial:, incr: true, cas: nil, ttl: nil, base64: false, quiet: false)
           cmd = "ma #{key} v"
           cmd << ' b' if base64
-          cmd << " D#{integer_flag(:delta, delta)}" if delta
-          cmd << " J#{integer_flag(:initial, initial)}" if initial
+          cmd << " D#{delta}" if delta
+          cmd << " J#{initial}" if initial
           # Always set a TTL if an initial value is specified
-          cmd << " N#{ttl ? integer_flag(:ttl, ttl) : 0}" if ttl || initial
+          cmd << " N#{ttl || 0}" if ttl || initial
           cmd << cas_string(cas)
           cmd << ' q' if quiet
           cmd << " M#{incr ? 'I' : 'D'}"
           cmd + TERMINATOR
         end
         # rubocop:enable Metrics/CyclomaticComplexity
-        # rubocop:enable Metrics/MethodLength
         # rubocop:enable Metrics/ParameterLists
         # rubocop:enable Metrics/PerceivedComplexity
 
@@ -81,13 +77,16 @@ module Dalli
           cmd + TERMINATOR
         end
 
+        ALLOWED_STATS_ARGS = [nil, '', 'items', 'slabs', 'settings', 'reset'].freeze
+
         def self.stats(arg = nil)
+          raise ArgumentError, "Invalid stats argument: #{arg.inspect}" unless ALLOWED_STATS_ARGS.include?(arg)
+
           cmd = +'stats'
-          cmd << " #{arg}" if arg
+          cmd << " #{arg}" if arg && !arg.empty?
           cmd + TERMINATOR
         end
 
-        # rubocop:disable Metrics/MethodLength
         def self.mode_to_token(mode)
           case mode
           when :add
@@ -102,19 +101,6 @@ module Dalli
             'S'
           end
         end
-        # rubocop:enable Metrics/MethodLength
-
-        # Numeric flag values are written straight into the command line, so a
-        # value that isn't an integer -- e.g. a String carrying CRLF -- would let
-        # the caller inject further memcached commands (GHSA-6wmv-xq9m-fmp7).
-        # Converting to Integer means only digits ever reach the wire. Strings
-        # are parsed as base 10 so "010" means 10, as memcached would read it,
-        # rather than octal 8.
-        def self.integer_flag(name, value)
-          value.is_a?(String) ? Integer(value, 10) : Integer(value)
-        rescue ArgumentError, TypeError, FloatDomainError
-          raise ArgumentError, "#{name} must be an Integer, got #{value.inspect}"
-        end
 
         def self.cas_string(cas)
           cas = parse_to_64_bit_int(cas, nil)

data/lib/dalli/protocol/meta/response_processor.rb

@@ -21,33 +21,29 @@ module Dalli
         STAT = 'STAT'
         VA = 'VA'
         VERSION = 'VERSION'
+        SERVER_ERROR = 'SERVER_ERROR'
 
         def initialize(io_source, value_marshaller)
           @io_source = io_source
           @value_marshaller = value_marshaller
         end
 
-        # raw: true returns the value as stored, without deserializing or
-        # decompressing it, whatever flags it was stored with
-        def meta_get_with_value(cache_nils: false, raw: false)
+        def meta_get_with_value(cache_nils: false)
           tokens = error_on_unexpected!([VA, EN, HD])
           return cache_nils ? ::Dalli::NOT_FOUND : nil if tokens.first == EN
           return true unless tokens.first == VA
 
-          value = read_line
-          raw ? value : @value_marshaller.retrieve(value, bitflags_from_tokens(tokens))
+          @value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens))
         end
 
-        # raw: true returns the value as stored; see #meta_get_with_value
-        def meta_get_with_value_and_cas(raw: false)
+        def meta_get_with_value_and_cas
           tokens = error_on_unexpected!([VA, EN, HD])
           return [nil, 0] if tokens.first == EN
 
           cas = cas_from_tokens(tokens)
           return [nil, cas] unless tokens.first == VA
 
-          value = read_line
-          [raw ? value : @value_marshaller.retrieve(value, bitflags_from_tokens(tokens)), cas]
+          [@value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens)), cas]
         end
 
         def meta_get_without_value
@@ -125,10 +121,6 @@ module Dalli
         end
 
         def full_response_from_buffer(tokens, body, resp_size)
-          # A hit with no key can't be matched to a request: skip it (false
-          # status) rather than yield it, or take it for the end of the pipeline
-          return [resp_size, false, nil, nil, nil] unless tokens.any? { |t| t.start_with?('k') }
-
           value = @value_marshaller.retrieve(body, bitflags_from_tokens(tokens))
           [resp_size, tokens.first == VA, cas_from_tokens(tokens), key_from_tokens(tokens), value]
         end
@@ -149,14 +141,11 @@ module Dalli
 
           tokens, header_len, body_len = tokens_from_header_buffer(buf)
 
-          # A complete response with no body. Only the terminating noop's MN
-          # ends the pipeline. Any other bodyless reply (CLIENT_ERROR,
-          # SERVER_ERROR, ...) answers one key's request: report it with a
-          # false status so the caller skips it and keeps reading. Treating it
-          # as the end would leave the remaining replies on the connection for
-          # later commands to read as their own. A hit on an empty value (VA 0)
-          # still has a body -- just its terminator -- so it's parsed below.
-          return [header_len, tokens.first == MN, nil, nil, nil] if no_body?(tokens, body_len)
+          # We have a complete response that has no body.
+          # This is either the response to the terminating
+          # noop or, if the status is not MN, an intermediate
+          # error response that needs to be discarded.
+          return [header_len, true, nil, nil, nil] if body_len.zero?
 
           resp_size = header_len + body_len + TERMINATOR.length
           # The header is in the buffer, but the body is not.  As we don't have
@@ -169,27 +158,6 @@ module Dalli
           full_response_from_buffer(tokens, body, resp_size)
         end
 
-        # memcached can't store an item larger than 1 GiB (its -I maximum). A
-        # pipelined reply claiming an impossible size would otherwise have the
-        # buffer wait for (and accumulate) that many bytes.
-        MAX_VALUE_BYTES = 1024 * 1024 * 1024
-
-        # The size given right after "VA", or 0 when it isn't a number
-        def positional_size(tokens)
-          tokens.first == VA && tokens[1]&.match?(/\A\d+\z/) ? tokens[1].to_i : 0
-        end
-
-        def check_value_size!(size)
-          return if size.between?(0, MAX_VALUE_BYTES)
-
-          raise Dalli::DalliError, "Reply value size #{size} is out of range"
-        end
-
-        # A zero-size reply has no body unless it's a VA (a hit on an empty value)
-        def no_body?(tokens, body_len)
-          body_len.zero? && tokens.first != VA
-        end
-
         def contains_header?(buf)
           buf.include?(TERMINATOR)
         end
@@ -200,9 +168,12 @@ module Dalli
 
         def error_on_unexpected!(expected_codes)
           tokens = next_line_to_tokens
-          raise Dalli::DalliError, "Response error: #{tokens.first}" unless expected_codes.include?(tokens.first)
 
-          tokens
+          return tokens if expected_codes.include?(tokens.first)
+
+          raise Dalli::ServerError, tokens.join(' ').to_s if tokens.first == SERVER_ERROR
+
+          raise Dalli::DalliError, "Response error: #{tokens.first}"
         end
 
         def bitflags_from_tokens(tokens)
@@ -220,11 +191,7 @@ module Dalli
         end
 
         def body_len_from_tokens(tokens)
-          # memcached also gives the size positionally ("VA <size> ..."); use it
-          # when there's no s flag rather than reading the value as replies
-          size = tokens.any? { |t| t.start_with?('s') } ? value_from_tokens(tokens, 's')&.to_i : positional_size(tokens)
-          check_value_size!(size) if size
-          size
+          value_from_tokens(tokens, 's')&.to_i
         end
 
         def value_from_tokens(tokens, flag)
@@ -242,6 +209,10 @@ module Dalli
           line = read_line
           line&.split || []
         end
+
+        def read_data(data_size)
+          @io_source.read(data_size + TERMINATOR.bytesize)&.chomp!(TERMINATOR)
+        end
       end
     end
   end

data/lib/dalli/protocol/meta.rb

@@ -27,7 +27,7 @@ module Dalli
         encoded_key, base64 = KeyRegularizer.encode(key)
         req = RequestFormatter.meta_get(key: encoded_key, base64: base64)
         write(req)
-        response_processor.meta_get_with_value(cache_nils: cache_nils?(options), raw: raw_request?(options))
+        response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
       end
 
       def quiet_get_request(key)
@@ -40,7 +40,7 @@ module Dalli
         encoded_key, base64 = KeyRegularizer.encode(key)
         req = RequestFormatter.meta_get(key: encoded_key, ttl: ttl, base64: base64)
         write(req)
-        response_processor.meta_get_with_value(cache_nils: cache_nils?(options), raw: raw_request?(options))
+        response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
       end
 
       def touch(key, ttl)
@@ -53,11 +53,11 @@ module Dalli
 
       # TODO: This is confusing, as there's a cas command in memcached
       # and this isn't it.  Maybe rename?  Maybe eliminate?
-      def cas(key, options = nil)
+      def cas(key)
         encoded_key, base64 = KeyRegularizer.encode(key)
         req = RequestFormatter.meta_get(key: encoded_key, value: true, return_cas: true, base64: base64)
         write(req)
-        response_processor.meta_get_with_value_and_cas(raw: raw_request?(options))
+        response_processor.meta_get_with_value_and_cas
       end
 
       # Storage Commands
@@ -85,6 +85,8 @@ module Dalli
                                         bitflags: bitflags, cas: cas,
                                         ttl: ttl, mode: mode, quiet: quiet?, base64: base64)
         write(req)
+        write(value)
+        write(TERMINATOR)
       end
       # rubocop:enable Metrics/ParameterLists
 
@@ -105,6 +107,8 @@ module Dalli
         req = RequestFormatter.meta_set(key: encoded_key, value: value, base64: base64,
                                         cas: cas, ttl: ttl, mode: mode, quiet: quiet?)
         write(req)
+        write(value)
+        write(TERMINATOR)
       end
       # rubocop:enable Metrics/ParameterLists
 

data/lib/dalli/protocol/server_config_parser.rb

@@ -16,7 +16,7 @@ module Dalli
       # can limit character set to LDH + '.'.  Hex digit section
       # is there to support IPv6 addresses, which need to be specified with
       # a bounding []
-      SERVER_CONFIG_REGEXP = /\A(\[([\h:]+)\]|[^:]+)(?::(\d+))?(?::(\d+))?\z/.freeze
+      SERVER_CONFIG_REGEXP = /\A(\[([\h:]+)\]|[^:]+)(?::(\d+))?(?::(\d+))?\z/
 
       DEFAULT_PORT = 11_211
       DEFAULT_WEIGHT = 1

data/lib/dalli/protocol/ttl_sanitizer.rb

@@ -31,7 +31,7 @@ module Dalli
         return ttl_as_i if ttl_as_i > now # Already a timestamp
 
         Dalli.logger.debug "Expiration interval (#{ttl_as_i}) too long for Memcached " \
-                           'and too short to be a future timestamp,' \
+                           'and too short to be a future timestamp, ' \
                            'converting to an expiration timestamp'
         now + ttl_as_i
       end

data/lib/dalli/protocol/value_compressor.rb

@@ -15,33 +15,18 @@ module Dalli
         compress: true,
         compressor: ::Dalli::Compressor,
         # min byte size to attempt compression
-        compression_min_size: 4 * 1024, # 4K
-        # max size a stored value may decompress to (nil: no limit). Guards
-        # against a small compressed value expanding into gigabytes on read.
-        decompressed_max_bytes: 128 * 1024 * 1024 # 128 MiB
+        compression_min_size: 4 * 1024 # 4K
       }.freeze
 
       OPTIONS = DEFAULTS.keys.freeze
 
-      KEYWORD_PARAMETER_TYPES = %i[key keyreq].freeze
-      private_constant :KEYWORD_PARAMETER_TYPES
-
       # https://www.hjp.at/zettel/m/memcached_flags.rxml
       # Looks like most clients use bit 1 to indicate gzip compression.
       FLAG_COMPRESSED = 0x2
 
       def initialize(client_options)
-        # Support the deprecated compression option, but don't allow it to override
-        # an explicit compress
-        # Remove this with 4.0
-        if client_options.key?(:compression) && !client_options.key?(:compress)
-          Dalli.logger.warn "DEPRECATED: Dalli's :compression option is now just 'compress: true'.  " \
-                            'Please update your configuration.'
-          client_options[:compress] = client_options.delete(:compression)
-        end
-
         @compression_options =
-          DEFAULTS.merge(client_options.select { |k, _| OPTIONS.include?(k) })
+          DEFAULTS.merge(client_options.slice(*OPTIONS))
       end
 
       def store(value, req_options, bitflags)
@@ -53,16 +38,8 @@ module Dalli
       end
 
       def retrieve(value, bitflags)
-        return value unless bitflags.anybits?(FLAG_COMPRESSED)
-
-        max_bytes = @compression_options[:decompressed_max_bytes]
-        # Custom compressors that only define decompress(data) keep working,
-        # without the limit
-        if max_bytes && compressor_accepts_max_bytes?
-          compressor.decompress(value, max_bytes: max_bytes)
-        else
-          compressor.decompress(value)
-        end
+        compressed = bitflags.anybits?(FLAG_COMPRESSED)
+        compressed ? compressor.decompress(value) : value
 
       # TODO: We likely want to move this rescue into the Dalli::Compressor / Dalli::GzipCompressor
       # itself, since not all compressors necessarily use Zlib.  For now keep it here, so the behavior
@@ -71,19 +48,6 @@ module Dalli
         raise UnmarshalError, "Unable to uncompress value: #{$ERROR_INFO.message}"
       end
 
-      def compressor_accepts_max_bytes?
-        return @compressor_accepts_max_bytes if defined?(@compressor_accepts_max_bytes)
-
-        @compressor_accepts_max_bytes =
-          begin
-            compressor.method(:decompress).parameters.any? do |type, name|
-              name == :max_bytes && KEYWORD_PARAMETER_TYPES.include?(type)
-            end
-          rescue NameError # an object without a reflectable decompress method
-            false
-          end
-      end
-
       def compress_by_default?
         @compression_options[:compress]
       end

data/lib/dalli/protocol/value_marshaller.rb

@@ -27,7 +27,7 @@ module Dalli
         @value_compressor = ValueCompressor.new(client_options)
 
         @marshal_options =
-          DEFAULTS.merge(client_options.select { |k, _| OPTIONS.include?(k) })
+          DEFAULTS.merge(client_options.slice(*OPTIONS))
       end
 
       def store(key, value, options = nil)

data/lib/dalli/protocol/value_serializer.rb

@@ -18,57 +18,53 @@ module Dalli
       # https://www.hjp.at/zettel/m/memcached_flags.rxml
       # Looks like most clients use bit 0 to indicate native language serialization
       FLAG_SERIALIZED = 0x1
+      FLAG_UTF8 = 0x2
+
+      # Class variable to track whether the Marshal warning has been logged
+      @@marshal_warning_logged = false # rubocop:disable Style/ClassVars
 
       attr_accessor :serialization_options
 
       def initialize(protocol_options)
         @serialization_options =
-          DEFAULTS.merge(protocol_options.select { |k, _| OPTIONS.include?(k) })
+          DEFAULTS.merge(protocol_options.slice(*OPTIONS))
+        warn_if_marshal_default(protocol_options) unless protocol_options[:silence_marshal_warning]
       end
 
       def store(value, req_options, bitflags)
-        do_serialize = !(req_options && req_options[:raw])
-        store_value = do_serialize ? serialize_value(value) : value.to_s
-        bitflags |= FLAG_SERIALIZED if do_serialize
-        [store_value, bitflags]
+        if req_options
+          return [value.to_s, bitflags] if req_options[:raw]
+
+          # If the value is a simple string, going through serialization is costly
+          # for no benefit other than preserving encoding.
+          # Assuming most strings are either UTF-8 or BINARY we can just store
+          # that information in the bitflags.
+          if req_options[:string_fastpath] && value.instance_of?(String)
+            case value.encoding
+            when Encoding::BINARY
+              return [value, bitflags]
+            when Encoding::UTF_8
+              return [value, bitflags | FLAG_UTF8]
+            end
+          end
+        end
+
+        [serialize_value(value), bitflags | FLAG_SERIALIZED]
       end
 
-      # TODO: Some of these error messages need to be validated.  It's not obvious
-      # that all of them are actually generated by the invoked code
-      # in current systems
-      # rubocop:disable Layout/LineLength
-      TYPE_ERR_REGEXP = %r{needs to have method `_load'|exception class/object expected|instance of IO needed|incompatible marshal file format}.freeze
-      ARGUMENT_ERR_REGEXP = /undefined class|marshal data too short/.freeze
-      NAME_ERR_STR = 'uninitialized constant'
-      # rubocop:enable Layout/LineLength
-
       def retrieve(value, bitflags)
-        serialized = (bitflags & FLAG_SERIALIZED) != 0
-        serialized ? serializer.load(value) : value
-      rescue TypeError => e
-        filter_type_error(e)
-      rescue ArgumentError => e
-        filter_argument_error(e)
-      rescue NameError => e
-        filter_name_error(e)
-      end
-
-      def filter_type_error(err)
-        raise err unless TYPE_ERR_REGEXP.match?(err.message)
-
-        raise UnmarshalError, "Unable to unmarshal value: #{err.message}"
-      end
-
-      def filter_argument_error(err)
-        raise err unless ARGUMENT_ERR_REGEXP.match?(err.message)
-
-        raise UnmarshalError, "Unable to unmarshal value: #{err.message}"
-      end
-
-      def filter_name_error(err)
-        raise err unless err.message.include?(NAME_ERR_STR)
-
-        raise UnmarshalError, "Unable to unmarshal value: #{err.message}"
+        serialized = bitflags.anybits?(FLAG_SERIALIZED)
+        if serialized
+          begin
+            serializer.load(value)
+          rescue StandardError
+            raise UnmarshalError, 'Unable to unmarshal value'
+          end
+        elsif bitflags.anybits?(FLAG_UTF8)
+          value.force_encoding(Encoding::UTF_8)
+        else
+          value
+        end
       end
 
       def serializer
@@ -86,6 +82,19 @@ module Dalli
         exc.set_backtrace e.backtrace
         raise exc
       end
+
+      private
+
+      def warn_if_marshal_default(protocol_options)
+        return if protocol_options.key?(:serializer)
+        return if @@marshal_warning_logged
+
+        Dalli.logger.warn 'SECURITY WARNING: Dalli is using Marshal for serialization. ' \
+                          'Marshal can execute arbitrary code during deserialization. ' \
+                          'If your memcached server could be compromised, consider using ' \
+                          'a safer serializer like JSON: Dalli::Client.new(servers, serializer: JSON)'
+        @@marshal_warning_logged = true # rubocop:disable Style/ClassVars
+      end
     end
   end
 end

data/lib/dalli/socket.rb

@@ -52,7 +52,7 @@ module Dalli
 
       FILTERED_OUT_OPTIONS = %i[username password].freeze
       def logged_options
-        options.reject { |k, _| FILTERED_OUT_OPTIONS.include? k }
+        options.except(*FILTERED_OUT_OPTIONS)
       end
     end
 
@@ -63,6 +63,7 @@ module Dalli
     ##
     class SSLSocket < ::OpenSSL::SSL::SSLSocket
       include Dalli::Socket::InstanceMethods
+
       def options
         io.options
       end
@@ -85,6 +86,7 @@ module Dalli
     ##
     class TCP < TCPSocket
       include Dalli::Socket::InstanceMethods
+
       # options - supports enhanced logging in the case of a timeout
       attr_accessor :options
 
@@ -117,19 +119,33 @@ module Dalli
       end
 
       def self.init_socket_options(sock, options)
+        configure_tcp_options(sock, options)
+        configure_socket_buffers(sock, options)
+        configure_timeout(sock, options)
+      end
+
+      def self.configure_tcp_options(sock, options)
         sock.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, true)
         sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true) if options[:keepalive]
+      end
+
+      def self.configure_socket_buffers(sock, options)
         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
 
+      def self.configure_timeout(sock, options)
         return unless options[:socket_timeout]
 
-        seconds, fractional = options[:socket_timeout].divmod(1)
-        microseconds = fractional * 1_000_000
-        timeval = [seconds, microseconds].pack('l_2')
+        if sock.respond_to?(:timeout=)
+          sock.timeout = options[:socket_timeout]
+        else
+          seconds, fractional = options[:socket_timeout].divmod(1)
+          timeval = [seconds, fractional * 1_000_000].pack('l_2')
 
-        sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_RCVTIMEO, timeval)
-        sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_SNDTIMEO, timeval)
+          sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_RCVTIMEO, timeval)
+          sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_SNDTIMEO, timeval)
+        end
       end
 
       def self.wrapping_ssl_socket(tcp_socket, host, ssl_context)
@@ -168,9 +184,16 @@ module Dalli
           Timeout.timeout(options[:socket_timeout]) do
             sock = new(path)
             sock.options = { path: path }.merge(options)
+            init_socket_options(sock, options)
             sock
           end
         end
+
+        def self.init_socket_options(sock, options)
+          # https://man7.org/linux/man-pages/man7/unix.7.html
+          sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_SNDBUF, options[:sndbuf]) if options[:sndbuf]
+          sock.timeout = options[:socket_timeout] if options[:socket_timeout] && sock.respond_to?(:timeout=)
+        end
       end
     end
   end

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '3.2.13'
+  VERSION = '4.0.0'
 
   MIN_SUPPORTED_MEMCACHED_VERSION = '1.4'
 end

data/lib/dalli.rb

@@ -4,8 +4,6 @@
 # Namespace for all Dalli code.
 ##
 module Dalli
-  autoload :Server, 'dalli/server'
-
   # generic error
   class DalliError < RuntimeError; end
 
@@ -27,6 +25,9 @@ module Dalli
   # operation is not permitted in a multi block
   class NotPermittedMultiOpError < DalliError; end
 
+  # raised when Memcached response with a SERVER_ERROR
+  class ServerError < 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
@@ -57,7 +58,6 @@ end
 require_relative 'dalli/version'
 
 require_relative 'dalli/compressor'
-require_relative 'dalli/json_serializer'
 require_relative 'dalli/client'
 require_relative 'dalli/key_manager'
 require_relative 'dalli/pipelined_getter'