dalli 2.7.11 → 3.0.0

data/lib/dalli/socket.rb

@@ -1,170 +1,95 @@
 # 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
-
-begin
-  require 'kgio'
-  puts "Using kgio socket IO" if defined?($TESTING) && $TESTING
-
-  class Dalli::Server::KSocket < Kgio::Socket
-    attr_accessor :options, :server
-
-    def kgio_wait_readable
-      IO.select([self], nil, nil, options[:socket_timeout]) || raise(Timeout::Error, "IO timeout")
-    end
-
-    def kgio_wait_writable
-      IO.select(nil, [self], nil, options[:socket_timeout]) || raise(Timeout::Error, "IO timeout")
-    end
-
-    alias :write :kgio_write
-
-    def readfull(count)
-      value = String.new('')
-      while true
-        value << kgio_read!(count - value.bytesize)
-        break if value.bytesize == count
-      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
-
-  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
+require 'openssl'
 
-  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
-    end
-  end
-
-  if ::Kgio.respond_to?(:wait_readable=)
-    ::Kgio.wait_readable = :kgio_wait_readable
-    ::Kgio.wait_writable = :kgio_wait_writable
-  end
-
-rescue LoadError
-
-  puts "Using standard socket IO (#{RUBY_DESCRIPTION})" if defined?($TESTING) && $TESTING
-  module Dalli::Server::KSocket
+module Dalli
+  module Socket
     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
+        value = +""
+        loop do
+          result = read_nonblock(count - value.bytesize, exception: false)
+          if result == :wait_readable
+            raise Timeout::Error, "IO timeout: #{safe_options.inspect}" unless IO.select([self], nil, nil, options[:socket_timeout])
+          elsif result == :wait_writable
+            raise Timeout::Error, "IO timeout: #{safe_options.inspect}" unless IO.select(nil, [self], nil, options[:socket_timeout])
+          elsif result
+            value << result
           else
-            safe_options = options.reject{|k,v| [:username, :password].include? k}
-            raise Timeout::Error, "IO timeout: #{safe_options.inspect}"
+            raise Errno::ECONNRESET, "Connection reset: #{safe_options.inspect}"
           end
+          break if value.bytesize == count
         end
         value
       end
 
       def read_available
-        value = String.new('')
-        while true
-          begin
-            value << read_nonblock(8196)
-          rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+        value = +""
+        loop do
+          result = read_nonblock(8196, exception: false)
+          if result == :wait_readable
+            break
+          elsif result == :wait_writable
             break
+          elsif result
+            value << result
+          else
+            raise Errno::ECONNRESET, "Connection reset: #{safe_options.inspect}"
           end
         end
         value
       end
-    end
 
-    def self.included(receiver)
-      receiver.send(:attr_accessor, :options, :server)
-      receiver.send(:include, InstanceMethods)
+      def safe_options
+        options.reject { |k, v| [:username, :password].include? k }
+      end
     end
-  end
-
-  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
+    class SSLSocket < ::OpenSSL::SSL::SSLSocket
+      include Dalli::Socket::InstanceMethods
+      def options
+        io.options
       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."
+    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
+          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]
+
+          return sock unless options[:ssl_context]
+
+          ssl_socket = Dalli::Socket::SSLSocket.new(sock, options[:ssl_context])
+          ssl_socket.hostname = host
+          ssl_socket.sync_close = true
+          ssl_socket.connect
+          ssl_socket
+        end
       end
     end
-  else
-    class Dalli::Server::KSocket::UNIX < UNIXSocket
-      include Dalli::Server::KSocket
+
+    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.options = {path: path}.merge(options)
           sock.server = server
           sock
         end
       end
     end
-
   end
 end

data/lib/dalli/version.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Dalli
-  VERSION = '2.7.11'
+  VERSION = "3.0.0"
 end

data/lib/dalli.rb

@@ -1,14 +1,17 @@
 # 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)
+
+require "dalli/compressor"
+require "dalli/client"
+require "dalli/ring"
+require "dalli/protocol"
+require "dalli/protocol/binary"
+require "dalli/socket"
+require "dalli/version"
+require "dalli/options"
 
 module Dalli
+  autoload :Server, "dalli/server"
+
   # generic error
   class DalliError < RuntimeError; end
   # socket/server communication error
@@ -28,12 +31,12 @@ module Dalli
 
   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)
+    require "logger"
+    l = Logger.new($stdout)
     l.level = Logger::INFO
     l
   end
@@ -41,9 +44,4 @@ 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

data/lib/rack/session/dalli.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 require 'rack/session/abstract/id'
 require 'dalli'
+require 'connection_pool'
 
 module Rack
   module Session
-    class Dalli < defined?(Abstract::Persisted) ? Abstract::Persisted : Abstract::ID
-      attr_reader :pool, :mutex
+    class Dalli < Abstract::Persisted
+      attr_reader :pool
 
       DEFAULT_DALLI_OPTIONS = {
         :namespace => 'rack:session',
@@ -74,26 +75,13 @@ 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|
+        with_block([nil, {}]) do |dc|
           unless sid and !sid.empty? and session = dc.get(sid)
             old_sid, sid, session = sid, generate_sid_with(dc), {}
             unless dc.add(sid, session, @default_ttl)
@@ -108,53 +96,49 @@ module Rack
       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|
+        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]
 
+        popts = {}
         # Filter out Rack::Session-specific options and apply our defaults
         mopts = DEFAULT_DALLI_OPTIONS.merge \
           options.reject {|k, _| DEFAULT_OPTIONS.key? k }
         mserv = mopts.delete :memcache_server
 
         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)
@@ -164,8 +148,7 @@ module Rack
         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/
@@ -174,8 +157,6 @@ module Rack
           warn $!.inspect
         end
         default
-      ensure
-        @mutex.unlock if @mutex and @mutex.locked?
       end
 
       def ttl(expire_after)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 2.7.11
+  version: 3.0.0
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -9,8 +9,50 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-09-26 00:00:00.000000000 Z
-dependencies: []
+date: 2021-10-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  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: connection_pool
+  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: openssl-extensions
+  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'
 description: High performance memcached client for Ruby
 email:
 - peter.m.goldstein@gmail.com
@@ -23,14 +65,13 @@ files:
 - History.md
 - LICENSE
 - README.md
-- lib/action_dispatch/middleware/session/dalli_store.rb
-- lib/active_support/cache/dalli_store.rb
 - lib/dalli.rb
 - lib/dalli/cas/client.rb
 - lib/dalli/client.rb
 - lib/dalli/compressor.rb
 - lib/dalli/options.rb
-- lib/dalli/railtie.rb
+- lib/dalli/protocol.rb
+- lib/dalli/protocol/binary.rb
 - lib/dalli/ring.rb
 - lib/dalli/server.rb
 - lib/dalli/socket.rb
@@ -55,8 +96,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.7.6.2
+rubygems_version: 3.2.29
 signing_key:
 specification_version: 4
 summary: High performance memcached client for Ruby

data/lib/action_dispatch/middleware/session/dalli_store.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-require 'active_support/cache'
-require 'action_dispatch/middleware/session/abstract_store'
-require 'dalli'
-
-# Dalli-based session store for Rails 3.0.
-module ActionDispatch
-  module Session
-    class DalliStore < AbstractStore
-      def initialize(app, options = {})
-        # Support old :expires option
-        options[:expire_after] ||= options[:expires]
-
-        super
-
-        @default_options = { :namespace => 'rack:session' }.merge(@default_options)
-
-        @pool = options[:cache] || begin
-          Dalli::Client.new(
-              @default_options[:memcache_server], @default_options)
-        end
-        @namespace = @default_options[:namespace]
-
-        @raise_errors = !!@default_options[:raise_errors]
-
-        super
-      end
-
-      def reset
-        @pool.reset
-      end
-
-      private
-
-      def get_session(env, sid)
-        sid = generate_sid unless sid and !sid.empty?
-        begin
-          session = @pool.get(sid) || {}
-        rescue Dalli::DalliError => ex
-          # re-raise ArgumentError so Rails' session abstract_store.rb can autoload any missing models
-          raise ArgumentError, ex.message if ex.message =~ /unmarshal/
-          Rails.logger.warn("Session::DalliStore#get: #{ex.message}")
-          session = {}
-        end
-        [sid, session]
-      end
-
-      def set_session(env, sid, session_data, options = nil)
-        options ||= env[ENV_SESSION_OPTIONS_KEY]
-        expiry  = options[:expire_after]
-        @pool.set(sid, session_data, expiry)
-        sid
-      rescue Dalli::DalliError
-        Rails.logger.warn("Session::DalliStore#set: #{$!.message}")
-        raise if @raise_errors
-        false
-      end
-
-      def destroy_session(env, session_id, options)
-        begin
-          @pool.delete(session_id)
-        rescue Dalli::DalliError
-          Rails.logger.warn("Session::DalliStore#destroy_session: #{$!.message}")
-          raise if @raise_errors
-        end
-        return nil if options[:drop]
-        generate_sid
-      end
-
-      def destroy(env)
-        if sid = current_session_id(env)
-          @pool.delete(sid)
-        end
-      rescue Dalli::DalliError
-        Rails.logger.warn("Session::DalliStore#destroy: #{$!.message}")
-        raise if @raise_errors
-        false
-      end
-
-    end
-  end
-end