Merge branch 'master' into 3.0.0

redisson/src/main/java/org/redisson/RedissonMap.java

@@ -106,20 +106,20 @@ public class RedissonMap<K, V> extends RedissonExpirable implements RMap<K, V> {
 
     @Override
     public RLock getLock(K key) {
-        String lockName = getLockName(key);
+        String lockName = getLockName(key, "lock");
         return new RedissonLock(commandExecutor, lockName);
     }
     
     @Override
     public RReadWriteLock getReadWriteLock(K key) {
-        String lockName = getLockName(key);
+        String lockName = getLockName(key, "rw_lock");
         return new RedissonReadWriteLock(commandExecutor, lockName);
     }
     
-    private String getLockName(Object key) {
+    private String getLockName(Object key, String suffix) {
         ByteBuf keyState = encodeMapKey(key);
         try {
-            return suffixName(getName(), Hash.hash128toBase64(keyState) + ":key");
+            return suffixName(getName(key), Hash.hash128toBase64(keyState) + ":" + suffix);
         } finally {
             keyState.release();
         }

redisson/src/main/java/org/redisson/RedissonSet.java

@@ -15,7 +15,6 @@
  */
 package org.redisson;
 
-import java.net.InetSocketAddress;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -25,6 +24,7 @@ import java.util.List;
 import java.util.Set;
 
 import org.redisson.api.RFuture;
+import org.redisson.api.RLock;
 import org.redisson.api.RSet;
 import org.redisson.api.RedissonClient;
 import org.redisson.api.SortOrder;
@@ -37,8 +37,11 @@ import org.redisson.client.protocol.decoder.ListScanResult;
 import org.redisson.client.protocol.decoder.ScanObjectEntry;
 import org.redisson.command.CommandAsyncExecutor;
 import org.redisson.mapreduce.RedissonCollectionMapReduce;
+import org.redisson.misc.Hash;
 import org.redisson.misc.RedissonPromise;
 
+import io.netty.buffer.ByteBuf;
+
 /**
  * Distributed and concurrent implementation of {@link java.util.Set}
  *
@@ -216,12 +219,14 @@ public class RedissonSet<V> extends RedissonExpirable implements RSet<V>, ScanIt
             return RedissonPromise.newSucceededFuture(true);
         }
         
+        String tempName = suffixName(getName(), "redisson_temp");
+        
         return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
                         "redis.call('sadd', KEYS[2], unpack(ARGV)); "
                         + "local size = redis.call('sdiff', KEYS[2], KEYS[1]);"
                         + "redis.call('del', KEYS[2]); "
                         + "return #size == 0 and 1 or 0; ",
-                       Arrays.<Object>asList(getName(), "redisson_temp__{" + getName() + "}"), encode(c).toArray());
+                       Arrays.<Object>asList(getName(), tempName), encode(c).toArray());
     }
 
     @Override
@@ -251,13 +256,17 @@ public class RedissonSet<V> extends RedissonExpirable implements RSet<V>, ScanIt
         if (c.isEmpty()) {
             return deleteAsync();
         }
+        
+        String tempName = suffixName(getName(), "redisson_temp");
+        
         return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
                "redis.call('sadd', KEYS[2], unpack(ARGV)); "
                 + "local prevSize = redis.call('scard', KEYS[1]); "
                 + "local size = redis.call('sinterstore', KEYS[1], KEYS[1], KEYS[2]);"
                 + "redis.call('del', KEYS[2]); "
                 + "return size ~= prevSize and 1 or 0; ",
-            Arrays.<Object>asList(getName(), "redisson_temp__{" + getName() + "}"), encode(c).toArray());
+            Arrays.<Object>asList(getName(), tempName), 
+            encode(c).toArray());
     }
 
     @Override
@@ -542,4 +551,19 @@ public class RedissonSet<V> extends RedissonExpirable implements RSet<V>, ScanIt
         return commandExecutor.writeAsync(getName(), codec, RedisCommands.SORT_TO, params.toArray());
     }
 
+    private String getLockName(Object value) {
+        ByteBuf state = encode(value);
+        try {
+            return suffixName(getName(value), Hash.hash128toBase64(state) + ":lock");
+        } finally {
+            state.release();
+        }
+    }
+    
+    @Override
+    public RLock getLock(V value) {
+        String lockName = getLockName(value);
+        return new RedissonLock(commandExecutor, lockName);
+    }
+    
 }

redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java

@@ -24,6 +24,7 @@ import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
 import org.redisson.api.RFuture;
+import org.redisson.api.RLock;
 import org.redisson.api.RSet;
 import org.redisson.api.SortOrder;
 import org.redisson.api.mapreduce.RCollectionMapReduce;
@@ -103,6 +104,7 @@ public class RedissonSetMultimapValues<V> extends RedissonExpirable implements R
         throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
     }
     
+    @Override
     public RFuture<Boolean> deleteAsync() {
         return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
                 "local expireDate = 92233720368547758; " +
@@ -441,6 +443,11 @@ public class RedissonSetMultimapValues<V> extends RedissonExpirable implements R
                Arrays.<Object>asList(timeoutSetName, getName()), args.toArray());
     }
 
+    @Override
+    public RLock getLock(V value) {
+        return set.getLock(value);
+    }
+    
     @Override
     public boolean removeAll(Collection<?> c) {
         return get(removeAllAsync(c));
@@ -529,106 +536,128 @@ public class RedissonSetMultimapValues<V> extends RedissonExpirable implements R
         return commandExecutor.writeAsync(getName(), codec, RedisCommands.SINTER, args.toArray());
     }
 
+    @Override
     public RFuture<Set<V>> readSortAsync(SortOrder order) {
         return set.readSortAsync(order);
     }
 
+    @Override
     public Set<V> readSort(SortOrder order) {
         return set.readSort(order);
     }
 
+    @Override
     public RFuture<Set<V>> readSortAsync(SortOrder order, int offset, int count) {
         return set.readSortAsync(order, offset, count);
     }
 
+    @Override
     public Set<V> readSort(SortOrder order, int offset, int count) {
         return set.readSort(order, offset, count);
     }
 
+    @Override
     public Set<V> readSort(String byPattern, SortOrder order) {
         return set.readSort(byPattern, order);
     }
 
+    @Override
     public RFuture<Set<V>> readSortAsync(String byPattern, SortOrder order) {
         return set.readSortAsync(byPattern, order);
     }
 
+    @Override
     public Set<V> readSort(String byPattern, SortOrder order, int offset, int count) {
         return set.readSort(byPattern, order, offset, count);
     }
 
+    @Override
     public RFuture<Set<V>> readSortAsync(String byPattern, SortOrder order, int offset, int count) {
         return set.readSortAsync(byPattern, order, offset, count);
     }
 
+    @Override
     public <T> Collection<T> readSort(String byPattern, List<String> getPatterns, SortOrder order) {
         return set.readSort(byPattern, getPatterns, order);
     }
 
+    @Override
     public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order) {
         return set.readSortAsync(byPattern, getPatterns, order);
     }
 
+    @Override
     public <T> Collection<T> readSort(String byPattern, List<String> getPatterns, SortOrder order, int offset,
             int count) {
         return set.readSort(byPattern, getPatterns, order, offset, count);
     }
 
+    @Override
     public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order,
             int offset, int count) {
         return set.readSortAsync(byPattern, getPatterns, order, offset, count);
     }
 
+    @Override
     public int sortTo(String destName, SortOrder order) {
         return set.sortTo(destName, order);
     }
 
+    @Override
     public RFuture<Integer> sortToAsync(String destName, SortOrder order) {
         return set.sortToAsync(destName, order);
     }
 
+    @Override
     public int sortTo(String destName, SortOrder order, int offset, int count) {
         return set.sortTo(destName, order, offset, count);
     }
 
+    @Override
     public RFuture<Integer> sortToAsync(String destName, SortOrder order, int offset, int count) {
         return set.sortToAsync(destName, order, offset, count);
     }
 
+    @Override
     public int sortTo(String destName, String byPattern, SortOrder order) {
         return set.sortTo(destName, byPattern, order);
     }
 
+    @Override
     public RFuture<Integer> sortToAsync(String destName, String byPattern, SortOrder order) {
         return set.sortToAsync(destName, byPattern, order);
     }
 
+    @Override
     public int sortTo(String destName, String byPattern, SortOrder order, int offset, int count) {
         return set.sortTo(destName, byPattern, order, offset, count);
     }
 
+    @Override
     public RFuture<Integer> sortToAsync(String destName, String byPattern, SortOrder order, int offset, int count) {
         return set.sortToAsync(destName, byPattern, order, offset, count);
     }
 
+    @Override
     public int sortTo(String destName, String byPattern, List<String> getPatterns, SortOrder order) {
         return set.sortTo(destName, byPattern, getPatterns, order);
     }
 
+    @Override
     public RFuture<Integer> sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order) {
         return set.sortToAsync(destName, byPattern, getPatterns, order);
     }
 
+    @Override
     public int sortTo(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset,
             int count) {
         return set.sortTo(destName, byPattern, getPatterns, order, offset, count);
     }
 
+    @Override
     public RFuture<Integer> sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order,
             int offset, int count) {
         return set.sortToAsync(destName, byPattern, getPatterns, order, offset, count);
     }
     
-    
-    
 }

redisson/src/main/java/org/redisson/api/RSet.java

@@ -29,6 +29,14 @@ import org.redisson.api.mapreduce.RCollectionMapReduce;
  */
 public interface RSet<V> extends Set<V>, RExpirable, RSetAsync<V>, RSortable<Set<V>> {
 
+    /**
+     * Returns lock instance associated with <code>value</code>
+     * 
+     * @param value - set value
+     * @return lock
+     */
+    RLock getLock(V value);
+    
     /**
      * Returns values iterator matches <code>pattern</code>. 
      * 

redisson/src/main/java/org/redisson/config/BaseMasterSlaveServersConfig.java

@@ -57,7 +57,7 @@ public class BaseMasterSlaveServersConfig<T extends BaseMasterSlaveServersConfig
 
     private ReadMode readMode = ReadMode.SLAVE;
     
-    private SubscriptionMode subscriptionMode = SubscriptionMode.SLAVE;
+    private SubscriptionMode subscriptionMode = SubscriptionMode.MASTER;
     
     /**
      * Redis 'slave' node minimum idle subscription (pub/sub) connection amount for <b>each</b> slave node
@@ -314,7 +314,7 @@ public class BaseMasterSlaveServersConfig<T extends BaseMasterSlaveServersConfig
     /**
      * Set node type used for subscription operation.
      * <p>
-     * Default is <code>SLAVE</code>
+     * Default is <code>MASTER</code>
      *
      * @param subscriptionMode param
      * @return config