Merge branch 'unstable' of github.com:/antirez/redis into unstable

src/redis-trib.rb

@@ -540,7 +540,6 @@ class RedisTrib
         nodes_count = @nodes.length
         masters_count = @nodes.length / (@replicas+1)
         masters = []
-        slaves = []
 
         # The first step is to split instances by IP. This is useful as
         # we'll try to allocate master nodes in different physical machines
@@ -558,15 +557,21 @@ class RedisTrib
 
         # Select master instances
         puts "Using #{masters_count} masters:"
-        while masters.length < masters_count
+        interleaved = []
-            ips.each{|ip,nodes_list|
+        stop = false
-                next if nodes_list.length == 0
+        while not stop do
-                masters << nodes_list.shift
+            # Take one node from each IP until we run out of nodes
-                puts masters[-1]
+            # across every IP.
-                nodes_count -= 1
+            ips.each do |ip,nodes|
-                break if masters.length == masters_count
+                stop = nodes.empty? and next
-            }
+                interleaved.push nodes.shift
             end
+        end
+
+        masters = interleaved.slice!(0, masters_count)
+        nodes_count -= masters.length
+
+        masters.each{|m| puts m}
 
         # Alloc slots on masters
         slots_per_node = ClusterHashSlots.to_f / masters_count
@@ -594,8 +599,8 @@ class RedisTrib
         # all nodes will be used.
         assignment_verbose = false
 
-        [:requested,:unused].each{|assign|
+        [:requested,:unused].each do |assign|
-            masters.each{|m|
+            masters.each do |m|
                 assigned_replicas = 0
                 while assigned_replicas < @replicas
                     break if nodes_count == 0
@@ -609,21 +614,33 @@ class RedisTrib
                                  "role too (#{nodes_count} remaining)."
                         end
                     end
-                    ips.each{|ip,nodes_list|
+
-                        next if nodes_list.length == 0
+                    # Return the first node not matching our current master
-                        # Skip instances with the same IP as the master if we
+                    node = interleaved.find{|n| n.info[:host] != m.info[:host]}
-                        # have some more IPs available.
+
-                        next if ip == m.info[:host] && nodes_count > nodes_list.length
+                    # If we found a node, use it as a best-first match.
-                        slave = nodes_list.shift
+                    # Otherwise, we didn't find a node on a different IP, so we
+                    # go ahead and use a same-IP replica.
+                    if node
+                        slave = node
+                        interleaved.delete node
+                    else
+                        slave = interleaved.shift
+                    end
                     slave.set_as_replica(m.info[:name])
                     nodes_count -= 1
                     assigned_replicas += 1
                     puts "Adding replica #{slave} to #{m}"
-                        break
+
-                    }
+                    # If we are in the "assign extra nodes" loop,
+                    # we want to assign one extra replica to each
+                    # master before repeating masters.
+                    # This break lets us assign extra replicas to masters
+                    # in a round-robin way.
+                    break if assign == :unused
+                end
+            end
         end
-            }
-        }
     end
 
     def flush_nodes_config

src/sentinel.c

@@ -2784,6 +2784,7 @@ void sentinelCommand(redisClient *c) {
         sentinelSetCommand(c);
     } else if (!strcasecmp(c->argv[1]->ptr,"info-cache")) {
         if (c->argc < 2) goto numargserr;
+        mstime_t now = mstime();
 
         /* Create an ad-hoc dictionary type so that we can iterate
          * a dictionary composed of just the master groups the user
@@ -2819,6 +2820,8 @@ void sentinelCommand(redisClient *c) {
             sentinelRedisInstance *ri = dictGetVal(de);
             addReplyBulkCBuffer(c,ri->name,strlen(ri->name));
             addReplyMultiBulkLen(c,dictSize(ri->slaves) + 1); /* +1 for self */
+            addReplyMultiBulkLen(c,2);
+            addReplyLongLong(c, now - ri->info_refresh);
             if (ri->info)
                 addReplyBulkCBuffer(c,ri->info,sdslen(ri->info));
             else
@@ -2829,6 +2832,8 @@ void sentinelCommand(redisClient *c) {
             sdi = dictGetIterator(ri->slaves);
             while ((sde = dictNext(sdi)) != NULL) {
                 sentinelRedisInstance *sri = dictGetVal(sde);
+                addReplyMultiBulkLen(c,2);
+                addReplyLongLong(c, now - sri->info_refresh);
                 if (sri->info)
                     addReplyBulkCBuffer(c,sri->info,sdslen(sri->info));
                 else