You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by ja...@apache.org on 2018/02/09 23:04:48 UTC
[geode] branch develop updated: GEODE-3813: Deprecating
RegisterInterest ALL_KEYS and List behavior (#1376)
This is an automated email from the ASF dual-hosted git repository.
jasonhuynh 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 66dbc8e GEODE-3813: Deprecating RegisterInterest ALL_KEYS and List behavior (#1376)
66dbc8e is described below
commit 66dbc8eb8d8fca7b55aed80322970400ee5f3627
Author: Jason Huynh <hu...@gmail.com>
AuthorDate: Fri Feb 9 15:04:43 2018 -0800
GEODE-3813: Deprecating RegisterInterest ALL_KEYS and List behavior (#1376)
---
.../main/java/org/apache/geode/cache/Region.java | 342 +++++++++++++++++++--
.../cache/client/internal/ServerRegionProxy.java | 3 +-
.../apache/geode/internal/cache/LocalRegion.java | 4 +
.../sockets/RegisterInterestIntegrationTest.java | 331 ++++++++++++++++++++
4 files changed, 658 insertions(+), 22 deletions(-)
diff --git a/geode-core/src/main/java/org/apache/geode/cache/Region.java b/geode-core/src/main/java/org/apache/geode/cache/Region.java
index 5073b8b..a933e51 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/Region.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/Region.java
@@ -1510,22 +1510,29 @@ public interface Region<K, V> extends ConcurrentMap<K, V> {
* cleared from the client and current value for this key is inserted into the local cache before
* this call returns.
*
- * @param key The key on which to register interest. If the key is a <code>List</code>, then all
- * the keys in the <code>List</code> will be registered. The key can also be the special
- * token 'ALL_KEYS', which will register interest in all keys in the region. In effect,
- * this will cause an update to any key in this region in the CacheServer to be pushed to
- * the client.
+ * @param key The key on which to register interest.
+ *
+ * The following <code>List</code> and 'ALL_KEYS' behavior is now deprecated. As an
+ * alternative, please use {@link #registerInterestForKeys(Iterable)} and
+ * {@link #registerInterestForAllKeys()}
+ *
+ * Deprecated behavior: If the key is a <code>List</code>, then all the keys in the
+ * <code>List</code> will be registered. The key can also be the special token 'ALL_KEYS',
+ * which will register interest in all keys in the region. In effect, this will cause an
+ * update to any key in this region in the CacheServer to be pushed to the client.
*
* <p>
* This method uses the default <code>InterestResultPolicy</code>.
* </p>
*
* <p>
- * <i>Using 'ALL_KEYS' is the same as calling {@link #registerInterestRegex(String)} with
+ * <i> Using 'ALL_KEYS' is the same as calling {@link #registerInterestRegex(String)} with
* ".*" as the argument. This means that all keys any type are pushed to the client and
* inserted into the local cache.</i>
* </p>
*
+ * End of deprecation
+ *
* <p>
* If you locally-destroy a key and your region has concurrency-checks-enabled turned off
* you will not receive invalidation events from your interest subscription for that key.
@@ -1558,17 +1565,22 @@ public interface Region<K, V> extends ConcurrentMap<K, V> {
* events to your client cache.
* </p>
*
- * @param key The key on which to register interest. If the key is a <code>List</code>, then all
- * the keys in the <code>List</code> will be registered. The key can also be the special
- * token 'ALL_KEYS', which will register interest in all keys in the region. In effect,
- * this will cause an update to any key in this region in the CacheServer to be pushed to
- * the client.
+ * @param key The key on which to register interest. The following <code>List</code> and
+ * 'ALL_KEYS' behavior is now deprecated. As an alternative, please use
+ * {@link #registerInterestForKeys(Iterable, InterestResultPolicy)} and
+ * {@link #registerInterestForAllKeys(InterestResultPolicy)}
+ *
+ * Deprecated behavior: If the key is a <code>List</code>, then all the keys in the
+ * <code>List</code> will be registered. The key can also be the special token 'ALL_KEYS',
+ * which will register interest in all keys in the region. In effect, this will cause an
+ * update to any key in this region in the CacheServer to be pushed to the client.
*
* <p>
* <i>Using 'ALL_KEYS' is the same as calling {@link #registerInterestRegex(String)} with
* ".*" as the argument. This means that all keys of any type are pushed to the client and
* inserted into the local cache.</i>
* </p>
+ * End of deprecation
*
* @param policy The interest result policy. This can be one of:
* <ul>
@@ -1589,6 +1601,271 @@ public interface Region<K, V> extends ConcurrentMap<K, V> {
*/
void registerInterest(K key, InterestResultPolicy policy);
+
+ /**
+ * Sends a request to the CacheServer to register interest in all keys for this client. Updates to
+ * any key by other clients will be pushed to this client by the CacheServer. This method is
+ * currently supported only on clients in a client server topology. The keys are first locally
+ * cleared from the client and current value for the keys are inserted into the local cache before
+ * this call returns.
+ *
+ * @since Geode 1.5
+ *
+ * @throws UnsupportedOperationException if the region is not configured with a pool name.
+ * @throws SubscriptionNotEnabledException if the region's pool does not have subscriptions
+ * enabled.
+ * @throws UnsupportedOperationException if the region is a replicate with distributed scope.
+ */
+ default void registerInterestForAllKeys() {
+ registerInterestRegex(".*");
+ }
+
+
+ /**
+ * Sends a request to the CacheServer to register interest in for all keys for this client.
+ * Updates to any key by other clients will be pushed to this client by the CacheServer. This
+ * method is currently supported only on clients in a client server topology. The keys are first
+ * locally cleared from the client and current value for the keys are inserted into the local
+ * cache before this call returns. (if requested).
+ *
+ * <p>
+ * If you locally-destroy a key and your region has concurrency-checks-enabled turned off you will
+ * not receive invalidation events from your interest subscription for that key. When
+ * concurrency-checks-enabled is turned on GemFire will accept invalidation and deliver these
+ * events to your client cache.
+ * </p>
+ *
+ * @param policy The interest result policy. This can be one of:
+ * <ul>
+ * <li>InterestResultPolicy.NONE - does not initialize the local cache</li>
+ * <li>InterestResultPolicy.KEYS - initializes the local cache with the keys satisfying the
+ * request</li>
+ * <li>InterestResultPolicy.KEYS_VALUES - initializes the local cache with the keys and
+ * current values satisfying the request</li>
+ * </ul>
+ * @throws UnsupportedOperationException if the region is not configured with a pool name.
+ * @throws SubscriptionNotEnabledException if the region's pool does not have subcriptions
+ * enabled.
+ * @throws UnsupportedOperationException if the region is a replicate with distributed scope.
+ *
+ * @see InterestResultPolicy
+ *
+ * @since Geode 1.5
+ */
+ default void registerInterestForAllKeys(InterestResultPolicy policy) {
+ registerInterestRegex(".*", policy);
+ }
+
+ /**
+ * Sends a request to the CacheServer to register interest in all keys for this client. Updates to
+ * any key by other clients will be pushed to this client by the CacheServer. This method is
+ * currently supported only on clients in a client server topology. The keys are first locally
+ * cleared from the client and the current value for the keys are inserted into the local cache
+ * before this call returns (if requested).
+ *
+ * @param policy The interest result policy. This can be one of:
+ * <ul>
+ * <li>InterestResultPolicy.NONE - does not initialize the local cache</li>
+ * <li>InterestResultPolicy.KEYS - initializes the local cache with the keys satisfying the
+ * request</li>
+ * <li>InterestResultPolicy.KEYS_VALUES - initializes the local cache with the keys and
+ * current values satisfying the request</li>
+ * </ul>
+ * @param isDurable true if the register interest is durable
+ * @throws UnsupportedOperationException if the region is not configured with a pool name.
+ * @throws SubscriptionNotEnabledException if the region's pool does not have subscriptions
+ * enabled.
+ * @throws UnsupportedOperationException if the region is a replicate with distributed scope.
+ *
+ * @see InterestResultPolicy
+ *
+ * @since Geode 1.5
+ */
+ default void registerInterestForAllKeys(InterestResultPolicy policy, boolean isDurable) {
+ registerInterestRegex(".*", policy, isDurable);
+ }
+
+
+ /**
+ * Sends a request to the CacheServer to register interest in all keys for this client. Updates to
+ * any key by other clients will be pushed to this client by the CacheServer. This method is
+ * currently supported only on clients in a client server topology. The keys are first locally
+ * cleared from the client and the current value for the keys are inserted into the local cache
+ * before this call returns (if requested).
+ *
+ * <p>
+ * If you locally-destroy a key and your region has concurrency-checks-enabled turned off you will
+ * not receive invalidation events from your interest subscription for that key. When
+ * concurrency-checks-enabled is turned on GemFire will accept invalidation and deliver these
+ * events to your client cache.
+ * </p>
+ *
+ * @param policy The interest result policy. This can be one of:
+ * <ul>
+ * <li>InterestResultPolicy.NONE - does not initialize the local cache</li>
+ * <li>InterestResultPolicy.KEYS - initializes the local cache with the keys satisfying the
+ * request</li>
+ * <li>InterestResultPolicy.KEYS_VALUES - initializes the local cache with the keys and
+ * current values satisfying the request</li>
+ * </ul>
+ * @param isDurable true if the register interest is durable
+ * @param receiveValues defaults to true. set to false to receive create or update events as
+ * invalidates similar to notify-by-subscription false.
+ * @throws UnsupportedOperationException if the region is not configured with a pool name.
+ * @throws SubscriptionNotEnabledException if the region's pool does not have subscriptions
+ * enabled.
+ * @throws UnsupportedOperationException if the region is a replicate with distributed scope.
+ *
+ * @see InterestResultPolicy
+ *
+ * @since Geode 1.5
+ */
+ default void registerInterestForAllKeys(InterestResultPolicy policy, boolean isDurable,
+ boolean receiveValues) {
+ registerInterestRegex(".*", policy, isDurable, receiveValues);
+ }
+
+ /**
+ * Sends a request to the CacheServer to register interest for all key in the iterable for this
+ * client. Updates to any of the keys in the iterable by other clients will be pushed to this
+ * client by the CacheServer. This method is currently supported only on clients in a client
+ * server topology. The keys are first locally cleared from the client and current value for the
+ * keys are inserted into the local cache before this call returns. (if requested).
+ *
+ * <p>
+ * If you locally-destroy a key and your region has concurrency-checks-enabled turned off you will
+ * not receive invalidation events from your interest subscription for that key. When
+ * concurrency-checks-enabled is turned on GemFire will accept invalidation and deliver these
+ * events to your client cache.
+ * </p>
+ *
+ * @param iterable The <code>Iterable</code> of keys on which to register interest.
+ * @throws UnsupportedOperationException if the region is not configured with a pool name.
+ * @throws SubscriptionNotEnabledException if the region's pool does not have subcriptions
+ * enabled.
+ * @throws UnsupportedOperationException if the region is a replicate with distributed scope.
+ **
+ * @since Geode 1.5
+ */
+ default void registerInterestForKeys(Iterable<K> iterable) {
+ iterable.forEach(k -> registerInterest(k));
+ }
+
+ /**
+ * Sends a request to the CacheServer to register interest for all key in the iterable for this
+ * client. Updates to any of the keys in the iterable by other clients will be pushed to this
+ * client by the CacheServer. This method is currently supported only on clients in a client
+ * server topology. The keys are first locally cleared from the client and current value for the
+ * keys are inserted into the local cache before this call returns. (if requested).
+ *
+ * <p>
+ * If you locally-destroy a key and your region has concurrency-checks-enabled turned off you will
+ * not receive invalidation events from your interest subscription for that key. When
+ * concurrency-checks-enabled is turned on GemFire will accept invalidation and deliver these
+ * events to your client cache.
+ * </p>
+ *
+ * @param iterable The <code>Iterable</code> of keys on which to register interest.
+ * @param policy The interest result policy. This can be one of:
+ * <ul>
+ * <li>InterestResultPolicy.NONE - does not initialize the local cache</li>
+ * <li>InterestResultPolicy.KEYS - initializes the local cache with the keys satisfying the
+ * request</li>
+ * <li>InterestResultPolicy.KEYS_VALUES - initializes the local cache with the keys and
+ * current values satisfying the request</li>
+ * </ul>
+ * @throws UnsupportedOperationException if the region is not configured with a pool name.
+ * @throws SubscriptionNotEnabledException if the region's pool does not have subcriptions
+ * enabled.
+ * @throws UnsupportedOperationException if the region is a replicate with distributed scope.
+ *
+ * @see InterestResultPolicy
+ *
+ * @since Geode 1.5
+ */
+ default void registerInterestForKeys(Iterable<K> iterable, InterestResultPolicy policy) {
+ iterable.forEach(k -> registerInterest(k, policy));
+ }
+
+ /**
+ * Sends a request to the CacheServer to register interest for all key in the iterable for this
+ * client. Updates to any of the keys in the iterable by other clients will be pushed to this
+ * client by the CacheServer. This method is currently supported only on clients in a client
+ * server topology. The keys are first locally cleared from the client and current value for the
+ * keys are inserted into the local cache before this call returns. (if requested).
+ *
+ * <p>
+ * If you locally-destroy a key and your region has concurrency-checks-enabled turned off you will
+ * not receive invalidation events from your interest subscription for that key. When
+ * concurrency-checks-enabled is turned on GemFire will accept invalidation and deliver these
+ * events to your client cache.
+ * </p>
+ *
+ * @param iterable The <code>Iterable</code> of keys on which to register interest.
+ * @param policy The interest result policy. This can be one of:
+ * <ul>
+ * <li>InterestResultPolicy.NONE - does not initialize the local cache</li>
+ * <li>InterestResultPolicy.KEYS - initializes the local cache with the keys satisfying the
+ * request</li>
+ * <li>InterestResultPolicy.KEYS_VALUES - initializes the local cache with the keys and
+ * current values satisfying the request</li>
+ * </ul>
+ * @param isDurable true if the register interest is durable
+ * @throws UnsupportedOperationException if the region is not configured with a pool name.
+ * @throws SubscriptionNotEnabledException if the region's pool does not have subcriptions
+ * enabled.
+ * @throws UnsupportedOperationException if the region is a replicate with distributed scope.
+ *
+ * @see InterestResultPolicy
+ *
+ * @since Geode 1.5
+ */
+ default void registerInterestForKeys(Iterable<K> iterable, InterestResultPolicy policy,
+ boolean isDurable) {
+ iterable.forEach(k -> registerInterest(k, policy, isDurable));
+ }
+
+ /**
+ * Sends a request to the CacheServer to register interest for all key in the iterable for this
+ * client. Updates to any of the keys in the iterable by other clients will be pushed to this
+ * client by the CacheServer. This method is currently supported only on clients in a client
+ * server topology. The keys are first locally cleared from the client and current value for the
+ * keys are inserted into the local cache before this call returns. (if requested).
+ *
+ * <p>
+ * If you locally-destroy a key and your region has concurrency-checks-enabled turned off you will
+ * not receive invalidation events from your interest subscription for that key. When
+ * concurrency-checks-enabled is turned on GemFire will accept invalidation and deliver these
+ * events to your client cache.
+ * </p>
+ *
+ * @param iterable The <code>Iterable</code> of keys on which to register interest.
+ * @param policy The interest result policy. This can be one of:
+ * <ul>
+ * <li>InterestResultPolicy.NONE - does not initialize the local cache</li>
+ * <li>InterestResultPolicy.KEYS - initializes the local cache with the keys satisfying the
+ * request</li>
+ * <li>InterestResultPolicy.KEYS_VALUES - initializes the local cache with the keys and
+ * current values satisfying the request</li>
+ * </ul>
+ * @param isDurable true if the register interest is durable
+ * @param receiveValues defaults to true. set to false to receive create or update events as
+ * invalidates similar to notify-by-subscription false.
+ * @throws UnsupportedOperationException if the region is not configured with a pool name.
+ * @throws SubscriptionNotEnabledException if the region's pool does not have subcriptions
+ * enabled.
+ * @throws UnsupportedOperationException if the region is a replicate with distributed scope.
+ *
+ * @see InterestResultPolicy
+ *
+ * @since Geode 1.5
+ */
+ default void registerInterestForKeys(Iterable<K> iterable, InterestResultPolicy policy,
+ boolean isDurable, boolean receiveValues) {
+ iterable.forEach(k -> registerInterest(k, policy, isDurable, receiveValues));
+ }
+
+
/**
* Sends a request to the CacheServer to register interest in a regular expression pattern for
* this client. Updates to any keys of type {@link String} satisfying this regular expression by
@@ -1809,17 +2086,28 @@ public interface Region<K, V> extends ConcurrentMap<K, V> {
* events to your client cache.
* </p>
*
- * @param key The key on which to register interest. If the key is a <code>List</code>, then all
- * the keys in the <code>List</code> will be registered. The key can also be the special
- * token 'ALL_KEYS', which will register interest in all keys in the region. In effect,
- * this will cause an update to any key in this region in the CacheServer to be pushed to
- * the client.
+ * @param key The key on which to register interest.
+ *
+ * The following <code>List</code> and 'ALL_KEYS' behavior is now deprecated. As an
+ * alternative, please use
+ * {@link #registerInterestForKeys(Iterable, InterestResultPolicy, boolean, boolean)} and
+ * {@link #registerInterestForAllKeys(InterestResultPolicy, boolean, boolean)}
+ *
+ * Deprecated behavior: If the key is a <code>List</code>, then all the keys in the
+ * <code>List</code> will be registered. The key can also be the special token 'ALL_KEYS',
+ * which will register interest in all keys in the region. In effect, this will cause an
+ * update to any key in this region in the CacheServer to be pushed to the client.
+ *
+ * <p>
+ * This method uses the default <code>InterestResultPolicy</code>.
+ * </p>
*
* <p>
* <i>Using 'ALL_KEYS' is the same as calling {@link #registerInterestRegex(String)} with
* ".*" as the argument. This means that all keys of any type are pushed to the client and
* inserted into the local cache.</i>
* </p>
+ * End of deprecation.
*
* @param policy The interest result policy. This can be one of:
* <ul>
@@ -1851,11 +2139,21 @@ public interface Region<K, V> extends ConcurrentMap<K, V> {
* cleared from the client and the current value for this key is inserted into the local cache
* before this call returns (if requested).
*
- * @param key The key on which to register interest. If the key is a <code>List</code>, then all
- * the keys in the <code>List</code> will be registered. The key can also be the special
- * token 'ALL_KEYS', which will register interest in all keys in the region. In effect,
- * this will cause an update to any key in this region in the CacheServer to be pushed to
- * the client.
+ * @param key The key on which to register interest.
+ *
+ * The following <code>List</code> and 'ALL_KEYS' behavior is now deprecated. As an
+ * alternative, please use
+ * {@link #registerInterestForKeys(Iterable, InterestResultPolicy, boolean)} and
+ * {@link #registerInterestForAllKeys(InterestResultPolicy, boolean)}
+ *
+ * Deprecated behavior: If the key is a <code>List</code>, then all the keys in the
+ * <code>List</code> will be registered. The key can also be the special token 'ALL_KEYS',
+ * which will register interest in all keys in the region. In effect, this will cause an
+ * update to any key in this region in the CacheServer to be pushed to the client.
+ *
+ * <p>
+ * This method uses the default <code>InterestResultPolicy</code>.
+ * </p>
*
* <p>
* <i>Using 'ALL_KEYS' is the same as calling {@link #registerInterestRegex(String)} with
@@ -1863,6 +2161,8 @@ public interface Region<K, V> extends ConcurrentMap<K, V> {
* inserted into the local cache.</i>
* </p>
*
+ * End of deprecation.
+ *
* <p>
* If you locally-destroy a key and your region has concurrency-checks-enabled turned off
* you will not receive invalidation events from your interest subscription for that key.
diff --git a/geode-core/src/main/java/org/apache/geode/cache/client/internal/ServerRegionProxy.java b/geode-core/src/main/java/org/apache/geode/cache/client/internal/ServerRegionProxy.java
index 96a6e51..69bcd91 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/client/internal/ServerRegionProxy.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/client/internal/ServerRegionProxy.java
@@ -345,10 +345,11 @@ public class ServerRegionProxy extends ServerProxy implements ServerRegionDataAc
final InterestResultPolicy policy, final boolean isDurable,
final boolean receiveUpdatesAsInvalidates, final byte regionDataPolicy) {
if (interestType == InterestType.KEY && key instanceof List) {
+ logger.warn(
+ "Usage of registerInterest(List) has been deprecated. Please use registerInterestForKeys(Iterable)");
return registerInterestList((List) key, policy, isDurable, receiveUpdatesAsInvalidates,
regionDataPolicy);
} else {
-
final RegisterInterestTracker rit = this.pool.getRITracker();
List result = null;
boolean finished = false;
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/LocalRegion.java b/geode-core/src/main/java/org/apache/geode/internal/cache/LocalRegion.java
index 914ce5d..77dc518 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/LocalRegion.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/LocalRegion.java
@@ -3747,10 +3747,14 @@ public class LocalRegion extends AbstractRegion implements LoaderHelperFactory,
case InterestType.KEY:
if (key instanceof String && key.equals("ALL_KEYS")) {
+ logger.warn(
+ "Usage of registerInterest('ALL_KEYS') has been deprecated. Please use registerInterestForAllKeys()");
serverKeys = proxy.registerInterest(".*", InterestType.REGULAR_EXPRESSION,
interestResultPolicy, isDurable, receiveUpdatesAsInvalidates, regionDataPolicy);
} else {
if (key instanceof List) {
+ logger.warn(
+ "Usage of registerInterest(List) has been deprecated. Please use registerInterestForKeys(Iterable)");
serverKeys = proxy.registerInterestList((List) key, interestResultPolicy, isDurable,
receiveUpdatesAsInvalidates, regionDataPolicy);
} else {
diff --git a/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/RegisterInterestIntegrationTest.java b/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/RegisterInterestIntegrationTest.java
new file mode 100644
index 0000000..ef7a3ac
--- /dev/null
+++ b/geode-core/src/test/java/org/apache/geode/internal/cache/tier/sockets/RegisterInterestIntegrationTest.java
@@ -0,0 +1,331 @@
+/*
+ * 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.internal.cache.tier.sockets;
+
+import static junit.framework.TestCase.assertEquals;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Properties;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+import org.awaitility.Awaitility;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import org.apache.geode.cache.Cache;
+import org.apache.geode.cache.InterestResultPolicy;
+import org.apache.geode.cache.Region;
+import org.apache.geode.cache.RegionShortcut;
+import org.apache.geode.cache.client.ClientCache;
+import org.apache.geode.cache.client.ClientCacheFactory;
+import org.apache.geode.cache.client.ClientRegionShortcut;
+import org.apache.geode.test.dunit.rules.ClusterStartupRule;
+import org.apache.geode.test.dunit.rules.MemberVM;
+import org.apache.geode.test.junit.categories.IntegrationTest;
+
+@Category({IntegrationTest.class})
+public class RegisterInterestIntegrationTest {
+
+ private MemberVM locator;
+ private int locatorPort;
+ private MemberVM server;
+
+ @Rule
+ public ClusterStartupRule locatorServerStartupRule = new ClusterStartupRule();
+
+ @Before
+ public void before() throws Exception {
+ locator = locatorServerStartupRule.startLocatorVM(1, new Properties());
+ locatorPort = locator.getPort();
+ server = locatorServerStartupRule.startServerVM(3, locatorPort);
+ createServerRegion(server, RegionShortcut.PARTITION);
+ }
+
+ @Test
+ public void registerInterestAllKeysShouldRegisterForAllKeys() throws Exception {
+
+ ClientCache clientCache = createClientCache(locatorPort);
+
+ Region region =
+ clientCache.createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY).create("region");
+ region.registerInterestForAllKeys();
+
+ server.invoke(() -> {
+ Region regionOnServer = ClusterStartupRule.getCache().getRegion("region");
+ regionOnServer.put("some key", "some value");
+ regionOnServer.put(new ArrayList(), new ArrayList());
+ regionOnServer.put(1, 2);
+ });
+
+ Awaitility.await().atMost(10, TimeUnit.SECONDS).until(() -> assertEquals(3, region.size()));
+ }
+
+ @Test
+ public void registerInterestAllKeysWithInterestPolicyShouldRegisterForAllKeys() throws Exception {
+
+ ClientCache clientCache = createClientCache(locatorPort);
+
+ Region region =
+ clientCache.createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY).create("region");
+ region.registerInterestForAllKeys(InterestResultPolicy.KEYS);
+
+ server.invoke(() -> {
+ Region regionOnServer = ClusterStartupRule.getCache().getRegion("region");
+ regionOnServer.put("some key", "some value");
+ regionOnServer.put(new ArrayList(), new ArrayList());
+ regionOnServer.put(1, 2);
+ });
+
+ Awaitility.await().atMost(10, TimeUnit.SECONDS)
+ .until(() -> assertEquals(3, region.keySet().size()));
+ }
+
+ @Test
+ public void nonDurableClientRegisterInterestForAllKeysWithDurableFlagShouldThrowException()
+ throws Exception {
+
+ ClientCache clientCache = createClientCache(locatorPort);
+
+ try {
+ Region region = clientCache.createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY)
+ .create("region");
+ region.registerInterestForAllKeys(InterestResultPolicy.KEYS, true);
+ fail();
+ } catch (IllegalStateException e) {
+ assertEquals("Durable flag only applicable for durable clients.", e.getMessage());
+ }
+ }
+
+ @Test
+ public void durableClientRegisterInterestAllKeysWithDurableFlagShouldRegisterInterest()
+ throws Exception {
+
+ ClientCache clientCache = createClientCache(locatorPort, true);
+
+ Region region =
+ clientCache.createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY).create("region");
+ region.registerInterestForAllKeys(InterestResultPolicy.NONE, true);
+
+ server.invoke(() -> {
+ Region regionOnServer = ClusterStartupRule.getCache().getRegion("region");
+ regionOnServer.put("some key", "some value");
+ regionOnServer.put(new ArrayList(), new ArrayList());
+ regionOnServer.put(1, 2);
+ });
+
+ Awaitility.await().atMost(10, TimeUnit.SECONDS)
+ .until(() -> assertEquals(3, region.keySet().size()));
+ }
+
+ @Test
+ public void durableClientRegisterInterestAllKeysAndReceiveValuesFalseShouldRegisterForAllKeys()
+ throws Exception {
+
+ ClientCache clientCache = createClientCache(locatorPort, true);
+
+ Region region =
+ clientCache.createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY).create("region");
+ region.registerInterestForAllKeys(InterestResultPolicy.NONE, true, false);
+
+ server.invoke(() -> {
+ Region regionOnServer = ClusterStartupRule.getCache().getRegion("region");
+ regionOnServer.put("some key", "some value");
+ regionOnServer.put(new ArrayList(), new ArrayList());
+ regionOnServer.put(1, 2);
+ });
+
+ Awaitility.await().atMost(10, TimeUnit.SECONDS)
+ .until(() -> assertEquals(3, region.keySet().size()));
+ }
+
+
+ @Test
+ public void registerInterestForKeysShouldRegisterInterestForEachObjectInTheIterable()
+ throws Exception {
+
+ ClientCache clientCache = createClientCache(locatorPort);
+
+ Set keysList = new HashSet();
+ keysList.add("some key");
+ keysList.add(1);
+
+ Region region =
+ clientCache.createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY).create("region");
+ region.registerInterestForKeys(keysList);
+
+ server.invoke(() -> {
+ Region regionOnServer = ClusterStartupRule.getCache().getRegion("region");
+ regionOnServer.put("some key", "some value");
+ regionOnServer.put(1, 2);
+ regionOnServer.put("should not be interested", "in this key/value");
+ });
+
+ Awaitility.await().atMost(10, TimeUnit.SECONDS).until(() -> assertEquals(2, region.size()));
+ }
+
+ @Test
+ public void registerInterestForKeysWithInterestPolicyShouldRegisterInterestForEachObjectInTheIterable()
+ throws Exception {
+
+ ClientCache clientCache = createClientCache(locatorPort);
+
+ Set keysList = new HashSet();
+ keysList.add("some key");
+ keysList.add(1);
+
+ Region region =
+ clientCache.createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY).create("region");
+ region.registerInterestForKeys(keysList, InterestResultPolicy.KEYS);
+
+ server.invoke(() -> {
+ Region regionOnServer = ClusterStartupRule.getCache().getRegion("region");
+ regionOnServer.put("some key", "some value");
+ regionOnServer.put(1, 2);
+ regionOnServer.put("should not be interested", "in this key/value");
+ });
+
+ Awaitility.await().atMost(10, TimeUnit.SECONDS).until(() -> assertEquals(2, region.size()));
+ }
+
+ @Test
+ public void registerInterestForKeysOnTypedRegionShouldRegisterInterestForEachObjectInIterable()
+ throws Exception {
+ ClientCache clientCache = createClientCache(locatorPort);
+
+ Set<String> keysList = new HashSet<>();
+ keysList.add("some key");
+ keysList.add("other key");
+
+ Region<String, String> region =
+ clientCache.<String, String>createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY)
+ .create("region");
+ region.registerInterestForKeys(keysList);
+
+ server.invoke(() -> {
+ Region regionOnServer = ClusterStartupRule.getCache().getRegion("region");
+ regionOnServer.put("some key", "some value");
+ regionOnServer.put("other key", "other value");
+ regionOnServer.put("should not be interested", "in this key/value");
+ });
+
+ Awaitility.await().atMost(10, TimeUnit.SECONDS).until(() -> assertEquals(2, region.size()));
+ }
+
+ @Test
+ public void nonDurableClientWhenRegisterInterestForKeysShouldThrowException() throws Exception {
+
+ ClientCache clientCache = createClientCache(locatorPort);
+
+ Set keysList = new HashSet();
+ keysList.add("some key");
+ keysList.add(1);
+
+ try {
+ Region region = clientCache.createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY)
+ .create("region");
+ region.registerInterestForKeys(keysList, InterestResultPolicy.KEYS, true);
+ fail();
+ } catch (IllegalStateException e) {
+ assertEquals("Durable flag only applicable for durable clients.", e.getMessage());
+ }
+ }
+
+ @Test
+ public void durableClientWhenRegisterInterestForKeyShouldCorrectlyRegisterInterest()
+ throws Exception {
+
+ ClientCache clientCache = createClientCache(locatorPort, true);
+
+ Set keysList = new HashSet();
+ keysList.add("some key");
+ keysList.add(1);
+
+ Region region =
+ clientCache.createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY).create("region");
+ region.registerInterestForKeys(keysList, InterestResultPolicy.KEYS, true);
+
+ server.invoke(() -> {
+ Region regionOnServer = ClusterStartupRule.getCache().getRegion("region");
+ regionOnServer.put("some key", "some value");
+ regionOnServer.put(1, 2);
+ regionOnServer.put("should not be interested", "in this key/value");
+ });
+
+ Awaitility.await().atMost(10, TimeUnit.SECONDS).until(() -> assertEquals(2, region.size()));
+ }
+
+ @Test
+ public void durableClientWhenRegisterInterestForKeysAndReturnValueFalseShouldCorrectlyRegisterInterest()
+ throws Exception {
+
+ ClientCache clientCache = createClientCache(locatorPort, true);
+
+ Set keysList = new HashSet();
+ keysList.add("some key");
+ keysList.add(1);
+
+ Region region =
+ clientCache.createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY).create("region");
+ region.registerInterestForKeys(keysList, InterestResultPolicy.KEYS, true, false);
+
+ server.invoke(() -> {
+ Region regionOnServer = ClusterStartupRule.getCache().getRegion("region");
+ regionOnServer.put("some key", "some value");
+ regionOnServer.put(1, 2);
+ regionOnServer.put("should not be interested", "in this key/value");
+ });
+
+ Awaitility.await().atMost(10, TimeUnit.SECONDS).until(() -> assertEquals(2, region.size()));
+ }
+
+ private ClientCache createClientCache(Integer locatorPort) {
+ return createClientCache(locatorPort, false);
+ }
+
+
+ private ClientCache createClientCache(Integer locatorPort, boolean isDurable) {
+ ClientCacheFactory ccf = null;
+ if (isDurable) {
+ Properties props = new Properties();
+ props.setProperty("durable-client-id", "31");
+ props.setProperty("durable-client-timeout", "" + 200);
+ ccf = new ClientCacheFactory(props);
+ } else {
+ ccf = new ClientCacheFactory();
+ }
+
+ ccf.addPoolLocator("localhost", locatorPort);
+ ccf.setPoolSubscriptionEnabled(true);
+ ClientCache cache = ccf.create();
+ if (isDurable) {
+ cache.readyForEvents();
+ }
+ return cache;
+ }
+
+ private void createServerRegion(MemberVM server, RegionShortcut regionShortcut) {
+ server.invoke(() -> {
+ Region regionOnServer =
+ ClusterStartupRule.getCache().createRegionFactory(regionShortcut).create("region");
+ });
+ }
+
+
+}
--
To stop receiving notification emails like this one, please contact
jasonhuynh@apache.org.