#2867682; Added cache key normalizer.

Author: kalpaitch

src/DrupalMemcacheBase.php

@@ -14,6 +14,8 @@
  */
 abstract class DrupalMemcacheBase implements DrupalMemcacheInterface {
 
+  use MemcacheCacheNormalizer;
+
   /**
    * The memcache config object.
    *
@@ -79,17 +81,7 @@ public function get($key) {
    * {@inheritdoc}
    */
   public function key($key) {
-    $full_key = urlencode($this->prefix . '-' . $key);
-
-    // Memcache only supports key lengths up to 250 bytes.  If we have generated
-    // a longer key, we shrink it to an acceptable length with a configurable
-    // hashing algorithm. Sha1 was selected as the default as it performs
-    // quickly with minimal collisions.
-    if (strlen($full_key) > 250) {
-      $full_key = urlencode(hash($this->hashAlgorithm, $this->prefix . '-' . $key));
-    }
-
-    return $full_key;
+    return $this->normalizeKey($this->prefix . '-' . $key);
   }
 
   /**

src/MemcacheBackend.php

@@ -7,7 +7,7 @@
 
 namespace Drupal\memcache;
 
-use Drupal\Component\Utility\Crypt;
+use Drupal\Core\Cache\Cache;
 use Drupal\Core\Cache\CacheBackendInterface;
 use Drupal\Core\Cache\CacheTagsChecksumInterface;
 use Drupal\Core\Lock\LockBackendInterface;
@@ -17,6 +17,8 @@
  */
 class MemcacheBackend implements CacheBackendInterface {
 
+  use MemcacheCacheNormalizer;
+
   /**
    * The cache bin to use.
    *
@@ -245,7 +247,7 @@ public function deleteAll() {
    * {@inheritdoc}
    */
   public function invalidate($cid) {
-    $this->invalidateMultiple([$cid]);
+    $this->invalidateMultiple((array) $cid);
   }
 
   /**
@@ -257,10 +259,10 @@ public function invalidate($cid) {
    * @param array $cids
    *   An array of cache IDs to invalidate.
    *
-   * @see \Drupal\Core\Cache\CacheBackendInterface::deleteMultiple()
-   * @see \Drupal\Core\Cache\CacheBackendInterface::invalidate()
-   * @see \Drupal\Core\Cache\CacheBackendInterface::invalidateTags()
-   * @see \Drupal\Core\Cache\CacheBackendInterface::invalidateAll()
+   * @see Drupal\Core\Cache\CacheBackendInterface::deleteMultiple()
+   * @see Drupal\Core\Cache\CacheBackendInterface::invalidate()
+   * @see Drupal\Core\Cache\CacheBackendInterface::invalidateTags()
+   * @see Drupal\Core\Cache\CacheBackendInterface::invalidateAll()
    */
   public function invalidateMultiple(array $cids) {
     foreach ($cids as $cid) {
@@ -308,32 +310,6 @@ public function isEmpty() {
     return TRUE;
   }
 
-  /**
-   * Normalizes a cache ID in order to comply with database limitations.
-   *
-   * The lock still uses the database so must comply with limitations.
-   *
-   * @param string $cid
-   *   The passed in cache ID.
-   *
-   * @return string
-   *   An ASCII-encoded cache ID that is at most 255 characters long.
-   */
-  protected function normalizeCid($cid) {
-    // Nothing to do if the ID is a US ASCII string of 255 characters or less.
-    $cid_is_ascii = mb_check_encoding($cid, 'ASCII');
-    if (strlen($cid) <= 255 && $cid_is_ascii) {
-      return $cid;
-    }
-    // Return a string that uses as much as possible of the original cache ID
-    // with the hash appended.
-    $hash = Crypt::hashBase64($cid);
-    if (!$cid_is_ascii) {
-      return $hash;
-    }
-    return substr($cid, 0, 255 - strlen($hash)) . $hash;
-  }
-
   /**
    * Returns a cache key prefixed with the current bin.
    *
@@ -342,7 +318,7 @@ protected function normalizeCid($cid) {
    * @return string
    */
   protected function key($cid) {
-    return $this->normalizeCid($this->bin . '-' . $cid);
+    return $this->normalizeKey($this->bin . '-' . $cid);
   }
 
 }

src/MemcacheCacheNormalizer.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Drupal\memcache;
+
+/**
+ * Class MemcacheCacheNormalizer.
+ */
+trait MemcacheCacheNormalizer {
+
+  /**
+   * Normalizes a cache ID in order to comply with key length limitations.
+   *
+   * @param string $key
+   *   The passed in cache ID.
+   *
+   * @return string
+   *   An ASCII-encoded cache ID that is at most 250 characters long.
+   */
+  protected function normalizeKey($key) {
+    $key = urlencode($key);
+    // Nothing to do if the ID is a US ASCII string of 250 characters or less.
+    $key_is_ascii = mb_check_encoding($key, 'ASCII');
+    if (strlen($key) <= 250 && $key_is_ascii) {
+      return $key;
+    }
+    // Memcache only supports key lengths up to 250 bytes.  If we have generated
+    // a longer key, we shrink it to an acceptable length with a configurable
+    // hashing algorithm. Sha1 was selected as the default as it performs
+    // quickly with minimal collisions.
+    // Return a string that uses as much as possible of the original cache ID
+    // with the hash appended.
+    $hash = hash($this->hashAlgorithm, $this->prefix . '-' . $key);
+    if (!$key_is_ascii) {
+      return $hash;
+    }
+    return substr($key, 0, 250 - strlen($hash)) . $hash;
+  }
+
+}