vinted-memcached 1.8.3 → 1.8.5

data/lib/memcached/exceptions.rb

@@ -1,4 +1,3 @@
-
 class Memcached
 
 =begin rdoc
@@ -46,17 +45,7 @@ Subclasses correspond one-to-one with server response strings or libmemcached er
 * Memcached::WriteFailure
 
 =end
-  class Error < RuntimeError
-    attr_accessor :no_backtrace
-
-    def set_backtrace(*args)
-      @no_backtrace ? [] : super
-    end
-
-    def backtrace(*args)
-      @no_backtrace ? [] : super
-    end
-  end
+  Error = Class.new(RuntimeError)
 
 #:stopdoc:
 

data/lib/memcached/experimental.rb

@@ -1,6 +1,5 @@
 class Memcached
   module Experimental
-
     # TOUCH is used to set a new expiration time for an existing item
     def touch(key, ttl=@default_ttl)
       check_return_code(
@@ -9,40 +8,9 @@ class Memcached
       )
     rescue => e
       tries ||= 0
-      raise unless tries < options[:exception_retry_limit] && should_retry(e)
+      raise unless should_retry(e, tries)
       tries += 1
       retry
     end
-
-    def get_len(bytes, keys)
-      if keys.is_a? ::Array
-        # Multi get
-        ret = Lib.memcached_mget_len(@struct, keys, bytes);
-        check_return_code(ret, keys)
-
-        hash = {}
-        keys.each do
-          value, key, flags, ret = Lib.memcached_fetch_rvalue(@struct)
-          break if ret == Lib::MEMCACHED_END
-          if ret != Lib::MEMCACHED_NOTFOUND
-            check_return_code(ret, key)
-            # Assign the value
-            hash[key] = value
-          end
-        end
-        hash
-      else
-        # Single get_len
-        value, flags, ret = Lib.memcached_get_len_rvalue(@struct, keys, bytes)
-        check_return_code(ret, keys)
-        value
-      end
-    rescue => e
-      tries ||= 0
-      raise unless tries < options[:exception_retry_limit] && should_retry(e)
-      tries += 1
-      retry
-    end
-
   end
 end

data/lib/memcached/memcached.rb

@@ -3,6 +3,7 @@ The Memcached client class.
 =end
 class Memcached
   FLAGS = 0x0
+  EMPTY_ARRAY = [].freeze
 
   DEFAULTS = {
     :hash => :fnv1_32,
@@ -174,17 +175,7 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
     set_servers(servers)
 
     # Not found exceptions
-    if options[:show_backtraces]
-      # Raise classes for full context
-      @not_found = NotFound
-      @not_stored = NotStored
-    else
-      # Raise fast context-free exception instances
-      @not_found = NotFound.new
-      @not_found.no_backtrace = true
-      @not_stored = NotStored.new
-      @not_stored.no_backtrace = true
-    end
+    @show_backtraces = options[:show_backtraces] ? nil : EMPTY_ARRAY
   end
 
   # Set the server list.
@@ -197,7 +188,7 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
           args = [@struct, server, options[:default_weight].to_i]
           Lib.memcached_server_add_unix_socket_with_weight(*args)
         # Network
-        elsif server.is_a?(String) and server =~ /^[\w\d\.-]+(:\d{1,5}){0,2}$/
+        elsif server.is_a?(String) and server =~ /^[\w\.-]+(:\d{1,5}){0,2}$/
           host, port, weight = server.split(":")
           args = [@struct, host, port.to_i, (weight || options[:default_weight]).to_i]
           if options[:use_udp]
@@ -206,7 +197,11 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
             Lib.memcached_server_add_with_weight(*args)
           end
         else
-          raise ArgumentError, "Servers must be either in the format 'host:port[:weight]' (e.g., 'localhost:11211' or  'localhost:11211:10') for a network server, or a valid path to a Unix domain socket (e.g., /var/run/memcached)."
+          raise ArgumentError, <<-MSG
+Servers must be either in the format 'host:port[:weight]' (e.g., 'localhost:11211' or 'localhost:11211:10')
+for a network server, or a valid path to a Unix domain socket (e.g., /var/run/memcached).
+But it was #{server}.
+          MSG
         end
       )
     end
@@ -277,8 +272,14 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
   end
 
   # Should retry the exception
-  def should_retry(e)
-    options[:exceptions_to_retry].each {|ex_class| return true if e.instance_of?(ex_class)}
+  def should_retry(exception, tries)
+    return false unless options[:exception_retry_limit]
+    return false unless tries < options[:exception_retry_limit]
+
+    options[:exceptions_to_retry].each do |ex_class|
+      return true if exception.instance_of?(ex_class)
+    end
+
     false
   end
 
@@ -322,8 +323,7 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
       )
     rescue => e
       tries ||= 0
-      retry if e.instance_of?(ClientError) && !tries
-      raise unless tries < options[:exception_retry_limit] && should_retry(e)
+      raise unless should_retry(e, tries)
       tries += 1
       retry
     end
@@ -339,7 +339,7 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
       )
     rescue => e
       tries ||= 0
-      raise unless tries < options[:exception_retry_limit] && should_retry(e)
+      raise unless should_retry(e, tries)
       tries += 1
       retry
     end
@@ -356,7 +356,7 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
     value
   rescue => e
     tries ||= 0
-    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    raise unless should_retry(e, tries)
     tries += 1
     retry
   end
@@ -368,7 +368,7 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
     value
   rescue => e
     tries ||= 0
-    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    raise unless should_retry(e, tries)
     tries += 1
     retry
   end
@@ -388,7 +388,7 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
       )
     rescue => e
       tries ||= 0
-      raise unless tries < options[:exception_retry_limit] && should_retry(e)
+      raise unless should_retry(e, tries)
       tries += 1
       retry
     end
@@ -405,7 +405,7 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
     )
   rescue => e
     tries ||= 0
-    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    raise unless should_retry(e, tries)
     tries += 1
     retry
   end
@@ -419,7 +419,7 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
     )
   rescue => e
     tries ||= 0
-    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    raise unless should_retry(e, tries)
     tries += 1
     retry
   end
@@ -451,7 +451,7 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
       single_cas(keys, value, ttl, flags, cas, decode)
     end
   rescue => e
-    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    raise unless should_retry(e, tries)
     tries += 1
     retry
   end
@@ -468,7 +468,7 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
     )
   rescue => e
     tries ||= 0
-    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    raise unless should_retry(e, tries)
     tries += 1
     retry
   end
@@ -480,7 +480,7 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
     )
   rescue => e
     tries ||= 0
-    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    raise unless should_retry(e, tries)
     tries += 1
     retry
   end
@@ -505,7 +505,7 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
     end
   rescue => e
     tries ||= 0
-    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    raise unless should_retry(e, tries)
     tries += 1
     retry
   end
@@ -521,6 +521,7 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
 
   # Gets a key's value from the previous server. Only useful with random distribution.
   def get_from_last(key, decode=true)
+    warn("Memcached#get_from_last is deprecated and was removed in newer versions of libmemcached")
     raise ArgumentError, "get_from_last() is not useful unless :random distribution is enabled." unless options[:distribution] == :random
     value, flags, ret = Lib.memcached_get_from_last_rvalue(@struct, key)
     check_return_code(ret, key)
@@ -587,9 +588,9 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
     if ret == 0 # Lib::MEMCACHED_SUCCESS
     elsif ret == 32 # Lib::MEMCACHED_BUFFERED
     elsif ret == 16
-      raise @not_found # Lib::MEMCACHED_NOTFOUND
+      raise NotFound, "NOTFOUND".freeze, @show_backtraces, cause: nil # Lib::MEMCACHED_NOTFOUND
     elsif ret == 14
-      raise @not_stored # Lib::MEMCACHED_NOTSTORED
+      raise NotStored, "NOTSTORED".freeze, @show_backtraces, cause: nil # Lib::MEMCACHED_NOTSTORED
     else
       reraise(key, ret)
     end
@@ -630,8 +631,8 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
   # FIXME Is this still necessary with cached_errno?
   def detect_failure
     time = Time.now
-    server = server_structs.detect do |server|
-      server.next_retry > time
+    server = server_structs.detect do |server_struct|
+      server_struct.next_retry > time
     end
     inspect_server(server) if server
   end
@@ -645,6 +646,12 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
     set_behavior(:hash, options[:hash])
   end
 
+  def destroy_credentials
+    if options[:credentials] != nil
+      check_return_code(Lib.memcached_destroy_sasl_auth_data(@struct))
+    end
+  end
+
   # Set the SASL credentials from the current options. If credentials aren't provided, try to get them from the environment.
   def set_credentials
     if options[:credentials]
@@ -693,8 +700,8 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
       value, key, flags, ret = Lib.memcached_fetch_rvalue(@struct)
     end
     if decode
-      hash.each do |key, value_and_flags|
-        hash[key] = @codec.decode(key, *value_and_flags)
+      hash.each do |inner_key, value_and_flags|
+        hash[inner_key] = @codec.decode(inner_key, *value_and_flags)
       end
     end
     [hash, flags_and_cas]
@@ -714,7 +721,7 @@ Please note that when <tt>:no_block => true</tt>, update methods do not raise on
           check_return_code(ret, key)
         end
       rescue => e
-        raise unless tries < options[:exception_retry_limit] && should_retry(e)
+        raise unless should_retry(e, tries)
         tries += 1
         retry
       end

data/lib/memcached/version.rb

@@ -1,3 +1,3 @@
 class Memcached
-  VERSION = '1.8.3'
+  VERSION = '1.8.5'
 end

data/lib/memcached.rb

@@ -21,13 +21,18 @@ require 'rlibmemcached'
 class Memcached
   Lib = Rlibmemcached
   raise "libmemcached 0.32 required; you somehow linked to #{Lib.memcached_lib_version}." unless "0.32" == Lib.memcached_lib_version
+  private_constant :Lib
+
+  VERSION = File.read("#{File.dirname(__FILE__)}/../CHANGELOG")[/v([\d\.]+)\./, 1]
+
+  autoload :Rails, 'memcached/rails'
+  deprecate_constant :Rails
+  autoload :Experimental, 'memcached/experimental'
 end
 
+Object.deprecate_constant :Rlibmemcached
+
 require 'memcached/exceptions'
 require 'memcached/behaviors'
-require 'memcached/auth'
 require 'memcached/marshal_codec'
 require 'memcached/memcached'
-require 'memcached/rails'
-require 'memcached/experimental'
-require 'memcached/version'

data/memcached.pem

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDaDCCAlCgAwIBAgIBATANBgkqhkiG9w0BAQUFADA9MQ0wCwYDVQQDDARldmFu
+MRgwFgYKCZImiZPyLGQBGRYIY2xvdWRidXIxEjAQBgoJkiaJk/IsZAEZFgJzdDAe
+Fw0xMzExMDQyMDI1MDVaFw0xNDExMDQyMDI1MDVaMD0xDTALBgNVBAMMBGV2YW4x
+GDAWBgoJkiaJk/IsZAEZFghjbG91ZGJ1cjESMBAGCgmSJomT8ixkARkWAnN0MIIB
+IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuG4q2IdTtlc7/IJkWPnbOAFt
+ysKc3XmLHsjeSXXSPdQ1mb2cDXvyDS8TkzjrgDoJ96RR2xrh7bfkHAMJhSVMhsPM
+rnYS7fDs//X1h6fRYBjjhqGeQhCL1xrS5/I4vKb7AjgFnuUbMZ/H0+ic2Ic2zTnZ
+jttSQZ/QOlYyctrYoTzAFdPwL+dOxskOyAmAbtV/pV3owcXpChRT/tphC7u69sOk
++IjWsMwrBCbEdj/Jmh4a52QntAwPWx4Krt0zm8eV3/UjSObB3BR1pZ/i5IsSLPs1
+lwMA6ywbfxBTP59XcgAyhfV3rRQXb+vjpf7OLuOCJOUIN8GEwb5HNjFo/UVdiwID
+AQABo3MwcTAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQUbTCqyydn
+0Rm6nngf15KtCEMc37swGwYDVR0RBBQwEoEQZXZhbkBjbG91ZGJ1ci5zdDAbBgNV
+HRIEFDASgRBldmFuQGNsb3VkYnVyLnN0MA0GCSqGSIb3DQEBBQUAA4IBAQBggGGb
+0AoyF0QofzkPImuhN1UF6eG/RdYOHqiUovuRN/9IblyKAaZAIl1mIspfCav8EVwo
+SC6vz4OaIVpS7QdI04oLNHxhmC6C5TTBONtddDl93M+9uWVipD5uVPktcHWG+bKn
+2L1lUykQXr8ra45TqAUZ/P+Yv76U8kUsVG2HE5gl/CgB5+V1qkpn5M4CADsvSvPA
+qEATZvw+KUzzMCUiVzq+T6lDrrCt+sD3NZlvG4BD2PpQuPtDf1i61DUc+5s2Nwm2
+t4uqNF7swBWS0n40/hmn5u8pT2JVsuwam79GGhJmNfCdPCcCbgphroexRcrwdURX
+ly00Xdf1gDVBxRoR
+-----END CERTIFICATE-----

data/{ext → vendor}/libmemcached-0.32/libmemcached/memcached_connect.c

@@ -248,22 +248,32 @@ static memcached_return network_connect(memcached_server_st *ptr)
           struct pollfd fds[1];
           fds[0].fd = ptr->fd;
           fds[0].events = POLLOUT;
-          int error= poll(fds, 1, ptr->root->connect_timeout);
-
-          if (error != 1 || fds[0].revents & POLLERR)
+          while (1)
           {
-            ptr->cached_errno = 0;
-
-            if (fds[0].revents & POLLERR)
+            int error= poll(fds, 1, ptr->root->connect_timeout);
+            if (error < 0 && errno == EINTR)
             {
-              int err;
-              socklen_t len = sizeof (err);
-              (void)getsockopt(ptr->fd, SOL_SOCKET, SO_ERROR, &err, &len);
-              ptr->cached_errno= (err == 0) ? errno : err;
+              /* retry */
+            }
+            else
+            {
+              if (error != 1 || fds[0].revents & POLLERR)
+              {
+                ptr->cached_errno = 0;
+
+                if (fds[0].revents & POLLERR)
+                {
+                  int err;
+                  socklen_t len = sizeof (err);
+                  (void)getsockopt(ptr->fd, SOL_SOCKET, SO_ERROR, &err, &len);
+                  ptr->cached_errno= (err == 0) ? errno : err;
+                }
+
+                (void)close(ptr->fd);
+                ptr->fd= -1;
+              }
+              break;
             }
-
-            (void)close(ptr->fd);
-            ptr->fd= -1;
           }
         } 
         else if (errno == EISCONN) /* we are connected :-) */

data/{ext → vendor}/libmemcached-0.32/libmemcached/memcached_io.c

@@ -46,21 +46,24 @@ static memcached_return io_wait(memcached_server_st *ptr,
        return MEMCACHED_FAILURE;
   }
 
-  error= poll(fds, 1, ptr->root->poll_timeout);
-
-  if (error == 1)
-    return MEMCACHED_SUCCESS;
-  else if (error == 0)
+  while(1)
   {
-    return MEMCACHED_TIMEOUT;
-  }
-
-  /* Imposssible for anything other then -1 */
-  WATCHPOINT_ASSERT(error == -1);
-  memcached_quit_server(ptr, 1);
+    error= poll(fds, 1, ptr->root->poll_timeout);
+    if (error == 1)
+      return MEMCACHED_SUCCESS;
+    else if (error == 0)
+    {
+      return MEMCACHED_TIMEOUT;
+    }
 
-  return MEMCACHED_FAILURE;
+    if (errno != EINTR) {
+      /* Imposssible for anything other then -1 */
+      WATCHPOINT_ASSERT(error == -1);
+      memcached_quit_server(ptr, 1);
 
+      return MEMCACHED_FAILURE;
+    }
+  }
 }
 
 #ifdef UNUSED
@@ -115,8 +118,9 @@ memcached_return memcached_io_read(memcached_server_st *ptr,
           rc= MEMCACHED_UNKNOWN_READ_FAILURE;
           switch (errno)
           {
-          case EAGAIN:
           case EINTR:
+            continue;
+          case EAGAIN:
             if ((rc= io_wait(ptr, MEM_READ)) == MEMCACHED_SUCCESS)
               continue;
           /* fall through */
@@ -422,6 +426,7 @@ static ssize_t io_flush(memcached_server_st *ptr,
       case ENOBUFS:
         continue;
       case EAGAIN:
+      case EINTR:
       {
         memcached_return rc;
         rc= io_wait(ptr, MEM_WRITE);

data/{ext → vendor}/libmemcached-0.32/libmemcached/memcached_purge.c

@@ -10,7 +10,7 @@ memcached_return memcached_purge(memcached_server_st *ptr)
   if (ptr->root->purging || /* already purging */
       (memcached_server_response_count(ptr) < ptr->root->io_msg_watermark &&
       ptr->io_bytes_sent < ptr->root->io_bytes_watermark) ||
-      (ptr->io_bytes_sent >= ptr->root->io_bytes_watermark &&
+      (ptr->io_bytes_sent > ptr->root->io_bytes_watermark &&
       memcached_server_response_count(ptr) < 2))
   {
     return MEMCACHED_SUCCESS;