repo
stringlengths 1
191
⌀ | file
stringlengths 23
351
| code
stringlengths 0
5.32M
| file_length
int64 0
5.32M
| avg_line_length
float64 0
2.9k
| max_line_length
int64 0
288k
| extension_type
stringclasses 1
value |
|---|---|---|---|---|---|---|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodSingleNodeTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.core.test.ServerTestingUtil.killServer;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.killClient;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import org.infinispan.AdvancedCache;
import org.infinispan.Cache;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
/**
* Base test class for single node Hot Rod tests.
*
* @author Galder Zamarreño
* @since 4.1
*/
public abstract class HotRodSingleNodeTest extends SingleCacheManagerTest {
protected String cacheName;
protected HotRodServer hotRodServer;
protected HotRodClient hotRodClient;
protected AdvancedCache<byte[], byte[]> advancedCache;
private String hotRodJmxDomain = getClass().getSimpleName();
@Override
protected EmbeddedCacheManager createCacheManager() {
EmbeddedCacheManager cacheManager = createTestCacheManager();
Cache<byte[], byte[]> cache = cacheManager.getCache(cacheName);
advancedCache = cache.getAdvancedCache();
return cacheManager;
}
@Override
protected void setup() throws Exception {
cacheName = TestCacheManagerFactory.DEFAULT_CACHE_NAME;
super.setup();
hotRodServer = createStartHotRodServer(cacheManager);
hotRodClient = connectClient();
}
@Override
protected void teardown() {
log.debug("Killing Hot Rod client and server");
killClient(hotRodClient);
killServer(hotRodServer);
super.teardown();
}
protected EmbeddedCacheManager createTestCacheManager() {
return TestCacheManagerFactory.createCacheManager(
new GlobalConfigurationBuilder().nonClusteredDefault().defaultCacheName(cacheName),
hotRodCacheConfiguration());
}
protected HotRodServer createStartHotRodServer(EmbeddedCacheManager cacheManager) {
return startHotRodServer(cacheManager);
}
protected HotRodServer server() {
return hotRodServer;
}
protected HotRodClient client() {
return hotRodClient;
}
protected String jmxDomain() {
return hotRodJmxDomain;
}
protected void shutdownClient() {
killClient(hotRodClient);
}
protected byte protocolVersion() {
return 21;
}
protected HotRodClient connectClient() {
return connectClient(protocolVersion());
}
protected HotRodClient connectClient(byte protocolVersion) {
return new HotRodClient("127.0.0.1", hotRodServer.getPort(), cacheName, protocolVersion);
}
}
| 2,874
| 29.913978
| 95
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/SkipCacheLoadHotRodTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertStatus;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import java.lang.reflect.Method;
import org.infinispan.commands.FlagAffectedCommand;
import org.infinispan.commands.VisitableCommand;
import org.infinispan.commons.CacheException;
import org.infinispan.context.InvocationContext;
import org.infinispan.context.impl.FlagBitSets;
import org.infinispan.interceptors.AsyncInterceptorChain;
import org.infinispan.interceptors.BaseAsyncInterceptor;
import org.testng.annotations.Test;
/**
* Tests if the {@link ProtocolFlag#SkipCacheLoader} flag is processed on server.
*
* @author Pedro Ruivo
* @since 7.0
*/
@Test(groups = "functional", testName = "server.hotrod.SkipCacheLoadHotRodTest")
public class SkipCacheLoadHotRodTest extends HotRodSingleNodeTest {
private static final int SKIP_LOADER_AND_RETURN_PREVIOUS_VALUE = join(ProtocolFlag.SkipCacheLoader.getValue(),
ProtocolFlag.ForceReturnPreviousValue
.getValue());
public void testPut(Method m) {
FlagCheckCommandInterceptor commandInterceptor = init();
//PUT
commandInterceptor.expectSkipLoadFlag = false;
assertStatus(client().put(k(m), 0, 0, v(m), 0), OperationStatus.Success);
commandInterceptor.expectSkipLoadFlag = true;
assertStatus(client().put(k(m), 0, 0, v(m), ProtocolFlag.SkipCacheLoader.getValue()), OperationStatus.Success);
assertStatus(client().put(k(m), 0, 0, v(m), SKIP_LOADER_AND_RETURN_PREVIOUS_VALUE),
OperationStatus.SuccessWithPrevious);
}
public void testReplace(Method m) {
//REPLACE
FlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipLoadFlag = false;
assertStatus(client().replace(k(m), 0, 0, v(m), 0), OperationStatus.OperationNotExecuted);
commandInterceptor.expectSkipLoadFlag = false;
assertStatus(client().replace(k(m), 0, 0, v(m), ProtocolFlag.SkipCacheLoader.getValue()),
OperationStatus.OperationNotExecuted);
assertStatus(client().replace(k(m), 0, 0, v(m), SKIP_LOADER_AND_RETURN_PREVIOUS_VALUE),
OperationStatus.OperationNotExecuted);
}
public void testPutIfAbsent(Method m) {
//PUT_IF_ABSENT
FlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipLoadFlag = false;
assertStatus(client().putIfAbsent(k(m), 0, 0, v(m), 0), OperationStatus.Success);
commandInterceptor.expectSkipLoadFlag = false;
assertStatus(client().putIfAbsent(k(m), 0, 0, v(m), ProtocolFlag.SkipCacheLoader.getValue()),
OperationStatus.OperationNotExecuted);
assertStatus(client().putIfAbsent(k(m), 0, 0, v(m), SKIP_LOADER_AND_RETURN_PREVIOUS_VALUE),
OperationStatus.NotExecutedWithPrevious);
}
public void testReplaceIfUnmodified(Method m) {
//REPLACE_IF_UNMODIFIED
FlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipLoadFlag = false;
assertStatus(client().replaceIfUnmodified(k(m), 0, 0, v(m), 0, 0), OperationStatus.KeyDoesNotExist);
commandInterceptor.expectSkipLoadFlag = false;
assertStatus(client().replaceIfUnmodified(k(m), 0, 0, v(m), 0, ProtocolFlag.SkipCacheLoader.getValue()),
OperationStatus.KeyDoesNotExist);
assertStatus(client().replaceIfUnmodified(k(m), 0, 0, v(m), 0, SKIP_LOADER_AND_RETURN_PREVIOUS_VALUE),
OperationStatus.KeyDoesNotExist);
}
public void testGet(Method m) {
//GET
FlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipLoadFlag = false;
assertStatus(client().get(k(m), 0), OperationStatus.KeyDoesNotExist);
commandInterceptor.expectSkipLoadFlag = true;
assertStatus(client().get(k(m), ProtocolFlag.SkipCacheLoader.getValue()), OperationStatus.KeyDoesNotExist);
assertStatus(client().get(k(m), SKIP_LOADER_AND_RETURN_PREVIOUS_VALUE), OperationStatus.KeyDoesNotExist);
}
public void testGetWithVersion(Method m) {
//GET_WITH_VERSION
FlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipLoadFlag = false;
assertStatus(client().getWithVersion(k(m), 0), OperationStatus.KeyDoesNotExist);
commandInterceptor.expectSkipLoadFlag = true;
assertStatus(client().getWithVersion(k(m), ProtocolFlag.SkipCacheLoader.getValue()),
OperationStatus.KeyDoesNotExist);
assertStatus(client().getWithVersion(k(m), SKIP_LOADER_AND_RETURN_PREVIOUS_VALUE),
OperationStatus.KeyDoesNotExist);
}
public void testGetWithMetadata(Method m) {
//GET_WITH_METADATA
FlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipLoadFlag = false;
assertStatus(client().getWithMetadata(k(m), 0), OperationStatus.KeyDoesNotExist);
commandInterceptor.expectSkipLoadFlag = true;
assertStatus(client().getWithMetadata(k(m), ProtocolFlag.SkipCacheLoader.getValue()),
OperationStatus.KeyDoesNotExist);
assertStatus(client().getWithMetadata(k(m), SKIP_LOADER_AND_RETURN_PREVIOUS_VALUE),
OperationStatus.KeyDoesNotExist);
}
public void testRemove(Method m) {
//REMOVE
FlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipLoadFlag = false;
assertStatus(client().remove(k(m), 0), OperationStatus.KeyDoesNotExist);
commandInterceptor.expectSkipLoadFlag = true;
assertStatus(client().remove(k(m), ProtocolFlag.SkipCacheLoader.getValue()), OperationStatus.KeyDoesNotExist);
assertStatus(client().remove(k(m), SKIP_LOADER_AND_RETURN_PREVIOUS_VALUE), OperationStatus.KeyDoesNotExist);
}
public void testRemoveIfUnmodified(Method m) {
//REMOVE_IF_UNMODIFIED
FlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipLoadFlag = false;
assertStatus(client().removeIfUnmodified(k(m), 0, 0), OperationStatus.KeyDoesNotExist);
commandInterceptor.expectSkipLoadFlag = false;
assertStatus(client().removeIfUnmodified(k(m), 0, ProtocolFlag.SkipCacheLoader.getValue()),
OperationStatus.KeyDoesNotExist);
assertStatus(client().removeIfUnmodified(k(m), 0, SKIP_LOADER_AND_RETURN_PREVIOUS_VALUE),
OperationStatus.KeyDoesNotExist);
}
public void testContainsKey(Method m) {
//CONTAINS_KEY
FlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipLoadFlag = false;
assertStatus(client().containsKey(k(m), 0), OperationStatus.KeyDoesNotExist);
commandInterceptor.expectSkipLoadFlag = true;
assertStatus(client().containsKey(k(m), ProtocolFlag.SkipCacheLoader.getValue()),
OperationStatus.KeyDoesNotExist);
assertStatus(client().containsKey(k(m), SKIP_LOADER_AND_RETURN_PREVIOUS_VALUE), OperationStatus.KeyDoesNotExist);
}
private FlagCheckCommandInterceptor init() {
AsyncInterceptorChain interceptorChain =
cacheManager.getCache(cacheName).getAdvancedCache().getAsyncInterceptorChain();
FlagCheckCommandInterceptor interceptor =
interceptorChain.findInterceptorExtending(FlagCheckCommandInterceptor.class);
if (interceptor != null)
return interceptor;
FlagCheckCommandInterceptor ci = new FlagCheckCommandInterceptor();
interceptorChain.addInterceptor(ci, 1);
return ci;
}
private static int join(int flagId, int joinId) {
return joinId | flagId;
}
}
class FlagCheckCommandInterceptor extends BaseAsyncInterceptor {
volatile boolean expectSkipLoadFlag = false;
@Override
public Object visitCommand(InvocationContext ctx, VisitableCommand command) throws Throwable {
if (command instanceof FlagAffectedCommand) {
FlagAffectedCommand flagAffectedCommand = (FlagAffectedCommand) command;
if (flagAffectedCommand.hasAnyFlag(FlagBitSets.CACHE_MODE_LOCAL)) {
// this is the fast non-blocking read
return invokeNext(ctx, command);
}
boolean hasFlag = flagAffectedCommand.hasAnyFlag(FlagBitSets.SKIP_CACHE_LOAD);
if (expectSkipLoadFlag && !hasFlag) {
throw new CacheException("SKIP_CACHE_LOAD flag is expected!");
} else if (!expectSkipLoadFlag && hasFlag) {
throw new CacheException("SKIP_CACHE_LOAD flag is *not* expected!");
}
}
return invokeNext(ctx, command);
}
}
| 8,937
| 44.602041
| 119
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodWithStoreTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertStatus;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.testng.AssertJUnit.assertEquals;
import java.lang.reflect.Method;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.context.Flag;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.persistence.dummy.DummyInMemoryStoreConfigurationBuilder;
import org.infinispan.server.hotrod.test.TestSizeResponse;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "server.hotrod.HotRodWithStoreTest")
public class HotRodWithStoreTest extends HotRodSingleNodeTest {
@Override
public EmbeddedCacheManager createCacheManager() {
ConfigurationBuilder builder = hotRodCacheConfiguration();
builder.persistence()
.addStore(DummyInMemoryStoreConfigurationBuilder.class)
.storeName(getClass().getName());
EmbeddedCacheManager cacheManager = TestCacheManagerFactory.createCacheManager(
new GlobalConfigurationBuilder().nonClusteredDefault().defaultCacheName(cacheName),
builder);
advancedCache = cacheManager.<byte[], byte[]>getCache(cacheName).getAdvancedCache();
return cacheManager;
}
public void testSize(Method m) {
TestSizeResponse sizeStart = client().size();
assertStatus(sizeStart, Success);
assertEquals(0, sizeStart.size);
for (int i = 0; i < 20; i++)
client().assertPut(m, "k-" + i, "v-" + i);
// Clear contents from memory
advancedCache.withFlags(Flag.SKIP_CACHE_STORE).clear();
TestSizeResponse sizeEnd = client().size();
assertStatus(sizeEnd, Success);
assertEquals(20, sizeEnd.size);
}
}
| 2,055
| 38.538462
| 95
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/InetAddressWithNetMaskTest.java
|
package org.infinispan.server.hotrod;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import java.net.InetAddress;
import java.net.UnknownHostException;
import org.testng.annotations.Test;
/**
* @since 14.0
**/
@Test(groups = "functional", testName = "server.hotrod.InetAddressWithNetMaskTest")
public class InetAddressWithNetMaskTest {
public void testNetmasksOverrides() throws UnknownHostException {
// Private/reserved ranges
// 10.0.0.0/8
check((byte) 10, (byte) 1, (byte) 2, (byte) 3, (short) 21, (short) 8);
// 100.64.0.0/10
check((byte) 100, (byte) 64, (byte) 2, (byte) 3, (short) 21, (short) 10);
// 169.254.0.0/16
check((byte) 169, (byte) 254, (byte) 2, (byte) 3, (short) 21, (short) 16);
// 172.16.0.0/12
check((byte) 172, (byte) 30, (byte) 2, (byte) 3, (short) 21, (short) 12);
// 192.168.0.0/16
check((byte) 192, (byte) 168, (byte) 2, (byte) 3, (short) 21, (short) 16);
// 240.0.0.0/4 (Class E)
check((byte) 250, (byte) 1, (byte) 2, (byte) 3, (short) 21, (short) 4);
// Public ranges
// Below 10.0.0.0/8
check((byte) 8, (byte) 1, (byte) 2, (byte) 3, (short) 21, (short) 21);
// Between 10.0.0.0/8 and 100.64.0.0/10
check((byte) 100, (byte) 63, (byte) 2, (byte) 3, (short) 21, (short) 21);
// Between 100.64.0.0/10 and 169.254.0.0/16
check((byte) 100, (byte) 130, (byte) 2, (byte) 3, (short) 21, (short) 21);
// Between 169.254.0.0/16 and 172.16.0.0/12
check((byte) 170, (byte) 1, (byte) 2, (byte) 3, (short) 21, (short) 21);
// Between 172.16.0.0/12 and 192.168.0.0
check((byte) 172, (byte) 32, (byte) 16, (byte) 3, (short) 21, (short) 21);
// Between 192.168.0.0 and 240.0.0.0/4
check((byte) 223, (byte) 32, (byte) 16, (byte) 8, (short) 21, (short) 21);
}
public void testDifferentIPvNess() {
assertFalse(
MultiHomedServerAddress.inetAddressMatchesInterfaceAddress(
new byte[]{10, 1, 2, 3},
new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}, 10)
);
}
private void check(byte a, byte b, byte c, byte d, short prefix, short expected) throws UnknownHostException {
InetAddress address = InetAddress.getByAddress(new byte[]{a, b, c, d});
MultiHomedServerAddress.InetAddressWithNetMask addressWithNetMask = new MultiHomedServerAddress.InetAddressWithNetMask(address, prefix, true);
assertEquals(expected, addressWithNetMask.prefixLength);
addressWithNetMask = new MultiHomedServerAddress.InetAddressWithNetMask(address, prefix, false);
assertEquals(prefix, addressWithNetMask.prefixLength);
}
}
| 2,747
| 42.619048
| 148
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/SkipIndexingHotRodTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertStatus;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import static org.infinispan.test.TestingUtil.extractInterceptorChain;
import java.lang.reflect.Method;
import org.infinispan.commands.FlagAffectedCommand;
import org.infinispan.commands.VisitableCommand;
import org.infinispan.commons.CacheException;
import org.infinispan.context.InvocationContext;
import org.infinispan.context.impl.FlagBitSets;
import org.infinispan.interceptors.AsyncInterceptorChain;
import org.infinispan.interceptors.BaseAsyncInterceptor;
import org.testng.annotations.Test;
/**
* Tests if the {@link ProtocolFlag#SkipIndexing} flag is processed on server.
*
* @author Tristan Tarrant
* @since 7.0
*/
@Test(groups = "functional", testName = "server.hotrod.SkipIndexingHotRodTest")
public class SkipIndexingHotRodTest extends HotRodSingleNodeTest {
private static final int SKIP_INDEXING_AND_RETURN_PREVIOUS_VALUE = join(ProtocolFlag.SkipIndexing.getValue(), ProtocolFlag.ForceReturnPreviousValue.getValue());
public void testPut(Method m) {
SkipIndexingFlagCheckCommandInterceptor commandInterceptor = init();
//PUT
commandInterceptor.expectSkipIndexingFlag = false;
assertStatus(client().put(k(m), 0, 0, v(m), 0), OperationStatus.Success);
commandInterceptor.expectSkipIndexingFlag = true;
assertStatus(client().put(k(m), 0, 0, v(m), ProtocolFlag.SkipIndexing.getValue()), OperationStatus.Success);
assertStatus(client().put(k(m), 0, 0, v(m), SKIP_INDEXING_AND_RETURN_PREVIOUS_VALUE),
OperationStatus.SuccessWithPrevious);
}
public void testReplace(Method m) {
//REPLACE
SkipIndexingFlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipIndexingFlag = false;
assertStatus(client().replace(k(m), 0, 0, v(m), 0), OperationStatus.OperationNotExecuted);
commandInterceptor.expectSkipIndexingFlag = true;
assertStatus(client().replace(k(m), 0, 0, v(m), ProtocolFlag.SkipIndexing.getValue()),
OperationStatus.OperationNotExecuted);
assertStatus(client().replace(k(m), 0, 0, v(m), SKIP_INDEXING_AND_RETURN_PREVIOUS_VALUE),
OperationStatus.OperationNotExecuted);
}
public void testPutIfAbsent(Method m) {
//PUT_IF_ABSENT
SkipIndexingFlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipIndexingFlag = false;
assertStatus(client().putIfAbsent(k(m), 0, 0, v(m), 0), OperationStatus.Success);
commandInterceptor.expectSkipIndexingFlag = true;
assertStatus(client().putIfAbsent(k(m), 0, 0, v(m), ProtocolFlag.SkipIndexing.getValue()),
OperationStatus.OperationNotExecuted);
assertStatus(client().putIfAbsent(k(m), 0, 0, v(m), SKIP_INDEXING_AND_RETURN_PREVIOUS_VALUE),
OperationStatus.NotExecutedWithPrevious);
}
public void testReplaceIfUnmodified(Method m) {
//REPLACE_IF_UNMODIFIED
SkipIndexingFlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipIndexingFlag = false;
assertStatus(client().replaceIfUnmodified(k(m), 0, 0, v(m), 0, 0), OperationStatus.KeyDoesNotExist);
commandInterceptor.expectSkipIndexingFlag = true;
assertStatus(client().replaceIfUnmodified(k(m), 0, 0, v(m), 0, ProtocolFlag.SkipIndexing.getValue()),
OperationStatus.KeyDoesNotExist);
assertStatus(client().replaceIfUnmodified(k(m), 0, 0, v(m), 0, SKIP_INDEXING_AND_RETURN_PREVIOUS_VALUE),
OperationStatus.KeyDoesNotExist);
}
public void testGet(Method m) {
//GET
SkipIndexingFlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipIndexingFlag = false;
assertStatus(client().get(k(m), 0), OperationStatus.KeyDoesNotExist);
commandInterceptor.expectSkipIndexingFlag = false;
assertStatus(client().get(k(m), ProtocolFlag.SkipIndexing.getValue()), OperationStatus.KeyDoesNotExist);
assertStatus(client().get(k(m), SKIP_INDEXING_AND_RETURN_PREVIOUS_VALUE),
OperationStatus.KeyDoesNotExist);
}
public void testGetWithVersion(Method m) {
//GET_WITH_VERSION
SkipIndexingFlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipIndexingFlag = false;
assertStatus(client().getWithVersion(k(m), 0), OperationStatus.KeyDoesNotExist);
commandInterceptor.expectSkipIndexingFlag = false;
assertStatus(client().getWithVersion(k(m), ProtocolFlag.SkipIndexing.getValue()),
OperationStatus.KeyDoesNotExist);
assertStatus(client().getWithVersion(k(m), SKIP_INDEXING_AND_RETURN_PREVIOUS_VALUE),
OperationStatus.KeyDoesNotExist);
}
public void testGetWithMetadata(Method m) {
//GET_WITH_METADATA
SkipIndexingFlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipIndexingFlag = false;
assertStatus(client().getWithMetadata(k(m), 0), OperationStatus.KeyDoesNotExist);
commandInterceptor.expectSkipIndexingFlag = false;
assertStatus(client().getWithMetadata(k(m), ProtocolFlag.SkipIndexing.getValue()),
OperationStatus.KeyDoesNotExist);
assertStatus(client().getWithMetadata(k(m), SKIP_INDEXING_AND_RETURN_PREVIOUS_VALUE),
OperationStatus.KeyDoesNotExist);
}
public void testRemove(Method m) {
//REMOVE
SkipIndexingFlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipIndexingFlag = false;
assertStatus(client().remove(k(m), 0), OperationStatus.KeyDoesNotExist);
commandInterceptor.expectSkipIndexingFlag = true;
assertStatus(client().remove(k(m), ProtocolFlag.SkipIndexing.getValue()), OperationStatus.KeyDoesNotExist);
assertStatus(client().remove(k(m), SKIP_INDEXING_AND_RETURN_PREVIOUS_VALUE), OperationStatus.KeyDoesNotExist);
}
public void testRemoveIfUnmodified(Method m) {
//REMOVE_IF_UNMODIFIED
SkipIndexingFlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipIndexingFlag = false;
assertStatus(client().removeIfUnmodified(k(m), 0, 0), OperationStatus.KeyDoesNotExist);
commandInterceptor.expectSkipIndexingFlag = true;
assertStatus(client().removeIfUnmodified(k(m), 0, ProtocolFlag.SkipIndexing.getValue()),
OperationStatus.KeyDoesNotExist);
assertStatus(client().removeIfUnmodified(k(m), 0, SKIP_INDEXING_AND_RETURN_PREVIOUS_VALUE),
OperationStatus.KeyDoesNotExist);
}
public void testContainsKey(Method m) {
//CONTAINS_KEY
SkipIndexingFlagCheckCommandInterceptor commandInterceptor = init();
commandInterceptor.expectSkipIndexingFlag = false;
assertStatus(client().containsKey(k(m), 0), OperationStatus.KeyDoesNotExist);
commandInterceptor.expectSkipIndexingFlag = false;
assertStatus(client().containsKey(k(m), ProtocolFlag.SkipIndexing.getValue()), OperationStatus.KeyDoesNotExist);
assertStatus(client().containsKey(k(m), SKIP_INDEXING_AND_RETURN_PREVIOUS_VALUE),
OperationStatus.KeyDoesNotExist);
}
private SkipIndexingFlagCheckCommandInterceptor init() {
AsyncInterceptorChain interceptorChain = extractInterceptorChain(cacheManager.getCache(cacheName));
SkipIndexingFlagCheckCommandInterceptor interceptor =
interceptorChain.findInterceptorExtending(SkipIndexingFlagCheckCommandInterceptor.class);
if (interceptor != null)
return interceptor;
SkipIndexingFlagCheckCommandInterceptor ci = new SkipIndexingFlagCheckCommandInterceptor();
interceptorChain.addInterceptor(ci, 1);
return ci;
}
private static int join(int flagId, int joinId) {
return joinId | flagId;
}
}
class SkipIndexingFlagCheckCommandInterceptor extends BaseAsyncInterceptor {
volatile boolean expectSkipIndexingFlag = false;
@Override
public Object visitCommand(InvocationContext ctx, VisitableCommand command) throws Throwable {
if (command instanceof FlagAffectedCommand) {
FlagAffectedCommand flagAffectedCommand = (FlagAffectedCommand) command;
boolean hasFlag = flagAffectedCommand.hasAnyFlag(FlagBitSets.SKIP_INDEXING);
if (expectSkipIndexingFlag && !hasFlag) {
throw new CacheException("SKIP_INDEXING flag is expected!");
} else if (!expectSkipIndexingFlag && hasFlag) {
throw new CacheException("SKIP_INDEXING flag is *not* expected!");
}
}
return invokeNext(ctx, command);
}
}
| 8,922
| 45.473958
| 163
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodMultiNodeTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.core.test.ServerTestingUtil.killServer;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.getServerTopologyId;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.serverPort;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import java.util.ArrayList;
import java.util.List;
import java.util.OptionalInt;
import java.util.stream.Collectors;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.core.AbstractProtocolServer;
import org.infinispan.server.core.test.ServerTestingUtil;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.server.hotrod.test.HotRodTestingUtil;
import org.infinispan.test.MultipleCacheManagersTest;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeClass;
/**
* Base test class for multi node or clustered Hot Rod tests.
*
* @author Galder Zamarreño
* @since 4.1
*/
public abstract class HotRodMultiNodeTest extends MultipleCacheManagersTest {
private List<HotRodServer> hotRodServers = new ArrayList<>();
private List<HotRodClient> hotRodClients = new ArrayList<>();
@Override
protected void createCacheManagers() {
for (int i = 0; i < nodeCount(); i++) {
EmbeddedCacheManager cm = createCacheManager();
cacheManagers.add(cm);
}
startCaches(cacheName());
}
protected EmbeddedCacheManager createCacheManager() {
return TestCacheManagerFactory.createClusteredCacheManager(hotRodCacheConfiguration());
}
void startCaches(String cacheName) {
cacheManagers.forEach(cm -> cm.createCache(cacheName, createCacheConfig().build()));
}
@BeforeClass(alwaysRun = true)
@Override
public void createBeforeClass() throws Throwable {
super.createBeforeClass();
int nextServerPort = serverPort();
for (int i = 0; i < nodeCount(); i++) {
hotRodServers.add(startTestHotRodServer(cacheManagers.get(i), nextServerPort));
nextServerPort += 50;
}
hotRodClients = createClients(cacheName());
}
protected OptionalInt findHighestPort() {
return hotRodServers.stream().mapToInt(AbstractProtocolServer::getPort).max();
}
List<HotRodClient> createClients(String cacheName) {
return hotRodServers.stream()
.map(s -> createClient(s, cacheName))
.collect(Collectors.toList());
}
protected HotRodClient createClient(HotRodServer server, String cacheName) {
return createClient(server, cacheName, "127.0.0.1");
}
protected HotRodClient createClient(HotRodServer server, String cacheName, String address) {
return new HotRodClient(address, server.getPort(), cacheName, protocolVersion());
}
protected HotRodServer startTestHotRodServer(EmbeddedCacheManager cacheManager, int port) {
return startHotRodServer(cacheManager, port);
}
protected HotRodServer startClusteredServer(int port) {
EmbeddedCacheManager cm = TestCacheManagerFactory.createClusteredCacheManager(hotRodCacheConfiguration());
cacheManagers.add(cm);
cm.createCache(cacheName(), createCacheConfig().build());
HotRodServer newServer;
try {
newServer = startHotRodServer(cm, port);
} catch (Exception e) {
log.error("Exception starting Hot Rod server", e);
TestingUtil.killCacheManagers(cm);
throw e;
}
TestingUtil.blockUntilViewsReceived(50000, true, cacheManagers);
return newServer;
}
protected void stopClusteredServer(HotRodServer server) {
killServer(server);
TestingUtil.killCacheManagers(server.getCacheManager());
cacheManagers.remove(server.getCacheManager());
TestingUtil.blockUntilViewsReceived(50000, false, cacheManagers);
}
public int currentServerTopologyId() {
return getServerTopologyId(servers().get(0).getCacheManager(), cacheName());
}
@AfterClass(alwaysRun = true)
@Override
protected void destroy() {
try {
log.debug("Test finished, close Hot Rod server");
hotRodClients.forEach(HotRodTestingUtil::killClient);
hotRodServers.forEach(ServerTestingUtil::killServer);
hotRodServers.clear();
} finally {
// Stop the caches last so that at stoppage time topology cache can be updated properly
super.destroy();
}
}
@AfterMethod(alwaysRun = true)
@Override
protected void clearContent() {
// Do not clear cache between methods so that topology cache does not get cleared
}
protected List<HotRodServer> servers() {
return hotRodServers;
}
protected List<HotRodClient> clients() {
return hotRodClients;
}
protected abstract String cacheName();
protected abstract ConfigurationBuilder createCacheConfig();
protected byte protocolVersion() {
return 21;
}
protected int nodeCount() {
return 2;
}
}
| 5,354
| 32.679245
| 112
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodDefaultCacheTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertHotRodEquals;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertStatus;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import static org.testng.AssertJUnit.assertFalse;
import java.lang.reflect.Method;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.hotrod.test.TestResponse;
import org.testng.annotations.Test;
/**
* Test class for setting an alternate default cache
*
* @author Tristan Tarrant
* @since 6.0
*/
@Test(groups = "functional", testName = "server.hotrod.HotRodDefaultCacheTest")
public class HotRodDefaultCacheTest extends HotRodSingleNodeTest {
private static final String ANOTHER_CACHE = "AnotherCache";
@Override
public HotRodServer createStartHotRodServer(EmbeddedCacheManager cacheManager) {
cacheManager.defineConfiguration(ANOTHER_CACHE, cacheManager.getDefaultCacheConfiguration());
return startHotRodServer(cacheManager, ANOTHER_CACHE);
}
public void testPutOnDefaultCache(Method m) {
TestResponse resp = client().execute(0xA0, (byte) 0x01, "", k(m), 0, 0, v(m), 0, (byte) 1, 0);
assertStatus(resp, Success);
assertHotRodEquals(cacheManager, ANOTHER_CACHE, k(m), v(m));
assertFalse(cacheManager.getCache().containsKey(k(m)));
}
}
| 1,626
| 39.675
| 100
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodSniFunctionalTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.core.test.ServerTestingUtil.killServer;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertSuccess;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.killClient;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.serverPort;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import javax.net.ssl.SNIHostName;
import javax.net.ssl.SNIServerName;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLEngine;
import javax.net.ssl.SSLParameters;
import org.infinispan.commons.test.security.TestCertificates;
import org.infinispan.commons.util.SslContextFactory;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.hotrod.configuration.HotRodServerConfigurationBuilder;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.server.hotrod.test.Op;
import org.infinispan.util.concurrent.TimeoutException;
import org.testng.Assert;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.Test;
/**
* Hot Rod server functional test for SNI.
*
* See <a href="https://tools.ietf.org/html/rfc6066#page-6">RFC 6066</a>.
*
* @author Sebastian Łaskawiec
* @since 9.0
*/
@Test(groups = "functional", testName = "server.hotrod.HotRodSniFunctionalTest")
public class HotRodSniFunctionalTest extends HotRodSingleNodeTest {
@AfterMethod(alwaysRun = true)
public void afterMethod() {
//HotRodSingleNodeTest assumes that we start/shutdown server once instead of per-test. We need to perform our own cleanup.
killClient(hotRodClient);
killServer(hotRodServer);
}
public void testServerAndClientWithDefaultSslContext(Method m) {
//given
hotRodServer = new HotrodServerBuilder()
.addSniDomain("*",
TestCertificates.certificate("server"), TestCertificates.KEY_PASSWORD,
TestCertificates.certificate("trust"), TestCertificates.KEY_PASSWORD
)
.build();
hotRodClient = new HotrodClientBuilder(hotRodServer)
.useSslConfiguration(
TestCertificates.certificate("server"), TestCertificates.KEY_PASSWORD,
TestCertificates.certificate("trust"), TestCertificates.KEY_PASSWORD)
.build();
//when
client().assertPut(m);
//then
assertSuccess(client().assertGet(m), v(m));
}
public void testServerAndClientWithSniSslContext(Method m) {
//given
hotRodServer = new HotrodServerBuilder()
//this will reject all clients without SNI Domain specified
.addSniDomain("*",
TestCertificates.certificate("untrusted"), TestCertificates.KEY_PASSWORD,
TestCertificates.certificate("trust"), TestCertificates.KEY_PASSWORD
)
//and here we allow only those with SNI specified
.addSniDomain("sni",
TestCertificates.certificate("sni"), TestCertificates.KEY_PASSWORD,
TestCertificates.certificate("trust"), TestCertificates.KEY_PASSWORD
)
.build();
hotRodClient = new HotrodClientBuilder(hotRodServer)
.useSslConfiguration(TestCertificates.certificate("sni"), TestCertificates.KEY_PASSWORD, TestCertificates.certificate("trust"), TestCertificates.KEY_PASSWORD)
.addSniDomain(Collections.singletonList("sni"))
.build();
//when
client().assertPut(m);
//then
assertSuccess(client().assertGet(m), v(m));
}
public void testServerWithNotMatchingDefaultAndClientWithSNI(Method m) {
//given
hotRodServer = new HotrodServerBuilder()
.addSniDomain("*", TestCertificates.certificate("untrusted"), TestCertificates.KEY_PASSWORD, TestCertificates.certificate("trust"), TestCertificates.KEY_PASSWORD)
.build();
hotRodClient = new HotrodClientBuilder(hotRodServer)
.useSslConfiguration(TestCertificates.certificate("sni"), TestCertificates.KEY_PASSWORD, TestCertificates.certificate("trust"), TestCertificates.KEY_PASSWORD)
.addSniDomain(Collections.singletonList("sni"))
.build();
//when
Op op = new Op(0xA0, (byte) 0x01, (byte) 20, client().defaultCacheName(), k(m), 0, 0, v(m), 0, 0, (byte) 1, 0);
boolean success = false;
try {
success = client().writeOp(op, false);
} catch (TimeoutException e) {
// Ignore the exception caused by https://issues.redhat.com/browse/WFSSL-73
}
//assert
Assert.assertFalse(success);
}
//Server configuration needs to be performed per test
protected @Override
HotRodServer createStartHotRodServer(EmbeddedCacheManager cacheManager) {
return null;
}
//Client configuration needs to be performed per test
protected @Override
HotRodClient connectClient() {
return null;
}
class HotrodClientBuilder {
private final HotRodServer hotRodServer;
SSLContext sslContext;
SSLEngine sslEngine;
public HotrodClientBuilder(HotRodServer hotRodServer) {
this.hotRodServer = hotRodServer;
}
public HotrodClientBuilder useSslConfiguration(String keystoreFileName, char[] keystorePassword,
String truststoreFileName, char[] truststorePassword) {
sslContext = new SslContextFactory()
.keyStoreFileName(keystoreFileName)
.keyStorePassword(keystorePassword)
.keyStoreType(TestCertificates.KEYSTORE_TYPE)
.trustStoreFileName(truststoreFileName)
.trustStorePassword(truststorePassword)
.trustStoreType(TestCertificates.KEYSTORE_TYPE)
.getContext();
sslEngine = SslContextFactory.getEngine(sslContext, true, false);
return this;
}
public HotrodClientBuilder addSniDomain(List<String> sniNames) {
if (!sniNames.isEmpty()) {
SSLParameters sslParameters = sslEngine.getSSLParameters();
List<SNIServerName> hosts = sniNames.stream().map(SNIHostName::new).collect(Collectors.toList());
sslParameters.setServerNames(hosts);
sslEngine.setSSLParameters(sslParameters);
}
return this;
}
public HotRodClient build() {
return new HotRodClient(hotRodServer.getHost(), hotRodServer.getPort(), cacheName,
HotRodClient.DEFAULT_TIMEOUT_SECONDS, (byte) 20, sslEngine);
}
}
class HotrodServerBuilder {
HotRodServerConfigurationBuilder builder = new HotRodServerConfigurationBuilder()
.proxyHost("127.0.0.1")
.proxyPort(serverPort())
.idleTimeout(0);
public HotrodServerBuilder addSniDomain(String domain, String keystoreFileName, char[] keystorePassword,
String truststoreFileName, char[] truststorePassword) {
builder.ssl().enable()
.sniHostName(domain)
.keyStoreFileName(keystoreFileName)
.keyStorePassword(keystorePassword)
.keyStoreType(TestCertificates.KEYSTORE_TYPE)
.trustStoreFileName(truststoreFileName)
.trustStorePassword(truststorePassword)
.trustStoreType(TestCertificates.KEYSTORE_TYPE);
return this;
}
public HotRodServer build() {
return startHotRodServer(cacheManager, serverPort(), builder);
}
}
}
| 7,935
| 38.482587
| 174
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodProxyTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertStatus;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.serverPort;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import java.util.Set;
import java.util.stream.Collectors;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.hotrod.test.AbstractTestTopologyAwareResponse;
import org.infinispan.server.hotrod.test.TestResponse;
import org.testng.annotations.Test;
/**
* Tests Hot Rod instances that are behind a proxy.
*
* @author Galder Zamarreño
* @since 4.1
*/
@Test(groups = "functional", testName = "server.hotrod.HotRodProxyTest")
public class HotRodProxyTest extends HotRodMultiNodeTest {
private String proxyHost1 = "1.2.3.4";
private String proxyHost2 = "2.3.4.5";
private int proxyPort1 = 8123;
private int proxyPort2 = 9123;
@Override
protected String cacheName() {
return "hotRodProxy";
}
@Override
protected ConfigurationBuilder createCacheConfig() {
ConfigurationBuilder config =
hotRodCacheConfiguration(getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, false));
config.clustering().stateTransfer().fetchInMemoryState(true);
return config;
}
@Override
protected HotRodServer startTestHotRodServer(EmbeddedCacheManager cacheManager, int port) {
if (port == serverPort())
return startHotRodServer(cacheManager, proxyHost1, proxyPort1);
else
return startHotRodServer(cacheManager, port, proxyHost2, proxyPort2);
}
public void testTopologyWithProxiesReturned() {
TestResponse resp = clients().get(0).ping((byte) 2, 0);
assertStatus(resp, Success);
AbstractTestTopologyAwareResponse topoResp = resp.asTopologyAwareResponse();
assertEquals(topoResp.topologyId, currentServerTopologyId());
assertEquals(topoResp.members.size(), 2);
Set<ServerAddress> serverAddresses = servers().stream()
.map(HotRodServer::getAddress)
.collect(Collectors.toSet());
topoResp.members.forEach(member -> assertTrue(serverAddresses.contains(member)));
}
}
| 2,688
| 37.971014
| 97
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/TestsModule.java
|
package org.infinispan.server.hotrod;
import org.infinispan.factories.annotations.InfinispanModule;
/**
* {@code InfinispanModule} annotation is required for component annotation processing
*/
@InfinispanModule(name = "server-hotrod-tests")
public class TestsModule implements org.infinispan.lifecycle.ModuleLifecycle {
}
| 326
| 28.727273
| 86
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodConcurrentTest.java
|
package org.infinispan.server.hotrod;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Future;
import org.infinispan.commons.test.TestResourceTracker;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.testng.annotations.Test;
/**
* Tests that Hot Rod servers can be concurrently accessed and modified.
*
* @author Galder Zamarreño
* @since 4.1
*/
@Test(groups = "functional", testName = "server.hotrod.HotRodConcurrentTest")
public class HotRodConcurrentTest extends HotRodSingleNodeTest {
public void testConcurrentPutRequests(Method m) throws Exception {
int numClients = 10;
int numOpsPerClient = 100;
CyclicBarrier barrier = new CyclicBarrier(numClients + 1);
List<Future<Void>> futures = new ArrayList<>();
List<Operator> operators = new ArrayList<>();
try {
for (int i = 0; i < numClients; i++) {
Operator operator = new Operator(barrier, m, i, numOpsPerClient);
operators.add(operator);
Future<Void> future = fork(operator);
futures.add(future);
}
barrier.await(); // wait for all threads to be ready
barrier.await(); // wait for all threads to finish
log.debug("All threads finished, let's shutdown the executor and check whether any exceptions were reported");
for (Future<?> future : futures) {
future.get();
}
} finally {
for (Operator operator : operators) {
operator.stop();
}
}
}
class Operator implements Callable<Void> {
private final CyclicBarrier barrier;
private final Method m;
private final int clientId;
private final int numOpsPerClient;
public Operator(CyclicBarrier barrier, Method m, int clientId, int numOpsPerClient) {
this.barrier = barrier;
this.m = m;
this.clientId = clientId;
this.numOpsPerClient = numOpsPerClient;
}
private HotRodClient client = new HotRodClient("127.0.0.1", server().getPort(), cacheName, (byte) 20);
@Override
public Void call() throws Exception {
TestResourceTracker.testThreadStarted(HotRodConcurrentTest.this.getTestName());
log.debug("Wait for all executions paths to be ready to perform calls");
barrier.await();
try {
for (int i = 0; i < numOpsPerClient; i++) {
client().assertPut(m, "k" + clientId + "-" + i + "-", "v" + clientId + "-" + i + "-");
}
} finally {
log.debug("Wait for all execution paths to finish");
barrier.await();
}
return null;
}
public Future<?> stop() {
return client.stop();
}
}
}
| 2,896
| 32.298851
| 119
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodShutdownTest.java
|
package org.infinispan.server.hotrod;
import java.lang.reflect.Method;
import org.testng.annotations.Test;
/**
* Tests that Hot Rod server can shutdown even if client dies not close connection.
*
* @author Galder Zamarreño
* @since 4.1
*/
@Test(groups = "functional", testName = "server.hotrod.HotRodShutdownTest")
public class HotRodShutdownTest extends HotRodSingleNodeTest {
@Override
protected void shutdownClient() {
}
public void testPutBasic(Method m) {
client().assertPut(m);
}
}
| 520
| 19.84
| 83
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/ServerHotRodTestBlockHoundIntegration.java
|
package org.infinispan.server.hotrod;
import org.infinispan.server.hotrod.counter.impl.TestCounterNotificationManager;
import org.infinispan.server.hotrod.event.EventLogListener;
import org.kohsuke.MetaInfServices;
import com.arjuna.ats.internal.arjuna.coordinator.ReaperThread;
import com.arjuna.ats.internal.arjuna.coordinator.ReaperWorkerThread;
import reactor.blockhound.BlockHound;
import reactor.blockhound.integration.BlockHoundIntegration;
@MetaInfServices
public class ServerHotRodTestBlockHoundIntegration implements BlockHoundIntegration {
@Override
public void applyTo(BlockHound.Builder builder) {
builder.allowBlockingCallsInside(TestCounterNotificationManager.class.getName(), "accept");
// Let arjuna block - sometimes its thread will be put in our non blocking thread group
builder.allowBlockingCallsInside(ReaperThread.class.getName(), "run");
builder.allowBlockingCallsInside(ReaperWorkerThread.class.getName(), "run");
builder.allowBlockingCallsInside(EventLogListener.class.getName(), "onCreated");
builder.allowBlockingCallsInside(EventLogListener.class.getName(), "onModified");
builder.allowBlockingCallsInside(EventLogListener.class.getName(), "onRemoved");
builder.allowBlockingCallsInside(EventLogListener.class.getName(), "onCustom");
}
}
| 1,329
| 46.5
| 97
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodConcurrentStartTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.serverPort;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import org.infinispan.commands.module.TestGlobalConfigurationBuilder;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.remoting.transport.Transport;
import org.infinispan.server.core.test.ServerTestingUtil;
import org.infinispan.server.hotrod.configuration.HotRodServerConfiguration;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.test.MultipleCacheManagersTest;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
/**
* Tests concurrent Hot Rod server startups
*
* @author Galder Zamarreño
* @since 4.2
*/
@Test(groups = "functional", testName = "server.hotrod.HotRodConcurrentStartTest")
public class HotRodConcurrentStartTest extends MultipleCacheManagersTest {
public static final int NUMBER_OF_SERVERS = 2;
public static final String CACHE_NAME = "hotRodConcurrentStart";
@Override
protected void createCacheManagers() {
for (int i = 0; i < NUMBER_OF_SERVERS; i++) {
GlobalConfigurationBuilder globalConfig = GlobalConfigurationBuilder.defaultClusteredBuilder();
if (i == 0) {
// Delay the start of the first server's address cache
globalConfig.addModule(TestGlobalConfigurationBuilder.class).cacheStartingCallback(cr -> {
if (cr.getCacheName().startsWith(HotRodServerConfiguration.TOPOLOGY_CACHE_NAME_PREFIX)) {
log.tracef("Delaying start of cache %s on %s", cr.getCacheName(),
cr.getComponent(Transport.class).getAddress());
TestingUtil.sleepThread(1000);
}
});
}
EmbeddedCacheManager cm = TestCacheManagerFactory.createClusteredCacheManager(globalConfig, null);
cacheManagers.add(cm);
ConfigurationBuilder cfg =
hotRodCacheConfiguration(getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, false));
cm.defineConfiguration(CACHE_NAME, cfg.build());
}
}
public void testConcurrentStartup(Method m) throws Exception {
int initialPort = serverPort();
List<HotRodServer> servers = new ArrayList<>();
try {
List<Future<HotRodServer>> futures = new ArrayList<>();
for (int i = 0; i < NUMBER_OF_SERVERS; i++) {
int finalI = i;
futures.add(fork(() -> {
HotRodServer server = startHotRodServer(getCacheManagers().get(finalI), initialPort + (finalI * 10));
servers.add(server);
return server;
}));
}
for (Future<HotRodServer> hotRodServerFuture : futures) {
hotRodServerFuture.get(30, TimeUnit.SECONDS);
}
try (HotRodClient client = new HotRodClient(servers.get(0).getHost(), servers.get(0).getPort(),
CACHE_NAME, HotRodConstants.VERSION_30)) {
client.assertPut(m);
}
} finally {
servers.forEach(ServerTestingUtil::killServer);
}
}
}
| 3,721
| 40.820225
| 116
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodFunctionalTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.hotrod.OperationStatus.InvalidMagicOrMsgId;
import static org.infinispan.server.hotrod.OperationStatus.KeyDoesNotExist;
import static org.infinispan.server.hotrod.OperationStatus.NotExecutedWithPrevious;
import static org.infinispan.server.hotrod.OperationStatus.OperationNotExecuted;
import static org.infinispan.server.hotrod.OperationStatus.ParseError;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import static org.infinispan.server.hotrod.OperationStatus.SuccessWithPrevious;
import static org.infinispan.server.hotrod.OperationStatus.UnknownOperation;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertHotRodEquals;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertKeyDoesNotExist;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertStatus;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertSuccess;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import static org.infinispan.test.TestingUtil.assertBetween;
import static org.infinispan.test.TestingUtil.generateRandomString;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.server.hotrod.configuration.HotRodServerConfiguration;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.server.hotrod.test.TestBulkGetKeysResponse;
import org.infinispan.server.hotrod.test.TestBulkGetResponse;
import org.infinispan.server.hotrod.test.TestErrorResponse;
import org.infinispan.server.hotrod.test.TestGetWithVersionResponse;
import org.infinispan.server.hotrod.test.TestResponse;
import org.infinispan.server.hotrod.test.TestResponseWithPrevious;
import org.infinispan.server.hotrod.test.TestSizeResponse;
import org.testng.annotations.Test;
/**
* Hot Rod server functional test.
*
* @author Galder Zamarreño
* @since 4.1
*/
@Test(groups = "functional", testName = "server.hotrod.HotRodFunctionalTest")
public class HotRodFunctionalTest extends HotRodSingleNodeTest {
public void testUnknownCommand(Method m) {
OperationStatus status = client().execute(0xA0, (byte)255, cacheName, k(m), 0, 0, v(m), 0, (byte) 1, 0).status;
assertEquals("Status should have been 'UnknownOperation' but instead was: " + status, status, UnknownOperation);
}
public void testUnknownMagic(Method m) {
client().assertPut(m); // Do a put to make sure decoder gets back to reading properly
OperationStatus status = client().executeExpectBadMagic(0x66, (byte) 0x01, cacheName, k(m), 0, 0, v(m), 0).status;
assertEquals("Status should have been 'InvalidMagicOrMsgId' but instead was: " + status, status, InvalidMagicOrMsgId);
}
// todo: test other error conditions such as invalid version...etc
public void testPutBasic(Method m) {
client().assertPut(m);
}
public void testPutOnDefaultCache(Method m) {
TestResponse resp = client().execute(0xA0, (byte) 0x01, "", k(m), 0, 0, v(m), 0, (byte) 1, 0);
assertStatus(resp, Success);
assertHotRodEquals(cacheManager, k(m), v(m));
}
public void testPutOnUndefinedCache(Method m) {
TestErrorResponse resp =
((TestErrorResponse) client().execute(0xA0, (byte) 0x01, "boomooo", k(m), 0, 0, v(m), 0, (byte) 1, 0));
assertTrue(resp.msg.contains("CacheNotFoundException"));
assertEquals("Status should have been 'ParseError' but instead was: " + resp.status, resp.status, ParseError);
client().assertPut(m);
}
public void testPutOnTopologyCache(Method m) {
TestErrorResponse resp = ((TestErrorResponse) client()
.execute(0xA0, (byte) 0x01, HotRodServerConfiguration.TOPOLOGY_CACHE_NAME_PREFIX, k(m), 0, 0, v(m), 0,
(byte) 1, 0));
assertTrue(resp.msg.contains("CacheNotFoundException"));
assertEquals("Status should have been 'ParseError' but instead was: " + resp.status, resp.status, ParseError);
client().assertPut(m);
}
public void testPutWithLifespan(Method m) throws InterruptedException {
client().assertPut(m, 1, 0);
assertEntryExpiration(k(m), 1000, -1);
}
public void testPutWithMaxIdle(Method m) throws InterruptedException {
client().assertPut(m, 0, 1);
assertEntryExpiration(k(m), -1, 1000);
}
public void testPutWithPreviousValue(Method m) {
TestResponseWithPrevious resp = ((TestResponseWithPrevious) client().put(k(m), 0, 0, v(m), 1));
assertSuccessPrevious(resp, null);
resp = (TestResponseWithPrevious) client().put(k(m), 0, 0, v(m, "v2-"), 1);
assertSuccessPrevious(resp, v(m));
}
public void testGetBasic(Method m) {
client().assertPut(m);
assertSuccess(client().assertGet(m), v(m));
}
public void testGetDoesNotExist(Method m) {
assertKeyDoesNotExist(client().assertGet(m));
}
public void testPutIfAbsentNotExist(Method m) {
TestResponse resp = client().putIfAbsent(k(m), 0, 0, v(m));
assertStatus(resp, Success);
}
public void testPutIfAbsentExist(Method m) {
client().assertPut(m);
TestResponse resp = client().putIfAbsent(k(m), 0, 0, v(m, "v2-"));
assertStatus(resp, OperationNotExecuted);
}
public void testPutIfAbsentWithLifespan(Method m) throws InterruptedException {
TestResponse resp = client().putIfAbsent(k(m), 1, 0, v(m));
assertStatus(resp, Success);
assertEntryExpiration(k(m), 1000, -1);
}
public void testPutIfAbsentWithMaxIdle(Method m) throws InterruptedException {
TestResponse resp = client().putIfAbsent(k(m), 0, 1, v(m));
assertStatus(resp, Success);
assertEntryExpiration(k(m), -1, 1000);
}
public void testPutIfAbsentWithPreviousValue(Method m) {
TestResponse resp1 = client().putIfAbsent(k(m), 0, 0, v(m), 0);
assertStatus(resp1, Success);
TestResponseWithPrevious resp2 = (TestResponseWithPrevious) client().putIfAbsent(k(m), 0, 0, v(m, "v2-"), 1);
assertNotExecutedPrevious(resp2, v(m));
}
public void testReplaceBasic(Method m) {
client().assertPut(m);
TestResponse resp = client().replace(k(m), 0, 0, v(m, "v1-"));
assertStatus(resp, Success);
assertSuccess(client().assertGet(m), v(m, "v1-"));
}
public void testNotReplaceIfNotPresent(Method m) {
TestResponse resp = client().replace(k(m), 0, 0, v(m));
assertStatus(resp, OperationNotExecuted);
}
public void testReplaceWithLifespan(Method m) throws InterruptedException {
client().assertPut(m);
TestResponse resp = client().replace(k(m), 1, 0, v(m, "v1-"));
assertStatus(resp, Success);
assertEntryExpiration(k(m), 1000, -1);
}
public void testReplaceWithMaxIdle(Method m) throws InterruptedException {
client().assertPut(m);
TestResponse resp = client().replace(k(m), 0, 1, v(m, "v1-"));
assertStatus(resp, Success);
assertEntryExpiration(k(m), -1, 1000);
}
public void testReplaceWithPreviousValue(Method m) {
TestResponse resp = client().replace(k(m), 0, 0, v(m), 0);
assertStatus(resp, OperationNotExecuted);
TestResponseWithPrevious resp2 = (TestResponseWithPrevious) client().put(k(m), 0, 0, v(m, "v2-"), 1);
assertSuccessPrevious(resp2, null);
TestResponseWithPrevious resp3 = (TestResponseWithPrevious) client().replace(k(m), 0, 0, v(m, "v3-"), 1);
assertSuccessPrevious(resp3, v(m, "v2-"));
}
public void testGetWithVersionBasic(Method m) {
client().assertPut(m);
assertSuccess(client().getWithVersion(k(m), 0), v(m), 0);
}
public void testGetWithVersionDoesNotExist(Method m) {
TestGetWithVersionResponse resp = client().getWithVersion(k(m), 0);
assertKeyDoesNotExist(resp);
assertTrue(resp.dataVersion == 0);
}
public void testGetWithMetadata(Method m) {
client().assertPut(m);
assertSuccess(client().assertGet(m), v(m));
assertSuccess(client().getWithMetadata(k(m), 0), v(m), -1, -1);
client().remove(k(m));
client().assertPut(m, 10, 5);
assertSuccess(client().getWithMetadata(k(m), 0), v(m), 10, 5);
}
public void testReplaceIfUnmodifiedBasic(Method m) {
client().assertPut(m);
TestGetWithVersionResponse resp = client().getWithVersion(k(m), 0);
assertSuccess(resp, v(m), 0);
TestResponse resp2 = client().replaceIfUnmodified(k(m), 0, 0, v(m, "v1-"), resp.dataVersion);
assertStatus(resp2, Success);
}
public void testReplaceIfUnmodifiedNotFound(Method m) {
client().assertPut(m);
TestGetWithVersionResponse resp = client().getWithVersion(k(m), 0);
assertSuccess(resp, v(m), 0);
TestResponse resp2 = client().replaceIfUnmodified(k(m, "k1-"), 0, 0, v(m, "v1-"), resp.dataVersion);
assertStatus(resp2, KeyDoesNotExist);
}
public void testReplaceIfUnmodifiedNotExecuted(Method m) {
client().assertPut(m);
TestGetWithVersionResponse resp = client().getWithVersion(k(m), 0);
assertSuccess(resp, v(m), 0);
TestResponse resp2 = client().replaceIfUnmodified(k(m), 0, 0, v(m, "v1-"), resp.dataVersion);
assertStatus(resp2, Success);
TestGetWithVersionResponse resp3 = client().getWithVersion(k(m), 0);
assertSuccess(resp3, v(m, "v1-"), 0);
assertTrue(resp.dataVersion != resp3.dataVersion);
TestResponse resp4 = client().replaceIfUnmodified(k(m), 0, 0, v(m, "v2-"), resp.dataVersion);
assertStatus(resp4, OperationNotExecuted);
TestResponse resp5 = client().replaceIfUnmodified(k(m), 0, 0, v(m, "v2-"), resp3.dataVersion);
assertStatus(resp5, Success);
}
public void testReplaceIfUnmodifiedWithPreviousValue(Method m) {
TestResponse resp = client().replaceIfUnmodified(k(m), 0, 0, v(m), 999, 0);
assertStatus(resp, KeyDoesNotExist);
client().assertPut(m);
TestGetWithVersionResponse getResp = client().getWithVersion(k(m), 0);
assertSuccess(getResp, v(m), 0);
TestResponseWithPrevious resp2 =
(TestResponseWithPrevious) client().replaceIfUnmodified(k(m), 0, 0, v(m, "v2-"), 888, 1);
assertNotExecutedPrevious(resp2, v(m));
TestResponseWithPrevious resp3 =
(TestResponseWithPrevious) client().replaceIfUnmodified(k(m), 0, 0, v(m, "v3-"), getResp.dataVersion, 1);
assertSuccessPrevious(resp3, v(m));
}
public void testReplaceIfUnmodifiedWithExpiry(Method m) throws InterruptedException {
client().assertPut(m);
TestGetWithVersionResponse resp = client().getWithVersion(k(m), 0);
assertSuccess(resp, v(m), 0);
assertTrue(resp.dataVersion != 0);
int lifespanSecs = 2;
long lifespan = TimeUnit.SECONDS.toMillis(lifespanSecs);
long startTime = System.currentTimeMillis();
TestResponse resp2 = client().replaceIfUnmodified(k(m), lifespanSecs, 0, v(m, "v1-"), resp.dataVersion);
assertStatus(resp2, Success);
assertEntryExpiration(k(m), lifespan, -1);
}
private void assertEntryExpiration(byte[] key, long lifespan, int maxIdle) {
CacheEntry<byte[], byte[]> entry = advancedCache.withStorageMediaType().getCacheEntry(key);
assertEquals(lifespan, entry.getLifespan());
assertEquals(maxIdle, entry.getMaxIdle());
}
public void testRemoveBasic(Method m) {
client().assertPut(m);
TestResponse resp = client().remove(k(m));
assertStatus(resp, Success);
assertKeyDoesNotExist(client().assertGet(m));
}
public void testRemoveDoesNotExist(Method m) {
assertStatus(client().remove(k(m)), KeyDoesNotExist);
}
public void testRemoveWithPreviousValue(Method m) {
TestResponse resp = client().remove(k(m), 0);
assertStatus(resp, KeyDoesNotExist);
client().assertPut(m);
TestResponseWithPrevious resp2 = (TestResponseWithPrevious) client().remove(k(m), 1);
assertSuccessPrevious(resp2, v(m));
}
public void testRemoveIfUnmodifiedBasic(Method m) {
client().assertPut(m);
TestGetWithVersionResponse resp = client().getWithVersion(k(m), 0);
assertSuccess(resp, v(m), 0);
assertTrue(resp.dataVersion != 0);
TestResponse resp2 = client().removeIfUnmodified(k(m), 0, 0, v(m, "v1-"), resp.dataVersion);
assertStatus(resp2, Success);
assertKeyDoesNotExist(client().assertGet(m));
}
public void testRemoveIfUnmodifiedNotFound(Method m) {
client().assertPut(m);
TestGetWithVersionResponse resp = client().getWithVersion(k(m), 0);
assertSuccess(resp, v(m), 0);
TestResponse resp2 = client().removeIfUnmodified(k(m, "k1-"), 0, 0, v(m, "v1-"), resp.dataVersion);
assertStatus(resp2, KeyDoesNotExist);
assertSuccess(client().assertGet(m), v(m));
}
public void testRemoveIfUnmodifiedNotExecuted(Method m) {
client().assertPut(m);
TestGetWithVersionResponse resp = client().getWithVersion(k(m), 0);
assertSuccess(resp, v(m), 0);
TestResponse resp2 = client().replaceIfUnmodified(k(m), 0, 0, v(m, "v1-"), resp.dataVersion);
assertStatus(resp2, Success);
TestGetWithVersionResponse resp3 = client().getWithVersion(k(m), 0);
assertSuccess(resp3, v(m, "v1-"), 0);
assertTrue(resp.dataVersion != resp3.dataVersion);
TestResponse resp4 = client().removeIfUnmodified(k(m), 0, 0, v(m, "v2-"), resp.dataVersion);
assertStatus(resp4, OperationNotExecuted);
TestResponse resp5 = client().removeIfUnmodified(k(m), 0, 0, v(m, "v2-"), resp3.dataVersion);
assertStatus(resp5, Success);
}
public void testRemoveIfUmodifiedWithPreviousValue(Method m) {
TestResponse resp = client().removeIfUnmodified(k(m), 999, 0);
assertStatus(resp, KeyDoesNotExist);
client().assertPut(m);
TestGetWithVersionResponse getResp = client().getWithVersion(k(m), 0);
assertSuccess(getResp, v(m), 0);
TestResponseWithPrevious resp2 = (TestResponseWithPrevious) client().removeIfUnmodified(k(m), 888, 1);
assertNotExecutedPrevious(resp2, v(m));
TestResponseWithPrevious resp3 =
(TestResponseWithPrevious) client().removeIfUnmodified(k(m), getResp.dataVersion, 1);
assertSuccessPrevious(resp3, v(m));
}
public void testContainsKeyBasic(Method m) {
client().assertPut(m);
assertStatus(client().containsKey(k(m), 0), Success);
}
public void testContainsKeyDoesNotExist(Method m) {
assertStatus(client().containsKey(k(m), 0), KeyDoesNotExist);
}
public void testClear(Method m) {
for (int i = 1; i <= 5; i++) {
byte[] key = k(m, "k" + i + "-");
byte[] value = v(m, "v" + i + "-");
assertStatus(client().put(key, 0, 0, value), Success);
assertStatus(client().containsKey(key, 0), Success);
}
assertStatus(client().clear(), Success);
for (int i = 1; i <= 5; i++) {
byte[] key = k(m, "k" + i + "-");
assertStatus(client().containsKey(key, 0), KeyDoesNotExist);
}
}
public void testStatsDisabled(Method m) {
Map<String, String> s = client().stats();
assertEquals(s.get("timeSinceStart"), "-1");
assertEquals(s.get("currentNumberOfEntries"), "-1");
assertEquals(s.get("stores"), "-1");
assertEquals(s.get("retrievals"), "-1");
assertEquals(s.get("hits"), "-1");
assertEquals(s.get("misses"), "-1");
assertEquals(s.get("removeHits"), "-1");
assertEquals(s.get("removeMisses"), "-1");
}
public void testPing(Method m) {
assertStatus(client().ping(), Success);
}
public void testPingWithTopologyAwareClient(Method m) {
TestResponse resp = client().ping();
assertStatus(resp, Success);
assertEquals(resp.topologyResponse, null);
resp = client().ping((byte) 1, 0);
assertStatus(resp, Success);
assertEquals(resp.topologyResponse, null);
resp = client().ping((byte) 2, 0);
assertStatus(resp, Success);
assertEquals(resp.topologyResponse, null);
resp = client().ping((byte) 3, 0);
assertStatus(resp, Success);
assertEquals(resp.topologyResponse, null);
}
public void testBulkGet(Method m) {
int size = 100;
byte[][] keys = new byte[size][];
for (int i = 0; i < size; i++) {
keys[i] = k(m, i + "k-");
TestResponse resp = client().put(keys[i], 0, 0, v(m, i + "v-"));
assertStatus(resp, Success);
}
TestBulkGetResponse resp = client().bulkGet();
assertStatus(resp, Success);
Map<byte[], byte[]> bulkData = resp.bulkData;
assertEquals(size, bulkData.size());
for (int i = 0; i < size; i++) {
byte[] key = keys[i];
List<Map.Entry<byte[], byte[]>> filtered = bulkData.entrySet().stream()
.filter(entry -> Arrays.equals(entry.getKey(), key))
.collect(Collectors.toList());
assertEquals(1, filtered.size());
}
size = 50;
resp = client().bulkGet(size);
assertStatus(resp, Success);
bulkData = resp.bulkData;
assertEquals(size, bulkData.size());
for (int i = 0; i < size; i++) {
byte[] key = keys[i];
List<Map.Entry<byte[], byte[]>> filtered = bulkData.entrySet().stream()
.filter(entry -> Arrays.equals(entry.getKey(), key))
.collect(Collectors.toList());
if (!filtered.isEmpty()) {
assertEquals(filtered.get(0).getValue(), v(m, i + "v-"));
}
}
}
public void testBulkGetKeys(Method m) {
int size = 100;
byte[][] keys = new byte[size][];
for (int i = 0; i < size; i++) {
keys[i] = k(m, i + "k-");
TestResponse resp = client().put(keys[i], 0, 0, v(m, i + "v-"));
assertStatus(resp, Success);
}
TestBulkGetKeysResponse resp = client().bulkGetKeys();
assertStatus(resp, Success);
Set<byte[]> bulkData = resp.bulkData;
assertEquals(size, bulkData.size());
for (int i = 0; i < size; i++) {
byte[] key = keys[i];
List<byte[]> filtered = bulkData.stream()
.filter(bytes -> Arrays.equals(bytes, key))
.collect(Collectors.toList());
assertEquals(1, filtered.size());
}
resp = client().bulkGetKeys(1);
assertStatus(resp, Success);
bulkData = resp.bulkData;
assertEquals(size, bulkData.size());
for (int i = 0; i < size; i++) {
byte[] key = keys[i];
List<byte[]> filtered = bulkData.stream()
.filter(bytes -> java.util.Arrays.equals(bytes, key))
.collect(Collectors.toList());
assertEquals(1, filtered.size());
}
resp = client().bulkGetKeys(2);
assertStatus(resp, Success);
bulkData = resp.bulkData;
assertEquals(size, bulkData.size());
for (int i = 0; i < size; i++) {
byte[] key = keys[i];
List<byte[]> filtered = bulkData.stream()
.filter(bytes -> Arrays.equals(bytes, key))
.collect(Collectors.toList());
assertEquals(1, filtered.size());
}
}
public void testPutBigSizeKey(Method m) {
// Not really necessary, SingleByteFrameDecoderChannelInitializer forces the server to retry even for small keys
byte[] key = generateRandomString(1024).getBytes();
assertStatus(client().put(key, 0, 0, v(m)), Success);
}
public void testPutBigSizeValue(Method m) {
// Not really necessary, SingleByteFrameDecoderChannelInitializer forces the server to retry even for small keys
byte[] value = generateRandomString(1024).getBytes();
assertStatus(client().put(k(m), 0, 0, value), Success);
}
public void testSize(Method m) {
TestSizeResponse sizeStart = client().size();
assertStatus(sizeStart, Success);
assertEquals(0, sizeStart.size);
for (int i = 0; i < 20; i++) {
client().assertPut(m, "k-" + i, "v-" + i);
}
TestSizeResponse sizeEnd = client().size();
assertStatus(sizeEnd, Success);
assertEquals(20, sizeEnd.size);
}
protected boolean assertSuccessPrevious(TestResponseWithPrevious resp, byte[] expected) {
if (expected == null)
assertEquals(Optional.empty(), resp.previous);
else
assertTrue(java.util.Arrays.equals(expected, resp.previous.get()));
return assertStatus(resp, SuccessWithPrevious);
}
protected boolean assertNotExecutedPrevious(TestResponseWithPrevious resp, byte[] expected) {
if (expected == null)
assertEquals(Optional.empty(), resp.previous);
else
assertTrue(java.util.Arrays.equals(expected, resp.previous.get()));
return assertStatus(resp, NotExecutedWithPrevious);
}
public void testLifespan2x(Method m) {
try (HotRodClient client2x = connectClient(HotRodVersion.HOTROD_29.getVersion())) {
// Expire in 1 day by setting the lifespan in seconds since the Unix epoch
long startMillis = System.currentTimeMillis();
long lifespanMillis = TimeUnit.MINUTES.toMillis(1);
int expirationUnixTime = (int) ((startMillis + lifespanMillis) / 1000);
assertStatus(client2x.put(k(m), expirationUnixTime, expirationUnixTime, v(m)), Success);
CacheEntry<byte[], byte[]> entry = advancedCache.withStorageMediaType().getCacheEntry(k(m));
// The lifespan is set to expirationUnixTime * 1000 - <current time on the server>
long endMillis = System.currentTimeMillis();
long lowerBound = expirationUnixTime * 1000L - endMillis;
long upperBound = expirationUnixTime * 1000L - startMillis;
assertBetween(lowerBound, upperBound, entry.getLifespan());
assertBetween(lowerBound, upperBound, entry.getMaxIdle());
}
}
public void testLifespan3x(Method m) {
try (HotRodClient client3x = connectClient(HotRodVersion.HOTROD_30.getVersion())) {
// Set a lifespan that would be interpreted as seconds since the Unix epoch in previous versions
int expirationSeconds = (int) TimeUnit.DAYS.toSeconds(90);
assertStatus(client3x.put(k(m), expirationSeconds, expirationSeconds, v(m)), Success);
CacheEntry<byte[], byte[]> entry = advancedCache.withStorageMediaType().getCacheEntry(k(m));
// The lifespan is interpreted as seconds since inserted, not since the Unix epoch
assertEquals(expirationSeconds * 1000L, entry.getLifespan());
assertEquals(expirationSeconds * 1000L, entry.getMaxIdle());
}
}
}
| 23,336
| 41.977901
| 124
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodMergeTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.hotrod.Constants.INTELLIGENCE_HASH_DISTRIBUTION_AWARE;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertHashTopology20Received;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertStatus;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.killClient;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.serverPort;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import static org.testng.AssertJUnit.assertEquals;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.distribution.LocalizedCacheTopology;
import org.infinispan.partitionhandling.BasePartitionHandlingTest;
import org.infinispan.partitionhandling.PartitionHandling;
import org.infinispan.server.core.test.ServerTestingUtil;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.server.hotrod.test.TestResponse;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TransportFlags;
import org.infinispan.topology.CacheTopology;
import org.testng.annotations.AfterClass;
import org.testng.annotations.Test;
@Test(groups = {"functional", "unstable"}, description = "ISPN-11566", testName = "server.hotrod.HotRodMergeTest")
public class HotRodMergeTest extends BasePartitionHandlingTest {
private List<HotRodServer> servers = new ArrayList<>();
private HotRodClient client;
public Object[] factory() {
return new Object[]{
new HotRodMergeTest().partitionHandling(PartitionHandling.DENY_READ_WRITES),
new HotRodMergeTest().partitionHandling(PartitionHandling.ALLOW_READ_WRITES)
};
}
public HotRodMergeTest() {
numMembersInCluster = 3;
cacheMode = CacheMode.DIST_SYNC;
cleanup = CleanupPhase.AFTER_TEST;
}
@Override
protected void createCacheManagers() throws Throwable {
ConfigurationBuilder dcc = hotRodCacheConfiguration();
dcc.clustering().cacheMode(cacheMode).hash();
dcc.clustering().partitionHandling().whenSplit(partitionHandling);
createClusteredCaches(numMembersInCluster, dcc, new TransportFlags().withFD(true).withMerge(true));
waitForClusterToForm();
// Allow servers for both instances to run in parallel
int threadServerPort = serverPort();
int nextServerPort = threadServerPort + partitionHandling.ordinal() * numMembersInCluster;
for (int i = 0; i < numMembersInCluster; i++) {
servers.add(startHotRodServer(cacheManagers.get(i), nextServerPort));
nextServerPort += 1;
}
client = new HotRodClient("127.0.0.1", servers.get(0).getPort(), getDefaultCacheName(), (byte) 21);
}
@AfterClass(alwaysRun = true)
@Override
protected void destroy() {
try {
killClient(client);
client = null;
servers.forEach(ServerTestingUtil::killServer);
servers.clear();
} finally {
super.destroy();
}
}
public void testNewTopologySentAfterCleanMerge() {
TestingUtil.waitForNoRebalanceAcrossManagers(managers());
int initialTopology = advancedCache(0).getRpcManager().getTopologyId();
expectCompleteTopology(client, initialTopology);
PartitionDescriptor p0 = new PartitionDescriptor(0, 1);
PartitionDescriptor p1 = new PartitionDescriptor(2);
splitCluster(p0.getNodes(), p1.getNodes());
eventuallyEquals(2, () -> advancedCache(0).getDistributionManager().getCacheTopology().getActualMembers().size());
eventuallyEquals(1, () -> advancedCache(2).getDistributionManager().getCacheTopology().getActualMembers().size());
int splitTopologyId = initialTopology + (partitionHandling == PartitionHandling.DENY_READ_WRITES ? 6 : 5);
eventuallyExpectPartialTopology(client, splitTopologyId, servers.get(0), servers.get(1));
partition(0).merge(partition(1));
int finalTopologyId = splitTopologyId + 6;
eventuallyExpectCompleteTopology(client, finalTopologyId);
// Check that we got the number of topology updates from the initialTopology to NO_REBALANCE right
// T+1: NO_REBALANCE actual_members=[0, 1], owners=[0,1,2] -> DENY_READ_WRITES only
// T+2: NO_REBALANCE actual_members=[0, 1], owners=[0,1]
// T+3: READ_OLD_WRITE_ALL
// T+4: READ_ALL_WRITE_ALL
// T+5: READ_NEW_WRITE_ALL
// T+6: NO_REBALANCE
// T+7: NO_REBALANCE
// T+8: NO_REBALANCE
// T+9: READ_OLD_WRITE_ALL
// T+10: READ_ALL_WRITE_ALL,
// T+11: READ_NEW_WRITE_ALL
// T+12: NO_REBALANCE
LocalizedCacheTopology newTopology = advancedCache(0).getDistributionManager().getCacheTopology();
assertEquals(CacheTopology.Phase.NO_REBALANCE, newTopology.getPhase());
assertEquals(finalTopologyId, newTopology.getTopologyId());
}
public void testNewTopologySentAfterOverlappingMerge() {
TestingUtil.waitForNoRebalanceAcrossManagers(managers());
CacheTopology initialTopology = advancedCache(0).getDistributionManager().getCacheTopology();
int initialTopologyId = initialTopology.getTopologyId();
expectCompleteTopology(client, initialTopologyId);
PartitionDescriptor p1 = new PartitionDescriptor(0);
// isolatePartitions will always result in a CR fail as Node 0 tries to contact Node 1 in order to receive segments
// which is not possible as all messages received by Node 1 from Node 0 are discarded by the DISCARD protocol.
// Therefore, it is necessary for the state transfer timeout to be < then the timeout utilised by TestingUtil::waitForNoRebalance
isolatePartition(p1.getNodes());
eventuallyEquals(1, () -> advancedCache(0).getDistributionManager().getCacheTopology().getActualMembers().size());
int expectedTologyId = initialTopologyId + 1;
eventuallyExpectPartialTopology(client, expectedTologyId, servers.get(0));
partition(0).merge(partition(1));
int finalTopologyId = initialTopologyId + (partitionHandling == PartitionHandling.DENY_READ_WRITES ? 2 : 7);
eventuallyExpectCompleteTopology(client, finalTopologyId);
// Check that we got the number of topology updates to NO_REBALANCE right
// With DENY_READ_WRITES:
// T+1: NO_REBALANCE, owners = [0,1,2], actual_members = [0]
// T+2: NO_REBALANCE, owners = [0,1,2], actual_members = [0,1,2] back to AVAILABLE
// With ALLOW_READ_WRITES:
// T+1: NO_REBALANCE owners = [0]
// T+2: NO_REBALANCE owners = [0]
// T+3: NO_REBALANCE owners = [0]
// T+4: READ_OLD_WRITE_ALL
// T+5: READ_ALL_WRITE_ALL
// T+6: READ_NEW_WRITE_ALL
// T+7: NO_REBALANCE
LocalizedCacheTopology newTopology = advancedCache(0).getDistributionManager().getCacheTopology();
assertEquals(CacheTopology.Phase.NO_REBALANCE, newTopology.getPhase());
}
private void eventuallyExpectCompleteTopology(HotRodClient c, int expectedTopologyId) {
eventually(() -> {
TestResponse resp = c.ping(INTELLIGENCE_HASH_DISTRIBUTION_AWARE, 0);
assertStatus(resp, Success);
if (resp.topologyResponse == null || (resp.topologyResponse.topologyId < expectedTopologyId)) {
return false;
}
assertHashTopology20Received(resp.topologyResponse, servers, client.defaultCacheName(), expectedTopologyId);
return true;
});
}
private void expectCompleteTopology(HotRodClient c, int expectedTopologyId) {
TestResponse resp = c.ping(INTELLIGENCE_HASH_DISTRIBUTION_AWARE, 0);
assertStatus(resp, Success);
assertHashTopology20Received(resp.topologyResponse, servers, client.defaultCacheName(), expectedTopologyId);
}
private void eventuallyExpectPartialTopology(HotRodClient c, int expectedTopologyId, HotRodServer... servers) {
eventually(() -> {
TestResponse resp = c.ping(INTELLIGENCE_HASH_DISTRIBUTION_AWARE, 0);
assertStatus(resp, Success);
if (resp.topologyResponse == null || (resp.topologyResponse.topologyId < expectedTopologyId)) {
return false;
}
assertHashTopology20Received(resp.topologyResponse, Arrays.asList(servers), client.defaultCacheName(),
expectedTopologyId);
return true;
});
}
}
| 8,684
| 46.459016
| 135
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/CrashedMemberDetectorTest.java
|
package org.infinispan.server.hotrod;
import static org.testng.AssertJUnit.assertTrue;
import java.util.ArrayList;
import java.util.List;
import org.infinispan.Cache;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.distribution.TestAddress;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.notifications.cachemanagerlistener.event.Event.Type;
import org.infinispan.notifications.cachemanagerlistener.event.impl.EventImpl;
import org.infinispan.remoting.transport.Address;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
/**
* Tests crashed or stopped member logic.
*
* @author Galder Zamarreño
* @since 5.1
*/
@Test(groups = "functional", testName = "server.hotrod.CrashedMemberDetectorTest")
public class CrashedMemberDetectorTest extends SingleCacheManagerTest {
@Override
protected EmbeddedCacheManager createCacheManager() {
return TestCacheManagerFactory.createCacheManager(new ConfigurationBuilder());
}
public void testDetectCrashedMembers() {
Cache<Address, ServerAddress> cache = cacheManager.getCache();
cache.put(new TestAddress(1), ServerAddress.forAddress("a", 123, true));
cache.put(new TestAddress(2), ServerAddress.forAddress("b", 456, true));
cache.put(new TestAddress(3), ServerAddress.forAddress("c", 789, true));
CrashedMemberDetectorListener detector = new CrashedMemberDetectorListener(cache, null);
List<Address> oldMembers = new ArrayList<>();
oldMembers.add(new TestAddress(1));
oldMembers.add(new TestAddress(3));
oldMembers.add(new TestAddress(2));
List<Address> newMembers = new ArrayList<>();
newMembers.add(new TestAddress(1));
newMembers.add(new TestAddress(2));
EventImpl e = new EventImpl("", cacheManager, Type.VIEW_CHANGED, newMembers,
oldMembers, new TestAddress(1), 99);
detector.detectCrashedMember(e);
assertTrue(cache.containsKey(new TestAddress(1)));
assertTrue(cache.containsKey(new TestAddress(2)));
}
}
| 2,170
| 35.183333
| 94
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodIteratorReapTest.java
|
package org.infinispan.server.hotrod;
import static org.testng.AssertJUnit.assertEquals;
import java.util.concurrent.TimeUnit;
import org.infinispan.commons.time.ControlledTimeService;
import org.infinispan.commons.time.TimeService;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.iteration.IterationManager;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.CleanupAfterMethod;
import org.testng.annotations.Test;
@Test(testName = "server.hotrod.HotRodIteratorReapTest", groups = "functional")
@CleanupAfterMethod
public class HotRodIteratorReapTest extends HotRodSingleNodeTest {
ControlledTimeService timeService = new ControlledTimeService();
@Override
protected EmbeddedCacheManager createCacheManager() {
EmbeddedCacheManager cm = super.createCacheManager();
TestingUtil.replaceComponent(cm, TimeService.class, timeService, true);
return cm;
}
public void testIterationStateReaperOnClosedConnections() throws InterruptedException {
IterationManager iterationManager = server().getIterationManager();
for (int i = 0; i < 10; i++) {
hotRodClient.iteratorStart(null, null, null, 10, false);
}
assertEquals(10, iterationManager.activeIterations());
hotRodClient.stop().await();
// The server reaps the iterations asynchronously after the connection is closed
eventuallyEquals(0, iterationManager::activeIterations);
}
public void testIterationStateReaperOnTimeout() {
IterationManager iterationManager = server().getIterationManager();
for (int i = 0; i < 10; i++) {
hotRodClient.iteratorStart(null, null, null, 10, false);
}
assertEquals(10, iterationManager.activeIterations());
timeService.advance(TimeUnit.MINUTES.toMillis(5));
assertEquals(0, iterationManager.activeIterations());
}
}
| 1,893
| 36.88
| 90
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodDistributionTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.hotrod.Constants.INTELLIGENCE_BASIC;
import static org.infinispan.server.hotrod.Constants.INTELLIGENCE_HASH_DISTRIBUTION_AWARE;
import static org.infinispan.server.hotrod.Constants.INTELLIGENCE_TOPOLOGY_AWARE;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertHashTopology20Received;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertStatus;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertSuccess;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertTopologyReceived;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.killClient;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import static org.testng.AssertJUnit.assertEquals;
import java.lang.reflect.Method;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.server.hotrod.test.HotRodTestingUtil;
import org.infinispan.server.hotrod.test.TestResponse;
import org.infinispan.server.hotrod.test.TestSizeResponse;
import org.infinispan.test.TestingUtil;
import org.testng.annotations.Test;
/**
* Tests Hot Rod logic when interacting with distributed caches, particularly logic to do with
* hash-distribution-aware headers and how it behaves when cluster formation changes.
*
* @author Galder Zamarreño
* @since 4.1
*/
@Test(groups = "functional", testName = "server.hotrod.HotRodDistributionTest")
public class HotRodDistributionTest extends HotRodMultiNodeTest {
@Override
protected String cacheName() {
return "hotRodDistSync";
}
@Override
protected ConfigurationBuilder createCacheConfig() {
ConfigurationBuilder cfg = hotRodCacheConfiguration(
getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, false));
cfg.clustering().l1().disable(); // Disable L1 explicitly
return cfg;
}
public void testDistributedPutWithTopologyChanges(Method m) {
HotRodClient client1 = clients().get(0);
HotRodClient client2 = clients().get(1);
TestResponse resp = client1.ping(INTELLIGENCE_HASH_DISTRIBUTION_AWARE, 0);
assertStatus(resp, Success);
assertHashTopology20Received(resp.topologyResponse, servers(), cacheName(), currentServerTopologyId());
resp = client1.put(k(m), 0, 0, v(m), INTELLIGENCE_BASIC, 0);
assertStatus(resp, Success);
assertEquals(resp.topologyResponse, null);
assertSuccess(client2.get(k(m), 0), v(m));
resp = client1.put(k(m), 0, 0, v(m, "v1-"), INTELLIGENCE_TOPOLOGY_AWARE, 0);
assertStatus(resp, Success);
assertTopologyReceived(resp.topologyResponse, servers(), currentServerTopologyId());
resp = client2.put(k(m), 0, 0, v(m, "v2-"), INTELLIGENCE_TOPOLOGY_AWARE, 0);
assertStatus(resp, Success);
int serverClientTopologyId = currentServerTopologyId();
assertTopologyReceived(resp.topologyResponse, servers(), serverClientTopologyId);
resp = client1.put(k(m), 0, 0, v(m, "v3-"), INTELLIGENCE_TOPOLOGY_AWARE,
serverClientTopologyId);
assertStatus(resp, Success);
assertEquals(resp.topologyResponse, null);
assertSuccess(client2.get(k(m), 0), v(m, "v3-"));
resp = client1.put(k(m), 0, 0, v(m, "v4-"), INTELLIGENCE_HASH_DISTRIBUTION_AWARE, 0);
assertStatus(resp, Success);
assertHashTopology20Received(resp.topologyResponse, servers(), cacheName(), currentServerTopologyId());
assertSuccess(client2.get(k(m), 0), v(m, "v4-"));
resp = client2.put(k(m), 0, 0, v(m, "v5-"), INTELLIGENCE_HASH_DISTRIBUTION_AWARE, 0);
assertStatus(resp, Success);
assertHashTopology20Received(resp.topologyResponse, servers(), cacheName(), currentServerTopologyId());
assertSuccess(client2.get(k(m), 0), v(m, "v5-"));
HotRodServer newServer = startClusteredServer(servers().get(1).getPort() + 25);
HotRodClient newClient = new HotRodClient("127.0.0.1", newServer.getPort(), cacheName(), protocolVersion());
List<HotRodServer> allServers =
Stream.concat(Stream.of(newServer), servers().stream()).collect(Collectors.toList());
try {
log.trace("New client started, modify key to be v6-*");
resp = newClient.put(k(m), 0, 0, v(m, "v6-"), INTELLIGENCE_HASH_DISTRIBUTION_AWARE, 0);
assertStatus(resp, Success);
assertHashTopology20Received(resp.topologyResponse, allServers, cacheName(), currentServerTopologyId());
log.trace("Get key and verify that's v6-*");
assertSuccess(client2.get(k(m), 0), v(m, "v6-"));
resp = client2.put(k(m), 0, 0, v(m, "v7-"), INTELLIGENCE_HASH_DISTRIBUTION_AWARE, 0);
assertStatus(resp, Success);
assertHashTopology20Received(resp.topologyResponse, allServers, cacheName(), currentServerTopologyId());
assertSuccess(newClient.get(k(m), 0), v(m, "v7-"));
} finally {
log.trace("Stopping new server");
killClient(newClient);
stopClusteredServer(newServer);
TestingUtil.waitForNoRebalance(cache(0, cacheName()), cache(1, cacheName()));
log.trace("New server stopped");
}
resp = client2.put(k(m), 0, 0, v(m, "v8-"), INTELLIGENCE_HASH_DISTRIBUTION_AWARE, 0);
assertStatus(resp, Success);
assertHashTopology20Received(resp.topologyResponse, servers(), cacheName(), currentServerTopologyId());
assertSuccess(client1.get(k(m), 0), v(m, "v8-"));
}
public void testSize(Method m) {
// Cache contents not cleared between methods to avoid deleting
// topology information, so just use a different cache
String newCacheName = "dist-size";
startCaches(newCacheName);
List<HotRodClient> newClients = createClients(newCacheName);
try {
TestSizeResponse sizeStart = newClients.get(0).size();
assertStatus(sizeStart, Success);
assertEquals(0, sizeStart.size);
for (int i = 0; i < 20; i++) {
newClients.get(1).assertPut(m, "k-" + i, "v-" + i);
}
TestSizeResponse sizeEnd = newClients.get(1).size();
assertStatus(sizeEnd, Success);
assertEquals(20, sizeEnd.size);
} finally {
newClients.forEach(HotRodTestingUtil::killClient);
}
}
}
| 6,754
| 45.267123
| 114
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodMultiHomedAddressTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import java.io.IOException;
import java.net.InetAddress;
import java.net.InterfaceAddress;
import java.net.NetworkInterface;
import java.util.Enumeration;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.hotrod.configuration.HotRodServerConfigurationBuilder;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.server.hotrod.test.TestResponse;
import org.testng.annotations.Test;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.1
**/
@Test(testName = "server.hotrod.HotRodMultiHomedAddressTest", groups = "functional")
public class HotRodMultiHomedAddressTest extends HotRodMultiNodeTest {
public void testInAddrAny() throws IOException {
for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements(); ) {
NetworkInterface netif = en.nextElement();
for (InterfaceAddress address : netif.getInterfaceAddresses()) {
HotRodClient hotRodClient = createClient(servers().get(0), cacheName(), address.getAddress().getHostAddress());
TestResponse ping = hotRodClient.ping((byte) 2, 0);
assertEquals(2, ping.topologyResponse.members.size());
for(ServerAddress serverAddress : ping.topologyResponse.members) {
InetAddress inetAddress = InetAddress.getByName(serverAddress.getHost(null));
assertTrue(MultiHomedServerAddress.inetAddressMatchesInterfaceAddress(inetAddress.getAddress(), address.getAddress().getAddress(), address.getNetworkPrefixLength()));
}
Exceptions.unchecked(() -> hotRodClient.stop().await());
}
}
}
@Override
protected String cacheName() {
return "multi";
}
@Override
protected ConfigurationBuilder createCacheConfig() {
return hotRodCacheConfiguration(getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, false));
}
@Override
protected HotRodServer startTestHotRodServer(EmbeddedCacheManager cacheManager, int port) {
HotRodServerConfigurationBuilder builder = new HotRodServerConfigurationBuilder();
builder.topologyNetworkPrefixOverride(false);
return startHotRodServer(cacheManager, "0.0.0.0", port, builder);
}
}
| 2,744
| 42.571429
| 181
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodReplicationTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.hotrod.OperationStatus.OperationNotExecuted;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertHashTopology20Received;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertKeyDoesNotExist;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertStatus;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertSuccess;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertTopologyReceived;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import java.lang.reflect.Method;
import java.util.List;
import java.util.stream.Stream;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.server.hotrod.test.AbstractTestTopologyAwareResponse;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.server.hotrod.test.TestResponse;
import org.infinispan.server.hotrod.test.TestSizeResponse;
import org.infinispan.test.TestingUtil;
import org.testng.annotations.Test;
/**
* Tests Hot Rod instances configured with replication.
*
* @author Galder Zamarreño
* @since 4.1
*/
@Test(groups = "functional", testName = "server.hotrod.HotRodReplicationTest")
public class HotRodReplicationTest extends HotRodMultiNodeTest {
@Override
protected String cacheName() {
return "hotRodReplSync";
}
@Override
protected ConfigurationBuilder createCacheConfig() {
ConfigurationBuilder config =
hotRodCacheConfiguration(getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, false));
config.clustering().stateTransfer().fetchInMemoryState(true);
return config;
}
public void testReplicatedPut(Method m) {
TestResponse resp = clients().get(0).put(k(m), 0, 0, v(m));
assertStatus(resp, Success);
assertSuccess(clients().get(1).get(k(m), 0), v(m));
}
public void testReplicatedPutIfAbsent(Method m) {
assertKeyDoesNotExist(clients().get(0).assertGet(m));
assertKeyDoesNotExist(clients().get(1).assertGet(m));
TestResponse resp = clients().get(0).putIfAbsent(k(m), 0, 0, v(m));
assertStatus(resp, Success);
assertSuccess(clients().get(1).get(k(m), 0), v(m));
assertStatus(clients().get(1).putIfAbsent(k(m), 0, 0, v(m, "v2-")), OperationNotExecuted);
}
public void testReplicatedReplace(Method m) {
TestResponse resp = clients().get(0).replace(k(m), 0, 0, v(m));
assertStatus(resp, OperationNotExecuted);
resp = clients().get(1).replace(k(m), 0, 0, v(m));
assertStatus(resp, OperationNotExecuted);
clients().get(1).assertPut(m);
resp = clients().get(1).replace(k(m), 0, 0, v(m, "v1-"));
assertStatus(resp, Success);
assertSuccess(clients().get(0).assertGet(m), v(m, "v1-"));
resp = clients().get(0).replace(k(m), 0, 0, v(m, "v2-"));
assertStatus(resp, Success);
assertSuccess(clients().get(1).assertGet(m), v(m, "v2-"));
}
public void testPingWithTopologyAwareClient() {
TestResponse resp = clients().get(0).ping();
assertStatus(resp, Success);
assertEquals(resp.topologyResponse, null);
resp = clients().get(1).ping((byte) 1, 0);
assertStatus(resp, Success);
assertEquals(resp.topologyResponse, null);
resp = clients().get(0).ping((byte) 2, 0);
assertStatus(resp, Success);
assertTopologyReceived(resp.topologyResponse, servers(), currentServerTopologyId());
resp = clients().get(1).ping((byte) 2, 0);
assertStatus(resp, Success);
int serverClientTopologyId = currentServerTopologyId();
assertTopologyReceived(resp.topologyResponse, servers(), serverClientTopologyId);
resp = clients().get(1).ping((byte) 2, serverClientTopologyId);
assertStatus(resp, Success);
assertEquals(resp.topologyResponse, null);
}
public void testReplicatedPutWithTopologyChanges(Method m) {
TestResponse resp = clients().get(0).put(k(m), 0, 0, v(m), (byte) 1, 0);
assertStatus(resp, Success);
assertEquals(resp.topologyResponse, null);
assertSuccess(clients().get(1).get(k(m), 0), v(m));
resp = clients().get(0).put(k(m), 0, 0, v(m, "v1-"), (byte) 2, 0);
assertStatus(resp, Success);
assertTopologyReceived(resp.topologyResponse, servers(), currentServerTopologyId());
resp = clients().get(1).put(k(m), 0, 0, v(m, "v2-"), (byte) 2, 0);
assertStatus(resp, Success);
int serverClientTopologyId = currentServerTopologyId();
assertTopologyReceived(resp.topologyResponse, servers(), serverClientTopologyId);
resp = clients().get(0)
.put(k(m), 0, 0, v(m, "v3-"), (byte) 2, serverClientTopologyId);
assertStatus(resp, Success);
assertEquals(resp.topologyResponse, null);
assertSuccess(clients().get(1).get(k(m), 0), v(m, "v3-"));
HotRodServer newServer = startClusteredServer(servers().get(1).getPort() + 25);
try {
resp = clients().get(0)
.put(k(m), 0, 0, v(m, "v4-"), (byte) 2, serverClientTopologyId);
assertStatus(resp, Success);
serverClientTopologyId = currentServerTopologyId();
assertEquals(resp.topologyResponse.topologyId, serverClientTopologyId);
AbstractTestTopologyAwareResponse topoResp = resp.asTopologyAwareResponse();
assertEquals(topoResp.members.size(), 3);
Stream.concat(Stream.of(newServer), servers().stream())
.map(HotRodServer::getAddress)
.forEach(serverAddress -> assertTrue(topoResp.members.contains(serverAddress)));
assertSuccess(clients().get(1).get(k(m), 0), v(m, "v4-"));
} finally {
stopClusteredServer(newServer);
TestingUtil.waitForNoRebalance(cache(0, cacheName()), cache(1, cacheName()));
}
resp = clients().get(0)
.put(k(m), 0, 0, v(m, "v5-"), (byte) 2, serverClientTopologyId);
assertStatus(resp, Success);
serverClientTopologyId = currentServerTopologyId();
assertEquals(resp.topologyResponse.topologyId, serverClientTopologyId);
AbstractTestTopologyAwareResponse topoResp3 = resp.asTopologyAwareResponse();
assertEquals(topoResp3.members.size(), 2);
servers().stream()
.map(HotRodServer::getAddress)
.forEach(addr -> assertTrue(topoResp3.members.contains(addr)));
assertSuccess(clients().get(1).get(k(m), 0), v(m, "v5-"));
HotRodServer crashingServer = startClusteredServer(servers().get(1).getPort() + 25);
try {
resp = clients().get(0).put(k(m), 0, 0, v(m, "v6-"), (byte) 2, serverClientTopologyId);
assertStatus(resp, Success);
serverClientTopologyId = currentServerTopologyId();
assertEquals(resp.topologyResponse.topologyId, serverClientTopologyId);
AbstractTestTopologyAwareResponse topoResp2 = resp.asTopologyAwareResponse();
assertEquals(topoResp2.members.size(), 3);
Stream.concat(Stream.of(crashingServer), servers().stream())
.map(HotRodServer::getAddress)
.forEach(addr -> assertTrue(topoResp2.members.contains(addr)));
assertSuccess(clients().get(1).get(k(m), 0), v(m, "v6-"));
} finally {
stopClusteredServer(crashingServer);
TestingUtil.waitForNoRebalance(cache(0, cacheName()), cache(1, cacheName()));
}
resp = clients().get(0)
.put(k(m), 0, 0, v(m, "v7-"), (byte) 2, serverClientTopologyId);
assertStatus(resp, Success);
assertEquals(resp.topologyResponse.topologyId, currentServerTopologyId());
AbstractTestTopologyAwareResponse topoResp4 = resp.asTopologyAwareResponse();
assertEquals(topoResp4.members.size(), 2);
servers().stream()
.map(HotRodServer::getAddress)
.forEach(addr -> assertTrue(topoResp4.members.contains(addr)));
assertSuccess(clients().get(1).get(k(m), 0), v(m, "v7-"));
resp = clients().get(0).put(k(m), 0, 0, v(m, "v8-"), (byte) 3, 1);
assertStatus(resp, Success);
checkTopologyReceived(resp.topologyResponse, servers(), cacheName());
assertSuccess(clients().get(1).get(k(m), 0), v(m, "v8-"));
}
public void testSize(Method m) {
// Cache contents not cleared between methods to avoid deleting
// topology information, so just use a different cache
String newCacheName = "repl-size";
startCaches(newCacheName);
List<HotRodClient> newClients = createClients(newCacheName);
try {
TestSizeResponse sizeStart = newClients.get(0).size();
assertStatus(sizeStart, Success);
assertEquals(0, sizeStart.size);
for (int i = 0; i < 20; i++) {
newClients.get(1).assertPut(m, "k-" + i, "v-" + i);
}
TestSizeResponse sizeEnd = newClients.get(1).size();
assertStatus(sizeEnd, Success);
assertEquals(20, sizeEnd.size);
} finally {
newClients.forEach(HotRodClient::stop);
}
}
protected void checkTopologyReceived(AbstractTestTopologyAwareResponse topoResp, List<HotRodServer> servers,
String cacheName) {
assertHashTopology20Received(topoResp, servers, cacheName, currentServerTopologyId());
}
}
| 9,740
| 44.097222
| 111
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodSingleClusteredNonLoopbackTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.core.test.ServerTestingUtil.killServer;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.findNetworkInterfaces;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.getDefaultHotRodConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.killClient;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.serverPort;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import static org.testng.Assert.assertEquals;
import java.lang.reflect.Method;
import java.net.NetworkInterface;
import java.util.EnumSet;
import java.util.List;
import org.infinispan.commons.test.skip.SkipTestNG;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.registry.InternalCacheRegistry;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.server.hotrod.test.TestResponse;
import org.infinispan.test.MultipleCacheManagersTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "server.hotrod.HotRodSingleClusteredNonLoopbackTest")
public class HotRodSingleClusteredNonLoopbackTest extends MultipleCacheManagersTest {
private HotRodServer hotRodServer;
private HotRodClient hotRodClient;
private final String cacheName = "HotRodCache";
@Override
protected void createCacheManagers() {
EmbeddedCacheManager cm = TestCacheManagerFactory.createClusteredCacheManager(hotRodCacheConfiguration());
cacheManagers.add(cm);
ConfigurationBuilder builder = hotRodCacheConfiguration(
getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, false));
cm.defineConfiguration(cacheName, builder.build());
}
@BeforeClass(alwaysRun = true)
@Override
public void createBeforeClass() throws Throwable {
super.createBeforeClass();
List<NetworkInterface> nonLoopInterfaces = findNetworkInterfaces(false);
SkipTestNG.skipIf(nonLoopInterfaces.isEmpty(), "No non-loop network interface");
NetworkInterface iface = nonLoopInterfaces.iterator().next();
String address = iface.getInetAddresses().nextElement().getHostAddress();
hotRodServer = startHotRodServer(cacheManagers.get(0), address, serverPort(), getDefaultHotRodConfiguration());
hotRodClient = new HotRodClient(address, hotRodServer.getPort(), cacheName, (byte) 20);
}
@AfterClass(alwaysRun = true)
@Override
protected void destroy() {
log.debug("Test finished, close client, server, and cache managers");
killClient(hotRodClient);
killServer(hotRodServer);
super.destroy();
}
public void testNonLoopbackPutOnProtectedCache(Method m) {
InternalCacheRegistry internalCacheRegistry =
manager(0).getGlobalComponentRegistry().getComponent(InternalCacheRegistry.class);
internalCacheRegistry.registerInternalCache("MyInternalCache",
hotRodCacheConfiguration().build(),
EnumSet.of(InternalCacheRegistry.Flag.USER,
InternalCacheRegistry.Flag.PROTECTED));
TestResponse resp = hotRodClient
.execute(0xA0, (byte) 0x01, "MyInternalCache", k(m), 0, 0, v(m), 0, (byte) 1, 0);
assertEquals(resp.status, Success, "Status should have been 'Success' but instead was: " + resp.status);
hotRodClient.assertPut(m);
}
}
| 4,084
| 46.5
| 117
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodAuthenticationTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import java.lang.reflect.Method;
import java.util.HashMap;
import javax.security.sasl.Sasl;
import javax.security.sasl.SaslClient;
import javax.security.sasl.SaslException;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.core.security.simple.SimpleSaslAuthenticator;
import org.infinispan.server.hotrod.configuration.HotRodServerConfigurationBuilder;
import org.infinispan.server.hotrod.test.HotRodTestingUtil;
import org.infinispan.server.hotrod.test.TestAuthMechListResponse;
import org.infinispan.server.hotrod.test.TestAuthResponse;
import org.infinispan.server.hotrod.test.TestCallbackHandler;
import org.infinispan.test.TestingUtil;
import org.testng.annotations.Test;
import io.netty.channel.group.ChannelGroup;
/**
* Hot Rod server authentication test.
*
* @author Tristan Tarrant
* @since 7.0
*/
@Test(groups = "functional", testName = "server.hotrod.HotRodAuthenticationTest")
public class HotRodAuthenticationTest extends HotRodSingleNodeTest {
@Override
public HotRodServer createStartHotRodServer(EmbeddedCacheManager cacheManager) {
SimpleSaslAuthenticator ssap = new SimpleSaslAuthenticator();
ssap.addUser("user", "realm", "password".toCharArray());
HotRodServerConfigurationBuilder builder = new HotRodServerConfigurationBuilder();
builder.authentication().enable()
.sasl()
.authenticator(ssap)
.addAllowedMech("CRAM-MD5")
.serverName("localhost")
.addMechProperty(Sasl.POLICY_NOANONYMOUS, "true");
return startHotRodServer(cacheManager, HotRodTestingUtil.serverPort(), builder);
}
public void testAuthMechList(Method m) {
TestAuthMechListResponse a = client().authMechList();
assertEquals(1, a.mechs.size());
assertTrue(a.mechs.contains("CRAM-MD5"));
assertEquals(1, server().getTransport().getNumberOfLocalConnections());
}
public void testAuth(Method m) throws SaslException {
HashMap<String, String> props = new HashMap<>();
SaslClient sc = Sasl.createSaslClient(new String[]{"CRAM-MD5"}, null, "hotrod", "localhost", props,
new TestCallbackHandler("user", "realm", "password"));
TestAuthResponse res = client().auth(sc);
assertTrue(res.complete);
assertEquals(1, server().getTransport().getNumberOfLocalConnections());
}
public void testUnauthorizedOpCloseConnection(Method m) {
// Ensure the transport is clean
ChannelGroup acceptedChannels =
TestingUtil.extractField(server().getTransport(), "acceptedChannels");
acceptedChannels.close().awaitUninterruptibly();
try {
client().assertPutFail(m);
} finally {
assertEquals(0, server().getTransport().getNumberOfLocalConnections());
}
}
}
| 3,073
| 38.922078
| 105
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodStatsTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertSuccess;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import static org.infinispan.test.fwk.TestCacheManagerFactory.configureJmx;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertTrue;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Objects;
import org.infinispan.commons.jmx.MBeanServerLookup;
import org.infinispan.commons.jmx.TestMBeanServerLookup;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
/**
* Tests stats operation against a Hot Rod server.
*
* @author Galder Zamarreño
* @since 4.1
*/
@Test(groups = "functional", testName = "server.hotrod.HotRodStatsTest")
public class HotRodStatsTest extends HotRodSingleNodeTest {
private final MBeanServerLookup mBeanServerLookup = TestMBeanServerLookup.create();
@Override
public EmbeddedCacheManager createTestCacheManager() {
ConfigurationBuilder cfg = hotRodCacheConfiguration();
cfg.statistics().enable();
GlobalConfigurationBuilder globalCfg = GlobalConfigurationBuilder.defaultClusteredBuilder();
globalCfg.cacheContainer().statistics(true).metrics().accurateSize(true);
configureJmx(globalCfg, jmxDomain(), mBeanServerLookup);
return TestCacheManagerFactory.createClusteredCacheManager(globalCfg, cfg);
}
public void testStats(Method m) {
int bytesRead = 0;
int bytesWritten = 0;
Map<String, String> s = client().stats();
assertEquals(s.get("currentNumberOfEntries"), "0");
assertEquals(s.get("stores"), "0");
assertEquals(s.get("retrievals"), "0");
assertEquals(s.get("hits"), "0");
assertEquals(s.get("misses"), "0");
assertEquals(s.get("removeHits"), "0");
assertEquals(s.get("removeMisses"), "0");
bytesRead = assertHigherBytes(bytesRead, s.get("totalBytesRead"));
// At time of request, no data had been written yet
assertEquals(s.get("totalBytesWritten"), "0");
client().assertPut(m);
s = client().stats();
assertEquals(s.get("currentNumberOfEntries"), "1");
assertEquals(s.get("stores"), "1");
bytesRead = assertHigherBytes(bytesRead, s.get("totalBytesRead"));
bytesWritten = assertHigherBytes(bytesWritten, s.get("totalBytesWritten"));
assertFalse(Objects.equals(s.get("totalBytesRead"), "0"));
assertFalse(Objects.equals(s.get("totalBytesWritten"), "0"));
assertSuccess(client().assertGet(m), v(m));
s = client().stats();
assertEquals(s.get("hits"), "1");
assertEquals(s.get("misses"), "0");
assertEquals(s.get("retrievals"), "1");
assertHigherBytes(bytesRead, s.get("totalBytesRead"));
assertHigherBytes(bytesWritten, s.get("totalBytesWritten"));
client().clear();
s = client().stats();
assertEquals(s.get("currentNumberOfEntries"), "0");
}
private int assertHigherBytes(int currentBytesRead, String bytesStr) {
int bytesRead = Integer.valueOf(bytesStr);
assertTrue(String.format("Expecting %d > %d", bytesRead, currentBytesRead), bytesRead > currentBytesRead);
return bytesRead;
}
}
| 3,613
| 39.155556
| 112
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodStatsClusterTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.hotrod.Constants.INTELLIGENCE_HASH_DISTRIBUTION_AWARE;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertKeyDoesNotExist;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertStatus;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertSuccess;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import static org.testng.AssertJUnit.assertEquals;
import java.lang.reflect.Method;
import java.util.Map;
import org.infinispan.commands.module.TestGlobalConfigurationBuilder;
import org.infinispan.commons.time.ControlledTimeService;
import org.infinispan.commons.time.TimeService;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.server.hotrod.test.HotRodMagicKeyGenerator;
import org.infinispan.server.hotrod.test.TestResponse;
import org.infinispan.stats.impl.AbstractClusterStats;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "server.hotrod.HotRodStatsClusterTest")
public class HotRodStatsClusterTest extends HotRodMultiNodeTest {
ControlledTimeService timeService = new ControlledTimeService();
@Override
protected byte protocolVersion() {
return 24;
}
@Override
protected String cacheName() {
return "hotRodClusterStats";
}
@Override
protected EmbeddedCacheManager createCacheManager() {
GlobalConfigurationBuilder global = GlobalConfigurationBuilder.defaultClusteredBuilder();
global.metrics().accurateSize(true);
global.addModule(TestGlobalConfigurationBuilder.class)
.testGlobalComponent(TimeService.class, timeService);
return TestCacheManagerFactory.createClusteredCacheManager(global, hotRodCacheConfiguration());
}
@Override
protected ConfigurationBuilder createCacheConfig() {
ConfigurationBuilder config = hotRodCacheConfiguration(getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, false));
config.statistics().enable();
config.clustering().hash().numOwners(1);
return config;
}
public void testClusterStats(Method m) throws Exception {
HotRodClient client1 = clients().get(0);
HotRodClient client2 = clients().get(1);
byte[] key1 = HotRodMagicKeyGenerator.newKey(cache(0, cacheName()));
byte[] value = v(m, "v1-");
TestResponse resp = client1.put(key1, 0, 0, value, INTELLIGENCE_HASH_DISTRIBUTION_AWARE, 0);
assertStatus(resp, Success);
assertSuccess(client1.get(key1, 0), value);
client1.remove(k(m));
Map<String, String> stats1 = client1.stats();
assertEquals(stats1.get("currentNumberOfEntries"), "1");
assertEquals(stats1.get("stores"), "1");
assertEquals(stats1.get("hits"), "1");
assertEquals(stats1.get("retrievals"), "1");
assertEquals(stats1.get("removeMisses"), "1");
assertEquals(stats1.get("globalCurrentNumberOfEntries"), "1");
assertEquals(stats1.get("globalStores"), "1");
assertEquals(stats1.get("globalHits"), "1");
assertEquals(stats1.get("globalRetrievals"), "1");
assertEquals(stats1.get("globalRemoveMisses"), "1");
Map<String, String> stats2 = client2.stats();
assertEquals(stats2.get("currentNumberOfEntries"), "0");
assertEquals(stats2.get("stores"), "0");
assertEquals(stats2.get("hits"), "0");
assertEquals(stats2.get("retrievals"), "0");
assertEquals(stats2.get("removeMisses"), "0");
assertEquals(stats2.get("globalCurrentNumberOfEntries"), "1");
assertEquals(stats2.get("globalStores"), "1");
assertEquals(stats2.get("globalHits"), "1");
assertEquals(stats2.get("globalRetrievals"), "1");
assertEquals(stats2.get("globalRemoveMisses"), "1");
timeService.advance(AbstractClusterStats.DEFAULT_STALE_STATS_THRESHOLD + 1);
client1.remove(key1);
assertKeyDoesNotExist(client1.get(key1, 0));
stats1 = client1.stats();
assertEquals(stats1.get("misses"), "1");
assertEquals(stats1.get("removeHits"), "1");
assertEquals(stats1.get("globalMisses"), "1");
assertEquals(stats1.get("globalRemoveHits"), "1");
stats2 = client2.stats();
assertEquals(stats2.get("misses"), "0");
assertEquals(stats2.get("removeHits"), "0");
assertEquals(stats2.get("globalMisses"), "1");
assertEquals(stats2.get("globalRemoveHits"), "1");
}
}
| 4,981
| 42.321739
| 121
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodNoDefaultCacheTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.core.test.ServerTestingUtil.killServer;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.killClient;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.server.hotrod.test.TestErrorResponse;
import org.infinispan.server.hotrod.test.TestResponse;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
/**
* Tests stats operation against a Hot Rod server.
*
* @author Galder Zamarreño
* @since 4.1
*/
@Test(groups = "functional", testName = "server.hotrod.HotRodNoDefaultCacheTest")
public class HotRodNoDefaultCacheTest extends SingleCacheManagerTest {
private HotRodServer server;
private HotRodClient client;
@Override
public EmbeddedCacheManager createCacheManager() {
EmbeddedCacheManager cm = TestCacheManagerFactory.createCacheManager((ConfigurationBuilder) null);
return cm;
}
@Override
protected void setup() throws Exception {
// super() creates the default cache and we do not want that
cacheManager = createCacheManager();
server = startHotRodServer(cacheManager, (String)null);
client = new HotRodClient("127.0.0.1", server.getPort(), "", HotRodVersion.HOTROD_21.getVersion());
}
@Override
protected void teardown() {
log.debug("Killing Hot Rod client and server");
killClient(client);
killServer(server);
super.teardown();
}
public void testNoDefault() {
TestResponse response = client.get("k1");
assertTrue(response instanceof TestErrorResponse);
TestErrorResponse error = (TestErrorResponse)response;
assertEquals("org.infinispan.server.hotrod.CacheNotFoundException: Default cache requested but not configured", error.msg);
}
}
| 2,185
| 36.050847
| 129
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodIdleTimeoutTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.commons.test.Exceptions.expectException;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.killClient;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.serverPort;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import java.lang.reflect.Method;
import java.nio.channels.ClosedChannelException;
import java.util.concurrent.CompletionException;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.testng.annotations.Test;
/**
* Tests idle timeout logic in Hot Rod.
*
* @author Galder Zamarreño
* @since 4.1
*/
@Test(groups = "functional", testName = "server.hotrod.HotRodIdleTimeoutTest")
public class HotRodIdleTimeoutTest extends HotRodSingleNodeTest {
public static final int IDLE_TIMEOUT = 1;
@Override
protected HotRodServer createStartHotRodServer(EmbeddedCacheManager cacheManager) {
return startHotRodServer(cacheManager, serverPort(), IDLE_TIMEOUT);
}
@Override
protected HotRodClient connectClient() {
return new HotRodClient("127.0.0.1", server().getPort(), cacheName, (byte) 20);
}
public void testSendPartialRequest(Method m) {
client().assertPut(m);
expectException(CompletionException.class, ClosedChannelException.class,
() -> client().executePartial(0xA0, (byte) 0x03, cacheName, k(m), 0, 0, v(m), 0));
// The connection cannot be used to send another request
client().assertPutFail(m);
shutdownClient();
// But another connection will work
HotRodClient newClient = connectClient();
try {
newClient.assertPut(m);
} finally {
killClient(newClient);
}
}
}
| 1,964
| 33.473684
| 104
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodSingleClusteredTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.core.test.ServerTestingUtil.killServer;
import static org.infinispan.server.hotrod.OperationStatus.ParseError;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertStatus;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertSuccess;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.killClient;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import java.lang.reflect.Method;
import java.util.EnumSet;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.registry.InternalCacheRegistry;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.server.hotrod.test.TestErrorResponse;
import org.infinispan.server.hotrod.test.TestResponse;
import org.infinispan.test.MultipleCacheManagersTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "server.hotrod.HotRodSingleClusteredTest")
public class HotRodSingleClusteredTest extends MultipleCacheManagersTest {
private HotRodServer hotRodServer;
private HotRodClient hotRodClient;
private String cacheName = "HotRodCache";
@Override
protected void createCacheManagers() {
EmbeddedCacheManager cm = TestCacheManagerFactory.createClusteredCacheManager(hotRodCacheConfiguration());
cacheManagers.add(cm);
ConfigurationBuilder builder = hotRodCacheConfiguration(
getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, false));
cm.defineConfiguration(cacheName, builder.build());
}
@BeforeClass(alwaysRun = true)
@Override
public void createBeforeClass() throws Throwable {
super.createBeforeClass();
hotRodServer = startHotRodServer(cacheManagers.get(0));
hotRodClient = new HotRodClient("127.0.0.1", hotRodServer.getPort(), cacheName, (byte) 20);
}
@AfterClass(alwaysRun = true)
@Override
protected void destroy() {
log.debug("Test finished, close client, server, and cache managers");
killClient(hotRodClient);
killServer(hotRodServer);
super.destroy();
}
public void testPutGet(Method m) {
assertStatus(hotRodClient.put(k(m), 0, 0, v(m)), Success);
assertSuccess(hotRodClient.get(k(m), 0), v(m));
}
public void testPutOnPrivateCache(Method m) {
TestErrorResponse resp = (TestErrorResponse) hotRodClient
.execute(0xA0, (byte) 0x01, hotRodServer.getConfiguration().topologyCacheName(), k(m), 0, 0, v(m), 0,
(byte) 1, 0);
assertTrue(resp.msg.contains("Remote requests are not allowed to private caches."));
assertEquals("Status should have been 'ParseError' but instead was: " + resp.status, ParseError, resp.status);
hotRodClient.assertPut(m);
}
public void testLoopbackPutOnProtectedCache(Method m) {
InternalCacheRegistry internalCacheRegistry =
manager(0).getGlobalComponentRegistry().getComponent(InternalCacheRegistry.class);
internalCacheRegistry.registerInternalCache("MyInternalCache",
hotRodCacheConfiguration().build(),
EnumSet.of(InternalCacheRegistry.Flag.USER,
InternalCacheRegistry.Flag.PROTECTED));
TestResponse resp = hotRodClient.execute(0xA0, (byte) 0x01, "MyInternalCache", k(m), 0, 0, v(m), 0, (byte) 1, 0);
assertEquals(Success, resp.status);
}
}
| 4,217
| 44.354839
| 119
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodAsymmetricClusterTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.hotrod.OperationStatus.ParseError;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertStatus;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import java.lang.reflect.Method;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.hotrod.test.TestResponse;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
/**
* Tests behaviour of Hot Rod servers with asymmetric clusters
*
* @author Galder Zamarreño
* @since 5.2
*/
@Test(groups = "functional", testName = "server.hotrod.HotRodAsymmetricClusterTest")
public class HotRodAsymmetricClusterTest extends HotRodMultiNodeTest {
protected String cacheName() { return "asymmetricCache"; }
protected ConfigurationBuilder createCacheConfig() {
return hotRodCacheConfiguration(
getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, false));
}
@Override
protected void createCacheManagers() {
for (int i = 0; i < 2; i++) {
EmbeddedCacheManager cm = TestCacheManagerFactory.createClusteredCacheManager(hotRodCacheConfiguration());
cacheManagers.add(cm);
if (i == 0) {
cm.defineConfiguration(cacheName(), createCacheConfig().build());
}
}
}
public void testPutInCacheDefinedNode(Method m) {
TestResponse resp = clients().get(0).put(k(m) , 0, 0, v(m));
assertStatus(resp, Success);
}
public void testPutInNonCacheDefinedNode(Method m) {
TestResponse resp = clients().get(1).put(k(m) , 0, 0, v(m));
assertStatus(resp, ParseError);
}
}
| 2,031
| 34.034483
| 114
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodSslFunctionalTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.host;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.serverPort;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLEngine;
import org.infinispan.commons.test.security.TestCertificates;
import org.infinispan.commons.util.SslContextFactory;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.core.configuration.SslConfiguration;
import org.infinispan.server.hotrod.configuration.HotRodServerConfigurationBuilder;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.testng.annotations.Test;
/**
* Hot Rod server functional test over SSL
*
* @author Tristan Tarrant
* @since 5.3
*/
@Test(groups = "functional", testName = "server.hotrod.HotRodSslFunctionalTest")
public class HotRodSslFunctionalTest extends HotRodFunctionalTest {
@Override
protected HotRodServer createStartHotRodServer(EmbeddedCacheManager cacheManager) {
HotRodServerConfigurationBuilder builder = new HotRodServerConfigurationBuilder();
builder.proxyHost(host()).proxyPort(serverPort()).idleTimeout(0);
builder.ssl().enable()
.keyStoreFileName(TestCertificates.certificate("server"))
.keyStorePassword(TestCertificates.KEY_PASSWORD)
.keyStoreType(TestCertificates.KEYSTORE_TYPE)
.trustStoreFileName(TestCertificates.certificate("trust"))
.trustStorePassword(TestCertificates.KEY_PASSWORD)
.trustStoreType(TestCertificates.KEYSTORE_TYPE);
return startHotRodServer(cacheManager, serverPort(), builder);
}
@Override
protected HotRodClient connectClient(byte protocolVersion) {
SslConfiguration ssl = hotRodServer.getConfiguration().ssl();
SSLContext sslContext = new SslContextFactory()
.keyStoreFileName(ssl.keyStoreFileName())
.keyStorePassword(ssl.keyStorePassword())
.keyStoreType(TestCertificates.KEYSTORE_TYPE)
.trustStoreFileName(ssl.trustStoreFileName())
.trustStorePassword(ssl.trustStorePassword())
.trustStoreType(TestCertificates.KEYSTORE_TYPE)
.getContext();
SSLEngine sslEngine = SslContextFactory.getEngine(sslContext, true, false);
return new HotRodClient(hotRodServer.getHost(), hotRodServer.getPort(), cacheName,
HotRodClient.DEFAULT_TIMEOUT_SECONDS, protocolVersion, sslEngine);
}
}
| 2,588
| 44.421053
| 96
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodConfigurationTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.serverPort;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNotNull;
import static org.testng.AssertJUnit.assertTrue;
import java.util.function.BiConsumer;
import org.infinispan.configuration.cache.ClusterLoaderConfiguration;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.server.core.test.Stoppable;
import org.infinispan.server.hotrod.configuration.HotRodServerConfigurationBuilder;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
/**
* Test to verify that configuration changes are reflected in backend caches.
*
* @author Galder Zamarreño
* @since 4.2
*/
@Test(groups = "functional", testName = "server.hotrod.HotRodConfigurationTest")
public class HotRodConfigurationTest extends AbstractInfinispanTest {
public void testUserDefinedTimeouts() {
HotRodServerConfigurationBuilder builder = new HotRodServerConfigurationBuilder();
builder.topologyLockTimeout(26000).topologyReplTimeout(31000);
withClusteredServer(builder, (cfg, distSyncTimeout) -> {
assertEquals(cfg.locking().lockAcquisitionTimeout(), 26000);
assertEquals(cfg.clustering().remoteTimeout(), 31000);
assertTrue(cfg.clustering().stateTransfer().fetchInMemoryState());
assertEquals(cfg.clustering().stateTransfer().timeout(), 31000 + distSyncTimeout);
assertTrue(cfg.persistence().stores().isEmpty());
});
}
public void testLazyLoadTopology() {
HotRodServerConfigurationBuilder builder = new HotRodServerConfigurationBuilder();
builder.topologyStateTransfer(false).topologyReplTimeout(43000);
withClusteredServer(builder, (cfg, distSyncTimeout) -> {
assertEquals(cfg.clustering().remoteTimeout(), 43000);
assertTrue(cfg.clustering().stateTransfer().fetchInMemoryState());
ClusterLoaderConfiguration clcfg = ((ClusterLoaderConfiguration) cfg.persistence().stores().get(0));
assertNotNull(clcfg);
assertEquals(clcfg.remoteCallTimeout(), 43000);
});
}
private void withClusteredServer(HotRodServerConfigurationBuilder builder,
BiConsumer<Configuration, Long> consumer) {
Stoppable.useCacheManager(TestCacheManagerFactory.createClusteredCacheManager(hotRodCacheConfiguration()), cm ->
Stoppable.useServer(startHotRodServer(cm, serverPort(), builder), server -> {
Configuration cfg = cm.getCacheConfiguration(server.getConfiguration().topologyCacheName());
consumer.accept(cfg, cm.getCacheManagerConfiguration().transport().distributedSyncTimeout());
}));
}
}
| 3,041
| 47.285714
| 118
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/HotRodSharedContainerTest.java
|
package org.infinispan.server.hotrod;
import static org.infinispan.server.core.test.ServerTestingUtil.killServer;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertSuccess;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.killClient;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.serverPort;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import java.lang.reflect.Method;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.hotrod.configuration.HotRodServerConfigurationBuilder;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.test.MultipleCacheManagersTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "server.hotrod.HotRodSharedContainerTest")
public class HotRodSharedContainerTest extends MultipleCacheManagersTest {
private HotRodServer hotRodServer1;
private HotRodServer hotRodServer2;
private HotRodClient hotRodClient1;
private HotRodClient hotRodClient2;
private String cacheName = "HotRodCache";
@Override
protected void createCacheManagers() {
GlobalConfigurationBuilder globalCfg = GlobalConfigurationBuilder.defaultClusteredBuilder();
EmbeddedCacheManager cm =
TestCacheManagerFactory.createClusteredCacheManager(globalCfg, hotRodCacheConfiguration());
cacheManagers.add(cm);
ConfigurationBuilder builder = hotRodCacheConfiguration(
getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, false));
cm.defineConfiguration(cacheName, builder.build());
}
@Test(expectedExceptions = CacheConfigurationException.class)
public void testTopologyConflict() {
int basePort = serverPort();
hotRodServer1 = startHotRodServer(cacheManagers.get(0), basePort, new HotRodServerConfigurationBuilder());
hotRodServer2 = startHotRodServer(cacheManagers.get(0), basePort + 50, new HotRodServerConfigurationBuilder());
}
public void testSharedContainer(Method m) {
int basePort = serverPort();
hotRodServer1 =
startHotRodServer(cacheManagers.get(0), basePort, new HotRodServerConfigurationBuilder().name("1"));
hotRodServer2 =
startHotRodServer(cacheManagers.get(0), basePort + 50, new HotRodServerConfigurationBuilder().name("2"));
hotRodClient1 = new HotRodClient("127.0.0.1", hotRodServer1.getPort(), cacheName, (byte) 20);
hotRodClient2 = new HotRodClient("127.0.0.1", hotRodServer2.getPort(), cacheName, (byte) 20);
hotRodClient1.put(k(m), 0, 0, v(m));
assertSuccess(hotRodClient2.get(k(m), 0), v(m));
}
@AfterMethod(alwaysRun = true)
void killClientsAndServers() {
killClient(hotRodClient1);
killClient(hotRodClient2);
killServer(hotRodServer1);
killServer(hotRodServer2);
}
}
| 3,458
| 44.513158
| 117
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/stress/HotRodBigDataStressTest.java
|
package org.infinispan.server.hotrod.stress;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertStatus;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.test.TestingUtil.generateRandomString;
import java.lang.reflect.Method;
import org.infinispan.server.hotrod.HotRodSingleNodeTest;
import org.testng.annotations.Test;
/**
* A simple test that stresses Hot Rod by storing big data and waits to allow
* the test runner to generate heap dumps for the test.
*
* @author Galder Zamarreño
* @since 5.1
*/
@Test(groups = "profiling", testName = "server.hotrod.stress.HotRodBigDataStressTest")
public class HotRodBigDataStressTest extends HotRodSingleNodeTest {
public void testPutBigSizeValue(Method m) throws InterruptedException {
byte[] value = generateRandomString(10 * 1024 * 1024).getBytes();
assertStatus(client().put(k(m), 0, 0, value), Success);
while (true) {
Thread.sleep(5000);
}
}
}
| 1,079
| 32.75
| 86
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/configuration/BuilderMutationTest.java
|
package org.infinispan.server.hotrod.configuration;
import static org.testng.Assert.assertEquals;
import org.testng.annotations.Test;
/**
* @author Radim Vansa <rvansa@redhat.com>
*/
@Test(groups = "functional", testName = "server.hotrod.configuration.BuilderMutationTest")
public class BuilderMutationTest {
public void testMutatePortAndHost() {
HotRodServerConfigurationBuilder builder = new HotRodServerConfigurationBuilder();
builder.host("foo").port(1234);
assertHostPort(builder.build(), "foo", 1234);
builder.host("bar").port(4321);
assertHostPort(builder.build(), "bar", 4321);
}
private void assertHostPort(HotRodServerConfiguration configuration, String host, int port) {
assertEquals(configuration.host(), host);
assertEquals(configuration.proxyHost(), null);
assertEquals(configuration.publicHost(), host);
assertEquals(configuration.port(), port);
assertEquals(configuration.proxyPort(), -1);
assertEquals(configuration.publicPort(), port);
}
}
| 1,052
| 30.909091
| 96
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/logging/HotRodAccessLoggingTest.java
|
package org.infinispan.server.hotrod.logging;
import static org.testng.AssertJUnit.assertTrue;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.core.layout.PatternLayout;
import org.infinispan.commons.test.TestResourceTracker;
import org.infinispan.commons.test.skip.StringLogAppender;
import org.infinispan.server.hotrod.HotRodSingleNodeTest;
import org.testng.annotations.Test;
/**
* @since 9.2
*/
@Test(groups = "functional", testName = "server.hotrod.logging.HotRodAccessLoggingTest")
public class HotRodAccessLoggingTest extends HotRodSingleNodeTest {
public static final String LOG_FORMAT = "%X{address} %X{user} [%d{dd/MMM/yyyy:HH:mm:ss Z}] \"%X{method} %m %X{protocol}\" %X{status} %X{requestSize} %X{responseSize} %X{duration}";
StringLogAppender logAppender;
private String testShortName;
@Override
protected void setup() throws Exception {
testShortName = TestResourceTracker.getCurrentTestShortName();
logAppender = new StringLogAppender("org.infinispan.HOTROD_ACCESS_LOG",
Level.TRACE,
t -> t.getName().startsWith("non-blocking-thread-" + testShortName),
PatternLayout.newBuilder().withPattern(LOG_FORMAT).build());
logAppender.install();
super.setup();
}
@Override
protected void teardown() {
logAppender.uninstall();
super.teardown();
}
public void testHotRodAccessLog() {
client().put("key", "value");
server().getTransport().stop();
String logline = logAppender.getLog(0);
assertTrue(logline, logline.matches(
"^127\\.0\\.0\\.1 - \\[\\d+/\\w+/\\d+:\\d+:\\d+:\\d+ [+-]?\\d*] \"PUT /" +
getDefaultCacheName() + "/\\[B0x6B6579 HOTROD/2\\.1\" OK \\d+ \\d+ \\d+$"));
}
}
| 1,828
| 36.326531
| 183
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestStatsResponse.java
|
package org.infinispan.server.hotrod.test;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import java.util.Map;
import org.infinispan.server.hotrod.HotRodOperation;
/**
* @author wburns
* @since 9.0
*/
public class TestStatsResponse extends TestResponse {
final Map<String, String> stats;
protected TestStatsResponse(byte version, long messageId, String cacheName, short clientIntel,
int topologyId, AbstractTestTopologyAwareResponse topologyResponse, Map<String, String> stats) {
super(version, messageId, cacheName, clientIntel, HotRodOperation.STATS, Success, topologyId, topologyResponse);
this.stats = stats;
}
}
| 699
| 30.818182
| 127
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestClientListener.java
|
package org.infinispan.server.hotrod.test;
import org.infinispan.notifications.cachelistener.event.Event;
/**
* @author Galder Zamarreño
*/
public abstract class TestClientListener {
public void onCreated(TestKeyWithVersionEvent event) {
} // no-op
public void onModified(TestKeyWithVersionEvent event) {
} // no-op
public void onRemoved(TestKeyEvent event) {
} // no-op
public void onCustom(TestCustomEvent event) {
} // no-op
public int queueSize(Event.Type eventType) {
return 0;
}
public Object pollEvent(Event.Type eventType) {
return null;
}
public int customQueueSize() {
return 0;
}
public TestCustomEvent pollCustom() {
return null;
}
public abstract byte[] getId();
}
| 766
| 18.175
| 62
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestIteratorNextResponse.java
|
package org.infinispan.server.hotrod.test;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import org.infinispan.server.hotrod.HotRodOperation;
public class TestIteratorNextResponse extends TestResponse {
protected TestIteratorNextResponse(byte version, long messageId, String cacheName, short clientIntel,
int topologyId, AbstractTestTopologyAwareResponse topologyResponse) {
super(version, messageId, cacheName, clientIntel, HotRodOperation.ITERATION_NEXT, Success, topologyId, topologyResponse);
}
}
| 576
| 43.384615
| 127
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestAuthMechListResponse.java
|
package org.infinispan.server.hotrod.test;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import java.util.Set;
import org.infinispan.server.hotrod.HotRodOperation;
/**
* @author wburns
* @since 9.0
*/
public class TestAuthMechListResponse extends TestResponse {
public final Set<String> mechs;
protected TestAuthMechListResponse(byte version, long messageId, String cacheName, short clientIntel,
int topologyId, AbstractTestTopologyAwareResponse topologyResponse, Set<String> mechs) {
super(version, messageId, cacheName, clientIntel, HotRodOperation.AUTH_MECH_LIST, Success, topologyId, topologyResponse);
this.mechs = mechs;
}
}
| 720
| 31.772727
| 127
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/HotRodPipeTest.java
|
package org.infinispan.server.hotrod.test;
import static org.infinispan.server.core.test.ServerTestingUtil.killServer;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.host;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.readString;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.readUnsignedLong;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.writeUnsignedLong;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;
import org.infinispan.commons.test.TestResourceTracker;
import org.infinispan.commons.util.Either;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.hotrod.HotRodServer;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.MessageToByteEncoder;
import io.netty.handler.codec.ReplayingDecoder;
import io.netty.util.concurrent.DefaultThreadFactory;
@Test(groups = "functional", testName = "server.hotrod.test.HotRodPipeTest")
public class HotRodPipeTest extends SingleCacheManagerTest {
HotRodServer server;
@Override
protected EmbeddedCacheManager createCacheManager() throws Exception {
GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder();
TestCacheManagerFactory.amendTransport(gcb);
return TestCacheManagerFactory.createCacheManager(gcb, hotRodCacheConfiguration());
}
@Override
protected void setup() throws Exception {
super.setup();
server = HotRodTestingUtil.startHotRodServer(cacheManager);
}
@Override
protected void teardown() {
log.debug("Killing Hot Rod server");
killServer(server);
}
public void testPipeRequests() throws InterruptedException {
final int numPipeReqs = 10_000;
BatchingClient client = new BatchingClient(server.getPort());
try {
client.start();
client.writeN(numPipeReqs);
eventuallyEquals(numPipeReqs, () -> {
Either<List<String>, Integer> either = client.readN();
switch (either.type()) {
case LEFT:
throw new AssertionError(either.left().get(0));
case RIGHT:
return either.right();
default:
throw new IllegalStateException("Either can only be left or right");
}
});
} finally {
client.stop();
}
}
static final class BatchingClient {
final EventLoopGroup group;
final int port;
Channel ch;
BatchingClient(int port) {
this.port = port;
DefaultThreadFactory threadFactory = new DefaultThreadFactory(TestResourceTracker.getCurrentTestShortName());
group = new NioEventLoopGroup(0, threadFactory);
}
void start() {
Bootstrap b = new Bootstrap();
b.group(group)
.channel(NioSocketChannel.class)
.option(ChannelOption.TCP_NODELAY, true)
.handler(new ChannelInitializer<Channel>() {
@Override
protected void initChannel(Channel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
p.addLast(new BatchingDecoder());
p.addLast(new BatchingEncoder());
p.addLast(new BatchingClientHandler());
}
});
try {
ChannelFuture f = b.connect(host(), port).sync();
ch = f.channel();
} catch (InterruptedException e) {
throw new AssertionError(e);
}
}
void stop() throws InterruptedException {
group.shutdownGracefully().await(10, TimeUnit.SECONDS);
}
void writeN(int n) {
ch.writeAndFlush(n);
}
Either<List<String>, Integer> readN() {
BatchingClientHandler last = (BatchingClientHandler) ch.pipeline().last();
return last.errors.isEmpty()
? Either.newRight(last.n)
: Either.newLeft(last.errors);
}
private static final class BatchingEncoder extends MessageToByteEncoder {
@Override
protected void encode(ChannelHandlerContext ctx, Object msg, ByteBuf out) throws Exception {
int n = (int) msg;
IntStream.range(0, n).forEach(i -> {
out.writeByte(0xA0); // magic
writeUnsignedLong(i, out); // message id
out.writeByte(0x19); // version
out.writeByte(0x01); // op code
out.writeByte(0x00); // cache name empty
out.writeByte(0x00); // flags
out.writeByte(0x03); // client intelligence
out.writeByte(0x00); // topology id
out.writeBytes(new byte[] { // operation parameters
0x03, 0x31, 0x30, 0x30, 0x77, 0x03, 0x31, 0x30, 0x30
});
});
}
}
private static final class BatchingDecoder extends ReplayingDecoder {
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
in.readUnsignedByte(); // magic byte
long id = readUnsignedLong(in); // message id
short op = in.readUnsignedByte(); // op code
in.readUnsignedByte(); // status code
in.readUnsignedByte(); // topology marker
switch (op) {
case 0x02: // normal response
out.add(id);
break;
case 0x50: // error response
String error = readString(in);
out.add(error);
break;
}
}
}
private static final class BatchingClientHandler extends SimpleChannelInboundHandler<Object> {
int n;
List<String> errors = new ArrayList<>();
@Override
protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
if (msg instanceof String) {
errors.add((String) msg);
} else {
n++;
}
}
}
}
}
| 7,086
| 34.974619
| 118
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestHashDistAware20Response.java
|
package org.infinispan.server.hotrod.test;
import java.util.Collection;
import java.util.List;
import org.infinispan.server.hotrod.ServerAddress;
public class TestHashDistAware20Response extends AbstractTestTopologyAwareResponse {
final List<Iterable<ServerAddress>> segments;
final byte hashFunction;
protected TestHashDistAware20Response(int topologyId, Collection<ServerAddress> members,
List<Iterable<ServerAddress>> segments, byte hashFunction) {
super(topologyId, members);
this.segments = segments;
this.hashFunction = hashFunction;
}
@Override
public String toString() {
return "TestHashDistAware20Response{" +
"hashFunction=" + hashFunction +
", topologyId=" + topologyId +
", members=" + members +
'}';
}
}
| 860
| 29.75
| 101
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestErrorResponse.java
|
package org.infinispan.server.hotrod.test;
import org.infinispan.server.hotrod.HotRodOperation;
import org.infinispan.server.hotrod.OperationStatus;
/**
* @author wburns
* @since 9.0
*/
public class TestErrorResponse extends TestResponse {
public final String msg;
protected TestErrorResponse(byte version, long messageId, String cacheName, short clientIntel,
OperationStatus status, int topologyId, AbstractTestTopologyAwareResponse topologyResponse, String msg) {
super(version, messageId, cacheName, clientIntel, HotRodOperation.ERROR, status, topologyId, topologyResponse);
this.msg = msg;
}
}
| 656
| 33.578947
| 136
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestSizeResponse.java
|
package org.infinispan.server.hotrod.test;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import org.infinispan.server.hotrod.HotRodOperation;
/**
* @author wburns
* @since 9.0
*/
public class TestSizeResponse extends TestResponse {
public final long size;
protected TestSizeResponse(byte version, long messageId, String cacheName, short clientIntel,
int topologyId, AbstractTestTopologyAwareResponse topologyResponse, long size) {
super(version, messageId, cacheName, clientIntel, HotRodOperation.SIZE, Success, topologyId, topologyResponse);
this.size = size;
}
}
| 645
| 31.3
| 117
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestQueryResponse.java
|
package org.infinispan.server.hotrod.test;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import org.infinispan.server.hotrod.HotRodOperation;
/**
* @author wburns
* @since 9.0
*/
public class TestQueryResponse extends TestResponse {
public final byte[] result;
protected TestQueryResponse(byte version, long messageId, String cacheName, short clientIntel,
int topologyId, AbstractTestTopologyAwareResponse topologyResponse, byte[] result) {
super(version, messageId, cacheName, clientIntel, HotRodOperation.QUERY, Success, topologyId, topologyResponse);
this.result = result;
}
}
| 661
| 32.1
| 118
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestHashDistAware10Response.java
|
package org.infinispan.server.hotrod.test;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import org.infinispan.server.hotrod.ServerAddress;
public class TestHashDistAware10Response extends AbstractTestTopologyAwareResponse {
final Map<ServerAddress, List<Integer>> hashIds;
final int numOwners;
final byte hashFunction;
final int hashSpace;
protected TestHashDistAware10Response(int topologyId, Collection<ServerAddress> members, Map<ServerAddress,
List<Integer>> hashIds, int numOwners, byte hashFunction, int hashSpace) {
super(topologyId, members);
this.hashIds = hashIds;
this.numOwners = numOwners;
this.hashFunction = hashFunction;
this.hashSpace = hashSpace;
}
@Override
public String toString() {
return "TestHashDistAware10Response{" +
"numOwners=" + numOwners +
", hashFunction=" + hashFunction +
", hashSpace=" + hashSpace +
", topologyId=" + topologyId +
", members=" + members +
'}';
}
}
| 1,085
| 29.166667
| 110
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestGetWithVersionResponse.java
|
package org.infinispan.server.hotrod.test;
import java.util.Optional;
import org.infinispan.server.hotrod.HotRodOperation;
import org.infinispan.server.hotrod.OperationStatus;
/**
* @author wburns
* @since 9.0
*/
public class TestGetWithVersionResponse extends TestGetResponse {
public final long dataVersion;
protected TestGetWithVersionResponse(byte version, long messageId, String cacheName, short clientIntel,
HotRodOperation operation, OperationStatus status, int topologyId,
AbstractTestTopologyAwareResponse topologyResponse, Optional<byte[]> data, long dataVersion) {
super(version, messageId, cacheName, clientIntel, operation, status, topologyId, topologyResponse, data);
this.dataVersion = dataVersion;
}
}
| 826
| 36.590909
| 134
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestAuthResponse.java
|
package org.infinispan.server.hotrod.test;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import org.infinispan.server.hotrod.HotRodOperation;
/**
* @author wburns
* @since 9.0
*/
public class TestAuthResponse extends TestResponse {
public final boolean complete;
public final byte[] challenge;
protected TestAuthResponse(byte version, long messageId, String cacheName, short clientIntel,
int topologyId, AbstractTestTopologyAwareResponse topologyResponse, boolean complete, byte[] challenge) {
super(version, messageId, cacheName, clientIntel, HotRodOperation.AUTH, Success, topologyId, topologyResponse);
this.complete = complete;
this.challenge = challenge;
}
}
| 753
| 33.272727
| 135
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/HotRodServerUnregisterTopologyCacheTest.java
|
package org.infinispan.server.hotrod.test;
import static org.infinispan.server.core.test.ServerTestingUtil.findFreePort;
import static org.infinispan.server.core.test.ServerTestingUtil.killServer;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.getDefaultHotRodConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertTrue;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.registry.InternalCacheRegistry;
import org.infinispan.server.hotrod.HotRodServer;
import org.infinispan.test.MultipleCacheManagersTest;
import org.testng.annotations.Test;
@Test(testName = "server.hotrod.test.HotRodServerUnregisterTopologyCacheTest", groups = "functional")
public class HotRodServerUnregisterTopologyCacheTest extends MultipleCacheManagersTest {
private static final int CLUSTER_SIZE = 2;
private List<HotRodServer> hotRodServers;
@Override
protected void createCacheManagers() throws Throwable {
createCluster(getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, false), CLUSTER_SIZE);
startServers();
waitForClusterToForm();
}
private void startServers() {
hotRodServers = new ArrayList<>(CLUSTER_SIZE);
for (int i = 0; i < CLUSTER_SIZE; i++) {
hotRodServers.add(startHotRodServer(manager(i), findFreePort(), getDefaultHotRodConfiguration()));
}
}
public void testServerUnregisterTopologyCacheOnStop() {
for (HotRodServer server : hotRodServers) {
String topologyCacheName = server.getConfiguration().topologyCacheName();
assertTrue(getInternalCacheNames(server).contains(topologyCacheName));
killServer(server);
assertFalse(getInternalCacheNames(server).contains(topologyCacheName));
}
}
private Set<String> getInternalCacheNames(HotRodServer server) {
return server.getCacheManager()
.getGlobalComponentRegistry()
.getComponent(InternalCacheRegistry.class)
.getInternalCacheNames();
}
}
| 2,214
| 35.916667
| 107
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestCallbackHandler.java
|
package org.infinispan.server.hotrod.test;
import java.io.IOException;
import javax.security.auth.callback.Callback;
import javax.security.auth.callback.CallbackHandler;
import javax.security.auth.callback.NameCallback;
import javax.security.auth.callback.PasswordCallback;
import javax.security.auth.callback.UnsupportedCallbackException;
import javax.security.sasl.AuthorizeCallback;
import javax.security.sasl.RealmCallback;
/**
* TestCallbackHandler.
*
* @author Tristan Tarrant
* @since 7.0
*/
public class TestCallbackHandler implements CallbackHandler {
final private String username;
final private char[] password;
final private String realm;
public TestCallbackHandler(String username, String realm, String password) {
this(username, realm, password.toCharArray());
}
public TestCallbackHandler(String username, String realm, char[] password) {
this.username = username;
this.password = password;
this.realm = realm;
}
@Override
public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException {
for (Callback callback : callbacks) {
if (callback instanceof NameCallback) {
NameCallback nameCallback = (NameCallback) callback;
nameCallback.setName(username);
} else if (callback instanceof PasswordCallback) {
PasswordCallback passwordCallback = (PasswordCallback) callback;
passwordCallback.setPassword(password);
} else if (callback instanceof AuthorizeCallback) {
AuthorizeCallback authorizeCallback = (AuthorizeCallback) callback;
authorizeCallback.setAuthorized(authorizeCallback.getAuthenticationID().equals(
authorizeCallback.getAuthorizationID()));
} else if (callback instanceof RealmCallback) {
RealmCallback realmCallback = (RealmCallback) callback;
realmCallback.setText(realm);
} else {
throw new UnsupportedCallbackException(callback);
}
}
}
}
| 2,050
| 34.982456
| 94
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestResponseWithPrevious.java
|
package org.infinispan.server.hotrod.test;
import java.util.Optional;
import org.infinispan.server.hotrod.HotRodOperation;
import org.infinispan.server.hotrod.OperationStatus;
/**
* @author wburns
* @since 9.0
*/
public class TestResponseWithPrevious extends TestResponse {
public final Optional<byte[]> previous;
protected TestResponseWithPrevious(byte version, long messageId, String cacheName, short clientIntel,
HotRodOperation operation, OperationStatus status, int topologyId,
AbstractTestTopologyAwareResponse topologyResponse, Optional<byte[]> previous) {
super(version, messageId, cacheName, clientIntel, operation, status, topologyId, topologyResponse);
this.previous = previous;
}
}
| 798
| 35.318182
| 118
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/HotRodClient.java
|
package org.infinispan.server.hotrod.test;
import static org.infinispan.counter.util.EncodeUtil.decodeConfiguration;
import static org.infinispan.server.hotrod.HotRodConstants.CONTAINS_KEY_REQUEST;
import static org.infinispan.server.hotrod.HotRodConstants.GET_REQUEST;
import static org.infinispan.server.hotrod.HotRodConstants.GET_WITH_METADATA;
import static org.infinispan.server.hotrod.HotRodConstants.GET_WITH_VERSION;
import static org.infinispan.server.hotrod.OperationStatus.NotExecutedWithPrevious;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import static org.infinispan.server.hotrod.OperationStatus.SuccessWithPrevious;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.readString;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.readUnsignedInt;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.readUnsignedShort;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.writeRangedBytes;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.writeString;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.writeUnsignedInt;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.writeUnsignedLong;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.writeXid;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertTrue;
import java.io.Closeable;
import java.lang.reflect.Method;
import java.net.InetSocketAddress;
import java.nio.channels.ClosedChannelException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import javax.net.ssl.SSLEngine;
import javax.security.sasl.SaslClient;
import javax.security.sasl.SaslException;
import org.infinispan.commons.io.SignedNumeric;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.commons.marshall.WrappedByteArray;
import org.infinispan.commons.test.TestResourceTracker;
import org.infinispan.commons.tx.XidImpl;
import org.infinispan.commons.util.Util;
import org.infinispan.server.core.transport.NettyInitializer;
import org.infinispan.server.core.transport.NettyInitializers;
import org.infinispan.server.hotrod.Constants;
import org.infinispan.server.hotrod.HotRodConstants;
import org.infinispan.server.hotrod.HotRodOperation;
import org.infinispan.server.hotrod.OperationStatus;
import org.infinispan.server.hotrod.ProtocolFlag;
import org.infinispan.server.hotrod.ServerAddress;
import org.infinispan.server.hotrod.counter.impl.TestCounterEventResponse;
import org.infinispan.server.hotrod.counter.impl.TestCounterNotificationManager;
import org.infinispan.server.hotrod.counter.op.CounterOp;
import org.infinispan.server.hotrod.counter.response.CounterConfigurationTestResponse;
import org.infinispan.server.hotrod.counter.response.CounterNamesTestResponse;
import org.infinispan.server.hotrod.counter.response.CounterValueTestResponse;
import org.infinispan.server.hotrod.counter.response.RecoveryTestResponse;
import org.infinispan.server.hotrod.logging.Log;
import org.infinispan.server.hotrod.transport.ExtendedByteBuf;
import org.infinispan.util.KeyValuePair;
import org.infinispan.util.concurrent.TimeoutException;
import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.MessageToByteEncoder;
import io.netty.handler.codec.ReplayingDecoder;
import io.netty.handler.ssl.SslHandler;
import io.netty.util.concurrent.DefaultThreadFactory;
import io.netty.util.concurrent.Future;
/**
* A very simple Hot Rod client for testing purposes. It's a quick and dirty client implementation. As a result, it
* might not be very readable, particularly for readers not used to scala.
* <p>
* Reasons why this should not really be a trait: Storing var instances in a trait cause issues with TestNG, see:
* http://thread.gmane.org/gmane.comp.lang.scala.user/24317
*
* @author Galder Zamarreño
* @author Tristan Tarrant
* @since 4.1
*/
public class HotRodClient implements Closeable {
public static final int DEFAULT_TIMEOUT_SECONDS = 60;
private static final Log log = LogFactory.getLog(HotRodClient.class, Log.class);
final static AtomicLong idCounter = new AtomicLong();
final String host;
final int port;
final String defaultCacheName;
final int rspTimeoutSeconds;
final byte protocolVersion;
final SSLEngine sslEngine;
final Channel ch;
final Map<Long, Op> idToOp = new ConcurrentHashMap<>();
private final EventLoopGroup eventLoopGroup =
new NioEventLoopGroup(1, new DefaultThreadFactory(TestResourceTracker.getCurrentTestShortName() + "-Client"));
public HotRodClient(String host, int port, String defaultCacheName, byte protocolVersion) {
this(host, port, defaultCacheName, DEFAULT_TIMEOUT_SECONDS, protocolVersion, null);
}
public HotRodClient(String host, int port, String defaultCacheName, int rspTimeoutSeconds, byte protocolVersion,
SSLEngine sslEngine) {
this.host = host;
this.port = port;
this.defaultCacheName = defaultCacheName;
this.rspTimeoutSeconds = rspTimeoutSeconds;
this.protocolVersion = protocolVersion;
this.sslEngine = sslEngine;
ch = initializeChannel();
}
public HotRodClient(HotRodClient other, byte protocolVersion) {
this(other.host, other.port, other.defaultCacheName, other.rspTimeoutSeconds, protocolVersion, other.sslEngine);
}
public byte protocolVersion() {
return protocolVersion;
}
public String defaultCacheName() {
return defaultCacheName;
}
private Channel initializeChannel() {
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(eventLoopGroup);
bootstrap.handler(new NettyInitializers(new ClientChannelInitializer(this, rspTimeoutSeconds, sslEngine, protocolVersion)));
bootstrap.channel(NioSocketChannel.class);
bootstrap.option(ChannelOption.TCP_NODELAY, true);
bootstrap.option(ChannelOption.SO_KEEPALIVE, true);
// Make a new connection.
ChannelFuture connectFuture = bootstrap.connect(new InetSocketAddress(host, port));
// Wait until the connection is made successfully.
Channel ch = connectFuture.syncUninterruptibly().channel();
assertTrue(connectFuture.isSuccess());
return ch;
}
@Override
public void close() {
Future<?> stopFuture = stop();
if (!stopFuture.awaitUninterruptibly(30, TimeUnit.SECONDS))
throw new TimeoutException();
stopFuture.syncUninterruptibly();
}
public Future<?> stop() {
return eventLoopGroup.shutdownGracefully(100, 1000, TimeUnit.MILLISECONDS);
}
public TestResponse put(byte[] k, int lifespan, int maxIdle, byte[] v) {
return execute(0xA0, (byte) 0x01, defaultCacheName, k, lifespan, maxIdle, v, 0, (byte) 1, 0);
}
public TestResponse put(byte[] k, int lifespan, int maxIdle, byte[] v, byte clientIntelligence, int topologyId) {
return execute(0xA0, (byte) 0x01, defaultCacheName, k, lifespan, maxIdle, v, 0, clientIntelligence, topologyId);
}
private void assertStatus(TestResponse resp, OperationStatus expected) {
OperationStatus status = resp.getStatus();
boolean isSuccess = status == expected;
if (resp instanceof TestErrorResponse) {
assertTrue(String.format("Status should have been '%s' but instead was: '%s', and the error message was: %s",
expected, status, ((TestErrorResponse) resp).msg), isSuccess);
} else {
assertTrue(String.format(
"Status should have been '%s' but instead was: '%s'", expected, status), isSuccess);
}
}
private byte[] k(Method m) {
return k(m, "k-");
}
private byte[] k(Method m, String prefix) {
return (prefix + m.getName()).getBytes();
}
private byte[] v(Method m) {
return v(m, "v-");
}
private byte[] v(Method m, String prefix) {
return k(m, prefix);
}
public void assertPut(Method m) {
assertStatus(put(k(m), 0, 0, v(m)), Success);
}
public void assertPutFail(Method m) {
Op op = new Op(0xA0, protocolVersion, (byte) 0x01, defaultCacheName, k(m), 0, 0, v(m), 0, 1, (byte) 0, 0);
idToOp.put(op.id, op);
ChannelFuture future = ch.writeAndFlush(op);
if (!future.awaitUninterruptibly(30, TimeUnit.SECONDS))
throw new TimeoutException();
assertFalse(future.isSuccess());
}
public void assertPut(Method m, String kPrefix, String vPrefix) {
assertStatus(put(k(m, kPrefix), 0, 0, v(m, vPrefix)), Success);
}
public void assertPut(Method m, int lifespan, int maxIdle) {
assertStatus(put(k(m), lifespan, maxIdle, v(m)), Success);
}
public TestResponse put(String k, String v) {
return put(k.getBytes(), 0, 0, v.getBytes());
}
public TestResponse put(byte[] k, int lifespan, int maxIdle, byte[] v, int flags) {
return execute(0xA0, (byte) 0x01, defaultCacheName, k, lifespan, maxIdle, v, 0, flags);
}
public TestResponse putIfAbsent(byte[] k, int lifespan, int maxIdle, byte[] v) {
return execute(0xA0, (byte) 0x05, defaultCacheName, k, lifespan, maxIdle, v, 0, (byte) 1, 0);
}
public TestResponse putIfAbsent(byte[] k, int lifespan, int maxIdle, byte[] v, int flags) {
return execute(0xA0, (byte) 0x05, defaultCacheName, k, lifespan, maxIdle, v, 0, flags);
}
public TestResponse replace(byte[] k, int lifespan, int maxIdle, byte[] v) {
return execute(0xA0, (byte) 0x07, defaultCacheName, k, lifespan, maxIdle, v, 0, (byte) 1, 0);
}
public TestResponse replace(byte[] k, int lifespan, int maxIdle, byte[] v, int flags) {
return execute(0xA0, (byte) 0x07, defaultCacheName, k, lifespan, maxIdle, v, (byte) 0, flags);
}
public TestResponse replaceIfUnmodified(byte[] k, int lifespan, int maxIdle, byte[] v, long dataVersion) {
return execute(0xA0, (byte) 0x09, defaultCacheName, k, lifespan, maxIdle, v, dataVersion, (byte) 1, 0);
}
public TestResponse replaceIfUnmodified(byte[] k, int lifespan, int maxIdle, byte[] v, long dataVersion, int flags) {
return execute(0xA0, (byte) 0x09, defaultCacheName, k, lifespan, maxIdle, v, dataVersion, flags);
}
public TestResponse remove(byte[] k) {
return execute(0xA0, (byte) 0x0B, defaultCacheName, k, 0, 0, null, 0, (byte) 1, 0);
}
public TestResponse remove(byte[] k, int flags) {
return execute(0xA0, (byte) 0x0B, defaultCacheName, k, 0, 0, null, 0, flags);
}
public TestResponse removeIfUnmodified(byte[] k, int lifespan, int maxIdle, byte[] v, long dataVersion) {
return execute(0xA0, (byte) 0x0D, defaultCacheName, k, lifespan, maxIdle, v, dataVersion, (byte) 1, 0);
}
public TestResponse removeIfUnmodified(byte[] k, long dataVersion, int flags) {
return execute(0xA0, (byte) 0x0D, defaultCacheName, k, 0, 0, Util.EMPTY_BYTE_ARRAY, dataVersion, flags);
}
public TestResponse execute(int magic, byte code, String name, byte[] k, int lifespan, int maxIdle,
byte[] v, long dataVersion, byte clientIntelligence, int topologyId) {
Op op = new Op(magic, protocolVersion, code, name, k, lifespan, maxIdle, v, 0, dataVersion,
clientIntelligence, topologyId);
return execute(op);
}
public TestErrorResponse executeExpectBadMagic(int magic, byte code, String name, byte[] k, int lifespan, int maxIdle,
byte[] v, long version) {
Op op = new Op(magic, protocolVersion, code, name, k, lifespan, maxIdle, v, 0, version, (byte) 1, 0);
return (TestErrorResponse) execute(op, 0);
}
public TestErrorResponse executePartial(int magic, byte code, String name, byte[] k, int lifespan, int maxIdle,
byte[] v, long version) {
Op op = new PartialOp(magic, protocolVersion, code, name, k, lifespan, maxIdle, v, 0, version, (byte) 1, 0);
return execute(op);
}
public TestResponse execute(int magic, byte code, String name, byte[] k, int lifespan, int maxIdle,
byte[] v, long dataVersion, int flags) {
Op op = new Op(magic, protocolVersion, code, name, k, lifespan, maxIdle, v, flags, dataVersion, (byte) 1, 0);
return execute(op);
}
private TestResponse execute(Op op, long expectedResponseMessageId) {
ClientHandler handler = (ClientHandler) ch.pipeline().last();
CompletionStage<TestResponse> responseStage = handler.waitForResponse(expectedResponseMessageId);
writeOp(op);
try {
return responseStage.toCompletableFuture().get(rspTimeoutSeconds, TimeUnit.SECONDS);
} catch (ExecutionException e) {
throw new CompletionException(e.getCause());
} catch (InterruptedException e) {
throw new CompletionException(e);
} catch (java.util.concurrent.TimeoutException e) {
throw new TimeoutException("No response from server in " + rspTimeoutSeconds + "s", e);
}
}
public boolean writeOp(Op op) {
return writeOp(op, true);
}
public boolean writeOp(Op op, boolean assertSuccess) {
log.tracef("Sending request %s", op);
idToOp.put(op.id, op);
ChannelFuture future = ch.writeAndFlush(op);
if (!future.awaitUninterruptibly(30, TimeUnit.SECONDS))
throw new TimeoutException();
if (assertSuccess) {
// Report the exception if failed
future.syncUninterruptibly();
}
return future.isSuccess();
}
public TestGetResponse get(byte[] k, int flags) {
return (TestGetResponse) get((byte) 0x03, k, flags);
}
public TestResponse get(String k) {
return get((byte) 0x03, k.getBytes(), 0);
}
public TestGetResponse assertGet(Method m) {
return assertGet(m, 0);
}
public TestGetResponse assertGet(Method m, int flags) {
return get(k(m), flags);
}
public TestResponse containsKey(byte[] k, int flags) {
return get((byte) 0x0F, k, flags);
}
public TestGetWithVersionResponse getWithVersion(byte[] k, int flags) {
return (TestGetWithVersionResponse) get((byte) 0x11, k, flags);
}
public TestGetWithMetadataResponse getWithMetadata(byte[] k, int flags) {
return (TestGetWithMetadataResponse) get((byte) 0x1B, k, flags);
}
private TestResponse get(byte code, byte[] k, int flags) {
assertTrue(code == GET_REQUEST || code == GET_WITH_VERSION || code == CONTAINS_KEY_REQUEST || code == GET_WITH_METADATA);
Op op = new Op(0xA0, protocolVersion, code, defaultCacheName, k, 0, 0, null, flags, 0, (byte) 1, 0);
return execute(op);
}
public TestResponse clear() {
return execute(0xA0, (byte) 0x13, defaultCacheName, null, 0, 0, null, 0, (byte) 1, 0);
}
public Map<String, String> stats() {
StatsOp op = new StatsOp(0xA0, protocolVersion, (byte) 0x15, defaultCacheName, (byte) 1, 0, null);
TestStatsResponse resp = execute(op);
return resp.stats;
}
public TestResponse ping() {
return execute(0xA0, (byte) 0x17, defaultCacheName, null, 0, 0, null, 0, (byte) 1, 0);
}
public TestResponse ping(byte clientIntelligence, int topologyId) {
return execute(0xA0, (byte) 0x17, defaultCacheName, null, 0, 0, null, 0, clientIntelligence, topologyId);
}
public TestBulkGetResponse bulkGet() {
return bulkGet(0);
}
public TestBulkGetResponse bulkGet(int count) {
BulkGetOp op = new BulkGetOp(0xA0, protocolVersion, (byte) 0x19, defaultCacheName, (byte) 1, 0, count);
return execute(op);
}
public TestBulkGetKeysResponse bulkGetKeys() {
return bulkGetKeys(0);
}
public TestBulkGetKeysResponse bulkGetKeys(int scope) {
BulkGetKeysOp op = new BulkGetKeysOp(0xA0, protocolVersion, (byte) 0x1D, defaultCacheName, (byte) 1, 0, scope);
return execute(op);
}
public TestQueryResponse query(byte[] query) {
QueryOp op = new QueryOp(0xA0, protocolVersion, defaultCacheName, (byte) 1, 0, query);
return execute(op);
}
public TestAuthMechListResponse authMechList() {
AuthMechListOp op = new AuthMechListOp(0xA0, protocolVersion, (byte) 0x21, defaultCacheName, (byte) 1, 0);
return execute(op);
}
public TestAuthResponse auth(SaslClient sc) throws SaslException {
byte[] saslResponse = sc.hasInitialResponse() ? sc.evaluateChallenge(Util.EMPTY_BYTE_ARRAY) : Util.EMPTY_BYTE_ARRAY;
AuthOp op = new AuthOp(0xA0, protocolVersion, (byte) 0x23, defaultCacheName, (byte) 1, 0, sc.getMechanismName(), saslResponse);
TestAuthResponse response = execute(op);
while (!sc.isComplete() || !response.complete) {
saslResponse = sc.evaluateChallenge(response.challenge);
op = new AuthOp(0xA0, protocolVersion, (byte) 0x23, defaultCacheName, (byte) 1, 0, "", saslResponse);
response = execute(op);
}
sc.dispose();
return response;
}
public TestResponse addClientListener(TestClientListener listener, boolean includeState,
Optional<KeyValuePair<String, List<byte[]>>> filterFactory,
Optional<KeyValuePair<String, List<byte[]>>> converterFactory, boolean useRawData) {
AddClientListenerOp op = new AddClientListenerOp(0xA0, protocolVersion, defaultCacheName,
(byte) 1, 0, listener.getId(), includeState, filterFactory, converterFactory, useRawData);
ClientHandler handler = (ClientHandler) ch.pipeline().last();
handler.addClientListener(listener);
return execute(op);
}
public TestResponse removeClientListener(byte[] listenerId) {
RemoveClientListenerOp op = new RemoveClientListenerOp(0xA0, protocolVersion, defaultCacheName, (byte) 1, 0, listenerId);
TestResponse response = execute(op);
if (response.getStatus() == Success) {
ClientHandler handler = (ClientHandler) ch.pipeline().last();
handler.removeClientListener(listenerId);
}
return response;
}
public TestSizeResponse size() {
SizeOp op = new SizeOp(0xA0, protocolVersion, defaultCacheName, (byte) 1, 0);
return execute(op);
}
public TestGetWithMetadataResponse getStream(byte[] key, int offset) {
GetStreamOp op = new GetStreamOp(0xA0, protocolVersion, defaultCacheName, key, 0, (byte) 1, 0, offset);
return execute(op);
}
public TestResponse putStream(byte[] key, byte[] value, long version, int lifespan, int maxIdle) {
PutStreamOp op = new PutStreamOp(0xA0, protocolVersion, defaultCacheName, key, value, lifespan, maxIdle, version, (byte) 1, 0);
return execute(op);
}
public TestResponse prepareTx(XidImpl xid, boolean onePhaseCommit, Collection<TxWrite> modifications) {
PrepareOp op = new PrepareOp(protocolVersion, defaultCacheName, 0, xid,
onePhaseCommit, modifications);
return execute(op);
}
public TestResponse commitTx(XidImpl xid) {
CommitOrRollbackOp op = new CommitOrRollbackOp(protocolVersion, defaultCacheName, xid, true);
return execute(op);
}
public TestResponse rollbackTx(XidImpl xid) {
CommitOrRollbackOp op = new CommitOrRollbackOp(protocolVersion, defaultCacheName, xid, false);
return execute(op);
}
public TestResponse forgetTx(XidImpl xid) {
TxOp op = new ForgetTxOp(protocolVersion, xid);
return execute(op);
}
public TestResponse recovery() {
Op op = new RecoveryOp(protocolVersion);
return execute(op);
}
public TestIteratorStartResponse iteratorStart(byte[] segmentMask, String filterConverterFactory,
List<byte[]> filterConverterParams, int batch, boolean includeMetadata) {
IterationStartOp op = new IterationStartOp(0xA0, protocolVersion, defaultCacheName, (byte) 1, 0, segmentMask, filterConverterFactory, filterConverterParams, batch, includeMetadata);
return execute(op);
}
public TestIteratorNextResponse iteratorNext(String iterationId) {
IterationNextOp op = new IterationNextOp(0xA0, protocolVersion, defaultCacheName, (byte) 1, 0, iterationId);
return execute(op);
}
public TestResponse iteratorEnd(String iterationId) {
IterationEndOp op = new IterationEndOp(0xA0, protocolVersion, defaultCacheName, (byte) 1, 0, iterationId);
return execute(op);
}
public <T> T execute(Op op) {
return (T) execute(op, op.id);
}
public void registerCounterNotificationManager(TestCounterNotificationManager manager) {
ClientHandler handler = (ClientHandler) ch.pipeline().last();
handler.registerCounterNotificationManager(manager);
}
}
class ClientChannelInitializer implements NettyInitializer {
private final HotRodClient client;
private final int rspTimeoutSeconds;
private final SSLEngine sslEngine;
private final byte protocolVersion;
ClientChannelInitializer(HotRodClient client, int rspTimeoutSeconds, SSLEngine sslEngine, byte protocolVersion) {
this.client = client;
this.rspTimeoutSeconds = rspTimeoutSeconds;
this.sslEngine = sslEngine;
this.protocolVersion = protocolVersion;
}
@Override
public void initializeChannel(Channel ch) {
ChannelPipeline pipeline = ch.pipeline();
if (sslEngine != null)
pipeline.addLast("ssl", new SslHandler(sslEngine));
pipeline.addLast("decoder", new Decoder(client));
pipeline.addLast("encoder", new Encoder(protocolVersion));
pipeline.addLast("handler", new ClientHandler(rspTimeoutSeconds));
}
}
class Encoder extends MessageToByteEncoder<Object> {
private final byte protocolVersion;
private static final Log log = LogFactory.getLog(Encoder.class, Log.class);
Encoder(byte protocolVersion) {
this.protocolVersion = protocolVersion;
}
@Override
protected void encode(ChannelHandlerContext ctx, Object msg, ByteBuf buffer) {
if (msg instanceof PartialOp) {
PartialOp partial = (PartialOp) msg;
buffer.writeByte((byte) partial.magic); // magic
writeUnsignedLong(partial.id, buffer); // message id
buffer.writeByte(partial.version); // version
buffer.writeByte(partial.code); // opcode
} else if (msg instanceof AddClientListenerOp) {
AddClientListenerOp op = (AddClientListenerOp) msg;
writeHeader(op, buffer);
writeRangedBytes(op.listenerId, buffer);
buffer.writeByte(op.includeState ? 1 : 0);
writeNamedFactory(op.filterFactory, buffer);
writeNamedFactory(op.converterFactory, buffer);
if (protocolVersion >= 21)
buffer.writeByte(op.useRawData ? 1 : 0);
} else if (msg instanceof AddBloomNearCacheListener) {
AddBloomNearCacheListener op = (AddBloomNearCacheListener) msg;
writeHeader(op, buffer);
writeRangedBytes(op.listenerId, buffer);
writeUnsignedInt(op.bloomBits, buffer);
} else if (msg instanceof RemoveClientListenerOp) {
RemoveClientListenerOp op = (RemoveClientListenerOp) msg;
writeHeader(op, buffer);
writeRangedBytes(op.listenerId, buffer);
} else if (msg instanceof PrepareOp) {
encodePrepareOp((PrepareOp) msg, buffer);
} else if (msg instanceof TxOp) {
encodeTxOp((TxOp) msg, buffer);
} else if (msg instanceof CounterOp) {
writeHeader((Op) msg, buffer);
((CounterOp) msg).writeTo(buffer);
} else if (msg instanceof Op) {
Op op = (Op) msg;
writeHeader(op, buffer);
if (op.code == HotRodOperation.COUNTER_GET_NAMES.getRequestOpCode() ||
op.code == HotRodConstants.FETCH_TX_RECOVERY) {
//nothing more to add
return;
}
if (protocolVersion < 20)
writeRangedBytes(Util.EMPTY_BYTE_ARRAY, buffer); // transaction id
if (op.code != 0x13 && op.code != 0x15
&& op.code != 0x17 && op.code != 0x19
&& op.code != 0x1D && op.code != 0x1F
&& op.code != 0x21 && op.code != 0x23
&& op.code != 0x29 && op.code != 0x31
&& op.code != 0x33 && op.code != 0x35) { // if it's a key based op...
writeRangedBytes(op.key, buffer); // key length + key
if (op.code == 0x37) {
// GetStream has an offset
writeUnsignedInt(((GetStreamOp) op).offset, buffer);
}
if (op.value != null) {
if (op.code != 0x0D) { // If it's not removeIfUnmodified...
if (protocolVersion >= 22) {
if (op.lifespan > 0 || op.maxIdle > 0) {
buffer.writeByte(0); // seconds for both
writeUnsignedInt(op.lifespan, buffer); // lifespan
writeUnsignedInt(op.maxIdle, buffer); // maxIdle
} else {
buffer.writeByte(0x88);
}
} else {
writeUnsignedInt(op.lifespan, buffer); // lifespan
writeUnsignedInt(op.maxIdle, buffer); // maxIdle
}
}
if (op.code == 0x09 || op.code == 0x0D || op.code == 0x39) {
buffer.writeLong(op.dataVersion);
}
if (op.code == 0x39) {
// Chunk the value
for (int offset = 0; offset < op.value.length; ) {
int chunk = Math.min(op.value.length - offset, 8192);
writeUnsignedInt(chunk, buffer);
buffer.writeBytes(op.value, offset, chunk);
offset += chunk;
}
writeUnsignedInt(0, buffer);
} else if (op.code != 0x0D) { // If it's not removeIfUnmodified...
writeRangedBytes(op.value, buffer); // value length + value
}
}
} else if (op.code == 0x19) {
writeUnsignedInt(((BulkGetOp) op).count, buffer); // Entry count
} else if (op.code == 0x1D) {
writeUnsignedInt(((BulkGetKeysOp) op).scope, buffer); // Bulk Get Keys Scope
} else if (op.code == 0x1F) {
writeRangedBytes(((QueryOp) op).query, buffer);
} else if (op.code == 0x23) {
AuthOp authop = (AuthOp) op;
if (!authop.mech.isEmpty()) {
writeRangedBytes(authop.mech.getBytes(), buffer);
} else {
writeUnsignedInt(0, buffer);
}
writeRangedBytes(((AuthOp) op).response, buffer);
} else if (op.code == 0x31) {
IterationStartOp startop = (IterationStartOp) op;
if (startop.segmentMask == null) {
writeUnsignedInt(SignedNumeric.encode(-1), buffer);
} else {
buffer.writeBytes(startop.segmentMask);
}
if (startop.filterConverterFactory != null) {
writeRangedBytes(startop.filterConverterFactory.getBytes(), buffer);
if (startop.filterConverterParams != null && startop.filterConverterParams.size() > 0) {
buffer.writeByte(startop.filterConverterParams.size());
startop.filterConverterParams.forEach(buffer::writeBytes);
} else {
buffer.writeByte(0);
}
} else {
writeUnsignedInt(SignedNumeric.encode(-1), buffer);
}
writeUnsignedInt(startop.batch, buffer);
if (protocolVersion >= 24) {
buffer.writeByte(startop.includeMetadata ? 1 : 0);
}
} else if (op.code == 0x33) {
IterationNextOp nextop = (IterationNextOp) op;
writeRangedBytes(nextop.iterationId.getBytes(), buffer);
} else if (op.code == 0x35) {
IterationEndOp endop = (IterationEndOp) op;
writeRangedBytes(endop.iterationId.getBytes(), buffer);
}
}
}
private void encodePrepareOp(PrepareOp op, ByteBuf buffer) {
writeHeader(op, buffer);
writeXid(op.xid, buffer);
buffer.writeByte(op.onePhaseCommit ? 1 : 0);
writeUnsignedInt(op.modifications.size(), buffer);
op.modifications.forEach(txWrite -> txWrite.encodeTo(buffer));
}
private void encodeTxOp(TxOp op, ByteBuf byteBuf) {
writeHeader(op, byteBuf);
writeXid(op.xid, byteBuf);
}
private void writeNamedFactory(Optional<KeyValuePair<String, List<byte[]>>> namedFactory, ByteBuf buffer) {
if (namedFactory.isPresent()) {
KeyValuePair<String, List<byte[]>> factory = namedFactory.get();
writeString(factory.getKey(), buffer);
buffer.writeByte(factory.getValue().size());
factory.getValue().forEach(bytes -> writeRangedBytes(bytes, buffer));
} else {
buffer.writeByte(0);
}
}
private void writeHeader(Op op, ByteBuf buffer) {
buffer.writeByte(op.magic); // magic
writeUnsignedLong(op.id, buffer); // message id
buffer.writeByte(op.version); // version
buffer.writeByte(op.code); // opcode
if (!op.cacheName.isEmpty()) {
writeRangedBytes(op.cacheName.getBytes(), buffer); // cache name length + cache name
} else {
writeUnsignedInt(0, buffer); // Zero length
}
writeUnsignedInt(op.flags, buffer); // flags
buffer.writeByte(op.clientIntel); // client intelligence
writeUnsignedInt(op.topologyId, buffer); // topology id
if (protocolVersion >= 28) {
buffer.writeByte(0); // key type
buffer.writeByte(0); // value type
}
}
}
class Decoder extends ReplayingDecoder<Void> {
private final HotRodClient client;
private final static Log log = LogFactory.getLog(Decoder.class, Log.class);
Decoder(HotRodClient client) {
this.client = client;
}
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf buf, List<Object> out) {
buf.readUnsignedByte(); // magic byte
long id = ExtendedByteBuf.readUnsignedLong(buf);
HotRodOperation opCode = HotRodOperation.fromResponseOpCode((byte) buf.readUnsignedByte());
OperationStatus status = OperationStatus.fromCode((byte) buf.readUnsignedByte());
short topologyChangeMarker = buf.readUnsignedByte();
Op op = client.idToOp.get(id);
log.tracef("Decoding response messageId=%d opCode=%s status=%s topologyChange=%d", id, opCode, status, topologyChangeMarker);
AbstractTestTopologyAwareResponse topologyChangeResponse;
if (topologyChangeMarker == 1) {
int topologyId = readUnsignedInt(buf);
if (op.clientIntel == Constants.INTELLIGENCE_TOPOLOGY_AWARE) {
int numberClusterMembers = readUnsignedInt(buf);
ServerAddress[] viewArray = new ServerAddress[numberClusterMembers];
for (int i = 0; i < numberClusterMembers; i++) {
String host = readString(buf);
int port = readUnsignedShort(buf);
viewArray[i] = ServerAddress.forAddress(host, port, true);
}
topologyChangeResponse = new TestTopologyAwareResponse(topologyId, Arrays.asList(viewArray));
} else if (op.clientIntel == Constants.INTELLIGENCE_HASH_DISTRIBUTION_AWARE) {
if (op.version < 20)
topologyChangeResponse = read1xHashDistAwareHeader(buf, topologyId, op);
else
topologyChangeResponse = read2xHashDistAwareHeader(buf, topologyId, op);
} else {
throw new UnsupportedOperationException(
"Client intelligence " + op.clientIntel + " not supported");
}
} else {
topologyChangeResponse = null;
}
TestResponse resp;
switch (opCode) {
case STATS:
int size = readUnsignedInt(buf);
Map<String, String> stats = new HashMap<>();
for (int i = 0; i < size; ++i) {
stats.put(readString(buf), readString(buf));
}
resp = new TestStatsResponse(op.version, id, op.cacheName, op.clientIntel,
op.topologyId, topologyChangeResponse, stats);
break;
case PUT:
case PUT_IF_ABSENT:
case REPLACE:
case REPLACE_IF_UNMODIFIED:
case REMOVE:
case REMOVE_IF_UNMODIFIED:
case PUT_STREAM:
boolean checkPrevious;
if (op.version >= 10 && op.version <= 13) {
checkPrevious = (op.flags & ProtocolFlag.ForceReturnPreviousValue.getValue()) == 1;
} else if (op.version >= 40) {
checkPrevious = status == SuccessWithPrevious || status == NotExecutedWithPrevious;
} else {
checkPrevious = status == SuccessWithPrevious || status == NotExecutedWithPrevious;
}
if (checkPrevious) {
int length = readUnsignedInt(buf);
if (length == 0) {
resp = new TestResponseWithPrevious(op.version, id, op.cacheName,
op.clientIntel, opCode, status, op.topologyId, topologyChangeResponse, Optional.empty());
} else {
byte[] previous = new byte[length];
buf.readBytes(previous);
resp = new TestResponseWithPrevious(op.version, id, op.cacheName,
op.clientIntel, opCode, status, op.topologyId, topologyChangeResponse, Optional.of(previous));
}
} else {
resp = new TestResponse(op.version, id, op.cacheName, op.clientIntel,
opCode, status, op.topologyId, topologyChangeResponse);
}
break;
case CONTAINS_KEY:
case CLEAR:
case PING:
case ADD_CLIENT_LISTENER:
case REMOVE_CLIENT_LISTENER:
case ITERATION_END:
resp = new TestResponse(op.version, id, op.cacheName, op.clientIntel, opCode,
status, op.topologyId, topologyChangeResponse);
break;
case GET_WITH_VERSION:
if (status == Success) {
long version = buf.readLong();
Optional<byte[]> data = Optional.of(ExtendedByteBuf.readRangedBytes(buf));
resp = new TestGetWithVersionResponse(op.version, id, op.cacheName,
op.clientIntel, opCode, status, op.topologyId, topologyChangeResponse, data, version);
} else {
resp = new TestGetWithVersionResponse(op.version, id, op.cacheName,
op.clientIntel, opCode, status, op.topologyId, topologyChangeResponse, Optional.empty(), 0);
}
break;
case GET_WITH_METADATA:
case GET_STREAM:
if (status == Success) {
long created = -1;
int lifespan = -1;
long lastUsed = -1;
int maxIdle = -1;
byte flags = buf.readByte();
if ((flags & 0x01) != 0x01) {
created = buf.readLong();
lifespan = readUnsignedInt(buf);
}
if ((flags & 0x02) != 0x02) {
lastUsed = buf.readLong();
maxIdle = readUnsignedInt(buf);
}
long version = buf.readLong();
Optional<byte[]> data = Optional.of(ExtendedByteBuf.readRangedBytes(buf));
resp = new TestGetWithMetadataResponse(op.version, id, op.cacheName,
op.clientIntel, opCode, status, op.topologyId, topologyChangeResponse, data, version,
created, lifespan, lastUsed, maxIdle);
} else {
resp = new TestGetWithMetadataResponse(op.version, id, op.cacheName,
op.clientIntel, opCode, status, op.topologyId, topologyChangeResponse, Optional.empty(), 0,
-1, -1, -1, -1);
}
break;
case GET:
if (status == Success) {
Optional<byte[]> data = Optional.of(ExtendedByteBuf.readRangedBytes(buf));
resp = new TestGetResponse(op.version, id, op.cacheName, op.clientIntel,
opCode, status, op.topologyId, topologyChangeResponse, data);
} else {
resp = new TestGetResponse(op.version, id, op.cacheName, op.clientIntel,
opCode, status, op.topologyId, topologyChangeResponse, Optional.empty());
}
break;
case BULK_GET:
byte done = buf.readByte();
Map<byte[], byte[]> bulkBuffer = new HashMap<>();
while (done == 1) {
bulkBuffer.put(ExtendedByteBuf.readRangedBytes(buf), ExtendedByteBuf.readRangedBytes(buf));
done = buf.readByte();
}
resp = new TestBulkGetResponse(op.version, id, op.cacheName, op.clientIntel,
op.topologyId, topologyChangeResponse, bulkBuffer);
break;
case BULK_GET_KEYS:
done = buf.readByte();
Set<byte[]> bulkKeys = new HashSet<>();
while (done == 1) {
bulkKeys.add(ExtendedByteBuf.readRangedBytes(buf));
done = buf.readByte();
}
resp = new TestBulkGetKeysResponse(op.version, id, op.cacheName, op.clientIntel,
op.topologyId, topologyChangeResponse, bulkKeys);
break;
case QUERY:
byte[] result = ExtendedByteBuf.readRangedBytes(buf);
resp = new TestQueryResponse(op.version, id, op.cacheName, op.clientIntel,
op.topologyId, topologyChangeResponse, result);
break;
case AUTH_MECH_LIST:
size = readUnsignedInt(buf);
Set<String> mechs = new HashSet<>();
for (int i = 0; i < size; ++i) {
mechs.add(readString(buf));
}
resp = new TestAuthMechListResponse(op.version, id, op.cacheName, op.clientIntel,
op.topologyId, topologyChangeResponse, mechs);
break;
case AUTH: {
boolean complete = buf.readBoolean();
byte[] challenge = ExtendedByteBuf.readRangedBytes(buf);
resp = new TestAuthResponse(op.version, id, op.cacheName, op.clientIntel,
op.topologyId, topologyChangeResponse, complete, challenge);
break;
}
case CACHE_ENTRY_CREATED_EVENT:
case CACHE_ENTRY_MODIFIED_EVENT:
case CACHE_ENTRY_REMOVED_EVENT:
byte[] listenerId = ExtendedByteBuf.readRangedBytes(buf);
byte isCustom = buf.readByte();
boolean isRetried = buf.readByte() == 1;
if (isCustom == 1 || isCustom == 2) {
byte[] eventData = ExtendedByteBuf.readRangedBytes(buf);
resp = new TestCustomEvent(client.protocolVersion, id, client.defaultCacheName, opCode, listenerId,
isRetried, eventData);
} else {
byte[] key = ExtendedByteBuf.readRangedBytes(buf);
if (opCode == HotRodOperation.CACHE_ENTRY_REMOVED_EVENT) {
resp = new TestKeyEvent(client.protocolVersion, id, client.defaultCacheName, listenerId, isRetried, key);
} else {
long dataVersion = buf.readLong();
resp = new TestKeyWithVersionEvent(client.protocolVersion, id, client.defaultCacheName,
opCode, listenerId, isRetried, key, dataVersion);
}
}
break;
case SIZE:
long lsize = ExtendedByteBuf.readUnsignedLong(buf);
resp = new TestSizeResponse(op.version, id, op.cacheName, op.clientIntel,
op.topologyId, topologyChangeResponse, lsize);
break;
case ERROR:
if (op == null)
resp = new TestErrorResponse((byte) 10, id, "", (short) 0, status, 0,
null, readString(buf));
else
resp = new TestErrorResponse(op.version, id, op.cacheName, op.clientIntel,
status, op.topologyId, topologyChangeResponse, readString(buf));
break;
case ITERATION_START:
String iterationId = readString(buf);
resp = new TestIteratorStartResponse(op.version, id, op.cacheName, op.clientIntel, op.topologyId, topologyChangeResponse, iterationId);
break;
case ITERATION_NEXT:
resp = new TestIteratorNextResponse(op.version, id, op.cacheName, op.clientIntel, op.topologyId, topologyChangeResponse);
break;
case PREPARE_TX:
case ROLLBACK_TX:
case COMMIT_TX:
resp = new TxResponse(client.protocolVersion, id, client.defaultCacheName, op.clientIntel, opCode, status,
op.topologyId, topologyChangeResponse, status == OperationStatus.Success ? buf.readInt() : 0);
break;
case FORGET_TX:
resp = new TestResponse(op.version, id, op.cacheName, op.clientIntel, opCode, status, op.topologyId,
topologyChangeResponse);
break;
case FETCH_TX_RECOVERY:
resp = status == OperationStatus.Success ?
new RecoveryTestResponse(op.version, id, op.cacheName, op.clientIntel, opCode, status, op.topologyId,
topologyChangeResponse, buf) :
new TestResponse(op.version, id, op.cacheName, op.clientIntel, opCode, status, op.topologyId,
topologyChangeResponse);
break;
case COUNTER_REMOVE:
case COUNTER_CREATE:
case COUNTER_IS_DEFINED:
case COUNTER_RESET:
case COUNTER_ADD_LISTENER:
case COUNTER_REMOVE_LISTENER:
resp = new TestResponse(op.version, id, op.cacheName, op.clientIntel,
opCode, status, op.topologyId, topologyChangeResponse);
break;
case COUNTER_GET_CONFIGURATION:
resp = status == OperationStatus.Success ?
new CounterConfigurationTestResponse(op.version, id, op.cacheName, op.clientIntel,
opCode, status, op.topologyId, topologyChangeResponse,
decodeConfiguration(buf::readByte, buf::readLong, () -> readUnsignedInt(buf))) :
new TestResponse(op.version, id, op.cacheName, op.clientIntel,
opCode, status, op.topologyId, topologyChangeResponse);
break;
case COUNTER_GET:
case COUNTER_ADD_AND_GET:
case COUNTER_CAS:
case COUNTER_GET_AND_SET:
resp = status == OperationStatus.Success ?
new CounterValueTestResponse(op.version, id, op.cacheName, op.clientIntel,
opCode, status, op.topologyId, topologyChangeResponse, buf.readLong()) :
new TestResponse(op.version, id, op.cacheName, op.clientIntel,
opCode, status, op.topologyId, topologyChangeResponse);
break;
case COUNTER_GET_NAMES:
resp = status == OperationStatus.Success ?
new CounterNamesTestResponse(op.version, id, op.cacheName, op.clientIntel,
opCode, status, op.topologyId, topologyChangeResponse, buf) :
new TestResponse(op.version, id, op.cacheName, op.clientIntel,
opCode, status, op.topologyId, topologyChangeResponse);
break;
case COUNTER_EVENT:
resp = new TestCounterEventResponse(client.protocolVersion, id, opCode, buf);
break;
default:
resp = null;
break;
}
// We cannot assert this since in concurrent case we could get two responses in single buffer
if (log.isTraceEnabled() && buf.readerIndex() != buf.writerIndex()) {
log.tracef("Left bytes in the buffer: %s",
new String(ByteBufUtil.getBytes(buf, buf.readerIndex(), buf.writerIndex() - buf.readerIndex())));
}
if (resp != null) {
log.tracef("Got response: %s", resp);
out.add(resp);
}
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
log.exceptionReported(cause);
}
private AbstractTestTopologyAwareResponse read2xHashDistAwareHeader(ByteBuf buf, int topologyId, Op op) {
int numServersInTopo = readUnsignedInt(buf);
List<ServerAddress> members = new ArrayList<>();
for (int i = 0; i < numServersInTopo; ++i) {
ServerAddress node = ServerAddress.forAddress(readString(buf), readUnsignedShort(buf), true);
members.add(node);
}
byte hashFunction = buf.readByte();
int numSegments = readUnsignedInt(buf);
List<Iterable<ServerAddress>> segments = new ArrayList<>();
if (hashFunction > 0) {
for (int i = 1; i <= numSegments; ++i) {
byte owners = buf.readByte();
List<ServerAddress> membersInSegment = new ArrayList<>();
for (int j = 1; j <= owners; ++j) {
int index = readUnsignedInt(buf);
membersInSegment.add(members.get(index));
}
segments.add(membersInSegment);
}
}
return new TestHashDistAware20Response(topologyId, members, segments, hashFunction);
}
private AbstractTestTopologyAwareResponse read1xHashDistAwareHeader(ByteBuf buf, int topologyId, Op op) {
int numOwners = readUnsignedShort(buf);
byte hashFunction = buf.readByte();
int hashSpace = readUnsignedInt(buf);
int numServersInTopo = readUnsignedInt(buf);
if (op.version == 10) {
return read10HashDistAwareHeader(buf, topologyId,
numOwners, hashFunction, hashSpace, numServersInTopo);
} else {
return read11HashDistAwareHeader(buf, topologyId,
numOwners, hashFunction, hashSpace, numServersInTopo);
}
}
private AbstractTestTopologyAwareResponse read10HashDistAwareHeader(ByteBuf buf, int topologyId,
int numOwners, byte hashFunction, int hashSpace, int numServersInTopo) {
// The exact number of topology addresses in the list is unknown
// until we loop through the entire list and we figure out how
// hash ids are per HotRod server (i.e. num virtual nodes > 1)
Set<ServerAddress> members = new HashSet<>();
Map<ServerAddress, List<Integer>> allHashIds = new HashMap<>();
List<Integer> hashIdsOfAddr = new ArrayList<>();
ServerAddress prevNode = null;
for (int i = 1; i <= numServersInTopo; ++i) {
ServerAddress node = ServerAddress.forAddress(readString(buf), readUnsignedShort(buf), true);
int hashId = buf.readInt();
if (prevNode == null || node.equals(prevNode)) {
// First time node has been seen, so cache it
if (prevNode == null)
prevNode = node;
// Add current hash id to list
hashIdsOfAddr.add(hashId);
} else {
// A new node has been detected, so create the topology
// address and store it in the view
allHashIds.put(prevNode, hashIdsOfAddr);
members.add(prevNode);
prevNode = node;
hashIdsOfAddr = new ArrayList<>();
hashIdsOfAddr.add(hashId);
}
// Check for last server hash in which case just add it
if (i == numServersInTopo) {
allHashIds.put(prevNode, hashIdsOfAddr);
members.add(prevNode);
}
}
return new TestHashDistAware10Response(topologyId, members,
allHashIds, numOwners, hashFunction, hashSpace);
}
private AbstractTestTopologyAwareResponse read11HashDistAwareHeader(ByteBuf buf, int topologyId,
int numOwners, Byte hashFunction, int hashSpace,
int numServersInTopo) {
int numVirtualNodes = readUnsignedInt(buf);
Map<ServerAddress, Integer> hashToAddress = new HashMap<>();
for (int i = 1; i <= numServersInTopo; ++i) {
hashToAddress.put(ServerAddress.forAddress(readString(buf), readUnsignedShort(buf), true), buf.readInt());
}
return new TestHashDistAware11Response(topologyId, hashToAddress,
numOwners, hashFunction, hashSpace, numVirtualNodes);
}
}
class ClientHandler extends ChannelInboundHandlerAdapter {
private static final Log log = LogFactory.getLog(ClientHandler.class, Log.class);
final int rspTimeoutSeconds;
ClientHandler(int rspTimeoutSeconds) {
this.rspTimeoutSeconds = rspTimeoutSeconds;
}
private Map<Long, CompletableFuture<TestResponse>> responses = new ConcurrentHashMap<>();
private Map<WrappedByteArray, TestClientListener> clientListeners = new ConcurrentHashMap<>();
private Map<WrappedByteArray, TestCounterNotificationManager> clientCounterListeners = new ConcurrentHashMap<>();
void registerCounterNotificationManager(TestCounterNotificationManager manager) {
clientCounterListeners.putIfAbsent(manager.getListenerId(), manager);
}
void addClientListener(TestClientListener listener) {
clientListeners.put(new WrappedByteArray(listener.getId()), listener);
}
void removeClientListener(byte[] listenerId) {
clientListeners.remove(new WrappedByteArray(listenerId));
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
if (msg instanceof TestKeyWithVersionEvent) {
TestKeyWithVersionEvent e = (TestKeyWithVersionEvent) msg;
TestClientListener listener = clientListeners.get(new WrappedByteArray(e.listenerId));
if (listener == null) {
log.errorf("Could not find listener for event %s", msg);
return;
}
switch (e.getOperation()) {
case CACHE_ENTRY_CREATED_EVENT:
listener.onCreated(e);
break;
case CACHE_ENTRY_MODIFIED_EVENT:
listener.onModified(e);
break;
}
} else if (msg instanceof TestKeyEvent) {
TestKeyEvent e = (TestKeyEvent) msg;
clientListeners.get(new WrappedByteArray(e.listenerId)).onRemoved(e);
} else if (msg instanceof TestCustomEvent) {
TestCustomEvent e = (TestCustomEvent) msg;
clientListeners.get(new WrappedByteArray(e.listenerId)).onCustom(e);
} else if (msg instanceof TestCounterEventResponse) {
TestCounterNotificationManager listener =
clientCounterListeners.get(((TestCounterEventResponse) msg).getListenerId());
if (listener == null) {
log.errorf("Could not find listener for event %s", msg);
return;
}
listener.accept((TestCounterEventResponse) msg);
} else if (msg instanceof TestResponse) {
TestResponse resp = (TestResponse) msg;
CompletableFuture<TestResponse> cf = responses.remove(resp.getMessageId());
if (cf == null) {
log.errorf("Could not find request for response %s", resp);
return;
}
cf.complete(resp);
} else {
throw new IllegalArgumentException("Unsupported object: " + msg);
}
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
super.channelInactive(ctx);
responses.forEach((messageId, responseFuture) -> responseFuture.completeExceptionally(new ClosedChannelException()));
}
CompletionStage<TestResponse> waitForResponse(long expectedResponseMessageId) {
CompletableFuture<TestResponse> cf = new CompletableFuture<>();
responses.put(expectedResponseMessageId, cf);
return cf;
}
}
class PartialOp extends Op {
public PartialOp(int magic, byte version, byte code, String cacheName, byte[] key, int lifespan, int maxIdle,
byte[] value, int flags, long dataVersion, byte clientIntel, int topologyId) {
super(magic, version, code, cacheName, key, lifespan, maxIdle, value, flags, dataVersion, clientIntel, topologyId);
}
}
abstract class AbstractOp extends Op {
public AbstractOp(int magic, byte version, byte code, String cacheName, byte clientIntel, int topologyId) {
super(magic, version, code, cacheName, null, 0, 0, null, 0, 0, clientIntel, topologyId);
}
}
class StatsOp extends AbstractOp {
final String statName;
public StatsOp(int magic, byte version, byte code, String cacheName, byte clientIntel, int topologyId, String statName) {
super(magic, version, code, cacheName, clientIntel, topologyId);
this.statName = statName;
}
}
class BulkGetOp extends AbstractOp {
final int count;
public BulkGetOp(int magic, byte version, byte code, String cacheName, byte clientIntel, int topologyId, int count) {
super(magic, version, code, cacheName, clientIntel, topologyId);
this.count = count;
}
}
class BulkGetKeysOp extends AbstractOp {
final int scope;
public BulkGetKeysOp(int magic, byte version, byte code, String cacheName, byte clientIntel, int topologyId, int scope) {
super(magic, version, code, cacheName, clientIntel, topologyId);
this.scope = scope;
}
}
class QueryOp extends AbstractOp {
final byte[] query;
public QueryOp(int magic, byte version, String cacheName, byte clientIntel, int topologyId, byte[] query) {
super(magic, version, (byte) 0x1F, cacheName, clientIntel, topologyId);
this.query = query;
}
}
class AddClientListenerOp extends AbstractOp {
final byte[] listenerId;
final boolean includeState;
final Optional<KeyValuePair<String, List<byte[]>>> filterFactory;
final Optional<KeyValuePair<String, List<byte[]>>> converterFactory;
final boolean useRawData;
public AddClientListenerOp(int magic, byte version, String cacheName, byte clientIntel, int topologyId,
byte[] listenerId, boolean includeState, Optional<KeyValuePair<String, List<byte[]>>> filterFactory,
Optional<KeyValuePair<String, List<byte[]>>> converterFactory, boolean useRawData) {
super(magic, version, (byte) 0x25, cacheName, clientIntel, topologyId);
this.listenerId = listenerId;
this.includeState = includeState;
this.filterFactory = filterFactory;
this.converterFactory = converterFactory;
this.useRawData = useRawData;
}
}
class AddBloomNearCacheListener extends AbstractOp {
final byte[] listenerId;
final int bloomBits;
public AddBloomNearCacheListener(int magic, byte version, String cacheName, byte clientIntel, int topologyId,
byte[] listenerId, int bloomBits) {
super(magic, version, (byte) 0x25, cacheName, clientIntel, topologyId);
this.listenerId = listenerId;
this.bloomBits = bloomBits;
}
}
class RemoveClientListenerOp extends AbstractOp {
final byte[] listenerId;
public RemoveClientListenerOp(int magic, byte version, String cacheName, byte clientIntel, int topologyId,
byte[] listenerId) {
super(magic, version, (byte) 0x27, cacheName, clientIntel, topologyId);
this.listenerId = listenerId;
}
}
class AuthMechListOp extends AbstractOp {
public AuthMechListOp(int magic, byte version, byte code, String cacheName, byte clientIntel, int topologyId) {
super(magic, version, code, cacheName, clientIntel, topologyId);
}
}
class AuthOp extends AbstractOp {
final String mech;
final byte[] response;
public AuthOp(int magic, byte version, byte code, String cacheName, byte clientIntel, int topologyId, String mech,
byte[] response) {
super(magic, version, code, cacheName, clientIntel, topologyId);
this.mech = mech;
this.response = response;
}
}
class SizeOp extends AbstractOp {
public SizeOp(int magic, byte version, String cacheName, byte clientIntel, int topologyId) {
super(magic, version, (byte) 0x29, cacheName, clientIntel, topologyId);
}
}
class IterationStartOp extends AbstractOp {
final byte[] segmentMask;
final String filterConverterFactory;
final List<byte[]> filterConverterParams;
final int batch;
final boolean includeMetadata;
public IterationStartOp(int magic, byte version, String cacheName, byte clientIntel, int topologyId, byte[] segmentMask, String filterConverterFactory,
List<byte[]> filterConverterParams, int batch, boolean includeMetadata) {
super(magic, version, (byte) 0x31, cacheName, clientIntel, topologyId);
this.segmentMask = segmentMask;
this.filterConverterFactory = filterConverterFactory;
this.filterConverterParams = filterConverterParams;
this.batch = batch;
this.includeMetadata = includeMetadata;
}
}
class IterationNextOp extends AbstractOp {
String iterationId;
public IterationNextOp(int magic, byte version, String cacheName, byte clientIntel, int topologyId, String iterationId) {
super(magic, version, (byte) 0x33, cacheName, clientIntel, topologyId);
this.iterationId = iterationId;
}
}
class IterationEndOp extends AbstractOp {
String iterationId;
public IterationEndOp(int magic, byte version, String cacheName, byte clientIntel, int topologyId, String iterationId) {
super(magic, version, (byte) 0x35, cacheName, clientIntel, topologyId);
this.iterationId = iterationId;
}
}
class GetStreamOp extends Op {
final int offset;
public GetStreamOp(int magic, byte version, String cacheName, byte[] key, int flags, byte clientIntel, int topologyId, int offset) {
super(magic, version, (byte) 0x37, cacheName, key, -1, -1, null, flags, 0, clientIntel, topologyId);
this.offset = offset;
}
}
class PutStreamOp extends Op {
public PutStreamOp(int magic, byte version, String cacheName, byte[] key, byte[] value, int lifespan, int maxIdle, long dataVersion, byte clientIntel, int topologyId) {
super(magic, version, (byte) 0x39, cacheName, key, lifespan, maxIdle, value, 0, dataVersion, clientIntel, topologyId);
}
}
abstract class TxOp extends AbstractOp {
final XidImpl xid;
TxOp(int magic, byte version, byte code, String cacheName, byte clientIntel, int topologyId, XidImpl xid) {
super(magic, version, code, cacheName, clientIntel, topologyId);
this.xid = xid;
}
}
class PrepareOp extends TxOp {
final boolean onePhaseCommit;
final List<TxWrite> modifications;
PrepareOp(byte version, String cacheName, int topologyId, XidImpl xid, boolean onePhaseCommit,
Collection<TxWrite> modifications) {
super(0xA0, version, (byte) 0x3B, cacheName, (byte) 1, topologyId, xid);
this.onePhaseCommit = onePhaseCommit;
this.modifications = new ArrayList<>(modifications);
}
}
class CommitOrRollbackOp extends TxOp {
CommitOrRollbackOp(byte version, String cacheName, XidImpl xid, boolean commit) {
super(0xA0, version, (byte) (commit ? 0x3D : 0x3F), cacheName, (byte) 1, 0, xid);
}
}
class ForgetTxOp extends TxOp {
ForgetTxOp(byte version, XidImpl xid) {
super(0xA0, version, HotRodConstants.FORGET_TX, "", (byte) 1, 0, xid);
}
}
class RecoveryOp extends AbstractOp {
RecoveryOp(byte version) {
super(0xA0, version, HotRodConstants.FETCH_TX_RECOVERY, "", (byte) 0, 0);
}
}
| 60,869
| 42.048091
| 187
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestKeyEvent.java
|
package org.infinispan.server.hotrod.test;
import org.infinispan.server.hotrod.HotRodOperation;
import org.infinispan.server.hotrod.OperationStatus;
/**
* @author wburns
* @since 9.0
*/
public class TestKeyEvent extends TestResponse {
public final byte[] listenerId;
public final boolean isRetried;
public final byte[] key;
protected TestKeyEvent(byte version, long messageId, String cacheName, byte[] listenerId, boolean isRetried, byte[] key) {
super(version, messageId, cacheName, (byte) 0, HotRodOperation.CACHE_ENTRY_REMOVED_EVENT,
OperationStatus.Success, (byte) 0, null);
this.listenerId = listenerId;
this.isRetried = isRetried;
this.key = key;
}
}
| 714
| 30.086957
| 125
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestIteratorStartResponse.java
|
package org.infinispan.server.hotrod.test;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import org.infinispan.server.hotrod.HotRodOperation;
public class TestIteratorStartResponse extends TestResponse {
public final String iteratorId;
protected TestIteratorStartResponse(byte version, long messageId, String cacheName, short clientIntel,
int topologyId, AbstractTestTopologyAwareResponse topologyResponse, String iteratorId) {
super(version, messageId, cacheName, clientIntel, HotRodOperation.ITERATION_START, Success, topologyId, topologyResponse);
this.iteratorId = iteratorId;
}
}
| 671
| 41
| 128
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestCustomEvent.java
|
package org.infinispan.server.hotrod.test;
import org.infinispan.server.hotrod.HotRodOperation;
import org.infinispan.server.hotrod.OperationStatus;
/**
* @author wburns
* @since 9.0
*/
public class TestCustomEvent extends TestResponse {
public final byte[] listenerId;
public final boolean isRetried;
public final byte[] eventData;
protected TestCustomEvent(byte version, long messageId, String cacheName, HotRodOperation operation, byte[] listenerId, boolean isRetried, byte[] eventData) {
super(version, messageId, cacheName, (byte) 0, operation, OperationStatus.Success, (byte) 0, null);
this.listenerId = listenerId;
this.isRetried = isRetried;
this.eventData = eventData;
}
}
| 727
| 32.090909
| 161
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestGetWithMetadataResponse.java
|
package org.infinispan.server.hotrod.test;
import java.util.Optional;
import org.infinispan.server.hotrod.HotRodOperation;
import org.infinispan.server.hotrod.OperationStatus;
/**
* @author wburns
* @since 9.0
*/
public class TestGetWithMetadataResponse extends TestGetWithVersionResponse {
final long created;
final int lifespan;
final long lastUsed;
final int maxIdle;
protected TestGetWithMetadataResponse(byte version, long messageId, String cacheName, short clientIntel,
HotRodOperation operation, OperationStatus status, int topologyId,
AbstractTestTopologyAwareResponse topologyResponse, Optional<byte[]> data, long dataVersion,
long created, int lifespan, long lastUsed, int maxIdle) {
super(version, messageId, cacheName, clientIntel, operation, status, topologyId, topologyResponse, data, dataVersion);
this.created = created;
this.lifespan = lifespan;
this.lastUsed = lastUsed;
this.maxIdle = maxIdle;
}
}
| 1,095
| 36.793103
| 133
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/AbstractTestTopologyAwareResponse.java
|
package org.infinispan.server.hotrod.test;
import java.util.Collection;
import org.infinispan.server.hotrod.ServerAddress;
/**
* @author wburns
* @since 9.0
*/
public abstract class AbstractTestTopologyAwareResponse {
public final int topologyId;
public final Collection<ServerAddress> members;
protected AbstractTestTopologyAwareResponse(int topologyId, Collection<ServerAddress> members) {
this.topologyId = topologyId;
this.members = members;
}
}
| 482
| 22
| 99
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/Op.java
|
package org.infinispan.server.hotrod.test;
import org.infinispan.commons.util.Util;
/**
* @author wburns
* @since 9.0
*/
public class Op {
final int magic;
final byte version;
final byte code;
final String cacheName;
final byte[] key;
final int lifespan;
final int maxIdle;
final byte[] value;
final int flags;
final long dataVersion;
final byte clientIntel;
final int topologyId;
final long id = HotRodClient.idCounter.incrementAndGet();
public Op(int magic, byte version, byte code, String cacheName, byte[] key, int lifespan, int maxIdle, byte[] value,
int flags, long dataVersion, byte clientIntel, int topologyId) {
this.magic = magic;
this.version = version;
this.code = code;
this.cacheName = cacheName;
this.key = key;
this.lifespan = lifespan;
this.maxIdle = maxIdle;
this.value = value;
this.flags = flags;
this.dataVersion = dataVersion;
this.clientIntel = clientIntel;
this.topologyId = topologyId;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("Op{");
sb.append("magic=").append(magic);
sb.append(", version=").append(version);
sb.append(", code=").append(code);
sb.append(", cacheName='").append(cacheName).append('\'');
sb.append(", key=");
sb.append(Util.printArray(key));
sb.append(", lifespan=").append(lifespan);
sb.append(", maxIdle=").append(maxIdle);
sb.append(", value=");
sb.append(Util.printArray(value));
sb.append(", flags=").append(flags);
sb.append(", dataVersion=").append(dataVersion);
sb.append(", clientIntel=").append(clientIntel);
sb.append(", topologyId=").append(topologyId);
sb.append(", id=").append(id);
sb.append('}');
return sb.toString();
}
}
| 1,876
| 29.274194
| 119
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestGetResponse.java
|
package org.infinispan.server.hotrod.test;
import java.util.Optional;
import org.infinispan.server.hotrod.HotRodOperation;
import org.infinispan.server.hotrod.OperationStatus;
/**
* @author wburns
* @since 9.0
*/
public class TestGetResponse extends TestResponse {
final Optional<byte[]> data;
protected TestGetResponse(byte version, long messageId, String cacheName, short clientIntel,
HotRodOperation operation, OperationStatus status, int topologyId,
AbstractTestTopologyAwareResponse topologyResponse, Optional<byte[]> data) {
super(version, messageId, cacheName, clientIntel, operation, status, topologyId, topologyResponse);
this.data = data;
}
}
| 739
| 32.636364
| 105
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestBulkGetKeysResponse.java
|
package org.infinispan.server.hotrod.test;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import java.util.Set;
import org.infinispan.server.hotrod.HotRodOperation;
/**
* @author wburns
* @since 9.0
*/
public class TestBulkGetKeysResponse extends TestResponse {
public final Set<byte[]> bulkData;
protected TestBulkGetKeysResponse(byte version, long messageId, String cacheName, short clientIntel,
int topologyId, AbstractTestTopologyAwareResponse topologyResponse, Set<byte[]> bulkData) {
super(version, messageId, cacheName, clientIntel, HotRodOperation.BULK_GET, Success, topologyId, topologyResponse);
this.bulkData = bulkData;
}
}
| 723
| 31.909091
| 128
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/HotRodMagicKeyGenerator.java
|
package org.infinispan.server.hotrod.test;
import java.util.Random;
import org.infinispan.Cache;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.commons.marshall.ProtoStreamMarshaller;
import org.infinispan.distribution.LocalizedCacheTopology;
/**
* {@link org.infinispan.distribution.MagicKey} equivalent for HotRod
*
* @author Galder Zamarreño
* @since 5.2
*/
public class HotRodMagicKeyGenerator {
public static byte[] newKey(Cache<?, ?> cache) throws Exception {
LocalizedCacheTopology cacheTopology = cache.getAdvancedCache().getDistributionManager().getCacheTopology();
Random r = new Random();
Marshaller marshaller = new ProtoStreamMarshaller();
for (int i = 0; i < 1000; i++) {
String candidate = String.valueOf(r.nextLong());
byte[] candidateBytes = marshaller.objectToByteBuffer(candidate, 64);
if (cacheTopology.isReadOwner(candidateBytes)) {
return candidateBytes;
}
}
throw new RuntimeException("Unable to find a key local to node " + cache);
}
}
| 1,087
| 31
| 114
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/HotRodStreamingTest.java
|
package org.infinispan.server.hotrod.test;
import static org.testng.AssertJUnit.assertEquals;
import org.infinispan.server.hotrod.HotRodSingleNodeTest;
import org.infinispan.server.hotrod.OperationStatus;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "server.hotrod.test.HotRodStreamingTest")
public class HotRodStreamingTest extends HotRodSingleNodeTest {
private final byte[] K1 = "K1".getBytes();
private final byte[] V1;
private final byte[] V2;
private final int V1_SIZE = 32_000;
private final int V2_SIZE = 16_000;
public HotRodStreamingTest() {
V1 = fillArray(V1_SIZE);
V2 = fillArray(V2_SIZE);
}
private byte[] fillArray(int size) {
byte[] array = new byte[size];
for(int i = 0; i < size; i++) {
array[i] = (byte)(i % 256);
}
return array;
}
public void testPutGetStream() {
TestResponse putResponse = client().putStream(K1, V1, 0, -1, -1);
assertEquals(OperationStatus.Success, putResponse.getStatus());
TestGetWithMetadataResponse getResponse = client().getStream(K1, 0);
assertEquals(-1, getResponse.lifespan);
assertEquals(-1, getResponse.maxIdle);
assertEquals(V1, getResponse.data.get());
}
public void testPutStreamIfAbsent() {
TestResponse putResponse = client().putStream(K1, V1, -1, -1, -1);
assertEquals(OperationStatus.Success, putResponse.getStatus());
TestGetWithMetadataResponse getResponse = client().getStream(K1, 0);
assertEquals(-1, getResponse.lifespan);
assertEquals(-1, getResponse.maxIdle);
assertEquals(V1, getResponse.data.get());
putResponse = client().putStream(K1, V2, -1, -1, -1);
assertEquals(OperationStatus.OperationNotExecuted, putResponse.getStatus());
getResponse = client().getStream(K1, 0);
assertEquals(-1, getResponse.lifespan);
assertEquals(-1, getResponse.maxIdle);
assertEquals(V1, getResponse.data.get());
}
public void testReplaceStream() {
TestResponse putResponse = client().putStream(K1, V1, -1, -1, -1);
assertEquals(OperationStatus.Success, putResponse.getStatus());
TestGetWithMetadataResponse getResponse = client().getStream(K1, 0);
assertEquals(-1, getResponse.lifespan);
assertEquals(-1, getResponse.maxIdle);
assertEquals(V1, getResponse.data.get());
long k1version = getResponse.dataVersion;
putResponse = client().putStream(K1, V2, k1version + 3, -1, -1); // use the wrong version
assertEquals(OperationStatus.OperationNotExecuted, putResponse.getStatus());
getResponse = client().getStream(K1, 0);
assertEquals(-1, getResponse.lifespan);
assertEquals(-1, getResponse.maxIdle);
assertEquals(V1, getResponse.data.get());
putResponse = client().putStream(K1, V2, k1version, -1, -1); // use the right version
assertEquals(OperationStatus.Success, putResponse.getStatus());
getResponse = client().getStream(K1, 0);
assertEquals(-1, getResponse.lifespan);
assertEquals(-1, getResponse.maxIdle);
assertEquals(V2, getResponse.data.get());
}
}
| 3,165
| 34.573034
| 95
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TxWrite.java
|
package org.infinispan.server.hotrod.test;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.writeUnsignedLong;
import org.infinispan.server.hotrod.transport.ExtendedByteBuf;
import org.infinispan.server.hotrod.tx.ControlByte;
import io.netty.buffer.ByteBuf;
/**
* A transaction write for testing.
*
* @author Pedro Ruivo
* @since 9.1
*/
public class TxWrite {
private final long versionRead;
private final byte control;
private final byte[] value;
private final int lifespan;
private final int maxIdle;
private final byte[] key;
private TxWrite(long versionRead, byte control, byte[] value, int lifespan, int maxIdle, byte[] key) {
this.versionRead = versionRead;
this.control = control;
this.value = value;
this.lifespan = lifespan;
this.maxIdle = maxIdle;
this.key = key;
}
public static TxWrite put(byte[] key, byte[] value, int lifespan, int maxIdle, byte control, long versionRead) {
return new TxWrite(versionRead, control, value, lifespan, maxIdle, key);
}
public static TxWrite remove(byte[] key, byte control, long versionRead) {
return new TxWrite(versionRead, ControlByte.REMOVE_OP.set(control), null, 0, 0, key);
}
void encodeTo(ByteBuf buffer) {
ExtendedByteBuf.writeRangedBytes(key, buffer);
buffer.writeByte(control);
if (!ControlByte.NOT_READ.hasFlag(control) && !ControlByte.NON_EXISTING.hasFlag(control)) {
buffer.writeLong(versionRead);
}
if (ControlByte.REMOVE_OP.hasFlag(control)) {
return;
}
if (lifespan > 0 || maxIdle > 0) {
buffer.writeByte(0); // seconds for both
writeUnsignedLong(lifespan, buffer); // lifespan
writeUnsignedLong(maxIdle, buffer); // maxIdle
} else {
buffer.writeByte(0x88);
}
ExtendedByteBuf.writeRangedBytes(value, buffer);
}
}
| 1,911
| 30.866667
| 115
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TxResponse.java
|
package org.infinispan.server.hotrod.test;
import org.infinispan.server.hotrod.HotRodOperation;
import org.infinispan.server.hotrod.OperationStatus;
/**
* A {@link TestResponse} used by prepare, commit or rollback requests.
*
* @author Pedro Ruivo
* @since 9.1
*/
public class TxResponse extends TestResponse {
public final int xaCode;
TxResponse(byte version, long messageId, String cacheName, short clientIntel,
HotRodOperation operation, OperationStatus status,
int topologyId, AbstractTestTopologyAwareResponse topologyResponse, int xaCode) {
super(version, messageId, cacheName, clientIntel, operation, status, topologyId, topologyResponse);
this.xaCode = xaCode;
}
}
| 721
| 30.391304
| 105
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/HotRodTestingUtil.java
|
package org.infinispan.server.hotrod.test;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_OBJECT_TYPE;
import static org.infinispan.server.hotrod.OperationStatus.KeyDoesNotExist;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNull;
import static org.testng.AssertJUnit.assertTrue;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import org.infinispan.AdvancedCache;
import org.infinispan.Cache;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.commons.marshall.ProtoStreamMarshaller;
import org.infinispan.commons.test.TestResourceTracker;
import org.infinispan.commons.util.Util;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.distribution.DistributionManager;
import org.infinispan.distribution.LocalizedCacheTopology;
import org.infinispan.distribution.ch.ConsistentHash;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.remoting.transport.Address;
import org.infinispan.server.core.transport.NettyChannelInitializer;
import org.infinispan.server.core.transport.NettyInitializers;
import org.infinispan.server.hotrod.HotRodServer;
import org.infinispan.server.hotrod.OperationStatus;
import org.infinispan.server.hotrod.ServerAddress;
import org.infinispan.server.hotrod.configuration.HotRodServerConfigurationBuilder;
import org.infinispan.server.hotrod.logging.Log;
import org.infinispan.server.hotrod.transport.TestHandlersChannelInitializer;
import org.infinispan.server.hotrod.transport.TimeoutEnabledChannelInitializer;
import org.infinispan.test.TestingUtil;
import org.infinispan.util.KeyValuePair;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
/**
* Test utils for Hot Rod tests.
*
* @author Galder Zamarreño
* @since 4.1
*/
public class HotRodTestingUtil {
private HotRodTestingUtil() {
}
private static final Log log = LogFactory.getLog(HotRodTestingUtil.class, Log.class);
private static final UniquePortThreadLocal uptl = new UniquePortThreadLocal();
public static String host() {
return "127.0.0.1";
}
public static int serverPort() {
return uptl.get();
}
public static HotRodServer startHotRodServer(EmbeddedCacheManager manager) {
return startHotRodServer(manager, serverPort());
}
public static HotRodServer startHotRodServer(EmbeddedCacheManager manager, String defaultCacheName) {
return startHotRodServer(manager, serverPort(), 0, host(), serverPort(), defaultCacheName);
}
public static HotRodServer startHotRodServer(EmbeddedCacheManager manager, String proxyHost, int proxyPort) {
return startHotRodServer(manager, serverPort(), 0, proxyHost, proxyPort, null);
}
public static HotRodServer startHotRodServer(EmbeddedCacheManager manager, int port) {
return startHotRodServer(manager, port, 0);
}
public static HotRodServer startHotRodServer(EmbeddedCacheManager manager, int port, String proxyHost, int proxyPort) {
return startHotRodServer(manager, port, 0, proxyHost, proxyPort, null);
}
public static HotRodServer startHotRodServer(EmbeddedCacheManager manager, int port, int idleTimeout) {
return startHotRodServer(manager, port, idleTimeout, host(), port, null);
}
public static HotRodServer startHotRodServerWithoutTransport(String... definedCaches) {
return startHotRodServerWithoutTransport(new HotRodServerConfigurationBuilder(), definedCaches);
}
public static HotRodServer startHotRodServerWithoutTransport(HotRodServerConfigurationBuilder builder, String... definedCaches) {
GlobalConfigurationBuilder globalConfiguration = new GlobalConfigurationBuilder();
Configuration cacheConfiguration = new ConfigurationBuilder()
.encoding().key().mediaType(APPLICATION_OBJECT_TYPE)
.encoding().value().mediaType(APPLICATION_OBJECT_TYPE)
.build();
builder.startTransport(false);
DefaultCacheManager cacheManager = new DefaultCacheManager(globalConfiguration.build());
for (String cache : definedCaches) {
cacheManager.defineConfiguration(cache, cacheConfiguration);
}
return startHotRodServer(cacheManager, builder);
}
public static HotRodServer startHotRodServer(EmbeddedCacheManager manager, int port, int idleTimeout,
String proxyHost, int proxyPort, String defaultCacheName) {
HotRodServerConfigurationBuilder builder = new HotRodServerConfigurationBuilder();
builder.proxyHost(proxyHost).proxyPort(proxyPort).idleTimeout(idleTimeout);
if (defaultCacheName != null) {
builder.defaultCacheName(defaultCacheName);
}
return startHotRodServer(manager, port, builder);
}
public static HotRodServer startHotRodServer(EmbeddedCacheManager manager, int port, int idleTimeout,
String proxyHost, int proxyPort) {
return startHotRodServer(manager, port, idleTimeout, proxyHost, proxyPort, null);
}
public static HotRodServer startHotRodServer(EmbeddedCacheManager manager, int port, HotRodServerConfigurationBuilder builder) {
return startHotRodServer(manager, host(), port, builder);
}
public static HotRodServer startHotRodServer(EmbeddedCacheManager manager, HotRodServerConfigurationBuilder builder) {
return startHotRodServer(manager, serverPort(), builder);
}
public static HotRodServer startHotRodServer(EmbeddedCacheManager manager, String host, int port,
HotRodServerConfigurationBuilder builder) {
log.infof("Start server in port %d", port);
HotRodServer server = new HotRodServer() {
@Override
public ChannelInitializer<Channel> getInitializer() {
if (configuration.idleTimeout() > 0)
return new NettyInitializers(
new NettyChannelInitializer<>(this, transport, getEncoder(), this::getDecoder),
new TimeoutEnabledChannelInitializer<>(this), new TestHandlersChannelInitializer());
else // Idle timeout logic is disabled with -1 or 0 values
return new NettyInitializers(
new NettyChannelInitializer<>(this, transport, getEncoder(), this::getDecoder),
new TestHandlersChannelInitializer());
}
};
String shortTestName = TestResourceTracker.getCurrentTestShortName();
if (!builder.name().contains(shortTestName)) {
// Only set the name once if HotRodClientTestingUtil.startHotRodServer() retries
builder.name(shortTestName + builder.name());
}
builder.host(host).port(port);
builder.ioThreads(3);
try {
server.start(builder.build(), manager);
return server;
} catch (Throwable t) {
server.stop();
throw t;
}
}
public static HotRodServerConfigurationBuilder getDefaultHotRodConfiguration() {
HotRodServerConfigurationBuilder builder = new HotRodServerConfigurationBuilder();
int port = serverPort();
builder.host(host()).port(port).proxyHost(host()).proxyPort(port);
return builder;
}
public static List<NetworkInterface> findNetworkInterfaces(boolean loopback) {
try {
List<NetworkInterface> matchingInterfaces = new ArrayList<>();
Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
while (interfaces.hasMoreElements()) {
NetworkInterface ni = interfaces.nextElement();
if (ni.isUp() && ni.isLoopback() == loopback && ni.getInetAddresses().hasMoreElements()) {
matchingInterfaces.add(ni);
}
}
return matchingInterfaces;
} catch (SocketException e) {
throw new CacheException(e);
}
}
public static byte[] k(Method m, String prefix) {
return (prefix + m.getName()).getBytes();
}
public static byte[] v(Method m, String prefix) {
return k(m, prefix);
}
public static byte[] k(Method m) {
return k(m, "k-");
}
public static byte[] v(Method m) {
return v(m, "v-");
}
public static boolean assertStatus(TestResponse resp, OperationStatus expected) {
OperationStatus status = resp.getStatus();
boolean isSuccess = status == expected;
if (resp instanceof TestErrorResponse) {
assertTrue(String.format("Status should have been '%s' but instead was: '%s', and the error message was: %s",
expected, status, ((TestErrorResponse) resp).msg), isSuccess);
} else {
assertTrue(String.format("Status should have been '%s' but instead was: '%s'", expected, status), isSuccess);
}
return isSuccess;
}
public static boolean assertSuccess(TestGetResponse resp, byte[] expected) {
assertStatus(resp, Success);
boolean isArrayEquals = Arrays.equals(expected, resp.data.get());
assertTrue("Retrieved data should have contained " + Util.printArray(expected, true) + " (" + new String(expected)
+ "), but instead we received " + Util.printArray(resp.data.get(), true) + " (" + new String(resp.data.get()) + ")", isArrayEquals);
return isArrayEquals;
}
public static void assertByteArrayEquals(byte[] expected, byte[] actual) {
boolean isArrayEquals = Arrays.equals(expected, actual);
assertTrue("Retrieved data should have contained " + Util.printArray(expected, true) + " (" + new String(expected)
+ "), but instead we received " + Util.printArray(actual, true) + " (" + new String(actual) + ")", isArrayEquals);
}
public static boolean assertSuccess(TestGetWithVersionResponse resp, byte[] expected, int expectedVersion) {
assertTrue(resp.getVersion() != expectedVersion);
return assertSuccess(resp, expected);
}
public static boolean assertSuccess(TestGetWithMetadataResponse resp, byte[] expected, int expectedLifespan, int expectedMaxIdle) {
assertEquals(resp.lifespan, expectedLifespan);
assertEquals(resp.maxIdle, expectedMaxIdle);
return assertSuccess(resp, expected);
}
public static boolean assertKeyDoesNotExist(TestGetResponse resp) {
OperationStatus status = resp.getStatus();
assertTrue("Status should have been 'KeyDoesNotExist' but instead was: " + status, status == KeyDoesNotExist);
assertEquals(resp.data, Optional.empty());
return status == KeyDoesNotExist;
}
public static void assertTopologyReceived(AbstractTestTopologyAwareResponse resp, List<HotRodServer> servers,
int expectedTopologyId) {
assertEquals(resp.topologyId, expectedTopologyId);
if (resp instanceof TestHashDistAware10Response) {
TestHashDistAware10Response h10 = (TestHashDistAware10Response) resp;
assertEquals(new HashSet<>(h10.members), servers.stream().map(HotRodServer::getAddress).collect(Collectors.toSet()));
} else if (resp instanceof TestHashDistAware11Response) {
TestHashDistAware11Response h11 = (TestHashDistAware11Response) resp;
assertEquals(new HashSet<>(h11.members), servers.stream().map(HotRodServer::getAddress).collect(Collectors.toSet()));
} else if (resp instanceof TestTopologyAwareResponse) {
TestTopologyAwareResponse t = (TestTopologyAwareResponse) resp;
assertEquals(new HashSet<>(t.members), servers.stream().map(HotRodServer::getAddress).collect(Collectors.toSet()));
} else {
throw new IllegalArgumentException("Unsupported response!");
}
}
public static void assertHashTopology20Received(AbstractTestTopologyAwareResponse topoResp,
List<HotRodServer> servers, String cacheName, int expectedTopologyId) {
TestHashDistAware20Response hashTopologyResp = (TestHashDistAware20Response) topoResp;
assertEquals(expectedTopologyId, hashTopologyResp.topologyId);
assertEquals(hashTopologyResp.members.size(), servers.size());
Set<ServerAddress> serverAddresses = servers.stream().map(HotRodServer::getAddress).collect(Collectors.toSet());
hashTopologyResp.members.forEach(member -> assertTrue(serverAddresses.contains(member)));
assertEquals(hashTopologyResp.hashFunction, 3);
// Assert segments
Cache cache = servers.get(0).getCacheManager().getCache(cacheName);
LocalizedCacheTopology cacheTopology = cache.getAdvancedCache().getDistributionManager().getCacheTopology();
assertEquals(cacheTopology.getActualMembers().size(), servers.size());
ConsistentHash ch = cacheTopology.getCurrentCH();
int numSegments = ch.getNumSegments();
int numOwners = cache.getCacheConfiguration().clustering().hash().numOwners();
assertEquals(hashTopologyResp.segments.size(), numSegments);
for (int i = 0; i < numSegments; ++i) {
List<Address> segment = ch.locateOwnersForSegment(i);
Iterable<ServerAddress> members = hashTopologyResp.segments.get(i);
assertEquals(Math.min(numOwners, ch.getMembers().size()), segment.size());
int count = 0;
for (ServerAddress member : members) {
count++;
assertTrue(serverAddresses.contains(member));
}
// The number of servers could be smaller than the number of CH members (same as the number of actual members)
assertEquals(Math.min(numOwners, servers.size()), count);
}
}
public static int getServerTopologyId(EmbeddedCacheManager cm, String cacheName) {
return TestingUtil.extractComponent(cm.getCache(cacheName), DistributionManager.class).getCacheTopology()
.getReadConsistentHash().hashCode();
}
public static void killClient(HotRodClient client) {
try {
if (client != null) {
client.stop().await();
}
} catch (Throwable t) {
log.error("Error stopping client", t);
}
}
public static ConfigurationBuilder hotRodCacheConfiguration() {
return hotRodCacheConfiguration(new ConfigurationBuilder());
}
public static ConfigurationBuilder hotRodCacheConfiguration(ConfigurationBuilder builder) {
return hotRodCacheConfiguration(builder, MediaType.APPLICATION_PROTOSTREAM);
}
public static ConfigurationBuilder hotRodCacheConfiguration(ConfigurationBuilder cfg, MediaType types) {
cfg.encoding().key().mediaType(types.toString());
cfg.encoding().value().mediaType(types.toString());
return cfg;
}
public static ConfigurationBuilder hotRodCacheConfiguration(MediaType types) {
return hotRodCacheConfiguration(new ConfigurationBuilder(), types);
}
public static CacheEntry assertHotRodEquals(EmbeddedCacheManager cm, byte[] key, byte[] expectedValue) {
return assertHotRodEquals(cm.getCache(), key, expectedValue);
}
public static CacheEntry assertHotRodEquals(EmbeddedCacheManager cm, String cacheName,
byte[] key, byte[] expectedValue) {
return assertHotRodEquals(cm.getCache(cacheName), key, expectedValue);
}
public static CacheEntry assertHotRodEquals(EmbeddedCacheManager cm, String key, String expectedValue) {
return assertHotRodEquals(cm.getCache(), marshall(key), marshall(expectedValue));
}
public static CacheEntry assertHotRodEquals(EmbeddedCacheManager cm, String cacheName,
String key, String expectedValue) {
return assertHotRodEquals(cm.getCache(cacheName), marshall(key), marshall(expectedValue));
}
private static CacheEntry assertHotRodEquals(Cache<byte[], byte[]> cache,
byte[] key, byte[] expectedValue) {
AdvancedCache advancedCache = cache.getAdvancedCache().withStorageMediaType();
CacheEntry<byte[], byte[]> entry = advancedCache.getCacheEntry(key);
// Assert based on passed parameters
if (expectedValue == null) {
assertNull(entry);
} else {
byte[] value = entry.getValue();
assertEquals(expectedValue, value);
}
return entry;
}
public static byte[] marshall(Object obj) {
try {
return obj == null ? null : getMarshaller().objectToByteBuffer(obj, 64);
} catch (IOException | InterruptedException e) {
throw new CacheException(e);
}
}
public static <T> T unmarshall(byte[] key) {
try {
return (T) getMarshaller().objectFromByteBuffer(key);
} catch (IOException | ClassNotFoundException e) {
throw new CacheException(e);
}
}
private static Marshaller getMarshaller() {
return new ProtoStreamMarshaller();
}
public static void withClientListener(HotRodClient client, TestClientListener listener,
Optional<KeyValuePair<String, List<byte[]>>> filterFactory,
Optional<KeyValuePair<String, List<byte[]>>> converterFactory, Runnable fn) {
withClientListener(client, listener, filterFactory, converterFactory, false, true, fn);
}
public static void withClientListener(HotRodClient client, TestClientListener listener,
Optional<KeyValuePair<String, List<byte[]>>> filterFactory,
Optional<KeyValuePair<String, List<byte[]>>> converterFactory, boolean includeState, boolean useRawData,
Runnable fn) {
assertStatus(client.addClientListener(listener, includeState, filterFactory == null ? Optional.empty() : filterFactory,
converterFactory == null ? Optional.empty() : converterFactory, useRawData), Success);
try {
fn.run();
} finally {
assertStatus(client.removeClientListener(listener.getId()), Success);
}
}
static final AtomicInteger uniqueAddr = new AtomicInteger(12411);
static class UniquePortThreadLocal extends ThreadLocal<Integer> {
@Override
protected Integer initialValue() {
int port = uniqueAddr.getAndAdd(110);
log.debugf("Server port range for test thread %s is: %d-%d", Thread.currentThread().getId(), port, port + 109);
return port;
}
}
}
| 19,285
| 43.851163
| 145
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestResponse.java
|
package org.infinispan.server.hotrod.test;
import org.infinispan.server.hotrod.HotRodOperation;
import org.infinispan.server.hotrod.OperationStatus;
/**
* @author wburns
* @since 9.0
*/
public class TestResponse {
public final AbstractTestTopologyAwareResponse topologyResponse;
public final byte version;
public final long messageId;
public final String cacheName;
public final short clientIntel;
public final HotRodOperation operation;
public final OperationStatus status;
public final int topologyId;
protected TestResponse(byte version, long messageId, String cacheName, short clientIntel,
HotRodOperation operation, OperationStatus status, int topologyId,
AbstractTestTopologyAwareResponse topologyResponse) {
this.version = version;
this.messageId = messageId;
this.cacheName = cacheName;
this.clientIntel = clientIntel;
this.operation = operation;
this.status = status;
this.topologyId = topologyId;
this.topologyResponse = topologyResponse;
}
public AbstractTestTopologyAwareResponse asTopologyAwareResponse() {
if (topologyResponse == null) {
throw new IllegalStateException("Unexpected response: " + topologyResponse);
}
return topologyResponse;
}
public byte getVersion() {
return version;
}
public long getMessageId() {
return messageId;
}
public String getCacheName() {
return cacheName;
}
public short getClientIntel() {
return clientIntel;
}
public HotRodOperation getOperation() {
return operation;
}
public OperationStatus getStatus() {
return status;
}
public int getTopologyId() {
return topologyId;
}
@Override
public String toString() {
return "Response{" +
"version=" + version +
", messageId=" + messageId +
", cacheName='" + cacheName + '\'' +
", clientIntel=" + clientIntel +
", operation=" + operation +
", status=" + status +
", topologyId=" + topologyId +
'}';
}
}
| 2,166
| 25.753086
| 92
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestKeyWithVersionEvent.java
|
package org.infinispan.server.hotrod.test;
import org.infinispan.server.hotrod.HotRodOperation;
import org.infinispan.server.hotrod.OperationStatus;
/**
* @author wburns
* @since 9.0
*/
public class TestKeyWithVersionEvent extends TestResponse {
public final byte[] listenerId;
public final boolean isRetried;
public final byte[] key;
public final long dataVersion;
protected TestKeyWithVersionEvent(byte version, long messageId, String cacheName, HotRodOperation operation,
byte[] listenerId, boolean isRetried, byte[] key, long dataVersion) {
super(version, messageId, cacheName, (byte) 0, operation, OperationStatus.Success, (byte) 0, null);
this.listenerId = listenerId;
this.isRetried = isRetried;
this.key = key;
this.dataVersion = dataVersion;
}
}
| 846
| 32.88
| 111
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestBulkGetResponse.java
|
package org.infinispan.server.hotrod.test;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import java.util.Map;
import org.infinispan.server.hotrod.HotRodOperation;
/**
* @author wburns
* @since 9.0
*/
public class TestBulkGetResponse extends TestResponse {
public final Map<byte[], byte[]> bulkData;
protected TestBulkGetResponse(byte version, long messageId, String cacheName, short clientIntel,
int topologyId, AbstractTestTopologyAwareResponse topologyResponse, Map<byte[], byte[]> bulkData) {
super(version, messageId, cacheName, clientIntel, HotRodOperation.BULK_GET, Success, topologyId, topologyResponse);
this.bulkData = bulkData;
}
}
| 727
| 32.090909
| 132
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestHashDistAware11Response.java
|
package org.infinispan.server.hotrod.test;
import java.util.Map;
import org.infinispan.server.hotrod.ServerAddress;
public class TestHashDistAware11Response extends AbstractTestTopologyAwareResponse {
final Map<ServerAddress, Integer> membersToHash;
final int numOwners;
final byte hashFunction;
final int hashSpace;
final int numVirtualNodes;
protected TestHashDistAware11Response(int topologyId, Map<ServerAddress, Integer> membersToHash, int numOwners,
byte hashFunction, int hashSpace, int numVirtualNodes) {
super(topologyId, membersToHash.keySet());
this.membersToHash = membersToHash;
this.numOwners = numOwners;
this.hashFunction = hashFunction;
this.hashSpace = hashSpace;
this.numVirtualNodes = numVirtualNodes;
}
@Override
public String toString() {
return "TestHashDistAware11Response{" +
"numOwners=" + numOwners +
", hashFunction=" + hashFunction +
", hashSpace=" + hashSpace +
", numVirtualNodes=" + numVirtualNodes +
", topologyId=" + topologyId +
", members=" + members +
'}';
}
}
| 1,208
| 31.675676
| 114
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/RemoteTransaction.java
|
package org.infinispan.server.hotrod.test;
import static java.lang.String.format;
import static org.infinispan.commons.util.Util.printArray;
import static org.testng.AssertJUnit.assertArrayEquals;
import static org.testng.AssertJUnit.assertEquals;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.commons.marshall.WrappedByteArray;
import org.infinispan.commons.tx.XidImpl;
import org.infinispan.server.hotrod.logging.Log;
import org.infinispan.server.hotrod.tx.ControlByte;
/**
* A test class that simulates a client's transaction.
*
* @author Pedro Ruivo
* @since 9.0
*/
public class RemoteTransaction {
private static final Log log = LogFactory.getLog(RemoteTransaction.class, Log.class);
private static final int FORMAT = -1234;
private static final AtomicInteger ID_GENERATOR = new AtomicInteger(0);
private final HotRodClient client;
private final XidImpl xid;
private final Map<WrappedByteArray, ContextValue> txContext;
private RemoteTransaction(HotRodClient client) {
this.client = client;
byte[] gtxAndBrandId = intToBytes(ID_GENERATOR.incrementAndGet());
xid = XidImpl.create(FORMAT, gtxAndBrandId, gtxAndBrandId);
txContext = new ConcurrentHashMap<>();
}
public static RemoteTransaction startTransaction(HotRodClient client) {
return new RemoteTransaction(Objects.requireNonNull(client));
}
private static byte[] intToBytes(long val) {
byte[] array = new byte[4];
for (int i = 3; i > 0; i--) {
array[i] = (byte) val;
val >>>= 8;
}
array[0] = (byte) val;
return array;
}
private static TxWrite transform(Map.Entry<WrappedByteArray, ContextValue> entry) {
ContextValue contextValue = entry.getValue();
if (contextValue.removed) {
return TxWrite.remove(entry.getKey().getBytes(), ControlByte.REMOVE_OP.set(contextValue.control),
contextValue.versionRead);
} else {
return TxWrite.put(entry.getKey().getBytes(), contextValue.value, contextValue.lifespan, contextValue.maxIdle,
contextValue.control, contextValue.versionRead);
}
}
private static boolean isModifiedFilter(Map.Entry<WrappedByteArray, ContextValue> entry) {
return entry.getValue().modified;
}
private static ContextValue nonExisting() {
return new ContextValue(0, ControlByte.NON_EXISTING.bit(), null);
}
private static ContextValue notRead(@SuppressWarnings("unused") WrappedByteArray ignoredKey) {
return new ContextValue(0, ControlByte.NOT_READ.bit(), null);
}
public void getAndAssert(byte[] key, byte[] expectedValue) {
final String message = format("[XID=%s] Wrong value for key %s", xid, printArray(key, true));
if (expectedValue == null) {
assertEquals(message, null, get(key));
} else {
assertArrayEquals(message, expectedValue, get(key));
}
}
public void set(byte[] key, byte[] value) {
set(key, value, 0, 0);
}
public void set(byte[] key, byte[] value, int lifespan, int maxIdle) {
log.debugf("SET[%s] (%s, %s, %s, &s)", xid, printArray(key, true), printArray(value, true), lifespan, maxIdle);
ContextValue contextValue = txContext.computeIfAbsent(new WrappedByteArray(key), RemoteTransaction::notRead);
contextValue.set(value, lifespan, maxIdle);
}
public void remove(byte[] key) {
ContextValue contextValue = txContext.computeIfAbsent(new WrappedByteArray(key), RemoteTransaction::notRead);
contextValue.remove();
}
public void prepareAndAssert(int expectedXaCode) {
final String message = format("[XID=%s] Wrong XA return code for prepare", xid);
assertEquals(message, expectedXaCode, prepare().xaCode);
}
public void prepareAndAssert(HotRodClient another, int expectedXaCode) {
final String message = format("[XID=%s] Wrong XA return code for prepare", xid);
log.debugf("PREPARE[%s]", xid);
assertEquals(message, expectedXaCode, ((TxResponse) another.prepareTx(xid, false, modifications())).xaCode);
}
public void commitAndAssert(int expectedXaCode) {
final String message = format("[XID=%s] Wrong XA return code for commit", xid);
assertEquals(message, expectedXaCode, commit().xaCode);
}
public void commitAndAssert(HotRodClient another, int expectedXaCode) {
final String message = format("[XID=%s] Wrong XA return code for commit", xid);
log.debugf("COMMIT[%s]", xid);
assertEquals(message, expectedXaCode, ((TxResponse) another.commitTx(xid)).xaCode);
}
public void rollbackAndAssert(int expectedXaCode) {
final String message = format("[XID=%s] Wrong XA return code for rollback", xid);
assertEquals(message, expectedXaCode, rollback().xaCode);
}
public void rollbackAndAssert(HotRodClient another, int expectedXaCode) {
final String message = format("[XID=%s] Wrong XA return code for rollback", xid);
log.debugf("ROLLBACK[%s]", xid);
assertEquals(message, expectedXaCode, ((TxResponse) another.rollbackTx(xid)).xaCode);
}
public void forget() {
log.debugf("FORGET[%s]", xid);
client.forgetTx(xid);
}
public void forget(HotRodClient another) {
log.debugf("FORGET[%s]", xid);
another.forgetTx(xid);
}
public XidImpl getXid() {
return xid;
}
private TxResponse rollback() {
log.debugf("ROLLBACK[%s]", xid);
return (TxResponse) client.rollbackTx(xid);
}
private byte[] get(byte[] key) {
log.debugf("GET[%s] (%s)", xid, printArray(key, true));
ContextValue value = txContext.get(new WrappedByteArray(key));
if (value != null) {
return value.value;
}
return performGet(key).value;
}
private TxResponse prepare() {
log.debugf("PREPARE[%s]", xid);
return (TxResponse) client.prepareTx(xid, false, modifications());
}
private TxResponse commit() {
log.debugf("COMMIT[%s]", xid);
return (TxResponse) client.commitTx(xid);
}
private List<TxWrite> modifications() {
return txContext.entrySet().stream().filter(RemoteTransaction::isModifiedFilter).map(RemoteTransaction::transform)
.collect(Collectors.toList());
}
private ContextValue performGet(byte[] key) {
TestGetWithMetadataResponse response = client.getWithMetadata(key, 0);
ContextValue contextValue = response.data
.map(bytes -> new ContextValue(response.dataVersion, (byte) 0, bytes))
.orElseGet(RemoteTransaction::nonExisting);
txContext.put(new WrappedByteArray(key), contextValue);
return contextValue;
}
private static class ContextValue {
private final long versionRead;
private final byte control;
private byte[] value;
private int lifespan;
private int maxIdle;
private boolean modified;
private boolean removed;
private ContextValue(long versionRead, byte control, byte[] value) {
this.versionRead = versionRead;
this.control = control;
this.value = value;
}
public void remove() {
this.value = null;
this.modified = true;
this.removed = true;
}
public void set(byte[] value, int lifespan, int maxIdle) {
this.value = value;
this.lifespan = lifespan;
this.maxIdle = maxIdle;
this.modified = true;
this.removed = false;
}
}
}
| 7,707
| 34.036364
| 120
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/test/TestTopologyAwareResponse.java
|
package org.infinispan.server.hotrod.test;
import java.util.Collection;
import org.infinispan.server.hotrod.ServerAddress;
public class TestTopologyAwareResponse extends AbstractTestTopologyAwareResponse {
protected TestTopologyAwareResponse(int topologyId, Collection<ServerAddress> members) {
super(topologyId, members);
}
@Override
public String toString() {
return "TestTopologyAwareResponse{" +
"topologyId=" + topologyId +
", members=" + members +
'}';
}
}
| 533
| 25.7
| 91
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/tx/TxFunctionalTest.java
|
package org.infinispan.server.hotrod.tx;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertKeyDoesNotExist;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertSuccess;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import static org.infinispan.test.TestingUtil.extractComponent;
import static org.infinispan.test.TestingUtil.extractGlobalComponent;
import static org.testng.AssertJUnit.assertTrue;
import java.lang.reflect.Method;
import java.util.Arrays;
import javax.transaction.xa.XAException;
import javax.transaction.xa.XAResource;
import org.infinispan.Cache;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.hotrod.HotRodMultiNodeTest;
import org.infinispan.server.hotrod.HotRodVersion;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.server.hotrod.test.RemoteTransaction;
import org.infinispan.server.hotrod.tx.table.GlobalTxTable;
import org.infinispan.server.hotrod.tx.table.PerCacheTxTable;
import org.infinispan.transaction.LockingMode;
import org.infinispan.transaction.TransactionMode;
import org.testng.annotations.Test;
/**
* Functional and validation test for transaction.
*
* @author Pedro Ruivo
* @since 9.1
*/
@Test(groups = "functional", testName = "server.hotrod.tx.TxFunctionalTest")
public class TxFunctionalTest extends HotRodMultiNodeTest {
private org.infinispan.configuration.cache.TransactionMode transactionMode;
@Override
public Object[] factory() {
return Arrays.stream(org.infinispan.configuration.cache.TransactionMode.values())
.filter(tMode -> tMode != org.infinispan.configuration.cache.TransactionMode.NONE)
.flatMap(txMode -> Arrays.stream(LockingMode.values())
.map(lockingMode -> new TxFunctionalTest()
.transactionMode(txMode)
.lockingMode(lockingMode)))
.toArray();
}
public TxFunctionalTest transactionMode(org.infinispan.configuration.cache.TransactionMode transactionMode) {
this.transactionMode = transactionMode;
return this;
}
public void testKeyNotRead(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.set(k1, v1);
tx.getAndAssert(k1, v1);
tx.set(k2, v2);
tx.getAndAssert(k2, v2);
tx.prepareAndAssert(XAResource.XA_OK);
tx.commitAndAssert(XAResource.XA_OK);
tx.forget();
assertData(k1, v1);
assertData(k2, v2);
assertServerTransactionTableEmpty();
}
public void testKeyNotReadWithConcurrentTransaction(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
final byte[] v1_1 = v(method, "v1_1");
HotRodClient otherClient = clients().get(1);
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.set(k1, v1);
tx.getAndAssert(k1, v1);
tx.set(k2, v2);
tx.getAndAssert(k2, v2);
otherClient.put(k1, 0, 0, v1_1);
tx.prepareAndAssert(XAResource.XA_OK);
tx.commitAndAssert(XAResource.XA_OK);
tx.forget();
assertData(k1, v1);
assertData(k2, v2);
assertServerTransactionTableEmpty();
}
public void testKeyNonExisting(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.getAndAssert(k1, null);
tx.set(k1, v1);
tx.getAndAssert(k1, v1);
tx.getAndAssert(k2, null);
tx.set(k2, v2);
tx.getAndAssert(k2, v2);
tx.prepareAndAssert(XAResource.XA_OK);
tx.commitAndAssert(XAResource.XA_OK);
tx.forget();
assertData(k1, v1);
assertData(k2, v2);
assertServerTransactionTableEmpty();
}
public void testKeyNonExistingWithConflict(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
final byte[] v1_1 = v(method, "v1_1");
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.getAndAssert(k1, null);
tx.set(k1, v1);
tx.getAndAssert(k1, v1);
tx.getAndAssert(k2, null);
tx.set(k2, v2);
tx.getAndAssert(k2, v2);
clients().get(1).put(k1, 0, 0, v1_1);
tx.prepareAndAssert(XAException.XA_RBROLLBACK);
tx.rollbackAndAssert(XAResource.XA_OK);
tx.forget();
assertData(k1, v1_1);
assertDataDoesNotExist(k2);
assertServerTransactionTableEmpty();
}
public void testKeyRead(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
final byte[] v1_1 = v(method, "v1_1");
final byte[] v2_1 = v(method, "v2_1");
clients().get(1).put(k1, 0, 0, v1);
clients().get(1).put(k2, 0, 0, v2);
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.getAndAssert(k1, v1);
tx.set(k1, v1_1);
tx.getAndAssert(k1, v1_1);
tx.getAndAssert(k2, v2);
tx.set(k2, v2_1);
tx.getAndAssert(k2, v2_1);
tx.prepareAndAssert(XAResource.XA_OK);
tx.commitAndAssert(XAResource.XA_OK);
tx.forget();
assertData(k1, v1_1);
assertData(k2, v2_1);
assertServerTransactionTableEmpty();
}
public void testKeyReadWithConflict(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
final byte[] v1_1 = v(method, "v1_1");
final byte[] v2_1 = v(method, "v2_1");
final byte[] v1_1_1 = v(method, "v1_1_1");
clients().get(1).put(k1, 0, 0, v1);
clients().get(1).put(k2, 0, 0, v2);
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.getAndAssert(k1, v1);
tx.set(k1, v1_1);
tx.getAndAssert(k1, v1_1);
tx.getAndAssert(k2, v2);
tx.set(k2, v2_1);
tx.getAndAssert(k2, v2_1);
clients().get(1).put(k1, 0, 0, v1_1_1);
tx.prepareAndAssert(XAException.XA_RBROLLBACK);
tx.rollbackAndAssert(XAResource.XA_OK);
tx.forget();
assertData(k1, v1_1_1);
assertData(k2, v2);
assertServerTransactionTableEmpty();
}
public void testRemoveWithKeyNotRead(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.set(k1, v1);
tx.getAndAssert(k1, v1);
tx.set(k2, v2);
tx.getAndAssert(k2, v2);
tx.remove(k1);
tx.getAndAssert(k1, null);
tx.prepareAndAssert(XAResource.XA_OK);
tx.commitAndAssert(XAResource.XA_OK);
tx.forget();
assertDataDoesNotExist(k1);
assertData(k2, v2);
assertServerTransactionTableEmpty();
}
public void testRemoveWithKeyNotReadWithConcurrentTransaction(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
final byte[] v1_1 = v(method, "v1_1");
final byte[] v2_1 = v(method, "v2_1");
final byte[] v1_1_1 = v(method, "v1_1_1");
clients().get(1).put(k1, 0, 0, v1);
clients().get(1).put(k2, 0, 0, v2);
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.set(k1, v1_1);
tx.getAndAssert(k1, v1_1);
tx.set(k2, v2_1);
tx.getAndAssert(k2, v2_1);
tx.remove(k1);
tx.getAndAssert(k1, null);
clients().get(1).put(k1, 0, 0, v1_1_1);
tx.prepareAndAssert(XAResource.XA_OK);
tx.commitAndAssert(XAResource.XA_OK);
tx.forget();
assertDataDoesNotExist(k1);
assertData(k2, v2_1);
assertServerTransactionTableEmpty();
}
public void testRemoveWithNonExisting(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.getAndAssert(k1, null);
tx.set(k1, v1);
tx.getAndAssert(k1, v1);
tx.getAndAssert(k2, null);
tx.set(k2, v2);
tx.getAndAssert(k2, v2);
tx.remove(k1);
tx.getAndAssert(k1, null);
tx.prepareAndAssert(XAResource.XA_OK);
tx.commitAndAssert(XAResource.XA_OK);
tx.forget();
assertDataDoesNotExist(k1);
assertData(k2, v2);
assertServerTransactionTableEmpty();
}
public void testRemoveWithNonExistingWithConflictingTransaction(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
final byte[] v1_1 = v(method, "v1_1");
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.getAndAssert(k1, null);
tx.set(k1, v1);
tx.getAndAssert(k1, v1);
tx.getAndAssert(k2, null);
tx.set(k2, v2);
tx.getAndAssert(k2, v2);
tx.remove(k1);
tx.getAndAssert(k1, null);
clients().get(1).put(k1, 0, 0, v1_1);
tx.prepareAndAssert(XAException.XA_RBROLLBACK);
tx.rollbackAndAssert(XAResource.XA_OK);
tx.forget();
assertData(k1, v1_1);
assertDataDoesNotExist(k2);
assertServerTransactionTableEmpty();
}
public void testRemoveKeyRead(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
final byte[] v2_1 = v(method, "v2_1");
clients().get(1).put(k1, 0, 0, v1);
clients().get(1).put(k2, 0, 0, v2);
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.getAndAssert(k1, v1);
tx.remove(k1);
tx.getAndAssert(k1, null);
tx.getAndAssert(k2, v2);
tx.set(k2, v2_1);
tx.getAndAssert(k2, v2_1);
tx.prepareAndAssert(XAResource.XA_OK);
tx.commitAndAssert(XAResource.XA_OK);
tx.forget();
assertDataDoesNotExist(k1);
assertData(k2, v2_1);
assertServerTransactionTableEmpty();
}
public void testRemoveKeyReadWithConflicting(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
final byte[] v1_1 = v(method, "v1_1");
final byte[] v2_1 = v(method, "v2_1");
clients().get(1).put(k1, 0, 0, v1);
clients().get(1).put(k2, 0, 0, v2);
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.getAndAssert(k1, v1);
tx.remove(k1);
tx.getAndAssert(k1, null);
tx.getAndAssert(k2, v2);
tx.set(k2, v2_1);
tx.getAndAssert(k2, v2_1);
clients().get(1).put(k1, 0, 0, v1_1);
tx.prepareAndAssert(XAException.XA_RBROLLBACK);
tx.rollbackAndAssert(XAResource.XA_OK);
tx.forget();
assertData(k1, v1_1);
assertData(k2, v2);
assertServerTransactionTableEmpty();
}
public void testReadReadConflict(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
final byte[] v1_1 = v(method, "v1_1");
final byte[] v2_1 = v(method, "v2_1");
clients().get(1).put(k1, 0, 0, v1);
clients().get(1).put(k2, 0, 0, v2);
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.getAndAssert(k1, v1);
tx.remove(k1);
tx.getAndAssert(k1, null);
clients().get(1).put(k2, 0, 0, v2_1);
tx.prepareAndAssert(XAResource.XA_OK);
tx.commitAndAssert(XAResource.XA_OK);
tx.forget();
assertDataDoesNotExist(k1);
assertData(k2, v2_1);
assertServerTransactionTableEmpty();
clients().get(1).put(k1, 0, 0, v1);
clients().get(1).put(k2, 0, 0, v2);
tx = RemoteTransaction.startTransaction(clients().get(0));
tx.getAndAssert(k1, v1);
tx.set(k1, v1_1);
tx.getAndAssert(k1, v1_1);
clients().get(1).put(k2, 0, 0, v2_1);
tx.prepareAndAssert(XAResource.XA_OK);
tx.commitAndAssert(XAResource.XA_OK);
tx.forget();
assertData(k1, v1_1);
assertData(k2, v2_1);
assertServerTransactionTableEmpty();
}
public void testCommitFromAnotherNode(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
final byte[] v1_1 = v(method, "v1_1");
clients().get(1).put(k1, 0, 0, v1);
clients().get(1).put(k2, 0, 0, v2);
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.getAndAssert(k1, v1);
tx.remove(k1);
tx.getAndAssert(k1, null);
tx.prepareAndAssert(XAResource.XA_OK);
tx.commitAndAssert(clients().get(1), XAResource.XA_OK);
tx.forget(clients().get(1));
assertDataDoesNotExist(k1);
assertData(k2, v2);
assertServerTransactionTableEmpty();
clients().get(1).put(k1, 0, 0, v1);
clients().get(1).put(k2, 0, 0, v2);
tx = RemoteTransaction.startTransaction(clients().get(0));
tx.getAndAssert(k1, v1);
tx.set(k1, v1_1);
tx.getAndAssert(k1, v1_1);
tx.prepareAndAssert(XAResource.XA_OK);
tx.commitAndAssert(clients().get(1), XAResource.XA_OK);
tx.forget(clients().get(1));
assertData(k1, v1_1);
assertData(k2, v2);
assertServerTransactionTableEmpty();
}
public void testRollbackFromAnotherNode(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
final byte[] v1_1 = v(method, "v1_1");
clients().get(1).put(k1, 0, 0, v1);
clients().get(1).put(k2, 0, 0, v2);
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.getAndAssert(k1, v1);
tx.remove(k1);
tx.getAndAssert(k1, null);
tx.prepareAndAssert(XAResource.XA_OK);
tx.rollbackAndAssert(clients().get(1), XAResource.XA_OK);
tx.forget(clients().get(1));
assertData(k1, v1);
assertData(k2, v2);
assertServerTransactionTableEmpty();
clients().get(1).put(k1, 0, 0, v1);
clients().get(1).put(k2, 0, 0, v2);
tx = RemoteTransaction.startTransaction(clients().get(0));
tx.getAndAssert(k1, v1);
tx.set(k1, v1_1);
tx.getAndAssert(k1, v1_1);
tx.prepareAndAssert(XAResource.XA_OK);
tx.rollbackAndAssert(clients().get(1), XAResource.XA_OK);
tx.forget(clients().get(1));
assertData(k1, v1);
assertData(k2, v2);
assertServerTransactionTableEmpty();
}
public void testPrepareOnDifferentNode(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.set(k1, v1);
tx.set(k2, v2);
tx.getAndAssert(k1, v1);
tx.getAndAssert(k2, v2);
tx.prepareAndAssert(XAResource.XA_OK);
tx.prepareAndAssert(clients().get(1), XAResource.XA_OK);
tx.commitAndAssert(XAResource.XA_OK);
tx.forget();
assertData(k1, v1);
assertData(k2, v2);
assertServerTransactionTableEmpty();
}
@Override
protected String parameters() {
return "[" + lockingMode + "/" + transactionMode + "]";
}
@Override
protected String cacheName() {
return "tx-cache";
}
@Override
protected ConfigurationBuilder createCacheConfig() {
ConfigurationBuilder builder = hotRodCacheConfiguration();
builder.transaction().transactionMode(TransactionMode.TRANSACTIONAL);
builder.transaction().lockingMode(lockingMode);
switch (transactionMode) {
case NON_XA:
builder.transaction().useSynchronization(true);
break;
case NON_DURABLE_XA:
builder.transaction().useSynchronization(false);
builder.transaction().recovery().disable();
break;
case FULL_XA:
builder.transaction().useSynchronization(false);
builder.transaction().recovery().enable();
break;
default:
throw new IllegalStateException();
}
builder.clustering().hash().numOwners(2);
builder.clustering().cacheMode(CacheMode.DIST_SYNC);
return builder;
}
@Override
protected byte protocolVersion() {
return HotRodVersion.HOTROD_27.getVersion();
}
private void assertDataDoesNotExist(byte[] key) {
for (HotRodClient client : clients()) {
assertKeyDoesNotExist(client.get(key, 0));
}
}
private void assertData(byte[] key, byte[] value) {
for (HotRodClient client : clients()) {
assertSuccess(client.get(key, 0), value);
}
}
private void assertServerTransactionTableEmpty() {
for (Cache<?, ?> cache : caches(cacheName())) {
PerCacheTxTable perCacheTxTable = extractComponent(cache, PerCacheTxTable.class);
assertTrue(perCacheTxTable.isEmpty());
}
for (EmbeddedCacheManager cm : managers()) {
GlobalTxTable globalTxTable = extractGlobalComponent(cm, GlobalTxTable.class);
assertTrue(globalTxTable.isEmpty());
}
}
}
| 18,729
| 30.692047
| 112
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/tx/TxReaperAndRecoveryTest.java
|
package org.infinispan.server.hotrod.tx;
import static org.infinispan.test.TestingUtil.extractComponent;
import static org.infinispan.test.TestingUtil.extractGlobalComponent;
import static org.infinispan.test.TestingUtil.replaceComponent;
import static org.infinispan.test.TestingUtil.wrapComponent;
import static org.infinispan.util.ByteString.fromString;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Queue;
import java.util.Set;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Function;
import jakarta.transaction.RollbackException;
import jakarta.transaction.Synchronization;
import org.infinispan.commands.ReplicableCommand;
import org.infinispan.commands.tx.PrepareCommand;
import org.infinispan.commands.tx.RollbackCommand;
import org.infinispan.commons.time.TimeService;
import org.infinispan.commons.tx.XidImpl;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.remoting.rpc.RpcManager;
import org.infinispan.remoting.rpc.RpcOptions;
import org.infinispan.remoting.transport.Address;
import org.infinispan.remoting.transport.ResponseCollector;
import org.infinispan.server.hotrod.HotRodMultiNodeTest;
import org.infinispan.server.hotrod.counter.response.RecoveryTestResponse;
import org.infinispan.server.hotrod.test.TestResponse;
import org.infinispan.server.hotrod.tx.table.CacheXid;
import org.infinispan.server.hotrod.tx.table.ClientAddress;
import org.infinispan.server.hotrod.tx.table.GlobalTxTable;
import org.infinispan.server.hotrod.tx.table.PerCacheTxTable;
import org.infinispan.server.hotrod.tx.table.Status;
import org.infinispan.server.hotrod.tx.table.TxState;
import org.infinispan.server.hotrod.tx.table.functions.CreateStateFunction;
import org.infinispan.server.hotrod.tx.table.functions.PreparingDecisionFunction;
import org.infinispan.server.hotrod.tx.table.functions.SetCompletedTransactionFunction;
import org.infinispan.server.hotrod.tx.table.functions.SetDecisionFunction;
import org.infinispan.server.hotrod.tx.table.functions.SetPreparedFunction;
import org.infinispan.server.hotrod.tx.table.functions.TxFunction;
import org.infinispan.topology.PersistentUUID;
import org.infinispan.transaction.LockingMode;
import org.infinispan.transaction.tm.EmbeddedTransaction;
import org.infinispan.transaction.tm.EmbeddedTransactionManager;
import org.infinispan.transaction.xa.GlobalTransaction;
import org.infinispan.transaction.xa.TransactionFactory;
import org.infinispan.util.AbstractDelegatingRpcManager;
import org.infinispan.util.ControlledTimeService;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
/**
* Transaction Recovery and Reaper test.
*
* @author Pedro Ruivo
* @since 9.4
*/
@Test(groups = "functional", testName = "server.hotrod.tx.TxReaperAndRecoveryTest")
public class TxReaperAndRecoveryTest extends HotRodMultiNodeTest {
private static final AtomicInteger XID_GENERATOR = new AtomicInteger(1);
private final ControlledTimeService timeService = new ControlledTimeService();
private static XidImpl newXid() {
byte id = (byte) XID_GENERATOR.getAndIncrement();
return XidImpl.create(-123456, new byte[]{id}, new byte[]{id});
}
private static Address newAddress() {
//test address isn't serializable and we just need an address that doesn't belong to the cluster (simulates a leaver)
return PersistentUUID.randomUUID();
}
@BeforeClass(alwaysRun = true)
@Override
public void createBeforeClass() throws Throwable {
super.createBeforeClass();
ConfigurationBuilder builder = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, true);
builder.transaction().lockingMode(LockingMode.PESSIMISTIC);
for (EmbeddedCacheManager cm : cacheManagers) {
//use the same time service in all managers
replaceComponent(cm, TimeService.class, timeService, true);
//stop reaper. we are going to trigger it manually
extractGlobalComponent(cm, GlobalTxTable.class).stop();
}
}
public void testCleanup() throws InterruptedException {
XidImpl xid1 = newXid();
XidImpl xid2 = newXid();
XidImpl xid3 = newXid();
XidImpl xid4 = newXid();
//Xid1 will be committed, Xid2 will be rolled-back
initGlobalTxTable(0, xid1, null, false, Status.COMMITTED);
initGlobalTxTable(1, xid2, null, false, Status.ROLLED_BACK);
initGlobalTxTable(1, xid3, newAddress(), false, Status.COMMITTED);
initGlobalTxTable(1, xid4, newAddress(), false, Status.ROLLED_BACK);
//check pre state
assertStatus(false, false, xid1, xid2, xid3, xid4);
timeService.advance(1);
//check that state is not timeout
assertStatus(false, false, xid1, xid2, xid3, xid4);
globalTxTable(0).run();
//remove is async and it shouldn't happen
//if it happens, we will get a NPE later in the test
Thread.sleep(1000);
timeService.advance(1);
assertStatus(true, false, xid1, xid2, xid3, xid4);
//it only cleanup locally originated
//and transaction where the originator doesn't belong to the view (i.e. xid1 and xid3)
globalTxTable(0).run();
eventually(() -> checkNotExists(xid1, xid3, xid4));
assertStatus(true, false, xid2);
globalTxTable(1).run();
eventually(() -> checkNotExists(xid2));
assertTrue(globalTxTable(0).isEmpty());
}
public void testRollbackIdleTransactions() throws RollbackException {
XidImpl xid1 = newXid();
XidImpl xid2 = newXid();
XidImpl xid3 = newXid();
//xid1 active status
initGlobalTxTable(0, xid1, null, false, Status.ACTIVE);
//xid2 preparing status
initGlobalTxTable(1, xid2, null, false, Status.PREPARING);
//xid3 prepared
initGlobalTxTable(1, xid3, newAddress(), false, Status.PREPARED);
//check pre state
assertStatus(false, false, xid1, xid2, xid3);
timeService.advance(2);
assertStatus(true, false, xid1, xid2, xid3);
EmbeddedTransaction tx1 = newTx(xid1);
LoggingSynchronization sync = new LoggingSynchronization();
tx1.registerSynchronization(sync);
perCacheTxTable(0).createLocalTx(xid1, tx1);
LoggingRpcManager rpcManager0 = rpcManager();
rpcManager0.queue.clear();
globalTxTable(0).run();
//it should fetch the embedded tx and rollback it
eventually(() -> "rolled_back".equals(sync.queue.poll()));
eventually(() -> "rollback".equals(rpcManager0.queue.poll()));
eventually(() -> getState(xid1) == null);
//it doesn't remove it right away.
eventually(() -> getState(xid3).getStatus() == Status.ROLLED_BACK);
EmbeddedTransaction tx2 = newTx(xid2);
sync.queue.clear();
tx2.registerSynchronization(sync);
perCacheTxTable(1).createLocalTx(xid2, tx2);
globalTxTable(1).run();
eventually(() -> "rolled_back".equals(sync.queue.poll()));
eventually(() -> getState(xid2) == null);
assertStatus(false, false, xid3);
timeService.advance(2);
globalTxTable(0).run();
eventually(() -> globalTxTable(0).isEmpty());
}
public void testPartialCompletedTransactions() throws RollbackException {
XidImpl xid1 = newXid();
XidImpl xid2 = newXid();
XidImpl xid3 = newXid();
XidImpl xid4 = newXid();
//xid1 mark_to_commit and local
initGlobalTxTable(0, xid1, null, false, Status.MARK_COMMIT);
//xid2 mark_to_rollback and remote
initGlobalTxTable(1, xid2, null, false, Status.MARK_ROLLBACK);
//xid3 mark_to_commit and leaver
initGlobalTxTable(1, xid3, newAddress(), false, Status.MARK_COMMIT);
//xid4 mark_to_commit and leaver
initGlobalTxTable(1, xid4, newAddress(), false, Status.MARK_ROLLBACK);
//check pre state
assertStatus(false, false, xid1, xid2, xid3, xid4);
timeService.advance(2);
assertStatus(true, false, xid1, xid2, xid3, xid4);
EmbeddedTransaction tx1 = newTx(xid1);
LoggingSynchronization sync = new LoggingSynchronization();
tx1.registerSynchronization(sync);
perCacheTxTable(0).createLocalTx(xid1, tx1);
LoggingRpcManager rpcManager0 = rpcManager();
rpcManager0.queue.clear();
globalTxTable(0).run();
//it should fetch the embedded tx and rollback it
eventually(() -> "committed".equals(sync.queue.poll()));
//we don't know the order of the operations
eventuallyEquals(2, rpcManager0.queue::size);
Set<String> actual = new HashSet<>(rpcManager0.queue);
Set<String> expected = new HashSet<>(Arrays.asList("rollback", "prepare"));
assertEquals(actual, expected);
eventually(() -> getState(xid1) == null);
//it doesn't remove it right away.
eventually(() -> getState(xid3).getStatus() == Status.COMMITTED);
eventually(() -> getState(xid4).getStatus() == Status.ROLLED_BACK);
EmbeddedTransaction tx2 = newTx(xid2);
sync.queue.clear();
tx2.registerSynchronization(sync);
perCacheTxTable(1).createLocalTx(xid2, tx2);
globalTxTable(1).run();
eventually(() -> "rolled_back".equals(sync.queue.poll()));
eventually(() -> getState(xid2) == null);
assertStatus(false, false, xid3, xid4);
timeService.advance(2);
globalTxTable(0).run();
eventually(() -> globalTxTable(0).isEmpty());
}
public void testRecovery() {
XidImpl xid1 = newXid();
XidImpl xid2 = newXid();
XidImpl xid3 = newXid();
XidImpl xid4 = newXid();
//xid1 local and prepared
initGlobalTxTable(0, xid1, null, true, Status.PREPARED);
//xid2 remote and prepared
initGlobalTxTable(1, xid2, null, true, Status.PREPARED);
//xid3 non-member and prepared
initGlobalTxTable(1, xid3, newAddress(), true, Status.PREPARED);
//xid4 non-member and preparing
initGlobalTxTable(1, xid4, newAddress(), false, Status.PREPARING);
assertStatus(false, true, xid1, xid2, xid3);
assertStatus(false, false, xid4);
timeService.advance(2);
assertStatus(true, true, xid1, xid2, xid3);
assertStatus(true, false, xid4);
//only xid4 should have make progress
globalTxTable(0).run();
eventually(() -> getState(xid4).getStatus() == Status.ROLLED_BACK);
assertEquals(Status.PREPARED, getState(xid1).getStatus());
assertEquals(Status.PREPARED, getState(xid2).getStatus());
assertEquals(Status.PREPARED, getState(xid3).getStatus());
Set<XidImpl> actual = new HashSet<>(globalTxTable(0).getPreparedTransactions());
Set<XidImpl> expected = new HashSet<>(Arrays.asList(xid1, xid2, xid3));
assertEquals(expected, actual);
assertStatus(true, true, xid1, xid2, xid3);
timeService.advance(2);
globalTxTable(0).run();
eventually(() -> getState(xid4) == null);
assertEquals(Status.PREPARED, getState(xid1).getStatus());
assertEquals(Status.PREPARED, getState(xid2).getStatus());
assertEquals(Status.PREPARED, getState(xid3).getStatus());
TestResponse response = clients().get(0).recovery();
assertTrue(response instanceof RecoveryTestResponse);
actual = new HashSet<>(((RecoveryTestResponse) response).getXids());
assertEquals(expected, actual);
for (XidImpl xid : expected) {
clients().get(0).rollbackTx(xid);
clients().get(0).forgetTx(xid);
}
assertTrue(globalTxTable(0).isEmpty());
}
@Override
protected String cacheName() {
return "tx-reaper-and-recovery";
}
@Override
protected ConfigurationBuilder createCacheConfig() {
//TODO optimistic (when it is supported)
ConfigurationBuilder builder = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, true);
builder.transaction().lockingMode(LockingMode.PESSIMISTIC);
return builder;
}
private TxState getState(XidImpl xid) {
return globalTxTable(0).getState(new CacheXid(fromString(cacheName()), xid));
}
private void initGlobalTxTable(int index, XidImpl xid, Address address, boolean recoverable, Status status) {
GlobalTxTable globalTxTable = globalTxTable(index);
CacheXid cacheXid = new CacheXid(fromString(cacheName()), xid);
List<TxFunction> functions = new ArrayList<>(5);
GlobalTransaction gtx = address == null ?
newGlobalTransaction(cacheName(), index) :
newGlobalTransaction(cacheName(), index, address);
switch (status) {
case ACTIVE:
functions.add(new CreateStateFunction(gtx, recoverable, 1));
break;
case PREPARING:
functions.add(new CreateStateFunction(gtx, recoverable, 1));
functions.add(new PreparingDecisionFunction(Collections.emptyList()));
break;
case PREPARED:
functions.add(new CreateStateFunction(gtx, recoverable, 1));
functions.add(new PreparingDecisionFunction(Collections.emptyList()));
functions.add(new SetPreparedFunction());
break;
case MARK_ROLLBACK:
functions.add(new CreateStateFunction(gtx, recoverable, 1));
functions.add(new PreparingDecisionFunction(Collections.emptyList()));
functions.add(new SetPreparedFunction());
functions.add(new SetDecisionFunction(false));
break;
case MARK_COMMIT:
functions.add(new CreateStateFunction(gtx, recoverable, 1));
functions.add(new PreparingDecisionFunction(Collections.emptyList()));
functions.add(new SetPreparedFunction());
functions.add(new SetDecisionFunction(true));
break;
case ROLLED_BACK:
functions.add(new CreateStateFunction(gtx, recoverable, 1));
functions.add(new PreparingDecisionFunction(Collections.emptyList()));
functions.add(new SetPreparedFunction());
functions.add(new SetDecisionFunction(false));
functions.add(new SetCompletedTransactionFunction(false));
break;
case COMMITTED:
functions.add(new CreateStateFunction(gtx, recoverable, 1));
functions.add(new PreparingDecisionFunction(Collections.emptyList()));
functions.add(new SetPreparedFunction());
functions.add(new SetDecisionFunction(true));
functions.add(new SetCompletedTransactionFunction(true));
break;
default:
throw new IllegalStateException();
}
for (TxFunction function : functions) {
assertEquals(Status.OK, globalTxTable.update(cacheXid, function, 30000));
}
assertEquals(status, globalTxTable.getState(cacheXid).getStatus());
}
private PerCacheTxTable perCacheTxTable(int index) {
return extractComponent(cache(index, cacheName()), PerCacheTxTable.class);
}
private EmbeddedTransaction newTx(XidImpl xid) {
EmbeddedTransaction tx = new EmbeddedTransaction(EmbeddedTransactionManager.getInstance());
tx.setXid(xid);
return tx;
}
private LoggingRpcManager rpcManager() {
RpcManager rpcManager = extractComponent(cache(0, cacheName()), RpcManager.class);
if (rpcManager instanceof LoggingRpcManager) {
return (LoggingRpcManager) rpcManager;
}
return wrapComponent(cache(0, cacheName()), RpcManager.class, LoggingRpcManager::new);
}
private boolean checkNotExists(XidImpl... xids) {
for (XidImpl xid : xids) {
CacheXid cacheXid = new CacheXid(fromString(cacheName()), xid);
if (globalTxTable(0).getState(cacheXid) != null) {
return false;
}
}
return true;
}
private void assertStatus(boolean timeout, boolean recoverable, XidImpl... xids) {
GlobalTxTable globalTxTable = globalTxTable(0);
for (XidImpl xid : xids) {
CacheXid cacheXid = new CacheXid(fromString(cacheName()), xid);
TxState state = globalTxTable.getState(cacheXid);
assertEquals(recoverable, state.isRecoverable());
assertEquals(timeout, state.hasTimedOut(timeService.time()));
}
}
private GlobalTxTable globalTxTable(int index) {
return extractGlobalComponent(cacheManagers.get(index), GlobalTxTable.class);
}
private GlobalTransaction newGlobalTransaction(String cacheName, int index) {
return newGlobalTransaction(cacheName, index, address(index));
}
private GlobalTransaction newGlobalTransaction(String cacheName, int index, Address address) {
TransactionFactory factory = extractComponent(cache(index, cacheName), TransactionFactory.class);
return factory.newGlobalTransaction(new ClientAddress(address), false);
}
private static class LoggingSynchronization implements Synchronization {
private final Queue<String> queue = new LinkedBlockingQueue<>();
@Override
public void beforeCompletion() {
queue.add("before");
}
@Override
public void afterCompletion(int status) {
if (status == jakarta.transaction.Status.STATUS_COMMITTED) {
queue.add("committed");
} else {
queue.add("rolled_back");
}
}
}
private static class LoggingRpcManager extends AbstractDelegatingRpcManager {
private final Queue<String> queue = new LinkedBlockingQueue<>();
private LoggingRpcManager(RpcManager realOne) {
super(realOne);
}
@Override
protected <T> CompletionStage<T> performRequest(Collection<Address> targets, ReplicableCommand command,
ResponseCollector<T> collector,
Function<ResponseCollector<T>, CompletionStage<T>> invoker,
RpcOptions rpcOptions) {
if (command instanceof RollbackCommand) {
queue.add("rollback");
} else if (command instanceof PrepareCommand) {
queue.add("prepare");
}
return super.performRequest(targets, command, collector, invoker, rpcOptions);
}
}
}
| 18,695
| 37.233129
| 123
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/tx/TopologyChangeFunctionalTest.java
|
package org.infinispan.server.hotrod.tx;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertSuccess;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.killClient;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import static org.infinispan.test.TestingUtil.extractComponent;
import static org.infinispan.test.TestingUtil.extractGlobalComponent;
import static org.testng.AssertJUnit.assertTrue;
import java.lang.reflect.Method;
import java.util.Arrays;
import javax.transaction.xa.XAResource;
import org.infinispan.Cache;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.hotrod.HotRodMultiNodeTest;
import org.infinispan.server.hotrod.HotRodServer;
import org.infinispan.server.hotrod.HotRodVersion;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.server.hotrod.test.HotRodTestingUtil;
import org.infinispan.server.hotrod.test.RemoteTransaction;
import org.infinispan.server.hotrod.tx.table.CacheXid;
import org.infinispan.server.hotrod.tx.table.GlobalTxTable;
import org.infinispan.server.hotrod.tx.table.PerCacheTxTable;
import org.infinispan.server.hotrod.tx.table.TxState;
import org.infinispan.server.hotrod.tx.table.functions.CreateStateFunction;
import org.infinispan.server.hotrod.tx.table.functions.TxFunction;
import org.infinispan.transaction.LockingMode;
import org.infinispan.transaction.TransactionMode;
import org.infinispan.util.ByteString;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* Functional test for transaction involved topology changes.
*
* @author Pedro Ruivo
* @since 9.1
*/
@Test(groups = "functional", testName = "server.hotrod.tx.TopologyChangeFunctionalTest")
public class TopologyChangeFunctionalTest extends HotRodMultiNodeTest {
private org.infinispan.configuration.cache.TransactionMode transactionMode;
@Override
public Object[] factory() {
return Arrays.stream(org.infinispan.configuration.cache.TransactionMode.values())
.filter(tMode -> tMode != org.infinispan.configuration.cache.TransactionMode.NONE)
.flatMap(txMode -> Arrays.stream(LockingMode.values())
.map(lockingMode -> new TopologyChangeFunctionalTest()
.transactionMode(txMode)
.lockingMode(lockingMode)))
.toArray();
}
public TopologyChangeFunctionalTest transactionMode(
org.infinispan.configuration.cache.TransactionMode transactionMode) {
this.transactionMode = transactionMode;
return this;
}
public void testNonOriginatorLeft(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.set(k1, v1);
tx.set(k2, v2);
tx.getAndAssert(k1, v1);
tx.getAndAssert(k2, v2);
tx.prepareAndAssert(XAResource.XA_OK);
killNode(1);
tx.commitAndAssert(XAResource.XA_OK);
tx.forget();
assertData(k1, v1);
assertData(k2, v2);
assertServerTransactionTableEmpty();
}
public void testNodeJoin(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.set(k1, v1);
tx.set(k2, v2);
tx.getAndAssert(k1, v1);
tx.getAndAssert(k2, v2);
tx.prepareAndAssert(XAResource.XA_OK);
addNewNode();
tx.commitAndAssert(XAResource.XA_OK);
tx.forget();
assertData(k1, v1);
assertData(k2, v2);
assertServerTransactionTableEmpty();
}
@Test(groups = "unstable", description = "ISPN-8432")
public void testOriginatorLeft(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.set(k1, v1);
tx.set(k2, v2);
tx.getAndAssert(k1, v1);
tx.getAndAssert(k2, v2);
tx.prepareAndAssert(XAResource.XA_OK);
killNode(0);
//index 0 is removed, index 0 is the old index 1
tx.commitAndAssert(clients().get(0), XAResource.XA_OK);
tx.forget(clients().get(0));
assertData(k1, v1);
assertData(k2, v2);
assertServerTransactionTableEmpty();
}
public void testOriginatorLeftBeforePrepare(Method method) {
final byte[] k1 = k(method, "k1");
final byte[] k2 = k(method, "k2");
final byte[] v1 = v(method, "v1");
final byte[] v2 = v(method, "v2");
RemoteTransaction tx = RemoteTransaction.startTransaction(clients().get(0));
tx.set(k1, v1);
tx.set(k2, v2);
tx.getAndAssert(k1, v1);
tx.getAndAssert(k2, v2);
tx.prepareAndAssert(XAResource.XA_OK);
killNode(0);
//set the tx state to running
GlobalTxTable transactionTable = extractGlobalComponent(manager(0), GlobalTxTable.class);
CacheXid cacheXid = new CacheXid(ByteString.fromString(cacheName()), tx.getXid());
TxState state = transactionTable.getState(cacheXid);
transactionTable.remove(cacheXid);
TxFunction function = new CreateStateFunction(state.getGlobalTransaction(), false, 60000);
transactionTable.update(cacheXid, function, 60000);
//index 0 is removed, index 0 is the old index 1
tx.prepareAndAssert(clients().get(0), XAResource.XA_OK);
tx.commitAndAssert(clients().get(0), XAResource.XA_OK);
tx.forget(clients().get(0));
assertData(k1, v1);
assertData(k2, v2);
assertServerTransactionTableEmpty();
}
@Override
protected byte protocolVersion() {
return HotRodVersion.HOTROD_27.getVersion();
}
@Override
protected String cacheName() {
return "topology-change-tx-cache";
}
@Override
protected String parameters() {
return "[" + lockingMode + "/" + transactionMode + "]";
}
@Override
protected ConfigurationBuilder createCacheConfig() {
ConfigurationBuilder builder = hotRodCacheConfiguration();
builder.transaction().transactionMode(TransactionMode.TRANSACTIONAL);
builder.transaction().lockingMode(lockingMode);
switch (transactionMode) {
case NON_XA:
builder.transaction().useSynchronization(true);
break;
case NON_DURABLE_XA:
builder.transaction().useSynchronization(false);
builder.transaction().recovery().disable();
break;
case FULL_XA:
builder.transaction().useSynchronization(false);
builder.transaction().recovery().enable();
break;
default:
throw new IllegalStateException();
}
builder.clustering().hash().numOwners(2);
builder.clustering().cacheMode(CacheMode.DIST_SYNC);
return builder;
}
@Override
protected int nodeCount() {
return 3;
}
@BeforeMethod(alwaysRun = true)
private void checkNumberOfNodes() {
while (servers().size() > nodeCount()) {
killNode(servers().size() - 1);
}
while (servers().size() < nodeCount()) {
addNewNode();
}
}
private void addNewNode() {
int nextServerPort = findHighestPort().orElseGet(HotRodTestingUtil::serverPort);
nextServerPort += 50;
HotRodServer server = startClusteredServer(nextServerPort); //it waits for view
servers().add(server);
clients().add(createClient(server, cacheName()));
}
private void assertData(byte[] key, byte[] value) {
for (HotRodClient client : clients()) {
assertSuccess(client.get(key, 0), value);
}
}
private void assertServerTransactionTableEmpty() {
for (Cache<?, ?> cache : caches(cacheName())) {
PerCacheTxTable perCacheTxTable = extractComponent(cache, PerCacheTxTable.class);
assertTrue(perCacheTxTable.isEmpty());
}
for (EmbeddedCacheManager cm : managers()) {
GlobalTxTable globalTxTable = extractGlobalComponent(cm, GlobalTxTable.class);
assertTrue(globalTxTable.isEmpty());
}
}
private void killNode(int index) {
killClient(clients().remove(index));
stopClusteredServer(servers().remove(index));
}
}
| 8,880
| 33.02682
| 96
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/tx/ServerConfigurationTest.java
|
package org.infinispan.server.hotrod.tx;
import static org.infinispan.test.TestingUtil.extractComponent;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import java.util.Collections;
import javax.transaction.xa.XAException;
import javax.transaction.xa.XAResource;
import org.infinispan.Cache;
import org.infinispan.commons.tx.XidImpl;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.server.hotrod.HotRodMultiNodeTest;
import org.infinispan.server.hotrod.HotRodVersion;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.server.hotrod.test.HotRodTestingUtil;
import org.infinispan.server.hotrod.test.TestErrorResponse;
import org.infinispan.server.hotrod.test.TxResponse;
import org.infinispan.server.hotrod.tx.table.PerCacheTxTable;
import org.infinispan.transaction.LockingMode;
import org.infinispan.transaction.TransactionMode;
import org.infinispan.util.concurrent.IsolationLevel;
import org.testng.annotations.Test;
/**
* Tests for valid and invalid configurations.
*
* @author Pedro Ruivo
* @since 9.2
*/
@Test(groups = "functional", testName = "server.hotrod.tx.ServerConfigurationTest")
public class ServerConfigurationTest extends HotRodMultiNodeTest {
public void testNonTransactionalConfiguration() {
final String cacheName = "non_tx_cache";
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.transaction().transactionMode(TransactionMode.NON_TRANSACTIONAL);
doWrongConfigurationTest(cacheName, builder,
"java.lang.IllegalStateException: ISPN006020: Cache 'non_tx_cache' is not transactional to execute a client transaction");
}
public void testWrongIsolationLevel() {
final String cacheName = "wrong_isolation_cache";
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.transaction().transactionMode(TransactionMode.TRANSACTIONAL);
builder.locking().isolationLevel(IsolationLevel.READ_COMMITTED);
builder.transaction().lockingMode(LockingMode.PESSIMISTIC);
doWrongConfigurationTest(cacheName, builder,
"java.lang.IllegalStateException: ISPN006021: Cache 'wrong_isolation_cache' must have REPEATABLE_READ isolation level");
}
public void testSynchronizationMode() {
final String cacheName = "sync_cache";
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.transaction().transactionMode(TransactionMode.TRANSACTIONAL);
builder.transaction().useSynchronization(true);
builder.transaction().lockingMode(LockingMode.PESSIMISTIC);
doCorrectConfigurationTest(cacheName, builder);
}
public void testXa() {
final String cacheName = "xa_cache";
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.transaction().transactionMode(TransactionMode.TRANSACTIONAL);
builder.transaction().useSynchronization(false);
builder.transaction().lockingMode(LockingMode.PESSIMISTIC);
doCorrectConfigurationTest(cacheName, builder);
}
public void testFullXa() {
final String cacheName = "full_xa_cache";
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.transaction().transactionMode(TransactionMode.TRANSACTIONAL);
builder.transaction().useSynchronization(false);
builder.transaction().recovery().enable();
builder.transaction().lockingMode(LockingMode.PESSIMISTIC);
doCorrectConfigurationTest(cacheName, builder);
}
public void testOptimisticConfiguration() {
final String cacheName = "opt-cache";
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.transaction().transactionMode(TransactionMode.TRANSACTIONAL);
builder.transaction().lockingMode(LockingMode.OPTIMISTIC);
doCorrectConfigurationTest(cacheName, builder);
}
@Override
protected String cacheName() {
return "default";
}
@Override
protected ConfigurationBuilder createCacheConfig() {
return new ConfigurationBuilder();
}
@Override
protected byte protocolVersion() {
return HotRodVersion.HOTROD_27.getVersion();
}
private void doWrongConfigurationTest(String cacheName, ConfigurationBuilder builder, String errorMsg) {
cacheManagers.forEach(cm -> cm.defineConfiguration(cacheName, builder.build()));
waitForClusterToForm(cacheName);
HotRodClient client = createClient(cacheName);
XidImpl xid = XidImpl.create(-1, new byte[]{2}, new byte[]{3});
try {
TestErrorResponse response = (TestErrorResponse) client.prepareTx(xid, false, Collections.emptyList());
assertEquals(errorMsg, response.msg);
TxResponse response2 = (TxResponse) client.commitTx(xid);
assertEquals(XAException.XAER_NOTA, response2.xaCode);
response2 = (TxResponse) client.rollbackTx(xid);
assertEquals(XAException.XAER_NOTA, response2.xaCode);
assertServerTransactionTableEmpty(cacheName);
} finally {
HotRodTestingUtil.killClient(client);
}
}
private void doCorrectConfigurationTest(String cacheName, ConfigurationBuilder builder) {
cacheManagers.forEach(cm -> cm.defineConfiguration(cacheName, builder.build()));
waitForClusterToForm(cacheName);
HotRodClient client = createClient(cacheName);
XidImpl xid = XidImpl.create(-1, new byte[]{2}, new byte[]{3});
try {
TxResponse response = (TxResponse) client.prepareTx(xid, false, Collections.emptyList());
assertEquals(XAResource.XA_RDONLY, response.xaCode);
response = (TxResponse) client.commitTx(xid);
assertEquals(XAException.XAER_NOTA, response.xaCode);
response = (TxResponse) client.rollbackTx(xid);
assertEquals(XAException.XAER_NOTA, response.xaCode);
assertServerTransactionTableEmpty(cacheName);
} finally {
HotRodTestingUtil.killClient(client);
}
}
private void assertServerTransactionTableEmpty(String cacheName) {
for (Cache<?, ?> cache : caches(cacheName)) {
if (cache.getCacheConfiguration().transaction().transactionMode().isTransactional()) {
PerCacheTxTable perCacheTxTable = extractComponent(cache, PerCacheTxTable.class);
assertTrue(perCacheTxTable.isEmpty());
}
}
}
private HotRodClient createClient(String cacheName) {
return new HotRodClient("127.0.0.1", servers().get(0).getPort(), cacheName, protocolVersion());
}
}
| 6,558
| 41.316129
| 134
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/event/HotRodFilterEventsTest.java
|
package org.infinispan.server.hotrod.event;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.startHotRodServer;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.withClientListener;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Collections;
import java.util.Optional;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.notifications.cachelistener.event.Event;
import org.infinispan.notifications.cachelistener.filter.CacheEventFilter;
import org.infinispan.notifications.cachelistener.filter.CacheEventFilterFactory;
import org.infinispan.server.hotrod.HotRodServer;
import org.infinispan.server.hotrod.HotRodSingleNodeTest;
import org.infinispan.util.KeyValuePair;
import org.testng.annotations.Test;
/**
* @author Galder Zamarreño
*/
@Test(groups = "functional", testName = "server.hotrod.event.HotRodFilterEventsTest")
public class HotRodFilterEventsTest extends HotRodSingleNodeTest {
@Override
protected HotRodServer createStartHotRodServer(EmbeddedCacheManager cacheManager) {
HotRodServer server = startHotRodServer(cacheManager);
server.addCacheEventFilterFactory("static-filter-factory", new StaticKeyValueFilterFactory(new byte[]{1, 2, 3}));
server.addCacheEventFilterFactory("dynamic-filter-factory", new DynamicKeyValueFilterFactory());
return server;
}
public void testFilteredEvents(Method m) {
EventLogListener eventListener = new EventLogListener();
byte[] acceptedKey = new byte[]{1, 2, 3};
withClientListener(client(), eventListener, Optional.of(
new KeyValuePair<>("static-filter-factory", Collections.emptyList())), Optional.empty(), () -> {
eventListener.expectNoEvents(Optional.empty());
byte[] key = k(m);
client().remove(key);
eventListener.expectNoEvents(Optional.empty());
client().put(key, 0, 0, v(m));
eventListener.expectNoEvents(Optional.empty());
client().put(acceptedKey, 0, 0, v(m));
eventListener.expectSingleEvent(cache, acceptedKey, Event.Type.CACHE_ENTRY_CREATED);
client().put(acceptedKey, 0, 0, v(m, "v2-"));
eventListener.expectSingleEvent(cache, acceptedKey, Event.Type.CACHE_ENTRY_MODIFIED);
client().remove(key);
eventListener.expectNoEvents(Optional.empty());
client().remove(acceptedKey);
eventListener.expectSingleEvent(cache, acceptedKey, Event.Type.CACHE_ENTRY_REMOVED);
});
}
public void testParameterBasedFiltering(Method m) {
EventLogListener eventListener = new EventLogListener();
byte[] acceptedKey = new byte[]{4, 5, 6};
withClientListener(client(), eventListener, Optional.of(
new KeyValuePair<>("dynamic-filter-factory", Collections.singletonList(new byte[]{4, 5, 6}))),
Optional.empty(), () -> {
eventListener.expectNoEvents(Optional.empty());
byte[] key = k(m);
client().put(key, 0, 0, v(m));
eventListener.expectNoEvents(Optional.empty());
client().put(acceptedKey, 0, 0, v(m));
eventListener.expectSingleEvent(cache, acceptedKey, Event.Type.CACHE_ENTRY_CREATED);
client().put(acceptedKey, 0, 0, v(m, "v2-"));
eventListener.expectSingleEvent(cache, acceptedKey, Event.Type.CACHE_ENTRY_MODIFIED);
client().remove(key);
eventListener.expectNoEvents(Optional.empty());
client().remove(acceptedKey);
eventListener.expectSingleEvent(cache, acceptedKey, Event.Type.CACHE_ENTRY_REMOVED);
});
}
public void testFilteredEventsReplay(Method m) {
EventLogListener eventListener = new EventLogListener();
byte[] staticAcceptedKey = new byte[]{1, 2, 3};
byte[] dynamicAcceptedKey = new byte[]{7, 8, 9};
byte[] key = k(m);
client().put(key, 0, 0, v(m));
client().put(staticAcceptedKey, 0, 0, v(m));
client().put(dynamicAcceptedKey, 0, 0, v(m));
withClientListener(client(), eventListener, Optional.of(
new KeyValuePair<>("static-filter-factory", Collections.emptyList())), Optional.empty(), true, true, () -> {
eventListener.expectSingleEvent(cache, staticAcceptedKey, Event.Type.CACHE_ENTRY_CREATED);
});
withClientListener(client(), eventListener, Optional.of(
new KeyValuePair<>("dynamic-filter-factory", Collections.singletonList(new byte[]{7, 8, 9}))),
Optional.empty(), true, true, () -> {
eventListener.expectSingleEvent(cache, dynamicAcceptedKey, Event.Type.CACHE_ENTRY_CREATED);
});
}
public void testFilteredEventsNoReplay(Method m) {
EventLogListener eventListener = new EventLogListener();
byte[] staticAcceptedKey = new byte[]{1, 2, 3};
byte[] dynamicAcceptedKey = new byte[]{7, 8, 9};
byte[] key = k(m);
client().put(key, 0, 0, v(m));
client().put(staticAcceptedKey, 0, 0, v(m));
client().put(dynamicAcceptedKey, 0, 0, v(m));
withClientListener(client(), eventListener, Optional.of(
new KeyValuePair<>("static-filter-factory", Collections.emptyList())), Optional.empty(), false, true,
() -> {
eventListener.expectNoEvents(Optional.empty());
});
withClientListener(client(), eventListener, Optional.of(
new KeyValuePair<>("dynamic-filter-factory", Collections.singletonList(new byte[]{7, 8, 9}))),
Optional.empty(), false, true, () -> {
eventListener.expectNoEvents(Optional.empty());
});
}
static class StaticKeyValueFilterFactory implements CacheEventFilterFactory {
private byte[] staticKey;
StaticKeyValueFilterFactory(byte[] staticKey) {
this.staticKey = staticKey;
}
@Override
public <K, V> CacheEventFilter<K, V> getFilter(Object[] params) {
return (key, prevValue, prevMetadata, value, metadata, eventType) -> Arrays.equals(((byte[]) key), staticKey);
}
}
static class DynamicKeyValueFilterFactory implements CacheEventFilterFactory {
@Override
public <K, V> CacheEventFilter<K, V> getFilter(Object[] params) {
return (key, oldValue, oldMetadata, newValue, newMetadata, eventType) -> {
byte[] acceptedKey = (byte[]) params[0];
return Arrays.equals(((byte[]) key), acceptedKey);
};
}
}
}
| 6,737
| 46.787234
| 120
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/event/HotRodEventsTest.java
|
package org.infinispan.server.hotrod.event;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertSuccess;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.withClientListener;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import org.infinispan.notifications.cachelistener.event.Event;
import org.infinispan.server.hotrod.HotRodSingleNodeTest;
import org.infinispan.server.hotrod.test.TestGetWithVersionResponse;
import org.testng.annotations.Test;
/**
* @author Galder Zamarreño
*/
@Test(groups = "functional", testName = "server.hotrod.event.HotRodEventsTest")
public class HotRodEventsTest extends HotRodSingleNodeTest {
public void testCreatedEvent(Method m) {
EventLogListener eventListener = new EventLogListener();
withClientListener(client(), eventListener, Optional.empty(), Optional.empty(), () -> {
eventListener.expectNoEvents(Optional.empty());
byte[] key = k(m);
client().put(key, 0, 0, v(m));
eventListener.expectOnlyCreatedEvent(cache, key);
});
}
public void testModifiedEvent(Method m) {
EventLogListener eventListener = new EventLogListener();
withClientListener(client(), eventListener, Optional.empty(), Optional.empty(), () -> {
eventListener.expectNoEvents(Optional.empty());
byte[] key = k(m);
client().put(key, 0, 0, v(m));
eventListener.expectOnlyCreatedEvent(cache, key);
client().put(key, 0, 0, v(m, "v2-"));
eventListener.expectOnlyModifiedEvent(cache, key);
});
}
public void testRemovedEvent(Method m) {
EventLogListener eventListener = new EventLogListener();
withClientListener(client(), eventListener, Optional.empty(), Optional.empty(), () -> {
eventListener.expectNoEvents(Optional.empty());
byte[] key = k(m);
client().remove(key);
eventListener.expectNoEvents(Optional.empty());
client().put(key, 0, 0, v(m));
eventListener.expectOnlyCreatedEvent(cache, key);
client().remove(key);
eventListener.expectOnlyRemovedEvent(cache, key);
});
}
public void testReplaceEvents(Method m) {
EventLogListener eventListener = new EventLogListener();
withClientListener(client(), eventListener, Optional.empty(), Optional.empty(), () -> {
eventListener.expectNoEvents(Optional.empty());
byte[] key = k(m);
client().replace(key, 0, 0, v(m));
eventListener.expectNoEvents(Optional.empty());
client().put(key, 0, 0, v(m));
eventListener.expectOnlyCreatedEvent(cache, key);
client().replace(key, 0, 0, v(m, "v2-"));
eventListener.expectOnlyModifiedEvent(cache, key);
});
}
public void testPutIfAbsentEvents(Method m) {
EventLogListener eventListener = new EventLogListener();
withClientListener(client(), eventListener, Optional.empty(), Optional.empty(), () -> {
eventListener.expectNoEvents(Optional.empty());
byte[] key = k(m);
client().putIfAbsent(key, 0, 0, v(m));
eventListener.expectOnlyCreatedEvent(cache, key);
client().putIfAbsent(key, 0, 0, v(m, "v2-"));
eventListener.expectNoEvents(Optional.empty());
});
}
public void testReplaceIfUnmodifiedEvents(Method m) {
EventLogListener eventListener = new EventLogListener();
withClientListener(client(), eventListener, Optional.empty(), Optional.empty(), () -> {
eventListener.expectNoEvents(Optional.empty());
byte[] key = k(m);
client().replaceIfUnmodified(key, 0, 0, v(m), 0);
eventListener.expectNoEvents(Optional.empty());
client().put(key, 0, 0, v(m));
eventListener.expectOnlyCreatedEvent(cache, key);
client().replaceIfUnmodified(key, 0, 0, v(m), 0);
eventListener.expectNoEvents(Optional.empty());
TestGetWithVersionResponse resp = client().getWithVersion(k(m), 0);
assertSuccess(resp, v(m), 0);
client().replaceIfUnmodified(k(m), 0, 0, v(m, "v1-"), resp.dataVersion);
eventListener.expectOnlyModifiedEvent(cache, key);
});
}
public void testRemoveIfUnmodifiedEvents(Method m) {
EventLogListener eventListener = new EventLogListener();
withClientListener(client(), eventListener, Optional.empty(), Optional.empty(), () -> {
eventListener.expectNoEvents(Optional.empty());
byte[] key = k(m);
client().removeIfUnmodified(key, 0, 0, v(m), 0);
eventListener.expectNoEvents(Optional.empty());
client().put(key, 0, 0, v(m));
eventListener.expectOnlyCreatedEvent(cache, key);
client().removeIfUnmodified(key, 0, 0, v(m), 0);
eventListener.expectNoEvents(Optional.empty());
TestGetWithVersionResponse resp = client().getWithVersion(k(m), 0);
assertSuccess(resp, v(m), 0);
client().removeIfUnmodified(k(m), 0, 0, v(m, "v1-"), resp.dataVersion);
eventListener.expectOnlyRemovedEvent(cache, key);
});
}
public void testClearEvents(Method m) {
EventLogListener eventListener = new EventLogListener();
withClientListener(client(), eventListener, Optional.empty(), Optional.empty(), () -> {
eventListener.expectNoEvents(Optional.empty());
byte[] key1 = k(m, "k1");
byte[] key2 = k(m, "k2");
byte[] key3 = k(m, "k3");
client().put(key1, 0, 0, v(m));
eventListener.expectOnlyCreatedEvent(cache, key1);
client().put(key2, 0, 0, v(m));
eventListener.expectOnlyCreatedEvent(cache, key2);
client().put(key3, 0, 0, v(m));
eventListener.expectOnlyCreatedEvent(cache, key3);
client().clear();
// Order in which clear operates cannot be guaranteed
List<byte[]> keys = Arrays.asList(key1, key2, key3);
eventListener.expectUnorderedEvents(cache, keys, Event.Type.CACHE_ENTRY_REMOVED);
});
}
public void testNoEventsBeforeAddingListener(Method m) {
EventLogListener eventListener = new EventLogListener();
byte[] key = k(m);
client().put(key, 0, 0, v(m));
eventListener.expectNoEvents(Optional.empty());
client().put(key, 0, 0, v(m, "v2-"));
eventListener.expectNoEvents(Optional.empty());
client().remove(key);
withClientListener(client(), eventListener, Optional.empty(), Optional.empty(), () -> {
byte[] key2 = k(m, "k2-");
client().put(key2, 0, 0, v(m));
eventListener.expectSingleEvent(cache, key2, Event.Type.CACHE_ENTRY_CREATED);
client().put(key2, 0, 0, v(m, "v2-"));
eventListener.expectSingleEvent(cache, key2, Event.Type.CACHE_ENTRY_MODIFIED);
client().remove(key2);
eventListener.expectSingleEvent(cache, key2, Event.Type.CACHE_ENTRY_REMOVED);
});
}
public void testNoEventsAfterRemovingListener(Method m) {
EventLogListener eventListener = new EventLogListener();
withClientListener(client(), eventListener, Optional.empty(), Optional.empty(), () -> {
byte[] key = k(m);
client().put(key, 0, 0, v(m));
eventListener.expectSingleEvent(cache, key, Event.Type.CACHE_ENTRY_CREATED);
client().put(key, 0, 0, v(m, "v2-"));
eventListener.expectSingleEvent(cache, key, Event.Type.CACHE_ENTRY_MODIFIED);
client().remove(key);
eventListener.expectSingleEvent(cache, key, Event.Type.CACHE_ENTRY_REMOVED);
});
byte[] key = k(m, "k2-");
client().put(key, 0, 0, v(m));
eventListener.expectNoEvents(Optional.empty());
client().put(key, 0, 0, v(m, "v2-"));
eventListener.expectNoEvents(Optional.empty());
client().remove(key);
eventListener.expectNoEvents(Optional.empty());
}
public void testEventReplayAfterAddingListener(Method m) {
EventLogListener eventListener = new EventLogListener();
byte[] k1 = k(m, "k1-");
byte[] v1 = v(m, "v1-");
byte[] k2 = k(m, "k2-");
byte[] v2 = v(m, "v2-");
byte[] k3 = k(m, "k3-");
byte[] v3 = v(m, "v3-");
client().put(k1, 0, 0, v1);
client().put(k2, 0, 0, v2);
client().put(k3, 0, 0, v3);
withClientListener(client(), eventListener, Optional.empty(), Optional.empty(), true, true, () -> {
eventListener.expectUnorderedEvents(cache, Arrays.asList(k1, k2, k3), Event.Type.CACHE_ENTRY_CREATED);
});
}
}
| 8,706
| 42.974747
| 111
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/event/AbstractHotRodClusterEventsTest.java
|
package org.infinispan.server.hotrod.event;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertStatus;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.withClientListener;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import org.infinispan.Cache;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.notifications.cachelistener.event.Event;
import org.infinispan.notifications.cachelistener.filter.CacheEventConverter;
import org.infinispan.notifications.cachelistener.filter.CacheEventConverterFactory;
import org.infinispan.notifications.cachelistener.filter.CacheEventFilter;
import org.infinispan.notifications.cachelistener.filter.CacheEventFilterFactory;
import org.infinispan.protostream.SerializationContextInitializer;
import org.infinispan.protostream.annotations.AutoProtoSchemaBuilder;
import org.infinispan.protostream.annotations.ProtoField;
import org.infinispan.server.hotrod.HotRodMultiNodeTest;
import org.infinispan.server.hotrod.HotRodServer;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.server.hotrod.test.HotRodTestingUtil;
import org.infinispan.server.hotrod.test.TestClientListener;
import org.infinispan.server.hotrod.test.TestResponse;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.infinispan.util.KeyValuePair;
import org.testng.annotations.Test;
/**
* @author Galder Zamarreño
*/
@Test(groups = "functional")
public abstract class AbstractHotRodClusterEventsTest extends HotRodMultiNodeTest {
private ArrayList<AcceptedKeyFilterFactory> filters = new ArrayList<>();
private ArrayList<AcceptedKeyValueConverterFactory> converters = new ArrayList<>();
@Override
protected String cacheName() {
return "remote-clustered-events";
}
@Override
protected int nodeCount() {
return 3;
}
@Override
protected ConfigurationBuilder createCacheConfig() {
return hotRodCacheConfiguration(getDefaultClusteredCacheConfig(cacheMode, false));
}
@Override
protected EmbeddedCacheManager createCacheManager() {
return TestCacheManagerFactory.createClusteredCacheManager(HotRodClusterEventsSCI.INSTANCE, hotRodCacheConfiguration());
}
@Override
protected HotRodServer startTestHotRodServer(EmbeddedCacheManager cacheManager, int port) {
HotRodServer server = HotRodTestingUtil.startHotRodServer(cacheManager, port);
filters.add(new AcceptedKeyFilterFactory());
server.addCacheEventFilterFactory("accepted-key-filter-factory", filters.get(0));
converters.add(new AcceptedKeyValueConverterFactory());
server.addCacheEventConverterFactory("accepted-keyvalue-converter-factory", converters.get(0));
return server;
}
public void testEventForwarding(Method m) {
// Registering listener in one node and executing operations against
// different nodes should still result in events received
HotRodClient client1 = clients().get(0);
HotRodClient client2 = clients().get(1);
HotRodClient client3 = clients().get(2);
EventLogListener listener1 = new EventLogListener();
withClientListener(client1, listener1, Optional.empty(), Optional.empty(), false, true, () -> {
byte[] key = k(m);
client2.put(key, 0, 0, v(m));
listener1.expectOnlyCreatedEvent(anyCache(), key);
client3.put(key, 0, 0, v(m, "v2-"));
listener1.expectOnlyModifiedEvent(anyCache(), key);
client2.remove(key);
listener1.expectOnlyRemovedEvent(anyCache(), key);
});
}
public void testNoEventsAfterRemovingListener(Method m) {
HotRodClient client1 = clients().get(0);
EventLogListener listener1 = new EventLogListener();
byte[] key = k(m);
withClientListener(client1, listener1, Optional.empty(), Optional.empty(), false, true, () -> {
client1.put(key, 0, 0, v(m));
listener1.expectOnlyCreatedEvent(anyCache(), key);
client1.put(key, 0, 0, v(m, "v2-"));
listener1.expectOnlyModifiedEvent(anyCache(), key);
client1.remove(key);
listener1.expectOnlyRemovedEvent(anyCache(), key);
});
client1.put(key, 0, 0, v(m));
listener1.expectNoEvents(Optional.empty());
client1.remove(key);
listener1.expectNoEvents(Optional.empty());
}
public void testNoEventsAfterRemovingListenerInDifferentNode(Method m) {
HotRodClient client1 = clients().get(0);
HotRodClient client2 = clients().get(1);
EventLogListener listener1 = new EventLogListener();
byte[] key = k(m);
assertStatus(client1.addClientListener(listener1, false, Optional.empty(), Optional.empty(), true), Success);
try {
client1.put(key, 0, 0, v(m));
listener1.expectOnlyCreatedEvent(anyCache(), key);
client1.put(key, 0, 0, v(m, "v2-"));
listener1.expectOnlyModifiedEvent(anyCache(), key);
client1.remove(key);
listener1.expectOnlyRemovedEvent(anyCache(), key);
// Use a client connected to a different node to attempt trying to remove listener
client2.removeClientListener(listener1.getId());
// The remoint has no effect since the listener information is not clustered
// Remoint needs to be done in the node where the listener was added
client1.put(key, 0, 0, v(m));
listener1.expectOnlyCreatedEvent(anyCache(), key);
client1.remove(key);
listener1.expectOnlyRemovedEvent(anyCache(), key);
} finally {
assertStatus(client1.removeClientListener(listener1.getId()), Success);
}
}
public void testClientDisconnectListenerCleanup(Method m) throws InterruptedException {
HotRodClient client1 = clients().get(0);
HotRodClient
newClient = new HotRodClient("127.0.0.1", servers().get(1).getPort(), cacheName(), protocolVersion());
EventLogListener listener = new EventLogListener();
assertStatus(newClient.addClientListener(listener, false, Optional.empty(), Optional.empty(), true), Success);
byte[] key = k(m);
client1.put(key, 0, 0, v(m));
listener.expectOnlyCreatedEvent(anyCache(), key);
newClient.stop().await();
client1.put(k(m, "k2-"), 0, 0, v(m));
listener.expectNoEvents(Optional.empty());
client1.remove(key);
client1.remove(k(m, "k2-"));
}
public void testFailoverSendsEventsForNewContent(Method m) {
HotRodClient client1 = clients().get(0);
HotRodClient client2 = clients().get(1);
HotRodClient client3 = clients().get(2);
EventLogListener listener1 = new EventLogListener();
EventLogListener listener2 = new EventLogListener();
withClientListener(client1, listener1, Optional.empty(), Optional.empty(), false, true, () -> {
byte[] key = k(m);
client2.put(key, 0, 0, v(m));
listener1.expectOnlyCreatedEvent(anyCache(), key);
client2.remove(key);
listener1.expectOnlyRemovedEvent(anyCache(), key);
HotRodServer newServer = startClusteredServer(servers().get(2).getPort() + 50);
HotRodClient client4 = new HotRodClient("127.0.0.1", newServer.getPort(), cacheName(), protocolVersion());
try {
withClientListener(client4, listener2, Optional.empty(), Optional.empty(), false, true, () -> {
byte[] newKey = k(m, "k2-");
client3.put(newKey, 0, 0, v(m));
listener1.expectOnlyCreatedEvent(anyCache(), newKey);
listener2.expectOnlyCreatedEvent(anyCache(), newKey);
client1.put(newKey, 0, 0, v(m, "v2-"));
listener1.expectOnlyModifiedEvent(anyCache(), newKey);
listener2.expectOnlyModifiedEvent(anyCache(), newKey);
client4.remove(newKey);
listener1.expectOnlyRemovedEvent(anyCache(), newKey);
listener2.expectOnlyRemovedEvent(anyCache(), newKey);
});
} finally {
if (client4 != null) {
client4.stop();
}
stopClusteredServer(newServer);
TestingUtil.waitForNoRebalance(
cache(0, cacheName()), cache(1, cacheName()), cache(2, cacheName()));
}
client3.put(key, 0, 0, v(m, "v2-"));
listener1.expectOnlyCreatedEvent(anyCache(), key);
listener2.expectNoEvents(Optional.empty());
client3.put(key, 0, 0, v(m, "v3-"));
listener1.expectOnlyModifiedEvent(anyCache(), key);
listener2.expectNoEvents(Optional.empty());
client2.remove(key);
listener1.expectOnlyRemovedEvent(anyCache(), key);
listener2.expectNoEvents(Optional.empty());
});
}
public void testFilteringInCluster(Method m) {
HotRodClient client1 = clients().get(0);
HotRodClient client2 = clients().get(1);
EventLogListener listener1 = new EventLogListener();
Optional<KeyValuePair<String, List<byte[]>>> filterFactory =
Optional.of(new KeyValuePair<String, List<byte[]>>("accepted-key-filter-factory", Collections.emptyList()));
byte[] key1 = k(m, "k1-");
withClusterClientListener(client1, listener1, filterFactory, Optional.empty(), key1, false, () -> {
client2.put(k(m, "k-99"), 0, 0, v(m));
listener1.expectNoEvents(Optional.empty());
client2.remove(k(m, "k-99"));
listener1.expectNoEvents(Optional.empty());
client2.put(key1, 0, 0, v(m));
listener1.expectOnlyCreatedEvent(anyCache(), key1);
client1.remove(key1);
listener1.expectOnlyRemovedEvent(anyCache(), key1);
});
}
public void testParameterBasedFilteringInCluster(Method m) {
HotRodClient client1 = clients().get(0);
HotRodClient client2 = clients().get(1);
EventLogListener listener1 = new EventLogListener();
byte[] dynamicAcceptedKey = new byte[]{4, 5, 6};
Optional<KeyValuePair<String, List<byte[]>>> filterFactory = Optional.of(
new KeyValuePair<>("accepted-key-filter-factory", Collections.singletonList(dynamicAcceptedKey)));
withClusterClientListener(client1, listener1, filterFactory, Optional.empty(), null, false, () -> {
byte[] key1 = k(m, "k1-");
client2.put(k(m, "k-99"), 0, 0, v(m));
listener1.expectNoEvents(Optional.empty());
client2.remove(k(m, "k-99"));
listener1.expectNoEvents(Optional.empty());
client2.put(key1, 0, 0, v(m));
listener1.expectNoEvents(Optional.empty());
client2.put(dynamicAcceptedKey, 0, 0, v(m));
listener1.expectOnlyCreatedEvent(anyCache(), dynamicAcceptedKey);
client1.remove(dynamicAcceptedKey);
listener1.expectOnlyRemovedEvent(anyCache(), dynamicAcceptedKey);
});
}
public void testConversionInCluster(Method m) {
HotRodClient client1 = clients().get(0);
HotRodClient client2 = clients().get(1);
EventLogListener listener1 = new EventLogListener();
Optional<KeyValuePair<String, List<byte[]>>> converterFactory = Optional
.of(new KeyValuePair<String, List<byte[]>>("accepted-keyvalue-converter-factory", Collections.emptyList()));
final byte[] key1 = k(m, "k1-");
withClusterClientListener(client1, listener1, Optional.empty(), converterFactory, key1, false,
() -> {
byte[] value = v(m);
byte[] key99 = k(m, "k-99");
client2.put(key99, 0, 0, v(m));
listener1.expectSingleCustomEvent(anyCache(), addLengthPrefix(key99));
client2.put(key1, 0, 0, v(m));
listener1.expectSingleCustomEvent(anyCache(), addLengthPrefix(key1, value));
client2.remove(key99);
listener1.expectSingleCustomEvent(anyCache(), addLengthPrefix(key99));
client2.remove(key1);
listener1.expectSingleCustomEvent(anyCache(), addLengthPrefix(key1));
});
}
public void testParameterBasedConversionInCluster(Method m) {
HotRodClient client1 = clients().get(0);
HotRodClient client2 = clients().get(1);
EventLogListener listener1 = new EventLogListener();
byte[] convertedKey = new byte[]{4, 5, 6};
Optional<KeyValuePair<String, List<byte[]>>> converteFactory = Optional.of(
new KeyValuePair<>("accepted-keyvalue-converter-factory", Collections.singletonList(new byte[]{4, 5, 6})));
withClusterClientListener(client1, listener1, Optional.empty(), converteFactory, null, false, () -> {
byte[] key1 = k(m, "k1-");
byte[] value = v(m);
byte[] key99 = k(m, "k-99");
client2.put(key99, 0, 0, v(m));
listener1.expectSingleCustomEvent(anyCache(), addLengthPrefix(key99));
client2.put(key1, 0, 0, v(m));
listener1.expectSingleCustomEvent(anyCache(), addLengthPrefix(key1));
client2.put(convertedKey, 0, 0, v(m));
listener1.expectSingleCustomEvent(anyCache(), addLengthPrefix(convertedKey, value));
client1.remove(convertedKey);
listener1.expectSingleCustomEvent(anyCache(), addLengthPrefix(convertedKey));
});
}
public void testEventReplayAfterAddingListenerInCluster(Method m) {
HotRodClient client1 = clients().get(0);
HotRodClient client2 = clients().get(1);
HotRodClient client3 = clients().get(2);
byte[] k1 = k(m, "k1-");
byte[] v1 = v(m, "v1-");
byte[] k2 = k(m, "k2-");
byte[] v2 = v(m, "v2-");
byte[] k3 = k(m, "k3-");
byte[] v3 = v(m, "v3-");
client1.put(k1, 0, 0, v1);
client2.put(k2, 0, 0, v2);
client3.put(k3, 0, 0, v3);
EventLogListener listener1 = new EventLogListener();
withClientListener(client1, listener1, Optional.empty(), Optional.empty(), true, true, () -> {
List<byte[]> keys = Arrays.asList(k1, k2, k3);
listener1.expectUnorderedEvents(anyCache(), keys, Event.Type.CACHE_ENTRY_CREATED);
client1.remove(k1);
listener1.expectOnlyRemovedEvent(anyCache(), k1);
client2.remove(k2);
listener1.expectOnlyRemovedEvent(anyCache(), k2);
client3.remove(k3);
listener1.expectOnlyRemovedEvent(anyCache(), k3);
});
}
public void testNoEventReplayAfterAddingListenerInCluster(Method m) {
HotRodClient client1 = clients().get(0);
HotRodClient client2 = clients().get(1);
HotRodClient client3 = clients().get(2);
byte[] k1 = k(m, "k1-");
byte[] v1 = v(m, "v1-");
byte[] k2 = k(m, "k2-");
byte[] v2 = v(m, "v2-");
byte[] k3 = k(m, "k3-");
byte[] v3 = v(m, "v3-");
client1.put(k1, 0, 0, v1);
client2.put(k2, 0, 0, v2);
client3.put(k3, 0, 0, v3);
EventLogListener listener1 = new EventLogListener();
withClientListener(client1, listener1, Optional.empty(), Optional.empty(), false, true, () -> {
listener1.expectNoEvents(Optional.empty());
client1.remove(k1);
listener1.expectOnlyRemovedEvent(anyCache(), k1);
client2.remove(k2);
listener1.expectOnlyRemovedEvent(anyCache(), k2);
client3.remove(k3);
listener1.expectOnlyRemovedEvent(anyCache(), k3);
});
}
private Cache<byte[], byte[]> anyCache() {
return cacheManagers.get(0).<byte[], byte[]>getCache(cacheName()).getAdvancedCache();
}
private void withClusterClientListener(HotRodClient client, TestClientListener listener,
Optional<KeyValuePair<String, List<byte[]>>> filterFactory,
Optional<KeyValuePair<String, List<byte[]>>> converterFactory,
byte[] staticKey, boolean includeState, Runnable fn) {
filters.forEach(factory -> factory.staticKey = staticKey);
converters.forEach(factory -> factory.staticKey = staticKey);
TestResponse response = client.addClientListener(listener, includeState, filterFactory, converterFactory, true);
assertStatus(response, Success);
try {
fn.run();
} finally {
assertStatus(client.removeClientListener(listener.getId()), Success);
filters.forEach(factory -> factory.staticKey = null);
converters.forEach(factory -> factory.staticKey = null);
}
}
public static byte[] addLengthPrefix(byte[] key) {
byte keyLength = (byte) key.length;
ByteBuffer buffer = ByteBuffer.allocate(keyLength + 1);
buffer.put(keyLength);
buffer.put(key);
return buffer.array();
}
public static byte[] addLengthPrefix(byte[] key, byte[] value) {
byte keyLength = (byte) key.length;
byte valueLength = (byte) value.length;
ByteBuffer buffer = ByteBuffer.allocate(keyLength + valueLength + 2);
buffer.put(keyLength);
buffer.put(key);
buffer.put(valueLength);
buffer.put(value);
return buffer.array();
}
static class AcceptedKeyFilterFactory implements CacheEventFilterFactory, Serializable {
@ProtoField(number = 1)
byte[] staticKey = null;
AcceptedKeyFilterFactory() {}
Optional<byte[]> getStaticKey() {
return Optional.ofNullable(staticKey);
}
@Override
public <K, V> CacheEventFilter<K, V> getFilter(Object[] params) {
return (CacheEventFilter<K, V> & Serializable) ((key, oldValue, oldMetadata, newValue, newMetadata, eventType) -> {
byte[] checkKey = getStaticKey().orElseGet(() -> (byte[]) params[0]);
return Arrays.equals(checkKey, (byte[]) key);
});
}
}
static class AcceptedKeyValueConverterFactory implements CacheEventConverterFactory, Serializable {
@ProtoField(number = 1)
byte[] staticKey = null;
AcceptedKeyValueConverterFactory() {}
Optional<byte[]> getStaticKey() {
return Optional.ofNullable(staticKey);
}
@Override
public <K, V, C> CacheEventConverter<K, V, C> getConverter(Object[] params) {
return (CacheEventConverter<K, V, C>) (CacheEventConverter<byte[], byte[], byte[]> & Serializable) ((key, oldValue, oldMetadata, newValue, newMetadata, eventType) -> {
byte[] checkKey = getStaticKey().orElseGet(() -> (byte[]) params[0]);
if (newValue == null || !Arrays.equals(checkKey, key)) {
return addLengthPrefix(key);
} else {
return addLengthPrefix(key, newValue);
}
});
}
}
@AutoProtoSchemaBuilder(
includeClasses = {
AcceptedKeyFilterFactory.class,
AcceptedKeyValueConverterFactory.class
},
schemaFileName = "test.hotrod.AbstractHotRodClusterEvents.proto",
schemaFilePath = "proto/generated",
schemaPackageName = "org.infinispan.test.hotord.AbstractHotRodClusterEvents",
service = false
)
interface HotRodClusterEventsSCI extends SerializationContextInitializer {
HotRodClusterEventsSCI INSTANCE = new HotRodClusterEventsSCIImpl();
}
}
| 19,984
| 44.112867
| 176
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/event/HotRodReplicatedEventsTest.java
|
package org.infinispan.server.hotrod.event;
import org.infinispan.configuration.cache.CacheMode;
import org.testng.annotations.Test;
/**
* @author Galder Zamarreño
*/
@Test(groups = "functional", testName = "server.hotrod.event.HotRodReplicatedEventsTest")
public class HotRodReplicatedEventsTest extends AbstractHotRodClusterEventsTest {
public HotRodReplicatedEventsTest() {
cacheMode = CacheMode.REPL_SYNC;
}
}
| 430
| 27.733333
| 89
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/event/EventLogListener.java
|
package org.infinispan.server.hotrod.event;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.assertByteArrayEquals;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertNotNull;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import org.infinispan.Cache;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.container.versioning.EntryVersion;
import org.infinispan.container.versioning.NumericVersion;
import org.infinispan.metadata.Metadata;
import org.infinispan.notifications.cachelistener.event.Event;
import org.infinispan.server.hotrod.test.TestClientListener;
import org.infinispan.server.hotrod.test.TestCustomEvent;
import org.infinispan.server.hotrod.test.TestKeyEvent;
import org.infinispan.server.hotrod.test.TestKeyWithVersionEvent;
import org.infinispan.test.TestException;
/**
* @author Galder Zamarreño
*/
public class EventLogListener extends TestClientListener {
private final ArrayBlockingQueue<TestKeyWithVersionEvent> createdEvents = new ArrayBlockingQueue<>(128);
private final ArrayBlockingQueue<TestKeyWithVersionEvent> modifiedEvents = new ArrayBlockingQueue<>(128);
private final ArrayBlockingQueue<TestKeyEvent> removedEvents = new ArrayBlockingQueue<>(128);
private final ArrayBlockingQueue<TestCustomEvent> customEvents = new ArrayBlockingQueue<>(128);
@Override
public int queueSize(Event.Type eventType) {
return queue(eventType).size();
}
@Override
public Object pollEvent(Event.Type eventType) {
try {
return queue(eventType).poll(10, TimeUnit.SECONDS);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new TestException();
}
}
private <T> BlockingQueue<T> queue(Event.Type eventType) {
BlockingQueue<?> eventQueue;
switch (eventType) {
case CACHE_ENTRY_CREATED:
eventQueue = createdEvents;
break;
case CACHE_ENTRY_MODIFIED:
eventQueue = modifiedEvents;
break;
case CACHE_ENTRY_REMOVED:
eventQueue = removedEvents;
break;
default:
throw new IllegalStateException("Unexpected event type: " + eventType);
}
return (BlockingQueue<T>) eventQueue;
}
@Override
public void onCreated(TestKeyWithVersionEvent event) {
createdEvents.add(event);
}
@Override
public void onModified(TestKeyWithVersionEvent event) {
modifiedEvents.add(event);
}
@Override
public void onRemoved(TestKeyEvent event) {
removedEvents.add(event);
}
@Override
public int customQueueSize() {
return customEvents.size();
}
@Override
public TestCustomEvent pollCustom() {
try {
return customEvents.poll(10, TimeUnit.SECONDS);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new TestException();
}
}
@Override
public void onCustom(TestCustomEvent event) {
customEvents.add(event);
}
@Override
public byte[] getId() {
return new byte[]{1, 2, 3};
}
public void expectNoEvents(Optional<Event.Type> eventType) {
if (eventType.isPresent()) {
assertEquals(0, queueSize(eventType.get()));
} else {
assertEquals(0, queueSize(Event.Type.CACHE_ENTRY_CREATED));
assertEquals(0, queueSize(Event.Type.CACHE_ENTRY_MODIFIED));
assertEquals(0, queueSize(Event.Type.CACHE_ENTRY_REMOVED));
assertEquals(0, customQueueSize());
}
}
public void expectOnlyRemovedEvent(Cache cache, byte[] k) {
expectSingleEvent(cache, k, Event.Type.CACHE_ENTRY_REMOVED);
expectNoEvents(Optional.of(Event.Type.CACHE_ENTRY_CREATED));
expectNoEvents(Optional.of(Event.Type.CACHE_ENTRY_MODIFIED));
}
public void expectOnlyModifiedEvent(Cache cache, byte[] k) {
expectSingleEvent(cache, k, Event.Type.CACHE_ENTRY_MODIFIED);
expectNoEvents(Optional.of(Event.Type.CACHE_ENTRY_CREATED));
expectNoEvents(Optional.of(Event.Type.CACHE_ENTRY_REMOVED));
}
public void expectOnlyCreatedEvent(Cache cache, byte[] k) {
expectSingleEvent(cache, k, Event.Type.CACHE_ENTRY_CREATED);
expectNoEvents(Optional.of(Event.Type.CACHE_ENTRY_MODIFIED));
expectNoEvents(Optional.of(Event.Type.CACHE_ENTRY_REMOVED));
}
public void expectSingleEvent(Cache cache, byte[] k, Event.Type eventType) {
expectEvent(cache, k, eventType);
assertEquals(0, queueSize(eventType));
}
public void expectEvent(Cache cache, byte[] k, Event.Type eventType) {
Object event = pollEvent(eventType);
assertNotNull(event);
if (event instanceof TestKeyWithVersionEvent) {
TestKeyWithVersionEvent t = (TestKeyWithVersionEvent) event;
assertByteArrayEquals(k, t.key);
assertEquals(serverDataVersion(k, cache), t.dataVersion);
} else if (event instanceof TestKeyEvent) {
assertByteArrayEquals(k, ((TestKeyEvent) event).key);
}
}
public void expectUnorderedEvents(Cache cache, Collection<byte[]> keys, Event.Type eventType) {
List<byte[]> assertedKeys = new ArrayList<>();
for (int i = 0; i < keys.size(); i++) {
Object event = pollEvent(eventType);
assertNotNull(event);
int initialSize = assertedKeys.size();
keys.forEach(key -> {
if (event instanceof TestKeyWithVersionEvent) {
TestKeyWithVersionEvent t = (TestKeyWithVersionEvent) event;
boolean keyMatched = checkUnorderedKeyEvent(assertedKeys, key, t.key);
if (keyMatched)
assertEquals(serverDataVersion(key, cache), t.dataVersion);
} else if (event instanceof TestKeyEvent) {
checkUnorderedKeyEvent(assertedKeys, key, ((TestKeyEvent) event).key);
}
});
int finalSize = assertedKeys.size();
assertEquals(initialSize + 1, finalSize);
}
}
private boolean checkUnorderedKeyEvent(List<byte[]> assertedKeys, byte[] key, byte[] eventKey) {
if (java.util.Arrays.equals(key, eventKey)) {
assertFalse(assertedKeys.contains(key));
assertedKeys.add(key);
return true;
} else {
return false;
}
}
public void expectSingleCustomEvent(Cache cache, byte[] eventData) {
TestCustomEvent event = pollCustom();
assertNotNull(event);
assertByteArrayEquals(eventData, event.eventData);
int remaining = customQueueSize();
assertEquals(0, remaining);
}
private long serverDataVersion(byte[] k, Cache cache) {
CacheEntry cacheEntry = cache.getAdvancedCache().withStorageMediaType().getCacheEntry(k);
Metadata metadata = cacheEntry.getMetadata();
EntryVersion version = metadata.version();
return ((NumericVersion) version).getVersion();
}
}
| 7,205
| 34.497537
| 108
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/event/HotRodDistributedEventsTest.java
|
package org.infinispan.server.hotrod.event;
import org.infinispan.configuration.cache.CacheMode;
import org.testng.annotations.Test;
/**
* @author Galder Zamarreño
*/
@Test(groups = "functional", testName = "server.hotrod.event.HotRodDistributedEventsTest")
public class HotRodDistributedEventsTest extends AbstractHotRodClusterEventsTest {
public HotRodDistributedEventsTest() {
cacheMode = CacheMode.DIST_SYNC;
}
}
| 433
| 27.933333
| 90
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/event/HotRodCustomEventsTest.java
|
package org.infinispan.server.hotrod.event;
import static org.infinispan.server.hotrod.event.AbstractHotRodClusterEventsTest.addLengthPrefix;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.k;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.v;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.withClientListener;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Collections;
import java.util.Optional;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.notifications.cachelistener.filter.CacheEventConverter;
import org.infinispan.notifications.cachelistener.filter.CacheEventConverterFactory;
import org.infinispan.server.hotrod.HotRodServer;
import org.infinispan.server.hotrod.HotRodSingleNodeTest;
import org.infinispan.server.hotrod.test.HotRodTestingUtil;
import org.infinispan.util.KeyValuePair;
import org.testng.annotations.Test;
/**
* @author Galder Zamarreño
*/
@Test(groups = "functional", testName = "server.hotrod.event.HotRodCustomEventsTest")
public class HotRodCustomEventsTest extends HotRodSingleNodeTest {
@Override
protected HotRodServer createStartHotRodServer(EmbeddedCacheManager cacheManager) {
HotRodServer server = HotRodTestingUtil.startHotRodServer(cacheManager);
server.addCacheEventConverterFactory("static-converter-factory", new StaticConverterFactory());
server.addCacheEventConverterFactory("dynamic-converter-factory", new DynamicConverterFactory());
return server;
}
public void testCustomEvents(Method m) {
EventLogListener eventListener = new EventLogListener();
withClientListener(client(), eventListener, Optional.empty(),
Optional.of(new KeyValuePair<>("static-converter-factory", Collections.emptyList())), () -> {
eventListener.expectNoEvents(Optional.empty());
byte[] key = k(m);
client().remove(key);
eventListener.expectNoEvents(Optional.empty());
byte[] value = v(m);
client().put(key, 0, 0, value);
eventListener.expectSingleCustomEvent(cache, addLengthPrefix(key, value));
byte[] value2 = v(m, "v2-");
client().put(key, 0, 0, value2);
eventListener.expectSingleCustomEvent(cache, addLengthPrefix(key, value2));
client().remove(key);
eventListener.expectSingleCustomEvent(cache, addLengthPrefix(key));
});
}
public void testParameterBasedConversion(Method m) {
EventLogListener eventListener = new EventLogListener();
byte[] customConvertKey = new byte[]{4, 5, 6};
withClientListener(client(), eventListener, Optional.empty(), Optional.of(
new KeyValuePair<>("dynamic-converter-factory", Collections.singletonList(new byte[]{4, 5, 6}))), () -> {
eventListener.expectNoEvents(Optional.empty());
byte[] key = k(m);
byte[] value = v(m);
client().put(key, 0, 0, value);
eventListener.expectSingleCustomEvent(cache, addLengthPrefix(key, value));
byte[] value2 = v(m, "v2-");
client().put(key, 0, 0, value2);
eventListener.expectSingleCustomEvent(cache, addLengthPrefix(key, value2));
client().remove(key);
eventListener.expectSingleCustomEvent(cache, addLengthPrefix(key));
client().put(customConvertKey, 0, 0, value);
eventListener.expectSingleCustomEvent(cache, addLengthPrefix(customConvertKey));
});
}
public void testConvertedEventsNoReplay(Method m) {
EventLogListener eventListener = new EventLogListener();
byte[] key = new byte[]{1};
byte[] value = new byte[]{2};
client().put(key, 0, 0, value);
withClientListener(client(), eventListener, Optional.empty(),
Optional.of(new KeyValuePair<>("static-converter-factory", Collections.emptyList())), () -> {
eventListener.expectNoEvents(Optional.empty());
});
}
public void testConvertedEventsReplay(Method m) {
EventLogListener eventListener = new EventLogListener();
byte[] key = new byte[]{1};
byte[] value = new byte[]{2};
client().put(key, 0, 0, value);
withClientListener(client(), eventListener, Optional.empty(), Optional
.of(new KeyValuePair<>("static-converter-factory", Collections.emptyList())), true, true, () -> {
eventListener.expectSingleCustomEvent(cache, addLengthPrefix(key, value));
});
}
private static class StaticConverterFactory implements CacheEventConverterFactory {
@Override
public <K, V, C> CacheEventConverter<K, V, C> getConverter(Object[] params) {
return (CacheEventConverter<K, V, C>) (CacheEventConverter<byte[], byte[], byte[]>) (key, oldValue, oldMetadata, newValue, newMetadata, eventType) -> {
if (newValue == null)
return addLengthPrefix(key);
else
return addLengthPrefix(key, newValue);
};
}
}
class DynamicConverterFactory implements CacheEventConverterFactory {
@Override
public <K, V, C> CacheEventConverter<K, V, C> getConverter(Object[] params) {
return (CacheEventConverter<K, V, C>) (CacheEventConverter<byte[], byte[], byte[]>) (key, oldValue, oldMetadata, newValue, newMetadata, eventType) -> {
if (newValue == null || Arrays.equals((byte[]) params[0], key))
return addLengthPrefix(key);
else
return addLengthPrefix(key, newValue);
};
}
}
}
| 5,665
| 45.442623
| 160
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/transport/TraceChannelHandler.java
|
package org.infinispan.server.hotrod.transport;
import static org.infinispan.server.core.transport.ExtendedByteBuf.hexDump;
import java.net.SocketAddress;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.commons.util.Util;
import org.infinispan.server.hotrod.logging.Log;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelDuplexHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelPromise;
/**
* Channel handler that logs every connect/disconnect/close/read/write event at trace level.
*
* @author Dan Berindei
* @since 11
*/
public class TraceChannelHandler extends ChannelDuplexHandler {
private static final Log log = LogFactory.getLog(TraceChannelHandler.class, Log.class);
@Override
public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress,
ChannelPromise promise) throws Exception {
log.tracef("Channel %s connect", ctx.channel());
super.connect(ctx, remoteAddress, localAddress, promise);
}
@Override
public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
log.tracef("%s disconnect", ctx.channel());
super.disconnect(ctx, promise);
}
@Override
public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
log.tracef("%s close", ctx.channel());
super.close(ctx, promise);
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
String msgString = msg instanceof ByteBuf ? hexDump(((ByteBuf) msg)) : Util.toStr(msg);
log.tracef("%s read: %s", ctx.channel(), msgString);
super.channelRead(ctx, msg);
}
@Override
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
String msgString = msg instanceof ByteBuf ? hexDump(((ByteBuf) msg)) : Util.toStr(msg);
log.tracef("%s write: %s", ctx.channel(), msgString);
super.write(ctx, msg, promise);
}
}
| 2,072
| 34.135593
| 106
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/transport/TestHandlersChannelInitializer.java
|
package org.infinispan.server.hotrod.transport;
import org.infinispan.server.core.transport.NettyInitializer;
import io.netty.channel.Channel;
import io.netty.channel.ChannelPipeline;
import io.netty.handler.codec.FixedLengthFrameDecoder;
/**
* A channel pipeline factory for testing that adds 2 handlers before a channel handler named <b>decoder</b>:
* <ul>
* <li>A logging decoder to log message contents at trace level</li>
* <li>A fixed length frame decoder of 1 byte</li>
* </ul>
*
* @author William Burns
* @since 9.0
*/
public class TestHandlersChannelInitializer implements NettyInitializer {
@Override
public void initializeChannel(Channel ch) {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addBefore("decoder", "trace", new TraceChannelHandler());
// Note: FixedLengthFrameDecoder never passes a buffer < frame length, so a higher frame length will not work
pipeline.addBefore("decoder", "1frame", new FixedLengthFrameDecoder(1));
}
}
| 1,002
| 34.821429
| 115
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/counter/StrongCounterAPITest.java
|
package org.infinispan.server.hotrod.counter;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.stream.Collectors;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.counter.api.CounterManager;
import org.infinispan.counter.impl.CounterModuleLifecycle;
import org.infinispan.server.hotrod.HotRodMultiNodeTest;
import org.infinispan.server.hotrod.HotRodVersion;
import org.infinispan.server.hotrod.counter.impl.StrongCounterImplTestStrategy;
import org.infinispan.server.hotrod.counter.impl.TestCounterManager;
import org.testng.annotations.Test;
/**
* A {@link org.infinispan.counter.api.StrongCounter} api test.
*
* @author Pedro Ruivo
* @since 9.2
*/
@Test(groups = "functional", testName = "server.hotrod.counter.StrongCounterAPITest")
public class StrongCounterAPITest extends HotRodMultiNodeTest implements StrongCounterTestStrategy {
private final StrongCounterTestStrategy strategy;
public StrongCounterAPITest() {
strategy = new StrongCounterImplTestStrategy(this::testCounterManager, this::allTestCounterManager);
}
@Override
public void testCompareAndSet(Method method) {
strategy.testCompareAndSet(method);
}
@Override
public void testCompareAndSwap(Method method) {
strategy.testCompareAndSwap(method);
}
@Override
public void testBoundaries(Method method) {
strategy.testBoundaries(method);
}
@Override
public void testAdd(Method method) {
strategy.testAdd(method);
}
@Override
public void testReset(Method method) {
strategy.testReset(method);
}
@Override
public void testNameAndConfigurationTest(Method method) {
strategy.testNameAndConfigurationTest(method);
}
@Override
public void testRemove(Method method) {
strategy.testRemove(method);
}
@Override
public void testListenerAddAndRemove(Method method) throws InterruptedException {
strategy.testListenerAddAndRemove(method);
}
@Override
public void testListenerWithBounds(Method method) throws InterruptedException {
strategy.testListenerWithBounds(method);
}
@Override
public void testSet(Method method) {
strategy.testSet(method);
}
@Override
protected String cacheName() {
return "unused";
}
@Override
protected ConfigurationBuilder createCacheConfig() {
return new ConfigurationBuilder();
}
@Override
protected byte protocolVersion() {
return HotRodVersion.HOTROD_27.getVersion();
}
private CounterManager testCounterManager() {
return new TestCounterManager(clients().get(0));
}
private Collection<CounterManager> allTestCounterManager() {
return clients().stream().map(TestCounterManager::new).collect(Collectors.toList());
}
@Override
protected void createCacheManagers() {
super.createCacheManagers();
waitForClusterToForm(CounterModuleLifecycle.COUNTER_CACHE_NAME);
}
}
| 2,993
| 25.972973
| 106
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/counter/BaseCounterTestStrategy.java
|
package org.infinispan.server.hotrod.counter;
import java.lang.reflect.Method;
import org.infinispan.counter.api.StrongCounter;
import org.infinispan.counter.api.WeakCounter;
/**
* A base test interface to test common methods from {@link StrongCounter} and {@link WeakCounter} API.
*
* @author Pedro Ruivo
* @since 9.2
*/
public interface BaseCounterTestStrategy {
void testAdd(Method method);
void testReset(Method method);
void testNameAndConfigurationTest(Method method);
void testRemove(Method method);
void testListenerAddAndRemove(Method method) throws InterruptedException;
}
| 611
| 22.538462
| 103
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/counter/NonClusteredStrongCounterAPITest.java
|
package org.infinispan.server.hotrod.counter;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Collections;
import org.infinispan.counter.api.CounterManager;
import org.infinispan.server.hotrod.HotRodSingleNodeTest;
import org.infinispan.server.hotrod.HotRodVersion;
import org.infinispan.server.hotrod.counter.impl.StrongCounterImplTestStrategy;
import org.infinispan.server.hotrod.counter.impl.TestCounterManager;
import org.testng.annotations.Test;
/**
* A {@link org.infinispan.counter.api.StrongCounter} api test.
*
* @author Pedro Ruivo
* @since 9.2
*/
@Test(groups = "functional", testName = "server.hotrod.counter.NonClusteredStrongCounterAPITest")
public class NonClusteredStrongCounterAPITest extends HotRodSingleNodeTest implements StrongCounterTestStrategy {
private final StrongCounterTestStrategy strategy;
public NonClusteredStrongCounterAPITest() {
strategy = new StrongCounterImplTestStrategy(this::testCounterManager, this::allTestCounterManager);
}
@Override
public void testCompareAndSet(Method method) {
strategy.testCompareAndSet(method);
}
@Override
public void testCompareAndSwap(Method method) {
strategy.testCompareAndSwap(method);
}
@Override
public void testBoundaries(Method method) {
strategy.testBoundaries(method);
}
@Override
public void testAdd(Method method) {
strategy.testAdd(method);
}
@Override
public void testReset(Method method) {
strategy.testReset(method);
}
@Override
public void testNameAndConfigurationTest(Method method) {
strategy.testNameAndConfigurationTest(method);
}
@Override
public void testRemove(Method method) {
strategy.testRemove(method);
}
@Override
public void testListenerAddAndRemove(Method method) throws InterruptedException {
strategy.testListenerAddAndRemove(method);
}
@Override
public void testListenerWithBounds(Method method) throws InterruptedException {
strategy.testListenerWithBounds(method);
}
@Override
public void testSet(Method method) {
strategy.testSet(method);
}
@Override
protected byte protocolVersion() {
return HotRodVersion.HOTROD_27.getVersion();
}
private CounterManager testCounterManager() {
return new TestCounterManager(client());
}
private Collection<CounterManager> allTestCounterManager() {
return Collections.singleton(testCounterManager());
}
}
| 2,502
| 25.913978
| 113
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/counter/NonClusteredWeakCounterAPITest.java
|
package org.infinispan.server.hotrod.counter;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Collections;
import org.infinispan.counter.api.CounterManager;
import org.infinispan.counter.api.WeakCounter;
import org.infinispan.server.hotrod.HotRodSingleNodeTest;
import org.infinispan.server.hotrod.HotRodVersion;
import org.infinispan.server.hotrod.counter.impl.TestCounterManager;
import org.infinispan.server.hotrod.counter.impl.WeakCounterImplTestStrategy;
import org.testng.annotations.Test;
/**
* A {@link WeakCounter} api test.
*
* @author Pedro Ruivo
* @since 9.2
*/
@Test(groups = "functional", testName = "server.hotrod.counter.NonClusteredWeakCounterAPITest")
public class NonClusteredWeakCounterAPITest extends HotRodSingleNodeTest implements WeakCounterTestStrategy {
private final WeakCounterTestStrategy strategy;
public NonClusteredWeakCounterAPITest() {
strategy = new WeakCounterImplTestStrategy(this::testCounterManager, this::allTestCounterManager);
}
@Override
public void testAdd(Method method) {
strategy.testAdd(method);
}
@Override
public void testReset(Method method) {
strategy.testReset(method);
}
@Override
public void testNameAndConfigurationTest(Method method) {
strategy.testNameAndConfigurationTest(method);
}
@Override
public void testRemove(Method method) {
strategy.testRemove(method);
}
@Override
public void testListenerAddAndRemove(Method method) throws InterruptedException {
strategy.testListenerAddAndRemove(method);
}
@Override
protected byte protocolVersion() {
return HotRodVersion.HOTROD_27.getVersion();
}
private CounterManager testCounterManager() {
return new TestCounterManager(client());
}
private Collection<CounterManager> allTestCounterManager() {
return Collections.singleton(testCounterManager());
}
}
| 1,937
| 27.086957
| 109
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/counter/WeakCounterTestStrategy.java
|
package org.infinispan.server.hotrod.counter;
import org.infinispan.counter.api.WeakCounter;
/**
* The {@link WeakCounter} API test interface.
*
* @author Pedro Ruivo
* @since 9.2
*/
public interface WeakCounterTestStrategy extends BaseCounterTestStrategy {
}
| 267
| 19.615385
| 74
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/counter/StrongCounterTestStrategy.java
|
package org.infinispan.server.hotrod.counter;
import java.lang.reflect.Method;
import org.infinispan.counter.api.StrongCounter;
/**
* The {@link StrongCounter} API test interface.
*
* @author Pedro Ruivo
* @since 9.2
*/
public interface StrongCounterTestStrategy extends BaseCounterTestStrategy {
void testCompareAndSet(Method method);
void testCompareAndSwap(Method method);
void testBoundaries(Method method);
void testListenerWithBounds(Method method) throws InterruptedException;
void testSet(Method method);
}
| 543
| 20.76
| 76
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/counter/WeakCounterAPITest.java
|
package org.infinispan.server.hotrod.counter;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.stream.Collectors;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.counter.api.CounterManager;
import org.infinispan.counter.api.WeakCounter;
import org.infinispan.counter.impl.CounterModuleLifecycle;
import org.infinispan.server.hotrod.HotRodMultiNodeTest;
import org.infinispan.server.hotrod.HotRodVersion;
import org.infinispan.server.hotrod.counter.impl.TestCounterManager;
import org.infinispan.server.hotrod.counter.impl.WeakCounterImplTestStrategy;
import org.testng.annotations.Test;
/**
* A {@link WeakCounter} api test.
*
* @author Pedro Ruivo
* @since 9.2
*/
@Test(groups = "functional", testName = "server.hotrod.counter.WeakCounterAPITest")
public class WeakCounterAPITest extends HotRodMultiNodeTest implements WeakCounterTestStrategy {
private final WeakCounterTestStrategy strategy;
public WeakCounterAPITest() {
strategy = new WeakCounterImplTestStrategy(this::testCounterManager, this::allTestCounterManager);
}
@Override
public void testAdd(Method method) {
strategy.testAdd(method);
}
@Override
public void testReset(Method method) {
strategy.testReset(method);
}
@Override
public void testNameAndConfigurationTest(Method method) {
strategy.testNameAndConfigurationTest(method);
}
@Override
public void testRemove(Method method) {
strategy.testRemove(method);
}
@Override
public void testListenerAddAndRemove(Method method) throws InterruptedException {
strategy.testListenerAddAndRemove(method);
}
@Override
protected String cacheName() {
return "unused";
}
@Override
protected ConfigurationBuilder createCacheConfig() {
return new ConfigurationBuilder();
}
@Override
protected byte protocolVersion() {
return HotRodVersion.HOTROD_27.getVersion();
}
private CounterManager testCounterManager() {
return new TestCounterManager(clients().get(0));
}
private Collection<CounterManager> allTestCounterManager() {
return clients().stream().map(TestCounterManager::new).collect(Collectors.toList());
}
@Override
protected void createCacheManagers() {
super.createCacheManagers();
waitForClusterToForm(CounterModuleLifecycle.COUNTER_CACHE_NAME);
}
}
| 2,427
| 27.232558
| 104
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/counter/CounterManagerOperationTest.java
|
package org.infinispan.server.hotrod.counter;
import static org.infinispan.commons.test.CommonsTestingUtil.tmpDirectory;
import static org.infinispan.server.hotrod.test.HotRodTestingUtil.hotRodCacheConfiguration;
import static org.infinispan.test.fwk.TestCacheManagerFactory.createClusteredCacheManager;
import java.io.File;
import java.lang.reflect.Method;
import java.nio.file.Paths;
import java.util.List;
import java.util.stream.Collectors;
import org.infinispan.commons.util.Util;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.counter.api.CounterManager;
import org.infinispan.counter.impl.CounterModuleLifecycle;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.hotrod.HotRodMultiNodeTest;
import org.infinispan.server.hotrod.HotRodVersion;
import org.infinispan.server.hotrod.counter.impl.CounterManagerImplTestStrategy;
import org.infinispan.server.hotrod.counter.impl.TestCounterManager;
import org.infinispan.util.logging.Log;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
/**
* A counter's creation and remove test.
*
* @author Pedro Ruivo
* @since 9.2
*/
@Test(groups = "functional", testName = "server.hotrod.counter.CounterManagerOperationTest")
public class CounterManagerOperationTest extends HotRodMultiNodeTest implements CounterManagerTestStrategy {
private static final String PERSISTENT_LOCATION = tmpDirectory("CounterManagerOperationTest");
private static final String TMP_LOCATION = Paths.get(PERSISTENT_LOCATION, "tmp").toString();
private static final String SHARED_LOCATION = Paths.get(PERSISTENT_LOCATION, "shared").toString();
private final CounterManagerTestStrategy strategy;
public CounterManagerOperationTest() {
strategy = new CounterManagerImplTestStrategy(this::allTestCounterManagers, this::log, this::cacheManager);
}
@BeforeClass(alwaysRun = true)
@Override
public void createBeforeClass() throws Throwable {
Util.recursiveFileRemove(PERSISTENT_LOCATION);
if (!new File(PERSISTENT_LOCATION).mkdirs()) {
log.warnf("Unable to create persistent location file: '%s'", PERSISTENT_LOCATION);
}
super.createBeforeClass();
}
@Override
public void testWeakCounter(Method method) {
strategy.testWeakCounter(method);
}
@Override
public void testUnboundedStrongCounter(Method method) {
strategy.testUnboundedStrongCounter(method);
}
@Override
public void testUpperBoundedStrongCounter(Method method) {
strategy.testUpperBoundedStrongCounter(method);
}
@Override
public void testLowerBoundedStrongCounter(Method method) {
strategy.testLowerBoundedStrongCounter(method);
}
@Override
public void testBoundedStrongCounter(Method method) {
strategy.testBoundedStrongCounter(method);
}
@Override
public void testUndefinedCounter() {
strategy.testUndefinedCounter();
}
@Override
public void testRemove(Method method) {
strategy.testRemove(method);
}
@Override
public void testGetCounterNames(Method method) {
strategy.testGetCounterNames(method);
}
@AfterClass(alwaysRun = true)
@Override
protected void destroy() {
super.destroy();
Util.recursiveFileRemove(PERSISTENT_LOCATION);
}
@Override
protected void createCacheManagers() {
for (int i = 0; i < nodeCount(); i++) {
char id = 'A';
id += i;
GlobalConfigurationBuilder builder = new GlobalConfigurationBuilder().clusteredDefault();
builder.globalState().enable()
.persistentLocation(Paths.get(PERSISTENT_LOCATION, Character.toString(id)).toString())
.temporaryLocation(TMP_LOCATION)
.sharedPersistentLocation(SHARED_LOCATION);
EmbeddedCacheManager cm = createClusteredCacheManager(builder, hotRodCacheConfiguration());
cacheManagers.add(cm);
}
waitForClusterToForm(CounterModuleLifecycle.COUNTER_CACHE_NAME);
}
@Override
protected String cacheName() {
return "unused-cache";
}
@Override
protected ConfigurationBuilder createCacheConfig() {
return new ConfigurationBuilder();
}
@Override
protected byte protocolVersion() {
return HotRodVersion.HOTROD_27.getVersion();
}
private Log log() {
return log;
}
private List<CounterManager> allTestCounterManagers() {
return clients().stream().map(TestCounterManager::new).collect(Collectors.toList());
}
private EmbeddedCacheManager cacheManager() {
return manager(0);
}
}
| 4,755
| 31.353741
| 113
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/counter/CounterManagerTestStrategy.java
|
package org.infinispan.server.hotrod.counter;
import java.lang.reflect.Method;
import org.infinispan.counter.api.CounterManager;
/**
* A interface for testing the {@link CounterManager} API.
*
* @author Pedro Ruivo
* @since 9.2
*/
public interface CounterManagerTestStrategy {
void testWeakCounter(Method method);
void testUnboundedStrongCounter(Method method);
void testUpperBoundedStrongCounter(Method method);
void testLowerBoundedStrongCounter(Method method);
void testBoundedStrongCounter(Method method);
void testUndefinedCounter();
void testRemove(Method method);
void testGetCounterNames(Method method);
}
| 654
| 20.129032
| 58
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/counter/response/RecoveryTestResponse.java
|
package org.infinispan.server.hotrod.counter.response;
import static java.util.Collections.emptyList;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.readRangedBytes;
import java.util.ArrayList;
import java.util.Collection;
import org.infinispan.commons.io.SignedNumeric;
import org.infinispan.commons.tx.XidImpl;
import org.infinispan.server.core.transport.VInt;
import org.infinispan.server.hotrod.HotRodOperation;
import org.infinispan.server.hotrod.OperationStatus;
import org.infinispan.server.hotrod.test.AbstractTestTopologyAwareResponse;
import org.infinispan.server.hotrod.test.TestResponse;
import io.netty.buffer.ByteBuf;
/**
* A {@link TestResponse} extension that contains the list of {@link XidImpl} to recover.
*
* @author Pedro Ruivo
* @since 9.4
*/
public class RecoveryTestResponse extends TestResponse {
private final Collection<XidImpl> xids;
public RecoveryTestResponse(byte version, long messageId, String cacheName, short clientIntel,
HotRodOperation operation, OperationStatus status, int topologyId,
AbstractTestTopologyAwareResponse topologyResponse, ByteBuf buffer) {
super(version, messageId, cacheName, clientIntel, operation, status, topologyId, topologyResponse);
this.xids = readXids(buffer);
}
private static Collection<XidImpl> readXids(ByteBuf buffer) {
int size = VInt.read(buffer);
if (size == 0) {
return emptyList();
}
Collection<XidImpl> xids = new ArrayList<>(size);
for (int i = 0; i < size; ++i) {
int formatId = SignedNumeric.decode(VInt.read(buffer));
byte[] globalId = readRangedBytes(buffer);
byte[] branchId = readRangedBytes(buffer);
xids.add(XidImpl.create(formatId, globalId, branchId));
}
return xids;
}
public Collection<XidImpl> getXids() {
return xids;
}
}
| 1,891
| 33.4
| 105
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/counter/response/CounterConfigurationTestResponse.java
|
package org.infinispan.server.hotrod.counter.response;
import org.infinispan.counter.api.CounterConfiguration;
import org.infinispan.server.hotrod.HotRodOperation;
import org.infinispan.server.hotrod.OperationStatus;
import org.infinispan.server.hotrod.test.AbstractTestTopologyAwareResponse;
import org.infinispan.server.hotrod.test.TestResponse;
/**
* A {@link TestResponse} extension that contains the {@link CounterConfiguration}.
*
* @author Pedro Ruivo
* @since 9.2
*/
public class CounterConfigurationTestResponse extends TestResponse {
private final CounterConfiguration configuration;
public CounterConfigurationTestResponse(byte version, long messageId, String cacheName, short clientIntel,
HotRodOperation operation, OperationStatus status, int topologyId,
AbstractTestTopologyAwareResponse topologyResponse, CounterConfiguration configuration) {
super(version, messageId, cacheName, clientIntel, operation, status, topologyId, topologyResponse);
this.configuration = configuration;
}
public CounterConfiguration getConfiguration() {
return configuration;
}
}
| 1,132
| 36.766667
| 109
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/counter/response/CounterNamesTestResponse.java
|
package org.infinispan.server.hotrod.counter.response;
import static java.util.Collections.emptyList;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.readString;
import java.util.ArrayList;
import java.util.Collection;
import org.infinispan.server.core.transport.VInt;
import org.infinispan.server.hotrod.HotRodOperation;
import org.infinispan.server.hotrod.OperationStatus;
import org.infinispan.server.hotrod.test.AbstractTestTopologyAwareResponse;
import org.infinispan.server.hotrod.test.TestResponse;
import io.netty.buffer.ByteBuf;
/**
* A {@link TestResponse} extension that contains the a collection of counter names.
*
* @author Pedro Ruivo
* @since 9.2
*/
public class CounterNamesTestResponse extends TestResponse {
private final Collection<String> counterNames;
public CounterNamesTestResponse(byte version, long messageId, String cacheName, short clientIntel,
HotRodOperation operation, OperationStatus status,
int topologyId, AbstractTestTopologyAwareResponse topologyResponse,
ByteBuf buffer) {
super(version, messageId, cacheName, clientIntel, operation, status, topologyId, topologyResponse);
this.counterNames = readCounterNames(buffer);
}
private static Collection<String> readCounterNames(ByteBuf buffer) {
int size = VInt.read(buffer);
if (size == 0) {
return emptyList();
}
Collection<String> names = new ArrayList<>(size);
for (int i = 0; i < size; ++i) {
names.add(readString(buffer));
}
return names;
}
public Collection<String> getCounterNames() {
return counterNames;
}
}
| 1,660
| 31.568627
| 105
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/counter/response/CounterValueTestResponse.java
|
package org.infinispan.server.hotrod.counter.response;
import org.infinispan.server.hotrod.HotRodOperation;
import org.infinispan.server.hotrod.OperationStatus;
import org.infinispan.server.hotrod.test.AbstractTestTopologyAwareResponse;
import org.infinispan.server.hotrod.test.TestResponse;
/**
* A counter test response for operations that return the counter's value.
*
* @author Pedro Ruivo
* @since 9.2
*/
public class CounterValueTestResponse extends TestResponse {
private final long value;
public CounterValueTestResponse(byte version, long messageId, String cacheName, short clientIntel,
HotRodOperation operation, OperationStatus status, int topologyId,
AbstractTestTopologyAwareResponse topologyResponse, long value) {
super(version, messageId, cacheName, clientIntel, operation, status, topologyId, topologyResponse);
this.value = value;
}
public long getValue() {
return value;
}
}
| 955
| 31.965517
| 105
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/counter/impl/StrongCounterImplTestStrategy.java
|
package org.infinispan.server.hotrod.counter.impl;
import static java.util.Arrays.asList;
import static org.infinispan.counter.api.CounterConfiguration.builder;
import static org.infinispan.counter.api.CounterType.BOUNDED_STRONG;
import static org.infinispan.counter.api.CounterType.UNBOUNDED_STRONG;
import static org.infinispan.counter.impl.Util.awaitCounterOperation;
import static org.infinispan.commons.test.Exceptions.expectException;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertNotNull;
import static org.testng.AssertJUnit.assertTrue;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.function.Supplier;
import org.infinispan.counter.api.CounterConfiguration;
import org.infinispan.counter.api.CounterEvent;
import org.infinispan.counter.api.CounterListener;
import org.infinispan.counter.api.CounterManager;
import org.infinispan.counter.api.CounterState;
import org.infinispan.counter.api.Handle;
import org.infinispan.counter.api.StrongCounter;
import org.infinispan.counter.exception.CounterOutOfBoundsException;
import org.infinispan.server.hotrod.counter.StrongCounterTestStrategy;
/**
* The {@link StrongCounterTestStrategy} implementation.
*
* @author Pedro Ruivo
* @since 9.2
*/
public class StrongCounterImplTestStrategy extends BaseCounterImplTest<StrongCounter> implements
StrongCounterTestStrategy {
private final Supplier<Collection<CounterManager>> allCounterManagerSupplier;
public StrongCounterImplTestStrategy(Supplier<CounterManager> counterManagerSupplier,
Supplier<Collection<CounterManager>> allCounterManagerSupplier) {
super(counterManagerSupplier);
this.allCounterManagerSupplier = allCounterManagerSupplier;
}
@Override
public void testCompareAndSet(Method method) {
final String counterName = method.getName();
final CounterManager counterManager = counterManagerSupplier.get();
assertTrue(counterManager.defineCounter(counterName, builder(UNBOUNDED_STRONG).initialValue(2).build()));
StrongCounter counter = counterManager.getStrongCounter(counterName);
assertFalse(awaitCounterOperation(counter.compareAndSet(0, 1)));
assertTrue(awaitCounterOperation(counter.compareAndSet(2, 3)));
}
@Override
public void testCompareAndSwap(Method method) {
final String counterName = method.getName();
final CounterManager counterManager = counterManagerSupplier.get();
assertTrue(counterManager.defineCounter(counterName, builder(UNBOUNDED_STRONG).initialValue(3).build()));
StrongCounter counter = counterManager.getStrongCounter(counterName);
assertEquals(3, (long) awaitCounterOperation(counter.compareAndSwap(0, 1)));
assertEquals(3, (long) awaitCounterOperation(counter.compareAndSwap(3, 2)));
}
@Override
public void testBoundaries(Method method) {
final String counterName = method.getName();
final CounterManager counterManager = counterManagerSupplier.get();
assertTrue(counterManager
.defineCounter(counterName, builder(BOUNDED_STRONG).initialValue(1).lowerBound(0).upperBound(20).build()));
StrongCounter counter = counterManager.getStrongCounter(counterName);
assertCounterValue(counter, 1);
expectException(ExecutionException.class, CounterOutOfBoundsException.class,
() -> counter.addAndGet(-10).get());
expectException(ExecutionException.class, CounterOutOfBoundsException.class,
() -> counter.addAndGet(30).get());
assertCounterValue(counter, 20);
expectException(ExecutionException.class, CounterOutOfBoundsException.class,
() -> counter.compareAndSet(20, -1).get());
assertCounterValue(counter, 20);
expectException(ExecutionException.class, CounterOutOfBoundsException.class,
() -> counter.compareAndSet(20, 21).get());
assertCounterValue(counter, 20);
expectException(ExecutionException.class, CounterOutOfBoundsException.class,
() -> counter.getAndSet(30).get());
assertCounterValue(counter, 20);
}
@Override
public void testListenerWithBounds(Method method) throws InterruptedException {
final String counterName = method.getName();
final CounterManager counterManager = counterManagerSupplier.get();
assertTrue(counterManager
.defineCounter(counterName, builder(BOUNDED_STRONG).initialValue(0).lowerBound(0).upperBound(20).build()));
StrongCounter counter = counterManager.getStrongCounter(counterName);
Handle<EventLogger> handle = counter.addListener(new EventLogger());
add(counter, 1, 1);
expectException(ExecutionException.class, CounterOutOfBoundsException.class,
() -> counter.addAndGet(20).get());
assertCounterValue(counter, 20);
reset(counter);
expectException(CounterOutOfBoundsException.class, () -> add(counter, -1, 0));
assertCounterValue(counter, 0);
assertNextValidEvent(handle, 0, 1);
assertNextEvent(handle, 1, CounterState.VALID, 20, CounterState.UPPER_BOUND_REACHED);
assertNextEvent(handle, 20, CounterState.UPPER_BOUND_REACHED, 0, CounterState.VALID);
assertNextEvent(handle, 0, CounterState.VALID, 0, CounterState.LOWER_BOUND_REACHED);
assertNoEvents(handle);
handle.remove();
}
@Override
public void testSet(Method method) {
final String counterName = method.getName();
final CounterManager counterManager = counterManagerSupplier.get();
assertTrue(counterManager.defineCounter(counterName, builder(UNBOUNDED_STRONG).initialValue(1).build()));
StrongCounter counter = counterManager.getStrongCounter(counterName);
assertCounterValue(counter, 1);
assertEquals(1, (long) awaitCounterOperation(counter.getAndSet(2)));
assertCounterValue(counter, 2);
}
@Override
public <L extends CounterListener> Handle<L> addListenerTo(StrongCounter counter, L logger) {
return counter.addListener(logger);
}
@Override
public StrongCounter defineAndCreateCounter(String counterName, long initialValue) {
final CounterManager counterManager = counterManagerSupplier.get();
assertTrue(
counterManager.defineCounter(counterName, builder(UNBOUNDED_STRONG).initialValue(initialValue).build()));
return counterManager.getStrongCounter(counterName);
}
@Override
public void add(StrongCounter counter, long delta, long result) {
if (delta == 1) {
assertEquals(result, (long) awaitCounterOperation(counter.incrementAndGet()));
} else if (delta == -1) {
assertEquals(result, (long) awaitCounterOperation(counter.decrementAndGet()));
} else {
assertEquals(result, (long) awaitCounterOperation(counter.addAndGet(delta)));
}
}
@Override
void remove(StrongCounter counter) {
awaitCounterOperation(counter.remove());
}
@Override
void assertCounterValue(StrongCounter counter, long value) {
assertEquals(value, (long) awaitCounterOperation(counter.getValue()));
}
@Override
void reset(StrongCounter counter) {
awaitCounterOperation(counter.reset());
}
@Override
List<CounterConfiguration> configurationsToTest() {
return asList(
builder(UNBOUNDED_STRONG).initialValue(5).build(),
builder(BOUNDED_STRONG).initialValue(0).lowerBound(-1).upperBound(1).build()
);
}
@Override
void assertCounterNameAndConfiguration(String counterName, CounterConfiguration configuration) {
allCounterManagerSupplier.get().forEach(counterManager -> {
StrongCounter counter = counterManager.getStrongCounter(counterName);
assertEquals(counterName, counter.getName());
assertEquals(configuration, counter.getConfiguration());
});
}
private void assertNextEvent(Handle<EventLogger> handle, long oldValue, CounterState oldState, long newValue,
CounterState newState)
throws InterruptedException {
CounterEvent event = handle.getCounterListener().waitingPoll();
assertNotNull(event);
assertEquals(oldValue, event.getOldValue());
assertEquals(oldState, event.getOldState());
assertEquals(newValue, event.getNewValue());
assertEquals(newState, event.getNewState());
}
}
| 8,560
| 40.357488
| 119
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/counter/impl/TestStrongCounter.java
|
package org.infinispan.server.hotrod.counter.impl;
import static java.lang.String.format;
import static org.infinispan.counter.exception.CounterOutOfBoundsException.FORMAT_MESSAGE;
import static org.infinispan.counter.exception.CounterOutOfBoundsException.LOWER_BOUND;
import static org.infinispan.counter.exception.CounterOutOfBoundsException.UPPER_BOUND;
import static org.infinispan.server.hotrod.HotRodOperation.COUNTER_GET;
import static org.infinispan.server.hotrod.HotRodOperation.COUNTER_REMOVE;
import static org.infinispan.server.hotrod.HotRodOperation.COUNTER_RESET;
import java.util.concurrent.CompletableFuture;
import java.util.function.BiConsumer;
import java.util.function.BooleanSupplier;
import org.infinispan.counter.api.CounterConfiguration;
import org.infinispan.counter.api.CounterListener;
import org.infinispan.counter.api.Handle;
import org.infinispan.counter.api.StrongCounter;
import org.infinispan.counter.api.SyncStrongCounter;
import org.infinispan.counter.exception.CounterException;
import org.infinispan.counter.exception.CounterOutOfBoundsException;
import org.infinispan.server.hotrod.counter.op.CounterAddOp;
import org.infinispan.server.hotrod.counter.op.CounterCompareAndSwapOp;
import org.infinispan.server.hotrod.counter.op.CounterOp;
import org.infinispan.server.hotrod.counter.op.CounterSetOp;
import org.infinispan.server.hotrod.counter.response.CounterValueTestResponse;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.server.hotrod.test.TestErrorResponse;
import org.infinispan.server.hotrod.test.TestResponse;
import org.infinispan.commons.util.concurrent.CompletableFutures;
/**
* A {@link StrongCounter} implementation for Hot Rod server testing.
*
* @author Pedro Ruivo
* @since 9.2
*/
class TestStrongCounter implements StrongCounter {
private final String name;
private final CounterConfiguration configuration;
private final HotRodClient client;
private final TestCounterNotificationManager notificationManager;
TestStrongCounter(String name, CounterConfiguration configuration, HotRodClient client,
TestCounterNotificationManager notificationManager) {
this.name = name;
this.configuration = configuration;
this.client = client;
this.notificationManager = notificationManager;
}
@Override
public String getName() {
return name;
}
@Override
public CompletableFuture<Long> getValue() {
CounterOp op = new CounterOp(client.protocolVersion(), COUNTER_GET, name);
return executeOp(op, this::handleValue, null);
}
@Override
public CompletableFuture<Long> addAndGet(long delta) {
CounterAddOp op = new CounterAddOp(client.protocolVersion(), name, delta);
return executeOp(op, this::handleValue, () -> delta > 0);
}
@Override
public CompletableFuture<Void> reset() {
CounterOp op = new CounterOp(client.protocolVersion(), COUNTER_RESET, name);
return executeOp(op, this::handleVoid, null);
}
@Override
public <T extends CounterListener> Handle<T> addListener(T listener) {
return notificationManager.register(name, listener);
}
@Override
public CompletableFuture<Long> compareAndSwap(long expect, long update) {
CounterCompareAndSwapOp op = new CounterCompareAndSwapOp(client.protocolVersion(), name, expect, update);
return executeOp(op, this::handleValue, () -> update >= configuration.upperBound());
}
@Override
public CompletableFuture<Long> getAndSet(long value) {
CounterSetOp op = new CounterSetOp(client.protocolVersion(), name, value);
return executeOp(op, this::handleValue, () -> value >= configuration.upperBound());
}
@Override
public CounterConfiguration getConfiguration() {
return configuration;
}
@Override
public CompletableFuture<Void> remove() {
CounterOp op = new CounterOp(client.protocolVersion(), COUNTER_REMOVE, name);
client.execute(op);
return CompletableFutures.completedNull();
}
@Override
public SyncStrongCounter sync() {
throw new UnsupportedOperationException(); //no need for testing
}
private void handleValue(CompletableFuture<Long> future, TestResponse response) {
future.complete(((CounterValueTestResponse) response).getValue());
}
private void handleVoid(CompletableFuture<Void> future, @SuppressWarnings("unused") TestResponse unused) {
future.complete(null);
}
private <T> CompletableFuture<T> executeOp(CounterOp op,
BiConsumer<CompletableFuture<T>, TestResponse> responseHandler, BooleanSupplier canReachUpperBound) {
TestResponse response = client.execute(op);
CompletableFuture<T> future = new CompletableFuture<>();
switch (response.getStatus()) {
case Success:
responseHandler.accept(future, response);
break;
case OperationNotExecuted:
responseHandler.accept(future, response);
break;
case KeyDoesNotExist:
future.completeExceptionally(new IllegalStateException("Counter Not Found!"));
break;
case ServerError:
future.completeExceptionally(new CounterException(((TestErrorResponse) response).msg));
break;
case NotExecutedWithPrevious:
future.completeExceptionally(canReachUpperBound.getAsBoolean() ?
new CounterOutOfBoundsException(format(FORMAT_MESSAGE, UPPER_BOUND)) :
new CounterOutOfBoundsException(format(FORMAT_MESSAGE, LOWER_BOUND))
);
break;
default:
future.completeExceptionally(new Exception("unknown response " + response));
}
return future;
}
}
| 5,800
| 38.462585
| 147
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/counter/impl/TestCounterManager.java
|
package org.infinispan.server.hotrod.counter.impl;
import static org.infinispan.server.hotrod.HotRodOperation.COUNTER_GET_CONFIGURATION;
import static org.infinispan.server.hotrod.HotRodOperation.COUNTER_GET_NAMES;
import static org.infinispan.server.hotrod.HotRodOperation.COUNTER_IS_DEFINED;
import static org.infinispan.server.hotrod.HotRodOperation.COUNTER_REMOVE;
import static org.infinispan.server.hotrod.OperationStatus.Success;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.infinispan.counter.api.CounterConfiguration;
import org.infinispan.counter.api.CounterManager;
import org.infinispan.counter.api.CounterType;
import org.infinispan.counter.api.StrongCounter;
import org.infinispan.counter.api.WeakCounter;
import org.infinispan.server.hotrod.counter.op.CounterOp;
import org.infinispan.server.hotrod.counter.op.CreateCounterOp;
import org.infinispan.server.hotrod.counter.response.CounterConfigurationTestResponse;
import org.infinispan.server.hotrod.counter.response.CounterNamesTestResponse;
import org.infinispan.server.hotrod.test.HotRodClient;
import org.infinispan.server.hotrod.test.Op;
import org.infinispan.server.hotrod.test.TestResponse;
/**
* A {@link CounterManager} for Hot Rod server testing.
*
* @author Pedro Ruivo
* @since 9.2
*/
public class TestCounterManager implements CounterManager {
private final HotRodClient client;
private final TestCounterNotificationManager notificationManager;
private final Map<String, Object> counters;
public TestCounterManager(HotRodClient client) {
this.client = client;
counters = new ConcurrentHashMap<>();
notificationManager = new TestCounterNotificationManager(client);
notificationManager.start();
}
@Override
public StrongCounter getStrongCounter(String name) {
StrongCounter c = (StrongCounter) counters.get(name);
if (c == null) {
CounterConfiguration config = getConfiguration(name);
if (config == null || config.type() == CounterType.WEAK) {
throw new IllegalStateException();
}
c = new TestStrongCounter(name, config, client, notificationManager);
counters.put(name, c);
}
return c;
}
@Override
public WeakCounter getWeakCounter(String name) {
WeakCounter c = (WeakCounter) counters.get(name);
if (c == null) {
CounterConfiguration config = getConfiguration(name);
if (config == null || config.type() != CounterType.WEAK) {
throw new IllegalStateException();
}
c = new TestWeakCounter(name, config, client, notificationManager);
counters.put(name, c);
}
return c;
}
@Override
public boolean defineCounter(String name, CounterConfiguration configuration) {
CreateCounterOp op = new CreateCounterOp(client.protocolVersion(), name, configuration);
TestResponse response = client.execute(op);
return response.getStatus() == Success;
}
@Override
public void undefineCounter(String name) {
}
@Override
public boolean isDefined(String name) {
CounterOp op = new CounterOp(client.protocolVersion(), COUNTER_IS_DEFINED, name);
TestResponse response = client.execute(op);
return response.getStatus() == Success;
}
@Override
public CounterConfiguration getConfiguration(String counterName) {
CounterOp op = new CounterOp(client.protocolVersion(), COUNTER_GET_CONFIGURATION, counterName);
TestResponse response = client.execute(op);
return response.getStatus() == Success ?
((CounterConfigurationTestResponse) response).getConfiguration() :
null;
}
@Override
public void remove(String counterName) {
CounterOp op = new CounterOp(client.protocolVersion(), COUNTER_REMOVE, counterName);
client.execute(op);
}
public Collection<String> getCounterNames() {
Op op = new Op(0xA0, client.protocolVersion(), (byte) COUNTER_GET_NAMES.getRequestOpCode(), "", null, 0, 0, null,
0, 0, (byte) 0, 0);
CounterNamesTestResponse response = client.execute(op);
return response.getCounterNames();
}
}
| 4,224
| 36.389381
| 119
|
java
|
null |
infinispan-main/server/hotrod/src/test/java/org/infinispan/server/hotrod/counter/impl/BaseCounterImplTest.java
|
package org.infinispan.server.hotrod.counter.impl;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNotNull;
import static org.testng.AssertJUnit.assertTrue;
import java.lang.reflect.Method;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
import org.infinispan.counter.api.CounterConfiguration;
import org.infinispan.counter.api.CounterEvent;
import org.infinispan.counter.api.CounterListener;
import org.infinispan.counter.api.CounterManager;
import org.infinispan.counter.api.CounterState;
import org.infinispan.counter.api.Handle;
import org.infinispan.counter.api.StrongCounter;
import org.infinispan.counter.api.WeakCounter;
import org.infinispan.server.hotrod.counter.BaseCounterTestStrategy;
/**
* The {@link BaseCounterTestStrategy} implementation.
*
* @param <T> the counter implementation ({@link StrongCounter} or {@link WeakCounter})
* @author Pedro Ruivo
* @since 9.2
*/
public abstract class BaseCounterImplTest<T> implements BaseCounterTestStrategy {
final Supplier<CounterManager> counterManagerSupplier;
BaseCounterImplTest(Supplier<CounterManager> counterManagerSupplier) {
this.counterManagerSupplier = counterManagerSupplier;
}
public static void assertNextValidEvent(Handle<EventLogger> eventLogger, long oldValue, long newValue)
throws InterruptedException {
CounterEvent event = eventLogger.getCounterListener().waitingPoll();
assertValidEvent(event, oldValue, newValue);
}
public static void assertValidEvent(CounterEvent event, long oldValue, long newValue) {
assertNotNull(event);
assertEquals(CounterState.VALID, event.getOldState());
assertEquals(CounterState.VALID, event.getNewState());
assertEquals(oldValue, event.getOldValue());
assertEquals(newValue, event.getNewValue());
}
public static void assertNoEvents(Handle<EventLogger> eventLogger) {
assertTrue(eventLogger.getCounterListener().eventLog.isEmpty());
}
@Override
public void testAdd(Method method) {
final String counterName = method.getName();
final long initialValue = 10;
T counter = defineAndCreateCounter(counterName, initialValue);
assertCounterValue(counter, initialValue);
add(counter, 10, 20);
assertCounterValue(counter, 20);
add(counter, -20, 0);
assertCounterValue(counter, 0);
}
@Override
public void testReset(Method method) {
final String counterName = method.getName();
final long initialValue = 5;
T counter = defineAndCreateCounter(counterName, initialValue);
add(counter, 100, 105);
assertCounterValue(counter, 105);
reset(counter);
assertCounterValue(counter, initialValue);
}
@Override
public void testNameAndConfigurationTest(Method method) {
final String prefix = method.getName();
List<CounterConfiguration> configs = configurationsToTest();
for (int i = 0; i < configs.size(); ++i) {
assertTrue(counterManagerSupplier.get().defineCounter(prefix + i, configs.get(i)));
assertCounterNameAndConfiguration(prefix + i, configs.get(i));
}
}
@Override
public void testRemove(Method method) {
final String counterName = method.getName();
final long initialValue = 5;
T counter = defineAndCreateCounter(counterName, initialValue);
add(counter, 100, 105);
assertCounterValue(counter, 105);
remove(counter);
assertCounterValue(counter, initialValue);
add(counter, -100, -95);
assertCounterValue(counter, -95);
counterManagerSupplier.get().remove(counterName);
assertCounterValue(counter, initialValue);
}
@Override
public void testListenerAddAndRemove(Method method) throws InterruptedException {
final String prefix = method.getName();
T counter1 = defineAndCreateCounter(prefix + "1", 0);
T counter2 = defineAndCreateCounter(prefix + "2", 10);
Handle<EventLogger> handle1 = addListenerTo(counter1, new EventLogger());
Handle<EventLogger> handle1_1 = addListenerTo(counter1, new EventLogger());
Handle<EventLogger> handle2 = addListenerTo(counter2, new EventLogger());
add(counter1, 1, 1);
add(counter1, -1, 0);
add(counter1, 10, 10);
add(counter2, 1, 11);
add(counter2, 2, 13);
assertNextValidEvent(handle1, 0, 1);
assertNextValidEvent(handle1, 1, 0);
assertNextValidEvent(handle1, 0, 10);
assertNextValidEvent(handle1_1, 0, 1);
assertNextValidEvent(handle1_1, 1, 0);
assertNextValidEvent(handle1_1, 0, 10);
assertNextValidEvent(handle2, 10, 11);
assertNextValidEvent(handle2, 11, 13);
assertNoEvents(handle1);
assertNoEvents(handle1_1);
assertNoEvents(handle2);
handle1.remove();
add(counter1, 1, 11);
assertNextValidEvent(handle1_1, 10, 11);
assertNoEvents(handle1);
handle1.remove();
handle1_1.remove();
handle2.remove();
add(counter1, 1, 12);
add(counter2, 1, 14);
assertNoEvents(handle1);
assertNoEvents(handle1_1);
assertNoEvents(handle2);
}
abstract <L extends CounterListener> Handle<L> addListenerTo(T counter, L logger);
abstract void remove(T counter);
abstract T defineAndCreateCounter(String counterName, long initialValue);
abstract void assertCounterValue(T counter, long value);
abstract void add(T counter, long delta, long result);
abstract void reset(T counter);
abstract List<CounterConfiguration> configurationsToTest();
abstract void assertCounterNameAndConfiguration(String counterName, CounterConfiguration configuration);
public static class EventLogger implements CounterListener {
final BlockingQueue<CounterEvent> eventLog;
public EventLogger() {
eventLog = new LinkedBlockingQueue<>();
}
@Override
public void onUpdate(CounterEvent entry) {
eventLog.add(entry);
}
public CounterEvent poll() {
return eventLog.poll();
}
public CounterEvent waitingPoll() throws InterruptedException {
return eventLog.poll(30, TimeUnit.SECONDS);
}
public int size() {
return eventLog.size();
}
}
}
| 6,442
| 30.276699
| 107
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.