Merge lp:~ricin/play/ricin into lp:play

[ricin]

[ricin (ricin)]

Updated to spymemcached 2.4.2.

This update fixed all of my issues with memcached running against memcached 1.2.2, 1.3.3, and 1.4.1 hosts.

[Guillaume Bort (guillaume-bort)]

Fine, thank you.
Are you sure that we can safely remove spy-2.4.jar ? It is not needed anymore ?

review: Needs Information

[ricin (ricin)]

Correct. It's no longer needed.

-------

From dsallings:

spy.jar should no longer be necessary, but it's all in my github account: http://github.com/dustin

http://code.google.com/p/spymemcached/wiki/Logging

=== removed file 'framework/lib/memcached-2.1.jar'
Binary files framework/lib/memcached-2.1.jar	2009-10-15 14:21:12 +0000 and framework/lib/memcached-2.1.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/memcached-2.4.2.jar'
Binary files framework/lib/memcached-2.4.2.jar	1970-01-01 00:00:00 +0000 and framework/lib/memcached-2.4.2.jar	2009-11-06 06:45:21 +0000 differ
=== removed file 'framework/lib/spy-2.4.jar'
Binary files framework/lib/spy-2.4.jar	2008-06-23 19:00:19 +0000 and framework/lib/spy-2.4.jar	1970-01-01 00:00:00 +0000 differ
=== modified file 'framework/src/play/cache/MemcachedImpl.java'
--- framework/src/play/cache/MemcachedImpl.java	2009-08-12 19:00:35 +0000
+++ framework/src/play/cache/MemcachedImpl.java	2009-11-06 06:45:21 +0000
@@ -21,155 +21,207 @@
 /**
  * Memcached implementation (using http://code.google.com/p/spymemcached/)
  */
-public class MemcachedImpl implements CacheImpl {
+public class MemcachedImpl implements CacheImpl
+{
 
     private static MemcachedImpl uniqueInstance;
 
-    public static MemcachedImpl getInstance() throws IOException {
-        if (uniqueInstance == null) {
+    public static MemcachedImpl getInstance() throws IOException
+    {
+        if (uniqueInstance == null)
+        {
             uniqueInstance = new MemcachedImpl();
         }
         return uniqueInstance;
     }
-    
+
     MemcachedClient client;
-
-    private MemcachedImpl() throws IOException {
-        System.setProperty("net.spy.log.LoggerImpl", "net.spy.log.Log4JLogger");
-        if (Play.configuration.containsKey("memcached.host")) {
+    SerializingTranscoder tc;
+
+    private MemcachedImpl() throws IOException
+    {
+        tc = new SerializingTranscoder() {
+            @Override
+            protected Object deserialize(byte[] data)
+            {
+                try
+                {
+                    return new ObjectInputStream(new ByteArrayInputStream(data)) {
+                        @Override
+                        protected Class<?> resolveClass(ObjectStreamClass desc)
+                                throws IOException, ClassNotFoundException
+                        {
+                            return Play.classloader.loadClass(desc.getName());
+                        }
+                    }.readObject();
+                }
+                catch (Exception e)
+                {
+                    Logger.error(e, "Could not deserialize");
+                }
+                return null;
+            }
+
+            @Override
+            protected byte[] serialize(Object object)
+            {
+                try
+                {
+                    ByteArrayOutputStream bos = new ByteArrayOutputStream();
+                    new ObjectOutputStream(bos).writeObject(object);
+                    return bos.toByteArray();
+                }
+                catch (IOException e)
+                {
+                    Logger.error(e, "Could not serialize");
+                }
+                return null;
+            }
+        };
+
+        System.setProperty("net.spy.log.LoggerImpl", "net.spy.memcached.compat.log.Log4JLogger");
+        if (Play.configuration.containsKey("memcached.host"))
+        {
             client = new MemcachedClient(AddrUtil.getAddresses(Play.configuration.getProperty("memcached.host")));
-            client.setTranscoder(new SerializingTranscoder() {
-
-                @Override
-                protected Object deserialize(byte[] data) {
-                    try {
-                        return new ObjectInputStream(new ByteArrayInputStream(data)) {
-
-                            @Override
-                            protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
-                                return Play.classloader.loadClass(desc.getName());
-                            }
-                        }.readObject();
-                    } catch (Exception e) {
-                        Logger.error(e, "Could not deserialize");
-                    }
-                    return null;
-                }
-
-                @Override
-                protected byte[] serialize(Object object) {
-                    try {
-                        ByteArrayOutputStream bos = new ByteArrayOutputStream();
-                        new ObjectOutputStream(bos).writeObject(object);
-                        return bos.toByteArray();
-                    } catch (IOException e) {
-                        Logger.error(e, "Could not serialize");
-                    }
-                    return null;
-                }
-            });
-        } else if (Play.configuration.containsKey("memcached.1.host")) {
+        }
+        else if (Play.configuration.containsKey("memcached.1.host"))
+        {
             int nb = 1;
             String addresses = "";
-            while (Play.configuration.containsKey("memcached." + nb + ".host")) {
+            while (Play.configuration.containsKey("memcached." + nb + ".host"))
+            {
                 addresses += Play.configuration.get("memcached." + nb + ".host") + " ";
                 nb++;
             }
             client = new MemcachedClient(AddrUtil.getAddresses(addresses));
-        } else {
+        }
+        else
+        {
             throw new ConfigurationException(("Bad configuration for memcached"));
         }
     }
 
-    public void add(String key, Object value, int expiration) {
-        client.add(key, expiration, value);
+    public void add(String key, Object value, int expiration)
+    {
+        client.add(key, expiration, value, tc);
     }
 
-    public Object get(String key) {
-        Future<Object> future = client.asyncGet(key);
-        try {
+    public Object get(String key)
+    {
+        Future<Object> future = client.asyncGet(key, tc);
+        try
+        {
             return future.get(1, TimeUnit.SECONDS);
-        } catch (Exception e) {
+        }
+        catch (Exception e)
+        {
             future.cancel(false);
         }
         return null;
     }
 
-    public void clear() {
+    public void clear()
+    {
         client.flush();
     }
 
-    public void delete(String key) {
+    public void delete(String key)
+    {
         client.delete(key);
     }
 
-    public Map<String, Object> get(String[] keys) {
-        Future<Map<String, Object>> future = client.asyncGetBulk(keys);
-        try {
+    public Map<String, Object> get(String[] keys)
+    {
+        Future<Map<String, Object>> future = client.asyncGetBulk(tc, keys);
+        try
+        {
             return future.get(1, TimeUnit.SECONDS);
-        } catch (Exception e) {
+        }
+        catch (Exception e)
+        {
             future.cancel(false);
         }
         return new HashMap<String, Object>();
     }
 
-    public long incr(String key, int by) {
+    public long incr(String key, int by)
+    {
         return client.incr(key, by);
     }
 
-    public long decr(String key, int by) {
+    public long decr(String key, int by)
+    {
         return client.decr(key, by);
     }
 
-    public void replace(String key, Object value, int expiration) {
-        client.replace(key, expiration, value);
+    public void replace(String key, Object value, int expiration)
+    {
+        client.replace(key, expiration, value, tc);
     }
 
-    public boolean safeAdd(String key, Object value, int expiration) {
-        Future<Boolean> future = client.add(key, expiration, value);
-        try {
+    public boolean safeAdd(String key, Object value, int expiration)
+    {
+        Future<Boolean> future = client.add(key, expiration, value, tc);
+        try
+        {
             return future.get(1, TimeUnit.SECONDS);
-        } catch (Exception e) {
+        }
+        catch (Exception e)
+        {
             future.cancel(false);
         }
         return false;
     }
 
-    public boolean safeDelete(String key) {
+    public boolean safeDelete(String key)
+    {
         Future<Boolean> future = client.delete(key);
-        try {
-            return future.get(1, TimeUnit.SECONDS);
-        } catch (Exception e) {
-            future.cancel(false);
-        }
-        return false;
-    }
-
-    public boolean safeReplace(String key, Object value, int expiration) {
-        Future<Boolean> future = client.replace(key, expiration, value);
-        try {
-            return future.get(1, TimeUnit.SECONDS);
-        } catch (Exception e) {
-            future.cancel(false);
-        }
-        return false;
-    }
-
-    public boolean safeSet(String key, Object value, int expiration) {
-        Future<Boolean> future = client.set(key, expiration, value);
-        try {
-            return future.get(1, TimeUnit.SECONDS);
-        } catch (Exception e) {
-            future.cancel(false);
-        }
-        return false;
-    }
-
-    public void set(String key, Object value, int expiration) {
-        client.set(key, expiration, value);
-    }
-
-    public void stop() {
+        try
+        {
+            return future.get(1, TimeUnit.SECONDS);
+        }
+        catch (Exception e)
+        {
+            future.cancel(false);
+        }
+        return false;
+    }
+
+    public boolean safeReplace(String key, Object value, int expiration)
+    {
+        Future<Boolean> future = client.replace(key, expiration, value, tc);
+        try
+        {
+            return future.get(1, TimeUnit.SECONDS);
+        }
+        catch (Exception e)
+        {
+            future.cancel(false);
+        }
+        return false;
+    }
+
+    public boolean safeSet(String key, Object value, int expiration)
+    {
+        Future<Boolean> future = client.set(key, expiration, value, tc);
+        try
+        {
+            return future.get(1, TimeUnit.SECONDS);
+        }
+        catch (Exception e)
+        {
+            future.cancel(false);
+        }
+        return false;
+    }
+
+    public void set(String key, Object value, int expiration)
+    {
+        client.set(key, expiration, value, tc);
+    }
+
+    public void stop()
+    {
         client.shutdown();
     }
 }