dalli 1.1.5 → 2.0.0

data/lib/dalli.rb

@@ -5,12 +5,6 @@ require 'dalli/socket'
 require 'dalli/version'
 require 'dalli/options'
 
-unless ''.respond_to?(:bytesize)
-  class String
-    alias_method :bytesize, :size
-  end
-end
-
 module Dalli
   # generic error
   class DalliError < RuntimeError; end

data/lib/dalli/client.rb

@@ -14,40 +14,20 @@ module Dalli
     # Note that the <tt>MEMCACHE_SERVERS</tt> environment variable will override the servers parameter for use
     # in managed environments like Heroku.
     #
-    # You can also provide a Unix socket as an argument, for example:
-    #
-    #   Dalli::Client.new("/tmp/memcached.sock")
-    #
-    # Initial testing shows that Unix sockets are about twice as fast as TCP sockets
-    # but Unix sockets only work on localhost.
-    #
     # Options:
+    # - :namespace - prepend each key with this value to provide simple namespacing.
     # - :failover - if a server is down, look for and store values on another server in the ring.  Default: true.
     # - :threadsafe - ensure that only one thread is actively using a socket at a time. Default: true.
     # - :expires_in - default TTL in seconds if you do not pass TTL as a parameter to an individual operation, defaults to 0 or forever
-    # - :compression - defaults to false, if true Dalli will compress values larger than 100 bytes before
+    # - :compress - defaults to false, if true Dalli will compress values larger than 100 bytes before
     #   sending them to memcached.
-    # - :async - assume its running inside the EM reactor. Requires em-synchrony to be installed. Default: false.
     #
     def initialize(servers=nil, options={})
       @servers = env_servers || servers || '127.0.0.1:11211'
-      @options = { :expires_in => 0 }.merge(options)
-      self.extend(Dalli::Client::MemcacheClientCompatibility) if Dalli::Client.compatibility_mode
+      @options = normalize_options(options)
       @ring = nil
     end
 
-    ##
-    # Turn on compatibility mode, which mixes in methods in memcache_client_compatibility.rb
-    # This value is set to true in memcache-client.rb.
-    def self.compatibility_mode
-      @compatibility_mode ||= false
-    end
-
-    def self.compatibility_mode=(compatibility_mode)
-      require 'dalli/compatibility'
-      @compatibility_mode = compatibility_mode
-    end
-
     #
     # The standard memcached instruction set
     #
@@ -178,7 +158,6 @@ module Dalli
       ring.servers.map { |s| s.request(:flush, time += delay) }
     end
 
-    # deprecated, please use #flush.
     alias_method :flush_all, :flush
 
     ##
@@ -229,6 +208,14 @@ module Dalli
       values
     end
 
+    ##
+    # Reset stats for each server.
+    def reset_stats
+      ring.servers.map do |server|
+        server.alive? ? server.request(:reset_stats) : nil
+      end
+    end
+
     ##
     # Close our connection to each server.
     # If you perform another operation after this, the connections will be re-established.
@@ -270,10 +257,9 @@ module Dalli
     end
 
     def validate_key(key)
+      raise ArgumentError, "key cannot be blank" if !key || key.length == 0
       raise ArgumentError, "illegal character in key #{key}" if key.respond_to?(:ascii_only?) && !key.ascii_only?
-      raise ArgumentError, "illegal character in key #{key}" if key =~ /\s/
-      raise ArgumentError, "illegal character in key #{key}" if key =~ /[\x00-\x20\x80-\xFF]/
-      raise ArgumentError, "key cannot be blank" if key.nil? || key.strip.size == 0
+      raise ArgumentError, "illegal character in key #{key}" if key =~ /[\x00-\x20\x7F-\xFF]/
       raise ArgumentError, "key too long #{key.inspect}" if key.length > 250
     end
 
@@ -282,7 +268,16 @@ module Dalli
     end
 
     def key_without_namespace(key)
-      @options[:namespace] ? key.gsub(%r(\A#{@options[:namespace]}:), '') : key
+      @options[:namespace] ? key.sub(%r(\A#{@options[:namespace]}:), '') : key
+    end
+
+    def normalize_options(opts)
+      if opts[:compression]
+        Dalli.logger.warn "DEPRECATED: Dalli's :compression option is now just :compress => true.  Please update your configuration."
+        opts[:compress] = opts.delete(:compression)
+      end
+      opts[:expires_in] ||= 0
+      opts
     end
   end
 end

data/lib/dalli/server.rb

@@ -22,7 +22,7 @@ module Dalli
       :value_max_bytes => 1024 * 1024,
       :username => nil,
       :password => nil,
-      :async => false,
+      :keepalive => true
     }
 
     def initialize(attribs, options = {})
@@ -92,10 +92,6 @@ module Dalli
 
     private
 
-    def is_unix_socket?(string)
-      !!(/^\/(.+)$/ =~ string)
-    end
-
     def failure!
       Dalli.logger.info { "#{hostname}:#{port} failed (count: #{@fail_count})" }
 
@@ -238,6 +234,12 @@ module Dalli
       keyvalue_response
     end
 
+    def reset_stats
+      req = [REQUEST, OPCODES[:stat], 'reset'.bytesize, 0, 0, 0, 'reset'.bytesize, 0, 0, 'reset'].pack(FORMAT[:stat])
+      write(req)
+      generic_response
+    end
+
     def cas(key)
       req = [REQUEST, OPCODES[:get], key.bytesize, 0, 0, 0, key.bytesize, 0, 0, key].pack(FORMAT[:get])
       write(req)
@@ -275,7 +277,7 @@ module Dalli
         value.to_s
       end
       compressed = false
-      if @options[:compression] && value.bytesize >= COMPRESSION_MIN_SIZE
+      if @options[:compress] && value.bytesize >= COMPRESSION_MIN_SIZE
         value = Zlib::Deflate.deflate(value)
         compressed = true
       end
@@ -386,14 +388,7 @@ module Dalli
       Dalli.logger.debug { "Dalli::Server#connect #{hostname}:#{port}" }
 
       begin
-        if @hostname =~ /^\//
-          @sock = USocket.new(hostname)
-        elsif options[:async]
-          raise Dalli::DalliError, "EM support not enabled, as em-synchrony is not installed." if not defined?(AsyncSocket)
-          @sock = AsyncSocket.open(hostname, port, :timeout => options[:socket_timeout])
-        else
-          @sock = KSocket.open(hostname, port, :timeout => options[:socket_timeout])
-        end
+        @sock = KSocket.open(hostname, port, options)
         @version = version # trigger actual connect
         sasl_authentication if need_auth?
         up!

data/lib/dalli/socket.rb

@@ -6,16 +6,17 @@ begin
     attr_accessor :options
 
     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")
+      IO.select(nil, [self], nil, options[:socket_timeout]) || raise(Timeout::Error, "IO timeout")
     end
 
     def self.open(host, port, options = {})
       addr = Socket.pack_sockaddr_in(port, host)
       sock = start(addr)
+      sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true) if options[:keepalive]
       sock.options = options
       sock.kgio_wait_writable
       sock
@@ -34,8 +35,6 @@ begin
 
   end
 
-
-
   if ::Kgio.respond_to?(:wait_readable=)
     ::Kgio.wait_readable = :kgio_wait_readable
     ::Kgio.wait_writable = :kgio_wait_writable
@@ -44,127 +43,34 @@ 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
+  class Dalli::Server::KSocket < TCPSocket
+    attr_accessor :options
 
-      def self.open(host, port, options = {})
+    def self.open(host, port, options = {})
+      Timeout.timeout(options[:socket_timeout]) do
         sock = new(host, port)
+        sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true) if options[:keepalive]
         sock.options = { :host => host, :port => port }.merge(options)
         sock
       end
-
-      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[:timeout])
-            retry
-          else
-            raise Timeout::Error, "IO timeout: #{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])
-          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}"
-          end
-        end
-        value
-      end
-    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
 
     def readfull(count)
       value = ''
-      loop do
-        value << read(count - value.bytesize)
-        break if value.bytesize == count
+      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}"
+        end
       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."
-    end
-  end
-else
-  class Dalli::Server::USocket < UNIXSocket
-    def readfull(count)
-      value = ''
-      loop do
-        value << read(count - value.bytesize)
-        break if value.bytesize == count
-      end
-      value
-    end
-  end
 end

data/lib/dalli/version.rb

@@ -1,3 +1,3 @@
 module Dalli
-  VERSION = '1.1.5'
+  VERSION = '2.0.0'
 end

data/test/helper.rb

@@ -7,7 +7,6 @@ gem 'rails', WANT_RAILS_VERSION
 require 'rails'
 puts "Testing with Rails #{Rails.version}"
 
-require 'minitest/spec'
 require 'mini_shoulda'
 require 'minitest/pride'
 require 'minitest/autorun'

data/test/memcached_mock.rb

@@ -15,10 +15,6 @@ module MemcachedMock
     block.call server
   end
 
-  def self.tmp_socket_path
-    "#{Dir.pwd}/tmp.sock"
-  end
-
   module Helper
     # Forks the current process and starts a new mock Memcached server on
     # port 22122.
@@ -71,14 +67,9 @@ module MemcachedMock
     end
 
     def memcached(port=19122, args='', options={})
-      return unless supports_fork?
       Memcached.path ||= find_memcached
 
-      cmd = if options[:unix]
-        "#{Memcached.path}memcached #{args} -s #{MemcachedMock.tmp_socket_path}"
-      else
-        "#{Memcached.path}memcached #{args} -p #{port}"
-      end
+      cmd = "#{Memcached.path}memcached #{args} -p #{port}"
 
       $started[port] ||= begin
         #puts "Starting: #{cmd}..."
@@ -94,11 +85,7 @@ module MemcachedMock
         sleep 0.1
         pid
       end
-      if options[:unix]
-        yield Dalli::Client.new(MemcachedMock.tmp_socket_path)
-      else
-        yield Dalli::Client.new(["localhost:#{port}", "127.0.0.1:#{port}"], options)
-      end
+      yield Dalli::Client.new(["localhost:#{port}", "127.0.0.1:#{port}"], options)
     end
 
     def supports_fork?

data/test/test_active_support.rb

@@ -8,21 +8,15 @@ describe 'ActiveSupport' do
       with_activesupport do
         memcached do
           connect
-          mvalue = @mc.fetch('somekeywithoutspaces', :expires_in => 1.second) { 123 }
           dvalue = @dalli.fetch('someotherkeywithoutspaces', :expires_in => 1.second) { 123 }
           assert_equal 123, dvalue
-          assert_equal mvalue, dvalue
 
           o = Object.new
           o.instance_variable_set :@foo, 'bar'
-          mvalue = @mc.fetch(rand_key, :raw => true) { o }
           dvalue = @dalli.fetch(rand_key, :raw => true) { o }
-          assert_equal mvalue, dvalue
-          assert_equal o, mvalue
+          assert_equal o, dvalue
 
-          mvalue = @mc.fetch(rand_key) { o }
           dvalue = @dalli.fetch(rand_key) { o }
-          assert_equal mvalue, dvalue
           assert_equal o, dvalue
         end
       end
@@ -32,9 +26,8 @@ describe 'ActiveSupport' do
       with_activesupport do
         memcached do
           connect
-          dvalue = @mc.fetch('some key with spaces', :expires_in => 1.second) { 123 }
-          mvalue = @dalli.fetch('some other key with spaces', :expires_in => 1.second) { 123 }
-          assert_equal mvalue, dvalue
+          dvalue = @dalli.fetch('some key with spaces', :expires_in => 1.second) { 123 }
+          assert_equal 123, dvalue
         end
       end
     end
@@ -45,14 +38,10 @@ describe 'ActiveSupport' do
           connect
           x = rand_key
           y = rand_key
-          assert_equal({}, @mc.read_multi(x, y))
           assert_equal({}, @dalli.read_multi(x, y))
           @dalli.write(x, '123')
           @dalli.write(y, 123)
-          @mc.write(x, '123')
-          @mc.write(y, 123)
           assert_equal({ x => '123', y => 123 }, @dalli.read_multi(x, y))
-          assert_equal({ x => '123', y => 123 }, @mc.read_multi(x, y))
         end
       end
     end
@@ -63,14 +52,10 @@ describe 'ActiveSupport' do
           connect
           x = rand_key
           y = rand_key
-          assert_equal({}, @mc.read_multi([x, y]))
           assert_equal({}, @dalli.read_multi([x, y]))
           @dalli.write(x, '123')
           @dalli.write(y, 123)
-          @mc.write(x, '123')
-          @mc.write(y, 123)
           assert_equal({ x => '123', y => 123 }, @dalli.read_multi([x, y]))
-          assert_equal({}, @mc.read_multi([x,y]))
         end
       end
     end
@@ -79,10 +64,6 @@ describe 'ActiveSupport' do
       with_activesupport do
         memcached do
           connect
-          @mc.write("abc", 5, :raw => true)
-          @mc.write("cba", 5, :raw => true)
-          assert_equal({'abc' => '5', 'cba' => '5' }, @mc.read_multi("abc", "cba"))
-
           @dalli.write("abc", 5, :raw => true)
           @dalli.write("cba", 5, :raw => true)
           assert_equal({'abc' => '5', 'cba' => '5' }, @dalli.read_multi("abc", "cba"))
@@ -96,20 +77,14 @@ describe 'ActiveSupport' do
           connect
           x = rand_key
           y = rand_key
-          assert_nil @mc.read(x)
           assert_nil @dalli.read(y)
-          mres = @mc.write(x, 123)
           dres = @dalli.write(y, 123)
-          assert_equal mres, dres
+          assert_equal true, dres
 
-          mres = @mc.read(x)
           dres = @dalli.read(y)
-          assert_equal mres, dres
           assert_equal 123, dres
 
-          mres = @mc.delete(x)
           dres = @dalli.delete(y)
-          assert_equal mres, dres
           assert_equal true, dres
         end
       end
@@ -119,22 +94,12 @@ describe 'ActiveSupport' do
       with_activesupport do
         memcached do
           connect
-          assert_equal true, @mc.write('counter', 0, :raw => true)
-          assert_equal 1, @mc.increment('counter')
-          assert_equal 2, @mc.increment('counter')
-          assert_equal 1, @mc.decrement('counter')
-          assert_equal "1", @mc.read('counter', :raw => true)
-
           assert_equal true, @dalli.write('counter', 0, :raw => true)
           assert_equal 1, @dalli.increment('counter')
           assert_equal 2, @dalli.increment('counter')
           assert_equal 1, @dalli.decrement('counter')
           assert_equal "1", @dalli.read('counter', :raw => true)
 
-          assert_equal 0, @mc.increment('counterX')
-          assert_equal 0, @mc.increment('counterX')
-          assert_equal nil, @mc.read('counterX')
-
           assert_equal 1, @dalli.increment('counterX')
           assert_equal 2, @dalli.increment('counterX')
           assert_equal 2, @dalli.read('counterX', :raw => true).to_i
@@ -146,18 +111,12 @@ describe 'ActiveSupport' do
       with_activesupport do
         memcached do
           connect
-          ms = @mc.stats
           ds = @dalli.stats
-          assert_equal ms.keys.sort, ds.keys.sort
-          assert_equal ms[ms.keys.first].keys.sort, ds[ds.keys.first].keys.sort
+          assert_equal 1, ds.keys.size
+          assert ds[ds.keys.first].keys.size > 0
 
           assert_equal true, @dalli.write(:foo, 'a')
-          assert_equal true, @mc.write(:foo, 'a')
-
-          assert_equal true, @mc.exist?(:foo)
           assert_equal true, @dalli.exist?(:foo)
-
-          assert_equal false, @mc.exist?(:bar)
           assert_equal false, @dalli.exist?(:bar)
 
           @dalli.reset
@@ -172,9 +131,7 @@ describe 'ActiveSupport' do
         connect
         key = "fooƒ"
         value = 'bafƒ'
-#        assert_equal true, @mc.write(key, value)
         assert_equal true, @dalli.write(key, value)
-#        assert_equal true, @mc.read(key, value)
         assert_equal value, @dalli.read(key)
       end
     end
@@ -183,15 +140,15 @@ describe 'ActiveSupport' do
   should 'normalize options as expected' do
     with_activesupport do
       memcached do
-        @dalli = ActiveSupport::Cache::DalliStore.new('localhost:19122', :expires_in => 1, :race_condition_ttl => 1)
-        assert_equal 2, @dalli.instance_variable_get(:@data).instance_variable_get(:@options)[:expires_in]
+        @dalli = ActiveSupport::Cache::DalliStore.new('localhost:19122', :expires_in => 1, :namespace => 'foo', :compress => true)
+        assert_equal 1, @dalli.instance_variable_get(:@data).instance_variable_get(:@options)[:expires_in]
+        assert_equal 'foo', @dalli.instance_variable_get(:@data).instance_variable_get(:@options)[:namespace]
       end
     end
   end
 
   def connect
     @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:19122', :expires_in => 10.seconds, :namespace => 'x')
-    @mc = ActiveSupport::Cache.lookup_store(:mem_cache_store, 'localhost:19122', :expires_in => 10.seconds, :namespace => 'a')
     @dalli.clear
   end