dalli 1.1.4 → 2.7.11

data/lib/dalli/socket.rb

@@ -1,40 +1,88 @@
+# 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
+    attr_accessor :options, :server
 
     def kgio_wait_readable
-      IO.select([self], nil, nil, options[:timeout]) || raise(Timeout::Error, "IO timeout")
+      IO.select([self], nil, nil, options[:socket_timeout]) || raise(Timeout::Error, "IO timeout")
     end
 
     def kgio_wait_writable
-      IO.select(nil, [self], nil, options[:timeout]) || raise(Timeout::Error, "IO timeout")
-    end
-
-    def self.open(host, port, options = {})
-      addr = Socket.pack_sockaddr_in(port, host)
-      sock = start(addr)
-      sock.options = options
-      sock.kgio_wait_writable
-      sock
+      IO.select(nil, [self], nil, options[:socket_timeout]) || raise(Timeout::Error, "IO timeout")
     end
 
     alias :write :kgio_write
 
     def readfull(count)
-      value = ''
-      loop do
+      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
+
+  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
@@ -44,127 +92,79 @@ begin
 rescue LoadError
 
   puts "Using standard socket IO (#{RUBY_DESCRIPTION})" if defined?($TESTING) && $TESTING
-  if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-
-    class Dalli::Server::KSocket < TCPSocket
-      attr_accessor :options
-
-      def self.open(host, port, options = {})
-        sock = new(host, port)
-        sock.options = { :host => host, :port => port }.merge(options)
-        sock
-      end
-
+  module Dalli::Server::KSocket
+    module InstanceMethods
       def readfull(count)
-        value = ''
+        value = String.new('')
         begin
-          loop do
+          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[:timeout])
+          if IO.select([self], nil, nil, options[:socket_timeout])
             retry
           else
-            raise Timeout::Error, "IO timeout: #{options.inspect}"
+            safe_options = options.reject{|k,v| [:username, :password].include? k}
+            raise Timeout::Error, "IO timeout: #{safe_options.inspect}"
           end
         end
         value
       end
 
-    end
-
-  else
-
-    class Dalli::Server::KSocket < Socket
-      attr_accessor :options
-
-      def self.open(host, port, options = {})
-        # All this ugly code to ensure proper Socket connect timeout
-        addr = Socket.getaddrinfo(host, nil)
-        sock = new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
-        sock.options = { :host => host, :port => port }.merge(options)
-        begin
-          sock.connect_nonblock(Socket.pack_sockaddr_in(port, addr[0][3]))
-        rescue Errno::EINPROGRESS
-          resp = IO.select(nil, [sock], nil, sock.options[:timeout])
+      def read_available
+        value = String.new('')
+        while true
           begin
-            sock.connect_nonblock(Socket.pack_sockaddr_in(port, addr[0][3]))
-          rescue Errno::EISCONN
-          end
-        end
-        sock
-      end
-
-      def readfull(count)
-        value = ''
-        begin
-          loop do
-            value << sysread(count - value.bytesize)
-            break if value.bytesize == count
-          end
-        rescue Errno::EAGAIN, Errno::EWOULDBLOCK
-          if IO.select([self], nil, nil, options[:timeout])
-            retry
-          else
-            raise Timeout::Error, "IO timeout: #{options.inspect}"
+            value << read_nonblock(8196)
+          rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+            break
           end
         end
         value
       end
     end
 
+    def self.included(receiver)
+      receiver.send(:attr_accessor, :options, :server)
+      receiver.send(:include, InstanceMethods)
+    end
   end
-end
 
-begin
-  require 'em-synchrony'
-  puts "Defining alternate em-synchrony socket IO" if defined?($TESTING) && $TESTING
-
-  class Dalli::Server::AsyncSocket < EventMachine::Synchrony::TCPSocket
-    # XXX. need to somehow implement the timeout option.
-    # EM::Synchrony::TCPsocket does give you any timeouts. To implement it we'd have
-    # to change that class to take a timeout parameter that it would then set on
-    # the Deferrable objects it waits on.
-    attr_accessor :options
-
-    def self.open(host, port, options = {})
-      sock = new(host, port)
-      sock.options = { :host => host, :port => port }.merge(options)
-      sock
-    end
+  class Dalli::Server::KSocket::TCP < TCPSocket
+    extend Dalli::Server::TCPSocketOptions
+    include Dalli::Server::KSocket
 
-    def readfull(count)
-      value = ''
-      loop do
-        value << read(count - value.bytesize)
-        break if value.bytesize == count
+    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
       end
-      value
     end
-
   end
 
-rescue LoadError
-  puts "Could not define alternate em-synchrony socket IO" if defined?($TESTING) && $TESTING
-end
-
-require 'rbconfig'
-if RbConfig::CONFIG['host_os'] =~ /mingw|mswin/
-  class Dalli::Server::USocket
-    def initialize(*args)
-      raise Dalli::DalliError, "Unix sockets are not supported on Windows platform."
+  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."
+      end
     end
-  end
-else
-  class Dalli::Server::USocket < UNIXSocket
-    def readfull(count)
-      value = ''
-      loop do
-        value << read(count - value.bytesize)
-        break if value.bytesize == count
+  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
+        end
       end
-      value
     end
+
   end
 end

data/lib/dalli/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dalli
-  VERSION = '1.1.4'
+  VERSION = '2.7.11'
 end

data/lib/rack/session/dalli.rb

@@ -1,52 +1,186 @@
+# frozen_string_literal: true
 require 'rack/session/abstract/id'
 require 'dalli'
 
 module Rack
   module Session
-    class Dalli < Abstract::ID
-      attr_reader :pool
+    class Dalli < defined?(Abstract::Persisted) ? Abstract::Persisted : Abstract::ID
+      attr_reader :pool, :mutex
 
-      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
-        mserv = @default_options[:memcache_server]
-        mopts = @default_options.reject{|k,v| !DEFAULT_OPTIONS.include? k }
-        @pool = options[:cache] || Dalli::Client.new(mserv, mopts)
-      end
 
-      def generate_sid
-        loop do
-          sid = super
-          break sid unless @pool.get(sid)
+        # Determine the default TTL for newly-created sessions
+        @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
+
+          @pool.alive!
         end
       end
 
       def get_session(env, sid)
-        unless sid and session = @pool.get(sid)
-          sid, session = generate_sid, {}
-          unless @pool.add(sid, session)
-            raise "Session collision on '#{sid.inspect}'"
+        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), {}
+            unless dc.add(sid, session, @default_ttl)
+              sid = old_sid
+              redo # generate a new sid and try again
+            end
           end
+          [sid, session]
         end
-        [sid, session]
       end
 
       def set_session(env, session_id, new_session, options)
-        expiry = options[:expire_after]
-        expiry = expiry.nil? ? 0 : expiry + 1
+        return false unless session_id
 
-        @pool.set session_id, new_session, expiry
-        session_id
+        with_block(env, false) do |dc|
+          dc.set(session_id, new_session, ttl(options[:expire_after]))
+          session_id
+        end
       end
 
       def destroy_session(env, session_id, options)
-        @pool.delete(session_id)
-        generate_sid unless options[:drop]
+        with_block(env) 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 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
       end
 
+      private
+
+      def extract_dalli_options(options)
+        return [options[:cache]] 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 }
+        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
+        end
+
+        [nil, 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(env, default=nil, &block)
+        @mutex.lock if @mutex and env['rack.multithread']
+        @pool.with(&block)
+      rescue ::Dalli::DalliError, Errno::ECONNREFUSED
+        raise if $!.message =~ /undefined class/
+        if $VERBOSE
+          warn "#{self} is unable to find memcached server."
+          warn $!.inspect
+        end
+        default
+      ensure
+        @mutex.unlock if @mutex and @mutex.locked?
+      end
+
+      def ttl(expire_after)
+        expire_after.nil? ? 0 : expire_after + 1
+      end
     end
   end
 end