You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by je...@apache.org on 2021/05/18 02:32:00 UTC
[geode] branch develop updated: GEODE-9265: Introduce redis
SlotAdvisor to manage slot information (#6467)
This is an automated email from the ASF dual-hosted git repository.
jensdeppe pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode.git
The following commit(s) were added to refs/heads/develop by this push:
new 681b5ed GEODE-9265: Introduce redis SlotAdvisor to manage slot information (#6467)
681b5ed is described below
commit 681b5edb87f2a30593135145d6801a44c062b181
Author: Jens Deppe <jd...@pivotal.io>
AuthorDate: Mon May 17 19:30:03 2021 -0700
GEODE-9265: Introduce redis SlotAdvisor to manage slot information (#6467)
* GEODE-9265: Introduce redis SlotAdvisor to manage slot information
We're currently using a function to pull bucket/slot info from each
member. However, members already contain the most current view of bucket
locations so we should use that instead. This will avoid an unnecessary
fn call as well as providing more up-to-date information.
This commit introduces a `SlotAdvisor` which is intended to be the
central point of information regarding buckets/slots/members. This will
also be used to support the MOVED response.
---
.../test/dunit/rules/RedisClusterStartupRule.java | 6 +-
.../geode/redis/internal/data/DeltaDUnitTest.java | 4 +-
.../cluster/ClusterSlotsAndNodesDUnitTest.java | 107 +++++++++++-
.../redis/session/SessionExpirationDUnitTest.java | 4 +-
.../apache/geode/codeAnalysis/excludedClasses.txt | 1 +
.../codeAnalysis/sanctionedDataSerializables.txt | 4 +
.../geode/redis/internal/GeodeRedisServer.java | 11 +-
.../geode/redis/internal/GeodeRedisService.java | 4 +
.../geode/redis/internal/RedisCommandType.java | 2 +-
.../geode/redis/internal/RegionProvider.java | 17 +-
.../apache/geode/redis/internal/SlotAdvisor.java | 181 +++++++++++++++++++++
.../cluster/BucketInfoRetrievalFunction.java | 118 --------------
.../RedisKey.java => cluster/RedisMemberInfo.java} | 67 ++++----
.../cluster/RedisMemberInfoRetrievalFunction.java | 76 +++++++++
.../data/RedisHashCommandsFunctionExecutor.java | 3 +-
.../apache/geode/redis/internal/data/RedisKey.java | 8 +
.../geode/redis/internal/executor/Executor.java | 2 +-
.../internal/executor/cluster/ClusterExecutor.java | 107 ++++--------
.../executor/cluster/RedisPartitionResolver.java | 6 +-
.../apache/geode/redis/internal/netty/Command.java | 2 +-
.../internal/netty/ExecutionHandlerContext.java | 16 +-
.../redis/internal/netty/NettyRedisServer.java | 8 +-
...de-apis-compatible-with-redis-serializables.txt | 2 -
.../serialization/DataSerializableFixedID.java | 1 +
24 files changed, 488 insertions(+), 269 deletions(-)
diff --git a/geode-apis-compatible-with-redis/src/commonTest/java/org/apache/geode/test/dunit/rules/RedisClusterStartupRule.java b/geode-apis-compatible-with-redis/src/commonTest/java/org/apache/geode/test/dunit/rules/RedisClusterStartupRule.java
index e88502b..5020a46 100644
--- a/geode-apis-compatible-with-redis/src/commonTest/java/org/apache/geode/test/dunit/rules/RedisClusterStartupRule.java
+++ b/geode-apis-compatible-with-redis/src/commonTest/java/org/apache/geode/test/dunit/rules/RedisClusterStartupRule.java
@@ -28,6 +28,8 @@ import org.apache.geode.test.junit.rules.ServerStarterRule;
public class RedisClusterStartupRule extends ClusterStartupRule {
+ private static final String BIND_ADDRESS = "127.0.0.1";
+
public RedisClusterStartupRule() {
super();
}
@@ -60,7 +62,7 @@ public class RedisClusterStartupRule extends ClusterStartupRule {
}
private ServerStarterRule withRedis(ServerStarterRule rule) {
- return rule.withProperty(REDIS_BIND_ADDRESS, "localhost")
+ return rule.withProperty(REDIS_BIND_ADDRESS, BIND_ADDRESS)
.withProperty(REDIS_PORT, "0")
.withProperty(REDIS_ENABLED, "true")
.withSystemProperty(GeodeRedisServer.ENABLE_UNSUPPORTED_COMMANDS_PARAM,
@@ -68,7 +70,7 @@ public class RedisClusterStartupRule extends ClusterStartupRule {
}
private ServerStarterRule withRedis(ServerStarterRule rule, String redisPort) {
- return rule.withProperty(REDIS_BIND_ADDRESS, "localhost")
+ return rule.withProperty(REDIS_BIND_ADDRESS, BIND_ADDRESS)
.withProperty(REDIS_PORT, redisPort)
.withProperty(REDIS_ENABLED, "true")
.withSystemProperty(GeodeRedisServer.ENABLE_UNSUPPORTED_COMMANDS_PARAM,
diff --git a/geode-apis-compatible-with-redis/src/distributedTest/java/org/apache/geode/redis/internal/data/DeltaDUnitTest.java b/geode-apis-compatible-with-redis/src/distributedTest/java/org/apache/geode/redis/internal/data/DeltaDUnitTest.java
index 37154b0..168350d 100644
--- a/geode-apis-compatible-with-redis/src/distributedTest/java/org/apache/geode/redis/internal/data/DeltaDUnitTest.java
+++ b/geode-apis-compatible-with-redis/src/distributedTest/java/org/apache/geode/redis/internal/data/DeltaDUnitTest.java
@@ -35,6 +35,7 @@ import redis.clients.jedis.Jedis;
import org.apache.geode.internal.cache.BucketDump;
import org.apache.geode.internal.cache.InternalCache;
import org.apache.geode.internal.cache.PartitionedRegion;
+import org.apache.geode.redis.internal.RegionProvider;
import org.apache.geode.test.awaitility.GeodeAwaitility;
import org.apache.geode.test.dunit.rules.ClusterStartupRule;
import org.apache.geode.test.dunit.rules.MemberVM;
@@ -194,7 +195,8 @@ public class DeltaDUnitTest {
private void compareBuckets() {
server1.invoke(() -> {
InternalCache cache = ClusterStartupRule.getCache();
- PartitionedRegion region = (PartitionedRegion) cache.getRegion("__REDIS_DATA");
+ PartitionedRegion region =
+ (PartitionedRegion) cache.getRegion(RegionProvider.REDIS_DATA_REGION);
for (int j = 0; j < region.getTotalNumberOfBuckets(); j++) {
List<BucketDump> buckets = region.getAllBucketEntries(j);
assertThat(buckets.size()).isEqualTo(2);
diff --git a/geode-apis-compatible-with-redis/src/distributedTest/java/org/apache/geode/redis/internal/executor/cluster/ClusterSlotsAndNodesDUnitTest.java b/geode-apis-compatible-with-redis/src/distributedTest/java/org/apache/geode/redis/internal/executor/cluster/ClusterSlotsAndNodesDUnitTest.java
index b0311ed..ba6eddb 100644
--- a/geode-apis-compatible-with-redis/src/distributedTest/java/org/apache/geode/redis/internal/executor/cluster/ClusterSlotsAndNodesDUnitTest.java
+++ b/geode-apis-compatible-with-redis/src/distributedTest/java/org/apache/geode/redis/internal/executor/cluster/ClusterSlotsAndNodesDUnitTest.java
@@ -19,13 +19,21 @@ import static org.apache.geode.redis.internal.RegionProvider.REDIS_REGION_BUCKET
import static org.apache.geode.redis.internal.RegionProvider.REDIS_SLOTS_PER_BUCKET;
import static org.assertj.core.api.Assertions.assertThat;
+import java.util.BitSet;
import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
import org.assertj.core.data.Offset;
+import org.junit.After;
+import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
+import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.Jedis;
+import redis.clients.jedis.JedisCluster;
import org.apache.geode.cache.control.RebalanceFactory;
import org.apache.geode.cache.control.ResourceManager;
@@ -35,12 +43,16 @@ import org.apache.geode.test.awaitility.GeodeAwaitility;
import org.apache.geode.test.dunit.rules.ClusterStartupRule;
import org.apache.geode.test.dunit.rules.MemberVM;
import org.apache.geode.test.dunit.rules.RedisClusterStartupRule;
+import org.apache.geode.test.junit.rules.ExecutorServiceRule;
public class ClusterSlotsAndNodesDUnitTest {
@ClassRule
public static RedisClusterStartupRule cluster = new RedisClusterStartupRule();
+ @Rule
+ public ExecutorServiceRule executor = new ExecutorServiceRule();
+
private static final int JEDIS_TIMEOUT =
Math.toIntExact(GeodeAwaitility.getTimeout().toMillis());
private static final String LOCAL_HOST = "127.0.0.1";
@@ -49,6 +61,7 @@ public class ClusterSlotsAndNodesDUnitTest {
private static Jedis jedis1;
private static Jedis jedis2;
+ private static JedisCluster jedisCluster;
@BeforeClass
public static void classSetup() {
@@ -61,6 +74,20 @@ public class ClusterSlotsAndNodesDUnitTest {
jedis1 = new Jedis(LOCAL_HOST, redisServerPort1, JEDIS_TIMEOUT);
jedis2 = new Jedis(LOCAL_HOST, redisServerPort2, JEDIS_TIMEOUT);
+
+ jedisCluster = new JedisCluster(new HostAndPort("localhost", redisServerPort1), JEDIS_TIMEOUT);
+ }
+
+ @AfterClass
+ public static void teardown() {
+ jedis1.close();
+ jedis2.close();
+ jedisCluster.close();
+ }
+
+ @After
+ public void testCleanup() {
+ rebalanceAllRegions(server1);
}
@Test
@@ -140,6 +167,84 @@ public class ClusterSlotsAndNodesDUnitTest {
}
@Test
+ public void whenMultipleServersFail_bucketsAreRecreated() {
+ int ENTRIES = 1000;
+
+ cluster.startRedisVM(3, locator.getPort());
+ cluster.startRedisVM(4, locator.getPort());
+ rebalanceAllRegions(server1);
+
+ for (int i = 0; i < ENTRIES; i++) {
+ jedisCluster.set("key-" + i, "value-" + 1);
+ }
+
+ cluster.crashVM(3);
+ cluster.crashVM(4);
+
+ // Implicitly recreate missing buckets.
+ jedis1.clusterSlots();
+ rebalanceAllRegions(server1);
+
+ int keysRemaining = 0;
+ for (int i = 0; i < ENTRIES; i++) {
+ keysRemaining += jedisCluster.get("key-" + i) != null ? 1 : 0;
+ }
+
+ assertThat(keysRemaining).isLessThan(ENTRIES);
+
+ List<Object> slots = jedis1.clusterSlots();
+ List<ClusterNode> nodes = ClusterNodes.parseClusterSlots(slots).getNodes();
+
+ assertThat(nodes).as("incorrect number of nodes").hasSize(2);
+ assertThat(nodes.get(0).slots.size()).isCloseTo(REDIS_REGION_BUCKETS / 2, Offset.offset(2));
+
+ String info = jedis1.clusterInfo();
+ assertThat(info).contains("cluster_known_nodes:2");
+ assertThat(info).contains("cluster_size:2");
+ }
+
+ @Test
+ public void slotsAreNotMissingOrDuplicatedWhenPrimariesAreMoving() throws Exception {
+ AtomicBoolean done = new AtomicBoolean();
+ CompletableFuture<Void> startupShutdownFuture = executor.runAsync(() -> {
+ while (!done.get()) {
+ MemberVM server3 = cluster.startRedisVM(3, locator.getPort());
+ rebalanceAllRegions(server3);
+ server3.stop();
+ }
+ });
+
+ long endTime = System.currentTimeMillis() + 60_000;
+ CompletableFuture<Integer> getSlotsFuture = executor.supplyAsync(() -> {
+ int iterations = 0;
+
+ while (System.currentTimeMillis() < endTime) {
+ List<ClusterNode> nodes = ClusterNodes.parseClusterSlots(jedis1.clusterSlots()).getNodes();
+
+ /// Ensure there is no missing or duplicate slot info
+ BitSet missingSlots = new BitSet();
+ // Set all bits as missing
+ missingSlots.flip(0, 16384);
+ nodes.stream()
+ .flatMap(node -> node.slots.stream())
+ .forEach(slot -> missingSlots.flip(slot.getLeft().intValue(),
+ slot.getRight().intValue() + 1));
+
+ assertThat(missingSlots.stream().toArray()).isEmpty();
+ iterations++;
+ }
+
+ return iterations;
+ });
+
+ int iterations = getSlotsFuture.get();
+ done.set(true);
+ startupShutdownFuture.get();
+
+ assertThat(iterations).isGreaterThan(0);
+ }
+
+ @Test
public void clusterSlotsAndClusterNodesResponseIsEquivalent() {
List<ClusterNode> nodesFromSlots =
ClusterNodes.parseClusterSlots(jedis1.clusterSlots()).getNodes();
@@ -150,7 +255,7 @@ public class ClusterSlotsAndNodesDUnitTest {
}
private static void rebalanceAllRegions(MemberVM vm) {
- vm.invoke(() -> {
+ vm.invoke("Running rebalance", () -> {
ResourceManager manager = ClusterStartupRule.getCache().getResourceManager();
RebalanceFactory factory = manager.createRebalanceFactory();
try {
diff --git a/geode-apis-compatible-with-redis/src/distributedTest/java/org/apache/geode/redis/session/SessionExpirationDUnitTest.java b/geode-apis-compatible-with-redis/src/distributedTest/java/org/apache/geode/redis/session/SessionExpirationDUnitTest.java
index d3dadb1..a4440bf 100644
--- a/geode-apis-compatible-with-redis/src/distributedTest/java/org/apache/geode/redis/session/SessionExpirationDUnitTest.java
+++ b/geode-apis-compatible-with-redis/src/distributedTest/java/org/apache/geode/redis/session/SessionExpirationDUnitTest.java
@@ -33,6 +33,7 @@ import org.springframework.web.client.RestTemplate;
import org.apache.geode.internal.cache.BucketDump;
import org.apache.geode.internal.cache.InternalCache;
import org.apache.geode.internal.cache.PartitionedRegion;
+import org.apache.geode.redis.internal.RegionProvider;
import org.apache.geode.redis.internal.data.RedisHash;
import org.apache.geode.test.awaitility.GeodeAwaitility;
import org.apache.geode.test.dunit.rules.ClusterStartupRule;
@@ -132,7 +133,8 @@ public class SessionExpirationDUnitTest extends SessionDUnitTest {
private void compareMaxInactiveIntervals() {
cluster.getVM(1).invoke(() -> {
InternalCache cache = ClusterStartupRule.getCache();
- PartitionedRegion region = (PartitionedRegion) cache.getRegion("__REDIS_DATA");
+ PartitionedRegion region =
+ (PartitionedRegion) cache.getRegion(RegionProvider.REDIS_DATA_REGION);
for (int j = 0; j < region.getTotalNumberOfBuckets(); j++) {
List<BucketDump> buckets = region.getAllBucketEntries(j);
if (buckets.isEmpty()) {
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/resources/org/apache/geode/codeAnalysis/excludedClasses.txt b/geode-apis-compatible-with-redis/src/integrationTest/resources/org/apache/geode/codeAnalysis/excludedClasses.txt
index 7f8e74a..0a0831c 100644
--- a/geode-apis-compatible-with-redis/src/integrationTest/resources/org/apache/geode/codeAnalysis/excludedClasses.txt
+++ b/geode-apis-compatible-with-redis/src/integrationTest/resources/org/apache/geode/codeAnalysis/excludedClasses.txt
@@ -1 +1,2 @@
+org/apache/geode/redis/internal/cluster/RedisMemberInfoRetrievalFunction
org/apache/geode/redis/internal/collections/Object2ObjectOpenCustomHashMapWithCursor
diff --git a/geode-apis-compatible-with-redis/src/integrationTest/resources/org/apache/geode/codeAnalysis/sanctionedDataSerializables.txt b/geode-apis-compatible-with-redis/src/integrationTest/resources/org/apache/geode/codeAnalysis/sanctionedDataSerializables.txt
index 38b06fc..5c8bea1 100644
--- a/geode-apis-compatible-with-redis/src/integrationTest/resources/org/apache/geode/codeAnalysis/sanctionedDataSerializables.txt
+++ b/geode-apis-compatible-with-redis/src/integrationTest/resources/org/apache/geode/codeAnalysis/sanctionedDataSerializables.txt
@@ -1,3 +1,7 @@
+org/apache/geode/redis/internal/cluster/RedisMemberInfo,2
+fromData,28
+toData,27
+
org/apache/geode/redis/internal/data/AbstractRedisData,2
fromData,11
toData,11
diff --git a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/GeodeRedisServer.java b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/GeodeRedisServer.java
index dcf1aff..e272a55 100644
--- a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/GeodeRedisServer.java
+++ b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/GeodeRedisServer.java
@@ -28,7 +28,8 @@ import org.apache.geode.internal.statistics.StatisticsClock;
import org.apache.geode.internal.statistics.StatisticsClockFactory;
import org.apache.geode.logging.internal.executors.LoggingExecutors;
import org.apache.geode.logging.internal.log4j.api.LogService;
-import org.apache.geode.redis.internal.cluster.BucketInfoRetrievalFunction;
+import org.apache.geode.redis.internal.cluster.RedisMemberInfoRetrievalFunction;
+import org.apache.geode.redis.internal.data.CommandHelper;
import org.apache.geode.redis.internal.executor.CommandFunction;
import org.apache.geode.redis.internal.executor.StripedExecutor;
import org.apache.geode.redis.internal.executor.SynchronizedStripedExecutor;
@@ -78,7 +79,11 @@ public class GeodeRedisServer {
pubSub = new PubSubImpl(new Subscriptions());
redisStats = createStats(cache);
StripedExecutor stripedExecutor = new SynchronizedStripedExecutor();
+ RedisMemberInfoRetrievalFunction infoFunction = RedisMemberInfoRetrievalFunction.register();
+
regionProvider = new RegionProvider(cache);
+ CommandHelper commandHelper =
+ new CommandHelper(regionProvider.getDataRegion(), redisStats, stripedExecutor);
CommandFunction.register(regionProvider.getDataRegion(), stripedExecutor, redisStats);
RenameFunction.register(regionProvider.getDataRegion(), stripedExecutor, redisStats);
@@ -94,9 +99,9 @@ public class GeodeRedisServer {
nettyRedisServer = new NettyRedisServer(() -> cache.getInternalDistributedSystem().getConfig(),
regionProvider, pubSub,
this::allowUnsupportedCommands, this::shutdown, port, bindAddress, redisStats,
- redisCommandExecutor, member);
+ redisCommandExecutor, member, commandHelper);
- BucketInfoRetrievalFunction.register(bindAddress, nettyRedisServer.getPort());
+ infoFunction.initialize(member, bindAddress, nettyRedisServer.getPort());
}
@VisibleForTesting
diff --git a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/GeodeRedisService.java b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/GeodeRedisService.java
index de3fa3a..138c677 100644
--- a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/GeodeRedisService.java
+++ b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/GeodeRedisService.java
@@ -28,6 +28,7 @@ import org.apache.geode.internal.cache.InternalCache;
import org.apache.geode.internal.serialization.DataSerializableFixedID;
import org.apache.geode.logging.internal.log4j.api.LogService;
import org.apache.geode.management.internal.beans.CacheServiceMBeanBase;
+import org.apache.geode.redis.internal.cluster.RedisMemberInfo;
import org.apache.geode.redis.internal.data.ByteArrayWrapper;
import org.apache.geode.redis.internal.data.NullRedisData;
import org.apache.geode.redis.internal.data.RedisHash;
@@ -76,6 +77,9 @@ public class GeodeRedisService implements CacheService, ResourceEventsListener {
InternalDataSerializer.getDSFIDSerializer().registerDSFID(
DataSerializableFixedID.REDIS_SET_OPTIONS_ID,
SetOptions.class);
+ InternalDataSerializer.getDSFIDSerializer().registerDSFID(
+ DataSerializableFixedID.REDIS_MEMBER_INFO_ID,
+ RedisMemberInfo.class);
}
@Override
diff --git a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/RedisCommandType.java b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/RedisCommandType.java
index d2ab9bb..56c6c05 100755
--- a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/RedisCommandType.java
+++ b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/RedisCommandType.java
@@ -333,7 +333,7 @@ public enum RedisCommandType {
}
public RedisResponse executeCommand(Command command,
- ExecutionHandlerContext executionHandlerContext) {
+ ExecutionHandlerContext executionHandlerContext) throws Exception {
parameterRequirements.checkParameters(command, executionHandlerContext);
diff --git a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/RegionProvider.java b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/RegionProvider.java
index 052e925..8dab42c 100644
--- a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/RegionProvider.java
+++ b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/RegionProvider.java
@@ -30,8 +30,7 @@ public class RegionProvider {
/**
* The name of the region that holds data stored in redis.
*/
- public static final String REDIS_DATA_REGION = "__REDIS_DATA";
- public static final String REDIS_CONFIG_REGION = "__REDIS_CONFIG";
+ public static final String REDIS_DATA_REGION = "REDIS_DATA";
public static final String REDIS_REGION_BUCKETS_PARAM = "redis.region.buckets";
// Ideally the bucket count should be a power of 2, but technically it is not required.
@@ -43,15 +42,14 @@ public class RegionProvider {
public static final int REDIS_SLOTS_PER_BUCKET = REDIS_SLOTS / REDIS_REGION_BUCKETS;
private final Region<RedisKey, RedisData> dataRegion;
- private final Region<String, Object> configRegion;
private final RedisHashCommandsFunctionInvoker hashCommands;
+ private final SlotAdvisor slotAdvisor;
public RegionProvider(InternalCache cache) {
validateBucketCount(REDIS_REGION_BUCKETS);
InternalRegionFactory<RedisKey, RedisData> redisDataRegionFactory =
cache.createInternalRegionFactory(RegionShortcut.PARTITION_REDUNDANT);
- redisDataRegionFactory.setInternalRegion(true).setIsUsedForMetaRegion(true);
PartitionAttributesFactory<RedisKey, RedisData> attributesFactory =
new PartitionAttributesFactory<>();
@@ -61,20 +59,17 @@ public class RegionProvider {
dataRegion = redisDataRegionFactory.create(REDIS_DATA_REGION);
- InternalRegionFactory<String, Object> redisConfigRegionFactory =
- cache.createInternalRegionFactory(RegionShortcut.REPLICATE);
- redisConfigRegionFactory.setInternalRegion(true).setIsUsedForMetaRegion(true);
- configRegion = redisConfigRegionFactory.create(REDIS_CONFIG_REGION);
+ hashCommands = new RedisHashCommandsFunctionInvoker(dataRegion);
- this.hashCommands = new RedisHashCommandsFunctionInvoker(dataRegion);
+ slotAdvisor = new SlotAdvisor(dataRegion);
}
public Region<RedisKey, RedisData> getDataRegion() {
return dataRegion;
}
- public Region<String, Object> getConfigRegion() {
- return configRegion;
+ public SlotAdvisor getSlotAdvisor() {
+ return slotAdvisor;
}
/**
diff --git a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/SlotAdvisor.java b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/SlotAdvisor.java
new file mode 100644
index 0000000..f3a727f
--- /dev/null
+++ b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/SlotAdvisor.java
@@ -0,0 +1,181 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
+ * agreements. See the NOTICE file distributed with this work for additional information regarding
+ * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License. You may obtain a
+ * copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.geode.redis.internal;
+
+import static org.apache.geode.redis.internal.RegionProvider.REDIS_REGION_BUCKETS;
+import static org.apache.geode.redis.internal.RegionProvider.REDIS_SLOTS_PER_BUCKET;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.logging.log4j.Logger;
+
+import org.apache.geode.cache.Region;
+import org.apache.geode.cache.execute.FunctionService;
+import org.apache.geode.cache.execute.ResultCollector;
+import org.apache.geode.distributed.DistributedMember;
+import org.apache.geode.distributed.internal.membership.InternalDistributedMember;
+import org.apache.geode.internal.cache.PartitionedRegion;
+import org.apache.geode.logging.internal.log4j.api.LogService;
+import org.apache.geode.redis.internal.cluster.RedisMemberInfo;
+import org.apache.geode.redis.internal.cluster.RedisMemberInfoRetrievalFunction;
+import org.apache.geode.redis.internal.data.RedisData;
+import org.apache.geode.redis.internal.data.RedisKey;
+
+public class SlotAdvisor {
+
+ private static final Logger logger = LogService.getLogger();
+ private static final int HOSTPORT_RETRIEVAL_ATTEMPTS = 20;
+ private static final int HOSTPORT_RETRIEVAL_INTERVAL = 100;
+
+ /**
+ * Cache of member ids to member IP address and redis listening port
+ */
+ private final Map<DistributedMember, RedisMemberInfo> memberInfos = new HashMap<>();
+ private final PartitionedRegion dataRegion;
+
+ SlotAdvisor(Region<RedisKey, RedisData> dataRegion) {
+ this.dataRegion = (PartitionedRegion) dataRegion;
+ }
+
+ public Map<String, List<Integer>> getMemberBuckets() {
+ Map<String, List<Integer>> memberBuckets = new HashMap<>();
+ for (int bucketId = 0; bucketId < REDIS_REGION_BUCKETS; bucketId++) {
+ String memberId = getOrCreateMember(bucketId).getUniqueId();
+ memberBuckets.computeIfAbsent(memberId, k -> new ArrayList<>()).add(bucketId);
+ }
+
+ return memberBuckets;
+ }
+
+ /**
+ * This returns a list of {@link MemberBucketSlot}s where each entry corresponds to a bucket. If
+ * the details for a given bucket cannot be determined, that entry will contain {@code null}.
+ */
+ public synchronized List<MemberBucketSlot> getBucketSlots() throws InterruptedException {
+ List<MemberBucketSlot> memberBucketSlots = new ArrayList<>(RegionProvider.REDIS_REGION_BUCKETS);
+ for (int bucketId = 0; bucketId < REDIS_REGION_BUCKETS; bucketId++) {
+ RedisMemberInfo memberInfo = getMemberInfo(bucketId);
+ if (memberInfo != null) {
+ memberBucketSlots.add(
+ new MemberBucketSlot(bucketId, memberInfo.getHostAddress(),
+ memberInfo.getRedisPort()));
+ }
+ }
+
+ return memberBucketSlots;
+ }
+
+ private InternalDistributedMember getOrCreateMember(int bucketId) {
+ return dataRegion.getOrCreateNodeForBucketWrite(bucketId, null);
+ }
+
+ /**
+ * This method will retry for {@link #HOSTPORT_RETRIEVAL_ATTEMPTS} attempts and return null if
+ * no information could be retrieved.
+ */
+ private RedisMemberInfo getMemberInfo(int bucketId) throws InterruptedException {
+ RedisMemberInfo response;
+
+ for (int i = 0; i < HOSTPORT_RETRIEVAL_ATTEMPTS; i++) {
+ response = getMemberInfo0(bucketId);
+ if (response != null) {
+ return response;
+ }
+
+ Thread.sleep(HOSTPORT_RETRIEVAL_INTERVAL);
+ }
+
+ logger.error("Unable to retrieve host and redis port for member with bucketId: {}", bucketId);
+
+ return null;
+ }
+
+ @SuppressWarnings("unchecked")
+ private RedisMemberInfo getMemberInfo0(int bucketId) {
+ InternalDistributedMember member = getOrCreateMember(bucketId);
+
+ if (memberInfos.containsKey(member)) {
+ return memberInfos.get(member);
+ }
+
+ List<RedisMemberInfo> memberInfos;
+ ResultCollector<RedisMemberInfo, List<RedisMemberInfo>> resultCollector =
+ FunctionService.onRegion(dataRegion).execute(RedisMemberInfoRetrievalFunction.ID);
+ memberInfos = resultCollector.getResult();
+
+ this.memberInfos.clear();
+
+ for (RedisMemberInfo memberInfo : memberInfos) {
+ if (memberInfo == null) {
+ continue;
+ }
+ this.memberInfos.put(memberInfo.getMember(), memberInfo);
+ }
+
+ return this.memberInfos.get(member);
+ }
+
+ public static class MemberBucketSlot {
+ private final int bucketId;
+ private final String primaryIpAddress;
+ private final int primaryPort;
+ private final int slotStart;
+ private final int slotEnd;
+
+ public MemberBucketSlot(int bucketId, String primaryIpAddress, int primaryPort) {
+ this.bucketId = bucketId;
+ this.primaryIpAddress = primaryIpAddress;
+ this.primaryPort = primaryPort;
+ this.slotStart = bucketId * REDIS_SLOTS_PER_BUCKET;
+ this.slotEnd = ((bucketId + 1) * REDIS_SLOTS_PER_BUCKET) - 1;
+ }
+
+ public int getBucketId() {
+ return bucketId;
+ }
+
+ public String getPrimaryIpAddress() {
+ return primaryIpAddress;
+ }
+
+ public int getPrimaryPort() {
+ return primaryPort;
+ }
+
+ public int getSlotStart() {
+ return slotStart;
+ }
+
+ public int getSlotEnd() {
+ return slotEnd;
+ }
+
+ @Override
+ public String toString() {
+ return "BucketSlot{" +
+ "bucketId=" + bucketId +
+ ", primaryIpAddress='" + primaryIpAddress + '\'' +
+ ", primaryPort=" + primaryPort +
+ ", slotStart=" + slotStart +
+ ", slotEnd=" + slotEnd +
+ '}';
+ }
+ }
+
+}
diff --git a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/cluster/BucketInfoRetrievalFunction.java b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/cluster/BucketInfoRetrievalFunction.java
deleted file mode 100644
index afde899..0000000
--- a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/cluster/BucketInfoRetrievalFunction.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
- * agreements. See the NOTICE file distributed with this work for additional information regarding
- * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License. You may obtain a
- * copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License
- * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
- * or implied. See the License for the specific language governing permissions and limitations under
- * the License.
- */
-
-package org.apache.geode.redis.internal.cluster;
-
-import java.io.Serializable;
-import java.net.InetAddress;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
-
-import org.apache.geode.cache.Region;
-import org.apache.geode.cache.execute.FunctionContext;
-import org.apache.geode.cache.execute.FunctionService;
-import org.apache.geode.internal.cache.PartitionedRegion;
-import org.apache.geode.internal.cache.execute.InternalFunction;
-import org.apache.geode.internal.inet.LocalHostUtil;
-import org.apache.geode.redis.internal.RegionProvider;
-import org.apache.geode.redis.internal.data.ByteArrayWrapper;
-import org.apache.geode.redis.internal.data.RedisKey;
-
-public class BucketInfoRetrievalFunction implements InternalFunction<Void> {
-
- public static final String ID = BucketInfoRetrievalFunction.class.getName();
- private final String hostAddress;
- private final int redisPort;
-
- private BucketInfoRetrievalFunction(String address, int redisPort) {
- if (address == null || address.isEmpty() || address.equals("0.0.0.0")) {
- InetAddress localhost = null;
- try {
- localhost = LocalHostUtil.getLocalHost();
- } catch (Exception ignored) {
- }
- hostAddress = localhost == null ? "127.0.0.1" : localhost.getHostAddress();
- } else {
- hostAddress = address;
- }
-
- this.redisPort = redisPort;
- }
-
- public static void register(String address, int redisPort) {
- FunctionService.registerFunction(new BucketInfoRetrievalFunction(address, redisPort));
- }
-
- @Override
- public void execute(FunctionContext<Void> context) {
- Region<RedisKey, ByteArrayWrapper> region =
- context.getCache().getRegion(RegionProvider.REDIS_DATA_REGION);
-
- String memberId =
- context.getCache().getDistributedSystem().getDistributedMember().getUniqueId();
-
- MemberBuckets mb = new MemberBuckets(memberId, hostAddress, redisPort,
- getLocalPrimaryBucketIds(region));
- context.getResultSender().lastResult(mb);
- }
-
- @Override
- public String getId() {
- return ID;
- }
-
- @SuppressWarnings("unchecked")
- public static Set<Integer> getLocalPrimaryBucketIds(Region region) {
- PartitionedRegion pr = (PartitionedRegion) region;
- if (pr.getDataStore() != null) {
- return new HashSet<>(pr.getDataStore().getAllLocalPrimaryBucketIds());
- } else {
- return Collections.EMPTY_SET;
- }
- }
-
- public static class MemberBuckets implements Serializable {
- private final String memberId;
- private final String hostAddress;
- private final int port;
- private final Set<Integer> primaryBucketIds;
-
- public MemberBuckets(String memberId, String hostAddress, int port,
- Set<Integer> primaryBucketIds) {
- this.memberId = memberId;
- this.hostAddress = hostAddress;
- this.port = port;
- this.primaryBucketIds = primaryBucketIds;
- }
-
- public String getMemberId() {
- return memberId;
- }
-
- public String getHostAddress() {
- return hostAddress;
- }
-
- public int getPort() {
- return port;
- }
-
- public Set<Integer> getPrimaryBucketIds() {
- return primaryBucketIds;
- }
-
- }
-}
diff --git a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/data/RedisKey.java b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/cluster/RedisMemberInfo.java
similarity index 56%
copy from geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/data/RedisKey.java
copy to geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/cluster/RedisMemberInfo.java
index 95c6d83..5784200 100644
--- a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/data/RedisKey.java
+++ b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/cluster/RedisMemberInfo.java
@@ -13,76 +13,67 @@
* the License.
*/
-package org.apache.geode.redis.internal.data;
+package org.apache.geode.redis.internal.cluster;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
+import org.apache.geode.DataSerializer;
+import org.apache.geode.distributed.DistributedMember;
import org.apache.geode.internal.serialization.DataSerializableFixedID;
import org.apache.geode.internal.serialization.DeserializationContext;
import org.apache.geode.internal.serialization.KnownVersion;
import org.apache.geode.internal.serialization.SerializationContext;
-import org.apache.geode.redis.internal.executor.cluster.CRC16;
-import org.apache.geode.redis.internal.executor.cluster.RedisPartitionResolver;
-public class RedisKey extends ByteArrayWrapper implements DataSerializableFixedID {
+public class RedisMemberInfo implements DataSerializableFixedID {
+ private DistributedMember member;
+ private String hostAddress;
+ private int redisPort;
- private int crc16;
+ // For serialization
+ public RedisMemberInfo() {}
- public RedisKey() {}
-
- public RedisKey(byte[] value) {
- super(value);
-
- int startHashtag = Integer.MAX_VALUE;
- int endHashtag = 0;
+ public RedisMemberInfo(DistributedMember member, String hostAddress, int redisPort) {
+ this.member = member;
+ this.hostAddress = hostAddress;
+ this.redisPort = redisPort;
+ }
- for (int i = 0; i < value.length; i++) {
- if (value[i] == '{' && startHashtag == Integer.MAX_VALUE) {
- startHashtag = i;
- } else if (value[i] == '}') {
- endHashtag = i;
- break;
- }
- }
+ public DistributedMember getMember() {
+ return member;
+ }
- if (endHashtag - startHashtag <= 1) {
- startHashtag = -1;
- endHashtag = value.length;
- }
+ public String getHostAddress() {
+ return hostAddress;
+ }
- crc16 = CRC16.calculate(value, startHashtag + 1, endHashtag);
+ public int getRedisPort() {
+ return redisPort;
}
@Override
public int getDSFID() {
- return DataSerializableFixedID.REDIS_KEY;
+ return REDIS_MEMBER_INFO_ID;
}
@Override
public void toData(DataOutput out, SerializationContext context) throws IOException {
- out.writeShort(crc16);
- super.toData(out, context);
+ DataSerializer.writeObject(member, out);
+ DataSerializer.writeString(hostAddress, out);
+ out.writeInt(redisPort);
}
@Override
public void fromData(DataInput in, DeserializationContext context)
throws IOException, ClassNotFoundException {
- // Need to convert a signed short to unsigned
- crc16 = in.readShort() & 0xffff;
- super.fromData(in, context);
+ member = DataSerializer.readObject(in);
+ hostAddress = DataSerializer.readString(in);
+ redisPort = DataSerializer.readPrimitiveInt(in);
}
@Override
public KnownVersion[] getSerializationVersions() {
return null;
}
-
- /**
- * Used by the {@link RedisPartitionResolver} to map slots to buckets
- */
- public int getCrc16() {
- return crc16;
- }
}
diff --git a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/cluster/RedisMemberInfoRetrievalFunction.java b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/cluster/RedisMemberInfoRetrievalFunction.java
new file mode 100644
index 0000000..5155898
--- /dev/null
+++ b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/cluster/RedisMemberInfoRetrievalFunction.java
@@ -0,0 +1,76 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
+ * agreements. See the NOTICE file distributed with this work for additional information regarding
+ * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License. You may obtain a
+ * copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.apache.geode.redis.internal.cluster;
+
+import java.net.InetAddress;
+
+import org.apache.geode.cache.execute.FunctionContext;
+import org.apache.geode.cache.execute.FunctionService;
+import org.apache.geode.distributed.DistributedMember;
+import org.apache.geode.internal.cache.execute.InternalFunction;
+import org.apache.geode.internal.inet.LocalHostUtil;
+
+/**
+ * There is a race between registering this function and redis clients being able to call
+ * {@code CLUSTER SLOTS} and receive accurate information. To help with this the function is
+ * registered before the redis server is available, but is only initialized with the host and port
+ * once the redis server is running. If the function returns null it means that the function has
+ * not been initialized yet and callers, (from java), should retry.
+ */
+public class RedisMemberInfoRetrievalFunction implements InternalFunction<Void> {
+
+ public static final String ID = RedisMemberInfoRetrievalFunction.class.getName();
+ private static final long serialVersionUID = 2207969011229079993L;
+
+ private RedisMemberInfo myself = null;
+
+ public static RedisMemberInfoRetrievalFunction register() {
+ RedisMemberInfoRetrievalFunction infoFunction = new RedisMemberInfoRetrievalFunction();
+ FunctionService.registerFunction(infoFunction);
+ return infoFunction;
+ }
+
+ public void initialize(DistributedMember member, String address, int redisPort) {
+ String hostAddress;
+ if (address == null || address.isEmpty() || address.equals("0.0.0.0")) {
+ InetAddress localhost = null;
+ try {
+ localhost = LocalHostUtil.getLocalHost();
+ } catch (Exception ignored) {
+ }
+ hostAddress = localhost == null ? "127.0.0.1" : localhost.getHostAddress();
+ } else {
+ hostAddress = address;
+ }
+
+ myself = new RedisMemberInfo(member, hostAddress, redisPort);
+ }
+
+ @Override
+ public void execute(FunctionContext<Void> context) {
+ context.getResultSender().lastResult(myself);
+ }
+
+ @Override
+ public String getId() {
+ return ID;
+ }
+
+ @Override
+ public boolean optimizeForWrite() {
+ return true;
+ }
+}
diff --git a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/data/RedisHashCommandsFunctionExecutor.java b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/data/RedisHashCommandsFunctionExecutor.java
index 7fa4a05..a529369 100644
--- a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/data/RedisHashCommandsFunctionExecutor.java
+++ b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/data/RedisHashCommandsFunctionExecutor.java
@@ -28,8 +28,7 @@ import org.apache.geode.redis.internal.executor.hash.RedisHashCommands;
public class RedisHashCommandsFunctionExecutor extends RedisDataCommandsFunctionExecutor implements
RedisHashCommands {
- public RedisHashCommandsFunctionExecutor(
- CommandHelper helper) {
+ public RedisHashCommandsFunctionExecutor(CommandHelper helper) {
super(helper);
}
diff --git a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/data/RedisKey.java b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/data/RedisKey.java
index 95c6d83..43b614a 100644
--- a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/data/RedisKey.java
+++ b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/data/RedisKey.java
@@ -15,6 +15,9 @@
package org.apache.geode.redis.internal.data;
+import static org.apache.geode.redis.internal.RegionProvider.REDIS_SLOTS;
+import static org.apache.geode.redis.internal.RegionProvider.REDIS_SLOTS_PER_BUCKET;
+
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
@@ -55,6 +58,11 @@ public class RedisKey extends ByteArrayWrapper implements DataSerializableFixedI
crc16 = CRC16.calculate(value, startHashtag + 1, endHashtag);
}
+ public int getBucketId() {
+ // & (REDIS_SLOTS - 1) is equivalent to % REDIS_SLOTS but supposedly faster
+ return getCrc16() & (REDIS_SLOTS - 1) / REDIS_SLOTS_PER_BUCKET;
+ }
+
@Override
public int getDSFID() {
return DataSerializableFixedID.REDIS_KEY;
diff --git a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/executor/Executor.java b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/executor/Executor.java
index 3952e76..526f537 100755
--- a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/executor/Executor.java
+++ b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/executor/Executor.java
@@ -31,5 +31,5 @@ public interface Executor {
* @param command The command to be executed
* @param context The execution context by which this command is to be executed
*/
- RedisResponse executeCommand(Command command, ExecutionHandlerContext context);
+ RedisResponse executeCommand(Command command, ExecutionHandlerContext context) throws Exception;
}
diff --git a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/executor/cluster/ClusterExecutor.java b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/executor/cluster/ClusterExecutor.java
index 7d0b452..fbfe8cd 100644
--- a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/executor/cluster/ClusterExecutor.java
+++ b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/executor/cluster/ClusterExecutor.java
@@ -16,32 +16,20 @@
package org.apache.geode.redis.internal.executor.cluster;
import static org.apache.geode.redis.internal.RedisConstants.ERROR_UNKNOWN_CLUSTER_SUBCOMMAND;
-import static org.apache.geode.redis.internal.RegionProvider.REDIS_REGION_BUCKETS;
import static org.apache.geode.redis.internal.RegionProvider.REDIS_SLOTS;
import static org.apache.geode.redis.internal.RegionProvider.REDIS_SLOTS_PER_BUCKET;
-import static org.apache.geode.redis.internal.cluster.BucketInfoRetrievalFunction.MemberBuckets;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
-import java.util.TreeMap;
-
-import org.apache.commons.lang3.tuple.Pair;
-import org.apache.logging.log4j.Logger;
import org.apache.geode.cache.Region;
-import org.apache.geode.cache.execute.FunctionService;
-import org.apache.geode.cache.execute.ResultCollector;
import org.apache.geode.cache.partition.PartitionMemberInfo;
import org.apache.geode.cache.partition.PartitionRegionHelper;
import org.apache.geode.cache.partition.PartitionRegionInfo;
-import org.apache.geode.distributed.DistributedMember;
-import org.apache.geode.logging.internal.log4j.api.LogService;
-import org.apache.geode.redis.internal.cluster.BucketInfoRetrievalFunction;
+import org.apache.geode.redis.internal.SlotAdvisor;
import org.apache.geode.redis.internal.data.RedisData;
import org.apache.geode.redis.internal.data.RedisKey;
import org.apache.geode.redis.internal.executor.AbstractExecutor;
@@ -51,10 +39,9 @@ import org.apache.geode.redis.internal.netty.ExecutionHandlerContext;
public class ClusterExecutor extends AbstractExecutor {
- private static final Logger logger = LogService.getLogger();
-
@Override
- public RedisResponse executeCommand(Command command, ExecutionHandlerContext context) {
+ public RedisResponse executeCommand(Command command, ExecutionHandlerContext context)
+ throws Exception {
List<byte[]> args = command.getProcessedCommand();
String subCommand = new String(args.get(1));
@@ -73,68 +60,26 @@ public class ClusterExecutor extends AbstractExecutor {
}
}
- private RedisResponse getSlots(ExecutionHandlerContext ctx) {
- List<MemberBuckets> memberBuckets = getMemberBuckets(ctx);
-
- Map<Integer, String> primaryBucketToMemberMap = new HashMap<>();
- Map<String, Pair<String, Integer>> memberToHostPortMap = new TreeMap<>();
- int retrievedBucketCount = 0;
-
- for (MemberBuckets m : memberBuckets) {
- memberToHostPortMap.put(m.getMemberId(), Pair.of(m.getHostAddress(), m.getPort()));
- for (Integer id : m.getPrimaryBucketIds()) {
- primaryBucketToMemberMap.put(id, m.getMemberId());
- retrievedBucketCount++;
- }
- }
-
- if (retrievedBucketCount != REDIS_REGION_BUCKETS) {
- logger.warn("Bucket count mismatch {} != {}", retrievedBucketCount, REDIS_REGION_BUCKETS);
- }
-
- int index = 0;
+ private RedisResponse getSlots(ExecutionHandlerContext ctx) throws InterruptedException {
List<Object> slots = new ArrayList<>();
- for (int i = 0; i < REDIS_REGION_BUCKETS; i++) {
- String member = primaryBucketToMemberMap.get(i);
- if (member == null) {
+ for (SlotAdvisor.MemberBucketSlot mbs : ctx.getRegionProvider().getSlotAdvisor()
+ .getBucketSlots()) {
+ if (mbs == null) {
continue;
}
- Pair<String, Integer> primaryHostAndPort = memberToHostPortMap.get(member);
-
List<Object> entry = new ArrayList<>();
- entry.add(index * REDIS_SLOTS_PER_BUCKET);
- entry.add(((index + 1) * REDIS_SLOTS_PER_BUCKET) - 1);
- entry.add(Arrays.asList(primaryHostAndPort.getLeft(), primaryHostAndPort.getRight()));
+ entry.add(mbs.getSlotStart());
+ entry.add(mbs.getSlotEnd());
+ entry.add(Arrays.asList(mbs.getPrimaryIpAddress(), mbs.getPrimaryPort()));
slots.add(entry);
- index++;
}
return RedisResponse.array(slots);
}
- @SuppressWarnings("unchecked")
- private List<MemberBuckets> getMemberBuckets(
- ExecutionHandlerContext ctx) {
- Region<RedisKey, RedisData> dataRegion = ctx.getRegionProvider().getDataRegion();
-
- if (BucketInfoRetrievalFunction.getLocalPrimaryBucketIds(dataRegion).isEmpty()) {
- PartitionRegionHelper.assignBucketsToPartitions(dataRegion);
- }
-
- Set<DistributedMember> membersWithDataRegion = new HashSet<>();
- for (PartitionMemberInfo memberInfo : getRegionMembers(ctx)) {
- membersWithDataRegion.add(memberInfo.getDistributedMember());
- }
-
- ResultCollector<MemberBuckets, List<MemberBuckets>> resultCollector =
- FunctionService.onMembers(membersWithDataRegion).execute(BucketInfoRetrievalFunction.ID);
-
- return resultCollector.getResult();
- }
-
/**
* The format being produced is something like this:
*
@@ -145,28 +90,37 @@ public class ClusterExecutor extends AbstractExecutor {
* </pre>
*
* Note that there are no 'slave' entries since Geode does not host all secondary data apart from
- * primary as redis does. The cluster port is provided only for consistency with the format
- * of the output.
+ * primary as redis does. The cluster port is provided only for consistency with the format of the
+ * output.
*/
- private RedisResponse getNodes(ExecutionHandlerContext ctx) {
- List<MemberBuckets> memberBuckets = getMemberBuckets(ctx);
+ private RedisResponse getNodes(ExecutionHandlerContext ctx) throws InterruptedException {
String memberId = ctx.getMemberName();
+ Map<String, List<Integer>> memberBuckets =
+ ctx.getRegionProvider().getSlotAdvisor().getMemberBuckets();
+ List<SlotAdvisor.MemberBucketSlot> memberBucketSlots =
+ ctx.getRegionProvider().getSlotAdvisor().getBucketSlots();
StringBuilder response = new StringBuilder();
- for (MemberBuckets m : memberBuckets) {
- response.append(String.format("%s %s:%d@%d master",
- m.getMemberId(), m.getHostAddress(), m.getPort(), m.getPort()));
+ for (Map.Entry<String, List<Integer>> member : memberBuckets.entrySet()) {
+ List<Integer> buckets = member.getValue();
+ SlotAdvisor.MemberBucketSlot mbs = memberBucketSlots.get(buckets.get(0));
+ if (mbs == null) {
+ continue;
+ }
- if (m.getMemberId().equals(memberId)) {
+ response.append(String.format("%s %s:%3$d@%3$d master",
+ member.getKey(), mbs.getPrimaryIpAddress(), mbs.getPrimaryPort()));
+
+ if (member.getKey().equals(memberId)) {
response.append(",myself");
}
response.append(" - 0 0 1 connected");
- for (Integer index : m.getPrimaryBucketIds()) {
+ for (int bucket : member.getValue()) {
response.append(" ");
- response.append(index * REDIS_SLOTS_PER_BUCKET);
+ response.append(bucket * REDIS_SLOTS_PER_BUCKET);
response.append("-");
- response.append(((index + 1) * REDIS_SLOTS_PER_BUCKET) - 1);
+ response.append(((bucket + 1) * REDIS_SLOTS_PER_BUCKET) - 1);
}
response.append("\n");
@@ -175,7 +129,6 @@ public class ClusterExecutor extends AbstractExecutor {
return RedisResponse.bulkString(response.toString());
}
-
private RedisResponse getInfo(ExecutionHandlerContext ctx) {
int memberCount = getRegionMembers(ctx).size();
diff --git a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/executor/cluster/RedisPartitionResolver.java b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/executor/cluster/RedisPartitionResolver.java
index 38f2034..1e1d886 100644
--- a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/executor/cluster/RedisPartitionResolver.java
+++ b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/executor/cluster/RedisPartitionResolver.java
@@ -15,9 +15,6 @@
package org.apache.geode.redis.internal.executor.cluster;
-import static org.apache.geode.redis.internal.RegionProvider.REDIS_SLOTS;
-import static org.apache.geode.redis.internal.RegionProvider.REDIS_SLOTS_PER_BUCKET;
-
import org.apache.geode.cache.EntryOperation;
import org.apache.geode.cache.PartitionResolver;
import org.apache.geode.redis.internal.data.RedisData;
@@ -27,8 +24,7 @@ public class RedisPartitionResolver implements PartitionResolver<RedisKey, Redis
@Override
public Object getRoutingObject(EntryOperation<RedisKey, RedisData> opDetails) {
- // & (REDIS_SLOTS - 1) is equivalent to % REDIS_SLOTS but supposedly faster
- return opDetails.getKey().getCrc16() & (REDIS_SLOTS - 1) / REDIS_SLOTS_PER_BUCKET;
+ return opDetails.getKey().getBucketId();
}
@Override
diff --git a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/netty/Command.java b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/netty/Command.java
index fe35428..4a17c70 100755
--- a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/netty/Command.java
+++ b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/netty/Command.java
@@ -183,7 +183,7 @@ public class Command {
return builder.toString();
}
- public RedisResponse execute(ExecutionHandlerContext executionHandlerContext) {
+ public RedisResponse execute(ExecutionHandlerContext executionHandlerContext) throws Exception {
RedisCommandType type = getCommandType();
return type.executeCommand(this, executionHandlerContext);
}
diff --git a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/netty/ExecutionHandlerContext.java b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/netty/ExecutionHandlerContext.java
index 5abe6a3..ff66f3f 100644
--- a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/netty/ExecutionHandlerContext.java
+++ b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/netty/ExecutionHandlerContext.java
@@ -50,6 +50,7 @@ import org.apache.geode.redis.internal.ParameterRequirements.RedisParametersMism
import org.apache.geode.redis.internal.RedisCommandType;
import org.apache.geode.redis.internal.RedisConstants;
import org.apache.geode.redis.internal.RegionProvider;
+import org.apache.geode.redis.internal.data.CommandHelper;
import org.apache.geode.redis.internal.data.RedisDataTypeMismatchException;
import org.apache.geode.redis.internal.executor.CommandFunction;
import org.apache.geode.redis.internal.executor.RedisResponse;
@@ -84,6 +85,7 @@ public class ExecutionHandlerContext extends ChannelInboundHandlerAdapter {
private final RedisStats redisStats;
private final EventLoopGroup subscriberGroup;
private final DistributedMember member;
+ private final CommandHelper commandHelper;
private BigInteger scanCursor;
private BigInteger sscanCursor;
private final AtomicBoolean channelInactive = new AtomicBoolean();
@@ -113,7 +115,8 @@ public class ExecutionHandlerContext extends ChannelInboundHandlerAdapter {
EventLoopGroup subscriberGroup,
byte[] password,
int serverPort,
- DistributedMember member) {
+ DistributedMember member,
+ CommandHelper commandHelper) {
this.channel = channel;
this.regionProvider = regionProvider;
this.pubsub = pubsub;
@@ -127,6 +130,7 @@ public class ExecutionHandlerContext extends ChannelInboundHandlerAdapter {
this.isAuthenticated = password == null;
this.serverPort = serverPort;
this.member = member;
+ this.commandHelper = commandHelper;
this.scanCursor = new BigInteger("0");
this.sscanCursor = new BigInteger("0");
redisStats.addClient();
@@ -281,7 +285,7 @@ public class ExecutionHandlerContext extends ChannelInboundHandlerAdapter {
}
}
- private void executeCommand(Command command) {
+ private void executeCommand(Command command) throws Exception {
try {
if (logger.isDebugEnabled()) {
logger.debug("Executing Redis command: {} - {}", command,
@@ -332,7 +336,7 @@ public class ExecutionHandlerContext extends ChannelInboundHandlerAdapter {
return allowUnsupportedSupplier.get();
}
- private RedisResponse handleUnAuthenticatedCommand(Command command) {
+ private RedisResponse handleUnAuthenticatedCommand(Command command) throws Exception {
RedisResponse response;
if (command.isOfType(RedisCommandType.AUTH)) {
response = command.execute(this);
@@ -436,6 +440,11 @@ public class ExecutionHandlerContext extends ChannelInboundHandlerAdapter {
return member.getUniqueId();
}
+
+ public CommandHelper getCommandHelper() {
+ return commandHelper;
+ }
+
/**
* This method and {@link #eventLoopReady()} are relevant for pubsub related commands which need
* to return responses on a different EventLoopGroup. We need to ensure that the EventLoopGroup
@@ -468,4 +477,5 @@ public class ExecutionHandlerContext extends ChannelInboundHandlerAdapter {
public RedisHashCommands getRedisHashCommands() {
return regionProvider.getHashCommands();
}
+
}
diff --git a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/netty/NettyRedisServer.java b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/netty/NettyRedisServer.java
index ce6b845..e2d1924 100644
--- a/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/netty/NettyRedisServer.java
+++ b/geode-apis-compatible-with-redis/src/main/java/org/apache/geode/redis/internal/netty/NettyRedisServer.java
@@ -60,6 +60,7 @@ import org.apache.geode.logging.internal.executors.LoggingThreadFactory;
import org.apache.geode.logging.internal.log4j.api.LogService;
import org.apache.geode.management.ManagementException;
import org.apache.geode.redis.internal.RegionProvider;
+import org.apache.geode.redis.internal.data.CommandHelper;
import org.apache.geode.redis.internal.pubsub.PubSub;
import org.apache.geode.redis.internal.statistics.RedisStats;
@@ -87,12 +88,14 @@ public class NettyRedisServer {
private final Channel serverChannel;
private final int serverPort;
private final DistributedMember member;
+ private final CommandHelper commandHelper;
public NettyRedisServer(Supplier<DistributionConfig> configSupplier,
RegionProvider regionProvider, PubSub pubsub,
Supplier<Boolean> allowUnsupportedSupplier,
Runnable shutdownInvoker, int port, String requestedAddress,
- RedisStats redisStats, ExecutorService backgroundExecutor, DistributedMember member) {
+ RedisStats redisStats, ExecutorService backgroundExecutor, DistributedMember member,
+ CommandHelper commandHelper) {
this.configSupplier = configSupplier;
this.regionProvider = regionProvider;
this.pubsub = pubsub;
@@ -101,6 +104,7 @@ public class NettyRedisServer {
this.redisStats = redisStats;
this.backgroundExecutor = backgroundExecutor;
this.member = member;
+ this.commandHelper = commandHelper;
if (port < RANDOM_PORT_INDICATOR) {
throw new IllegalArgumentException(
@@ -178,7 +182,7 @@ public class NettyRedisServer {
pipeline.addLast(ExecutionHandlerContext.class.getSimpleName(),
new ExecutionHandlerContext(socketChannel, regionProvider, pubsub,
allowUnsupportedSupplier, shutdownInvoker, redisStats, backgroundExecutor,
- subscriberGroup, redisPasswordBytes, getPort(), member));
+ subscriberGroup, redisPasswordBytes, getPort(), member, commandHelper));
}
};
}
diff --git a/geode-apis-compatible-with-redis/src/main/resources/org/apache/geode/redis/internal/sanctioned-geode-apis-compatible-with-redis-serializables.txt b/geode-apis-compatible-with-redis/src/main/resources/org/apache/geode/redis/internal/sanctioned-geode-apis-compatible-with-redis-serializables.txt
index 460588a..0ece538 100755
--- a/geode-apis-compatible-with-redis/src/main/resources/org/apache/geode/redis/internal/sanctioned-geode-apis-compatible-with-redis-serializables.txt
+++ b/geode-apis-compatible-with-redis/src/main/resources/org/apache/geode/redis/internal/sanctioned-geode-apis-compatible-with-redis-serializables.txt
@@ -1,8 +1,6 @@
org/apache/geode/redis/internal/ParameterRequirements/RedisParametersMismatchException,true,-643700717871858072
org/apache/geode/redis/internal/RedisCommandSupportLevel,false
org/apache/geode/redis/internal/RedisCommandType,false,deferredParameterRequirements:org/apache/geode/redis/internal/ParameterRequirements/ParameterRequirements,executor:org/apache/geode/redis/internal/executor/Executor,parameterRequirements:org/apache/geode/redis/internal/ParameterRequirements/ParameterRequirements,supportLevel:org/apache/geode/redis/internal/RedisCommandSupportLevel
-org/apache/geode/redis/internal/cluster/BucketInfoRetrievalFunction,false,hostAddress:java/lang/String,redisPort:int
-org/apache/geode/redis/internal/cluster/BucketInfoRetrievalFunction$MemberBuckets,false,hostAddress:java/lang/String,memberId:java/lang/String,port:int,primaryBucketIds:java/util/Set
org/apache/geode/redis/internal/data/NullRedisSet$SetOp,false
org/apache/geode/redis/internal/data/NullRedisString$BitOp,false
org/apache/geode/redis/internal/data/RedisDataType,false,toStringValue:java/lang/String
diff --git a/geode-serialization/src/main/java/org/apache/geode/internal/serialization/DataSerializableFixedID.java b/geode-serialization/src/main/java/org/apache/geode/internal/serialization/DataSerializableFixedID.java
index 9fcebb1..462f7b4 100644
--- a/geode-serialization/src/main/java/org/apache/geode/internal/serialization/DataSerializableFixedID.java
+++ b/geode-serialization/src/main/java/org/apache/geode/internal/serialization/DataSerializableFixedID.java
@@ -687,6 +687,7 @@ public interface DataSerializableFixedID extends SerializationVersions, BasicSer
short REDIS_HASH_ID = 2188;
short REDIS_NULL_DATA_ID = 2189;
short REDIS_SET_OPTIONS_ID = 2190;
+ short REDIS_MEMBER_INFO_ID = 2191;
// NOTE, codes > 65535 will take 4 bytes to serialize
/**