dalli 4.3.10 → 5.0.0

data/lib/dalli/protocol/binary.rb

@@ -1,202 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-require 'socket'
-require 'timeout'
-
-module Dalli
-  module Protocol
-    ##
-    # Access point for a single Memcached server, accessed via Memcached's binary
-    # protocol.  Contains logic for managing connection state to the server (retries, etc),
-    # formatting requests to the server, and unpacking responses.
-    ##
-    class Binary < Base
-      def response_processor
-        @response_processor ||= ResponseProcessor.new(@connection_manager, @value_marshaller)
-      end
-
-      private
-
-      # Retrieval Commands
-      def get(key, options = nil)
-        req = RequestFormatter.standard_request(opkey: :get, key: key)
-        write(req)
-        @connection_manager.flush
-        response_processor.get(cache_nils: cache_nils?(options), raw: raw_request?(options))
-      end
-
-      def quiet_get_request(key)
-        RequestFormatter.standard_request(opkey: :getkq, key: key)
-      end
-
-      def gat(key, ttl, options = nil)
-        ttl = TtlSanitizer.sanitize(ttl)
-        req = RequestFormatter.standard_request(opkey: :gat, key: key, ttl: ttl)
-        write(req)
-        @connection_manager.flush
-        response_processor.get(cache_nils: cache_nils?(options), raw: raw_request?(options))
-      end
-
-      def touch(key, ttl)
-        ttl = TtlSanitizer.sanitize(ttl)
-        write(RequestFormatter.standard_request(opkey: :touch, key: key, ttl: ttl))
-        @connection_manager.flush
-        response_processor.generic_response
-      end
-
-      # 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)
-        req = RequestFormatter.standard_request(opkey: :get, key: key)
-        write(req)
-        @connection_manager.flush
-        response_processor.data_cas_response(raw: raw_request?(options))
-      end
-
-      # Storage Commands
-      def set(key, value, ttl, cas, options)
-        opkey = quiet? ? :setq : :set
-        storage_req(opkey, key, value, ttl, cas, options)
-      end
-
-      # Pipelined set - writes a quiet set request without reading response.
-      # Used by PipelinedSetter for bulk operations.
-      def pipelined_set(key, value, ttl, options)
-        storage_req(:setq, key, value, ttl, 0, options, quiet: true)
-      end
-
-      def add(key, value, ttl, options)
-        opkey = quiet? ? :addq : :add
-        storage_req(opkey, key, value, ttl, 0, options)
-      end
-
-      def replace(key, value, ttl, cas, options)
-        opkey = quiet? ? :replaceq : :replace
-        storage_req(opkey, key, value, ttl, cas, options)
-      end
-
-      # rubocop:disable-next Metrics/ParameterLists
-      def storage_req(opkey, key, value, ttl, cas, options, quiet: quiet?)
-        (value, bitflags) = @value_marshaller.store(key, value, options)
-        ttl = TtlSanitizer.sanitize(ttl)
-
-        req = RequestFormatter.standard_request(opkey: opkey, key: key,
-                                                value: value, bitflags: bitflags,
-                                                ttl: ttl, cas: cas)
-        write(req)
-        @connection_manager.flush unless quiet
-        response_processor.storage_response unless quiet
-      end
-
-      def append(key, value)
-        opkey = quiet? ? :appendq : :append
-        write_append_prepend opkey, key, value
-      end
-
-      def prepend(key, value)
-        opkey = quiet? ? :prependq : :prepend
-        write_append_prepend opkey, key, value
-      end
-
-      def write_append_prepend(opkey, key, value)
-        write(RequestFormatter.standard_request(opkey: opkey, key: key, value: value))
-        @connection_manager.flush unless quiet?
-        response_processor.no_body_response unless quiet?
-      end
-
-      # Delete Commands
-      def delete(key, cas)
-        opkey = quiet? ? :deleteq : :delete
-        req = RequestFormatter.standard_request(opkey: opkey, key: key, cas: cas)
-        write(req)
-        @connection_manager.flush unless quiet?
-        response_processor.delete unless quiet?
-      end
-
-      # Pipelined delete - writes a quiet delete request without reading response.
-      # Used by PipelinedDeleter for bulk operations.
-      def pipelined_delete(key)
-        req = RequestFormatter.standard_request(opkey: :deleteq, key: key, cas: 0)
-        write(req)
-      end
-
-      # Arithmetic Commands
-      def decr(key, count, ttl, initial)
-        opkey = quiet? ? :decrq : :decr
-        decr_incr opkey, key, count, ttl, initial
-      end
-
-      def incr(key, count, ttl, initial)
-        opkey = quiet? ? :incrq : :incr
-        decr_incr opkey, key, count, ttl, initial
-      end
-
-      # This allows us to special case a nil initial value, and
-      # handle it differently than a zero.  This special value
-      # for expiry causes memcached to return a not found
-      # if the key doesn't already exist, rather than
-      # setting the initial value
-      NOT_FOUND_EXPIRY = 0xFFFFFFFF
-      private_constant :NOT_FOUND_EXPIRY
-
-      def decr_incr(opkey, key, count, ttl, initial)
-        expiry = initial ? TtlSanitizer.sanitize(ttl) : NOT_FOUND_EXPIRY
-        initial ||= 0
-        write(RequestFormatter.decr_incr_request(opkey: opkey, key: key,
-                                                 count: count, initial: initial, expiry: expiry))
-        @connection_manager.flush unless quiet?
-        response_processor.decr_incr unless quiet?
-      end
-
-      # Other Commands
-      def flush(ttl = 0)
-        opkey = quiet? ? :flushq : :flush
-        write(RequestFormatter.standard_request(opkey: opkey, ttl: ttl))
-        @connection_manager.flush unless quiet?
-        response_processor.no_body_response unless quiet?
-      end
-
-      # Noop is a keepalive operation but also used to demarcate the end of a set of pipelined commands.
-      # We need to read all the responses at once.
-      def noop
-        write_noop
-        result = response_processor.consume_all_responses_until_noop
-        # Everything up to and including the noop reply has been read
-        @connection_manager.clear_quiet_responses_pending!
-        result
-      end
-
-      def stats(info = '')
-        req = RequestFormatter.standard_request(opkey: :stat, key: info)
-        write(req)
-        @connection_manager.flush
-        response_processor.stats
-      end
-
-      def reset_stats
-        write(RequestFormatter.standard_request(opkey: :stat, key: 'reset'))
-        @connection_manager.flush
-        response_processor.reset
-      end
-
-      def version
-        write(RequestFormatter.standard_request(opkey: :version))
-        @connection_manager.flush
-        response_processor.version
-      end
-
-      def write_noop
-        req = RequestFormatter.standard_request(opkey: :noop)
-        write(req)
-        @connection_manager.flush
-      end
-
-      require_relative 'binary/request_formatter'
-      require_relative 'binary/response_header'
-      require_relative 'binary/response_processor'
-      require_relative 'binary/sasl_authentication'
-      include SaslAuthentication
-    end
-  end
-end

data/lib/dalli/protocol_deprecations.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Dalli
-  ##
-  # Handles deprecation warnings for protocol and authentication features
-  # that will be removed in Dalli 5.0.
-  ##
-  module ProtocolDeprecations
-    BINARY_PROTOCOL_DEPRECATION_MESSAGE = <<~MSG.chomp
-      [DEPRECATION] The binary protocol is deprecated and will be removed in Dalli 5.0. \
-      Please use `protocol: :meta` instead. The meta protocol requires memcached 1.6+. \
-      See https://github.com/petergoldstein/dalli for migration details.
-    MSG
-
-    SASL_AUTH_DEPRECATION_MESSAGE = <<~MSG.chomp
-      [DEPRECATION] SASL authentication is deprecated and will be removed in Dalli 5.0. \
-      SASL is only supported by the binary protocol, which is being removed. \
-      Consider using network-level security (firewall rules, VPN) or memcached's TLS support instead.
-    MSG
-
-    private
-
-    def emit_deprecation_warnings
-      emit_binary_protocol_deprecation_warning
-      emit_sasl_auth_deprecation_warning
-    end
-
-    def emit_binary_protocol_deprecation_warning
-      protocol = @options[:protocol]
-      # Binary is used when protocol is nil, :binary, or 'binary'
-      return if protocol.to_s == 'meta'
-
-      warn BINARY_PROTOCOL_DEPRECATION_MESSAGE
-      Dalli.logger.warn(BINARY_PROTOCOL_DEPRECATION_MESSAGE)
-    end
-
-    def emit_sasl_auth_deprecation_warning
-      username = @options[:username] || ENV.fetch('MEMCACHE_USERNAME', nil)
-      return unless username
-
-      warn SASL_AUTH_DEPRECATION_MESSAGE
-      Dalli.logger.warn(SASL_AUTH_DEPRECATION_MESSAGE)
-    end
-  end
-end