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/resp/src/main/java/org/infinispan/server/resp/commands/generic/EXPIRETIME.java
|
package org.infinispan.server.resp.commands.generic;
/**
* @since 15.0
**/
public class EXPIRETIME extends TTL {
public EXPIRETIME() {
super(true, false);
}
}
| 174
| 14.909091
| 52
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/generic/EXPIRE.java
|
package org.infinispan.server.resp.commands.generic;
import static org.infinispan.server.resp.Util.fromUnixTime;
import static org.infinispan.server.resp.Util.toUnixTime;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.TimeUnit;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.ArgumentUtils;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* EXPIRE Resp Command
*
* @link <a href="https://redis.io/commands/expire/">EXPIRE</a>
* @since 15.0
*/
public class EXPIRE extends RespCommand implements Resp3Command {
private static final CompletableFuture<Long> NOT_APPLIED = CompletableFuture.completedFuture(0L);
private static final CompletableFuture<Long> APPLIED = CompletableFuture.completedFuture(1L);
enum Mode {
NONE, NX, XX, GT, LT
}
private final boolean unixTime;
public EXPIRE() {
this(false);
}
protected EXPIRE(boolean at) {
super(-3, 1, 1, 1);
this.unixTime = at;
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] key = arguments.get(0);
long expiration = ArgumentUtils.toLong(arguments.get(1));
Mode mode = Mode.NONE;
if (arguments.size() == 3) {
// Handle mode
mode = Mode.valueOf(new String(arguments.get(2), StandardCharsets.US_ASCII).toUpperCase());
}
return handler.stageToReturn(expire(handler, key, expiration, mode, unixTime), ctx, Consumers.LONG_BICONSUMER);
}
private static CompletionStage<Long> expire(Resp3Handler handler, byte[] key, long expiration, Mode mode, boolean unixTime) {
return handler.cache().getCacheEntryAsync(key).thenCompose(e -> {
if (e == null) {
return NOT_APPLIED;
} else {
long ttl = e.getLifespan();
if (unixTime) {
ttl = toUnixTime(ttl, handler.respServer().getTimeService());
} else if (ttl >= 0) {
ttl = TimeUnit.MILLISECONDS.toSeconds(e.getLifespan());
}
switch (mode) {
case NX:
if (ttl >= 0) {
return NOT_APPLIED;
}
break;
case XX:
if (ttl < 0) {
return NOT_APPLIED;
}
break;
case GT:
if (expiration < ttl) {
return NOT_APPLIED;
}
break;
case LT:
if (expiration > ttl) {
return NOT_APPLIED;
}
break;
}
CompletableFuture<Boolean> replace;
if (unixTime) {
replace = handler.cache().replaceAsync(e.getKey(), e.getValue(), e.getValue(), fromUnixTime(expiration, handler.respServer().getTimeService()), TimeUnit.MILLISECONDS);
} else {
replace = handler.cache().replaceAsync(e.getKey(), e.getValue(), e.getValue(), expiration, TimeUnit.SECONDS);
}
return replace.thenCompose(b -> {
if (b) {
return APPLIED;
} else {
return expire(handler, key, expiration, mode, unixTime);
}
});
}
});
}
}
| 3,859
| 33.464286
| 182
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/generic/EXPIREAT.java
|
package org.infinispan.server.resp.commands.generic;
/**
* @since 15.0
**/
public class EXPIREAT extends EXPIRE {
public EXPIREAT() {
super(true);
}
}
| 166
| 14.181818
| 52
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/generic/EXISTS.java
|
package org.infinispan.server.resp.commands.generic;
import java.util.List;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.atomic.AtomicLong;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.util.concurrent.AggregateCompletionStage;
import org.infinispan.util.concurrent.CompletionStages;
import io.netty.channel.ChannelHandlerContext;
/**
* EXISTS Resp Command
*
* @link https://redis.io/commands/exists/
* @since 15.0
*/
public class EXISTS extends RespCommand implements Resp3Command {
public EXISTS() {
super(-2, 1, -1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
AggregateCompletionStage<Void> acs = CompletionStages.aggregateCompletionStage();
AtomicLong presentCount = new AtomicLong(arguments.size());
for (byte[] bs : arguments) {
acs.dependsOn(handler.cache().touch(bs, false).thenApply((v) -> {
if (!v) {
presentCount.decrementAndGet();
}
return null;
}));
}
return handler.stageToReturn(acs.freeze().thenApply(v -> presentCount.get()), ctx,
Consumers.LONG_BICONSUMER);
}
}
| 1,493
| 31.478261
| 88
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/generic/FLUSHALL.java
|
package org.infinispan.server.resp.commands.generic;
/**
* <a href="https://redis.io/commands/flushall/">FLUSHALL</a>
*
* Currently, it invokes FLUSHDB as Infinispan doesn't support multiple Redis databases yet
*
* @since 15.0
*/
public class FLUSHALL extends FLUSHDB {
}
| 279
| 22.333333
| 91
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/generic/TYPE.java
|
package org.infinispan.server.resp.commands.generic;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.multimap.impl.HashMapBucket;
import org.infinispan.multimap.impl.ListBucket;
import org.infinispan.multimap.impl.SetBucket;
import org.infinispan.multimap.impl.SortedSetBucket;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.RespTypes;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* TYPE Resp Command
* <a href="https://redis.io/commands/type/">type</a>
* @since 15.0
*/
public class TYPE extends RespCommand implements Resp3Command {
public TYPE() {
super(2, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] keyBytes = arguments.get(0);
MediaType vmt = handler.cache().getValueDataConversion().getStorageMediaType();
return handler.stageToReturn(handler.cache().withMediaType(MediaType.APPLICATION_OCTET_STREAM, vmt).getCacheEntryAsync(keyBytes).thenApply(e -> {
if (e == null) {
return RespTypes.none.name().getBytes(StandardCharsets.US_ASCII);
}
Class<?> c = e.getValue().getClass();
if (c == HashMapBucket.class) {
return RespTypes.hash.name().getBytes(StandardCharsets.US_ASCII);
} else if (c == ListBucket.class) {
return RespTypes.list.name().getBytes(StandardCharsets.US_ASCII);
} else if (c == SetBucket.class) {
return RespTypes.set.name().getBytes(StandardCharsets.US_ASCII);
} else if (c == SortedSetBucket.class) {
return RespTypes.zset.name().getBytes(StandardCharsets.US_ASCII);
} else if (c == byte[].class) {
return RespTypes.string.name().getBytes(StandardCharsets.US_ASCII);
} else {
return RespTypes.unknown.name().getBytes(StandardCharsets.US_ASCII);
}
}), ctx, Consumers.GET_BICONSUMER);
}
}
| 2,440
| 41.086207
| 151
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/generic/SCAN.java
|
package org.infinispan.server.resp.commands.generic;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.server.iteration.IterationManager;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.commands.iteration.BaseIterationCommand;
/**
* <a href="https://redis.io/commands/scan/">SCAN</a>
*
* @since 15.0
*/
public class SCAN extends BaseIterationCommand {
public SCAN() {
super(-2, 0, 0, 0);
}
@Override
protected IterationManager retrieveIterationManager(Resp3Handler handler) {
return handler.respServer().getIterationManager();
}
@Override
protected String cursor(List<byte[]> raw) {
return new String(raw.get(0), StandardCharsets.US_ASCII);
}
@Override
protected List<byte[]> writeResponse(List<CacheEntry> response) {
List<byte[]> output = new ArrayList<>(response.size());
for (CacheEntry<?, ?> entry : response) {
output.add((byte[]) entry.getKey());
}
return output;
}
}
| 1,121
| 25.714286
| 78
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/generic/TTL.java
|
package org.infinispan.server.resp.commands.generic;
import static org.infinispan.server.resp.Util.toUnixTime;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* TTL Resp Command
* <a href="https://redis.io/commands/ttl/">ttl</a>
*
* @since 15.0
*/
public class TTL extends RespCommand implements Resp3Command {
private final boolean unixTime;
private final boolean milliseconds;
public TTL() {
this(false, false);
}
protected TTL(boolean unixTime, boolean milliseconds) {
super(2, 1, 1, 1);
this.unixTime = unixTime;
this.milliseconds = milliseconds;
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] keyBytes = arguments.get(0);
return handler.stageToReturn(handler.cache().getCacheEntryAsync(keyBytes).thenApply(e -> {
if (e == null) {
return -2L;
} else {
long ttl = e.getLifespan();
if (unixTime) {
ttl = toUnixTime(ttl, handler.respServer().getTimeService());
}
if (milliseconds) {
return ttl;
} else {
return ttl < 0 ? ttl : ttl / 1000;
}
}
}), ctx, Consumers.LONG_BICONSUMER);
}
}
| 1,752
| 28.711864
| 96
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/generic/FLUSHDB.java
|
package org.infinispan.server.resp.commands.generic;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespErrorUtil;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.Util;
import org.infinispan.server.resp.commands.Resp3Command;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* <a href="https://redis.io/commands/flushdb/">FLUSHDB</a>
*
* @since 15.0
*/
public class FLUSHDB extends RespCommand implements Resp3Command {
private static final byte[] SYNC_BYTES = "SYNC".getBytes(StandardCharsets.US_ASCII);
private static final byte[] ASYNC_BYTES = "ASYNC".getBytes(StandardCharsets.US_ASCII);
public FLUSHDB() {
super(-1, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
if (arguments.size() == 1) {
byte[] mode = arguments.get(0);
if (Util.isAsciiBytesEquals(SYNC_BYTES, mode)) {
return handler.stageToReturn(handler.cache().clearAsync(), ctx, Consumers.OK_BICONSUMER);
} else if (Util.isAsciiBytesEquals(ASYNC_BYTES, mode)) {
handler.cache().clearAsync();
Consumers.OK_BICONSUMER.accept(null, handler.allocator());
return handler.myStage();
} else {
RespErrorUtil.syntaxError(handler.allocator());
return handler.myStage();
}
}
return handler.stageToReturn(handler.cache().clearAsync(), ctx, Consumers.OK_BICONSUMER);
}
}
| 1,880
| 37.387755
| 101
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/generic/PEXPIRETIME.java
|
package org.infinispan.server.resp.commands.generic;
/**
* @since 15.0
**/
public class PEXPIRETIME extends TTL {
public PEXPIRETIME() {
super(true, true);
}
}
| 175
| 15
| 52
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/generic/PTTL.java
|
package org.infinispan.server.resp.commands.generic;
/**
* PTTL Resp Command
* <a href="https://redis.io/commands/pttl/">pttl</a>
* @since 15.0
*/
public class PTTL extends TTL {
public PTTL() {
super(false, true);
}
}
| 237
| 16
| 53
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/iteration/BaseIterationCommand.java
|
package org.infinispan.server.resp.commands.iteration;
import static org.infinispan.server.resp.RespConstants.CRLF_STRING;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.reactive.publisher.impl.DeliveryGuarantee;
import org.infinispan.server.iteration.IterableIterationResult;
import org.infinispan.server.iteration.IterationInitializationContext;
import org.infinispan.server.iteration.IterationManager;
import org.infinispan.server.iteration.IterationState;
import org.infinispan.server.resp.ByteBufferUtils;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
public abstract class BaseIterationCommand extends RespCommand implements Resp3Command {
private static final String INITIAL_CURSOR = "0";
protected BaseIterationCommand(int arity, int firstKeyPos, int lastKeyPos, int steps) {
super(arity, firstKeyPos, lastKeyPos, steps);
}
@Override
public final CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments) {
IterationArguments args = IterationArguments.parse(handler, arguments);
if (args == null) return handler.myStage();
IterationManager manager = retrieveIterationManager(handler);
String cursor = cursor(arguments);
if (INITIAL_CURSOR.equals(cursor)) {
CompletionStage<IterationInitializationContext> initialization = initializeIteration(handler, arguments);
if (initialization != null) {
return initialization.thenCompose(iic -> initializeAndIterate(handler, ctx, manager, args, iic));
}
return initializeAndIterate(handler, ctx, manager, args, null);
}
return iterate(handler, manager, cursor, args);
}
private CompletionStage<RespRequestHandler> initializeAndIterate(Resp3Handler handler, ChannelHandlerContext ctx,
IterationManager manager, IterationArguments arguments,
IterationInitializationContext iic) {
IterationState iterationState = manager.start(handler.cache(), null, arguments.getFilterConverterFactory(),
arguments.getFilterConverterParams(), MediaType.APPLICATION_OCTET_STREAM, arguments.getCount(),
false, DeliveryGuarantee.AT_LEAST_ONCE, iic);
iterationState.getReaper().registerChannel(ctx.channel());
return iterate(handler, manager, iterationState.getId(), arguments);
}
private CompletionStage<RespRequestHandler> iterate(Resp3Handler handler, IterationManager manager, String cursor,
IterationArguments arguments) {
if (manager == null) {
ByteBufferUtils.stringToByteBuf("*2\r\n$1\r\n0\r\n*0\r\n", handler.allocator());
return handler.myStage();
}
IterableIterationResult result = manager.next(cursor, arguments.getCount());
IterableIterationResult.Status status = result.getStatusCode();
if (status == IterableIterationResult.Status.InvalidIteration) {
// Let's just return 0
ByteBufferUtils.stringToByteBuf("*2\r\n$1\r\n0\r\n*0\r\n", handler.allocator());
} else {
StringBuilder response = new StringBuilder();
response.append("*2\r\n");
if (status == IterableIterationResult.Status.Finished) {
// We've reached the end of iteration, return a 0 cursor
response.append("$1\r\n0\r\n");
manager.close(cursor);
} else {
response.append('$');
response.append(cursor.length());
response.append(CRLF_STRING);
response.append(cursor);
response.append(CRLF_STRING);
}
ByteBufferUtils.stringToByteBuf(response, handler.allocator());
ByteBufferUtils.bytesToResult(writeResponse(result.getEntries()), handler.allocator());
}
return handler.myStage();
}
protected abstract IterationManager retrieveIterationManager(Resp3Handler handler);
protected CompletionStage<IterationInitializationContext> initializeIteration(Resp3Handler handler, List<byte[]> arguments) {
return null;
}
protected abstract String cursor(List<byte[]> raw);
protected abstract Collection<byte[]> writeResponse(List<CacheEntry> response);
}
| 4,724
| 45.323529
| 134
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/iteration/IterationArguments.java
|
package org.infinispan.server.resp.commands.iteration;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.List;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespErrorUtil;
import org.infinispan.server.resp.RespTypes;
import org.infinispan.server.resp.Util;
import org.infinispan.server.resp.commands.ArgumentUtils;
import org.infinispan.server.resp.filter.GlobMatchFilterConverterFactory;
public class IterationArguments {
private static final int DEFAULT_COUNT = 10;
private static final byte[] COUNT = "COUNT".getBytes(StandardCharsets.US_ASCII);
private static final byte[] MATCH = "MATCH".getBytes(StandardCharsets.US_ASCII);
private static final byte[] TYPE = "TYPE".getBytes(StandardCharsets.US_ASCII);
private final int count;
private final String filterConverterFactory;
private final List<byte[]> filterConverterParams;
private final RespTypes type;
private IterationArguments(int count, String filterConverterFactory, List<byte[]> filterConverterParams, RespTypes type) {
this.count = count;
this.filterConverterFactory = filterConverterFactory;
this.filterConverterParams = filterConverterParams;
this.type = type;
}
public int getCount() {
return count;
}
public String getFilterConverterFactory() {
return filterConverterFactory;
}
public List<byte[]> getFilterConverterParams() {
return filterConverterParams;
}
public RespTypes getType() {
return type;
}
public static IterationArguments parse(Resp3Handler handler, List<byte[]> arguments) {
int argc = arguments.size();
String filterConverterFactory = null;
List<byte[]> filterConverterParams = null;
int count = DEFAULT_COUNT;
RespTypes type = null;
if (argc > 1) {
for (int i = 1; i < argc; i++) {
byte[] arg = arguments.get(i);
if (Util.isAsciiBytesEquals(MATCH, arg)) {
if (++i >= argc) {
RespErrorUtil.syntaxError(handler.allocator());
return null;
} else {
filterConverterFactory = GlobMatchFilterConverterFactory.class.getName();
filterConverterParams = Collections.singletonList(arguments.get(i));
}
} else if (Util.isAsciiBytesEquals(COUNT, arg)) {
if (++i >= argc) {
RespErrorUtil.syntaxError(handler.allocator());
return null;
} else {
try {
count = ArgumentUtils.toInt(arguments.get(i));
} catch (NumberFormatException e) {
RespErrorUtil.valueNotInteger(handler.allocator());
return null;
}
}
} else if (Util.isAsciiBytesEquals(TYPE, arg)) {
if (++i >= argc) {
RespErrorUtil.syntaxError(handler.allocator());
return null;
} else {
try {
type = RespTypes.valueOf(new String(arguments.get(i), StandardCharsets.US_ASCII));
} catch (IllegalArgumentException e) {
type = RespTypes.unknown;
}
}
}
}
}
return new IterationArguments(count, filterConverterFactory, filterConverterParams, type);
}
}
| 3,479
| 36.021277
| 125
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/RPOP.java
|
package org.infinispan.server.resp.commands.list;
import org.infinispan.server.resp.commands.list.internal.POP;
/**
* @link https://redis.io/commands/rpop/
*
* Removes and returns the last elements of the list stored at key.
*
* By default, the command pops a single element from the end of the list.
* When provided with the optional count argument, the reply will consist of up to count elements,
* depending on the list's length.
*
* @since 15.0
*/
public class RPOP extends POP {
public RPOP() {
super(false);
}
}
| 542
| 24.857143
| 98
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/LREM.java
|
package org.infinispan.server.resp.commands.list;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.multimap.impl.EmbeddedMultimapListCache;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespErrorUtil;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.ArgumentUtils;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/lrem/
*
* Removes the first count occurrences of elements equal to element from the list.
*
* count > 0: Remove elements equal to element moving from head to tail.
* count < 0: Remove elements equal to element moving from tail to head.
* count = 0: Remove all elements equal to element.
*
* When key does not exist, the command will always return 0.
*
* @since 15.0
*/
public class LREM extends RespCommand implements Resp3Command {
public LREM() {
super(4, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] key = arguments.get(0);
Long count;
try {
count = ArgumentUtils.toLong(arguments.get(1));
} catch (NumberFormatException e) {
RespErrorUtil.customError("value is not an integer or out of range", handler.allocator());
return handler.myStage();
}
byte[] element = arguments.get(2);
EmbeddedMultimapListCache<byte[], byte[]> listMultimap = handler.getListMultimap();
return handler.stageToReturn(listMultimap.remove(key, count, element), ctx, Consumers.LONG_BICONSUMER);
}
}
| 1,934
| 33.553571
| 109
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/LPUSHX.java
|
package org.infinispan.server.resp.commands.list;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.server.resp.commands.list.internal.PUSHX;
/**
* @link https://redis.io/commands/lpushx/
* Inserts specified values at the head of the list stored at key,
* only if key already exists and holds a list. In contrary to LPUSH,
* no operation will be performed when key does not yet exist.
* @since 15.0
*/
public class LPUSHX extends PUSHX implements Resp3Command {
public LPUSHX() {
super(true);
}
}
| 546
| 29.388889
| 69
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/LLEN.java
|
package org.infinispan.server.resp.commands.list;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.multimap.impl.EmbeddedMultimapListCache;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/llen/
*
* Returns the length of the list stored at key. If key does not exist,
* it is interpreted as an empty list and 0 is returned.
* When the value at key is not a list, an error is returned.
*
* @since 15.0
*/
public class LLEN extends RespCommand implements Resp3Command {
public LLEN() {
super(2, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] key = arguments.get(0);
EmbeddedMultimapListCache<byte[], byte[]> listMultimap = handler.getListMultimap();
return handler.stageToReturn(listMultimap.size(key), ctx, Consumers.LONG_BICONSUMER);
}
}
| 1,336
| 32.425
| 91
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/LMOVE.java
|
package org.infinispan.server.resp.commands.list;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.multimap.impl.EmbeddedMultimapListCache;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespErrorUtil;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.server.resp.logging.Log;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* @link https://redis.io/commands/lmove/
* <p>
* Atomically returns and removes the first/last element (head/tail depending on the wherefrom argument)
* of the list stored at source, and pushes the element at the first/last element (head/tail depending on the whereto argument)
* of the list stored at destination.
* <p>
* For example: consider source holding the list a,b,c, and destination holding the list x,y,z.
* Executing LMOVE source destination RIGHT LEFT results in source holding a,b and destination holding c,x,y,z.
* <p>
* If source does not exist, the value nil is returned and no operation is performed.
* If source and destination are the same, the operation is equivalent to removing the first/last element
* from the list and pushing it as first/last element of the list,
* so it can be considered as a list rotation command (or a no-op if wherefrom is the same
* as whereto).
* <p>
* This command comes in place of the now deprecated RPOPLPUSH.
* Doing LMOVE RIGHT LEFT is equivalent.
* @since 15.0
*/
public class LMOVE extends RespCommand implements Resp3Command {
public static final String LEFT = "LEFT";
public static final String RIGHT = "RIGHT";
public LMOVE(int arity) {
super(arity, 1, 2, 1);
}
public LMOVE() {
super(5, 1, 2, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx,
List<byte[]> arguments) {
return lmoveAndReturn(handler, ctx, arguments, false);
}
protected CompletionStage<RespRequestHandler> lmoveAndReturn(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments,
boolean rightLeft) {
byte[] source = arguments.get(0);
byte[] destination = arguments.get(1);
boolean sameList = Arrays.equals(source, destination);
if (!sameList) {
// warn when different lists
Log.SERVER.lmoveConsistencyMessage();
}
final boolean isSourceLeft;
final boolean isDestinationLeft;
if (rightLeft) {
isSourceLeft = false;
isDestinationLeft = true;
} else {
// parse and validate RIGHT and LEFT arguments
final String sourceWhereFrom = new String(arguments.get(2)).toUpperCase();
final String destinationWhereFrom = new String(arguments.get(3)).toUpperCase();
isSourceLeft = LEFT.equals(sourceWhereFrom);
isDestinationLeft = LEFT.equals(destinationWhereFrom);
if ((!isSourceLeft && !RIGHT.equals(sourceWhereFrom)) || (!isDestinationLeft && !RIGHT.equals(
destinationWhereFrom))) {
RespErrorUtil.syntaxError(handler.allocator());
return handler.myStage();
}
}
EmbeddedMultimapListCache<byte[], byte[]> listMultimap = handler.getListMultimap();
if (sameList) {
CompletionStage<byte[]> performedCall;
if (isSourceLeft && isDestinationLeft) {
// peek first element and do nothing else
performedCall = listMultimap.index(source, 0);
} else if (!isSourceLeft && !isDestinationLeft) {
// peek last element and do nothing else
performedCall = listMultimap.index(source, -1);
} else {
// rotate from left (head->tail) to right or from right to left (tail->left)
performedCall = listMultimap.rotate(source, isSourceLeft);
}
return handler.stageToReturn(performedCall, ctx, Consumers.GET_BICONSUMER);
}
CompletionStage<Collection<byte[]>> pollCall;
if (isSourceLeft) {
pollCall = listMultimap.pollFirst(source, 1);
} else {
pollCall = listMultimap.pollLast(source, 1);
}
return pollCall.thenCompose( pollResult -> {
if (pollResult == null) {
return handler.stageToReturn(CompletableFutures.completedNull(), ctx, Consumers.GET_BICONSUMER);
}
final byte[] element = pollResult.iterator().next();
CompletionStage<Void> offerCall;
if (isDestinationLeft) {
offerCall = listMultimap.offerFirst(destination, element);
} else {
offerCall = listMultimap.offerLast(destination, element);
}
return handler.stageToReturn(offerCall.thenApply(r -> element), ctx, Consumers.GET_BICONSUMER);
});
}
}
| 5,391
| 39.848485
| 127
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/RPUSHX.java
|
package org.infinispan.server.resp.commands.list;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.server.resp.commands.list.internal.PUSHX;
/**
* @link https://redis.io/commands/rpushx/
* Inserts specified values at the tail of the list stored at key,
* only if key already exists and holds a list. In contrary to LPUSH,
* no operation will be performed when key does not yet exist.
* @since 15.0
*/
public class RPUSHX extends PUSHX implements Resp3Command {
public RPUSHX() {
super(false);
}
}
| 547
| 29.444444
| 69
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/LPOS.java
|
package org.infinispan.server.resp.commands.list;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.multimap.impl.EmbeddedMultimapListCache;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespErrorUtil;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.ArgumentUtils;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.util.concurrent.CompletionStages;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
/**
* @link https://redis.io/commands/lpos/
*
* Returns the element at the given index in the list.
* The index is zero-based, so 0 means the first element, 1 the second element and so on.
* Negative indices can be used to designate elements starting at the tail of the list.
* -1 means the last element.
* When the value at key is not a list, an error is returned.
*
* @since 15.0
*/
public class LPOS extends RespCommand implements Resp3Command {
public static final String COUNT = "COUNT";
public static final String RANK = "RANK";
public static final String MAXLEN = "MAXLEN";
public LPOS() {
super(-3, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
if (arguments.size() % 2 != 0 || arguments.size() > 8) {
//(error) (arguments must come in pairs)
RespErrorUtil.syntaxError(handler.allocator());
return handler.myStage();
}
return lposAndReturn(handler, ctx, arguments);
}
protected CompletionStage<RespRequestHandler> lposAndReturn(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] key = arguments.get(0);
byte[] element = arguments.get(1);
Long count = null;
Long rank = null;
Long maxLen = null;
for (int i = 2; i < arguments.size(); i++) {
String argumentName = new String(arguments.get(i++)).toUpperCase();
long argumentValue = ArgumentUtils.toLong(arguments.get(i));
switch (argumentName) {
case COUNT:
count = argumentValue;
if (count < 0) {
RespErrorUtil.customError("COUNT can't be negative", handler.allocator());
return handler.myStage();
}
break;
case RANK:
rank = argumentValue;
if (rank == 0) {
RespErrorUtil.customError("RANK can't be zero: use 1 to start from the first match, "
+ "2 from the second ... or use negative to start from the end of the list", handler.allocator());
return handler.myStage();
}
break;
case MAXLEN:
maxLen = argumentValue;
if (maxLen < 0) {
RespErrorUtil.customError("MAXLEN can't be negative", handler.allocator());
return handler.myStage();
}
break;
default:
RespErrorUtil.syntaxError(handler.allocator());
return handler.myStage();
}
}
EmbeddedMultimapListCache<byte[], byte[]> listMultimap = handler.getListMultimap();
final boolean returnSingleElement = count == null;
return CompletionStages.handleAndCompose(listMultimap.indexOf(key, element, count, rank, maxLen), (indexes, t) -> {
if (t != null) {
return handleException(handler, t);
}
if (returnSingleElement) {
Long singleIndex = indexes == null || indexes.isEmpty() ? null : indexes.iterator().next();
return handler.stageToReturn(CompletableFuture.completedFuture(singleIndex), ctx, Consumers.LONG_BICONSUMER);
}
return handler.stageToReturn(CompletableFuture.completedFuture(indexes == null ? Collections.emptyList() : indexes), ctx, Consumers.COLLECTION_LONG_BICONSUMER);
});
}
}
| 4,460
| 38.477876
| 169
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/LTRIM.java
|
package org.infinispan.server.resp.commands.list;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.multimap.impl.EmbeddedMultimapListCache;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.ArgumentUtils;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/ltrim/
*
* Trim an existing list so that it will contain only the specified range of elements specified.
* Both start and stop are zero-based indexes, where 0 is the first element of the list (the head),
* 1 the next element and so on.
* start and end can also be negative numbers indicating offsets from the end of the list,
* where -1 is the last element of the list, -2 the penultimate element and so on.
* Out of range indexes will not produce an error:
* if start is larger than the end of the list, or start > end,
* the result will be an empty list (which causes key to be removed).
* If end is larger than the end of the list, the command will treat it like the last element of the list.
* Returns "OK"
* @since 15.0
*/
public class LTRIM extends RespCommand implements Resp3Command {
public LTRIM() {
super(4, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] key = arguments.get(0);
int start = ArgumentUtils.toInt(arguments.get(1));
int stop = ArgumentUtils.toInt(arguments.get(2));
EmbeddedMultimapListCache<byte[], byte[]> listMultimap = handler.getListMultimap();
return handler.stageToReturn(listMultimap.trim(key, start, stop), ctx, Consumers.OK_BICONSUMER);
}
}
| 2,040
| 39.82
| 106
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/RPUSH.java
|
package org.infinispan.server.resp.commands.list;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.server.resp.commands.list.internal.PUSH;
/**
* @link https://redis.io/commands/rpush/
*
* Insert all the specified values at the tail of the list stored at key. If key does not exist,
* it is created as empty list before performing the push operations.
* When key holds a value that is not a list, an error is returned.
* Integer reply: the length of the list after the push operation.
*
* @since 15.0
*/
public class RPUSH extends PUSH implements Resp3Command {
public RPUSH() {
super(false);
}
}
| 650
| 30
| 96
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/LINDEX.java
|
package org.infinispan.server.resp.commands.list;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.multimap.impl.EmbeddedMultimapListCache;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/lindex/
*
* Returns the element at the given index in the list.
* The index is zero-based, so 0 means the first element, 1 the second element and so on.
* Negative indices can be used to designate elements starting at the tail of the list.
* -1 means the last element.
* When the value at key is not a list, an error is returned.
*
* @since 15.0
*/
public class LINDEX extends RespCommand implements Resp3Command {
public LINDEX() {
super(3, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] key = arguments.get(0);
final long index = Long.parseLong(new String(arguments.get(1), StandardCharsets.US_ASCII));
EmbeddedMultimapListCache<byte[], byte[]> listMultimap = handler.getListMultimap();
CompletionStage<byte[]> value = listMultimap.index(key, index);
return handler.stageToReturn(value, ctx, Consumers.GET_BICONSUMER);
}
}
| 1,667
| 36.909091
| 97
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/LSET.java
|
package org.infinispan.server.resp.commands.list;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.multimap.impl.EmbeddedMultimapListCache;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespErrorUtil;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.ArgumentUtils;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.util.concurrent.CompletionStages;
import org.jgroups.util.CompletableFutures;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* @link https://redis.io/commands/lset/
*
* Sets the list element at index to element.
* An error is returned for out of range indexes.
*
* @since 15.0
*/
public class LSET extends RespCommand implements Resp3Command {
public LSET() {
super(4, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] key = arguments.get(0);
long index = ArgumentUtils.toLong(arguments.get(1));
byte[] value = arguments.get(2);
EmbeddedMultimapListCache<byte[], byte[]> listMultimap = handler.getListMultimap();
return CompletionStages.handleAndCompose(listMultimap.set(key, index, value) ,(result, t) -> {
if (t != null) {
return handleException(handler, t);
}
if (!result) {
RespErrorUtil.noSuchKey(handler.allocator());
return handler.myStage();
}
return handler.stageToReturn(CompletableFutures.completedNull(), ctx, Consumers.OK_BICONSUMER);
});
}
}
| 1,888
| 32.732143
| 104
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/RPOPLPUSH.java
|
package org.infinispan.server.resp.commands.list;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* https://redis.io/commands/rpoplpush/
* Is like {@link LMOVE} with RIGHT and LEFT
*
* @since 15.0
*/
public class RPOPLPUSH extends LMOVE implements Resp3Command {
public RPOPLPUSH() {
super(3);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
return lmoveAndReturn(handler, ctx, arguments, true);
}
}
| 865
| 27.866667
| 80
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/LRANGE.java
|
package org.infinispan.server.resp.commands.list;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.multimap.impl.EmbeddedMultimapListCache;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.ArgumentUtils;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.util.concurrent.CompletionStages;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
/**
* https://redis.io/commands/lrange/
*
* Returns the specified elements of the list stored at key.
* The offsets start and stop are zero-based indexes,
* with 0 being the first element of the list (the head of the list),
* 1 being the next element and so on.
*
* These offsets can also be negative numbers indicating offsets starting at the end of the list.
* For example, -1 is the last element of the list, -2 the penultimate, and so on.
*
* Out of range indexes will not produce an error.
* If start is larger than the end of the list, an empty list is returned.
* If stop is larger than the actual end of the list, will treat it like the
* last element of the list.
* @since 15.0
*/
public class LRANGE extends RespCommand implements Resp3Command {
public LRANGE() {
super(4, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] key = arguments.get(0);
int start = ArgumentUtils.toInt(arguments.get(1));
int stop = ArgumentUtils.toInt(arguments.get(2));
EmbeddedMultimapListCache<byte[], byte[]> listMultimap = handler.getListMultimap();
return CompletionStages.handleAndCompose(listMultimap.subList(key, start, stop) ,(c, t) -> {
if (t != null) {
return handleException(handler, t);
}
return handler.stageToReturn(CompletableFuture.completedFuture(c == null ? Collections.emptyList() : c), ctx, Consumers.GET_ARRAY_BICONSUMER);
});
}
}
| 2,345
| 37.459016
| 151
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/LPOP.java
|
package org.infinispan.server.resp.commands.list;
import org.infinispan.server.resp.commands.list.internal.POP;
/**
* @link https://redis.io/commands/lpop/
*
* Removes and returns the first elements of the list stored at key.
*
* By default, the command pops a single element from the end of the list.
* When provided with the optional count argument, the reply will consist of up to count elements,
* depending on the list's length.
*
* @since 15.0
*/
public class LPOP extends POP {
public LPOP() {
super(true);
}
}
| 542
| 24.857143
| 98
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/LPUSH.java
|
package org.infinispan.server.resp.commands.list;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.server.resp.commands.list.internal.PUSH;
/**
* @link https://redis.io/commands/lpush/
* Insert all the specified values at the head of the list stored at key. If key does not exist,
* it is created as empty list before performing the push operations.
* When key holds a value that is not a list, an error is returned.
* Integer reply: the length of the list after the push operation.
* @since 15.0
*/
public class LPUSH extends PUSH implements Resp3Command {
public LPUSH() {
super(true);
}
}
| 643
| 32.894737
| 96
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/LINSERT.java
|
package org.infinispan.server.resp.commands.list;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.multimap.impl.EmbeddedMultimapListCache;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespErrorUtil;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/linsert/
*
* Inserts element in the list stored at key either before or after the reference value pivot.
* When key does not exist, it is considered an empty list and no operation is performed.
* An error is returned when key exists but does not hold a list value.
* Returns the list length after a successful insert operation,
* 0 if the key doesn't exist, and -1 when the pivot wasn't found.
*
* @since 15.0
*/
public class LINSERT extends RespCommand implements Resp3Command {
public static final String BEFORE = "BEFORE";
public static final String AFTER = "AFTER";
public LINSERT() {
super(5, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] key = arguments.get(0);
String position = new String(arguments.get(1)).toUpperCase();
boolean isBefore = position.equals(BEFORE);
if (!isBefore && !position.equals(AFTER)) {
RespErrorUtil.syntaxError(handler.allocator());
return handler.myStage();
}
byte[] pivot = arguments.get(2);
byte[] element = arguments.get(3);
EmbeddedMultimapListCache<byte[], byte[]> listMultimap = handler.getListMultimap();
return handler.stageToReturn(listMultimap.insert(key, isBefore, pivot, element), ctx, Consumers.LONG_BICONSUMER);
}
}
| 2,066
| 35.910714
| 119
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/internal/PUSH.java
|
package org.infinispan.server.resp.commands.list.internal;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.multimap.impl.EmbeddedMultimapListCache;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.util.concurrent.AggregateCompletionStage;
import org.infinispan.util.concurrent.CompletionStages;
import io.netty.channel.ChannelHandlerContext;
/**
* Abstract class for common code on PUSH operations
*
* @since 15.0
*/
public abstract class PUSH extends RespCommand implements Resp3Command {
protected boolean first;
public PUSH(boolean first) {
super(-3, 1, 1, 1);
this.first = first;
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
return pushAndReturn(handler, ctx, arguments);
}
protected CompletionStage<RespRequestHandler> pushAndReturn(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] key = arguments.get(0);
EmbeddedMultimapListCache<byte[], byte[]> listMultimap = handler.getListMultimap();
AggregateCompletionStage<Void> aggregateCompletionStage = CompletionStages.aggregateCompletionStage();
// TODO: putAll operation on listMultimap ?
for (int i = 1; i < arguments.size(); i++) {
CompletionStage<Void> push = first ? listMultimap.offerFirst(key, arguments.get(i)) : listMultimap.offerLast(key, arguments.get(i));
aggregateCompletionStage.dependsOn(push);
}
CompletionStage<Long> cs = aggregateCompletionStage.freeze().thenCompose(ignore -> listMultimap.size(key));
return handler.stageToReturn(cs, ctx, Consumers.LONG_BICONSUMER);
}
}
| 2,189
| 39.555556
| 141
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/internal/PUSHX.java
|
package org.infinispan.server.resp.commands.list.internal;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.multimap.impl.EmbeddedMultimapListCache;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.util.concurrent.CompletionStages;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
/**
* Abstract class for common code on PUSHX operations.
*
* @since 15.0
*/
public abstract class PUSHX extends PUSH implements Resp3Command {
public PUSHX(boolean first) {
super(first);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
EmbeddedMultimapListCache<byte[], byte[]> listCache = handler.getListMultimap();
byte[] key = arguments.get(0);
CompletionStage<Boolean> containsKey = listCache.containsKey(key);
return CompletionStages.handleAndCompose(containsKey, (exists, t1) -> {
if (exists) {
return pushAndReturn(handler, ctx, arguments);
}
return handler
.stageToReturn(CompletableFuture.completedFuture(0L),
ctx, Consumers.LONG_BICONSUMER);
});
}
}
| 1,537
| 34.767442
| 86
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/list/internal/POP.java
|
package org.infinispan.server.resp.commands.list.internal;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.multimap.impl.EmbeddedMultimapListCache;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespErrorUtil;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.ArgumentUtils;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.util.concurrent.CompletionStages;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
/**
* Abstract class for common code on POP operations
*
* @since 15.0
*/
public abstract class POP extends RespCommand implements Resp3Command {
protected boolean first;
public POP(boolean first) {
super(-2, 1, 1, 1);
this.first = first;
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
return popAndReturn(handler, ctx, arguments);
}
protected CompletionStage<RespRequestHandler> popAndReturn(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] key = arguments.get(0);
final long count;
if (arguments.size() > 1) {
count = ArgumentUtils.toLong(arguments.get(1));
if (count < 0) {
RespErrorUtil.mustBePositive(handler.allocator());
return handler.myStage();
}
} else {
count = 1;
}
EmbeddedMultimapListCache<byte[], byte[]> listMultimap = handler.getListMultimap();
CompletionStage<Collection<byte[]>> pollValues = first ?
listMultimap.pollFirst(key, count) :
listMultimap.pollLast(key, count);
return CompletionStages.handleAndCompose(pollValues ,(c, t) -> {
if (t != null) {
return handleException(handler, t);
}
if (c == null) {
return handler.stageToReturn(CompletableFuture.completedFuture(null), ctx, Consumers.GET_BICONSUMER);
}
if (c.size() == 1 && arguments.size() == 1) {
// one single element and count argument was not present, return the value as string
return handler.stageToReturn(CompletableFuture.completedFuture(c.iterator().next()), ctx, Consumers.GET_BICONSUMER);
}
// return an array of strings
return handler.stageToReturn(CompletableFuture.completedFuture(c), ctx, Consumers.GET_ARRAY_BICONSUMER);
});
}
}
| 2,925
| 36.512821
| 128
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/pubsub/PUNSUBSCRIBE.java
|
package org.infinispan.server.resp.commands.pubsub;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.server.resp.ByteBufferUtils;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.SubscriberHandler;
import org.infinispan.server.resp.commands.PubSubResp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/punsubscribe/
* @since 14.0
*/
public class PUNSUBSCRIBE extends RespCommand implements PubSubResp3Command {
public PUNSUBSCRIBE() {
super(-1, 0,0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(SubscriberHandler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
ByteBufferUtils.stringToByteBuf("-ERR not implemented yet\r\n", handler.allocator());
return handler.myStage();
}
}
| 1,033
| 32.354839
| 91
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/pubsub/PSUBSCRIBE.java
|
package org.infinispan.server.resp.commands.pubsub;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.server.resp.ByteBufferUtils;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.SubscriberHandler;
import org.infinispan.server.resp.commands.PubSubResp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/psubscribe/
* @since 14.0
*/
public class PSUBSCRIBE extends RespCommand implements PubSubResp3Command {
public PSUBSCRIBE() {
super(-2, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(SubscriberHandler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
ByteBufferUtils.stringToByteBuf("-ERR not implemented yet\r\n", handler.allocator());
return handler.myStage();
}
}
| 1,028
| 32.193548
| 91
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/pubsub/UNSUBSCRIBE.java
|
package org.infinispan.server.resp.commands.pubsub;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.commons.marshall.WrappedByteArray;
import org.infinispan.server.resp.commands.PubSubResp3Command;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.SubscriberHandler;
import org.infinispan.util.concurrent.AggregateCompletionStage;
import org.infinispan.util.concurrent.CompletionStages;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* @link https://redis.io/commands/ubsubscribe/
* @since 14.0
*/
public class UNSUBSCRIBE extends RespCommand implements PubSubResp3Command {
public static final String NAME = "UNSUBSCRIBE";
public UNSUBSCRIBE() {
super(NAME, -1, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(SubscriberHandler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
AggregateCompletionStage<Void> aggregateCompletionStage = CompletionStages.aggregateCompletionStage();
if (arguments.size() == 0) {
return handler.unsubscribeAll(ctx);
} else {
for (byte[] keyChannel : arguments) {
WrappedByteArray wrappedByteArray = new WrappedByteArray(keyChannel);
SubscriberHandler.PubSubListener listener = handler.specificChannelSubscribers().remove(wrappedByteArray);
if (listener != null) {
aggregateCompletionStage.dependsOn(handler.handleStageListenerError(handler.cache().removeListenerAsync(listener), keyChannel, false));
}
}
}
return handler.sendSubscriptions(ctx, aggregateCompletionStage.freeze(), arguments, false);
}
}
| 1,861
| 40.377778
| 150
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/pubsub/SUBSCRIBE.java
|
package org.infinispan.server.resp.commands.pubsub;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.CharsetUtil;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.commons.marshall.WrappedByteArray;
import org.infinispan.server.resp.commands.PubSubResp3Command;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.SubscriberHandler;
import org.infinispan.server.resp.logging.Log;
import org.infinispan.util.concurrent.AggregateCompletionStage;
import org.infinispan.util.concurrent.CompletionStages;
import java.lang.invoke.MethodHandles;
import java.nio.ByteBuffer;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* @link https://redis.io/commands/subscribe/
* @since 14.0
*/
public class SUBSCRIBE extends RespCommand implements Resp3Command, PubSubResp3Command {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass(), Log.class);
public SUBSCRIBE() {
super(-2, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
SubscriberHandler subscriberHandler = new SubscriberHandler(handler.respServer(), handler);
return subscriberHandler.handleRequest(ctx, this, arguments);
}
@Override
public CompletionStage<RespRequestHandler> perform(SubscriberHandler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
AggregateCompletionStage<Void> aggregateCompletionStage = CompletionStages.aggregateCompletionStage();
for (byte[] keyChannel : arguments) {
if (log.isTraceEnabled()) {
log.tracef("Subscriber for channel: " + CharsetUtil.UTF_8.decode(ByteBuffer.wrap(keyChannel)));
}
WrappedByteArray wrappedByteArray = new WrappedByteArray(keyChannel);
if (handler.specificChannelSubscribers().get(wrappedByteArray) == null) {
SubscriberHandler.PubSubListener pubSubListener = new SubscriberHandler.PubSubListener(ctx.channel(), handler.cache().getKeyDataConversion(), handler.cache().getValueDataConversion());
handler.specificChannelSubscribers().put(wrappedByteArray, pubSubListener);
byte[] channel = KeyChannelUtils.keyToChannel(keyChannel);
CompletionStage<Void> stage = handler.cache().addListenerAsync(pubSubListener, new SubscriberHandler.ListenerKeyFilter(channel, handler.cache().getKeyDataConversion()), null);
aggregateCompletionStage.dependsOn(handler.handleStageListenerError(stage, keyChannel, true));
}
}
return handler.sendSubscriptions(ctx, aggregateCompletionStage.freeze(), arguments, true);
}
}
| 3,106
| 49.112903
| 196
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/pubsub/PUBLISH.java
|
package org.infinispan.server.resp.commands.pubsub;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.server.resp.ByteBufferUtils;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import java.util.List;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.TimeUnit;
/**
* @link https://redis.io/commands/publish/
* @since 14.0
*/
public class PUBLISH extends RespCommand implements Resp3Command {
public PUBLISH() {
super(3, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
// TODO: should we return the # of subscribers on this node?
// We use expiration to remove the event values eventually while preventing them during high periods of
// updates
return handler.stageToReturn(handler.ignorePreviousValuesCache()
.putAsync(KeyChannelUtils.keyToChannel(arguments.get(0)), arguments.get(1), 3, TimeUnit.SECONDS), ctx,
(ignore, alloc) -> ByteBufferUtils.stringToByteBuf(":0\r\n", alloc)
);
}
}
| 1,378
| 37.305556
| 114
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/pubsub/KeyChannelUtils.java
|
package org.infinispan.server.resp.commands.pubsub;
import java.util.Arrays;
public final class KeyChannelUtils {
private KeyChannelUtils() {
}
// Random bytes to keep listener keys separate from others. Means `resp|`.
public static final byte[] PREFIX_CHANNEL_BYTES = new byte[]{114, 101, 115, 112, 124};
public static byte[] keyToChannel(byte[] keyBytes) {
byte[] result = new byte[keyBytes.length + PREFIX_CHANNEL_BYTES.length];
System.arraycopy(PREFIX_CHANNEL_BYTES, 0, result, 0, PREFIX_CHANNEL_BYTES.length);
System.arraycopy(keyBytes, 0, result, PREFIX_CHANNEL_BYTES.length, keyBytes.length);
return result;
}
public static byte[] channelToKey(byte[] channelBytes) {
return Arrays.copyOfRange(channelBytes, PREFIX_CHANNEL_BYTES.length, channelBytes.length);
}
}
| 829
| 33.583333
| 96
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/sortedset/ZRANGE.java
|
package org.infinispan.server.resp.commands.sortedset;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.multimap.impl.EmbeddedMultimapSortedSetCache;
import org.infinispan.multimap.impl.SortedSetBucket;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* TODO: implement all the command, this is just the start point to help testing ZADD
*
* @since 15.0
* @see <a href="https://redis.io/commands/zrange">Redis Documentation</a>
*/
public class ZRANGE extends RespCommand implements Resp3Command {
public ZRANGE() {
super(-4, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
// TODO: implement the command correctly
byte[] name = arguments.get(0);
EmbeddedMultimapSortedSetCache sortedSetCache = handler.getSortedSeMultimap();
CompletionStage<Collection<SortedSetBucket.ScoredValue>> getSortedSet = sortedSetCache.get(name);
CompletionStage<List<byte[]>> list = getSortedSet
.thenApply(
r -> {
List<byte[]> result = new ArrayList<>();
r.stream().forEach(e -> {
result.add((byte[]) e.getValue());
result.add(Double.toString(e.score()).getBytes(StandardCharsets.US_ASCII));
});
return result;
});
return handler.stageToReturn(list, ctx, Consumers.GET_ARRAY_BICONSUMER);
}
}
| 1,970
| 36.903846
| 103
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/sortedset/ZPOPMAX.java
|
package org.infinispan.server.resp.commands.sortedset;
import org.infinispan.server.resp.commands.sortedset.internal.POP;
/**
* ZPOPMAX key [count]
* Removes and returns up to count members with the highest scores in the sorted set stored at key.
*
* When left unspecified, the default value for count is 1.
* Specifying a count value that is higher than the sorted set's cardinality will not produce an error.
* When returning multiple elements, the one with the highest score will be the first, followed
* by the elements with lower scores.
*
* @since 15.0
* @see <a href="https://redis.io/commands/zpopmax/">Redis Documentation</a>
*/
public class ZPOPMAX extends POP {
public ZPOPMAX() {
super(false);
}
}
| 736
| 31.043478
| 103
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/sortedset/ZADD.java
|
package org.infinispan.server.resp.commands.sortedset;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.multimap.impl.EmbeddedMultimapSortedSetCache;
import org.infinispan.multimap.impl.SortedSetAddArgs;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespErrorUtil;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.ArgumentUtils;
import org.infinispan.server.resp.commands.Resp3Command;
import java.util.List;
import java.util.concurrent.CompletionStage;
import static org.infinispan.multimap.impl.SortedSetAddArgs.ADD_AND_UPDATE_ONLY_INCOMPATIBLE_ERROR;
/**
* Adds all the specified members with the specified scores to the sorted set stored at key.
* It is possible to specify multiple score / member pairs.
* If a specified member is already a member of the sorted set,
* the score is updated and the element reinserted at the right position to ensure the correct ordering.
* <p>
* If key does not exist, a new sorted set with the specified members as sole members is created,
* like if the sorted set was empty.
* If the key exists but does not hold a sorted set, an error is returned.
* <p>
* Options:
* <ul>
* <li>XX: Only update elements that already exist. Don't add new elements.</li>
* <li>NX: Only add new elements. Don't update already existing elements.</li>
* <li>LT: Only update existing elements if the new score is less than the current score. This flag doesn't prevent adding new elements.</li>
* <li>GT: Only update existing elements if the new score is greater than the current score. This flag doesn't prevent adding new elements.</li>
* <li>CH: Modify the return value from the number of new elements added, to the total number of elements changed.
* Changed elements are new elements added and elements already existing for which the score was updated.
* Normally the return value of ZADD only counts the number of new elements added.</li>
* <li>INCR: When this option is specified ZADD acts like ZINCRBY. Only one score-element pair can be specified in this mode.</li>
* Note: The GT, LT and NX options are mutually exclusive.
* </ul>
* The score values should be the string representation of a double precision floating
* point number. +inf and -inf values are valid values as well.
*
* @since 15.0
* @see <a href="https://redis.io/commands/zadd">Redis Documentation</a>
*/
public class ZADD extends RespCommand implements Resp3Command {
public static final String XX = "XX";
public static final String NX = "NX";
public static final String LT = "LT";
public static final String GT = "GT";
public static final String CH = "CH";
public static final String INCR = "INCR";
public static final List<String> ARGUMENTS = List.of(XX, NX, LT, GT, CH, INCR);
public ZADD() {
super(-4, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
//zadd key [NX|XX] [GT|LT] [CH] [INCR] score member [score member ...]
// TODO: INCR Option in ISPN-14612
byte[] name = arguments.get(0);
SortedSetAddArgs.Builder addManyArgs = SortedSetAddArgs.create();
EmbeddedMultimapSortedSetCache<byte[], byte[]> sortedSetCache = handler.getSortedSeMultimap();
int pos = 1;
while (pos < arguments.size()) {
String arg = new String(arguments.get(pos));
if (ARGUMENTS.contains(arg)) {
parseArgument(addManyArgs, arg);
pos++;
} else {
break;
}
}
// Validate arguments
SortedSetAddArgs sortedSetAddArgs;
try {
sortedSetAddArgs = addManyArgs.build();
} catch (IllegalArgumentException ex) {
if (ex.getMessage().equals(ADD_AND_UPDATE_ONLY_INCOMPATIBLE_ERROR)) {
RespErrorUtil.customError("XX and NX options at the same time are not compatible", handler.allocator());
} else {
RespErrorUtil.customError("GT, LT, and/or NX options at the same time are not compatible", handler.allocator());
}
return handler.myStage();
}
// Validate scores and values in pairs
if ((arguments.size() - pos) % 2 != 0) {
// Scores and Values come in pairs
RespErrorUtil.syntaxError(handler.allocator());
return handler.myStage();
}
int count = (arguments.size() - pos) / 2;
double[] scores = new double[count];
byte[][] values = new byte[count][];
int i = 0;
while (pos < arguments.size()) {
double score;
try {
score = ArgumentUtils.toDouble(arguments.get(pos++));
} catch (NumberFormatException e) {
// validate number format
RespErrorUtil.valueNotAValidFloat(handler.allocator());
return handler.myStage();
}
byte[] value = arguments.get(pos++);
scores[i] = score;
values[i] = value;
i++;
}
return handler.stageToReturn(sortedSetCache.addMany(name, scores, values, sortedSetAddArgs), ctx,
Consumers.LONG_BICONSUMER);
}
private void parseArgument(SortedSetAddArgs.Builder addManyArgs, String argument) {
switch (argument) {
case NX:
addManyArgs.addOnly();
break;
case XX:
addManyArgs.updateOnly();
break;
case GT:
addManyArgs.updateGreaterScoresOnly();
break;
case LT:
addManyArgs.updateLessScoresOnly();
break;
case CH:
addManyArgs.returnChangedCount();
break;
default:
}
}
}
| 5,957
| 38.72
| 144
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/sortedset/ZPOPMIN.java
|
package org.infinispan.server.resp.commands.sortedset;
import org.infinispan.server.resp.commands.sortedset.internal.POP;
/**
* Removes and returns up to count members with the lowest scores in the sorted set stored at key.
*
* When left unspecified, the default value for count is 1. Specifying a count value that is higher
* than the sorted set's cardinality will not produce an error. When returning multiple elements,
* the one with the lowest score will be the first, followed by the elements with greater scores.
*
* @since 15.0
* @see <a href="https://redis.io/commands/zpopmax/">Redis Documentation</a>
*/
public class ZPOPMIN extends POP {
public ZPOPMIN() {
super(true);
}
}
| 709
| 32.809524
| 99
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/sortedset/ZCARD.java
|
package org.infinispan.server.resp.commands.sortedset;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.multimap.impl.EmbeddedMultimapSortedSetCache;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* Returns the sorted set number of elements.
*
* @since 15.0
* @see <a href="https://redis.io/commands/zcard">Redis Documentation</a>
*/
public class ZCARD extends RespCommand implements Resp3Command {
public ZCARD() {
super(2, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] name = arguments.get(0);
EmbeddedMultimapSortedSetCache sortedSetCache = handler.getSortedSeMultimap();
return handler.stageToReturn(sortedSetCache.size(name), ctx, Consumers.LONG_BICONSUMER);
}
}
| 1,231
| 33.222222
| 94
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/sortedset/ZCOUNT.java
|
package org.infinispan.server.resp.commands.sortedset;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespErrorUtil;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.ArgumentUtils;
import org.infinispan.server.resp.commands.Resp3Command;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* Returns the number of elements in the sorted set at key with a score between min and max.
* Min and max can be -inf and +inf, so that you are not required to know the highest or lowest score
* in the sorted set to get all elements from or up to a certain score.
*
* By default, the interval specified by min and max is closed (inclusive).
* It is possible to specify an open interval (exclusive) by prefixing the score with the character (.
* min and max can be -inf and +inf, so that you are not required to know the highest or
* lowest score in the sorted set to get all elements from or up to a certain score.
* For example:
* - ZCOUNT people (1 5 Will return all elements with 1 < score <= 5
* while:
* - ZCOUNT people (5 (10
* Will return all the elements with 5 < score < 10 (5 and 10 excluded).
*
* @since 15.0
* @see <a href="https://redis.io/commands/zcount">Redis Documentation</a>
*/
public class ZCOUNT extends RespCommand implements Resp3Command {
public ZCOUNT() {
super(4, 1, 1, 1);
}
public static byte INCLUDE = ((byte)'(');
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] name = arguments.get(0);
byte[] min = arguments.get(1);
byte[] max = arguments.get(2);
boolean includeMin = true;
boolean includeMax = true;
double min_val;
double max_val;
try {
if (ArgumentUtils.isNegativeInf(min)) {
min_val = Double.MIN_VALUE;
} else if (min[0] == INCLUDE) {
includeMin = false;
min_val = ArgumentUtils.toDouble(min, 1);
} else {
min_val = ArgumentUtils.toDouble(min);
}
if (ArgumentUtils.isPositiveInf(max)) {
max_val = Double.MAX_VALUE;
} else if (max[0] == INCLUDE) {
includeMax = false;
max_val = ArgumentUtils.toDouble(max, 1);
} else {
max_val = ArgumentUtils.toDouble(max);
}
} catch (NumberFormatException ex) {
RespErrorUtil.customError("min or max is not a float", handler.allocator());
return handler.myStage();
}
return handler.stageToReturn(handler.getSortedSeMultimap()
.count(name, min_val, includeMin, max_val, includeMax), ctx, Consumers.LONG_BICONSUMER);
}
}
| 3,037
| 37.455696
| 102
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/sortedset/ZSCORE.java
|
package org.infinispan.server.resp.commands.sortedset;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.multimap.impl.EmbeddedMultimapSortedSetCache;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* Returns the score of member in the sorted set at key.
*
* If member does not exist in the sorted set, or key does not exist, nil is returned.
* Bulk string reply: the score of member (a double precision floating point number),
* represented as string.
*
* @since 15.0
* @see <a href="https://redis.io/commands/zscore/">Redis Documentation</a>
*/
public class ZSCORE extends RespCommand implements Resp3Command {
public ZSCORE() {
super(3, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] name = arguments.get(0);
byte[] member = arguments.get(1);
EmbeddedMultimapSortedSetCache<byte[], byte[]> sortedSetCache = handler.getSortedSeMultimap();
CompletionStage<byte[]> score = sortedSetCache.score(name, member)
.thenApply(r -> r == null ? null : Double.toString(r).getBytes(StandardCharsets.US_ASCII));
return handler.stageToReturn(score, ctx, Consumers.GET_BICONSUMER);
}
}
| 1,703
| 36.866667
| 103
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/sortedset/internal/POP.java
|
package org.infinispan.server.resp.commands.sortedset.internal;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.multimap.impl.EmbeddedMultimapSortedSetCache;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespErrorUtil;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.ArgumentUtils;
import org.infinispan.server.resp.commands.Resp3Command;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* Common implementation for ZPOP commands
*/
public abstract class POP extends RespCommand implements Resp3Command {
private final boolean min;
public POP(boolean min) {
super(-2, 1, 1, 1);
this.min = min;
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] name = arguments.get(0);
EmbeddedMultimapSortedSetCache<byte[], byte[]> sortedSetCache = handler.getSortedSeMultimap();
long count = 1;
if (arguments.size() > 1) {
try {
count = ArgumentUtils.toLong(arguments.get(1));
if (count < 0) {
RespErrorUtil.mustBePositive(handler.allocator());
return handler.myStage();
}
} catch (NumberFormatException e) {
RespErrorUtil.mustBePositive(handler.allocator());
return handler.myStage();
}
}
CompletionStage<List<byte[]>> popElements = sortedSetCache.pop(name, min, count).thenApply(r -> {
List<byte[]> result = new ArrayList<>();
r.stream().forEach(e -> {
result.add(e.getValue());
result.add(Double.toString(e.score()).getBytes(StandardCharsets.US_ASCII));
});
return result;
});
return handler.stageToReturn(popElements, ctx, Consumers.GET_ARRAY_BICONSUMER);
}
}
| 2,208
| 34.629032
| 103
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/connection/DBSIZE.java
|
package org.infinispan.server.resp.commands.connection;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* <a href="https://redis.io/commands/dbsize/">DBSIZE</a>
*
* @since 15.0
*/
public class DBSIZE extends RespCommand implements Resp3Command {
public DBSIZE() {
super(1, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx,
List<byte[]> arguments) {
return handler.stageToReturn(handler.cache().sizeAsync(), ctx, Consumers.LONG_BICONSUMER);
}
}
| 928
| 29.966667
| 102
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/connection/CLIENT.java
|
package org.infinispan.server.resp.commands.connection;
import static org.infinispan.server.resp.Resp3Handler.handleBulkResult;
import static org.infinispan.server.resp.Util.utf8;
import java.time.Duration;
import java.time.Instant;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.Security;
import org.infinispan.server.core.transport.ConnectionMetadata;
import org.infinispan.server.core.transport.NettyTransport;
import org.infinispan.server.resp.ByteBufferUtils;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.ChannelMatcher;
/**
* <a href="https://redis.io/commands/client/">CLIENT</a> *
*
* @since 15.0
*/
public class CLIENT extends RespCommand implements Resp3Command {
public CLIENT() {
super(-2, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx,
List<byte[]> arguments) {
String subcommand = utf8(arguments.get(0)).toUpperCase();
ConnectionMetadata metadata = ConnectionMetadata.getInstance(ctx.channel());
switch (subcommand) {
case "CACHING":
case "UNPAUSE":
case "PAUSE":
case "NO-EVICT":
case "KILL":
case "NO-TOUCH":
case "GETREDIR":
case "UNBLOCK":
case "REPLY":
ByteBufferUtils.stringToByteBuf("-ERR unsupported command\r\n", handler.allocator());
break;
case "SETINFO":
for (int i = 1; i < arguments.size(); i++) {
String name = utf8(arguments.get(i));
switch (name.toUpperCase()) {
case "LIB-NAME":
metadata.clientLibraryName(utf8(arguments.get(++i)));
break;
case "LIB-VER":
metadata.clientLibraryVersion(utf8(arguments.get(++i)));
break;
default:
ByteBufferUtils.stringToByteBuf("-ERR unsupported attribute " + name + "\r\n", handler.allocator());
return handler.myStage();
}
}
break;
case "SETNAME":
metadata.clientName(utf8(arguments.get(1)));
Consumers.OK_BICONSUMER.accept(null, handler.allocator());
break;
case "GETNAME":
handleBulkResult(metadata.clientName(), handler.allocator());
break;
case "ID":
Consumers.LONG_BICONSUMER.accept(metadata.id(), handler.allocator());
break;
case "INFO": {
StringBuilder sb = new StringBuilder();
addInfo(sb, metadata);
handleBulkResult(sb, handler.allocator());
break;
}
case "LIST": {
handler.checkPermission(AuthorizationPermission.ADMIN);
StringBuilder sb = new StringBuilder();
ChannelMatcher matcher = handler.respServer().getChannelMatcher();
NettyTransport transport = handler.respServer().getTransport();
if (transport == null) {
transport = (NettyTransport) handler.respServer().getEnclosingProtocolServer().getTransport();
}
ChannelGroup channels = transport.getAcceptedChannels();
channels.forEach(ch -> {
if (matcher.matches(ch)) {
addInfo(sb, ConnectionMetadata.getInstance(ch));
}
});
handleBulkResult(sb, handler.allocator());
break;
}
case "TRACKING":
ByteBufferUtils.stringToByteBuf("-ERR client tracking not supported\r\n", handler.allocator());
break;
case "TRACKINGINFO":
ByteBufferUtils.stringToByteBuf("*0\r\n", handler.allocator());
break;
}
return handler.myStage();
}
private void addInfo(StringBuilder sb, ConnectionMetadata metadata) {
sb.append("id=");
sb.append(metadata.id());
sb.append(" addr=");
sb.append(metadata.remoteAddress());
sb.append(" laddr=");
sb.append(metadata.localAddress());
sb.append(" name=");
String name = metadata.clientName();
if (name != null) {
sb.append(name);
}
sb.append(" age=");
sb.append(Duration.between(metadata.created(), Instant.now()).getSeconds());
sb.append(" user=");
sb.append(Security.getSubjectUserPrincipalName(metadata.subject()));
sb.append("\n");
}
}
| 4,948
| 36.778626
| 121
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/connection/RESET.java
|
package org.infinispan.server.resp.commands.connection;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import org.infinispan.server.resp.ByteBufferUtils;
import org.infinispan.server.resp.Resp3AuthHandler;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.SubscriberHandler;
import org.infinispan.server.resp.commands.PubSubResp3Command;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/reset/
* @since 14.0
*/
public class RESET extends RespCommand implements Resp3Command, PubSubResp3Command {
public RESET() {
super(1, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
ByteBufferUtils.stringToByteBuf("+RESET\r\n", handler.allocator());
if (handler.respServer().getConfiguration().authentication().enabled()) {
return CompletableFuture.completedFuture(new Resp3AuthHandler(handler.respServer()));
}
return handler.myStage();
}
@Override
public CompletionStage<RespRequestHandler> perform(SubscriberHandler handler, ChannelHandlerContext ctx,
List<byte[]> arguments) {
handler.removeAllListeners();
return handler.resp3Handler().handleRequest(ctx, this, arguments);
}
}
| 1,710
| 37.022222
| 107
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/connection/MODULE.java
|
package org.infinispan.server.resp.commands.connection;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.server.resp.ByteBufferUtils;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* <a href="https://redis.io/commands/module-list/">MODULE LIST</a>
*
* @since 15.0
*/
public class MODULE extends RespCommand implements Resp3Command {
public MODULE() {
super(-1, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx,
List<byte[]> arguments) {
handler.checkPermission(AuthorizationPermission.ADMIN);
String subcommand = new String(arguments.get(0), StandardCharsets.UTF_8).toUpperCase();
switch (subcommand) {
case "LIST":
ByteBufferUtils.stringToByteBuf("*0\r\n", handler.allocator());
break;
case "LOAD":
case "LOADEX":
case "UNLOAD":
ByteBufferUtils.stringToByteBuf("-ERR module loading/unloading unsupported\r\n", handler.allocator());
break;
}
return handler.myStage();
}
}
| 1,491
| 32.909091
| 114
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/connection/COMMAND.java
|
package org.infinispan.server.resp.commands.connection;
import static org.infinispan.server.resp.RespConstants.CRLF_STRING;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.server.resp.ByteBufferUtils;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Commands;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.buffer.ByteBufUtil;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/command/
* @since 14.0
*/
public class COMMAND extends RespCommand implements Resp3Command {
public static final String NAME = "COMMAND";
public COMMAND() {
super(NAME, -1, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
if (!arguments.isEmpty()) {
ByteBufferUtils.stringToByteBuf("-ERR COMMAND does not currently support arguments\r\n", handler.allocator());
} else {
StringBuilder commandBuilder = new StringBuilder();
List<RespCommand> commands = Commands.all();
commandBuilder.append("*");
commandBuilder.append(commands.size());
commandBuilder.append(CRLF_STRING);
for (RespCommand command : commands){
addCommand(commandBuilder, command);
}
ByteBufferUtils.stringToByteBuf(commandBuilder.toString(), handler.allocator());
}
return handler.myStage();
}
private void addCommand(StringBuilder builder, RespCommand command) {
builder.append("*6\r\n");
// Name
builder.append("$").append(ByteBufUtil.utf8Bytes(command.getName())).append(CRLF_STRING).append(command.getName()).append(CRLF_STRING);
// Arity
builder.append(":").append(command.getArity()).append(CRLF_STRING);
// Flags
builder.append("*0\r\n");
// First key
builder.append(":").append(command.getFirstKeyPos()).append(CRLF_STRING);
// Second key
builder.append(":").append(command.getLastKeyPos()).append(CRLF_STRING);
// Step
builder.append(":").append(command.getSteps()).append(CRLF_STRING);
}
}
| 2,431
| 36.415385
| 141
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/connection/READONLY.java
|
package org.infinispan.server.resp.commands.connection;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/readonly/
* @since 14.0
*/
public class READONLY extends RespCommand implements Resp3Command {
public READONLY() {
super(1, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
Consumers.OK_BICONSUMER.accept(null, handler.allocator());
return handler.myStage();
}
}
| 970
| 30.322581
| 80
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/connection/QUIT.java
|
package org.infinispan.server.resp.commands.connection;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.server.resp.commands.AuthResp3Command;
import org.infinispan.server.resp.commands.PubSubResp3Command;
import org.infinispan.server.resp.Resp3AuthHandler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.SubscriberHandler;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* @link https://redis.io/commands/quit/
* @since 14.0
*/
public class QUIT extends RespCommand implements AuthResp3Command, PubSubResp3Command {
public QUIT() {
super(1, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3AuthHandler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
ctx.close();
return handler.myStage();
}
@Override
public CompletionStage<RespRequestHandler> perform(SubscriberHandler handler, ChannelHandlerContext ctx,
List<byte[]> arguments) {
handler.removeAllListeners();
return handler.resp3Handler().handleRequest(ctx, this, arguments);
}
}
| 1,345
| 33.512821
| 107
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/connection/ECHO.java
|
package org.infinispan.server.resp.commands.connection;
import static org.infinispan.server.resp.RespConstants.CRLF_STRING;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.server.resp.ByteBufferUtils;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/echo/
* @since 14.0
*/
public class ECHO extends RespCommand implements Resp3Command {
public ECHO() {
super(2, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] argument = arguments.get(0);
ByteBuf bufferToWrite = ByteBufferUtils.
stringToByteBufWithExtra("$" + argument.length + CRLF_STRING, handler.allocator(), argument.length + 2);
bufferToWrite.writeBytes(argument);
bufferToWrite.writeByte('\r').writeByte('\n');
return handler.myStage();
}
}
| 1,257
| 33
| 116
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/connection/READWRITE.java
|
package org.infinispan.server.resp.commands.connection;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/readwrite/
* @since 14.0
*/
public class READWRITE extends RespCommand implements Resp3Command {
public READWRITE() {
super(1, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
// We are always in read write allowing read from backups
Consumers.OK_BICONSUMER.accept(null, handler.allocator());
return handler.myStage();
}
}
| 1,038
| 30.484848
| 80
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/connection/HELLO.java
|
package org.infinispan.server.resp.commands.connection;
import static org.infinispan.server.resp.RespConstants.CRLF_STRING;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.commons.util.Version;
import org.infinispan.server.resp.ByteBufPool;
import org.infinispan.server.resp.ByteBufferUtils;
import org.infinispan.server.resp.Resp3AuthHandler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.AuthResp3Command;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.CharsetUtil;
/**
* @link https://redis.io/commands/hello/
* @since 14.0
*/
public class HELLO extends RespCommand implements AuthResp3Command {
public HELLO() {
super(-1, 0, 0,0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3AuthHandler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
CompletionStage<Boolean> successStage = null;
byte[] respProtocolBytes = arguments.get(0);
String version = new String(respProtocolBytes, CharsetUtil.UTF_8);
if (!version.equals("3")) {
ByteBufferUtils.stringToByteBuf("-NOPROTO sorry this protocol version is not supported\r\n", handler.allocator());
} else {
if (arguments.size() == 4) {
successStage = handler.performAuth(ctx, arguments.get(2), arguments.get(3));
} else if (!handler.isAuthorized() && handler.canUseCertAuth()) {
successStage = handler.performAuth(ctx);
} else {
helloResponse(handler.allocator());
}
}
if (successStage != null) {
return handler.stageToReturn(successStage, ctx, success -> AUTH.createAfterAuthentication(success, handler));
}
return handler.myStage();
}
private static void helloResponse(ByteBufPool alloc) {
String versionString = Version.getBrandVersion();
ByteBufferUtils.stringToByteBuf("%7\r\n" +
"$6\r\nserver\r\n$15\r\nInfinispan RESP\r\n" +
"$7\r\nversion\r\n$" + versionString.length() + CRLF_STRING + versionString + CRLF_STRING +
"$5\r\nproto\r\n:3\r\n" +
"$2\r\nid\r\n:184\r\n" +
"$4\r\nmode\r\n$7\r\ncluster\r\n" +
"$4\r\nrole\r\n$6\r\nmaster\r\n" +
"$7\r\nmodules\r\n*0\r\n", alloc);
}
}
| 2,514
| 36.537313
| 123
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/connection/MEMORY.java
|
package org.infinispan.server.resp.commands.connection;
import static org.infinispan.server.resp.RespConstants.CRLF_STRING;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.server.resp.ByteBufferUtils;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespErrorUtil;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* <a href="https://redis.io/commands/memory/">MEMORY</a>
*
* @since 15.0
*/
public class MEMORY extends RespCommand implements Resp3Command {
public MEMORY() {
super(-2, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx,
List<byte[]> arguments) {
handler.checkPermission(AuthorizationPermission.ADMIN);
String subcommand = new String(arguments.get(0), StandardCharsets.US_ASCII).toUpperCase();
switch (subcommand) {
case "STATS":
StringBuilder sb = new StringBuilder();
sb.append("*54\r\n");
addStat(sb, "peak.allocated", 0); //1
addStat(sb, "total.allocated", 0); //3
addStat(sb, "startup.allocated", 0); //5
addStat(sb, "replication.backlog", 0);//7
addStat(sb, "clients.slaves", 0); //9
addStat(sb, "clients.normal", 0); //11
addStat(sb, "cluster.links", 0); //13
addStat(sb, "aof.buffer", 0); //15
addStat(sb, "lua.caches", 0); //17
addStat(sb, "functions.caches", 0); //19
addStat(sb, "overhead.total", 0); //21
addStat(sb, "keys.count", 0); //23
addStat(sb, "keys.bytes-per-key", 0); //25
addStat(sb, "dataset.bytes", 0); //27
addStat(sb, "dataset.percentage", "0.0"); //29
addStat(sb, "peak.percentage", "0.0"); //31
addStat(sb, "allocator.allocated", 0); //33
addStat(sb, "allocator.active", 0); //35
addStat(sb, "allocator.resident", 0); //37
addStat(sb, "allocator-fragmentation.ratio", "0.0"); //39
addStat(sb, "allocator-fragmentation.bytes", 0); //41
addStat(sb, "allocator-rss.ratio", "0.0"); //43
addStat(sb, "allocator-rss.bytes", 0); //45
addStat(sb, "rss-overhead.ratio", "0.0"); //47
addStat(sb, "rss-overhead.bytes", 0); //49
addStat(sb, "fragmentation", "0.0"); //51
addStat(sb, "fragmentation.bytes", 0); //53
ByteBufferUtils.stringToByteBuf(sb, handler.allocator());
break;
case "USAGE":
if (arguments.size() < 2) {
RespErrorUtil.wrongArgumentCount(this, handler.allocator());
return handler.myStage();
} else {
byte[] key = arguments.get(1);
return handler.stageToReturn(handler.cache().getAsync(key).thenApply(v ->
v == null ? null : (long) (key.length + v.length + 14) / 8 * 8),
ctx, Consumers.LONG_BICONSUMER);
}
case "DOCTOR":
case "MALLOC-STATS":
case "PURGE":
ByteBufferUtils.stringToByteBuf("-ERR module loading/unloading unsupported\r\n", handler.allocator());
break;
}
return handler.myStage();
}
private void addStat(StringBuilder sb, String s, int i) {
sb.append('$');
sb.append(s.length());
sb.append(CRLF_STRING);
sb.append(s);
sb.append(CRLF_STRING);
sb.append(':');
sb.append(i);
sb.append(CRLF_STRING);
}
private void addStat(StringBuilder sb, String s, String v) {
sb.append('$');
sb.append(s.length());
sb.append(CRLF_STRING);
sb.append(s);
sb.append(CRLF_STRING);
sb.append('$');
sb.append(v.length());
sb.append(CRLF_STRING);
sb.append(v);
sb.append(CRLF_STRING);
}
}
| 4,297
| 37.720721
| 114
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/connection/SELECT.java
|
package org.infinispan.server.resp.commands.connection;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.server.resp.ByteBufferUtils;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/select/
* @since 14.0
*/
public class SELECT extends RespCommand implements Resp3Command {
public SELECT() {
super(-1, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
ByteBufferUtils
.stringToByteBuf("-ERR Select not supported in cluster mode\r\n", handler.allocator());
return handler.myStage();
}
}
| 1,028
| 31.15625
| 99
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/connection/PING.java
|
package org.infinispan.server.resp.commands.connection;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.server.resp.ByteBufferUtils;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.SubscriberHandler;
import org.infinispan.server.resp.commands.PubSubResp3Command;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/ping/
* @since 14.0
*/
public class PING extends RespCommand implements Resp3Command, PubSubResp3Command {
public static final String NAME = "PING";
public PING() {
super(NAME, -1, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx,
List<byte[]> arguments) {
if (arguments.size() == 0) {
ByteBufferUtils.stringToByteBuf("$4\r\nPONG\r\n", handler.allocator());
return handler.myStage();
}
return handler.delegate(ctx, this, arguments);
}
@Override
public CompletionStage<RespRequestHandler> perform(SubscriberHandler handler, ChannelHandlerContext ctx,
List<byte[]> arguments) {
handler.resp3Handler().handleRequest(ctx, this, arguments);
return handler.myStage();
}
}
| 1,539
| 34
| 107
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/connection/AUTH.java
|
package org.infinispan.server.resp.commands.connection;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.server.resp.Resp3AuthHandler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.AuthResp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/auth/
* @since 14.0
*/
public class AUTH extends RespCommand implements AuthResp3Command {
public AUTH() {
super(-2, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3AuthHandler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
CompletionStage<Boolean> successStage = handler.performAuth(ctx, arguments.get(0), arguments.get(1));
return handler.stageToReturn(successStage, ctx, success -> createAfterAuthentication(success, handler));
}
static RespRequestHandler createAfterAuthentication(boolean success, Resp3AuthHandler prev) {
if (!success) return prev;
return prev.respServer().newHandler();
}
}
| 1,234
| 33.305556
| 110
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/cluster/SHARDS.java
|
package org.infinispan.server.resp.commands.cluster;
import static org.infinispan.server.resp.RespConstants.CRLF_STRING;
import static org.infinispan.server.resp.commands.cluster.CLUSTER.findPhysicalAddress;
import static org.infinispan.server.resp.commands.cluster.CLUSTER.findPort;
import static org.infinispan.server.resp.commands.cluster.CLUSTER.getOnlyIp;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ConcurrentHashMap;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.util.IntSet;
import org.infinispan.commons.util.IntSets;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.distribution.DistributionManager;
import org.infinispan.distribution.ch.ConsistentHash;
import org.infinispan.manager.CacheManagerInfo;
import org.infinispan.manager.ClusterExecutor;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.remoting.transport.Address;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.server.resp.ByteBufferUtils;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespErrorUtil;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.topology.CacheTopology;
import io.netty.channel.ChannelHandlerContext;
import net.jcip.annotations.GuardedBy;
/**
* `CLUSTER SHARDS` command.
* <p>
* Use the {@link CacheTopology} and retrieves information based on the {@link ConsistentHash}. We broadcast the
* command to the current topology members to retrieve specific data from the nodes.
*
* @link <a href="https://redis.io/commands/cluster-shards/">CLUSTER SHARDS</a>
* @since 15.0
*/
public class SHARDS extends RespCommand implements Resp3Command {
@GuardedBy("this")
private CompletionStage<CharSequence> lastExecution = null;
@GuardedBy("this")
private ConsistentHash lastAcceptedHash = null;
public SHARDS() {
super(2, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments) {
AdvancedCache<?, ?> respCache = handler.cache();
DistributionManager dm = respCache.getDistributionManager();
if (dm == null) {
RespErrorUtil.customError("This instance has cluster support disabled", handler.allocator());
return handler.myStage();
}
CacheTopology topology = dm.getCacheTopology();
ConsistentHash hash = topology.getCurrentCH();
if (hash == null) {
RespErrorUtil.customError("No consistent hash available", handler.allocator());
return handler.myStage();
}
synchronized (this) {
if (!hash.equals(lastAcceptedHash)) {
lastExecution = readShardsInformation(hash, SecurityActions.getClusterExecutor(respCache));
lastAcceptedHash = hash;
}
}
return handler.stageToReturn(lastExecution, ctx, ByteBufferUtils::stringToByteBuf);
}
private static CompletionStage<CharSequence> readShardsInformation(ConsistentHash hash, ClusterExecutor executor) {
Map<List<Address>, IntSet> segmentOwners = new HashMap<>();
for (int i = 0; i < hash.getNumSegments(); i++) {
segmentOwners.computeIfAbsent(hash.locateOwnersForSegment(i), ignore -> IntSets.mutableEmptySet())
.add(i);
}
return readNodeInformation(hash.getMembers(), executor)
.thenApply(information -> {
StringBuilder response = new StringBuilder();
// Number of elements.
response.append('*').append(segmentOwners.size()).append(CRLF_STRING);
for (Map.Entry<List<Address>, IntSet> entry : segmentOwners.entrySet()) {
List<Address> addresses = entry.getKey();
String leader = information.get(addresses.get(0));
if (leader == null) {
log.debugf("Not found information for leader: %s", addresses.get(0));
String name = addresses.get(0).toString();
StringBuilder sb = new StringBuilder();
// A health of `loading` mean that the node will be available in the future for traffic.
createNodeSerialized(sb, name, name, 0, "loading");
leader = sb.toString();
}
List<String> replicas = null;
if (addresses.size() > 1) {
replicas = new ArrayList<>();
for (int i = 1; i < addresses.size(); i++) {
String replica = information.get(addresses.get(i));
if (replica == null) {
String name = addresses.get(i).toString();
StringBuilder sb = new StringBuilder();
createNodeSerialized(sb, name, name, 0, "loading");
replica = sb.toString();
}
replicas.add(replica);
}
}
serialize(response, leader, replicas, entry.getValue());
}
return response;
});
}
private static CompletionStage<Map<Address, String>> readNodeInformation(List<Address> members, ClusterExecutor executor) {
final Map<Address, String> responses = new ConcurrentHashMap<>(members.size());
return executor.filterTargets(members)
.submitConsumer(SHARDS::readLocalNodeInformation, (address, res, t) -> {
if (t != null) {
throw CompletableFutures.asCompletionException(t);
}
responses.put(address, res);
}).thenApply(ignore -> responses);
}
private static String readLocalNodeInformation(EmbeddedCacheManager ecm) {
CacheManagerInfo manager = ecm.getCacheManagerInfo();
String name = manager.getNodeName();
Address address = findPhysicalAddress(ecm);
int port = findPort(address);
String addressString = address != null ? getOnlyIp(address) : ecm.getCacheManagerInfo().getNodeAddress();
StringBuilder sb = new StringBuilder();
createNodeSerialized(sb, name, addressString, port, "online");
return sb.toString();
}
private static void createNodeSerialized(StringBuilder sb, String name, String address, int port, String health) {
// Define the number of properties and values we return.
// We do not include the role here. This is added on the caller.
sb.append("*14\r\n");
sb.append("$2\r\n").append("id\r\n");
sb.append("$").append(name.length()).append(CRLF_STRING).append(name).append(CRLF_STRING);
sb.append("$4\r\n").append("port\r\n");
sb.append(":").append(port).append(CRLF_STRING);
sb.append("$2\r\n").append("ip\r\n");
sb.append("$").append(address.length()).append(CRLF_STRING).append(address).append(CRLF_STRING);
sb.append("$8\r\n").append("endpoint\r\n");
sb.append("$").append(address.length()).append(CRLF_STRING).append(address).append(CRLF_STRING);
sb.append("$18\r\n").append("replication-offset\r\n");
sb.append(":0\r\n");
sb.append("$6\r\n").append("health\r\n");
sb.append("$").append(health.length()).append(CRLF_STRING).append(health).append(CRLF_STRING);
}
private static void serialize(StringBuilder output, String leader, List<String> replicas, IntSet ranges) {
// Each element in the list has 2 properties, the ranges and nodes, and the associated values.
output.append("*4\r\n");
int segmentCount = 0;
StringBuilder segments = new StringBuilder();
for (int i = ranges.nextSetBit(0); i >= 0; i = ranges.nextSetBit(i + 1)) {
int runStart = i;
while (ranges.contains(i + 1)) {
i++;
}
segments.append(":").append(runStart).append(CRLF_STRING);
segments.append(":").append(i).append(CRLF_STRING);
segmentCount++;
}
// Serializing the ranges.
output.append("$5\r\n").append("slots\r\n");
output.append("*").append(segmentCount * 2).append(CRLF_STRING).append(segments);
// Now serialize information about the nodes.
// We start with the segment owner.
output.append("$5\r\n").append("nodes\r\n");
output.append("*").append(replicas == null || replicas.isEmpty() ? 1 : replicas.size() + 1).append(CRLF_STRING);
if (leader != null) {
output.append(leader).append("$4\r\nrole\r\n$6\r\nmaster\r\n");
} else {
output.append("$-1\r\n");
}
// Now any backups, if available.
if (replicas != null) {
for (String replica : replicas) {
output.append(replica).append("$4\r\nrole\r\n$7\r\nreplica\r\n");
}
}
}
}
| 9,099
| 40.363636
| 128
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/cluster/NODES.java
|
package org.infinispan.server.resp.commands.cluster;
import static org.infinispan.server.resp.RespConstants.CRLF_STRING;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.time.Instant;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ConcurrentHashMap;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.util.IntSet;
import org.infinispan.commons.util.IntSets;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.distribution.DistributionManager;
import org.infinispan.distribution.ch.ConsistentHash;
import org.infinispan.factories.impl.BasicComponentRegistry;
import org.infinispan.factories.impl.ComponentRef;
import org.infinispan.manager.CacheManagerInfo;
import org.infinispan.manager.ClusterExecutor;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.remoting.transport.Address;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.server.resp.ByteBufferUtils;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespErrorUtil;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.RespServer;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.topology.CacheTopology;
import io.netty.channel.ChannelHandlerContext;
import net.jcip.annotations.GuardedBy;
/**
* `<code>CLUSTER NODES</code>` command.
* <p>
* A command that uses the current {@link CacheTopology} and {@link ConsistentHash} to retrieve information about
* the nodes. The response slightly changes with the node executing the command, as it is necessary to identify itself.
* The execution is broadcast for nodes in the topology to identify themselves. So the response are cached according
* to the node that executed the command and the topology.
* </p>
*
* @link <a href="https://redis.io/commands/cluster-nodes/">CLUSTER NODES</a>
* @since 15.0
* @author José Bolina
*/
public class NODES extends RespCommand implements Resp3Command {
@GuardedBy("this")
protected ConsistentHash hash = null;
@GuardedBy("this")
protected CompletionStage<CharSequence> response = null;
public NODES() {
super(2, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments) {
handler.checkPermission(AuthorizationPermission.ADMIN);
AdvancedCache<?, ?> respCache = handler.cache();
DistributionManager dm = respCache.getDistributionManager();
if (dm == null) {
RespErrorUtil.customError("This instance has cluster support disabled", handler.allocator());
return handler.myStage();
}
CacheTopology topology = dm.getCacheTopology();
ConsistentHash currentCH = topology.getCurrentCH();
if (currentCH == null) {
RespErrorUtil.customError("No consistent hash available", handler.allocator());
return handler.myStage();
}
synchronized (this) {
if (!currentCH.equals(hash)) {
EmbeddedCacheManager ecm = SecurityActions.getEmbeddedCacheManager(respCache);
response = requestClusterInformation(handler, ctx, ecm, topology);
hash = currentCH;
}
}
return handler.stageToReturn(response, ctx, ByteBufferUtils::stringToByteBuf);
}
protected static CompletionStage<CharSequence> requestClusterInformation(Resp3Handler handler, ChannelHandlerContext ctx,
EmbeddedCacheManager ecm, CacheTopology topology) {
ConsistentHash hash = topology.getCurrentCH();
return readNodeInformation(hash.getMembers(), handler)
.thenApply(information -> {
// The response is a bulk string, each line contains information about one node.
// The format of each line is:
// <id> <ip:port@cport[,hostname[,auxiliary_field=value]*]> <flags> <master> <ping-sent> <pong-recv> <config-epoch> <link-state> <slot> <slot> ... <slot>
// More information about each field is available at the command link.
// Since some of that information doesn't make sense for Infinispan, so we add some simple value since it is required.
StringBuilder response = new StringBuilder();
Address local = ecm.getAddress();
int cport = findClientPort(ctx.channel().remoteAddress());
for (Address member : hash.getMembers()) {
boolean isMyself = member.equals(local);
IntSet owner = IntSets.from(hash.getPrimarySegmentsForOwner(member));
String initial = information.get(member);
String health = "connected";
if (initial != null) {
// We were able to connect the node.
// This contains the <id> <ip:port@cport[,hostname[,auxiliary_field=value]*]>
response.append(String.format(initial, cport));
if (isMyself) {
response.append("myself,");
}
} else {
// We could not retrieve information from the node.
// We add the information as if was disconnected.
response.append(member).append(' ');
if (isMyself) {
RespServer server = handler.respServer();
response.append(server.getHost()).append(':').append(server.getPort());
response.append('@').append(cport);
response.append(",,shard-id=").append(member).append(' ');
response.append("myself,");
} else {
response.append(":0@0 noaddr,fail?,");
}
health = "disconnected";
}
response.append("master").append(' ');
response.append('-').append(' ');
response.append('0').append(' ');
response.append(Instant.now().getEpochSecond()).append(' ');
response.append(topology.getTopologyId()).append(' ');
response.append(health).append(' ');
serializeSegments(response, owner);
response.append('\n');
}
return "$" + response.length() + CRLF_STRING + response + CRLF_STRING;
});
}
private static void serializeSegments(StringBuilder response, IntSet ranges) {
boolean first = true;
for (int i = ranges.nextSetBit(0); i >= 0; i = ranges.nextSetBit(i + 1)) {
if (!first) {
response.append(' ');
}
first = false;
int runStart = i;
while (ranges.contains(i + 1)) {
i++;
}
response.append(runStart).append('-').append(i);
}
}
private static CompletionStage<Map<Address, String>> readNodeInformation(List<Address> members, Resp3Handler handler) {
final Map<Address, String> response = new ConcurrentHashMap<>(members.size());
ClusterExecutor executor = SecurityActions.getClusterExecutor(handler.cache());
String sqn = handler.respServer().getQualifiedName();
return executor.filterTargets(members)
.submitConsumer(ecm -> readLocalNodeInformation(sqn, ecm), (address, res, t) -> {
if (t != null) {
throw CompletableFutures.asCompletionException(t);
}
response.put(address, res);
}).thenApply(ignore -> response);
}
private static String readLocalNodeInformation(String serverName, EmbeddedCacheManager ecm) {
CacheManagerInfo info = ecm.getCacheManagerInfo();
ComponentRef<RespServer> ref = SecurityActions.getGlobalComponentRegistry(ecm)
.getComponent(BasicComponentRegistry.class)
.getComponent(serverName, RespServer.class);
String name = info.getNodeName();
StringBuilder sb = new StringBuilder();
sb.append(name).append(' ');
if (ref != null) {
RespServer server = ref.running();
sb.append(server.getHost()).append(':').append(server.getPort()).append('@').append("%d");
sb.append(",,shard-id=").append(name).append(' ');
} else {
sb.append(":0@0 noaddr,");
}
return sb.toString();
}
private static int findClientPort(SocketAddress addr) {
if (addr instanceof InetSocketAddress) {
return ((InetSocketAddress) addr).getPort();
}
return 0;
}
}
| 8,930
| 42.565854
| 168
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/cluster/SLOTS.java
|
package org.infinispan.server.resp.commands.cluster;
import static org.infinispan.server.resp.RespConstants.CRLF_STRING;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ConcurrentHashMap;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.util.IntSet;
import org.infinispan.commons.util.IntSets;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.distribution.DistributionManager;
import org.infinispan.distribution.ch.ConsistentHash;
import org.infinispan.factories.impl.BasicComponentRegistry;
import org.infinispan.factories.impl.ComponentRef;
import org.infinispan.manager.CacheManagerInfo;
import org.infinispan.manager.ClusterExecutor;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.remoting.transport.Address;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.server.core.transport.NettyTransport;
import org.infinispan.server.resp.ByteBufferUtils;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespErrorUtil;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.RespServer;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.topology.CacheTopology;
import io.netty.channel.ChannelHandlerContext;
import net.jcip.annotations.GuardedBy;
public class SLOTS extends RespCommand implements Resp3Command {
@GuardedBy("this")
private CompletionStage<CharSequence> lastExecution = null;
@GuardedBy("this")
private ConsistentHash lastAcceptedHash = null;
public SLOTS() {
super(2, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments) {
AdvancedCache<?, ?> respCache = handler.cache();
DistributionManager dm = respCache.getDistributionManager();
if (dm == null) {
RespErrorUtil.customError("This instance has cluster support disabled", handler.allocator());
return handler.myStage();
}
CacheTopology topology = dm.getCacheTopology();
ConsistentHash hash = topology.getCurrentCH();
if (hash == null) {
RespErrorUtil.customError("No consistent hash available", handler.allocator());
return handler.myStage();
}
synchronized (this) {
if (!hash.equals(lastAcceptedHash)) {
lastExecution = getSlotsInformation(handler, hash);
lastAcceptedHash = hash;
}
}
return handler.stageToReturn(lastExecution, ctx, ByteBufferUtils::stringToByteBuf);
}
private static CompletionStage<CharSequence> getSlotsInformation(Resp3Handler handler, ConsistentHash hash) {
return requestNodesNetworkInformation(hash.getMembers(), handler)
.thenApply(information -> {
StringBuilder builder = new StringBuilder();
Map<List<Address>, IntSet> segmentOwners = new HashMap<>();
for (int i = 0; i < hash.getNumSegments(); i++) {
segmentOwners.computeIfAbsent(hash.locateOwnersForSegment(i), ignore -> IntSets.mutableEmptySet())
.add(i);
}
int size = 0;
for (Map.Entry<List<Address>, IntSet> entry : segmentOwners.entrySet()) {
List<Address> owners = entry.getKey();
IntSet segments = entry.getValue();
for (int i = segments.nextSetBit(0); i >= 0; i = segments.nextSetBit(i + 1)) {
int runStart = i;
while (segments.contains(i + 1)) {
i++;
}
size++;
builder.append('*').append(2 + owners.size()).append(CRLF_STRING);
builder.append(':').append(runStart).append(CRLF_STRING);
builder.append(':').append(i).append(CRLF_STRING);
for (Address owner: owners) {
String info = information.get(owner);
builder.append(info);
}
}
}
return "*" + size + CRLF_STRING + builder;
});
}
private static CompletionStage<Map<Address, String>> requestNodesNetworkInformation(List<Address> members, Resp3Handler handler) {
Map<Address, String> responses = new ConcurrentHashMap<>(members.size());
ClusterExecutor executor = SecurityActions.getClusterExecutor(handler.cache());
String name = handler.respServer().getQualifiedName();
return executor.filterTargets(members)
.submitConsumer(e -> readLocalInformation(name, e), (address, res, t) -> {
if (t != null) {
throw CompletableFutures.asCompletionException(t);
}
responses.put(address, res);
}).thenApply(ignore -> responses);
}
private static String readLocalInformation(String serverName, EmbeddedCacheManager ecm) {
StringBuilder sb = new StringBuilder();
ComponentRef<RespServer> ref = SecurityActions.getGlobalComponentRegistry(ecm)
.getComponent(BasicComponentRegistry.class)
.getComponent(serverName, RespServer.class);
if (ref == null) {
// Handle with basic information.
return "$-1\r\n";
}
// An array with network information.
sb.append("*4\r\n");
RespServer server = ref.running();
CacheManagerInfo info = ecm.getCacheManagerInfo();
sb.append('$').append(server.getHost().length()).append(CRLF_STRING).append(server.getHost()).append(CRLF_STRING);
sb.append(':').append(server.getPort()).append(CRLF_STRING);
sb.append('$').append(info.getNodeName().length()).append(CRLF_STRING).append(info.getNodeName()).append(CRLF_STRING);
// The last element is for additional metadata. For example, hostnames or something like that.
NettyTransport transport = server.getTransport();
if (transport != null) {
String host = transport.getHostName();
sb.append("*1\r\n").append('$').append(host.length()).append(CRLF_STRING).append(host).append(CRLF_STRING);
} else {
sb.append("$-1\r\n");
}
return sb.toString();
}
}
| 6,481
| 40.551282
| 133
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/cluster/CLUSTER.java
|
package org.infinispan.server.resp.commands.cluster;
import java.util.List;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.remoting.transport.Address;
import org.infinispan.remoting.transport.Transport;
import org.infinispan.remoting.transport.jgroups.JGroupsAddress;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.commands.FamilyCommand;
import org.jgroups.stack.IpAddress;
public class CLUSTER extends FamilyCommand {
private static final RespCommand[] CLUSTER_COMMANDS;
static {
CLUSTER_COMMANDS = new RespCommand[] {
new SHARDS(),
new NODES(),
new SLOTS(),
};
}
public CLUSTER() {
super(-2, 0, 0, 0);
}
@Override
public RespCommand[] getFamilyCommands() {
return CLUSTER_COMMANDS;
}
public static Address findPhysicalAddress(EmbeddedCacheManager ecm) {
Transport transport = ecm.getTransport();
if (transport == null) {
return null;
}
List<Address> addresses = transport.getPhysicalAddresses();
if (addresses.isEmpty()) {
// Returning a logical address.
return ecm.getAddress();
}
return addresses.get(0);
}
public static int findPort(Address address) {
int port = 0;
if (address instanceof JGroupsAddress && ((JGroupsAddress) address).getJGroupsAddress() instanceof IpAddress) {
JGroupsAddress jAddress = (JGroupsAddress) address;
port = ((IpAddress) jAddress.getJGroupsAddress()).getPort();
}
return port;
}
public static String getOnlyIp(Address address) {
if (address instanceof JGroupsAddress && ((JGroupsAddress) address).getJGroupsAddress() instanceof IpAddress) {
JGroupsAddress jAddress = (JGroupsAddress) address;
return ((IpAddress) jAddress.getJGroupsAddress()).getIpAddress().getHostAddress();
}
return address.toString();
}
}
| 1,965
| 29.246154
| 117
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/response/SetResponse.java
|
package org.infinispan.server.resp.response;
public class SetResponse {
private final byte[] value;
private final boolean returnValue;
private final boolean success;
public SetResponse(byte[] value, boolean returnValue) {
this(value, returnValue, true);
}
public SetResponse(byte[] value, boolean returnValue, boolean success) {
this.value = value;
this.returnValue = returnValue;
this.success = success;
}
public byte[] value() {
return value;
}
public boolean isReturnValue() {
return returnValue;
}
public boolean isSuccess() {
return success;
}
}
| 639
| 19.645161
| 75
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/response/LCSResponse.java
|
package org.infinispan.server.resp.response;
import java.util.ArrayList;
public class LCSResponse {
public ArrayList<long[]> idx;
public byte[] lcs;
public int[][] C;
public int len;
}
| 214
| 18.545455
| 44
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/authentication/RespAuthenticator.java
|
package org.infinispan.server.resp.authentication;
import java.util.concurrent.CompletionStage;
import javax.security.auth.Subject;
import javax.security.sasl.SaslException;
import io.netty.channel.Channel;
public interface RespAuthenticator {
CompletionStage<Subject> clientCertAuth(Channel channel) throws SaslException;
CompletionStage<Subject> usernamePasswordAuth(String username, char[] password);
boolean isClientCertAuthEnabled();
}
| 457
| 24.444444
| 83
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/operation/RespExpiration.java
|
package org.infinispan.server.resp.operation;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeUnit;
import org.infinispan.commons.time.TimeService;
import org.infinispan.server.resp.Util;
public enum RespExpiration {
EX {
@Override
protected long convert(long value, TimeService timeService) {
return TimeUnit.SECONDS.toMillis(value);
}
},
PX {
@Override
protected long convert(long value, TimeService timeService) {
return value;
}
},
EXAT {
@Override
protected long convert(long value, TimeService timeService) {
return (value - timeService.instant().getEpochSecond()) * 1000;
}
},
PXAT {
@Override
protected long convert(long value, TimeService timeService) {
return value - timeService.instant().toEpochMilli();
}
};
public static final byte[] EXAT_BYTES = "EXAT".getBytes(StandardCharsets.US_ASCII);
public static final byte[] PXAT_BYTES = "PXAT".getBytes(StandardCharsets.US_ASCII);
protected abstract long convert(long value, TimeService timeService);
public static RespExpiration valueOf(byte[] type) {
if (type.length == 2) {
if (!Util.caseInsensitiveAsciiCheck('X', type[1]))
throw new IllegalArgumentException("Invalid expiration type");
switch (type[0]) {
case 'E':
case 'e':
return EX;
case 'P':
case 'p':
return PX;
}
}
if (type.length == 4) {
if (Util.isAsciiBytesEquals(EXAT_BYTES, type)) return EXAT;
if (Util.isAsciiBytesEquals(PXAT_BYTES, type)) return PXAT;
}
throw new IllegalArgumentException("Invalid expiration type");
}
}
| 1,794
| 27.492063
| 86
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/operation/GetexOperation.java
|
package org.infinispan.server.resp.operation;
import java.nio.charset.StandardCharsets;
import java.util.List;
import org.infinispan.commons.time.TimeService;
import org.infinispan.server.resp.Util;
public class GetexOperation {
private static final byte[] PERSIST_BYTES = "PERSIST".getBytes(StandardCharsets.US_ASCII);
public static long parseExpiration(List<byte[]> arguments, TimeService timeService) {
long expirationMs = 0;
// Below here we parse the optional expiration for the GETEX command:
// Related parameters:
//
// `EX` seconds: TTL in seconds;
// `PX` milliseconds: TTL in ms;
// `EXAT` timestamp: Unix time for key expiration, seconds;
// `PXAT` timestamp: Unix time for key expiration, milliseconds;
// `PERSIST`: Remove the TTL for the entry.
//
// Each of the time arguments are exclusive, only one is present at a time.
// All these arguments can be in any order. Expiration must be followed by the
// proper value.
for (int i = 1; i < arguments.size(); i++) {
byte[] arg = arguments.get(i);
// expiration options
if (arg.length == 2 || arg.length == 4) {
switch (arg[0]) {
case 'E':
case 'P':
case 'e':
case 'p':
// Throws an exception if invalid.
RespExpiration expiration = RespExpiration.valueOf(arg);
if (expirationMs != 0)
throw new IllegalArgumentException("Only one expiration option should be used on GETEX");
if (i + 1 > arguments.size())
throw new IllegalArgumentException("No argument accompanying expiration");
expirationMs = expiration
.convert(Long.parseLong(new String(arguments.get(i + 1), StandardCharsets.US_ASCII)), timeService);
i++;
continue;
}
}
// `PERSIST` argument.
if (arg.length == 7 && Util.isAsciiBytesEquals(PERSIST_BYTES, arg)) {
if (expirationMs != 0)
throw new IllegalArgumentException("PERSIST and EX/PX/EXAT/PXAT are mutually exclusive");
expirationMs = -1;
continue;
}
throw new IllegalArgumentException("Unknown argument for GETEX operation");
}
return expirationMs;
}
}
| 2,436
| 40.305085
| 123
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/operation/SetOperation.java
|
package org.infinispan.server.resp.operation;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.TimeUnit;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.time.TimeService;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.server.resp.Util;
import org.infinispan.server.resp.response.SetResponse;
import org.infinispan.util.concurrent.CompletionStages;
public class SetOperation {
private static final byte[] GET_BYTES = "GET".getBytes(StandardCharsets.US_ASCII);
private static final byte[] NX_BYTES = "NX".getBytes(StandardCharsets.US_ASCII);
private static final byte[] XX_BYTES = "XX".getBytes(StandardCharsets.US_ASCII);
private static final byte[] KEEP_TTL_BYTES = "KEEPTTL".getBytes(StandardCharsets.US_ASCII);
private static final CompletionStage<SetResponse> MISSING_ARGUMENTS = CompletableFuture.failedFuture(new IllegalStateException("Missing arguments"));
public static CompletionStage<SetResponse> performOperation(AdvancedCache<byte[], byte[]> cache, List<byte[]> arguments, TimeService timeService) {
try {
if (arguments.size() < 2) return MISSING_ARGUMENTS;
SetOperationOptions options = new SetOperationOptions(arguments, timeService);
if (options.operationType == XX_BYTES) {
return performOperationWithXX(cache, options, timeService);
}
CompletionStage<byte[]> cacheOperation;
if (options.isKeepingTtl()) {
cacheOperation = cache.getCacheEntryAsync(options.key)
.thenCompose(e -> performOperation(cache, options, e != null ? extractCurrentTTL(e, timeService) : -1));
} else {
cacheOperation = performOperation(cache, options, options.expirationMs);
}
if (CompletionStages.isCompletedSuccessfully(cacheOperation)) {
return CompletableFuture.completedFuture(parseResponse(options, CompletionStages.join(cacheOperation)));
}
return cacheOperation.thenApply(v -> parseResponse(options, v));
} catch (Exception e) {
return CompletableFuture.failedFuture(e);
}
}
private static CompletionStage<byte[]> performOperation(AdvancedCache<byte[], byte[]> cache, SetOperationOptions options, long expiration) {
byte[] key = options.key;
byte[] value = options.value;
return options.operationType == null
? cache.putAsync(key, value, expiration, TimeUnit.MILLISECONDS)
: cache.putIfAbsentAsync(key, value, expiration, TimeUnit.MILLISECONDS);
}
private static SetResponse parseResponse(SetOperationOptions options, byte[] v) {
return options.operationType == null
? new SetResponse(v, options.isReturningPrevious())
: new SetResponse(v, options.isReturningPrevious(), v == null);
}
private static CompletionStage<SetResponse> performOperationWithXX(AdvancedCache<byte[], byte[]> cache, SetOperationOptions options, TimeService timeService) {
byte[] key = options.key;
byte[] value = options.value;
return cache.getCacheEntryAsync(key)
.thenCompose(e -> {
if (e == null || e.isNull()) {
return CompletableFuture.completedFuture(new SetResponse(null, options.isReturningPrevious(), false));
}
long exp = -1;
if (options.isKeepingTtl()) {
exp = extractCurrentTTL(e, timeService);
}
byte[] prev = e.getValue();
return cache.replaceAsync(key, prev, value, exp, TimeUnit.MILLISECONDS)
.thenApply(b -> new SetResponse(prev, options.isReturningPrevious(), b));
});
}
private static long extractCurrentTTL(CacheEntry<?, ?> entry, TimeService timeService) {
long lifespan = entry.getLifespan();
long delta = timeService.instant().toEpochMilli() - entry.getCreated();
return lifespan - delta;
}
private static class SetOperationOptions {
private final List<byte[]> arguments;
private byte[] key;
private byte[] value;
private long expirationMs;
private boolean keepTtl;
private boolean setAndReturnPrevious;
private byte[] operationType;
public SetOperationOptions(List<byte[]> arguments, TimeService timeService) {
this.arguments = arguments;
this.key = null;
this.value = null;
this.expirationMs = -1;
this.keepTtl = false;
this.setAndReturnPrevious = false;
this.operationType = null;
parseAndLoadOptions(timeService);
}
public void withKey(byte[] key) {
this.key = key;
}
public void withValue(byte[] value) {
this.value = value;
}
public void withReturnPrevious() {
this.setAndReturnPrevious = true;
}
public void withExpiration(long expirationMs) {
this.expirationMs = expirationMs;
}
public void withOperationType(byte[] operationType) {
this.operationType = operationType;
}
public void withKeepTtl() {
this.keepTtl = true;
}
public boolean isKeepingTtl() {
return this.keepTtl;
}
public boolean isReturningPrevious() {
return this.setAndReturnPrevious;
}
public boolean isUsingExpiration() {
return expirationMs > 0 || isKeepingTtl();
}
private void parseAndLoadOptions(TimeService timeService) {
withKey(arguments.get(0));
withValue(arguments.get(1));
// Bellow here we parse the optional arguments for the SET command:
//
// * `GET`: return the previous value with this key or nil;
// * `NX` or `XX`: putIfAbsent or putIfPresent. Returns nil if failed, if `GET` is present, it takes precedence.
//
// And expiration related parameters:
//
// `EX` seconds: TTL in seconds;
// `PX` milliseconds: TTL in ms;
// `EXAT` timestamp: Unix time for key expiration, seconds;
// `PXAT` timestamp: Unix time for key expiration, milliseconds;
// `KEEPTTL`: keep the key current TTL.
//
// Each of the time arguments are exclusive, only one is present at a time.
// All these arguments can be in any order. Expiration must be followed by the proper value.
for (int i = 2; i < arguments.size(); i++) {
byte[] arg = arguments.get(i);
// `NX`, `XX` or expiration.
if (arg.length == 2 || arg.length == 4) {
switch (arg[0]) {
case 'N':
case 'n':
if (!Util.caseInsensitiveAsciiCheck('X', arg[1])) break;
if (operationType != null) throw new IllegalArgumentException("NX and XX options are mutually exclusive");
withOperationType(NX_BYTES);
continue;
case 'X':
case 'x':
if (!Util.caseInsensitiveAsciiCheck('X', arg[1])) break;
if (operationType != null) throw new IllegalArgumentException("NX and XX options are mutually exclusive");
withOperationType(XX_BYTES);
continue;
case 'E':
case 'P':
case 'e':
case 'p':
// Throws an exception if invalid.
RespExpiration expiration = RespExpiration.valueOf(arg);
if (isUsingExpiration()) throw new IllegalArgumentException("Only one expiration option should be used on SET");
if (isKeepingTtl()) throw new IllegalArgumentException("KEEPTTL and EX/PX/EXAT/PXAT are mutually exclusive");
if (i + 1 > arguments.size()) throw new IllegalArgumentException("No argument accompanying expiration");
withExpiration(expiration.convert(Long.parseLong(new String(arguments.get(i + 1), StandardCharsets.US_ASCII)), timeService));
i++;
continue;
}
throw new IllegalArgumentException("Unknown argument for SET operation");
}
// `GET` argument.
if (arg.length == 3 && Util.isAsciiBytesEquals(GET_BYTES, arg)) {
withReturnPrevious();
continue;
}
// `KEEPTTL` argument.
if (arg.length == 7 && Util.isAsciiBytesEquals(KEEP_TTL_BYTES, arg)) {
if (isUsingExpiration()) throw new IllegalArgumentException("KEEPTTL and EX/PX/EXAT/PXAT are mutually exclusive");
withKeepTtl();
continue;
}
throw new IllegalArgumentException("Unknown argument for SET operation");
}
}
}
}
| 9,052
| 40.15
| 162
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/operation/LCSOperation.java
|
package org.infinispan.server.resp.operation;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import org.infinispan.AdvancedCache;
import org.infinispan.server.resp.response.LCSResponse;
public class LCSOperation {
private static final CompletionStage<LCSResponse> MISSING_ARGUMENTS = CompletableFuture
.failedFuture(new IllegalStateException("Missing arguments"));
public static CompletionStage<LCSResponse> performOperation(AdvancedCache<byte[], byte[]> cache,
List<byte[]> arguments) {
if (arguments.size() < 4)
return MISSING_ARGUMENTS;
LCSOperationContext lcsCtx = new LCSOperationContext(arguments);
lcsCtx.cache = cache;
return lcsCtx.cache.getAllAsync(Set.of(lcsCtx.key1, lcsCtx.key2))
.thenApply((m) -> {
var v1 = m.get(lcsCtx.key1);
var v2 = m.get(lcsCtx.key2);
if (v1 == null || v2 == null) {
lcsCtx.result = new LCSResponse();
lcsCtx.result.lcs = new byte[0];
}
lcsCtx.lcsLength(v1, v2);
if (!lcsCtx.justLen) {
lcsCtx.backtrack(v1, v2);
}
return lcsCtx.result;
});
}
protected static class LCSOperationContext {
private final List<byte[]> arguments;
AdvancedCache<byte[], byte[]> cache;
private byte[] key1;
private byte[] key2;
private boolean justLen;
private boolean idx;
private boolean matchLen;
private long minMatchLen;
private LCSResponse result;
public LCSResponse getResult() {
return result;
}
public LCSOperationContext(byte[] v1, byte[] v2, boolean onlyLen, boolean idx, boolean matchLen,
long minMatchLen) {
this.arguments = null;
this.justLen = onlyLen;
this.idx = idx;
this.matchLen = matchLen;
this.minMatchLen = minMatchLen;
this.result = new LCSResponse();
}
public LCSOperationContext(List<byte[]> arguments) {
this.arguments = arguments;
this.key1 = null;
this.key2 = null;
this.matchLen = false;
this.justLen = false;
this.minMatchLen = 0;
this.result = new LCSResponse();
parseAndLoadOptions();
}
private void parseAndLoadOptions() {
if (!(new String(arguments.get(0), StandardCharsets.US_ASCII)).equals("LCS")) {
throw new IllegalArgumentException("Unknown argument for LCS operation");
}
if (!(new String(arguments.get(1), StandardCharsets.US_ASCII)).equals("KEYS")) {
throw new IllegalArgumentException("Unknown argument for LCS operation");
}
this.key1 = arguments.get(2);
this.key2 = arguments.get(3);
// Below here we parse the optional arguments for the LCS command:
//
// LEN: returns the length of the longest match
// IDX: returns the index position of each matching excludes LEN)
// MINMATCHLEN: returns indexes only for matching longer than
// WITHMATCHLEN: returns length of each match
for (int i = 4; i < arguments.size(); i++) {
byte[] arg = arguments.get(i);
switch (new String(arg, StandardCharsets.US_ASCII)) {
case "LEN":
if (this.idx)
throw new IllegalArgumentException(
"ERR If you want both the length and indexes, please just use IDX.");
this.justLen = true;
continue;
case "IDX":
if (this.matchLen)
throw new IllegalArgumentException(
"ERR If you want both the length and indexes, please just use IDX.");
idx = true;
continue;
case "MINMATCHLEN":
if (i + 1 > arguments.size())
throw new IllegalArgumentException("ERR syntax error");
this.minMatchLen = Long.parseLong(new String(arguments.get(i + 1), StandardCharsets.US_ASCII));
i++;
case "WITHMATCHLEN":
if (this.matchLen)
throw new IllegalArgumentException(
"ERR If you want both the length and indexes, please just use IDX.");
matchLen = true && idx; // matchLen useless without idx
continue;
}
throw new IllegalArgumentException("Unknown argument for LCS operation");
}
}
// See https://en.wikipedia.org/wiki/Longest_common_subsequence
// Keeping same naming for reference
public void lcsLength(byte[] a, byte[] b) {
int m = a.length;
int n = b.length;
var C = new int[m + 1][n + 1];
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (a[i - 1] == b[j - 1]) {
C[i][j] = C[i - 1][j - 1] + 1;
} else {
C[i][j] = Math.max(C[i][j - 1], C[i - 1][j]);
}
}
}
this.result.C = C;
this.result.len = C[m][n];
}
// This backtrack from bottom right of the C matrix to top left
// see example in link above
public void backtrack(byte[] aStr, byte[] bStr) {
int x = aStr.length;
int y = bStr.length;
int i = x;
int j = y;
int m = this.result.len - 1;
boolean matching = false;
// If idx we need only the matching index
// else we need only the lcs string
if (this.idx) {
this.result.idx = new ArrayList<long[]>();
} else {
this.result.lcs = new byte[this.result.len];
}
while (i > 0 && j > 0) {
if (aStr[i - 1] == bStr[j - 1]) { // On match, save char and move up-left
matching = true;
if (!this.idx) {
this.result.lcs[m--] = aStr[i - 1];
}
i--;
j--;
} else { // on not match
if (matching) { // if matching, no more matching and save match positions
matching = false;
if (x - i >= this.minMatchLen && this.idx) {
if (this.matchLen) {
this.result.idx.add(new long[] { i, x - 1, j, y - 1, x - i });
} else {
this.result.idx.add(new long[] { i, x - 1, j, y - 1 });
}
}
x = i;
y = j;
}
// Decide where to go next
if (this.result.C[i][j - 1] >= this.result.C[i - 1][j]) {
// go left ...
y--;
j--;
} else {
// ... or go up
x--;
i--;
}
}
}
if (matching && this.idx && x - i >= this.minMatchLen) {
if (this.matchLen) {
this.result.idx.add(new long[] { i, x - 1, j, y - 1, x - i });
} else {
this.result.idx.add(new long[] { i, x - 1, j, y - 1 });
}
}
}
}
}
| 7,551
| 36.572139
| 113
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/configuration/CreateCacheIndexTemplateTest.java
|
package org.infinispan.configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.query.test.Person;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "configuration.CreateCacheIndexTemplateTest")
public class CreateCacheIndexTemplateTest extends SingleCacheManagerTest {
@Override
protected EmbeddedCacheManager createCacheManager() throws Exception {
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.indexing().enable().addIndexedEntities(Person.class);
return TestCacheManagerFactory.createCacheManager(builder);
}
public void createCacheTest() {
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.read(cacheManager.getDefaultCacheConfiguration());
builder.template(false);
cacheManager.defineConfiguration("newCache", builder.build());
cacheManager.getCache("newCache");
}
}
| 1,112
| 32.727273
| 85
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/TestsModule.java
|
package org.infinispan.query;
import org.infinispan.factories.annotations.InfinispanModule;
/**
* {@code InfinispanModule} annotation is required for component annotation processing
*/
@InfinispanModule(name = "query-tests")
public class TestsModule implements org.infinispan.lifecycle.ModuleLifecycle {
}
| 310
| 27.272727
| 86
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/projection/ProjectionTest.java
|
package org.infinispan.query.projection;
import static org.assertj.core.api.Assertions.assertThat;
import static org.infinispan.configuration.cache.IndexStorage.LOCAL_HEAP;
import java.util.List;
import org.hibernate.search.mapper.pojo.model.spi.PojoRawTypeIdentifier;
import org.infinispan.Cache;
import org.infinispan.api.annotations.indexing.Basic;
import org.infinispan.api.annotations.indexing.Indexed;
import org.infinispan.api.annotations.indexing.Text;
import org.infinispan.commons.util.CloseableIterator;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.query.Search;
import org.infinispan.query.dsl.Query;
import org.infinispan.query.dsl.QueryFactory;
import org.infinispan.search.mapper.common.impl.EntityReferenceImpl;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "query.projection.ProjectionTest")
public class ProjectionTest extends SingleCacheManagerTest {
private QueryFactory queryFactory;
@Override
protected EmbeddedCacheManager createCacheManager() throws Exception {
ConfigurationBuilder cfg = getDefaultStandaloneCacheConfig(true);
cfg.indexing().enable()
.storage(LOCAL_HEAP)
.addIndexedEntity(Foo.class);
EmbeddedCacheManager cacheManager = TestCacheManagerFactory.createCacheManager(cfg);
Cache<Object, Object> cache = cacheManager.getCache();
queryFactory = Search.getQueryFactory(cache);
return cacheManager;
}
@Test
public void testQueryProjectionWithSingleField() {
cache.put("1", new Foo("bar1", "baz1"));
Query<?> cacheQuery = createProjectionQuery("bar");
assertQueryReturns(cacheQuery, new Object[]{"bar1"});
}
@Test
public void testQueryProjectionWithMultipleFields() {
cache.put("1", new Foo("bar1", "baz1"));
Query<?> cacheQuery = createProjectionQuery("bar", "baz");
assertQueryReturns(cacheQuery, new Object[]{"bar1", "baz1"});
}
@Test
public void testMixedProjections() {
Foo foo = new Foo("bar1", "baz4");
cache.put("1", foo);
Query<?> cacheQuery = createProjectionQuery(
"baz",
"bar"
);
assertQueryReturns(cacheQuery, new Object[]{foo.baz, foo.bar});
}
private <T> Query<T> createProjectionQuery(String... projection) {
String selectClause = String.join(",", projection);
String q = String.format("SELECT %s FROM %s WHERE bar:'bar1'", selectClause, Foo.class.getName());
return queryFactory.create(q);
}
private void assertQueryReturns(Query<?> cacheQuery, Object expected) {
assertQueryListContains(cacheQuery.execute().list(), expected);
try (CloseableIterator<?> eagerIterator = cacheQuery.iterator()) {
assertQueryIteratorContains(eagerIterator, expected);
}
}
private void assertQueryListContains(List<?> list, Object expected) {
assert list.size() == 1;
Object value = list.get(0);
assertThat(value).isEqualTo(expected);
}
private void assertQueryIteratorContains(CloseableIterator<?> iterator, Object expected) {
assert iterator.hasNext();
Object value = iterator.next();
assertThat(value).isEqualTo(expected);
assert !iterator.hasNext();
}
private static EntityReferenceImpl entityReference(Class<?> type, String key) {
return new EntityReferenceImpl(PojoRawTypeIdentifier.of(type), type.getSimpleName(), key);
}
@Indexed(index = "FooIndex")
public static class Foo {
private String bar;
private String baz;
public Foo(String bar, String baz) {
this.bar = bar;
this.baz = baz;
}
@Text
public String getBar() {
return bar;
}
@Basic(projectable = true)
public String getBaz() {
return baz;
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Foo foo = (Foo) o;
if (bar != null ? !bar.equals(foo.bar) : foo.bar != null)
return false;
return baz != null ? baz.equals(foo.baz) : foo.baz == null;
}
@Override
public int hashCode() {
return bar.hashCode();
}
}
}
| 4,478
| 32.177778
| 104
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/projection/MetaProjectionTest.java
|
package org.infinispan.query.projection;
import static org.assertj.core.api.Assertions.assertThat;
import static org.infinispan.configuration.cache.IndexStorage.LOCAL_HEAP;
import java.util.List;
import org.infinispan.Cache;
import org.infinispan.commons.test.annotation.TestForIssue;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.container.versioning.NumericVersion;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.metadata.EmbeddedMetadata;
import org.infinispan.query.Search;
import org.infinispan.query.dsl.Query;
import org.infinispan.query.dsl.QueryFactory;
import org.infinispan.query.model.Developer;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "query.projection.MetaProjectionTest")
@TestForIssue(jiraKey = "ISPN-14478")
public class MetaProjectionTest extends SingleCacheManagerTest {
@Override
protected EmbeddedCacheManager createCacheManager() throws Exception {
ConfigurationBuilder cfg = getDefaultStandaloneCacheConfig(true);
cfg.indexing().enable()
.storage(LOCAL_HEAP)
.addIndexedEntity(Developer.class);
return TestCacheManagerFactory.createCacheManager(cfg);
}
@Test
public void testVersionProjection() {
Cache<Object, Developer> cache = cacheManager.getCache();
QueryFactory queryFactory = Search.getQueryFactory(cache);
cache.getAdvancedCache()
.put("open-contributor", new Developer("iamopen", "iamopen@redmail.io", "Infinispan developer", 2000),
new EmbeddedMetadata.Builder().version(new NumericVersion(1)).build());
cache.put("another-contributor", new Developer("mycodeisopen", "mycodeisopen@redmail.io", "Infinispan engineer",
799));
String ickle = String.format(
"select d.nick, version(d), d.email, d.biography, d.contributions from %s d where d.biography : 'Infinispan' order by d.email",
Developer.class.getName());
Query<Object[]> query = queryFactory.create(ickle);
List<Object[]> list = query.execute().list();
assertThat(list).hasSize(2);
assertThat(list.get(0)).containsExactly("iamopen", new NumericVersion(1), "iamopen@redmail.io",
"Infinispan developer", 2000);
assertThat(list.get(1)).containsExactly("mycodeisopen", null, "mycodeisopen@redmail.io",
"Infinispan engineer", 799);
ickle = String.format(
"select d.nick, version(d), d.email, d.biography, d.contributions from %s d where d.biography : 'developer'",
Developer.class.getName());
query = queryFactory.create(ickle);
list = query.execute().list();
assertThat(list).hasSize(1);
assertThat(list.get(0)).containsExactly("iamopen", new NumericVersion(1), "iamopen@redmail.io",
"Infinispan developer", 2000);
ickle = String.format(
"select version(d) from %s d where d.biography : 'developer'",
Developer.class.getName());
query = queryFactory.create(ickle);
list = query.execute().list();
assertThat(list).hasSize(1);
assertThat(list.get(0)).containsExactly(new NumericVersion(1));
ickle = String.format(
"select d, version(d) from %s d where d.biography : 'Infinispan' order by d.email",
Developer.class.getName());
query = queryFactory.create(ickle);
list = query.execute().list();
assertThat(list).hasSize(2);
assertThat(list.get(0)[0]).isNotNull().isInstanceOf(Developer.class);
assertThat(list.get(0)[1]).isEqualTo(new NumericVersion(1));
}
}
| 3,749
| 41.134831
| 139
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/sort/OrderByTest.java
|
package org.infinispan.query.sort;
import static org.assertj.core.api.Assertions.assertThat;
import static org.infinispan.configuration.cache.IndexStorage.LOCAL_HEAP;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.query.Search;
import org.infinispan.query.dsl.Query;
import org.infinispan.query.dsl.QueryFactory;
import org.infinispan.query.dsl.QueryResult;
import org.infinispan.query.model.Book;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "query.parameter.OrderByTest")
public class OrderByTest extends SingleCacheManagerTest {
@Override
protected EmbeddedCacheManager createCacheManager() throws Exception {
ConfigurationBuilder builder = getDefaultStandaloneCacheConfig(false);
builder.indexing().enable()
.storage(LOCAL_HEAP)
.addIndexedEntity(Book.class);
return TestCacheManagerFactory.createCacheManager(builder);
}
@BeforeMethod(alwaysRun = true)
public void beforeMethod() {
Book book = new Book();
book.setTitle("island");
book.setDescription("A place surrounded by the sea.");
cache.put(1, book);
Book book2 = new Book();
book2.setTitle("home");
book2.setDescription("The place where I'm staying.");
cache.put(2, book2);
Book book3 = new Book();
book3.setTitle("space");
book3.setDescription("Space is the place");
cache.put(3, book3);
}
public void useDifferentIndexFieldNamesTests() {
QueryFactory factory = Search.getQueryFactory(cache);
Query<Book> query = factory.create("from org.infinispan.query.model.Book where naming : 'place' order by label");
QueryResult<Book> result = query.execute();
assertThat(result.count().isExact()).isTrue();
assertThat(result.count().value()).isEqualTo(3);
assertThat(result.list()).extracting("title").contains("island", "home", "space");
}
}
| 2,153
| 35.508475
| 119
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/expiration/DistributedQueryExpiredEntitiesTest.java
|
package org.infinispan.query.expiration;
import static org.assertj.core.api.Assertions.assertThat;
import static org.infinispan.configuration.cache.IndexStorage.LOCAL_HEAP;
import java.util.concurrent.TimeUnit;
import org.infinispan.Cache;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.test.annotation.TestForIssue;
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.query.Search;
import org.infinispan.query.dsl.Query;
import org.infinispan.query.dsl.QueryFactory;
import org.infinispan.query.dsl.QueryResult;
import org.infinispan.query.model.Game;
import org.infinispan.test.MultipleCacheManagersTest;
import org.infinispan.test.TestingUtil;
import org.testng.annotations.Test;
@TestForIssue(jiraKey = "ISPN-14119")
public class DistributedQueryExpiredEntitiesTest extends MultipleCacheManagersTest {
private static final String CACHE_NAME = "games";
private static final int TIME = 100;
private static final ControlledTimeService timeService = new ControlledTimeService();
@Override
protected void createCacheManagers() throws Throwable {
GlobalConfigurationBuilder global = GlobalConfigurationBuilder.defaultClusteredBuilder();
ConfigurationBuilder config = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC);
createClusteredCaches(3, global, config, true, "default");
EmbeddedCacheManager cacheManager = cacheManagers.get(0); // use the first one
TestingUtil.replaceComponent(cacheManager, TimeService.class, timeService, true);
config.encoding().mediaType(MediaType.APPLICATION_PROTOSTREAM_TYPE);
config.expiration()
.lifespan(TIME, TimeUnit.MILLISECONDS)
.maxIdle(TIME, TimeUnit.MILLISECONDS);
config.indexing().enable()
.storage(LOCAL_HEAP)
.addIndexedEntity("org.infinispan.query.model.Game");
config.statistics().enable();
cacheManager.createCache(CACHE_NAME, config.build());
}
@Test
public void testQueryExpiredEntities() {
Cache<Integer, Game> cache = cacheManagers.get(0).getCache(CACHE_NAME);
cache.put(1, new Game("Ultima IV: Quest of the Avatar", "It is the first in the \"Age of Enlightenment\" trilogy ..."));
QueryFactory factory = Search.getQueryFactory(cache);
Query<Game> query = factory.create("from org.infinispan.query.model.Game where description : 'trilogy'");
QueryResult<Game> result = query.execute();
assertThat(result.count().isExact()).isTrue();
assertThat(result.count().value()).isEqualTo(1);
assertThat(result.list()).extracting("name").contains("Ultima IV: Quest of the Avatar");
timeService.advance(TIME * 2);
query = factory.create("from org.infinispan.query.model.Game where description : 'trilogy'");
result = query.execute();
assertThat(result.count().isExact()).isTrue();
assertThat(result.count().value()).isEqualTo(1);
// verify that the result list does not contain any null value, but it is empty in this case
assertThat(result.list()).isEmpty();
}
}
| 3,401
| 41
| 126
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/continuous/CallCountingCQResultListener.java
|
package org.infinispan.query.continuous;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import org.infinispan.query.api.continuous.ContinuousQueryListener;
import org.infinispan.util.logging.Log;
import org.infinispan.util.logging.LogFactory;
/**
* {@link ContinuousQueryListener} which counts number of calls for each key.
*
* @author vjuranek
* @since 8.0
*/
public class CallCountingCQResultListener<K, V> implements ContinuousQueryListener<K, V> {
private static final Log log = LogFactory.getLog(CallCountingCQResultListener.class);
private final Map<K, Integer> joined = Collections.synchronizedMap(new HashMap<>());
private final Map<K, Integer> updated = Collections.synchronizedMap(new HashMap<>());
private final Map<K, Integer> left = Collections.synchronizedMap(new HashMap<>());
@Override
public void resultJoining(K key, V value) {
log.debugf("Key %s joined", key);
incrementNumberOfCalls(key, joined);
}
@Override
public void resultUpdated(K key, V value) {
log.debugf("Key %s updated", key);
incrementNumberOfCalls(key, updated);
}
@Override
public void resultLeaving(K key) {
log.debugf("Key %s left", key);
incrementNumberOfCalls(key, left);
}
public Map<K, Integer> getJoined() {
return joined;
}
public Map<K, Integer> getUpdated() {
return updated;
}
public Map<K, Integer> getLeft() {
return left;
}
private void incrementNumberOfCalls(K key, Map<K, Integer> callMap) {
synchronized (callMap) {
Integer calls = callMap.get(key);
callMap.put(key, calls == null ? 1 : calls + 1);
}
}
}
| 1,700
| 26.885246
| 90
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/continuous/AbstractCQMultipleCachesTest.java
|
package org.infinispan.query.continuous;
import static org.testng.AssertJUnit.assertEquals;
import java.util.Map;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.query.Search;
import org.infinispan.query.api.continuous.ContinuousQuery;
import org.infinispan.query.dsl.Query;
import org.infinispan.query.dsl.QueryFactory;
import org.infinispan.query.test.Person;
import org.infinispan.query.test.QueryTestSCI;
import org.infinispan.test.MultipleCacheManagersTest;
import org.testng.annotations.Test;
/**
* Base class for continuous query tests with multiple caches.
*
* @author vjuranek
* @since 8.0
*/
@Test(groups = "functional")
public abstract class AbstractCQMultipleCachesTest extends MultipleCacheManagersTest {
protected final int NUM_NODES = 3;
protected final int NUM_OWNERS = NUM_NODES - 1;
protected abstract CacheMode getCacheMode();
public AbstractCQMultipleCachesTest() {
cleanup = CleanupPhase.AFTER_METHOD;
}
@Override
protected void createCacheManagers() {
ConfigurationBuilder c = buildConfiguration();
createCluster(QueryTestSCI.INSTANCE, c, NUM_NODES);
waitForClusterToForm();
}
protected ConfigurationBuilder buildConfiguration() {
ConfigurationBuilder c = getDefaultClusteredCacheConfig(getCacheMode(), false);
c.clustering().hash().numOwners(NUM_OWNERS);
return c;
}
protected CallCountingCQResultListener<Integer, Person> createContinuousQuery() {
QueryFactory qf = Search.getQueryFactory(cache(0));
Query<Person> query = qf.create("FROM org.infinispan.query.test.Person WHERE age <= 30");
CallCountingCQResultListener<Integer, Person> listener = new CallCountingCQResultListener<>();
ContinuousQuery<Integer, Person> cq = Search.getContinuousQuery(cache(0));
cq.addContinuousQueryListener(query, listener);
return listener;
}
public void testContinuousQueryMultipleCaches() {
for (int i = 0; i < 2; i++) {
Person value = new Person();
value.setName("John");
value.setAge(22);
cache(i).put(i, value);
}
CallCountingCQResultListener<Integer, Person> listener = createContinuousQuery();
final Map<Integer, Integer> joined = listener.getJoined();
final Map<Integer, Integer> left = listener.getLeft();
assertEquals(2, joined.size());
assertEquals(0, left.size());
joined.clear();
for (int i = 0; i < 2; i++) {
Person value = new Person();
value.setName("John");
value.setAge(40);
cache(i).put(i, value);
}
assertEquals(0, joined.size());
assertEquals(2, left.size());
left.clear();
for (int i = 0; i < 10; i++) {
Person value = new Person();
value.setName("John");
value.setAge(i + 25);
cache(0).put(i, value);
}
assertEquals(6, joined.size());
assertEquals(0, left.size());
for (int i = 0; i < 6; i++) {
assertEquals(1, joined.get(i).intValue());
}
joined.clear();
cache(0).clear();
assertEquals(0, joined.size());
assertEquals(6, left.size());
for (int i = 0; i < 6; i++) {
assertEquals(1, left.get(i).intValue());
}
left.clear();
}
public void testCQCacheLeavesAndJoins() {
CallCountingCQResultListener<Integer, Person> listener = createContinuousQuery();
final Map<Integer, Integer> joined = listener.getJoined();
final Map<Integer, Integer> left = listener.getLeft();
assertEquals(0, joined.size());
assertEquals(0, left.size());
for (int i = 0; i < 2; i++) {
Person value = new Person();
value.setName("John");
value.setAge(40);
cache(i).put(i, value);
}
assertEquals(0, joined.size());
assertEquals(0, left.size());
for (int i = 0; i < 10; i++) {
Person value = new Person();
value.setName("John");
value.setAge(i + 25);
cache(0).put(i, value);
if (i == 2) {
// The listener matches entries with age <= 30
// It will receive entries 0..2 before the node is killed, and entries 3..5 after
killMember(1);
}
}
assertEquals(6, joined.size());
assertEquals(0, left.size());
for (int i = 0; i < 6; i++) {
assertEquals(1, joined.get(i).intValue());
}
joined.clear();
cache(0).clear();
assertEquals(0, joined.size());
assertEquals(6, left.size());
left.clear();
for (int i = 0; i < 10; i++) {
Person value = new Person();
value.setName("John");
value.setAge(i + 25);
cache(0).put(i, value);
if (i == 2) {
// The listener matches entries with age <= 30
// It will receive entries 0..2 before the node joins, and entries 3..5 after
addClusterEnabledCacheManager(QueryTestSCI.INSTANCE, buildConfiguration());
}
}
assertEquals(6, joined.size());
assertEquals(0, left.size());
for (int i = 0; i < 6; i++) {
assertEquals(1, joined.get(i).intValue());
}
joined.clear();
}
}
| 5,318
| 29.745665
| 100
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/continuous/ContinuousQueryMultipleCachesDistTest.java
|
package org.infinispan.query.continuous;
import org.infinispan.configuration.cache.CacheMode;
import org.testng.annotations.Test;
/**
* Tests continuous query with multiple caches in distribute mode.
*
* @author vjuranek
* @since 8.0
*/
@Test(groups = "functional", testName = "query.continuous.ContinuousQueryMultipleCachesDistTest")
public class ContinuousQueryMultipleCachesDistTest extends AbstractCQMultipleCachesTest {
@Override
protected CacheMode getCacheMode() {
return CacheMode.DIST_SYNC;
}
}
| 528
| 24.190476
| 97
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/continuous/ContinuousQueryTest.java
|
package org.infinispan.query.continuous;
import static org.testng.AssertJUnit.assertEquals;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import org.infinispan.commons.time.TimeService;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.objectfilter.ParsingException;
import org.infinispan.query.Search;
import org.infinispan.query.api.continuous.ContinuousQuery;
import org.infinispan.query.dsl.Query;
import org.infinispan.query.dsl.QueryFactory;
import org.infinispan.query.test.Person;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.infinispan.util.ControlledTimeService;
import org.testng.annotations.Test;
/**
* @author anistor@redhat.com
* @since 8.0
*/
@Test(groups = "functional", testName = "query.continuous.ContinuousQueryTest")
public class ContinuousQueryTest extends SingleCacheManagerTest {
protected ControlledTimeService timeService = new ControlledTimeService();
@Override
protected EmbeddedCacheManager createCacheManager() throws Exception {
ConfigurationBuilder cacheConfiguration = TestCacheManagerFactory.getDefaultCacheConfiguration(true);
//cacheConfiguration.transaction().lockingMode(LockingMode.PESSIMISTIC);
EmbeddedCacheManager cm = TestCacheManagerFactory.createCacheManager(cacheConfiguration);
TestingUtil.replaceComponent(cm, TimeService.class, timeService, true);
return cm;
}
/**
* Fulltext continuous queries are not allowed.
*/
@Test(expectedExceptions = ParsingException.class, expectedExceptionsMessageRegExp = ".*ISPN028521:.*")
public void testDisallowFullTextQuery() {
QueryFactory qf = Search.getQueryFactory(cache());
Query<Person> query = qf.create("FROM org.infinispan.query.test.Person WHERE name : 'john'");
ContinuousQuery<Object, Object> cq = Search.getContinuousQuery(cache());
cq.addContinuousQueryListener(query, new CallCountingCQResultListener<>());
}
/**
* Using grouping and aggregation with continuous query is not allowed.
*/
@Test(expectedExceptions = ParsingException.class, expectedExceptionsMessageRegExp = ".*ISPN028509:.*")
public void testDisallowGroupingAndAggregation() {
QueryFactory qf = Search.getQueryFactory(cache());
Query<Object[]> query = qf.create("SELECT MAX(age) FROM org.infinispan.query.test.Person WHERE age >= 20");
ContinuousQuery<Integer, Person> cq = Search.getContinuousQuery(cache());
cq.addContinuousQueryListener(query, new CallCountingCQResultListener<>());
}
public void testContinuousQuery() {
for (int i = 0; i < 2; i++) {
Person value = new Person();
value.setName("John");
value.setAge(30 + i);
cache().put(i, value);
}
QueryFactory qf = Search.getQueryFactory(cache());
ContinuousQuery<Integer, Person> cq = Search.getContinuousQuery(cache());
Query<Object[]> query = qf.create("SELECT age FROM org.infinispan.query.test.Person WHERE age <= :ageParam");
query.setParameter("ageParam", 30);
CallCountingCQResultListener<Integer, Person> listener = new CallCountingCQResultListener<>();
cq.addContinuousQueryListener(query, listener);
final Map<Integer, Integer> joined = listener.getJoined();
final Map<Integer, Integer> updated = listener.getUpdated();
final Map<Integer, Integer> left = listener.getLeft();
assertEquals(1, joined.size());
assertEquals(0, updated.size());
assertEquals(0, left.size());
joined.clear();
for (int i = 0; i < 10; i++) {
Person value = new Person();
value.setName("John");
value.setAge(i + 25);
cache().put(i, value);
}
assertEquals(5, joined.size());
assertEquals(1, updated.size());
assertEquals(0, left.size());
joined.clear();
for (int i = 0; i < 2; i++) {
Person value = new Person();
value.setName("John");
value.setAge(i + 40);
cache().put(i, value);
}
assertEquals(0, joined.size());
assertEquals(1, updated.size());
assertEquals(2, left.size());
left.clear();
for (int i = 4; i < 20; i++) {
cache().remove(i);
}
assertEquals(0, joined.size());
assertEquals(1, updated.size());
assertEquals(2, left.size());
left.clear();
cache().clear(); //todo [anistor] Does this generate MODIFY instead of REMOVE ???
assertEquals(0, joined.size());
assertEquals(1, updated.size());
assertEquals(2, left.size());
left.clear();
for (int i = 0; i < 2; i++) {
Person value = new Person();
value.setName("John");
value.setAge(i + 20);
cache().put(i, value, 5, TimeUnit.MILLISECONDS);
}
assertEquals(2, joined.size());
assertEquals(1, updated.size());
assertEquals(0, left.size());
joined.clear();
timeService.advance(6);
cache.getAdvancedCache().getExpirationManager().processExpiration();
assertEquals(0, cache().size());
assertEquals(0, joined.size());
assertEquals(1, updated.size());
assertEquals(2, left.size());
left.clear();
cq.removeContinuousQueryListener(listener);
for (int i = 0; i < 3; i++) {
Person value = new Person();
value.setName("John");
value.setAge(i + 20);
cache().put(i, value);
}
assertEquals(0, joined.size());
assertEquals(1, updated.size());
assertEquals(0, left.size());
}
public void testContinuousQueryChangingParameter() {
for (int i = 0; i < 2; i++) {
Person value = new Person();
value.setName("John");
value.setAge(30 + i);
cache().put(i, value);
}
QueryFactory qf = Search.getQueryFactory(cache());
ContinuousQuery<Object, Object> cq = Search.getContinuousQuery(cache());
Query<Object[]> query = qf.create("SELECT age FROM org.infinispan.query.test.Person WHERE age <= :ageParam");
query.setParameter("ageParam", 30);
CallCountingCQResultListener<Object, Object> listener = new CallCountingCQResultListener<>();
cq.addContinuousQueryListener(query, listener);
Map<Object, Integer> joined = listener.getJoined();
Map<Object, Integer> updated = listener.getUpdated();
Map<Object, Integer> left = listener.getLeft();
assertEquals(1, joined.size());
assertEquals(0, updated.size());
assertEquals(0, left.size());
joined.clear();
cq.removeContinuousQueryListener(listener);
query.setParameter("ageParam", 32);
listener = new CallCountingCQResultListener<>();
cq.addContinuousQueryListener(query, listener);
joined = listener.getJoined();
left = listener.getLeft();
assertEquals(2, joined.size());
assertEquals(0, updated.size());
assertEquals(0, left.size());
cq.removeContinuousQueryListener(listener);
}
public void testTwoSimilarCQ() {
QueryFactory qf = Search.getQueryFactory(cache());
CallCountingCQResultListener<Object, Object> listener = new CallCountingCQResultListener<>();
Query<Person> query1 = qf.create("FROM org.infinispan.query.test.Person WHERE (age <= 30 AND name = 'John') OR name = 'Johny'");
ContinuousQuery<Object, Object> cq1 = Search.getContinuousQuery(cache());
cq1.addContinuousQueryListener(query1, listener);
Query<Person> query2 = qf.create("FROM org.infinispan.query.test.Person WHERE age <= 30 OR name = 'Joe'");
ContinuousQuery<Object, Object> cq2 = Search.getContinuousQuery(cache());
cq2.addContinuousQueryListener(query2, listener);
final Map<Object, Integer> joined = listener.getJoined();
final Map<Object, Integer> updated = listener.getUpdated();
final Map<Object, Integer> left = listener.getLeft();
assertEquals(0, joined.size());
assertEquals(0, updated.size());
assertEquals(0, left.size());
Person value = new Person();
value.setName("John");
value.setAge(20);
cache().put(1, value);
assertEquals(1, joined.size());
assertEquals(2, joined.get(1).intValue());
assertEquals(0, updated.size());
assertEquals(0, left.size());
joined.clear();
value = new Person();
value.setName("Joe");
cache().replace(1, value);
assertEquals(0, joined.size());
assertEquals(1, updated.size());
assertEquals(1, left.size());
joined.clear();
left.clear();
value = new Person();
value.setName("Joe");
value.setAge(31);
cache().replace(1, value);
assertEquals(0, joined.size());
assertEquals(1, updated.size());
assertEquals(0, left.size());
joined.clear();
left.clear();
value = new Person();
value.setName("John");
value.setAge(29);
cache().put(1, value);
assertEquals(1, joined.size());
assertEquals(1, joined.get(1).intValue());
assertEquals(1, updated.size());
assertEquals(0, left.size());
joined.clear();
left.clear();
value = new Person();
value.setName("Johny");
value.setAge(29);
cache().put(1, value);
assertEquals(0, joined.size());
assertEquals(1, updated.size());
assertEquals(0, left.size());
joined.clear();
left.clear();
cache().clear();
assertEquals(0, joined.size());
assertEquals(1, left.size());
assertEquals(2, left.get(1).intValue());
assertEquals(1, updated.size());
}
}
| 9,786
| 32.748276
| 134
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/continuous/ContinuousQueryProfilingTest.java
|
package org.infinispan.query.continuous;
import org.infinispan.Cache;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.query.Search;
import org.infinispan.query.api.continuous.ContinuousQuery;
import org.infinispan.query.api.continuous.ContinuousQueryListener;
import org.infinispan.query.dsl.Query;
import org.infinispan.query.dsl.QueryFactory;
import org.infinispan.query.test.Person;
import org.infinispan.query.test.QueryTestSCI;
import org.infinispan.test.MultipleCacheManagersTest;
import org.testng.annotations.Test;
/**
* @author anistor@redhat.com
* @since 8.2
*/
@Test(groups = "profiling", testName = "query.continuous.ContinuousQueryProfilingTest")
public class ContinuousQueryProfilingTest extends MultipleCacheManagersTest {
private static final int NUM_NODES = 10;
private static final int NUM_OWNERS = 3;
private static final int NUM_ENTRIES = 100000;
private static final int NUM_LISTENERS = 1000;
@Override
protected void createCacheManagers() {
ConfigurationBuilder c = buildConfiguration();
createCluster(QueryTestSCI.INSTANCE, c, NUM_NODES);
waitForClusterToForm();
}
private ConfigurationBuilder buildConfiguration() {
ConfigurationBuilder c = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, false);
c.clustering().hash().numOwners(NUM_OWNERS);
return c;
}
public void testContinuousQueryPerformance() {
long t1 = testContinuousQueryPerformance(false);
long t2 = testContinuousQueryPerformance(true);
log.infof("ContinuousQueryProfilingTest.testContinuousQueryPerformance doRegisterListener=false took %d us\n", t1 / 1000);
log.infof("ContinuousQueryProfilingTest.testContinuousQueryPerformance doRegisterListener=true took %d us\n", t2 / 1000);
}
private long testContinuousQueryPerformance(boolean doRegisterListener) {
ContinuousQuery<String, Person> cq = Search.getContinuousQuery(cache(0));
if (doRegisterListener) {
Query<Person> query = makeQuery(cache(0));
for (int i = 0; i < NUM_LISTENERS; i++) {
cq.addContinuousQueryListener(query, new ContinuousQueryListener<String, Person>() {
});
}
}
long startTs = System.nanoTime();
// create entries
for (int i = 0; i < NUM_ENTRIES; ++i) {
Person value = new Person();
value.setName("John");
value.setAge(i + 25);
Cache<String, Person> cache = cache(i % NUM_NODES);
cache.put(value.getName(), value);
}
// update entries (with same value)
for (int i = 0; i < NUM_ENTRIES; ++i) {
Person value = new Person();
value.setName("John");
value.setAge(i + 25);
Cache<String, Person> cache = cache(i % NUM_NODES);
cache.put(value.getName(), value);
}
long endTs = System.nanoTime();
cq.removeAllListeners();
return endTs - startTs;
}
private Query<Person> makeQuery(Cache<?, ?> c) {
QueryFactory qf = Search.getQueryFactory(c);
return qf.create("FROM org.infinispan.query.test.Person WHERE age >= 18");
}
}
| 3,219
| 35.179775
| 128
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/continuous/ContinuousQueryMultipleCachesReplTest.java
|
package org.infinispan.query.continuous;
import org.infinispan.configuration.cache.CacheMode;
import org.testng.annotations.Test;
/**
* Tests continuous query with multiple caches in replicated mode.
*
* @author vjuranek
* @since 8.0
*/
@Test(groups = "functional", testName = "query.continuous.ContinuousQueryMultipleCachesReplTest")
public class ContinuousQueryMultipleCachesReplTest extends AbstractCQMultipleCachesTest {
@Override
protected CacheMode getCacheMode() {
return CacheMode.REPL_SYNC;
}
}
| 528
| 24.190476
| 97
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/indexedembedded/CollectionsIndexingTest.java
|
package org.infinispan.query.indexedembedded;
import static org.infinispan.configuration.cache.IndexStorage.LOCAL_HEAP;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertSame;
import java.util.List;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.query.Search;
import org.infinispan.query.dsl.Query;
import org.infinispan.query.dsl.QueryFactory;
import org.infinispan.query.test.QueryTestSCI;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
/**
* @author Sanne Grinovero <sanne@hibernate.org> (C) 2011 Red Hat Inc.
*/
@Test(groups = "functional", testName = "query.indexedembedded.CollectionsIndexingTest")
public class CollectionsIndexingTest extends SingleCacheManagerTest {
private QueryFactory queryFactory;
protected EmbeddedCacheManager createCacheManager() throws Exception {
ConfigurationBuilder cfg = getDefaultStandaloneCacheConfig(true);
cfg
.indexing()
.enable()
.storage(LOCAL_HEAP)
.addIndexedEntity(Country.class);
return TestCacheManagerFactory.createCacheManager(QueryTestSCI.INSTANCE, cfg);
}
@BeforeClass
public void prepareSearchManager() {
queryFactory = Search.getQueryFactory(cache);
}
@AfterMethod
public void cleanupData() {
cache.clear();
}
@Test
public void searchOnEmptyIndex() {
List<?> list = getCountryQuery().list();
assertEquals(0, list.size());
}
private Query getCountryQuery() {
String q = String.format("FROM %s where countryName:'Italy'", Country.class.getName());
return queryFactory.create(q);
}
private Query getMatchAllQuery() {
String q = String.format("FROM %s", Country.class.getName());
return queryFactory.create(q);
}
@Test
public void searchOnAllTypes() {
Country italy = new Country();
italy.countryName = "Italy";
cache.put("IT", italy);
List<?> list = getCountryQuery().list();
assertEquals(1, list.size());
list = getCountryQuery().list();
assertEquals(1, list.size());
list = getMatchAllQuery().list();
assertEquals(1, list.size());
}
@Test
public void searchOnSimpleField() throws Exception {
Country italy = new Country();
italy.countryName = "Italy";
cache.put("IT", italy);
List<?> list = getCountryQuery().list();
assertEquals(1, list.size());
}
@Test
public void searchOnEmbeddedField() {
Country uk = new Country();
City london = new City();
london.name = "London";
City newcastle = new City();
newcastle.name = "Newcastle";
uk.countryName = "United Kingdom";
uk.cities.add(newcastle);
uk.cities.add(london);
//verify behaviour on multiple insertions as well:
cache.put("UK", uk);
cache.put("UK", uk);
cache.put("UK", uk);
String q = String.format("FROM %s c where c.cities.name:'Newcastle'", Country.class.getName());
List<?> list = queryFactory.create(q).list();
assertEquals(1, list.size());
assertSame(uk, list.get(0));
}
}
| 3,393
| 30.425926
| 101
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/indexedembedded/BooksExampleTest.java
|
package org.infinispan.query.indexedembedded;
import static org.infinispan.configuration.cache.IndexStorage.LOCAL_HEAP;
import java.util.List;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.query.Search;
import org.infinispan.query.dsl.QueryFactory;
import org.infinispan.query.test.QueryTestSCI;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.infinispan.transaction.TransactionMode;
import org.testng.annotations.Test;
/**
* @author Sanne Grinovero <sanne@infinispan.org> (C) 2011 Red Hat Inc.
*/
@Test(groups = "functional", testName = "query.indexedembedded.BooksExampleTest")
public class BooksExampleTest extends SingleCacheManagerTest {
protected EmbeddedCacheManager createCacheManager() throws Exception {
ConfigurationBuilder cfg = getDefaultStandaloneCacheConfig(true);
cfg
.transaction()
.transactionMode(TransactionMode.TRANSACTIONAL)
.indexing()
.enable()
.storage(LOCAL_HEAP)
.addIndexedEntity(Book.class);
return TestCacheManagerFactory.createCacheManager(QueryTestSCI.INSTANCE, cfg);
}
@Test
public void searchOnEmptyIndex() {
cache.put("1",
new Book("Seam in Action",
"Dan Allen",
"Manning"));
cache.put("2",
new Book("Hibernate Search in Action",
"Emmanuel Bernard and John Griffin",
"Manning"));
cache.put("3",
new Book("Megaprogramming Ruby",
"Paolo Perrotta",
"The Pragmatic Programmers"));
QueryFactory qf = Search.getQueryFactory(cache);
String query = String.format("FROM %s WHERE title:'in action'", Book.class.getName());
List<?> list = qf.create(query).list();
assert list.size() == 2;
}
}
| 1,984
| 33.224138
| 92
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/indexedembedded/City.java
|
package org.infinispan.query.indexedembedded;
import org.infinispan.api.annotations.indexing.Text;
import org.infinispan.protostream.annotations.ProtoField;
/**
* @author Sanne Grinovero <sanne@hibernate.org> (C) 2011 Red Hat Inc.
*/
public class City {
@ProtoField(1)
public String name;
@Text
public String getName() {
return name;
}
}
| 371
| 18.578947
| 76
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/indexedembedded/Book.java
|
package org.infinispan.query.indexedembedded;
import java.io.Serializable;
import org.infinispan.api.annotations.indexing.Basic;
import org.infinispan.api.annotations.indexing.Indexed;
import org.infinispan.api.annotations.indexing.Text;
@Indexed
public class Book implements Serializable {
String title;
String author;
String editor;
public Book(String title, String author, String editor) {
this.title = title;
this.author = author;
this.editor = editor;
}
@Text
public String getTitle() {
return title;
}
@Basic
public String getAuthor() {
return author;
}
@Basic
public String getEditor() {
return editor;
}
}
| 700
| 17.945946
| 60
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/indexedembedded/Country.java
|
package org.infinispan.query.indexedembedded;
import java.util.HashSet;
import java.util.Set;
import org.infinispan.api.annotations.indexing.Embedded;
import org.infinispan.api.annotations.indexing.Indexed;
import org.infinispan.api.annotations.indexing.Text;
import org.infinispan.protostream.annotations.ProtoField;
/**
* @author Sanne Grinovero <sanne@hibernate.org> (C) 2011 Red Hat Inc.
*/
@Indexed
public class Country {
@ProtoField(1)
public Long id;
@ProtoField(2)
public String countryName;
@ProtoField(number = 3, collectionImplementation = HashSet.class)
public Set<City> cities = new HashSet<>();
@Text
public String getCountryName() {
return countryName;
}
@Embedded
public Set<City> getCities() {
return cities;
}
}
| 794
| 21.083333
| 76
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/indexing/DefaultIndexPathTest.java
|
package org.infinispan.query.indexing;
import java.nio.file.Path;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import org.infinispan.Cache;
import org.infinispan.commons.test.annotation.TestForIssue;
import org.infinispan.commons.util.Util;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.cache.IndexStorage;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.query.Search;
import org.infinispan.query.core.stats.IndexInfo;
import org.infinispan.query.impl.config.SearchPropertyExtractor;
import org.infinispan.query.model.TypeA;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "query.indexing.DefaultIndexPathTest")
@TestForIssue(jiraKey = "ISPN-14109")
public class DefaultIndexPathTest extends SingleCacheManagerTest {
private static final String CACHE_1_NAME = "cache-1";
private static final String CACHE_2_NAME = "cache-2";
private static final int SIZE = 400;
private Path indexLocation1;
private Path indexLocation2;
@Override
protected EmbeddedCacheManager createCacheManager() throws Exception {
ConfigurationBuilder config = new ConfigurationBuilder();
config
.indexing()
.enable()
.storage(IndexStorage.FILESYSTEM) // use filesystem storage without defining a path
.addIndexedEntity(TypeA.class);
EmbeddedCacheManager result = TestCacheManagerFactory.createCacheManager();
result.defineConfiguration(CACHE_1_NAME, config.build());
result.defineConfiguration(CACHE_2_NAME, config.build());
GlobalConfiguration globalConfiguration = result.getGlobalComponentRegistry().getGlobalConfiguration();
indexLocation1 = SearchPropertyExtractor.getIndexLocation(globalConfiguration, null, CACHE_1_NAME);
indexLocation2 = SearchPropertyExtractor.getIndexLocation(globalConfiguration, null, CACHE_2_NAME);
return result;
}
@Test
public void test() throws Exception {
Map<String, TypeA> entries = IntStream.range(0, SIZE).boxed()
.map(i -> "simple-" + i)
.collect(Collectors.toMap(id -> "key-" + id, id -> new TypeA("value-" + id)));
Cache<String, TypeA> cache1 = cacheManager.getCache(CACHE_1_NAME);
Cache<String, TypeA> cache2 = cacheManager.getCache(CACHE_2_NAME);
CompletableFuture<Void> future1 = cache1.putAllAsync(entries);
CompletableFuture<Void> future2 = cache2.putAllAsync(entries);
future1.get();
// if the default filesystem storage is not chosen wisely, we're expecting a lock error such as:
//
// java.util.concurrent.ExecutionException: org.infinispan.commons.CacheException:
// HSEARCH600016: Unable to index entity of type 'org.infinispan.query.model.TypeA' with identifier 'key-simple-313' and tenant identifier 'null':
// Lock held by this virtual machine: /Users/fabio/code/infinispan/query/index-A/write.lock
// Context: index 'index-A'
future2.get();
CompletionStage<Map<String, IndexInfo>> infoIndex1 = Search.getSearchStatistics(cache1).getIndexStatistics()
.computeIndexInfos();
CompletionStage<Map<String, IndexInfo>> infoIndex2 = Search.getSearchStatistics(cache2).getIndexStatistics()
.computeIndexInfos();
infoIndex1.toCompletableFuture().get();
// same here:
infoIndex2.toCompletableFuture().get();
}
@Override
protected void teardown() {
// index-A is specified as index in TypeA class >> @Indexed(index = "index-A")
Util.recursiveFileRemove(indexLocation1);
Util.recursiveFileRemove(indexLocation2);
super.teardown();
}
}
| 4,007
| 41.189474
| 152
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/indexing/IndexingOperationOffloadingTest.java
|
package org.infinispan.query.indexing;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Fail.fail;
import java.util.HashMap;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicInteger;
import org.infinispan.Cache;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.cache.IndexStorage;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.query.Search;
import org.infinispan.query.dsl.Query;
import org.infinispan.query.dsl.QueryFactory;
import org.infinispan.query.dsl.QueryResult;
import org.infinispan.query.logging.Log;
import org.infinispan.query.model.TypeA;
import org.infinispan.query.model.TypeB;
import org.infinispan.query.model.TypeC;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.infinispan.util.logging.LogFactory;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "query.indexing.IndexingOperationOffloadingTest")
public class IndexingOperationOffloadingTest extends SingleCacheManagerTest {
private static final Log log = LogFactory.getLog(IndexingOperationOffloadingTest.class, Log.class);
private static final String CACHE_NAME = "types";
private static final int SIZE = 400;
private static final int CHUNK_SIZE = 20;
private static final int CHUNKS_NUMBER = SIZE / CHUNK_SIZE;
@Override
protected EmbeddedCacheManager createCacheManager() throws Exception {
ConfigurationBuilder config = new ConfigurationBuilder();
config
.indexing()
.enable()
.storage(IndexStorage.LOCAL_HEAP)
.writer().queueCount(1).queueSize(1) // Use a very small single queue
.addIndexedEntity(TypeA.class)
.addIndexedEntity(TypeB.class)
.addIndexedEntity(TypeC.class);
EmbeddedCacheManager result = TestCacheManagerFactory.createCacheManager();
result.defineConfiguration(CACHE_NAME, config.build());
return result;
}
public void putAll() throws Exception {
Cache<Object, Object> types = cacheManager.getCache(CACHE_NAME);
HashMap<String, Object> entries = new HashMap<>();
for (int i = 0; i < SIZE; i++) {
String id = "simple-" + i;
String key = "key-" + id;
String value = "value-" + id;
entries.put(key, new TypeA(value));
}
types.putAllAsync(entries).get();
assertThat(entries).hasSize(SIZE);
QueryFactory factory = Search.getQueryFactory(types);
Query<TypeA> queryAll = factory.create("from org.infinispan.query.model.TypeA");
QueryResult<TypeA> result = queryAll.execute();
assertThat(result.count().value()).isEqualTo(SIZE);
}
@Test
public void batchedPutAll() throws Exception {
Cache<Object, Object> types = cacheManager.getCache(CACHE_NAME);
CompletableFuture<Void>[] chunksExecutions = new CompletableFuture[CHUNKS_NUMBER];
AtomicInteger completedExecutions = new AtomicInteger(0);
long timeZero = System.currentTimeMillis();
for (int c = 0; c < CHUNKS_NUMBER; c++) {
HashMap<String, Object> chunk = new HashMap<>();
for (int i = 0; i < CHUNK_SIZE; i++) {
String id = "batch-" + c + "-" + i;
String key = "key-" + id;
String value = "value-" + id;
chunk.put(key, new TypeB(value));
}
CompletableFuture<Void> execution = types.putAllAsync(chunk);
log.info("Started: " + (c + 1) + " / " + CHUNKS_NUMBER + ". Elapsed: " + getElapsed(timeZero));
execution.whenComplete((unused, throwable) -> {
if (throwable != null) {
fail("We don't expect the throwable:", throwable);
}
log.info("Completed: " + completedExecutions.incrementAndGet() + " / " + CHUNKS_NUMBER +
". Elapsed: " + getElapsed(timeZero));
});
chunksExecutions[c] = execution;
}
CompletableFuture.allOf(chunksExecutions).get();
assertThat(completedExecutions.get()).isEqualTo(CHUNKS_NUMBER);
QueryFactory factory = Search.getQueryFactory(types);
Query<TypeB> queryAll = factory.create("from org.infinispan.query.model.TypeB");
QueryResult<TypeB> result = queryAll.execute();
assertThat(result.count().value()).isEqualTo(CHUNKS_NUMBER * CHUNK_SIZE);
}
private long getElapsed(long timeZero) {
return System.currentTimeMillis() - timeZero;
}
}
| 4,596
| 36.991736
| 104
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/config/DeclarativeConfigTest.java
|
package org.infinispan.query.config;
import static org.assertj.core.api.Assertions.assertThat;
import static org.testng.AssertJUnit.assertEquals;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.List;
import org.apache.lucene.store.ByteBuffersDirectory;
import org.hibernate.search.engine.backend.index.IndexManager;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.query.dsl.Query;
import org.infinispan.query.helper.IndexAccessor;
import org.infinispan.query.helper.TestQueryHelperFactory;
import org.infinispan.query.test.Person;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
@Test(testName = "query.config.DeclarativeConfigTest", groups = "functional")
public class DeclarativeConfigTest extends SingleCacheManagerTest {
@Override
protected EmbeddedCacheManager createCacheManager() throws Exception {
String config = TestingUtil.wrapXMLWithSchema(
"<cache-container default-cache=\"default\">" +
" <local-cache name=\"default\">\n" +
" <indexing storage=\"local-heap\">\n" +
" <indexed-entities>\n" +
" <indexed-entity>org.infinispan.query.test.Person</indexed-entity>\n" +
" </indexed-entities>\n" +
" </indexing>\n" +
" </local-cache>\n" +
"</cache-container>"
);
log.tracef("Using test configuration:\n%s", config);
try (InputStream is = new ByteArrayInputStream(config.getBytes())) {
cacheManager = TestCacheManagerFactory.fromStream(is);
}
cache = cacheManager.getCache();
return cacheManager;
}
public void simpleIndexTest() {
cache.put("1", new Person("A Person's Name", "A paragraph containing some text", 75));
Query<Person> cq = TestQueryHelperFactory.createCacheQuery(Person.class, cache, "name", "Name");
assertEquals(1, cq.execute().count().value());
List<Person> l = cq.execute().list();
assertEquals(1, l.size());
Person p = l.get(0);
assertEquals("A Person's Name", p.getName());
assertEquals("A paragraph containing some text", p.getBlurb());
assertEquals(75, p.getAge());
}
public void testPropertiesWhereRead() {
IndexAccessor accessorTest = IndexAccessor.of(cache, Person.class);
IndexManager indexManager = accessorTest.getIndexManager();
assertThat(indexManager).isNotNull();
assertThat(accessorTest.getDirectory()).isInstanceOf(ByteBuffersDirectory.class);
}
}
| 2,690
| 40.4
| 102
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/config/MultipleCachesTest.java
|
package org.infinispan.query.config;
import static org.assertj.core.api.Assertions.assertThat;
import static org.testng.AssertJUnit.assertEquals;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.List;
import org.apache.lucene.store.ByteBuffersDirectory;
import org.infinispan.Cache;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.objectfilter.ParsingException;
import org.infinispan.query.dsl.Query;
import org.infinispan.query.helper.IndexAccessor;
import org.infinispan.query.helper.TestQueryHelperFactory;
import org.infinispan.query.test.Person;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
/**
* @author Sanne Grinovero <sanne@infinispan.org> (C) 2011 Red Hat Inc.
*/
@Test(groups = "unit", testName = "query.config.MultipleCachesTest")
public class MultipleCachesTest extends SingleCacheManagerTest {
@Override
protected EmbeddedCacheManager createCacheManager() throws Exception {
String config = TestingUtil.wrapXMLWithSchema(
"<cache-container default-cache=\"default\">" +
" <local-cache name=\"default\">\n" +
" <indexing enabled=\"false\" />\n" +
" </local-cache>\n" +
" <local-cache name=\"indexingenabled\">\n" +
" <indexing storage=\"local-heap\">\n" +
" <indexed-entities>\n" +
" <indexed-entity>org.infinispan.query.test.Person</indexed-entity>\n" +
" </indexed-entities>\n" +
" </indexing>\n" +
" </local-cache>\n" +
"</cache-container>"
);
log.tracef("Using test configuration:\n%s", config);
InputStream is = new ByteArrayInputStream(config.getBytes());
final EmbeddedCacheManager cm;
try {
cm = TestCacheManagerFactory.fromStream(is);
} finally {
is.close();
}
cache = cm.getCache();
return cm;
}
@Test(expectedExceptions = ParsingException.class)
public void queryNotIndexedCache() {
cacheManager.defineConfiguration("notIndexedA", cacheManager.getDefaultCacheConfiguration());
final Cache<Object, Object> notIndexedCache = cacheManager.getCache("notIndexedA");
notIndexedCache.put("1", new Person("A Person's Name", "A paragraph containing some text", 75));
Query<Person> fullTextQuery = TestQueryHelperFactory.createCacheQuery(Person.class, cache, "name", "Name");
assertEquals(1, fullTextQuery.execute().count().value());
List<Person> l = fullTextQuery.execute().list();
assertEquals(1, l.size());
Person p = l.get(0);
assertEquals("A Person's Name", p.getName());
assertEquals("A paragraph containing some text", p.getBlurb());
assertEquals(75, p.getAge());
}
@Test
public void notIndexedCacheNormalUse() {
cacheManager.defineConfiguration("notIndexedB", cacheManager.getDefaultCacheConfiguration());
final Cache<Object, Object> notIndexedCache = cacheManager.getCache("notIndexedB");
notIndexedCache.put("1", new Person("A Person's Name", "A paragraph containing some text", 75));
assert notIndexedCache.get("1") != null;
}
@Test
public void indexedCache() {
Cache<Object, Object> indexedCache = cacheManager.getCache("indexingenabled");
useQuery(indexedCache);
}
private void useQuery(Cache<Object, Object> indexedCache) {
indexedCache.put("1", new Person("A Person's Name", "A paragraph containing some text", 75));
Query<Person> cq = TestQueryHelperFactory.createCacheQuery(Person.class, indexedCache, "name", "Name");
assertEquals(1, cq.execute().count().value());
List<Person> l = cq.execute().list();
assertEquals(1, l.size());
Person p = l.get(0);
assertEquals("A Person's Name", p.getName());
assertEquals("A paragraph containing some text", p.getBlurb());
assertEquals(75, p.getAge());
IndexAccessor accessorTest = IndexAccessor.of(indexedCache, Person.class);
assertThat(accessorTest.getIndexManager()).isNotNull();
assertThat(accessorTest.getDirectory()).isInstanceOf(ByteBuffersDirectory.class);
}
}
| 4,343
| 41.588235
| 113
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/config/QueryParsingTest.java
|
package org.infinispan.query.config;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
import java.io.IOException;
import java.util.Map;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.cache.IndexStorage;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.configuration.parsing.ParserRegistry;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
@Test(groups = "unit", testName = "query.config.QueryParsingTest")
public class QueryParsingTest extends AbstractInfinispanTest {
public void testConfigurationFileParsing() throws IOException {
ConfigurationBuilderHolder holder = TestCacheManagerFactory.parseFile("configuration-parsing-test.xml", false);
Map<String, ConfigurationBuilder> namedConfigurations = holder.getNamedConfigurationBuilders();
Configuration defaultConfiguration = namedConfigurations.get("default").build();
assertFalse(defaultConfiguration.indexing().enabled());
Configuration simpleCfg = namedConfigurations.get("simple").build();
assertFalse(simpleCfg.indexing().enabled());
Configuration memoryCfg = namedConfigurations.get("memory-searchable").build();
assertTrue(memoryCfg.indexing().enabled());
assertEquals(IndexStorage.LOCAL_HEAP, memoryCfg.indexing().storage());
Configuration diskCfg = namedConfigurations.get("disk-searchable").build();
assertTrue(diskCfg.indexing().enabled());
assertEquals(diskCfg.indexing().storage(), IndexStorage.FILESYSTEM);
assertEquals(diskCfg.indexing().path(), "target/");
Configuration replDefaults = namedConfigurations.get("repl-with-default").build();
assertTrue(replDefaults.indexing().enabled());
}
public void testConfigurationFileParsingWithDefaultEnabled() throws IOException {
ParserRegistry parserRegistry = new ParserRegistry(Thread.currentThread().getContextClassLoader());
ConfigurationBuilderHolder holder = parserRegistry.parseFile("configuration-parsing-test-enbledInDefault.xml");
Map<String, ConfigurationBuilder> namedConfigurations = holder.getNamedConfigurationBuilders();
Configuration defaultConfiguration = namedConfigurations.get("default").build();
assertTrue(defaultConfiguration.indexing().enabled());
assertEquals(IndexStorage.LOCAL_HEAP, defaultConfiguration.indexing().storage());
Configuration nonSearchableCfg = namedConfigurations.get("not-searchable").build();
assertFalse(nonSearchableCfg.indexing().enabled());
Configuration simpleCfg = namedConfigurations.get("simple").build();
assertTrue(simpleCfg.indexing().enabled());
Configuration memoryCfg = namedConfigurations.get("memory-searchable").build();
assertTrue(memoryCfg.indexing().enabled());
assertEquals(memoryCfg.indexing().storage(), IndexStorage.LOCAL_HEAP);
Configuration diskCfg = namedConfigurations.get("disk-searchable").build();
assertTrue(diskCfg.indexing().enabled());
assertEquals(diskCfg.indexing().storage(), IndexStorage.FILESYSTEM);
assertEquals(diskCfg.indexing().path(), "target/");
}
}
| 3,408
| 47.7
| 117
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/config/CacheModeTest.java
|
package org.infinispan.query.config;
import static org.testng.AssertJUnit.assertNotNull;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.CacheContainer;
import org.infinispan.query.backend.QueryInterceptor;
import org.infinispan.query.test.Person;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.TestDataSCI;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "query.config.CacheModeTest")
public class CacheModeTest extends AbstractInfinispanTest {
public void testLocal() {
doTest(CacheMode.LOCAL);
}
public void testReplicated() {
doTest(CacheMode.REPL_SYNC);
}
@Test(expectedExceptions = CacheConfigurationException.class,
expectedExceptionsMessageRegExp = "ISPN(\\d)*: Indexing can not be enabled on caches in Invalidation mode")
public void testInvalidated() {
doTest(CacheMode.INVALIDATION_SYNC);
}
public void testDistributed() {
doTest(CacheMode.DIST_SYNC);
}
private void doTest(CacheMode m) {
CacheContainer cc = null;
try {
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.clustering().cacheMode(m).indexing().enable().addIndexedEntities(Person.class);
cc = TestCacheManagerFactory.createClusteredCacheManager(TestDataSCI.INSTANCE, builder);
QueryInterceptor queryInterceptor =
TestingUtil.findInterceptor(cc.getCache(), QueryInterceptor.class);
assertNotNull("Didn't find a query interceptor in the chain!!", queryInterceptor);
} finally {
TestingUtil.killCacheManagers(cc);
}
}
}
| 1,888
| 35.326923
| 116
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/config/DeclarativeInheritanceConfigTest.java
|
package org.infinispan.query.config;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import java.util.Set;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.query.indexedembedded.Book;
import org.infinispan.query.test.AnotherGrassEater;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
@Test(testName = "query.config.DeclarativeInheritanceConfigTest", groups = "functional")
public class DeclarativeInheritanceConfigTest extends SingleCacheManagerTest {
@Override
protected EmbeddedCacheManager createCacheManager() throws Exception {
return TestCacheManagerFactory.fromXml("configuration-inheritance-parsing-test.xml");
}
public void testIndexedConfigurationInheritance() {
Configuration configuration = cacheManager.getCacheConfiguration("default");
Set<String> indexedEntities = configuration.indexing().indexedEntityTypes();
assertEquals(1, indexedEntities.size());
assertTrue(indexedEntities.contains(Book.class.getName()));
configuration = cacheManager.getCacheConfiguration("extended");
indexedEntities = configuration.indexing().indexedEntityTypes();
assertEquals(1, indexedEntities.size());
assertTrue(indexedEntities.contains(AnotherGrassEater.class.getName()));
}
}
| 1,480
| 40.138889
| 91
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/config/EngineConfigTest.java
|
package org.infinispan.query.config;
import static org.infinispan.query.impl.config.SearchPropertyExtractor.extractProperties;
import static org.testng.AssertJUnit.assertEquals;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Map;
import org.infinispan.commons.util.Util;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.cache.IndexStorage;
import org.infinispan.configuration.cache.IndexingConfiguration;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.query.test.Person;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* @since 12.0
*/
@Test(groups = "unit", testName = "query.config.EngineConfigTest")
public class EngineConfigTest extends AbstractInfinispanTest {
EmbeddedCacheManager cacheManager;
File tempDir;
@BeforeMethod
public void createTempDir() throws IOException {
tempDir = Files.createTempDirectory(EngineConfigTest.class.getName()).toFile();
}
@AfterMethod
public void tearDown() throws Exception {
TestingUtil.killCacheManagers(cacheManager);
Util.recursiveFileRemove(tempDir);
}
@Test
public void testPropertiesGeneration() {
GlobalConfigurationBuilder globalConfigurationBuilder = new GlobalConfigurationBuilder();
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.indexing().enable().addIndexedEntity(Person.class)
.storage(IndexStorage.FILESYSTEM).path(Paths.get(tempDir.getPath(), "baseDir").toString())
.reader().refreshInterval(5000)
.writer().commitInterval(2000)
.ramBufferSize(40)
.queueSize(555).queueCount(8)
.threadPoolSize(11).setLowLevelTrace(true).maxBufferedEntries(50000)
.merge().maxSize(1500).factor(30).calibrateByDeletes(true).minSize(100).maxForcedSize(110).maxEntries(12000);
Map<String, Object> properties = resolveIndexingProperties(globalConfigurationBuilder, builder);
// Storage
assertEquals("local-filesystem", properties.get("hibernate.search.backend.directory.type"));
assertEquals(tempDir.toString() + File.separator + "baseDir", properties.get("hibernate.search.backend.directory.root"));
// reader
assertEquals(5000L, properties.get("hibernate.search.backend.io.refresh_interval"));
// writer
assertEquals(2000, properties.get("hibernate.search.backend.io.commit_interval"));
assertEquals(40, properties.get("hibernate.search.backend.io.writer.ram_buffer_size"));
assertEquals(555, properties.get("hibernate.search.backend.indexing.queue_size"));
assertEquals(8, properties.get("hibernate.search.backend.indexing.queue_count"));
assertEquals(11, properties.get("hibernate.search.backend.thread_pool.size"));
assertEquals(Boolean.TRUE, properties.get("hibernate.search.backend.io.writer.infostream"));
assertEquals(50000, properties.get("hibernate.search.backend.io.writer.max_buffered_docs"));
// merge
assertEquals(1500, properties.get("hibernate.search.backend.io.merge.max_size"));
assertEquals(30, properties.get("hibernate.search.backend.io.merge.factor"));
assertEquals(Boolean.TRUE, properties.get("hibernate.search.backend.io.merge.calibrate_by_deletes"));
assertEquals(100, properties.get("hibernate.search.backend.io.merge.min_size"));
assertEquals(110, properties.get("hibernate.search.backend.io.merge.max_forced_size"));
assertEquals(12000, properties.get("hibernate.search.backend.io.merge.max_docs"));
}
@Test
public void testNoIndexLocationWithGlobalState() {
GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder();
gcb.globalState().enabled(true).persistentLocation(tempDir.getPath());
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.indexing().enable().addIndexedEntity(Person.class).storage(IndexStorage.FILESYSTEM).create();
Map<String, Object> properties = resolveIndexingProperties(gcb, builder);
assertEquals(tempDir.getPath() + "/defaultcache", properties.get("hibernate.search.backend.directory.root"));
}
@Test
public void testNoIndexLocationWithoutGlobalState() {
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.indexing().enable().addIndexedEntity(Person.class).enable();
Map<String, Object> properties = resolveIndexingProperties(new GlobalConfigurationBuilder(), builder);
assertEquals(System.getProperty("user.dir") + "/defaultcache", properties.get("hibernate.search.backend.directory.root"));
}
@Test
public void testRelativeIndexLocation() {
GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder();
gcb.globalState().enabled(true).persistentLocation(tempDir.getPath());
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.indexing().enable().addIndexedEntity(Person.class)
.storage(IndexStorage.FILESYSTEM).path("my-index").create();
Map<String, Object> properties = resolveIndexingProperties(gcb, builder);
assertEquals(tempDir.getPath() + File.separator + "my-index", properties.get("hibernate.search.backend.directory.root"));
}
private Map<String, Object> resolveIndexingProperties(GlobalConfigurationBuilder gcb, ConfigurationBuilder builder) {
cacheManager = TestCacheManagerFactory.createCacheManager(gcb, builder);
GlobalConfiguration globalConfiguration = cacheManager.getCacheManagerConfiguration();
IndexingConfiguration indexingConfiguration = cacheManager.getCache().getCacheConfiguration().indexing();
return extractProperties(globalConfiguration, cacheManager.getCache().getName(), indexingConfiguration,
this.getClass().getClassLoader());
}
}
| 6,235
| 46.242424
| 129
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/config/DefaultCacheInheritancePreventedTest.java
|
package org.infinispan.query.config;
import static org.infinispan.test.TestingUtil.withCacheManager;
import java.io.IOException;
import org.infinispan.Cache;
import org.infinispan.query.backend.QueryInterceptor;
import org.infinispan.query.impl.ComponentRegistryUtils;
import org.infinispan.search.mapper.mapping.SearchMapping;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.CacheManagerCallable;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.Assert;
import org.testng.annotations.Test;
/**
* Similar to QueryParsingTest but that one only looks at the configuration; in this case we check the components are actually
* started as expected (or not at all, if so expected). See also ISPN-2065.
*
* @author Sanne Grinovero
* @since 5.2
*/
@Test(groups = "unit", testName = "query.config.DefaultCacheInheritancePreventedTest")
public class DefaultCacheInheritancePreventedTest extends AbstractInfinispanTest {
@Test
public void verifyIndexDisabledCorrectly() throws IOException {
withCacheManager(new CacheManagerCallable(
TestCacheManagerFactory.fromXml("configuration-parsing-test-enbledInDefault.xml")) {
@Override
public void call() {
assertIndexingEnabled(cm.getCache(), true);
assertIndexingEnabled(cm.getCache("simple"), true);
assertIndexingEnabled(cm.getCache("not-searchable"), false);
assertIndexingEnabled(cm.getCache("memory-searchable"), true);
assertIndexingEnabled(cm.getCache("disk-searchable"), true);
}
});
}
public void verifyIndexEnabledCorrectly() throws IOException {
withCacheManager(new CacheManagerCallable(
TestCacheManagerFactory.fromXml("configuration-parsing-test.xml")) {
@Override
public void call() {
assertIndexingEnabled(cm.getCache(), false);
assertIndexingEnabled(cm.getCache("simple"), false);
assertIndexingEnabled(cm.getCache("memory-searchable"), true);
assertIndexingEnabled(cm.getCache("disk-searchable"), true);
}
});
}
/**
* Verifies that the SearchIntegrator is or is not registered as expected
* @param expected true if you expect indexing to be enabled
* @param cache the cache to extract indexing from
*/
private void assertIndexingEnabled(Cache<Object, Object> cache, boolean expected) {
SearchMapping searchMapping = null;
try {
searchMapping = ComponentRegistryUtils.getSearchMapping(cache);
} catch (IllegalStateException e) {
// ignored here, we deal with it later
}
if (expected && searchMapping == null) {
Assert.fail("SearchIntegrator not found but expected for cache " + cache.getName());
}
if (!expected && searchMapping != null) {
Assert.fail("SearchIntegrator not expected but found for cache " + cache.getName());
}
//verify as well that the indexing interceptor is (not) there:
QueryInterceptor queryInterceptor = null;
try {
queryInterceptor = ComponentRegistryUtils.getQueryInterceptor(cache);
} catch (IllegalStateException e) {
// ignored here, we deal with it later
}
if (expected && queryInterceptor == null) {
Assert.fail("QueryInterceptor not found but expected for cache " + cache.getName());
}
if (!expected && queryInterceptor != null) {
Assert.fail("QueryInterceptor not expected but found for cache " + cache.getName());
}
}
}
| 3,595
| 39.863636
| 126
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/config/IndexingConfigurationIgnoredTest.java
|
package org.infinispan.query.config;
import org.infinispan.Cache;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "query.config.IndexingConfigurationIgnoredTest")
public class IndexingConfigurationIgnoredTest extends AbstractInfinispanTest {
private EmbeddedCacheManager manager;
@Test
public void testIndexingParametersForNamedCache() {
Cache<Object, Object> inMemory = manager.getCache("memory-searchable");
inMemory.start();
}
@BeforeMethod
public void init() throws Exception {
manager = TestCacheManagerFactory.fromXml("configuration-parsing-test.xml");
}
@AfterMethod
public void destroy() throws Exception {
TestingUtil.killCacheManagers(manager);
}
}
| 1,035
| 28.6
| 88
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/api/TestEntity.java
|
package org.infinispan.query.api;
import org.infinispan.api.annotations.indexing.Basic;
import org.infinispan.api.annotations.indexing.Indexed;
import org.infinispan.protostream.annotations.ProtoFactory;
import org.infinispan.protostream.annotations.ProtoField;
@Indexed(index = "indexA")
public class TestEntity {
private String name;
private String surname;
private long id;
private String note;
public TestEntity(TestEntity e) {
this.id = e.getId();
this.name = e.getName();
this.surname = e.getSurname();
this.note = e.getNote();
}
@ProtoFactory
public TestEntity(String name, String surname, long id, String note) {
this.name = name;
this.surname = surname;
this.id = id;
this.note = note;
}
@Basic(projectable = true)
@ProtoField(1)
public String getName() {
return name;
}
@Basic(projectable = true)
@ProtoField(2)
public String getSurname() {
return surname;
}
@ProtoField(number = 3, defaultValue = "0")
public long getId() {
return id;
}
@ProtoField(4)
public String getNote() {
return note;
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
TestEntity that = (TestEntity) o;
if (id != that.id)
return false;
if (name != null ? !name.equals(that.name) : that.name != null)
return false;
if (note != null ? !note.equals(that.note) : that.note != null)
return false;
if (surname != null ? !surname.equals(that.surname)
: that.surname != null)
return false;
return true;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + (surname != null ? surname.hashCode() : 0);
result = 31 * result + (int) (id ^ (id >>> 32));
result = 31 * result + (note != null ? note.hashCode() : 0);
return result;
}
}
| 2,062
| 22.712644
| 73
|
java
|
null |
infinispan-main/query/src/test/java/org/infinispan/query/api/InfinispanDirectoryNonIndexedValuesTest.java
|
package org.infinispan.query.api;
import static org.infinispan.configuration.cache.IndexStorage.LOCAL_HEAP;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.query.test.QueryTestSCI;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
/**
* Testing Non-indexed values on InfinispanDirectory.
*
* @author Anna Manukyan
*/
@Test(groups = "functional", testName = "query.api.InfinispanDirectoryNonIndexedValuesTest")
public class InfinispanDirectoryNonIndexedValuesTest extends NonIndexedValuesTest {
protected EmbeddedCacheManager createCacheManager() throws Exception {
ConfigurationBuilder c = getDefaultStandaloneCacheConfig(isTransactional());
c.indexing()
.enable()
.storage(LOCAL_HEAP)
.addIndexedEntity(TestEntity.class)
.addIndexedEntity(AnotherTestEntity.class);
return TestCacheManagerFactory.createCacheManager(QueryTestSCI.INSTANCE, c);
}
protected boolean isTransactional() {
return false;
}
}
| 1,126
| 33.151515
| 92
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.