dalli 2.7.2 → 3.0.0

data/lib/dalli/socket.rb

@@ -1,108 +1,95 @@
-begin
-  require 'kgio'
-  puts "Using kgio socket IO" if defined?($TESTING) && $TESTING
+# frozen_string_literal: true
 
-  class Dalli::Server::KSocket < Kgio::Socket
-    attr_accessor :options, :server
+require 'openssl'
 
-    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
+module Dalli
+  module Socket
+    module InstanceMethods
 
-    def self.open(host, port, server, options = {})
-      addr = Socket.pack_sockaddr_in(port, host)
-      sock = start(addr)
-      sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
-      sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true) if options[:keepalive]
-      sock.options = options
-      sock.server = server
-      sock.kgio_wait_writable
-      sock
-    end
+      def readfull(count)
+        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
+            raise Errno::ECONNRESET, "Connection reset: #{safe_options.inspect}"
+          end
+          break if value.bytesize == count
+        end
+        value
+      end
 
-    alias :write :kgio_write
+      def read_available
+        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
 
-    def readfull(count)
-      value = ''
-      loop do
-        value << kgio_read!(count - value.bytesize)
-        break if value.bytesize == count
+      def safe_options
+        options.reject { |k, v| [:username, :password].include? k }
       end
-      value
     end
 
-    def read_available
-      value = ''
-      loop do
-        ret = kgio_tryread(8196)
-        case ret
-        when nil
-          raise EOFError, 'end of stream'
-        when :wait_readable
-          break
-        else
-          value << ret
-        end
+    class SSLSocket < ::OpenSSL::SSL::SSLSocket
+      include Dalli::Socket::InstanceMethods
+      def options
+        io.options
       end
-      value
     end
 
-  end
-
-  if ::Kgio.respond_to?(:wait_readable=)
-    ::Kgio.wait_readable = :kgio_wait_readable
-    ::Kgio.wait_writable = :kgio_wait_writable
-  end
+    class TCP < TCPSocket
+      include Dalli::Socket::InstanceMethods
+      attr_accessor :options, :server
 
-rescue LoadError
+      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]
 
-  puts "Using standard socket IO (#{RUBY_DESCRIPTION})" if defined?($TESTING) && $TESTING
-  class Dalli::Server::KSocket < TCPSocket
-    attr_accessor :options, :server
-
-    def self.open(host, port, server, options = {})
-      Timeout.timeout(options[:socket_timeout]) do
-        sock = new(host, port)
-        sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
-        sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true) if options[:keepalive]
-        sock.options = { :host => host, :port => port }.merge(options)
-        sock.server = server
-        sock
-      end
-    end
+          return sock unless options[:ssl_context]
 
-    def readfull(count)
-      value = ''
-      begin
-        loop do
-          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
-          raise Timeout::Error, "IO timeout: #{options.inspect}"
+          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
-      value
     end
 
-    def read_available
-      value = ''
-      loop do
-        begin
-          value << read_nonblock(8196)
-        rescue Errno::EAGAIN, Errno::EWOULDBLOCK
-          break
+    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
-      value
     end
-
   end
 end

data/lib/dalli/version.rb

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

data/lib/dalli.rb

@@ -1,13 +1,17 @@
-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)
+# frozen_string_literal: true
+
+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
@@ -18,6 +22,8 @@ module Dalli
   class MarshalError < DalliError; end
   # application error in marshalling deserialization or decompression
   class UnmarshalError < DalliError; end
+  # payload too big for memcached
+  class ValueOverMaxSize < DalliError; end
 
   def self.logger
     @logger ||= (rails_logger || default_logger)
@@ -25,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
@@ -38,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,37 +1,92 @@
+# frozen_string_literal: true
 require 'rack/session/abstract/id'
 require 'dalli'
+require 'connection_pool'
 
 module Rack
   module Session
-    class Dalli < Abstract::ID
-      attr_reader :pool, :mutex
+    class Dalli < Abstract::Persisted
+      attr_reader :pool
 
-      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge \
+      DEFAULT_DALLI_OPTIONS = {
         :namespace => 'rack:session',
         :memcache_server => 'localhost:11211'
+      }
 
+      # Brings in a new Rack::Session::Dalli middleware with the given
+      # `:memcache_server`. The server is either a hostname, or a
+      # host-with-port string in the form of "host_name:port", or an array of
+      # such strings. For example:
+      #
+      #   use Rack::Session::Dalli,
+      #     :memcache_server => "mc.example.com:1234"
+      #
+      # If no `:memcache_server` option is specified, Rack::Session::Dalli will
+      # connect to localhost, port 11211 (the default memcached port). If
+      # `:memcache_server` is set to nil, Dalli::Client will look for
+      # ENV['MEMCACHE_SERVERS'] and use that value if it is available, or fall
+      # back to the same default behavior described above.
+      #
+      # Rack::Session::Dalli is intended to be a drop-in replacement for
+      # Rack::Session::Memcache. It accepts additional options that control the
+      # behavior of Rack::Session, Dalli::Client, and an optional
+      # ConnectionPool. First and foremost, if you wish to instantiate your own
+      # Dalli::Client (or ConnectionPool) and use that instead of letting
+      # Rack::Session::Dalli instantiate it on your behalf, simply pass it in
+      # as the `:cache` option. Please note that you will be responsible for
+      # setting the namespace and any other options on Dalli::Client.
+      #
+      # Secondly, if you're not using the `:cache` option, Rack::Session::Dalli
+      # accepts the same options as Dalli::Client, so it's worth reviewing its
+      # documentation. Perhaps most importantly, if you don't specify a
+      # `:namespace` option, Rack::Session::Dalli will default to using
+      # "rack:session".
+      #
+      # Whether you are using the `:cache` option or not, it is not recommend
+      # to set `:expires_in`. Instead, use `:expire_after`, which will control
+      # both the expiration of the client cookie as well as the expiration of
+      # the corresponding entry in memcached.
+      #
+      # Rack::Session::Dalli also accepts a host of options that control how
+      # the sessions and session cookies are managed, including the
+      # aforementioned `:expire_after` option. Please see the documentation for
+      # Rack::Session::Abstract::Persisted for a detailed explanation of these
+      # options and their default values.
+      #
+      # Finally, if your web application is multithreaded, the
+      # Rack::Session::Dalli middleware can become a source of contention. You
+      # can use a connection pool of Dalli clients by passing in the
+      # `:pool_size` and/or `:pool_timeout` options. For example:
+      #
+      #   use Rack::Session::Dalli,
+      #     :memcache_server => "mc.example.com:1234",
+      #     :pool_size => 10
+      #
+      # You must include the `connection_pool` gem in your project if you wish
+      # to use pool support. Please see the documentation for ConnectionPool
+      # 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={})
+        # Parent uses DEFAULT_OPTIONS to build @default_options for Rack::Session
         super
-        @mutex = Mutex.new
-        mserv = @default_options[:memcache_server]
-        mopts = @default_options.reject{|k,v| !DEFAULT_OPTIONS.include? k }
-        @pool = options[:cache] || ::Dalli::Client.new(mserv, mopts)
-        @pool.alive!
-      end
 
-      def generate_sid
-        loop do
-          sid = super
-          break sid unless @pool.get(sid)
-        end
+        # Determine the default TTL for newly-created sessions
+        @default_ttl = ttl @default_options[:expire_after]
+
+        # Normalize and validate passed options
+        mserv, mopts, popts = extract_dalli_options(options)
+
+        @pool = ConnectionPool.new(popts || {}) { ::Dalli::Client.new(mserv, mopts) }
       end
 
       def get_session(env, sid)
-        with_lock(env, [nil, {}]) do
-          unless sid and !sid.empty? and session = @pool.get(sid)
-            sid, session = generate_sid, {}
-            unless @pool.add(sid, session)
-              raise "Session collision on '#{sid.inspect}'"
+        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)
+              sid = old_sid
+              redo # generate a new sid and try again
             end
           end
           [sid, session]
@@ -40,25 +95,61 @@ module Rack
 
       def set_session(env, session_id, new_session, options)
         return false unless session_id
-        expiry = options[:expire_after]
-        expiry = expiry.nil? ? 0 : expiry + 1
 
-        with_lock(env, false) do
-          @pool.set session_id, new_session, expiry
+        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_lock(env) do
-          @pool.delete(session_id)
-          generate_sid unless options[:drop]
+        with_block do |dc|
+          dc.delete(session_id)
+          generate_sid_with(dc) unless options[:drop]
         end
       end
 
-      def with_lock(env, default=nil)
-        @mutex.lock if env['rack.multithread']
-        yield
+      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 delete_session(req, sid, options)
+        destroy_session req.env, sid, options
+      end
+
+      private
+
+      def extract_dalli_options(options)
+        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[:size] = mopts.delete :pool_size if mopts[:pool_size]
+          popts[:timeout] = mopts.delete :pool_timeout if mopts[:pool_timeout]
+          mopts[:threadsafe] = true
+        end
+
+        [mserv, mopts, popts]
+      end
+
+      def generate_sid_with(dc)
+        while true
+          sid = generate_sid
+          break sid unless dc.get(sid)
+        end
+      end
+
+      def with_block(default=nil, &block)
+        @pool.with(&block)
       rescue ::Dalli::DalliError, Errno::ECONNREFUSED
         raise if $!.message =~ /undefined class/
         if $VERBOSE
@@ -66,10 +157,11 @@ module Rack
           warn $!.inspect
         end
         default
-      ensure
-        @mutex.unlock if @mutex.locked?
       end
 
+      def ttl(expire_after)
+        expire_after.nil? ? 0 : expire_after + 1
+      end
     end
   end
 end

metadata

@@ -1,31 +1,32 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 2.7.2
+  version: 3.0.0
 platform: ruby
 authors:
+- Peter M. Goldstein
 - Mike Perham
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-05-17 00:00:00.000000000 Z
+date: 2021-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: mocha
+  name: connection_pool
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,21 +40,23 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: openssl-extensions
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '0'
 description: High performance memcached client for Ruby
-email: mperham@gmail.com
+email:
+- peter.m.goldstein@gmail.com
+- mperham@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -61,46 +64,25 @@ files:
 - Gemfile
 - History.md
 - LICENSE
-- Performance.md
 - README.md
-- Rakefile
-- dalli.gemspec
-- 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
 - lib/dalli/version.rb
 - lib/rack/session/dalli.rb
-- test/benchmark_test.rb
-- test/helper.rb
-- test/memcached_mock.rb
-- test/sasldb
-- test/test_active_support.rb
-- test/test_cas_client.rb
-- test/test_compressor.rb
-- test/test_dalli.rb
-- test/test_encoding.rb
-- test/test_failover.rb
-- test/test_network.rb
-- test/test_rack_session.rb
-- test/test_ring.rb
-- test/test_sasl.rb
-- test/test_serializer.rb
-- test/test_server.rb
-homepage: http://github.com/mperham/dalli
+homepage: https://github.com/petergoldstein/dalli
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
-rdoc_options:
-- "--charset=UTF-8"
+post_install_message:
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -114,25 +96,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
-signing_key: 
+rubygems_version: 3.2.29
+signing_key:
 specification_version: 4
 summary: High performance memcached client for Ruby
-test_files:
-- test/benchmark_test.rb
-- test/helper.rb
-- test/memcached_mock.rb
-- test/sasldb
-- test/test_active_support.rb
-- test/test_cas_client.rb
-- test/test_compressor.rb
-- test/test_dalli.rb
-- test/test_encoding.rb
-- test/test_failover.rb
-- test/test_network.rb
-- test/test_rack_session.rb
-- test/test_ring.rb
-- test/test_sasl.rb
-- test/test_serializer.rb
-- test/test_server.rb
+test_files: []

data/Performance.md

@@ -1,42 +0,0 @@
-Performance
-====================
-
-Caching is all about performance, so I carefully track Dalli performance to ensure no regressions.
-You can optionally use kgio to give Dalli a 10-20% performance boost: `gem install kgio`.
-
-Note I've added some benchmarks over time to Dalli that the other libraries don't necessarily have.
-
-memcache-client
----------------
-
-Testing 1.8.5 with ruby 1.9.3p0 (2011-10-30 revision 33570) [x86_64-darwin11.2.0]
-
-                                          user     system      total        real
-    set:plain:memcache-client         1.860000   0.310000   2.170000 (  2.188030)
-    set:ruby:memcache-client          1.830000   0.290000   2.120000 (  2.130212)
-    get:plain:memcache-client         1.830000   0.340000   2.170000 (  2.176156)
-    get:ruby:memcache-client          1.900000   0.330000   2.230000 (  2.235045)
-    multiget:ruby:memcache-client     0.860000   0.120000   0.980000 (  0.987348)
-    missing:ruby:memcache-client      1.630000   0.320000   1.950000 (  1.954867)
-    mixed:ruby:memcache-client        3.690000   0.670000   4.360000 (  4.364469)
-
-
-dalli
------
-
-Testing with Rails 3.2.1
-Using kgio socket IO
-Testing 2.0.0 with ruby 1.9.3p125 (2012-02-16 revision 34643) [x86_64-darwin11.3.0]
-
-                                          user     system      total        real
-    mixed:rails:dalli                 1.580000   0.570000   2.150000 (  3.008839)
-    set:plain:dalli                   0.730000   0.300000   1.030000 (  1.567098)
-    setq:plain:dalli                  0.520000   0.120000   0.640000 (  0.634402)
-    set:ruby:dalli                    0.800000   0.300000   1.100000 (  1.640348)
-    get:plain:dalli                   0.840000   0.330000   1.170000 (  1.668425)
-    get:ruby:dalli                    0.850000   0.330000   1.180000 (  1.665716)
-    multiget:ruby:dalli               0.700000   0.260000   0.960000 (  0.965423)
-    missing:ruby:dalli                0.720000   0.320000   1.040000 (  1.511720)
-    mixed:ruby:dalli                  1.660000   0.640000   2.300000 (  3.320743)
-    mixedq:ruby:dalli                 1.630000   0.510000   2.140000 (  2.629734)
-    incr:ruby:dalli                   0.270000   0.100000   0.370000 (  0.547618)

data/Rakefile

@@ -1,42 +0,0 @@
-require 'appraisal'
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.warning = true
-  test.verbose = true
-end
-
-Rake::TestTask.new(:bench) do |test|
-  test.libs << 'test'
-  test.pattern = 'test/benchmark_test.rb'
-end
-
-begin
-  require 'metric_fu'
-  MetricFu::Configuration.run do |config|
-    config.rcov[:rcov_opts] << "-Itest:lib"
-  end
-rescue LoadError
-end
-
-task :default => :test
-
-task :test_all do
-  system('rake test RAILS_VERSION="~> 3.0.0"')
-  system('rake test RAILS_VERSION=">= 3.0.0"')
-end
-
-# 'gem install rdoc' to upgrade RDoc if this is giving you errors
-begin
-  require 'rdoc/task'
-  RDoc::Task.new do |rd|
-    rd.rdoc_files.include("lib/**/*.rb")
-  end
-rescue LoadError
-  puts "Unable to load rdoc, run 'gem install rdoc' to fix this."
-end
-
-require 'rake/clean'
-CLEAN.include "**/*.rbc"
-CLEAN.include "**/.DS_Store"