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/memcached/src/main/java/org/infinispan/server/memcached/text/TextOpDecoder.java
|
package org.infinispan.server.memcached.text;
import static java.util.concurrent.CompletableFuture.completedFuture;
import static java.util.concurrent.CompletableFuture.failedFuture;
import static org.infinispan.commons.util.concurrent.CompletableFutures.asCompletionException;
import static org.infinispan.server.core.transport.ExtendedByteBuf.buffer;
import static org.infinispan.server.core.transport.ExtendedByteBuf.wrappedBuffer;
import static org.infinispan.server.memcached.MemcachedStats.CAS_BADVAL;
import static org.infinispan.server.memcached.MemcachedStats.CAS_HITS;
import static org.infinispan.server.memcached.MemcachedStats.CAS_MISSES;
import static org.infinispan.server.memcached.MemcachedStats.DECR_HITS;
import static org.infinispan.server.memcached.MemcachedStats.DECR_MISSES;
import static org.infinispan.server.memcached.MemcachedStats.INCR_HITS;
import static org.infinispan.server.memcached.MemcachedStats.INCR_MISSES;
import static org.infinispan.server.memcached.text.TextConstants.CRLF;
import static org.infinispan.server.memcached.text.TextConstants.CRLFBytes;
import static org.infinispan.server.memcached.text.TextConstants.DELETED;
import static org.infinispan.server.memcached.text.TextConstants.END;
import static org.infinispan.server.memcached.text.TextConstants.END_SIZE;
import static org.infinispan.server.memcached.text.TextConstants.EXISTS;
import static org.infinispan.server.memcached.text.TextConstants.MAX_UNSIGNED_LONG;
import static org.infinispan.server.memcached.text.TextConstants.MIN_UNSIGNED;
import static org.infinispan.server.memcached.text.TextConstants.MN;
import static org.infinispan.server.memcached.text.TextConstants.NOT_FOUND;
import static org.infinispan.server.memcached.text.TextConstants.NOT_STORED;
import static org.infinispan.server.memcached.text.TextConstants.OK;
import static org.infinispan.server.memcached.text.TextConstants.SPACE;
import static org.infinispan.server.memcached.text.TextConstants.STORED;
import static org.infinispan.server.memcached.text.TextConstants.TOUCHED;
import static org.infinispan.server.memcached.text.TextConstants.VALUE;
import static org.infinispan.server.memcached.text.TextConstants.VALUE_SIZE;
import static org.infinispan.server.memcached.text.TextConstants.ZERO;
import java.io.StreamCorruptedException;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.TimeUnit;
import javax.security.auth.Subject;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.util.Version;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.container.versioning.NumericVersion;
import org.infinispan.context.Flag;
import org.infinispan.metadata.Metadata;
import org.infinispan.server.memcached.MemcachedMetadata;
import org.infinispan.server.memcached.MemcachedServer;
import org.infinispan.server.memcached.ParseUtil;
import io.netty.buffer.ByteBuf;
/**
* @since 15.0
**/
public abstract class TextOpDecoder extends TextDecoder {
protected TextOpDecoder(MemcachedServer server, Subject subject) {
super(server, subject);
}
protected void get(TextHeader header, List<byte[]> keys, boolean withVersions) {
int numberOfKeys = keys.size();
if (numberOfKeys > 1) {
CacheEntry<byte[], byte[]>[] entries = new CacheEntry[numberOfKeys];
CompletionStage<Void> lastStage = doGetMultipleKeys(keys, entries, 0);
for (int i = 1; i < numberOfKeys; ++i) {
final int idx = i;
lastStage = lastStage.thenCompose(unused -> doGetMultipleKeys(keys, entries, idx));
}
send(header, lastStage.thenApply(unused -> createMultiGetResponse(entries)));
} else {
byte[] key = keys.get(0);
send(header, cache.getCacheEntryAsync(key).thenApply(entry -> createGetResponse(key, entry, withVersions)));
}
}
protected void set(TextHeader header, byte[] key, byte[] value, int flags, int expiration, boolean quiet) {
send(header, cache.withFlags(Flag.IGNORE_RETURN_VALUES)
.putAsync(key, value, metadata(flags, expiration))
.thenApply(unused -> createSuccessResponse(TextCommand.set, quiet)));
}
protected void delete(TextHeader header, byte[] key, boolean quiet) {
send(header, cache.removeAsync(key)
.thenApply(prev -> prev == null ? createNotExistResponse(TextCommand.delete, quiet) : createSuccessResponse(TextCommand.delete, quiet)));
}
protected void concat(TextHeader header, byte[] key, byte[] value, int flags, int expiration, boolean quiet, boolean append) {
send(header, cache.getAsync(key)
.thenCompose(prev -> {
if (prev == null) {
return completedFuture(quiet ? null : NOT_STORED);
}
byte[] concatenated = append ? concat(prev, value) : concat(value, prev);
return cache.replaceAsync(key, prev, concatenated, metadata(flags, expiration))
.thenApply(replaced ->
replaced ?
(quiet ? null : STORED) :
(quiet ? null : NOT_STORED));
}));
}
protected void replace(TextHeader header, byte[] key, byte[] value, int flags, int expiration, boolean quiet) {
send(header, cache.withFlags(Flag.SKIP_LISTENER_NOTIFICATION)
.getAsync(key)
.thenCompose(prev -> prev == null ?
CompletableFutures.completedNull() :
cache.replaceAsync(key, value, metadata(flags, expiration)))
.thenApply(prev -> prev == null ? createNotExecutedResponse(TextCommand.replace, quiet) : createSuccessResponse(TextCommand.replace, quiet)));
}
protected void add(TextHeader header, byte[] key, byte[] value, int flags, int expiration, boolean quiet) {
send(header, cache.getAsync(key)
.thenCompose(prev -> prev == null ?
cache.putIfAbsentAsync(key, value, metadata(flags, expiration)) :
completedFuture(prev))
.thenApply(prev -> prev == null ? createSuccessResponse(TextCommand.add, quiet) : createNotExecutedResponse(TextCommand.add, quiet)));
}
protected void cas(TextHeader header, byte[] key, byte[] value, int flags, int expiration, long cas, boolean quiet) {
send(header, cache.withFlags(Flag.SKIP_LISTENER_NOTIFICATION)
.getCacheEntryAsync(key)
.thenCompose(entry -> {
if (entry == null) {
return completedFuture(createNotExistResponse(TextCommand.cas, quiet));
}
NumericVersion streamVersion = new NumericVersion(cas);
if (!entry.getMetadata().version().equals(streamVersion)) {
return completedFuture(createNotExecutedResponse(TextCommand.cas, quiet));
}
byte[] prev = entry.getValue();
return cache.replaceAsync(key, prev, value, metadata(flags, expiration))
.thenApply(replaced -> replaced ? createSuccessResponse(TextCommand.cas, quiet) : createNotExecutedResponse(TextCommand.cas, quiet));
}));
}
protected void touch(TextHeader header, byte[] key, int expiration, boolean quiet) {
send(header, cache.getCacheEntryAsync(key)
.thenCompose(entry -> {
if (entry == null) {
return completedFuture(createNotExistResponse(TextCommand.touch, quiet));
}
return cache.replaceAsync(entry.getKey(), entry.getValue(), touchMetadata(entry, expiration))
.thenApply(unused -> createTouchedResponse(quiet));
}));
}
protected void gat(TextHeader header, int expiration, List<byte[]> keys, boolean withVersions) {
int numberOfKeys = keys.size();
if (numberOfKeys > 1) {
CacheEntry<byte[], byte[]>[] entries = new CacheEntry[numberOfKeys];
CompletionStage<Void> lastStage = doGatMultipleKeys(keys, entries, expiration, 0);
for (int i = 1; i < numberOfKeys; ++i) {
final int idx = i;
lastStage = lastStage.thenCompose(unused -> doGatMultipleKeys(keys, entries, expiration, idx));
}
send(header, lastStage.thenApply(unused -> createMultiGetResponse(entries)));
} else {
byte[] key = keys.get(0);
send(header, cache.getCacheEntryAsync(key).thenCompose(entry -> {
if (entry == null) {
return completedFuture(END);
} else {
return cache.replaceAsync(entry.getKey(), entry.getValue(), touchMetadata(entry, expiration))
.thenApply(unused -> createGetResponse(key, entry, withVersions));
}
}));
}
}
protected void md(TextHeader header, byte[] key, List<byte[]> args) {
throw new UnsupportedOperationException();
}
protected void ma(TextHeader header, byte[] key, List<byte[]> args) {
throw new UnsupportedOperationException();
}
protected void me(TextHeader header, byte[] key, List<byte[]> args) {
throw new UnsupportedOperationException();
}
protected void mn(TextHeader header) {
send(header, CompletableFuture.completedFuture(MN));
}
protected void ms(TextHeader header, byte[] key, byte[] value, List<byte[]> args) {
throw new UnsupportedOperationException();
}
protected void mg(TextHeader header, byte[] key, List<byte[]> args) {
throw new UnsupportedOperationException();
}
private Object createMultiGetResponse(CacheEntry<byte[], byte[]>[] entries) {
ByteBuf[] elements = new ByteBuf[entries.length + 1];
for (int i = 0; i < entries.length; i++) {
elements[i] = buildGetResponse(entries[i]);
}
elements[entries.length] = wrappedBuffer(END);
return elements;
}
private CompletionStage<Void> doGetMultipleKeys(List<byte[]> keys, CacheEntry<byte[], byte[]>[] entries, int i) {
try {
return cache.getCacheEntryAsync(keys.get(i)).thenAccept(entry -> entries[i] = entry);
} catch (Throwable t) {
return failedFuture(t);
}
}
private CompletionStage<Void> doGatMultipleKeys(List<byte[]> keys, CacheEntry<byte[], byte[]>[] entries, int expiration, int idx) {
return cache.getCacheEntryAsync(keys.get(idx))
.thenCompose(entry -> {
if (entry == null) {
return CompletableFutures.completedNull();
} else {
return cache.replaceAsync(entry.getKey(), entry.getValue(), touchMetadata(entry, expiration)).thenApply(unused -> {
entries[idx] = entry;
return null;
});
}
});
}
protected void flush_all(TextHeader header, List<byte[]> varargs) {
boolean noreply = false;
int delay = 0;
for (byte[] arg : varargs) {
String s = new String(arg, StandardCharsets.US_ASCII);
if ("noreply".equals(s)) {
noreply = true;
} else {
delay = ParseUtil.readInt(arg);
}
}
boolean quiet = noreply;
if (delay == 0) {
send(header, cache.clearAsync().thenApply(unused -> quiet ? null : OK));
return;
}
server.getScheduler().schedule(cache::clear, toMillis(delay), TimeUnit.MILLISECONDS);
send(header, CompletableFuture.completedFuture(quiet ? null : OK));
}
protected void version(TextHeader header) {
send(header, CompletableFuture.completedFuture("VERSION " + Version.getVersion() + CRLF));
}
protected void quit(TextHeader header) {
channel.close();
}
protected void incr(TextHeader header, byte[] key, byte[] delta, boolean quiet, boolean isIncrement) {
send(header, cache.getAsync(key)
.thenCompose(prev -> {
if (prev == null) {
if (statsEnabled) {
if (isIncrement) {
INCR_MISSES.incrementAndGet(statistics);
} else {
DECR_MISSES.incrementAndGet(statistics);
}
}
return completedFuture(quiet ? null : NOT_FOUND);
}
BigInteger prevCounter = new BigInteger(new String(prev));
BigInteger d = validateDelta(new String(delta, StandardCharsets.US_ASCII));
BigInteger candidateCounter;
if (isIncrement) {
candidateCounter = prevCounter.add(d);
candidateCounter = candidateCounter.compareTo(MAX_UNSIGNED_LONG) > 0 ? MIN_UNSIGNED : candidateCounter;
} else {
candidateCounter = prevCounter.subtract(d);
candidateCounter = candidateCounter.compareTo(MIN_UNSIGNED) < 0 ? MIN_UNSIGNED : candidateCounter;
}
String counterString = candidateCounter.toString();
return cache.replaceAsync(key, prev, counterString.getBytes(), metadata(0, 0))
.thenApply(replaced -> {
if (!replaced) {
// If there's a concurrent modification on this key, the spec does not say what to do, so treat it as exceptional
throw asCompletionException(new CacheException("Value modified since we retrieved from the cache, old value was " + prevCounter));
}
if (statsEnabled) {
if (isIncrement) {
INCR_HITS.incrementAndGet(statistics);
} else {
DECR_HITS.incrementAndGet(statistics);
}
}
return quiet ? null : counterString + CRLF;
});
}));
}
protected void stats(TextHeader header, List<byte[]> names) {
send(header, server.getBlockingManager().supplyBlocking(() -> {
Map<byte[], byte[]> stats = statsMap();
ByteBuf buf = channel.alloc().buffer();
if (names.isEmpty()) {
for (Map.Entry<byte[], byte[]> stat : stats.entrySet()) {
stat(buf, stat.getKey(), stat.getValue());
}
} else {
for (byte[] name : names) {
byte[] value = stats.get(name);
if (value == null) {
buf.clear();
buf.writeCharSequence("CLIENT_ERROR\r\n", StandardCharsets.US_ASCII);
return buf;
} else {
stat(buf, name, value);
}
}
}
buf.writeBytes(END);
return buf;
}, "memcached-stats"));
}
private static void stat(ByteBuf buf, byte[] name, byte[] value) {
if (value != null) {
buf.writeCharSequence("STAT ", StandardCharsets.US_ASCII);
buf.writeBytes(name);
buf.writeByte(' ');
buf.writeBytes(value);
buf.writeBytes(CRLFBytes);
}
}
private CompletionStage<Void> doGetMultipleKeys(byte[] key, Map<byte[], CacheEntry<byte[], byte[]>> responses) {
try {
return cache.getCacheEntryAsync(key)
.thenAccept(entry -> {
if (entry != null) {
responses.put(key, entry);
}
});
} catch (Throwable t) {
return failedFuture(t);
}
}
private Object createSuccessResponse(TextCommand cmd, boolean quiet) {
if (statsEnabled && cmd == TextCommand.cas) {
CAS_HITS.incrementAndGet(statistics);
}
if (quiet) {
return null;
}
return cmd == TextCommand.delete ? DELETED : STORED;
}
Object createNotExecutedResponse(TextCommand cmd, boolean quiet) {
if (statsEnabled && cmd == TextCommand.cas) {
CAS_BADVAL.incrementAndGet(statistics);
}
if (quiet) {
return null;
}
return cmd == TextCommand.cas ? EXISTS : NOT_STORED;
}
Object createNotExistResponse(TextCommand cmd, boolean quiet) {
if (statsEnabled && cmd == TextCommand.cas) {
CAS_MISSES.incrementAndGet(statistics);
}
return quiet ? null : NOT_FOUND;
}
private static Object createGetResponse(byte[] k, CacheEntry<byte[], byte[]> entry, boolean requiresVersions) {
if (entry == null) {
return END;
}
return requiresVersions ? buildSingleGetWithVersionResponse(entry) : buildSingleGetResponse(entry);
}
private static Object createTouchedResponse(boolean quiet) {
return quiet ? null : TOUCHED;
}
private static ByteBuf buildSingleGetResponse(CacheEntry<byte[], byte[]> entry) {
ByteBuf buf = buildGetHeaderBegin(entry, END_SIZE);
writeGetHeaderData(entry.getValue(), buf);
return writeGetHeaderEnd(buf);
}
private static ByteBuf buildGetResponse(CacheEntry<byte[], byte[]> entry) {
if (entry == null) {
return null;
} else {
ByteBuf buf = buildGetHeaderBegin(entry, 0);
return writeGetHeaderData(entry.getValue(), buf);
}
}
private static ByteBuf buildGetHeaderBegin(CacheEntry<byte[], byte[]> entry,
int extraSpace) {
byte[] key = entry.getKey();
byte[] data = entry.getValue();
byte[] dataSize = String.valueOf(data.length).getBytes();
byte[] flags;
Metadata metadata = entry.getMetadata();
if (metadata instanceof MemcachedMetadata) {
long metaFlags = ((MemcachedMetadata) metadata).flags;
flags = String.valueOf(metaFlags).getBytes();
} else {
flags = ZERO;
}
int flagsSize = flags.length;
ByteBuf buf = buffer(VALUE_SIZE + key.length + data.length + flagsSize + dataSize.length + 6 + extraSpace);
buf.writeBytes(VALUE);
buf.writeBytes(key);
buf.writeByte(SPACE);
buf.writeBytes(flags);
buf.writeByte(SPACE);
buf.writeBytes(dataSize);
return buf;
}
private static ByteBuf buildSingleGetWithVersionResponse(CacheEntry<byte[], byte[]> entry) {
byte[] v = entry.getValue();
// TODO: Would be nice for EntryVersion to allow retrieving the version itself...
byte[] version = String.valueOf(((NumericVersion) entry.getMetadata().version()).getVersion()).getBytes();
ByteBuf buf = buildGetHeaderBegin(entry, version.length + 1 + END_SIZE);
buf.writeByte(SPACE); // 1
buf.writeBytes(version); // version.length
writeGetHeaderData(v, buf);
return writeGetHeaderEnd(buf);
}
private static ByteBuf writeGetHeaderData(byte[] data, ByteBuf buf) {
buf.writeBytes(CRLFBytes);
buf.writeBytes(data);
buf.writeBytes(CRLFBytes);
return buf;
}
private static ByteBuf writeGetHeaderEnd(ByteBuf buf) {
buf.writeBytes(END);
return buf;
}
static byte[] concat(byte[] a, byte[] b) {
byte[] data = new byte[a.length + b.length];
System.arraycopy(a, 0, data, 0, a.length);
System.arraycopy(b, 0, data, a.length, b.length);
return data;
}
private BigInteger validateDelta(String delta) {
BigInteger bigIntDelta = new BigInteger(delta);
if (bigIntDelta.compareTo(MAX_UNSIGNED_LONG) > 0)
throw asCompletionException(new StreamCorruptedException("Increment or decrement delta sent (" + delta + ") exceeds unsigned limit ("
+ MAX_UNSIGNED_LONG + ")"));
else if (bigIntDelta.compareTo(MIN_UNSIGNED) < 0)
throw asCompletionException(new StreamCorruptedException("Increment or decrement delta cannot be negative: " + delta));
return bigIntDelta;
}
}
| 20,109
| 41.787234
| 157
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/text/TextAuthDecoder.java
|
package org.infinispan.server.memcached.text;
import static org.infinispan.server.memcached.text.TextConstants.CLIENT_ERROR_AUTH;
import static org.infinispan.server.memcached.text.TextConstants.STORED;
import java.nio.charset.StandardCharsets;
import org.infinispan.server.core.security.UsernamePasswordAuthenticator;
import org.infinispan.server.memcached.MemcachedServer;
import io.netty.buffer.ByteBuf;
/**
* @since 15.0
**/
public abstract class TextAuthDecoder extends TextDecoder {
private final UsernamePasswordAuthenticator authenticator;
protected TextAuthDecoder(MemcachedServer server) {
super(server, ANONYMOUS);
authenticator = server.getConfiguration().authentication().text().authenticator();
}
protected void auth(byte[] token) {
String s = new String(token, StandardCharsets.US_ASCII);
String[] parts = s.split(" ");
if (parts.length != 2) {
authFailure("Wrong credentials");
} else {
authenticator.authenticate(parts[0], parts[1].toCharArray()).handle((subject, t) -> {
if (t != null) {
authFailure(t.getMessage());
} else {
channel.eventLoop().submit(() -> {
ByteBuf buf = channel.alloc().ioBuffer();
buf.writeBytes(STORED);
channel.writeAndFlush(buf);
channel.pipeline().replace("decoder", "decoder", new TextOpDecoderImpl(server, subject));
});
}
return null;
});
}
}
private void authFailure(String message) {
channel.eventLoop().submit(() -> {
ByteBuf buf = channel.alloc().ioBuffer();
buf.writeCharSequence(CLIENT_ERROR_AUTH + message, StandardCharsets.US_ASCII);
channel.writeAndFlush(buf);
});
}
}
| 1,830
| 32.290909
| 107
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/text/TextHeader.java
|
package org.infinispan.server.memcached.text;
import java.nio.charset.StandardCharsets;
import java.time.temporal.Temporal;
import org.infinispan.server.memcached.logging.Header;
/**
* @since 15.0
**/
public class TextHeader extends Header {
private final TextCommand op;
private final byte[] key;
public TextHeader(int requestBytes, Temporal requestStart, String principalName, byte[] key, TextCommand op) {
super(requestStart, requestBytes, principalName);
this.key = key;
this.op = op;
}
@Override
public Object getKey() {
return new String(key, StandardCharsets.US_ASCII);
}
@Override
public String getOp() {
return op.name();
}
@Override
public String getProtocol() {
return "MCTXT"; // Memcached Text Protocol
}
}
| 805
| 20.783784
| 113
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/text/TextCommand.java
|
package org.infinispan.server.memcached.text;
/**
* @since 15.0
**/
public enum TextCommand {
// Text commands
set,
get,
gets,
add,
replace,
append,
prepend,
incr,
decr,
delete,
gat,
gats,
touch,
flush_all,
cas,
stats,
verbosity,
version,
quit,
// Meta commands
mg,
ms,
md,
ma,
mn,
me
}
| 371
| 9.628571
| 45
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/text/TextConstants.java
|
package org.infinispan.server.memcached.text;
import java.math.BigInteger;
/**
* Memcached text protocol utilities.
*
* @author Galder Zamarreño
* @since 4.1
*/
public class TextConstants {
private TextConstants() {
}
public static final String CRLF = "\r\n";
public static final byte[] CRLFBytes = CRLF.getBytes();
public static final byte[] END = "END\r\n".getBytes();
public static final int END_SIZE = END.length;
public static final byte[] DELETED = "DELETED\r\n".getBytes();
public static final byte[] NOT_FOUND = "NOT_FOUND\r\n".getBytes();
public static final byte[] EXISTS = "EXISTS\r\n".getBytes();
public static final byte[] STORED = "STORED\r\n".getBytes();
public static final byte[] NOT_STORED = "NOT_STORED\r\n".getBytes();
public static final byte[] OK = "OK\r\n".getBytes();
public static final byte[] TOUCHED = "TOUCHED\r\n".getBytes();
public static final byte[] ERROR = "ERROR\r\n".getBytes();
public static final String CLIENT_ERROR_BAD_FORMAT = "CLIENT_ERROR bad command line format: ";
public static final String CLIENT_ERROR_AUTH = "CLIENT_ERROR authentication failed: ";
public static final String SERVER_ERROR = "SERVER_ERROR ";
public static final byte[] VALUE = "VALUE ".getBytes();
public static final int VALUE_SIZE = VALUE.length;
public static final byte[] ZERO = "0".getBytes();
public static final byte[] NOREPLY = "noreply\r\n".getBytes();
public static final byte[] MN = "MN\r\n".getBytes();
public static final int SPACE = 32;
public static final BigInteger MAX_UNSIGNED_LONG = new BigInteger("18446744073709551615");
public static final BigInteger MIN_UNSIGNED = BigInteger.ZERO;
public static final int MAX_EXPIRATION = 60 * 60 * 24 * 30;
}
| 1,769
| 40.162791
| 97
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/text/TextDecoder.java
|
package org.infinispan.server.memcached.text;
import java.util.concurrent.CompletionStage;
import javax.security.auth.Subject;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.server.core.transport.ConnectionMetadata;
import org.infinispan.server.memcached.MemcachedBaseDecoder;
import org.infinispan.server.memcached.MemcachedServer;
import org.infinispan.server.memcached.logging.Header;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;
/**
* @since 15.0
**/
abstract class TextDecoder extends MemcachedBaseDecoder {
protected TextDecoder(MemcachedServer server, Subject subject) {
super(server, subject, server.getCache().getAdvancedCache().withMediaType(MediaType.TEXT_PLAIN, server.getConfiguration().clientEncoding()));
}
@Override
public void handlerAdded(ChannelHandlerContext ctx) {
super.handlerAdded(ctx);
ConnectionMetadata metadata = ConnectionMetadata.getInstance(channel);
metadata.subject(subject);
metadata.protocolVersion("MCTXT");
}
@Override
public void send(Header header, CompletionStage<?> response) {
new TextResponse(current, channel).queueResponse(accessLogging ? header : null, response);
}
@Override
public void send(Header header, CompletionStage<?> response, GenericFutureListener<? extends Future<? super Void>> listener) {
new TextResponse(current, channel).queueResponse(accessLogging ? header : null, response, listener);
}
}
| 1,567
| 35.465116
| 147
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/text/TextIntrinsics.java
|
package org.infinispan.server.memcached.text;
import static java.nio.charset.StandardCharsets.US_ASCII;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.List;
import org.infinispan.server.core.transport.ExtendedByteBufJava;
import io.netty.buffer.ByteBuf;
public class TextIntrinsics {
// [0-9]
private static final BitSet NUMBERS = BitSet.valueOf(new long[]{287948901175001088L});
// [A-Za-z_]
private static final BitSet LETTERS = BitSet.valueOf(new long[]{0, 576460745995190270L});
// [^\n\r ]
private static final BitSet TEXT = BitSet.valueOf(new long[]{-4294976513L, -1, -1, -1});
public static short short_(ByteBuf b) {
if (b.readableBytes() >= 2) {
return b.readShort();
} else return 0;
}
public static byte[] fixedArray(ByteBuf b, int length) {
b.markReaderIndex();
return ExtendedByteBufJava.readMaybeRangedBytes(b, length);
}
private static Void consumeLine(ByteBuf buf) {
buf.markReaderIndex();
while (buf.isReadable()) {
byte b = buf.readByte();
if (b == 10) {
return null;
}
}
buf.resetReaderIndex();
return null;
}
/**
* Reads the next token from the buffer, accepting only valid characters. If a non-valid character is found, the
* buffer is consumed to the end of the line and an {@link IllegalArgumentException} is thrown.
*
* @param buf the buffer
* @param valid the valid characters
* @return the token as a {@link ByteBuf}
*/
private static ByteBuf token(ByteBuf buf, BitSet valid) {
buf.markReaderIndex();
int startIndex = buf.readerIndex();
while (buf.readableBytes() > 0) {
short b = buf.readUnsignedByte();
// Found a space, return the current slice
if (b == 32) {
return buf.slice(startIndex, buf.readerIndex() - startIndex - 1);
} else if (b == 13) {
// Found CR
if ((buf.readerIndex() - startIndex) == 1) {
if (!buf.isReadable())
break;
// If it's the first byte, chomp the LF and return null
buf.readByte();
return null;
} else {
// We leave the CR alone, backtracking the reader index
return buf.readerIndex(buf.readerIndex() - 1).slice(startIndex, buf.readerIndex() - startIndex);
}
} else if (!valid.get(b)) {
consumeLine(buf);
throw new IllegalArgumentException("Invalid byte " + b);
}
}
buf.resetReaderIndex();
return null;
}
public static long long_number(ByteBuf buf) {
ByteBuf s = token(buf, NUMBERS);
if (s == null) {
return 0;
} else if (s.isReadable()) {
return Long.parseUnsignedLong(s.toString(US_ASCII));
} else {
consumeLine(buf);
throw new IllegalArgumentException("Expected number");
}
}
public static int int_number(ByteBuf buf) {
ByteBuf s = token(buf, NUMBERS);
if (s == null) {
return 0;
} else if (s.isReadable()) {
return parseUnsignedInt(s);
} else {
consumeLine(buf);
throw new IllegalArgumentException("Expected number");
}
}
public static String id(ByteBuf buf) {
ByteBuf s = token(buf, LETTERS);
if (s == null) {
return null;
} else if (s.isReadable()) {
return s.toString(US_ASCII);
} else {
consumeLine(buf);
throw new IllegalArgumentException("Expected identifier, got empty string");
}
}
public static TextCommand command(ByteBuf buf) {
String id = id(buf);
try {
return id == null ? null : TextCommand.valueOf(id);
} catch (IllegalArgumentException e) {
consumeLine(buf);
throw new UnsupportedOperationException(id);
}
}
public static byte[] text(ByteBuf buf) {
ByteBuf s = token(buf, TEXT);
if (s == null || !s.isReadable()) {
return null;
} else {
byte[] b = new byte[s.capacity()];
s.readBytes(b);
return b;
}
}
public static byte[] text_key(ByteBuf buf) {
ByteBuf s = token(buf, TEXT);
if (s == null || !s.isReadable()) {
return null;
} else if (s.capacity() > 250) {
consumeLine(buf);
throw new IllegalArgumentException("Key length over the 250 character limit");
} else {
byte[] b = new byte[s.capacity()];
s.readBytes(b);
return b;
}
}
public static List<byte[]> text_list(ByteBuf buf) {
List<byte[]> list = new ArrayList<>();
for (byte[] b = text(buf); b != null; b = text(buf)) {
list.add(b);
}
return list;
}
public static List<byte[]> text_key_list(ByteBuf buf) {
List<byte[]> list = new ArrayList<>();
for (byte[] b = text_key(buf); b != null; b = text_key(buf)) {
list.add(b);
}
return list;
}
public static boolean eowc(ByteBuf buf) {
buf.markReaderIndex();
if (buf.readableBytes() > 1) {
short b = buf.readUnsignedByte();
if (b == 13) {
buf.readByte(); // eat the LF
return false;
} else if (b == TextConstants.NOREPLY[0]) {
int pos = 1;
while (buf.readableBytes() > 0) {
b = buf.readUnsignedByte();
if (b != TextConstants.NOREPLY[pos]) {
consumeLine(buf);
throw new IllegalArgumentException();
}
if (++pos == TextConstants.NOREPLY.length) {
return true;
}
}
} else {
consumeLine(buf);
throw new IllegalArgumentException();
}
}
buf.resetReaderIndex();
return false;
}
public static long parseLong(ByteBuf s) {
byte first = s.readByte();
long result = first == '+' ? 0 : first - 48;
while (s.isReadable()) {
byte b = s.readByte();
if (b < '0' || b > '9')
throw new NumberFormatException("Invalid character: " + b);
result = (result << 3) + (result << 1) + (b - 48);
}
return result;
}
public static int parseUnsignedInt(ByteBuf s) {
long v = parseLong(s);
// From Integer.parseUnsignedInt.
if ((v & 0xffff_ffff_0000_0000L) != 0L) {
throw new NumberFormatException("Value exceeds range of unsigned int: " + v);
}
return (int)v;
}
}
| 6,629
| 29.412844
| 115
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/RespSingleNodeTest.java
|
package org.infinispan.server.resp;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.fail;
import static org.infinispan.server.resp.test.RespTestingUtil.OK;
import static org.infinispan.server.resp.test.RespTestingUtil.PONG;
import static org.infinispan.test.TestingUtil.k;
import static org.infinispan.test.TestingUtil.v;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.server.resp.commands.Commands;
import org.infinispan.server.resp.test.CommonRespTests;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import io.lettuce.core.ExpireArgs;
import io.lettuce.core.FlushMode;
import io.lettuce.core.KeyScanCursor;
import io.lettuce.core.KeyValue;
import io.lettuce.core.RedisCommandExecutionException;
import io.lettuce.core.ScanArgs;
import io.lettuce.core.SetArgs;
import io.lettuce.core.StrAlgoArgs;
import io.lettuce.core.StringMatchResult;
import io.lettuce.core.api.sync.RedisCommands;
import io.lettuce.core.codec.StringCodec;
import io.lettuce.core.output.ArrayOutput;
import io.lettuce.core.output.StatusOutput;
import io.lettuce.core.protocol.CommandArgs;
import io.lettuce.core.protocol.ProtocolKeyword;
import io.lettuce.core.pubsub.RedisPubSubAdapter;
import io.lettuce.core.pubsub.api.sync.RedisPubSubCommands;
/**
* Base class for single node tests.
*
* @author William Burns
* @since 14.0
*/
@Test(groups = "functional", testName = "server.resp.RespSingleNodeTest")
public class RespSingleNodeTest extends SingleNodeRespBaseTest {
@Test
public void testSetMultipleOptions() {
RedisCommands<String, String> redis = redisConnection.sync();
// Should return (nil), failed since value does not exist
SetArgs args = SetArgs.Builder.xx();
assertThat(redis.set("key", "value", args)).isNull();
// Should return OK, because value does not exist.
args = SetArgs.Builder.nx();
assertThat(redis.set("key", "value", args)).isEqualTo(OK);
assertThat(redis.get("key")).isEqualTo("value");
// Should return (nil), because value exists.
assertThat(redis.set("key", "value3", args)).isNull();
assertThat(redis.get("key")).isEqualTo("value");
// Should return OK, value exists
args = SetArgs.Builder.xx();
assertThat(redis.set("key", "value2", args)).isEqualTo(OK);
assertThat(redis.get("key")).isEqualTo("value2");
// Should insert with TTL. This one returns the value.
args = SetArgs.Builder.ex(60);
assertThat(redis.setGet("key", "value3", args)).isEqualTo("value2");
CacheEntry<Object, Object> entry = cache.getAdvancedCache()
.withMediaType(MediaType.APPLICATION_OCTET_STREAM, MediaType.APPLICATION_OCTET_STREAM)
.getCacheEntry("key".getBytes(StandardCharsets.UTF_8));
assertThat(new String((byte[]) entry.getValue())).isEqualTo("value3");
assertThat(entry.getLifespan()).isEqualTo(60_000);
// We insert while keeping the TTL.
args = SetArgs.Builder.keepttl();
assertThat(redis.set("key", "value4", args)).isEqualTo(OK);
entry = cache.getAdvancedCache()
.withMediaType(MediaType.APPLICATION_OCTET_STREAM, MediaType.APPLICATION_OCTET_STREAM)
.getCacheEntry("key".getBytes(StandardCharsets.UTF_8));
assertThat(new String((byte[]) entry.getValue())).isEqualTo("value4");
assertThat(entry.getLifespan()).isEqualTo(60_000);
// Conditional operation keeping TTL.
args = SetArgs.Builder.keepttl().xx();
assertThat(redis.set("key", "value5", args)).isEqualTo(OK);
entry = cache.getAdvancedCache()
.withMediaType(MediaType.APPLICATION_OCTET_STREAM, MediaType.APPLICATION_OCTET_STREAM)
.getCacheEntry("key".getBytes(StandardCharsets.UTF_8));
assertThat(new String((byte[]) entry.getValue())).isEqualTo("value5");
assertThat(entry.getLifespan()).isEqualTo(60_000);
// Key exist and keeping TTL, but conditional failing. Should return nil.
args = SetArgs.Builder.keepttl().nx();
String res = redis.set("key", "value5", args);
assertThat(res).isNull();
// No NPE when keeping TTL, key not exists, and conditional succeed.
args = SetArgs.Builder.keepttl().nx();
assertThat(redis.set("randomKey", "value", args)).isEqualTo(OK);
// No NPE when keeping TTL and key doesn't exist.
args = SetArgs.Builder.keepttl();
assertThat(redis.set("otherKey", "value", args)).isEqualTo(OK);
redis.del("key", "randomKey", "otherKey");
}
public void testConditionalSetOperationWithReturn() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = UUID.randomUUID().toString();
// Should return (nil), failed since value does not exist.
SetArgs args = SetArgs.Builder.xx();
assertThat(redis.setGet(key, "something", args)).isNull();
assertThat(redis.get(key)).isNull();
// Should return (nil), because value does not exist, but operation succeeded.
args = SetArgs.Builder.nx();
String res = redis.setGet(key, "value", args);
assertThat(res).isNull();
assertThat(redis.get(key)).isEqualTo("value");
// Should return the previous because value exists but operation failed.
assertThat(redis.setGet(key, "value2", args)).isEqualTo("value");
assertThat(redis.get(key)).isEqualTo("value");
// Should return previous value but succeeded.
args = SetArgs.Builder.xx();
assertThat(redis.setGet(key, "value2", args)).isEqualTo("value");
assertThat(redis.get(key)).isEqualTo("value2");
}
public void testSetMGet() {
RedisCommands<String, String> redis = redisConnection.sync();
redis.set("k1", "v1");
redis.set("k3", "v3");
redis.set("k4", "v4");
List<KeyValue<String, String>> expected = new ArrayList<>(4);
expected.add(KeyValue.just("k1", "v1"));
expected.add(KeyValue.empty("k2"));
expected.add(KeyValue.just("k3", "v3"));
expected.add(KeyValue.just("k4", "v4"));
List<KeyValue<String, String>> results = redis.mget("k1", "k2", "k3", "k4");
assertThat(results).containsExactlyElementsOf(expected);
}
public void testSetEmptyStringMGet() {
RedisCommands<String, String> redis = redisConnection.sync();
redis.set("k1", "");
redis.set("k3", "value2");
assertThat(redis.get("k1")).isEmpty();
List<KeyValue<String, String>> expected = new ArrayList<>(3);
expected.add(KeyValue.just("k1", ""));
expected.add(KeyValue.empty("k2"));
expected.add(KeyValue.just("k3", "value2"));
List<KeyValue<String, String>> results = redis.mget("k1", "k2", "k3");
assertThat(results).containsExactlyElementsOf(expected);
}
public void testMSetMGet() {
RedisCommands<String, String> redis = redisConnection.sync();
Map<String, String> values = new HashMap<>();
values.put("k1", "v1");
values.put("k3", "v3");
values.put("k4", "v4");
redis.mset(values);
List<KeyValue<String, String>> expected = new ArrayList<>(4);
expected.add(KeyValue.just("k1", "v1"));
expected.add(KeyValue.empty("k2"));
expected.add(KeyValue.just("k3", "v3"));
expected.add(KeyValue.just("k4", "v4"));
List<KeyValue<String, String>> results = redis.mget("k1", "k2", "k3", "k4");
assertThat(results).containsExactlyElementsOf(expected);
}
public void testSetGetDelete() {
RedisCommands<String, String> redis = redisConnection.sync();
redis.set("k1", "v1");
String v = redis.get("k1");
assertThat(v).isEqualTo("v1");
redis.del("k1");
assertThat(redis.get("k1")).isNull();
assertThat(redis.get("something")).isNull();
}
public void testSetGetBigValue() {
RedisCommands<String, String> redis = redisConnection.sync();
StringBuilder sb = new StringBuilder();
String charsToChoose = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
for (int i = 0; i < 10_000; ++i) {
sb.append(charsToChoose.charAt(ThreadLocalRandom.current().nextInt(charsToChoose.length())));
}
String actualString = sb.toString();
redis.set("k1", actualString);
assertThat(redis.get("k1")).isEqualTo(actualString);
}
public void testPingNoArg() {
RedisCommands<String, String> redis = redisConnection.sync();
assertThat(redis.ping()).isEqualTo(PONG);
}
public void testEcho() {
RedisCommands<String, String> redis = redisConnection.sync();
String stringToSend = "HI THERE!";
assertThat(redis.echo(stringToSend)).isEqualTo(stringToSend);
}
private BlockingQueue<String> addPubSubListener(RedisPubSubCommands<String, String> connection) {
BlockingQueue<String> handOffQueue = new LinkedBlockingQueue<>();
connection.getStatefulConnection().addListener(new RedisPubSubAdapter<String, String>() {
@Override
public void message(String channel, String message) {
log.tracef("Received message on channel %s of %s", channel, message);
handOffQueue.add("message-" + channel + "-" + message);
}
@Override
public void subscribed(String channel, long count) {
log.tracef("Subscribed to %s with %s", channel, count);
handOffQueue.add("subscribed-" + channel + "-" + count);
}
@Override
public void unsubscribed(String channel, long count) {
log.tracef("Unsubscribed to %s with %s", channel, count);
handOffQueue.add("unsubscribed-" + channel + "-" + count);
}
});
return handOffQueue;
}
@DataProvider(name = "booleans")
Object[][] booleans() {
// Reset disabled for now as the client isn't sending a reset command to the
// server
return new Object[][]{{true}, {false}};
}
@Test(dataProvider = "booleans")
public void testPubSubUnsubscribe(boolean quit) throws InterruptedException {
int listenersBefore = cache.getAdvancedCache().getListeners().size();
RedisPubSubCommands<String, String> connection = createPubSubConnection();
BlockingQueue<String> handOffQueue = addPubSubListener(connection);
// Subscribe to some channels
connection.subscribe("channel2", "test");
String value = handOffQueue.poll(10, TimeUnit.SECONDS);
assertThat(value).isEqualTo("subscribed-channel2-0");
value = handOffQueue.poll(10, TimeUnit.SECONDS);
assertThat(value).isEqualTo("subscribed-test-0");
// 2 listeners, one for each sub above
assertThat(cache.getAdvancedCache().getListeners()).hasSize(listenersBefore + 2);
// Unsubscribe to all channels
if (quit) {
// Originally wanted to use reset or quit, but they don't do what we expect from
// lettuce
connection.getStatefulConnection().close();
// Have to use eventually as they are removed asynchronously
eventually(() -> cache.getAdvancedCache().getListeners().size() == listenersBefore);
assertThat(cache.getAdvancedCache().getListeners()).hasSize(listenersBefore);
assertThat(handOffQueue).isEmpty();
} else {
connection.unsubscribe();
// Unsubscribed channels can be in different orders
for (int i = 0; i < 2; ++i) {
value = handOffQueue.poll(10, TimeUnit.SECONDS);
assertThat(value).withFailMessage("Didn't receive any notifications").isNotNull();
if (!value.equals("unsubscribed-channel2-0") && !value.equals("unsubscribed-test-0")) {
fail("Notification doesn't match expected, was: " + value);
}
}
assertThat(cache.getAdvancedCache().getListeners()).hasSize(listenersBefore);
assertThat(connection.ping()).isEqualTo(PONG);
}
}
public void testPubSub() throws InterruptedException {
RedisPubSubCommands<String, String> connection = createPubSubConnection();
BlockingQueue<String> handOffQueue = addPubSubListener(connection);
// Subscribe to some channels
connection.subscribe("channel2", "test");
String value = handOffQueue.poll(10, TimeUnit.SECONDS);
assertThat(value).isEqualTo("subscribed-channel2-0");
value = handOffQueue.poll(10, TimeUnit.SECONDS);
assertThat(value).isEqualTo("subscribed-test-0");
// Send a message to confirm it is properly listening
RedisCommands<String, String> redis = redisConnection.sync();
redis.publish("channel2", "boomshakayaka");
value = handOffQueue.poll(10, TimeUnit.SECONDS);
assertThat(value).isEqualTo("message-channel2-boomshakayaka");
connection.subscribe("channel");
value = handOffQueue.poll(10, TimeUnit.SECONDS);
assertThat(value).isEqualTo("subscribed-channel-0");
connection.unsubscribe("channel2");
connection.unsubscribe("doesn't-exist");
connection.unsubscribe("channel", "test");
for (String channel : new String[]{"channel2", "doesn't-exist", "channel", "test"}) {
value = handOffQueue.poll(10, TimeUnit.SECONDS);
assertThat(value).isEqualTo("unsubscribed-" + channel + "-0");
}
}
public void testCommand() {
RedisCommands<String, String> redis = redisConnection.sync();
List<Object> commands = redis.command();
assertThat(commands.size()).isEqualTo(Commands.all().size());
}
public void testAuth() {
RedisCommands<String, String> redis = redisConnection.sync();
Exceptions.expectException(RedisCommandExecutionException.class, ".*but no password is set",
() -> redis.auth("user", "pass"));
}
public void testNotImplementedCommand() {
RedisCommands<String, String> redis = redisConnection.sync();
Exceptions.expectException(RedisCommandExecutionException.class, "ERR unknown command",
() -> redis.xdel("not-supported", "should error"));
}
protected RedisPubSubCommands<String, String> createPubSubConnection() {
return client.connectPubSub().sync();
}
public void testPipeline() throws ExecutionException, InterruptedException, TimeoutException {
CommonRespTests.testPipeline(redisConnection);
}
@Test
public void testUpperLowercase() {
RedisCommands<String, String> redis = redisConnection.sync();
CommandArgs<String, String> args = new CommandArgs<>(StringCodec.UTF8).addValue("Hello");
String response = redis.dispatch(new SimpleCommand("ECHO"), new StatusOutput<>(StringCodec.UTF8), args);
assertEquals("Hello", response);
response = redis.dispatch(new SimpleCommand("echo"), new StatusOutput<>(StringCodec.UTF8), args);
assertEquals("Hello", response);
}
@Test
public void testInfo() {
RedisCommands<String, String> redis = redisConnection.sync();
String info = redis.info();
assertThat(info).contains("# Server");
assertThat(info).contains("# Client");
assertThat(info).contains("# Modules");
assertThat(info).contains("# Persistence");
assertThat(info).contains("# Keyspace");
info = redis.info("server");
assertThat(info).contains("# Server");
assertThat(info).doesNotContain("# Client");
}
@Test
public void testModule() {
RedisCommands<String, String> redis = redisConnection.sync();
CommandArgs<String, String> args = new CommandArgs<>(StringCodec.UTF8).addValue("LIST");
List<Object> response = redis.dispatch(new SimpleCommand("MODULE"), new ArrayOutput<>(StringCodec.UTF8), args);
assertEquals(0, response.size());
}
@Test
public void testDbSize() {
RedisCommands<String, String> redis = redisConnection.sync();
Long size = redis.dbsize();
assertThat(size).isEqualTo(cache.size());
redis.set("dbsize-key", "dbsize-value");
assertThat(redis.dbsize()).isEqualTo(size + 1);
}
@Test
public void testClient() {
RedisCommands<String, String> redis = redisConnection.sync();
Long l = redis.clientId();
assertThat(l).isNotNull();
String list = redis.clientList();
assertThat(list).contains("id=" + l);
assertThat(list).contains("name= ");
redis.clientSetname("test");
assertThat(redis.clientGetname()).isEqualTo("test");
list = redis.clientList();
assertThat(list).contains("name=test");
}
public static class SimpleCommand implements ProtocolKeyword {
private final String name;
public SimpleCommand(String name) {
this.name = name;
}
@Override
public byte[] getBytes() {
return name.getBytes(StandardCharsets.UTF_8);
}
@Override
public String name() {
return name;
}
}
@Test
public void testExists() {
// Test on 10 entries
RedisCommands<String, String> redis = redisConnection.sync();
IntStream.range(0, 10).map(i -> 2 * i).forEach(i -> redis.set("key" + i, "value " + i));
// Check 20 keys, 10 exist
String[] keys = IntStream.range(0, 21).boxed().map(v -> "key" + v).toArray(String[]::new);
assertThat(redis.exists(keys)).isEqualTo(10);
}
@Test
public void testExistsMisc() {
RedisCommands<String, String> redis = redisConnection.sync();
redis.set("key1", "value1");
redis.set("key2", "value2");
redis.set("key3", "value3");
assertThat(redis.exists("key1")).isEqualTo(1);
assertThat(redis.exists("key1", "key2", "key3")).isEqualTo(3);
assertThat(redis.exists("nonexistent-key")).isEqualTo(0);
assertThat(redis.exists("key1", "nonexistent-key", "key2")).isEqualTo(2);
assertThat(redis.exists("key1", "nonexistent-key", "key1")).isEqualTo(2);
assertThat(redis.exists("nonexistent-key", "nonexistent-key", "key1")).isEqualTo(1);
}
@Test
public void testFlushDb() {
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(k(0), v(0));
assertThat(redis.dbsize()).isGreaterThan(0);
redis.flushdb(FlushMode.SYNC);
assertThat(redis.dbsize()).isEqualTo(0);
redis.set(k(0), v(0));
assertThat(redis.dbsize()).isGreaterThan(0);
redis.flushdb(FlushMode.ASYNC);
eventually(() -> redis.dbsize() == 0);
}
@Test
public void testFlushAll() {
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(k(0), v(0));
assertThat(redis.dbsize()).isGreaterThan(0);
redis.flushall(FlushMode.SYNC);
assertThat(redis.dbsize()).isEqualTo(0);
redis.set(k(0), v(0));
assertThat(redis.dbsize()).isGreaterThan(0);
redis.flushall(FlushMode.ASYNC);
eventually(() -> redis.dbsize() == 0);
}
@Test
public void testScan() {
RedisCommands<String, String> redis = redisConnection.sync();
redis.flushdb();
Set<String> all = new HashSet<>();
for (int i = 0; i < 15; i++) {
String k = k(i);
redis.set(k, v(i));
all.add(k);
}
Set<String> keys = new HashSet<>();
for (KeyScanCursor<String> cursor = redis.scan(); ; cursor = redis.scan(cursor)) {
keys.addAll(cursor.getKeys());
if (cursor.isFinished())
break;
}
assertTrue(keys.containsAll(all));
}
@Test
public void testScanCount() {
RedisCommands<String, String> redis = redisConnection.sync();
redis.flushdb();
Set<String> all = new HashSet<>();
for (int i = 0; i < 15; i++) {
String k = k(i);
redis.set(k, v(i));
all.add(k);
}
Set<String> keys = new HashSet<>();
ScanArgs args = ScanArgs.Builder.limit(5);
for (KeyScanCursor<String> cursor = redis.scan(args); ; cursor = redis.scan(cursor, args)) {
if (!cursor.isFinished()) {
assertEquals(5, cursor.getKeys().size());
}
keys.addAll(cursor.getKeys());
if (cursor.isFinished())
break;
}
assertTrue(keys.containsAll(all));
}
@Test
public void testScanMatch() {
// This only works with certain key types
RedisCommands<String, String> redis = redisConnection.sync();
redis.flushdb();
Set<String> all = new HashSet<>();
for (int i = 0; i < 15; i++) {
String k = k(i);
redis.set(k, v(i));
all.add(k);
}
Set<String> keys = new HashSet<>();
ScanArgs args = ScanArgs.Builder.matches("k1*");
for (KeyScanCursor<String> cursor = redis.scan(args); ; cursor = redis.scan(cursor, args)) {
for (String key : cursor.getKeys()) {
assertThat(key).startsWith("k1");
keys.add(key);
}
if (cursor.isFinished())
break;
}
}
public void testClusterShardsSingleNode() {
RedisCommands<String, String> redis = redisConnection.sync();
assertThatThrownBy(redis::clusterShards)
.isInstanceOf(RedisCommandExecutionException.class)
.hasMessageContaining("ERR This instance has cluster support disabled");
}
@Test(dataProvider = "lcsCases")
public void testLcs(String v1, String v2, String resp, int[][] idx) {
String key1 = "lcs-base-1";
String key2 = "lcs-base-2";
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(key1, v1);
redis.set(key2, v2);
StrAlgoArgs args = StrAlgoArgs.Builder.keys(key1, key2);
StringMatchResult res = redis.stralgoLcs(args);
assertThat(res.getMatchString()).isEqualTo(resp);
assertThat(res.getLen()).isZero();
}
@Test(dataProvider = "lcsCases")
public void testLcsLen(String v1, String v2, String resp, int[][] idx) {
String key1 = "lcs-base-1";
String key2 = "lcs-base-2";
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(key1, v1);
redis.set(key2, v2);
StrAlgoArgs args = StrAlgoArgs.Builder.keys(key1, key2).justLen();
StringMatchResult res = redis.stralgoLcs(args);
assertThat(res.getLen()).isEqualTo(resp.length());
assertThat(res.getMatchString()).isNull();
}
@Test(dataProvider = "lcsCases")
public void testLcsIdx(String v1, String v2, String resp, int[][] idx) {
String key1 = "lcs-base-1";
String key2 = "lcs-base-2";
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(key1, v1);
redis.set(key2, v2);
StrAlgoArgs args = StrAlgoArgs.Builder.keys(key1, key2).withIdx();
StringMatchResult res = redis.stralgoLcs(args);
checkIdx(resp, idx, res, false);
}
@Test(dataProvider = "lcsCases")
public void testLcsIdxWithLen(String v1, String v2, String resp, int[][] idx) {
String key1 = "lcs-base-1";
String key2 = "lcs-base-2";
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(key1, v1);
redis.set(key2, v2);
StrAlgoArgs args = StrAlgoArgs.Builder.keys(key1, key2).withIdx().withMatchLen();
StringMatchResult res = redis.stralgoLcs(args);
checkIdx(resp, idx, res, true);
}
@Test(dataProvider = "lcsCasesWithMinLen")
public void testLcsIdxWithMinLen(String v1, String v2, String resp, int[][] idxs, int minLen) {
String key1 = "lcs-base-1";
String key2 = "lcs-base-2";
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(key1, v1);
redis.set(key2, v2);
StrAlgoArgs args = StrAlgoArgs.Builder.keys(key1, key2).withIdx().minMatchLen(minLen);
int[][] idx = Arrays.stream(idxs).filter(pos -> pos.length == 1 || pos[1] - pos[0] >= minLen)
.toArray(int[][]::new);
StringMatchResult res = redis.stralgoLcs(args);
checkIdx(resp, idx, res, false);
}
@DataProvider
public Object[][] lcsCases() {
return new Object[][]{
{"GAC", "AGCAT", "AC", new int[][]{{2, 2, 2, 2}, {1, 1, 0, 0}, {2}}},
{"XMJYAUZ", "MZJAWXU", "MJAU",
new int[][]{{5, 5, 6, 6}, {4, 4, 3, 3}, {2, 2, 2, 2}, {1, 1, 0, 0}, {4}}},
{"ohmytext", "mynewtext", "mytext", new int[][]{{4, 7, 5, 8}, {2, 3, 0, 1}, {6}}},
{"ABCBDAB", "BDCABA", "BDAB", new int[][]{{5, 6, 3, 4}, {3, 4, 0, 1}, {4}}},
{"ABCEZ12 21AAZ", "12ABZ 21AZAZ", "ABZ 21AAZ",
new int[][]{{11, 12, 10, 11}, {7, 10, 5, 8}, {4, 4, 4, 4}, {0, 1, 2, 3}, {9}}}
};
}
@DataProvider
public Object[][] lcsCasesWithMinLen() {
var minLengths = new Object[][]{{1}, {2}, {4}, {10}};
var lcsCases = this.lcsCases();
var result = new Object[lcsCases.length][];
for (Object[] len : minLengths) {
for (int i = 0; i < lcsCases.length; i++) {
result[i] = Stream.concat(Arrays.stream(lcsCases[i]), Arrays.stream(len)).toArray();
}
}
return result;
}
private void checkIdx(String resp, int[][] idx, StringMatchResult res, boolean withLen) {
var matches = res.getMatches();
assertThat(matches.size()).isEqualTo(idx.length - 1);
for (int i = 0; i < matches.size(); i++) {
assertThat(matches.get(i).getA().getStart()).isEqualTo(idx[i][0]);
assertThat(matches.get(i).getA().getEnd()).isEqualTo(idx[i][1]);
assertThat(matches.get(i).getB().getStart()).isEqualTo(idx[i][2]);
assertThat(matches.get(i).getB().getEnd()).isEqualTo(idx[i][3]);
if (withLen) {
assertThat(matches.get(i).getMatchLen()).isEqualTo(idx[i][1] - idx[i][0] + 1);
}
}
assertThat(res.getLen()).isEqualTo(resp.length());
assertThat(res.getMatchString()).isNull();
}
@Test
public void testTTL() {
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(k(), v());
assertThat(redis.ttl(k())).isEqualTo(-1);
assertThat(redis.ttl(k(1))).isEqualTo(-2);
redis.set(k(2), v(2), SetArgs.Builder.ex(10_000));
assertThat(redis.ttl(k(2))).isEqualTo(10_000L);
}
@Test
public void testPTTL() {
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(k(), v());
assertThat(redis.pttl(k())).isEqualTo(-1);
assertThat(redis.pttl(k(1))).isEqualTo(-2);
redis.set(k(2), v(2), SetArgs.Builder.ex(10_000));
assertThat(redis.pttl(k(2))).isEqualTo(10_000_000L);
}
@Test
public void testExpireTime() {
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(k(), v());
assertThat(redis.expiretime(k())).isEqualTo(-1);
assertThat(redis.expiretime(k(1))).isEqualTo(-2);
redis.set(k(2), v(2), SetArgs.Builder.exAt(timeService.wallClockTime() + 10_000));
assertThat(redis.expiretime(k(2))).isEqualTo(timeService.wallClockTime() + 10_000L);
}
@Test
public void testPExpireTime() {
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(k(), v());
assertThat(redis.pexpiretime(k())).isEqualTo(-1);
assertThat(redis.pexpiretime(k(1))).isEqualTo(-2);
redis.set(k(2), v(2), SetArgs.Builder.exAt(timeService.wallClockTime() + 10_000));
assertThat(redis.pexpiretime(k(2))).isEqualTo((timeService.wallClockTime() + 10_000L) * 1000L);
}
@Test
public void testMemoryUsage() {
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(k(), "1");
assertThat(redis.memoryUsage(k())).isEqualTo(16);
redis.set(k(1), "a".repeat(1001));
assertThat(redis.memoryUsage(k(1))).isEqualTo(1032);
}
@Test
public void testClusterNodesSingleNode() {
RedisCommands<String, String> redis = redisConnection.sync();
assertThatThrownBy(redis::clusterNodes)
.isInstanceOf(RedisCommandExecutionException.class)
.hasMessageContaining("ERR This instance has cluster support disabled");
}
@Test
public void testType() {
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(k(), "1");
assertThat(redis.type(k())).isEqualTo("string");
redis.hset(k(1), "k", "v");
assertThat(redis.type(k(1))).isEqualTo("hash");
redis.lpush(k(2), "a");
assertThat(redis.type(k(2))).isEqualTo("list");
redis.sadd(k(3), "a");
assertThat(redis.type(k(3))).isEqualTo("set");
redis.zadd(k(4), 1.0, "a");
assertThat(redis.type(k(4))).isEqualTo("zset");
assertThat(redis.type(k(100))).isEqualTo("none");
}
@Test
public void testExpire() {
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(k(), v());
assertThat(redis.ttl(k())).isEqualTo(-1);
assertThat(redis.expire(k(), 1000)).isTrue();
assertThat(redis.ttl(k())).isEqualTo(1000);
assertThat(redis.expire(k(), 500, ExpireArgs.Builder.gt())).isFalse();
assertThat(redis.expire(k(), 1500, ExpireArgs.Builder.gt())).isTrue();
assertThat(redis.expire(k(), 2000, ExpireArgs.Builder.lt())).isFalse();
assertThat(redis.expire(k(), 1000, ExpireArgs.Builder.lt())).isTrue();
assertThat(redis.expire(k(), 1250, ExpireArgs.Builder.xx())).isTrue();
assertThat(redis.expire(k(), 1000, ExpireArgs.Builder.nx())).isFalse();
assertThat(redis.expire(k(1), 1000)).isFalse();
redis.set(k(1), v(1));
assertThat(redis.expire(k(1), 1000, ExpireArgs.Builder.xx())).isFalse();
assertThat(redis.expire(k(1), 1000, ExpireArgs.Builder.nx())).isTrue();
}
@Test
public void testExpireAt() {
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(k(), v());
assertThat(redis.expiretime(k())).isEqualTo(-1);
assertThat(redis.expireat(k(), timeService.wallClockTime() + 1000)).isTrue();
assertThat(redis.expiretime(k())).isEqualTo((timeService.wallClockTime() + 1000) / 1000);
assertThat(redis.expireat(k(), timeService.wallClockTime() + 500, ExpireArgs.Builder.gt())).isFalse();
assertThat(redis.expireat(k(), timeService.wallClockTime() + 1500, ExpireArgs.Builder.gt())).isTrue();
assertThat(redis.expireat(k(), timeService.wallClockTime() + 2000, ExpireArgs.Builder.lt())).isFalse();
assertThat(redis.expireat(k(), timeService.wallClockTime() + 1000, ExpireArgs.Builder.lt())).isTrue();
assertThat(redis.expireat(k(), timeService.wallClockTime() + 1250, ExpireArgs.Builder.xx())).isTrue();
assertThat(redis.expireat(k(), timeService.wallClockTime() + 1000, ExpireArgs.Builder.nx())).isFalse();
assertThat(redis.expireat(k(1), timeService.wallClockTime() + 1000)).isFalse();
redis.set(k(1), v(1));
assertThat(redis.expireat(k(1), timeService.wallClockTime() + 1000, ExpireArgs.Builder.xx())).isFalse();
assertThat(redis.expireat(k(1), timeService.wallClockTime() + 1000, ExpireArgs.Builder.nx())).isTrue();
}
}
| 31,761
| 39.205063
| 117
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/ClusteredOperationsTest.java
|
package org.infinispan.server.resp;
import static org.assertj.core.api.Assertions.assertThat;
import static org.infinispan.server.resp.test.RespTestingUtil.OK;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Stream;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "server.resp.ClusteredOperationsTest")
public class ClusteredOperationsTest extends BaseMultipleRespTest {
public void testClusteredGetAndSet() {
for (int i = 0; i < 100; i++) {
assertThat(redisConnection1.sync().set("key" + i, "value" + i)).isEqualTo(OK);
}
for (int i = 0; i < 100; i++) {
assertThat( redisConnection2.sync().get("key" + i)).isEqualTo("value" + i);
}
}
public void retrieveShardsInformation() {
validate(redisConnection1.sync().clusterShards());
validate(redisConnection2.sync().clusterShards());
}
public void retrieveNodesInformation() {
assertClusterNodesResponse(redisConnection1.sync().clusterNodes());
assertClusterNodesResponse(redisConnection2.sync().clusterNodes());
}
private void assertClusterNodesResponse(String response) {
String[] nodes = response.split("\n");
assertThat(nodes).hasSize(2);
for (String node : nodes) {
String[] information = node.split(" ");
assertThat(information)
// Number of slots vary.
.hasSizeGreaterThan(8)
.containsAnyOf("master", "myself,master")
.satisfies(c -> assertThat(Stream.of(c).anyMatch(s -> s.startsWith("127.0.0.1:"))).isTrue())
.contains("connected", "-", "0");
}
}
public void retrieveSlotsInformation() {
List<Object> slots = redisConnection1.sync().clusterSlots();
// With 2 nodes, we should have at least 2 slots.
assertThat(slots).hasSizeGreaterThanOrEqualTo(2);
for (Object slot : slots) {
List<Object> values = (List<Object>) slot;
// Base information includes the slot range start, end, and at least 1 owner.
assertThat(values).hasSizeGreaterThanOrEqualTo(3);
assertThat(values.get(0)).isInstanceOf(Long.class);
assertThat(values.get(1)).isInstanceOf(Long.class);
List<Object> owner = asList(values, 2);
assertThat(owner).hasSizeGreaterThanOrEqualTo(3);
assertThat(owner.get(0)).isInstanceOf(String.class)
.satisfies(h -> assertThat(h.equals(server1.getHost()) || h.equals(server2.getHost())).isTrue());
assertThat(owner.get(1)).isInstanceOf(Long.class)
.satisfies(v -> assertThat(v.equals((long) server1.getPort()) || v.equals((long) server2.getPort())).isTrue());
}
}
private void validate(List<Object> shards) {
// We have 2 nodes in the system.
assertThat(shards).hasSize(2);
assertShard(asList(shards, 0), 2);
assertShard(asList(shards, 1), 2);
}
static void assertShard(List<Object> values, int size) {
assertThat(values)
.hasSize(4)
.contains("slots", "nodes");
Map<String, Object> slot = new HashMap<>();
slot.put((String) values.get(0), values.get(1));
slot.put((String) values.get(2), values.get(3));
assertThat(slot.get("slots")).isInstanceOf(List.class)
.asList()
.isNotEmpty();
assertThat(slot.get("nodes")).isInstanceOf(List.class)
.asList()
.hasSize(size);
for (int i = 0; i < size; i++) {
// First node always master.
String role = i == 0 ? "master" : "replica";
assertNode(toNodeInformation(asList((List<Object>) slot.get("nodes"), i)), role);
}
}
private static void assertNode(Map<String, Object> node, String role) {
assertThat(node)
// Some required keys from the specification.
.containsKeys("id", "port", "endpoint", "ip", "replication-offset", "role", "health")
.containsEntry("role", role)
.containsEntry("replication-offset", 0L)
.containsEntry("health", "online")
.hasEntrySatisfying("port", port -> assertThat((Long) port).isGreaterThanOrEqualTo(0))
.hasEntrySatisfying("endpoint", endpoint -> assertThat(endpoint).isEqualTo(node.get("ip")));
}
private static List<Object> asList(List<Object> slots, int idx) {
Object object = slots.get(idx);
assertThat(object).isInstanceOf(List.class);
return (List<Object>) object;
}
private static Map<String, Object> toNodeInformation(List<Object> values) {
assertThat(values).size()
.satisfies(size -> assertThat(size).isEven());
Map<String, Object> node = new HashMap<>();
for (int i = 0; i < values.size(); i += 2) {
node.put((String) values.get(i), values.get(i + 1));
}
return node;
}
}
| 4,918
| 35.169118
| 126
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/StringCommandsTest.java
|
package org.infinispan.server.resp;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.withPrecision;
import java.util.Arrays;
import java.util.stream.Stream;
import org.infinispan.commons.time.ControlledTimeService;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import io.lettuce.core.GetExArgs;
import io.lettuce.core.RedisCommandExecutionException;
import io.lettuce.core.SetArgs;
import io.lettuce.core.StrAlgoArgs;
import io.lettuce.core.StringMatchResult;
import io.lettuce.core.api.sync.RedisCommands;
@Test(groups = "functional", testName = "server.resp.StringCommandsTest")
public class StringCommandsTest extends SingleNodeRespBaseTest {
@Test
public void testIncrNotPresent() {
RedisCommands<String, String> redis = redisConnection.sync();
String nonPresentKey = "incr-notpresent";
Long newValue = redis.incr(nonPresentKey);
assertThat(newValue.longValue()).isEqualTo(1L);
Long nextValue = redis.incr(nonPresentKey);
assertThat(nextValue.longValue()).isEqualTo(2L);
}
@Test
public void testIncrPresent() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "incr";
redis.set(key, "12");
Long newValue = redis.incr(key);
assertThat(newValue.longValue()).isEqualTo(13L);
Long nextValue = redis.incr(key);
assertThat(nextValue.longValue()).isEqualTo(14L);
}
@Test
public void testIncrPresentNotInteger() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "incr-string";
redis.set(key, "foo");
assertThatThrownBy(() -> redis.incr(key))
.isInstanceOf(RedisCommandExecutionException.class)
.hasMessageContaining("value is not an integer or out of range");
}
@Test
public void testDecrNotPresent() {
RedisCommands<String, String> redis = redisConnection.sync();
String nonPresentKey = "decr-notpresent";
Long newValue = redis.decr(nonPresentKey);
assertThat(newValue.longValue()).isEqualTo(-1L);
Long nextValue = redis.decr(nonPresentKey);
assertThat(nextValue.longValue()).isEqualTo(-2L);
}
@Test
public void testDecrPresent() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "decr";
redis.set(key, "12");
Long newValue = redis.decr(key);
assertThat(newValue.longValue()).isEqualTo(11L);
Long nextValue = redis.decr(key);
assertThat(nextValue.longValue()).isEqualTo(10L);
}
@Test
public void testIncrbyNotPresent() {
RedisCommands<String, String> redis = redisConnection.sync();
String nonPresentKey = "incrby-notpresent";
Long newValue = redis.incrby(nonPresentKey, 42);
assertThat(newValue.longValue()).isEqualTo(42L);
Long nextValue = redis.incrby(nonPresentKey, 2);
assertThat(nextValue.longValue()).isEqualTo(44L);
}
@Test
public void testIncrbyPresent() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "incrby";
redis.set(key, "12");
Long newValue = redis.incrby(key, 23);
assertThat(newValue.longValue()).isEqualTo(35L);
Long nextValue = redis.incrby(key, 23);
assertThat(nextValue.longValue()).isEqualTo(58L);
}
@Test
public void testIncrbyPresentNotInteger() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "incrby-string";
redis.set(key, "foo");
assertThatThrownBy(() -> redis.incrby(key, 1), "")
.isInstanceOf(RedisCommandExecutionException.class)
.hasMessageContaining("value is not an integer or out of range");
}
@Test
public void testDecrbyNotPresent() {
RedisCommands<String, String> redis = redisConnection.sync();
String nonPresentKey = "decrby-notpresent";
Long newValue = redis.decrby(nonPresentKey, 42);
assertThat(newValue.longValue()).isEqualTo(-42L);
Long nextValue = redis.decrby(nonPresentKey, 2);
assertThat(nextValue.longValue()).isEqualTo(-44L);
}
@Test
public void testDecrbyPresent() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "decrby";
redis.set(key, "12");
Long newValue = redis.decrby(key, 10);
assertThat(newValue.longValue()).isEqualTo(2L);
Long nextValue = redis.decrby(key, 10);
assertThat(nextValue.longValue()).isEqualTo(-8L);
}
@Test
public void testIncrbyFloatNotPresent() {
RedisCommands<String, String> redis = redisConnection.sync();
String nonPresentKey = "incrbyfloat-notpresent";
Double newValue = redis.incrbyfloat(nonPresentKey, 0.42);
assertThat(newValue.doubleValue()).isEqualTo(0.42, withPrecision(2d));
Double nextValue = redis.incrbyfloat(nonPresentKey, 0.2);
assertThat(nextValue.doubleValue()).isEqualTo(0.62, withPrecision(2d));
}
@Test
public void testIncrbyFloatPresent() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "incrbyfloat";
redis.set(key, "0.12");
Double newValue = redis.incrbyfloat(key, 0.23);
assertThat(newValue.doubleValue()).isEqualTo(0.35, withPrecision(2d));
Double nextValue = redis.incrbyfloat(key, -0.23);
assertThat(nextValue.doubleValue()).isEqualTo(0.12, withPrecision(2d));
}
@Test
public void testIncrbyFloatPresentNotFloat() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "incrbyfloat-string";
redis.set(key, "foo");
assertThatThrownBy(() -> redis.incrbyfloat(key, 0.1), "")
.isInstanceOf(RedisCommandExecutionException.class)
.hasMessageContaining("value is not a valid float");
}
@Test
public void testAppend() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "append";
String val = "Hello";
String app = " World";
String expect = val + app;
redis.set(key, val);
long retVal = redis.append(key, app);
assertThat(retVal).isEqualTo(expect.length());
assertThat(redis.get(key)).isEqualTo(expect);
}
@Test
public void testAppendNotPresent() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "append";
String app = " World";
String expect = app;
long retVal = redis.append(key, app);
assertThat(retVal).isEqualTo(expect.length());
String val = redis.get(key);
assertThat(val).isEqualTo(expect);
}
public void testGetdel() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "getdel";
redis.set(key, "value");
String retval = redis.getdel(key);
assertThat(retval).isEqualTo("value");
assertThat(redis.get(key)).isNull();
}
@Test
public void testGetdelNotPresent() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "getdel-notpresent";
assertThat(redis.getdel(key)).isNull();
}
@Test
public void testStrlen() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "strlen";
String val = "Hello";
String app = " World";
redis.set(key, val);
assertThat(redis.strlen(key)).isEqualTo(5);
long retVal = redis.append(key, app);
assertThat(redis.strlen(key)).isEqualTo(retVal);
}
@Test
public void testStrlenUTF8() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "strlen-nonascii";
String val = "Euro is €";
String app = " yen is ¥";
redis.set(key, val);
assertThat(redis.strlen(key)).isEqualTo(11);
// See if append and strlen are consistent
long retVal = redis.append(key, app);
assertThat(redis.strlen(key)).isEqualTo(retVal);
}
@Test
public void testStrlenNotPresent() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "strlen-notpresent";
assertThat(redis.strlen(key)).isEqualTo(0);
}
@Test(dataProvider = "lcsCases")
public void testLcs(String v1, String v2, String resp, int[][] idx) {
String key1 = "lcs-base-1";
String key2 = "lcs-base-2";
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(key1, v1);
redis.set(key2, v2);
StrAlgoArgs args = StrAlgoArgs.Builder.keys(key1, key2);
StringMatchResult res = redis.stralgoLcs(args);
assertThat(res.getMatchString()).isEqualTo(resp);
assertThat(res.getLen()).isZero();
}
@Test(dataProvider = "lcsCases")
public void testLcsLen(String v1, String v2, String resp, int[][] idx) {
String key1 = "lcs-base-1";
String key2 = "lcs-base-2";
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(key1, v1);
redis.set(key2, v2);
StrAlgoArgs args = StrAlgoArgs.Builder.keys(key1, key2).justLen();
StringMatchResult res = redis.stralgoLcs(args);
assertThat(res.getLen()).isEqualTo(resp.length());
assertThat(res.getMatchString()).isNull();
}
@Test(dataProvider = "lcsCases")
public void testLcsIdx(String v1, String v2, String resp, int[][] idx) {
String key1 = "lcs-base-1";
String key2 = "lcs-base-2";
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(key1, v1);
redis.set(key2, v2);
StrAlgoArgs args = StrAlgoArgs.Builder.keys(key1, key2).withIdx();
StringMatchResult res = redis.stralgoLcs(args);
checkIdx(resp, idx, res, false);
}
@Test(dataProvider = "lcsCases")
public void testLcsIdxWithLen(String v1, String v2, String resp, int[][] idx) {
String key1 = "lcs-base-1";
String key2 = "lcs-base-2";
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(key1, v1);
redis.set(key2, v2);
StrAlgoArgs args = StrAlgoArgs.Builder.keys(key1, key2).withIdx().withMatchLen();
StringMatchResult res = redis.stralgoLcs(args);
checkIdx(resp, idx, res, true);
}
@Test(dataProvider = "lcsCasesWithMinLen")
public void testLcsIdxWithMinLen(String v1, String v2, String resp, int[][] idxs, int minLen) {
String key1 = "lcs-base-1";
String key2 = "lcs-base-2";
RedisCommands<String, String> redis = redisConnection.sync();
redis.set(key1, v1);
redis.set(key2, v2);
StrAlgoArgs args = StrAlgoArgs.Builder.keys(key1, key2).withIdx().minMatchLen(minLen);
int[][] idx = Arrays.stream(idxs).filter(pos -> pos.length == 1 || pos[1] - pos[0] >= minLen)
.toArray(int[][]::new);
StringMatchResult res = redis.stralgoLcs(args);
checkIdx(resp, idx, res, false);
}
@DataProvider
public Object[][] lcsCases() {
return new Object[][] {
{ "GAC", "AGCAT", "AC", new int[][] { { 2, 2, 2, 2 }, { 1, 1, 0, 0 }, { 2 } } },
{ "XMJYAUZ", "MZJAWXU", "MJAU",
new int[][] { { 5, 5, 6, 6 }, { 4, 4, 3, 3 }, { 2, 2, 2, 2 }, { 1, 1, 0, 0 }, { 4 } } },
{ "ohmytext", "mynewtext", "mytext", new int[][] { { 4, 7, 5, 8 }, { 2, 3, 0, 1 }, { 6 } } },
{ "ABCBDAB", "BDCABA", "BDAB", new int[][] { { 5, 6, 3, 4 }, { 3, 4, 0, 1 }, { 4 } } },
{ "ABCEZ12 21AAZ", "12ABZ 21AZAZ", "ABZ 21AAZ",
new int[][] { { 11, 12, 10, 11 }, { 7, 10, 5, 8 }, { 4, 4, 4, 4 }, { 0, 1, 2, 3 }, { 9 } } }
};
}
@DataProvider
public Object[][] lcsCasesWithMinLen() {
var minLengths = new Object[][] { { 1 }, { 2 }, { 4 }, { 10 } };
var lcsCases = this.lcsCases();
var result = new Object[lcsCases.length][];
for (Object[] len : minLengths) {
for (int i = 0; i < lcsCases.length; i++) {
result[i] = Stream.concat(Arrays.stream(lcsCases[i]), Arrays.stream(len)).toArray();
}
}
return result;
}
private void checkIdx(String resp, int[][] idx, StringMatchResult res, boolean withLen) {
var matches = res.getMatches();
assertThat(matches.size()).isEqualTo(idx.length - 1);
for (int i = 0; i < matches.size(); i++) {
assertThat(matches.get(i).getA().getStart()).isEqualTo(idx[i][0]);
assertThat(matches.get(i).getA().getEnd()).isEqualTo(idx[i][1]);
assertThat(matches.get(i).getB().getStart()).isEqualTo(idx[i][2]);
assertThat(matches.get(i).getB().getEnd()).isEqualTo(idx[i][3]);
if (withLen) {
assertThat(matches.get(i).getMatchLen()).isEqualTo(idx[i][1] - idx[i][0] + 1);
}
}
assertThat(res.getLen()).isEqualTo(resp.length());
assertThat(res.getMatchString()).isNull();
}
@Test
void testGetRange() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "getrange";
redis.set(key, "A long string for testing");
assertThat(redis.getrange(key, 1, 7)).isEqualTo(" long s");
// Check negative range
assertThat(redis.getrange(key, 10, -2)).isEqualTo("ing for testin");
}
@Test
void testGetRangeMultibyte() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "getrange";
redis.set(key, "Testing with € char");
var g = redis.getrange(key, 13, 20);
assertThat(g).isEqualTo("€ char");
// Check negative range
assertThat(redis.getrange(key, 10, -2)).isEqualTo("th € cha");
}
@Test
void testSetrange() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "setrange";
redis.set(key, "A long string for testing");
assertThat(redis.setrange(key, 2, "tiny")).isEqualTo(25);
assertThat(redis.get(key)).isEqualTo("A tiny string for testing");
}
@Test
void testSetrangePatchOverflowsLength() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "setrange";
redis.set(key, "A long string for testing");
assertThat(redis.setrange(key, 18, "setrange testing")).isEqualTo(34);
assertThat(redis.get(key)).isEqualTo("A long string for setrange testing");
}
@Test
void testSetrangeOffsetGreaterThanLength() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "setrange";
redis.set(key, "A long string for testing");
assertThat(redis.setrange(key, 30, "my setrange")).isEqualTo(41);
assertThat(redis.get(key)).isEqualTo("A long string for testing\u0000\u0000\u0000\u0000\u0000my setrange");
}
@Test
void testSetrangeNotPresent() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "setrange-notpresent";
assertThat(redis.setrange(key, 5, "my setrange")).isEqualTo(16);
assertThat(redis.get(key)).isEqualTo("\u0000\u0000\u0000\u0000\u0000my setrange");
}
@Test
public void testGetexWithEX() throws InterruptedException {
RedisCommands<String, String> redis = redisConnection.sync();
GetExArgs args = GetExArgs.Builder.ex(1);
String key = "getexex";
String value = "getex-value";
redis.set(key, value);
redis.getex(key, args);
assertThat(redis.get(key)).isEqualTo(value);
((ControlledTimeService) this.timeService).advance(2000);
assertThat(redis.get(key)).isNull();
}
@Test
public void testGetexWithPEX() throws InterruptedException {
RedisCommands<String, String> redis = redisConnection.sync();
GetExArgs args = GetExArgs.Builder.px(500);
String key = "getexpex";
String value = "getexpex-value";
redis.set(key, value);
redis.getex(key, args);
assertThat(redis.get(key)).isEqualTo(value);
((ControlledTimeService) this.timeService).advance(1000);
assertThat(redis.get(key)).isNull();
}
@Test
public void testGetexWithPERSIST() throws InterruptedException {
RedisCommands<String, String> redis = redisConnection.sync();
GetExArgs args = GetExArgs.Builder.ex(2);
String key = "getexpersist";
String value = "getexpersist-value";
redis.set(key, value);
redis.getex(key, args);
assertThat(redis.get(key)).isEqualTo(value);
((ControlledTimeService) this.timeService).advance(1000);
args = GetExArgs.Builder.persist();
redis.getex(key, args);
((ControlledTimeService) this.timeService).advance(1500);
assertThat(redis.get(key)).isEqualTo(value);
}
@Test
public void testGetexWithEXNotPresent() throws InterruptedException {
RedisCommands<String, String> redis = redisConnection.sync();
GetExArgs args = GetExArgs.Builder.ex(2);
String key = "getexex";
redis.getex(key, args);
assertThat(redis.get(key)).isNull();
}
@Test
public void testSetWithEX() throws InterruptedException {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "setex";
String value = "getex-value";
var args = new SetArgs().ex(1);
redis.set(key, value, args);
assertThat(redis.get(key)).isEqualTo(value);
((ControlledTimeService) this.timeService).advance(2000);
assertThat(redis.get(key)).isNull();
}
}
| 17,415
| 35.898305
| 113
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/RespDecoderTest.java
|
package org.infinispan.server.resp;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNotNull;
import java.nio.charset.StandardCharsets;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.CompletionStage;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.embedded.EmbeddedChannel;
import io.netty.handler.codec.FixedLengthFrameDecoder;
/**
* Test to ensure decoder works properly for various requests, types and replay
*
* @author William Burns
* @since 15.0
*/
@Test(groups = "functional", testName = "server.resp.RespDecoderTest")
public class RespDecoderTest {
EmbeddedChannel channel;
Queue<Request> queuedCommands;
static class Request {
private final RespCommand command;
private final List<byte[]> arguments;
Request(RespCommand command, List<byte[]> arguments) {
this.command = command;
// Make a copy, because the decoder may reuse the list
this.arguments = new ArrayList<>(arguments);
}
}
@BeforeClass
public void beforeClass() {
queuedCommands = new ArrayDeque<>();
RespRequestHandler myRespRequestHandler = new RespRequestHandler() {
@Override
protected CompletionStage<RespRequestHandler> actualHandleRequest(ChannelHandlerContext ctx, RespCommand type, List<byte[]> arguments) {
queuedCommands.add(new Request(type, arguments));
return myStage;
}
};
RespDecoder decoder = new RespDecoder();
channel = new EmbeddedChannel(new FixedLengthFrameDecoder(1), decoder, new RespHandler(decoder, myRespRequestHandler));
}
@AfterClass
public void afterClass() {
channel.close();
}
@Test
public void testMixtureOfTypes() {
String commandName = "PSUBSCRIBE";
String minValueStr = String.valueOf(Long.MIN_VALUE);
ByteBuf buffer = Unpooled.copiedBuffer("*6\r\n+" + commandName + "\r\n$3\r\nkey\r\n+value\r\n:23\r\n$5\r\nworks\r\n:" + minValueStr + "\r\n", StandardCharsets.US_ASCII);
channel.writeInbound(buffer);
channel.checkException();
Request req = queuedCommands.poll();
assertNotNull(req);
assertEquals(commandName, req.command.getName());
List<byte[]> arguments = req.arguments;
assertEquals(5, arguments.size());
assertEquals("key".getBytes(StandardCharsets.US_ASCII), arguments.get(0));
assertEquals("value".getBytes(StandardCharsets.US_ASCII), arguments.get(1));
assertEquals("23".getBytes(StandardCharsets.US_ASCII), arguments.get(2));
assertEquals("works".getBytes(StandardCharsets.US_ASCII), arguments.get(3));
assertEquals(minValueStr.getBytes(StandardCharsets.US_ASCII), arguments.get(4));
assertEquals(0, queuedCommands.size());
assertEquals(0, buffer.readableBytes());
}
}
| 3,123
| 33.32967
| 175
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/HashOperationsTest.java
|
package org.infinispan.server.resp;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
import static org.infinispan.server.resp.test.RespTestingUtil.assertWrongType;
import java.util.HashMap;
import java.util.Map;
import org.testng.annotations.Test;
import io.lettuce.core.KeyValue;
import io.lettuce.core.MapScanCursor;
import io.lettuce.core.RedisCommandExecutionException;
import io.lettuce.core.ScanArgs;
import io.lettuce.core.api.sync.RedisCommands;
@Test(groups = "functional", testName = "server.resp.HashOperationsTest")
public class HashOperationsTest extends SingleNodeRespBaseTest {
public void testHMSET() {
RedisCommands<String, String> redis = redisConnection.sync();
Map<String, String> map = Map.of("key1", "value1", "key2", "value2", "key3", "value3");
assertThat(redis.hmset("HMSET", map)).isEqualTo("OK");
assertThat(redis.hget("HMSET", "key1")).isEqualTo("value1");
assertThat(redis.hget("HMSET", "unknown")).isNull();
assertThat(redis.hget("UNKNOWN", "unknown")).isNull();
assertWrongType(() -> redis.set("plain", "string"), () -> redis.hmset("plain", Map.of("k1", "v1")));
}
public void testHSET() {
RedisCommands<String, String> redis = redisConnection.sync();
Map<String, String> map = Map.of("key1", "value1", "key2", "value2", "key3", "value3");
assertThat(redis.hset("HSET", map)).isEqualTo(3);
// Updating some keys should return 0.
assertThat(redis.hset("HSET", Map.of("key1", "other-value1"))).isEqualTo(0);
// Mixing update and new keys.
assertThat(redis.hset("HSET", Map.of("key2", "other-value2", "key4", "value4"))).isEqualTo(1);
assertThat(redis.hget("HSET", "key1")).isEqualTo("other-value1");
assertThat(redis.hget("HSET", "unknown")).isNull();
assertThat(redis.hget("UNKNOWN", "unknown")).isNull();
assertWrongType(() -> redis.set("plain", "string"), () -> redis.hmset("plain", Map.of("k1", "v1")));
assertWrongType(() -> {}, () -> redis.hget("plain", "k1"));
}
public void testHashLength() {
RedisCommands<String, String> redis = redisConnection.sync();
Map<String, String> map = Map.of("key1", "value1", "key2", "value2", "key3", "value3");
assertThat(redis.hset("len-test", map)).isEqualTo(3);
assertThat(redis.hlen("len-test")).isEqualTo(3);
assertThat(redis.hlen("UNKNOWN")).isEqualTo(0);
assertWrongType(() -> redis.set("plain", "string"), () -> redis.hlen("plain"));
}
public void testHScanOperation() {
RedisCommands<String, String> redis = redisConnection.sync();
Map<String, String> content = new HashMap<>();
int dataSize = 15;
redis.flushdb();
for (int i = 0; i < dataSize; i++) {
content.put("key" + i, "value" + i);
}
assertThat(redis.hmset("hscan-test", content)).isEqualTo("OK");
assertThat(redis.hlen("hscan-test")).isEqualTo(dataSize);
Map<String, String> scanned = new HashMap<>();
for (MapScanCursor<String, String> cursor = redis.hscan("hscan-test"); ; cursor = redis.hscan("hscan-test", cursor)) {
scanned.putAll(cursor.getMap());
if (cursor.isFinished()) break;
}
assertThat(scanned)
.hasSize(dataSize)
.containsAllEntriesOf(content);
MapScanCursor<String, String> empty = redis.hscan("unknown");
assertThat(empty)
.satisfies(v -> assertThat(v.isFinished()).isTrue())
.satisfies(v -> assertThat(v.getMap()).isEmpty());
}
public void testHScanCount() {
RedisCommands<String, String> redis = redisConnection.sync();
Map<String, String> content = new HashMap<>();
int dataSize = 15;
for (int i = 0; i < dataSize; i++) {
content.put("key" + i, "value" + i);
}
assertThat(redis.hmset("hscan-count-test", content)).isEqualTo("OK");
assertThat(redis.hlen("hscan-count-test")).isEqualTo(dataSize);
int count = 5;
Map<String, String> scanned = new HashMap<>();
ScanArgs args = ScanArgs.Builder.limit(count);
for (MapScanCursor<String, String> cursor = redis.hscan("hscan-count-test", args); ; cursor = redis.hscan("hscan-count-test", cursor, args)) {
scanned.putAll(cursor.getMap());
if (cursor.isFinished()) break;
assertThat(cursor.getMap()).hasSize(count);
}
assertThat(scanned)
.hasSize(dataSize)
.containsAllEntriesOf(content);
}
public void testHScanMatch() {
RedisCommands<String, String> redis = redisConnection.sync();
Map<String, String> content = new HashMap<>();
int dataSize = 15;
for (int i = 0; i < dataSize; i++) {
content.put("k" + i, "value" + i);
}
assertThat(redis.hmset("hscan-match-test", content)).isEqualTo("OK");
assertThat(redis.hlen("hscan-match-test")).isEqualTo(dataSize);
Map<String, String> scanned = new HashMap<>();
ScanArgs args = ScanArgs.Builder.matches("k1*");
for (MapScanCursor<String, String> cursor = redis.hscan("hscan-match-test", args); ; cursor = redis.hscan("hscan-match-test", cursor, args)) {
scanned.putAll(cursor.getMap());
for (String key : cursor.getMap().keySet()) {
assertThat(key).startsWith("k1");
}
if (cursor.isFinished()) break;
}
assertThat(scanned)
.hasSize(6)
.containsKeys("k1", "k10", "k11", "k12", "k13", "k14");
}
public void testKeySetOperation() {
RedisCommands<String, String> redis = redisConnection.sync();
assertThat(redis.hkeys("something")).asList().isEmpty();
Map<String, String> map = Map.of("key1", "value1", "key2", "value2", "key3", "value3");
assertThat(redis.hset("keyset-operation", map)).isEqualTo(3);
assertThat(redis.hkeys("keyset-operation")).asList()
.hasSize(3).containsAll(map.keySet());
assertWrongType(() -> redis.set("plain", "string"), () -> redis.hkeys("plain"));
}
public void testValuesOperation() {
RedisCommands<String, String> redis = redisConnection.sync();
assertThat(redis.hvals("something")).asList().isEmpty();
Map<String, String> map = Map.of("key1", "value1", "key2", "value2", "key3", "value3");
assertThat(redis.hset("values-operation", map)).isEqualTo(3);
assertThat(redis.hvals("values-operation")).asList()
.hasSize(3).containsAll(map.values());
assertWrongType(() -> redis.set("plain", "string"), () -> redis.hvals("plain"));
}
public void testPropertyExists() {
RedisCommands<String, String> redis = redisConnection.sync();
assertThat(redis.hexists("something", "key")).isFalse();
assertThat(redis.hset("exists-test", "key", "value")).isTrue();
assertThat(redis.hexists("exists-test", "key")).isTrue();
assertThat(redis.hexists("exists-test", "key2")).isFalse();
assertWrongType(() -> redis.set("plain", "string"), () -> redis.hexists("plain", "key"));
}
public void testSetAndGet() {
RedisCommands<String, String> redis = redisConnection.sync();
assertThat(redis.hdel("not-existent", "key1")).isEqualTo(0);
assertThat(redis.hgetall("not-existent")).isEmpty();
Map<String, String> map = Map.of("key1", "value1", "key2", "value2", "key3", "value3");
assertThat(redis.hset("HSET-HDEL", map))
.isEqualTo(3);
assertThat(redis.hgetall("HSET-HDEL")).containsAllEntriesOf(map);
assertThat(redis.hdel("HSET-HDEL", "key1")).isEqualTo(1);
assertThat(redis.hdel("HSET-HDEL", "key1")).isEqualTo(0);
assertThat(redis.hdel("HSET-HDEL", "key2", "key3", "key4")).isEqualTo(2);
assertThat(redis.hgetall("HSET-HDEL")).isEmpty();
assertWrongType(() -> redis.set("plain", "string"), () -> redis.hdel("plain", "key1"));
}
public void testIncrementOperations() {
RedisCommands<String, String> redis = redisConnection.sync();
assertThat(redis.hincrby("incr-test", "age", 5)).isEqualTo(5);
assertThat(redis.hincrby("incr-test", "age", 2)).isEqualTo(7);
assertThat(redis.hincrby("incr-test", "age", -3)).isEqualTo(4);
assertThat(redis.hincrby("incr-test", "age", 0)).isEqualTo(4);
// Now we verify if it is working with additional properties.
Map<String, String> map = Map.of("key1", "value1");
assertThat(redis.hset("incr-test", map)).isEqualTo(1);
assertThat(redis.hget("incr-test", "key1")).isEqualTo("value1");
assertThat(redis.hget("incr-test", "age")).isEqualTo("4");
// Incr does not work with something that is not a long.
assertThatThrownBy(() -> redis.hincrby("incr-test", "key1", 1))
.hasCauseInstanceOf(RedisCommandExecutionException.class)
.hasMessageContaining("value is not an integer or out of range");
assertThat(redis.hincrbyfloat("incr-test", "age", 0.5)).isEqualTo(4.5);
// Incrbyfloat only work with numbers.
assertThatThrownBy(() -> redis.hincrbyfloat("incr-test", "key1", 1))
.hasCauseInstanceOf(RedisCommandExecutionException.class)
.hasMessageContaining("value is not an integer or out of range");
// Since the value has an increment of 0.5, we can't use hincrby anymore, the value is not a long.
assertThatThrownBy(() -> redis.hincrby("incr-test", "age", 1))
.hasCauseInstanceOf(RedisCommandExecutionException.class)
.hasMessageContaining("value is not an integer or out of range");
// Increment by 0.5 leaves with a long value again.
assertThat(redis.hincrbyfloat("incr-test", "age", 0.5)).isEqualTo(5);
assertThat(redis.hincrby("incr-test", "age", -1)).isEqualTo(4);
assertThat(redis.hincrbyfloat("incr-test", "age", -0.5)).isEqualTo(3.5);
assertThat(redis.hget("incr-test", "key1")).isEqualTo("value1");
assertThat(redis.hget("incr-test", "age")).isEqualTo("3.5");
}
public void testHrandField() {
RedisCommands<String, String> redis = redisConnection.sync();
assertThat(redis.hrandfield("something")).isNull();
Map<String, String> map = Map.of("key1", "value1", "key2", "value2", "key3", "value3");
assertThat(redis.hset("hrand-operations", map)).isEqualTo(3);
assertThat(redis.hrandfield("hrand-operations")).isIn(map.keySet());
assertThat(redis.hrandfieldWithvalues("hrand-operations"))
.satisfies(kv -> assertThat(map.get(kv.getKey())).isEqualTo(kv.getValue()));
assertThat(redis.hrandfield("hrand-operations", 0)).isEmpty();
assertThat(redis.hrandfield("hrand-operations", 2)).hasSize(2);
assertThat(redis.hrandfieldWithvalues("hrand-operations", 2)).hasSize(2);
assertThat(redis.hrandfield("hrand-operations", 20)).hasSize(3);
assertThat(redis.hrandfieldWithvalues("hrand-operations", 20)).hasSize(3);
assertThat(redis.hrandfield("hrand-operations", -20)).hasSize(20);
assertThat(redis.hrandfieldWithvalues("hrand-operations", -20)).hasSize(20);
assertWrongType(() -> redis.set("plain", "string"), () -> redis.hrandfield("plain"));
}
public void testHMultiGet() {
RedisCommands<String, String> redis = redisConnection.sync();
assertThat(redis.hmget("something", "k1"))
.hasSize(1)
.contains(KeyValue.empty("k1"));
Map<String, String> map = Map.of("key1", "value1", "key2", "value2", "key3", "value3");
assertThat(redis.hset("hmget-operations", map)).isEqualTo(3);
assertThat(redis.hmget("hmget-operations", "key1", "key2", "key3"))
.hasSize(3)
.satisfies(entries -> entries.forEach(kv -> assertThat(map.get(kv.getKey())).isEqualTo(kv.getValue())));
assertThat(redis.hmget("hmget-operations", "key3", "key4"))
.hasSize(2)
.contains(KeyValue.just("key3", "value3"))
.contains(KeyValue.empty("key4"));
}
}
| 12,058
| 39.877966
| 148
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/RespMediaTypesTest.java
|
package org.infinispan.server.resp;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.resp.configuration.RespServerConfiguration;
import org.testng.annotations.Factory;
import org.testng.annotations.Test;
import java.util.ArrayList;
import java.util.List;
import static org.infinispan.server.resp.test.RespTestingUtil.createClient;
import static org.infinispan.server.resp.test.RespTestingUtil.startServer;
@Test(groups = "functional", testName = "server.resp.RespMediaTypesTest")
public class RespMediaTypesTest extends RespSingleNodeTest {
private MediaType keyType;
private MediaType valueType;
@Override
protected EmbeddedCacheManager createCacheManager() {
cacheManager = createTestCacheManager();
Configuration configuration = new ConfigurationBuilder()
.encoding()
.key().mediaType(keyType.toString())
.encoding()
.value().mediaType(valueType.toString())
.build();
RespServerConfiguration serverConfiguration = serverConfiguration().build();
cacheManager.defineConfiguration(serverConfiguration.defaultCacheName(), configuration);
server = startServer(cacheManager, serverConfiguration);
client = createClient(30000, server.getPort());
redisConnection = client.connect();
cache = cacheManager.getCache(server.getConfiguration().defaultCacheName());
return cacheManager;
}
private RespMediaTypesTest withKeyType(MediaType type) {
this.keyType = type;
return this;
}
private RespMediaTypesTest withValueType(MediaType type) {
this.valueType = type;
return this;
}
@Factory
public Object[] factory() {
List<RespMediaTypesTest> instances = new ArrayList<>();
MediaType[] types = new MediaType[] {
MediaType.APPLICATION_OCTET_STREAM,
MediaType.APPLICATION_OBJECT,
MediaType.TEXT_PLAIN,
};
for (MediaType key : types) {
for (MediaType value : types) {
instances.add(new RespMediaTypesTest().withKeyType(key).withValueType(value));
}
}
return instances.toArray();
}
@Override
protected String parameters() {
return String.format("[key=%s, value=%s]", keyType, valueType);
}
}
| 2,485
| 33.527778
| 94
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/RespListCommandsTest.java
|
package org.infinispan.server.resp;
import io.lettuce.core.LMoveArgs;
import io.lettuce.core.LPosArgs;
import io.lettuce.core.RedisCommandExecutionException;
import io.lettuce.core.api.sync.RedisCommands;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.infinispan.server.resp.test.RespTestingUtil.assertWrongType;
/**
* RESP List commands testing
*
* @since 15.0
*/
@Test(groups = "functional", testName = "server.resp.RespListCommandsTest")
public class RespListCommandsTest extends SingleNodeRespBaseTest {
RedisCommands<String, String> redis;
@BeforeMethod
public void initConnection() {
redis = redisConnection.sync();
}
public void testRPUSH() {
long result = redis.rpush("people", "tristan");
assertThat(result).isEqualTo(1);
result = redis.rpush("people", "william");
assertThat(result).isEqualTo(2);
result = redis.rpush("people", "william", "jose", "pedro");
assertThat(result).isEqualTo(5);
assertThat(redis.lrange("people", 0, 4)).containsExactly("tristan", "william", "william", "jose", "pedro");
assertWrongType(() -> redis.set("leads", "tristan"), () -> redis.rpush("leads", "william"));
}
public void testRPUSHX() {
long result = redis.rpushx("noexisting", "doraemon", "son goku");
assertThat(result).isEqualTo(0);
result = redis.rpush("existing", "tristan");
assertThat(result).isEqualTo(1);
result = redis.rpushx("existing", "william", "jose");
assertThat(result).isEqualTo(3);
assertThat(redis.lrange("existing", 0, 2)).containsExactly("tristan", "william", "jose");
assertWrongType(() -> redis.set("leads", "tristan"), () -> redis.rpushx("leads", "william"));
}
public void testLPUSH() {
long result = redis.lpush("people", "tristan");
assertThat(result).isEqualTo(1);
result = redis.lpush("people", "william");
assertThat(result).isEqualTo(2);
result = redis.lpush("people", "william", "jose", "pedro");
assertThat(result).isEqualTo(5);
assertThat(redis.lrange("people", 0, 4)).containsExactly("pedro", "jose", "william", "william", "tristan");
assertWrongType(() -> redis.set("leads", "tristan"), () -> redis.lpush("leads", "william"));
}
public void testLPUSHX() {
long result = redis.lpushx("noexisting", "doraemon", "son goku");
assertThat(result).isEqualTo(0);
result = redis.lpush("existing", "tristan");
assertThat(result).isEqualTo(1);
result = redis.lpushx("existing", "william", "jose");
assertThat(result).isEqualTo(3);
assertThat(redis.lrange("existing", 0, 2)).containsExactly("jose", "william", "tristan");
assertWrongType(() -> redis.set("leads", "tristan"), () -> redis.lpushx("leads", "william"));
}
public void testRPOP() {
assertThat(redis.rpop("not_exist")).isNull();
// test single value
assertThat(redis.rpush("leads", "tristan")).isEqualTo(1);
assertThat(redis.rpop("leads")).isEqualTo("tristan");
assertThat(redis.rpop("leads")).isNull();
// test multiple values
assertThat(redis.rpush("leads", "tristan", "jose", "william", "pedro")).isEqualTo(4);
assertThat(redis.rpop("leads", 0)).isEmpty();
assertThat(redis.rpop("leads", 3)).containsExactly( "pedro", "william", "jose");
assertThat(redis.rpop("leads", 1)).containsExactly("tristan");
assertThat(redis.rpop("leads")).isNull();
assertWrongType(() -> redis.set("leads", "tristan"), () -> redis.rpop("leads"));
// RPOP the count argument is negative
assertThatThrownBy(() -> {
redis.rpop("leads", -42);
}).isInstanceOf(RedisCommandExecutionException.class)
.hasMessageContaining("ERR value is out of range, must be positive");
}
public void testLPOP() {
assertThat(redis.lpop("not_exist")).isNull();
// test single value
assertThat(redis.rpush("leads", "tristan")).isEqualTo(1);
assertThat(redis.lpop("leads")).isEqualTo("tristan");
assertThat(redis.lpop("leads")).isNull();
// test multiple values
assertThat(redis.rpush("leads", "tristan", "jose", "william", "pedro")).isEqualTo(4);
assertThat(redis.lpop("leads", 0)).isEmpty();
assertThat(redis.lpop("leads", 3)).containsExactly( "tristan", "jose", "william");
assertThat(redis.lpop("leads", 1)).containsExactly("pedro");
assertThat(redis.lpop("leads")).isNull();
assertWrongType(() -> redis.set("leads", "tristan"), () -> redis.lpop("leads"));
// RPOP the count argument is negative
assertThatThrownBy(() -> {
redis.lpop("leads", -42);
}).isInstanceOf(RedisCommandExecutionException.class)
.hasMessageContaining("ERR value is out of range, must be positive");
}
public void testLINDEX() {
assertThat(redis.lindex("noexisting", 10)).isNull();
redis.rpush("leads", "tristan");
assertThat(redis.lindex("leads", 0)).isEqualTo("tristan");
assertThat(redis.lindex("leads", -1)).isEqualTo("tristan");
assertThat(redis.lindex("leads", 1)).isNull();
assertThat(redis.lindex("leads", -2)).isNull();
redis.rpush("leads", "william", "jose", "ryan", "pedro", "vittorio");
// size 6: ["tristan", "william", "jose", "ryan", "pedro", "vittorio"]
assertThat(redis.lindex("leads", 1)).isEqualTo("william");
assertThat(redis.lindex("leads", -1)).isEqualTo("vittorio");
assertThat(redis.lindex("leads", -6)).isEqualTo("tristan");
assertThat(redis.lindex("leads", 3)).isEqualTo("ryan");
assertThat(redis.lindex("leads", -3)).isEqualTo("ryan");
assertThat(redis.lindex("leads", 6)).isNull();
assertThat(redis.lindex("leads", -7)).isNull();
assertWrongType(() -> redis.set("another", "tristan"), () -> redis.lindex("another", 1));
}
public void testLLEN() {
assertThat(redis.llen("noexisting")).isEqualTo(0);
redis.rpush("leads", "william", "jose", "ryan", "pedro", "vittorio");
assertThat(redis.llen("leads")).isEqualTo(5);
assertWrongType(() -> redis.set("another", "tristan"), () -> redis.llen("another"));
}
public void testLRANGE() {
assertThat(redis.lrange("noexisting", -1, 3)).isEmpty();
redis.rpush("leads", "william", "jose", "ryan", "pedro", "vittorio");
assertThat(redis.lrange("leads", 0, 5)).containsExactly("william", "jose", "ryan", "pedro", "vittorio");
assertThat(redis.lrange("leads", 1, -1)).containsExactly("jose", "ryan", "pedro", "vittorio");
assertThat(redis.lrange("leads", 3, 3)).containsExactly("pedro");
assertWrongType(() -> redis.set("another", "tristan"), () -> redis.llen("another"));
}
public void testLSET() {
redis.rpush("leads", "william", "jose", "ryan", "pedro", "vittorio");
assertThat(redis.lset("leads", 0, "fabio")).isEqualTo("OK");
assertThat(redis.lindex("leads", 0)).isEqualTo("fabio");
assertThat(redis.lset("leads", -1, "tristan")).isEqualTo("OK");
assertThat(redis.lindex("leads", -1)).isEqualTo("tristan");
assertThat(redis.lset("leads", 2, "wolf")).isEqualTo("OK");
assertThat(redis.lindex("leads", 2)).isEqualTo("wolf");
assertThat(redis.lset("leads", -3, "anna")).isEqualTo("OK");
assertThat(redis.lindex("leads", -3)).isEqualTo("anna");
assertThatThrownBy(() -> {
redis.lset("leads", 5, "dan");
}).isInstanceOf(RedisCommandExecutionException.class)
.hasMessageContaining("ERR index out of range");
assertThatThrownBy(() -> {
redis.lset("leads", -6, "dan");
}).isInstanceOf(RedisCommandExecutionException.class)
.hasMessageContaining("ERR index out of range");
assertThatThrownBy(() -> {
redis.lset("not_existing", 0, "tristan");
}).isInstanceOf(RedisCommandExecutionException.class)
.hasMessageContaining("ERR no such key");
assertWrongType(() -> redis.set("another", "tristan"), () -> redis.lset("another", 0, "tristan"));
}
public void testLPOS() {
redis.rpush("leads", "william", "jose", "ryan", "pedro", "vittorio", "ryan", "michael", "ryan");
assertThat(redis.lpos("not_existing", "ryan")).isNull();
assertThat(redis.lpos("leads", "ramona")).isNull();
assertThat(redis.lpos("leads", "ryan")).isEqualTo(2);
assertThat(redis.lpos("leads", "ryan", LPosArgs.Builder.rank(1))).isEqualTo(2);
assertThat(redis.lpos("leads", "ryan", LPosArgs.Builder.rank(-1))).isEqualTo(7);
assertThat(redis.lpos("leads", "ryan", LPosArgs.Builder.rank(-2))).isEqualTo(5);
assertThat(redis.lpos("leads", "ryan", LPosArgs.Builder.rank(2))).isEqualTo(5);
assertThat(redis.lpos("leads", "ryan", LPosArgs.Builder.maxlen(3))).isEqualTo(2);
assertThat(redis.lpos("leads", "ryan", LPosArgs.Builder.maxlen(2))).isNull();
assertThat(redis.lpos("leads", "ryan", 0)).containsExactly(2L, 5L, 7L);
assertThat(redis.lpos("leads", "ryan", 1)).containsExactly(2L);
assertThat(redis.lpos("leads", "ryan", 2)).containsExactly(2L, 5L);
assertThat(redis.lpos("leads", "ryan", 3)).containsExactly(2L, 5L, 7L);
assertThat(redis.lpos("leads", "ryan", 10)).containsExactly(2L, 5L, 7L);
assertThat(redis.lpos("leads", "ryan", 0, LPosArgs.Builder.rank(2))).containsExactly(5L, 7L);
assertThat(redis.lpos("leads", "ryan", 2, LPosArgs.Builder.rank(-2))).containsExactly(5L, 2L);
assertThat(redis.lpos("leads", "ryan", 2, LPosArgs.Builder.rank(1))).containsExactly(2L, 5L);
assertThat(redis.lpos("leads", "ramona", 0)).isEmpty();
// LPOS on an existing key that contains a String, not a Collection!
assertThatThrownBy(() -> {
redis.lpos("leads", "ryan", LPosArgs.Builder.rank(0));
}).isInstanceOf(RedisCommandExecutionException.class)
.hasMessageContaining("ERR RANK can't be zero");
assertWrongType(() -> redis.set("another", "tristan"), () -> redis.lpos("another","tristan"));
}
public void testLINSERT() {
redis.rpush("leads", "william", "jose", "ryan", "pedro", "jose");
assertThat(redis.linsert("not_exsiting", true, "william", "fabio")).isEqualTo(0);
assertThat(redis.linsert("leads", true, "vittorio", "fabio")).isEqualTo(-1);
assertThat(redis.linsert("leads", true, "jose", "fabio")).isEqualTo(6);
assertThat(redis.lrange("leads",0, -1)).containsExactly("william", "fabio", "jose", "ryan", "pedro", "jose");
assertThat(redis.linsert("leads", false, "jose", "fabio")).isEqualTo(7);
assertThat(redis.lrange("leads",0, -1)).containsExactly("william", "fabio", "jose", "fabio", "ryan", "pedro", "jose");
assertWrongType(() -> redis.set("another", "tristan"), () -> redis.linsert("another", true,"tristan", "william"));
}
public void testLREM() {
redis.rpush("leads", "william", "jose", "ryan", "pedro", "jose", "pedro", "pedro", "tristan", "pedro");
assertThat(redis.lrem("not_existing", 1, "ramona")).isEqualTo(0);
assertThat(redis.lrem("leads", 1, "ramona")).isEqualTo(0);
assertThat(redis.lrem("leads", 1, "pedro")).isEqualTo(1);
assertThat(redis.lrange("leads", 0, -1)).containsExactly("william", "jose", "ryan", "jose", "pedro", "pedro", "tristan", "pedro");
assertThat(redis.lrem("leads", -2, "pedro")).isEqualTo(2);
assertThat(redis.lrange("leads", 0, -1)).containsExactly("william", "jose", "ryan", "jose", "pedro", "tristan");
assertThat(redis.lrem("leads", 0, "jose")).isEqualTo(2);
assertThat(redis.lrange("leads", 0, -1)).containsExactly("william", "ryan", "pedro", "tristan");
redis.lrem("leads", 0, "tristan");
redis.lrem("leads", 0, "william");
redis.lrem("leads", 0, "pedro");
assertThat(redis.exists("leads")).isEqualTo(1);
redis.lrem("leads", 0, "ryan");
assertThat(redis.exists("leads")).isEqualTo(0);
assertWrongType(() -> redis.set("another", "tristan"), () -> redis.lrem("another", 0,"tristan"));
}
public void testLTRIM() {
assertThat(redis.lrange("noexisting", -1, 3)).isEmpty();
redis.rpush("leads", "william", "jose", "ryan", "pedro", "vittorio");
assertThat(redis.ltrim("leads", 0, 2)).isEqualTo("OK");
assertThat(redis.lrange("leads", 0, -1)).containsExactly("william", "jose", "ryan");
assertThat(redis.ltrim("leads", 1, 1)).isEqualTo("OK");
assertThat(redis.lrange("leads", 0, -1)).containsExactly("jose");
assertThat(redis.ltrim("leads", 1, -1)).isEqualTo("OK");
assertThat(redis.exists("leads")).isEqualTo(0);
assertWrongType(() -> redis.set("another", "tristan"), () -> redis.ltrim("another", 0, 2));
}
public void testLMOVE() {
redis.rpush("leads", "william", "tristan", "pedro", "jose", "ryan");
assertThat(redis.lmove("not_existing", "leads", LMoveArgs.Builder.rightRight())).isNull();
// Rotate
assertThat(redis.lmove("leads", "leads", LMoveArgs.Builder.rightRight())).isEqualTo("ryan");
assertThat(redis.lrange("leads", 0, -1)).containsExactly("william", "tristan", "pedro", "jose", "ryan");
assertThat(redis.lmove("leads", "leads", LMoveArgs.Builder.leftLeft())).isEqualTo("william");
assertThat(redis.lrange("leads", 0, -1)).containsExactly("william", "tristan", "pedro", "jose", "ryan");
assertThat(redis.lmove("leads", "leads", LMoveArgs.Builder.leftRight())).isEqualTo("william");
assertThat(redis.lrange("leads", 0, -1)).containsExactly("tristan", "pedro", "jose", "ryan", "william");
assertThat(redis.lmove("leads", "leads", LMoveArgs.Builder.rightLeft())).isEqualTo("william");
assertThat(redis.lrange("leads", 0, -1)).containsExactly("william", "tristan", "pedro", "jose", "ryan");
// Move from two lists
redis.rpush("fantasy_leads", "doraemon", "son goku", "snape");
assertThat(redis.lmove("leads", "fantasy_leads", LMoveArgs.Builder.rightRight())).isEqualTo("ryan");
assertThat(redis.lrange("leads", 0, -1)).containsExactly("william", "tristan", "pedro", "jose");
assertThat(redis.lrange("fantasy_leads", 0, -1)).containsExactly("doraemon", "son goku", "snape", "ryan");
assertThat(redis.lmove("leads", "fantasy_leads", LMoveArgs.Builder.rightLeft())).isEqualTo("jose");
assertThat(redis.lrange("leads", 0, -1)).containsExactly("william", "tristan", "pedro");
assertThat(redis.lrange("fantasy_leads", 0, -1)).containsExactly("jose", "doraemon", "son goku", "snape", "ryan");
assertThat(redis.lmove("leads", "fantasy_leads", LMoveArgs.Builder.leftRight())).isEqualTo("william");
assertThat(redis.lrange("leads", 0, -1)).containsExactly("tristan", "pedro");
assertThat(redis.lrange("fantasy_leads", 0, -1)).containsExactly("jose", "doraemon", "son goku", "snape", "ryan", "william");
assertThat(redis.lmove("leads", "fantasy_leads", LMoveArgs.Builder.leftLeft())).isEqualTo("tristan");
assertThat(redis.lrange("leads", 0, -1)).containsExactly("pedro");
assertThat(redis.lrange("fantasy_leads", 0, -1)).containsExactly("tristan", "jose", "doraemon", "son goku", "snape", "ryan", "william");
assertThat(redis.lmove("leads", "new_leads", LMoveArgs.Builder.leftLeft())).isEqualTo("pedro");
assertThat(redis.lrange("leads", 0, -1)).isEmpty();
assertThat(redis.lrange("new_leads", 0, -1)).containsExactly("pedro");
assertWrongType(() -> redis.set("another", "tristan"), () -> redis.lmove("another", "another", LMoveArgs.Builder.leftRight()));
}
public void testRPOPLPUSH() {
redis.rpush("leads", "william", "tristan", "pedro", "jose", "ryan");
assertThat(redis.rpoplpush("not_existing", "leads")).isNull();
// Rotate
assertThat(redis.lrange("leads", 0, -1)).containsExactly("william", "tristan", "pedro", "jose", "ryan");
assertThat(redis.rpoplpush("leads", "leads")).isEqualTo("ryan");
assertThat(redis.lrange("leads", 0, -1)).containsExactly("ryan", "william", "tristan", "pedro", "jose");
// Move from two lists
redis.rpush("fantasy_leads", "doraemon", "son goku", "snape");
assertThat(redis.rpoplpush("leads", "fantasy_leads")).isEqualTo("jose");
assertThat(redis.lrange("leads", 0, -1)).containsExactly("ryan", "william", "tristan", "pedro");
assertThat(redis.lrange("fantasy_leads", 0, -1)).containsExactly("jose", "doraemon", "son goku", "snape");
assertThat(redis.rpoplpush("leads", "new_leads")).isEqualTo("pedro");
assertThat(redis.lrange("leads", 0, -1)).containsExactly("ryan", "william", "tristan");
assertThat(redis.lrange("new_leads", 0, -1)).containsExactly("pedro");
assertWrongType(() -> redis.set("another", "tristan"), () -> redis.rpoplpush("another", "another"));
}
}
| 16,989
| 47.821839
| 142
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/SortedSetCommandsTest.java
|
package org.infinispan.server.resp;
import io.lettuce.core.Range;
import io.lettuce.core.ScoredValue;
import io.lettuce.core.ZAddArgs;
import io.lettuce.core.api.sync.RedisCommands;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import static io.lettuce.core.Range.Boundary.excluding;
import static io.lettuce.core.Range.Boundary.including;
import static io.lettuce.core.ScoredValue.just;
import static org.assertj.core.api.Assertions.assertThat;
import static org.infinispan.server.resp.test.RespTestingUtil.assertWrongType;
/**
* RESP Sorted set commands testing
*
* @since 15.0
*/
@Test(groups = "functional", testName = "server.resp.SortedSetCommandsTest")
public class SortedSetCommandsTest extends SingleNodeRespBaseTest {
RedisCommands<String, String> redis;
@BeforeMethod
public void initConnection() {
redis = redisConnection.sync();
}
public void testZADD() {
assertThat(redis.zadd("people", 10.4, "william")).isEqualTo(1);
assertThat(redis.zrangeWithScores("people", 1, -1))
.containsExactly(just(10.4, "william"));
assertThat(redis.zadd("people", just(13.4, "tristan"))).isEqualTo(1);
assertThat(redis.zrangeWithScores("people", 1, -1))
.containsExactly(just(10.4, "william"), just(13.4, "tristan"));
assertThat(redis.zadd("people", just(13.4, "jose"))).isEqualTo(1);
assertThat(redis.zrangeWithScores("people", 1, -1))
.containsExactly(just(10.4, "william"), just(13.4, "jose"), just(13.4, "tristan"));
assertThat(redis.zadd("people", just(13.4, "xavier"))).isEqualTo(1);
assertThat(redis.zrangeWithScores("people", 1, -1))
.containsExactly(just(10.4, "william"), just(13.4, "jose"), just(13.4, "tristan"), just(13.4, "xavier"));
// count changes too
assertThat(redis.zadd("people", ZAddArgs.Builder.ch(),
just(18.9, "fabio"),
just(21.9, "marc")))
.isEqualTo(2);
assertThat(redis.zrangeWithScores("people", 1, -1))
.containsExactly(just(10.4, "william"), just(13.4, "jose"),
just(13.4, "tristan"), just(13.4, "xavier"),
just(18.9, "fabio"), just(21.9, "marc"));
// Adds only
assertThat(redis.zadd("people", ZAddArgs.Builder.nx(),
just(0.8, "fabio"),
just(0.9, "xavier"),
just(1.0, "ryan")))
.isEqualTo(1);
assertThat(redis.zrangeWithScores("people", 1, -1))
.containsExactly(just(1.0, "ryan"), just(10.4, "william"), just(13.4, "jose"),
just(13.4, "tristan"), just(13.4, "xavier"),
just(18.9, "fabio"), just(21.9, "marc"));
// Updates only
assertThat(redis.zadd("people", ZAddArgs.Builder.xx(),
just(0.8, "fabio"),
just(0.9, "xavier"),
just(1.0, "katia")))
.isEqualTo(0);
assertThat(redis.zrangeWithScores("people", 1, -1))
.containsExactly(just(0.8, "fabio"), just(0.9, "xavier"), just(1.0, "ryan"),
just(10.4, "william"), just(13.4, "jose"),
just(13.4, "tristan"), just(21.9, "marc"));
// Updates greater scores and add new values
assertThat(redis.zadd("people", ZAddArgs.Builder.gt(),
just(13, "fabio"), // changes to 13 because 13 (new) is greater than 0.8 (current)
just(0.5, "xavier"), // stays 0.9 because 0.5 (new) is less than 0.9 (current)
just(2, "katia"))) // added
.isEqualTo(1);
assertThat(redis.zrangeWithScores("people", 1, -1))
.containsExactly(just(0.9, "xavier"), just(1.0, "ryan"), just(2, "katia"),
just(10.4, "william"), just(13, "fabio"), just(13.4, "jose"),
just(13.4, "tristan"), just(21.9, "marc"));
// Updates less than scores and add new values
assertThat(redis.zadd("people", ZAddArgs.Builder.lt(),
just(100, "fabio"), // stays 13 because 100 (new) is greater than 13 (current)
just(0.3, "xavier"), // changes to 0.3 because 0.3 (new) is less than 0.5 (current)
just(0.2, "vittorio"))) // added
.isEqualTo(1);
assertThat(redis.zrangeWithScores("people", 1, -1))
.containsExactly(just(0.2, "vittorio"), just(0.3, "xavier"),
just(1.0, "ryan"), just(2, "katia"),
just(10.4, "william"), just(13, "fabio"), just(13.4, "jose"),
just(13.4, "tristan"), just(21.9, "marc"));
assertWrongType(() -> redis.set("another", "tristan"), () -> redis.zadd("another", 2.3, "tristan"));
}
public void testZCARD() {
assertThat(redis.zcard("not_existing")).isEqualTo(0);
assertThat(redis.zadd("people", ZAddArgs.Builder.ch(),
just(18.9, "fabio"),
just(21.9, "marc")))
.isEqualTo(2);
assertThat(redis.zcard("people")).isEqualTo(2);
assertWrongType(() -> redis.set("another", "tristan"), () -> redis.zcard("another"));
}
public void testZCOUNT() {
Range<Double> unbounded = Range.unbounded();
assertThat(redis.zcount("not_existing", unbounded)).isEqualTo(0);
redis.zadd("people", ZAddArgs.Builder.ch(),
ScoredValue.just(-10, "tristan"),
ScoredValue.just(1, "ryan"),
ScoredValue.just(17, "vittorio"),
ScoredValue.just(18.9, "fabio"),
ScoredValue.just(18.9, "jose"),
ScoredValue.just(18.9, "katia"),
ScoredValue.just(21.9, "marc"));
assertThat(redis.zcard("people")).isEqualTo(7);
assertThat(redis.zcount("people", unbounded)).isEqualTo(7);
assertThat(redis.zcount("people", Range.from(including(-10d), including(21.9d)))).isEqualTo(7);
assertThat(redis.zcount("people", Range.from(including(-11d), including(22.9d)))).isEqualTo(7);
assertThat(redis.zcount("people", Range.from(including(1d), including(17d)))).isEqualTo(2);
assertThat(redis.zcount("people", Range.from(including(0d), including(18d)))).isEqualTo(2);
assertThat(redis.zcount("people", Range.from(including(0d), including(18.9d)))).isEqualTo(5);
assertThat(redis.zcount("people", Range.from(including(18.9d), including(22d)))).isEqualTo(4);
assertThat(redis.zcount("people", Range.from(excluding(1d), including(19)))).isEqualTo(4);
assertThat(redis.zcount("people", Range.from(including(1d), excluding(19)))).isEqualTo(5);
assertThat(redis.zcount("people", Range.from(including(-10d), excluding(18.9)))).isEqualTo(3);
assertThat(redis.zcount("people", Range.from(including(-10d), excluding(-10.d)))).isEqualTo(0);
assertThat(redis.zcount("people", Range.from(excluding(-10d), including(-10.d)))).isEqualTo(0);
assertThat(redis.zcount("people", Range.from(including(-10d), including(-10.d)))).isEqualTo(1);
assertThat(redis.zcount("people", Range.from(excluding(-10d), excluding(-10.d)))).isEqualTo(0);
assertThat(redis.zcount("people", Range.from(including(18.9d), excluding(18.9d)))).isEqualTo(0);
assertThat(redis.zcount("people", Range.from(excluding(18.9d), excluding(18.9d)))).isEqualTo(0);
assertThat(redis.zcount("people", Range.from(including(18.9d), including(18.9d)))).isEqualTo(3);
assertThat(redis.zcount("people", Range.from(excluding(18.9d), including(18.9d)))).isEqualTo(0);
redis.zadd("manyduplicates", ZAddArgs.Builder.ch(),
ScoredValue.just(1, "a"),
ScoredValue.just(1, "b"),
ScoredValue.just(1, "c"),
ScoredValue.just(2, "d"),
ScoredValue.just(2, "e"),
ScoredValue.just(2, "f"),
ScoredValue.just(2, "g"),
ScoredValue.just(2, "h"),
ScoredValue.just(2, "i"),
ScoredValue.just(3, "j"),
ScoredValue.just(3, "k"),
ScoredValue.just(3, "l"),
ScoredValue.just(3, "m"),
ScoredValue.just(3, "n"));
assertThat(redis.zcount("manyduplicates",
Range.from(including(1), including(3)))).isEqualTo(14);
assertThat(redis.zcount("manyduplicates",
Range.from(excluding(1), excluding(3)))).isEqualTo(6);
assertThat(redis.zcount("manyduplicates",
Range.from(including(1), excluding(2)))).isEqualTo(3);
assertThat(redis.zcount("manyduplicates",
Range.from(excluding(1), including(2)))).isEqualTo(6);
assertThat(redis.zcount("manyduplicates",
Range.from(including(1), including(1)))).isEqualTo(3);
assertThat(redis.zcount("manyduplicates",
Range.from(including(2), including(2)))).isEqualTo(6);
assertThat(redis.zcount("manyduplicates",
Range.from(including(3), including(3)))).isEqualTo(5);
assertThat(redis.zcount("manyduplicates",
Range.from(including(1.5), excluding(2.1)))).isEqualTo(6);
assertThat(redis.zcount("manyduplicates",
Range.from(excluding(1), excluding(2)))).isEqualTo(0);
assertThat(redis.zcount("manyduplicates",
Range.from(excluding(2.5), excluding(3)))).isEqualTo(0);
assertThat(redis.zcount("manyduplicates",
Range.from(including(1), excluding(3)))).isEqualTo(9);
assertWrongType(() -> redis.set("another", "tristan"), () -> redis.zcount("another", unbounded));
}
public void testZPOPMIN() {
assertThat(redis.zpopmin("not_existing").isEmpty()).isTrue();
assertThat(redis.zpopmin("not_existing", 2)).isEmpty();
redis.zadd("people", ZAddArgs.Builder.ch(),
ScoredValue.just(-10, "tristan"),
ScoredValue.just(1, "ryan"),
ScoredValue.just(17, "vittorio"),
ScoredValue.just(18.9, "fabio"),
ScoredValue.just(18.9, "jose"),
ScoredValue.just(18.9, "katia"),
ScoredValue.just(21.9, "marc"));
assertThat(redis.zcard("people")).isEqualTo(7);
assertThat(redis.zpopmin("people")).isEqualTo(just(-10.0, "tristan"));
assertThat(redis.zcard("people")).isEqualTo(6);
assertThat(redis.zpopmin("people", 2))
.containsExactly(just(1, "ryan"), just(17, "vittorio"));
assertThat(redis.zcard("people")).isEqualTo(4);
redis.zpopmin("people", 10);
assertThat(redis.exists("people")).isEqualTo(0);
assertWrongType(() -> redis.set("another", "tristan"), () -> redis.zpopmin("another"));
}
public void testZPOPMAX() {
assertThat(redis.zpopmax("not_existing").isEmpty()).isTrue();
assertThat(redis.zpopmax("not_existing", 2)).isEmpty();
redis.zadd("people", ZAddArgs.Builder.ch(),
ScoredValue.just(-10, "tristan"),
ScoredValue.just(1, "ryan"),
ScoredValue.just(17, "vittorio"),
ScoredValue.just(18.9, "fabio"),
ScoredValue.just(18.9, "jose"),
ScoredValue.just(18.9, "katia"),
ScoredValue.just(21.9, "marc"));
assertThat(redis.zcard("people")).isEqualTo(7);
assertThat(redis.zpopmax("people")).isEqualTo(just(21.9, "marc"));
assertThat(redis.zcard("people")).isEqualTo(6);
assertThat(redis.zpopmax("people", 2))
.containsExactly(just(18.9, "katia"), just(18.9, "jose"));
assertThat(redis.zcard("people")).isEqualTo(4);
redis.zpopmax("people", 10);
assertThat(redis.exists("people")).isEqualTo(0);
assertWrongType(() -> redis.set("another", "tristan"), () -> redis.zpopmax("another"));
}
public void testZSCORE() {
assertThat(redis.zscore("not_existing", "no_existing")).isNull();
redis.zadd("people", ZAddArgs.Builder.ch(),
ScoredValue.just(-10, "tristan"),
ScoredValue.just(1, "ryan"),
ScoredValue.just(17, "vittorio"),
ScoredValue.just(18.9, "fabio"),
ScoredValue.just(18.9, "jose"),
ScoredValue.just(18.9, "katia"),
ScoredValue.just(21.9, "marc"));
assertThat(redis.zscore("people", "jose")).isEqualTo(18.9);
assertThat(redis.zscore("people", "takolo")).isNull();
assertWrongType(() -> redis.set("another", "tristan"), () -> redis.zscore("another", "tristan"));
}
}
| 12,236
| 46.247104
| 118
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/RespTwoNodeTest.java
|
package org.infinispan.server.resp;
import io.lettuce.core.RedisFuture;
import io.lettuce.core.api.async.RedisAsyncCommands;
import org.infinispan.Cache;
import org.infinispan.distribution.DistributionTestHelper;
import org.infinispan.interceptors.locking.ClusteringDependentLogic;
import org.infinispan.server.resp.test.CommonRespTests;
import org.infinispan.test.Mocks;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.CheckPoint;
import org.testng.annotations.Test;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.infinispan.server.resp.test.RespTestingUtil.OK;
import static org.infinispan.server.resp.test.RespTestingUtil.PONG;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
@Test(groups = "functional", testName = "server.resp.RespTwoNodeTest")
public class RespTwoNodeTest extends BaseMultipleRespTest {
public void testConcurrentOperations() throws ExecutionException, InterruptedException, TimeoutException {
CheckPoint checkPoint = new CheckPoint();
checkPoint.triggerForever(Mocks.AFTER_RELEASE);
String blockedKey = "foo";
// We block the non owner, so we know the primary owner of the data's netty thread isn't blocked on accident
Cache<String, String> nonOwner = DistributionTestHelper.getFirstBackupOwner(blockedKey, caches(server1.getConfiguration().defaultCacheName()));
var original = Mocks.blockingMock(checkPoint, ClusteringDependentLogic.class, nonOwner, (stubber, clusteringDependentLogic) ->
stubber.when(clusteringDependentLogic).commitEntry(any(), any(), any(), any(), anyBoolean()));
RedisAsyncCommands<String, String> redis = redisConnection1.async();
try {
RedisFuture<String> futureSet = redis.set(blockedKey, "bar");
checkPoint.awaitStrict(Mocks.BEFORE_INVOCATION, 10, TimeUnit.SECONDS);
RedisFuture<String> futurePing = redis.ping();
RedisFuture<List<Object>> futureCommand = redis.command();
checkPoint.triggerForever(Mocks.BEFORE_RELEASE);
String getResponse = futurePing.get(10, TimeUnit.SECONDS);
assertThat(futureSet.get(10, TimeUnit.SECONDS)).isEqualTo(OK);
assertThat(getResponse).isEqualTo(PONG);
List<Object> results = futureCommand.get(10, TimeUnit.SECONDS);
assertThat(results).hasSizeGreaterThan(10);
} finally {
TestingUtil.replaceComponent(nonOwner, ClusteringDependentLogic.class, original, true);
}
RedisFuture<String> getFuture = redis.get(blockedKey);
assertThat(getFuture.get(10, TimeUnit.SECONDS)).isEqualTo("bar");
}
public void testPipeline() throws ExecutionException, InterruptedException, TimeoutException {
CommonRespTests.testPipeline(redisConnection1);
}
}
| 2,991
| 44.333333
| 149
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/RespServerTest.java
|
package org.infinispan.server.resp;
import static org.testng.AssertJUnit.assertEquals;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.server.core.test.Stoppable;
import org.infinispan.server.resp.configuration.RespServerConfiguration;
import org.infinispan.server.resp.configuration.RespServerConfigurationBuilder;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
/**
* Resp server unit test.
*
* @author William Burns
* @since 14.0
*/
@Test(groups = "functional", testName = "server.resp.RespServerTest")
public class RespServerTest extends AbstractInfinispanTest {
public void testValidateDefaultConfiguration() {
Stoppable.useCacheManager(TestCacheManagerFactory.createCacheManager(), cm ->
Stoppable.useServer(new RespServer(), ms -> {
ms.start(new RespServerConfigurationBuilder().port(0).build(), cm);
assertEquals(ms.getHost(), "127.0.0.1");
assertEquals(ms.getCache().getName(), RespServerConfiguration.DEFAULT_RESP_CACHE);
}));
}
public void testExpiration() {
ConfigurationBuilder config = new ConfigurationBuilder();
config.expiration().lifespan(10);
Stoppable.useCacheManager(TestCacheManagerFactory.createCacheManager(config), cm ->
Stoppable.useServer(new RespServer(), ms -> {
ms.start(new RespServerConfigurationBuilder().port(0).defaultCacheName(cm.getCacheManagerConfiguration().defaultCacheName().get()).build(), cm);
assertEquals(10, ms.getCache().getCacheConfiguration().expiration().lifespan());
}));
}
public void testNoDefaultConfigurationLocal() {
GlobalConfigurationBuilder global = new GlobalConfigurationBuilder();
Stoppable.useCacheManager(new DefaultCacheManager(global.build()), cm ->
Stoppable.useServer(new RespServer(), ms -> {
ms.start(new RespServerConfigurationBuilder().port(0).build(), cm);
assertEquals(CacheMode.LOCAL, ms.getCache().getCacheConfiguration().clustering().cacheMode());
}));
}
public void testNoDefaultConfigurationClustered() {
GlobalConfigurationBuilder global = GlobalConfigurationBuilder.defaultClusteredBuilder();
Stoppable.useCacheManager(new DefaultCacheManager(global.build()), cm ->
Stoppable.useServer(new RespServer(), ms -> {
ms.start(new RespServerConfigurationBuilder().port(0).build(), cm);
assertEquals(CacheMode.REPL_SYNC, ms.getCache().getCacheConfiguration().clustering().cacheMode());
}));
}
}
| 2,892
| 45.66129
| 159
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/RespAuthSingleNodeTest.java
|
package org.infinispan.server.resp;
import java.lang.reflect.Method;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import javax.security.auth.Subject;
import javax.security.sasl.SaslException;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.server.resp.authentication.RespAuthenticator;
import org.infinispan.server.resp.configuration.RespServerConfigurationBuilder;
import org.infinispan.test.fwk.CleanupAfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import io.lettuce.core.RedisCommandExecutionException;
import io.lettuce.core.api.sync.RedisCommands;
import io.lettuce.core.pubsub.api.sync.RedisPubSubCommands;
import io.netty.channel.Channel;
/**
* Test single node with authentication enabled.
*
* @author Jose Bolina
* @since 14.0
*/
@CleanupAfterMethod
@Test(groups = "functional", testName = "server.resp.RespAuthSingleNodeTest")
public class RespAuthSingleNodeTest extends RespSingleNodeTest {
private static final String USERNAME = "admin";
private static final String PASSWORD = "super-password";
@Override
protected RespServerConfigurationBuilder serverConfiguration() {
RespServerConfigurationBuilder builder = super.serverConfiguration();
builder.authentication()
.enable()
.authenticator(new FakeRespAuthenticator());
return builder;
}
@BeforeMethod(alwaysRun = true)
public void authenticateBefore(Method method) {
if (method.getName().endsWith("Auth")) return;
RedisCommands<String, String> redis = redisConnection.sync();
redis.auth(USERNAME, PASSWORD);
}
@Override
protected void teardown() {
super.destroyAfterClass();
}
@Override
public void testAuth() {
// Try auth with wrong user/pass
super.testAuth();
// This method did not issue AUTH, so this should be unauthorized.
RedisCommands<String, String> redis = redisConnection.sync();
Exceptions.expectException(RedisCommandExecutionException.class,
"WRONGPASS invalid username-password pair or user is disabled\\.",
() -> redis.set("k", "v"));
}
@Override
protected RedisPubSubCommands<String, String> createPubSubConnection() {
RedisPubSubCommands<String, String> connection = super.createPubSubConnection();
connection.auth(USERNAME, PASSWORD);
return connection;
}
public static class FakeRespAuthenticator implements RespAuthenticator {
@Override
public CompletionStage<Subject> clientCertAuth(Channel channel) throws SaslException {
return CompletableFutures.completedNull();
}
@Override
public CompletionStage<Subject> usernamePasswordAuth(String username, char[] password) {
if (username.equals(USERNAME) && new String(password).equals(PASSWORD)) {
return CompletableFuture.completedFuture(new Subject());
}
return CompletableFutures.completedNull();
}
@Override
public boolean isClientCertAuthEnabled() {
return false;
}
}
}
| 3,211
| 32.113402
| 94
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/SingleNodeRespBaseTest.java
|
package org.infinispan.server.resp;
import static org.infinispan.server.resp.test.RespTestingUtil.createClient;
import static org.infinispan.server.resp.test.RespTestingUtil.killClient;
import static org.infinispan.server.resp.test.RespTestingUtil.killServer;
import static org.infinispan.server.resp.test.RespTestingUtil.startServer;
import org.infinispan.commons.test.TestResourceTracker;
import org.infinispan.commons.time.ControlledTimeService;
import org.infinispan.commons.time.TimeService;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.distribution.ch.impl.CRC16HashFunctionPartitioner;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.resp.configuration.RespServerConfiguration;
import org.infinispan.server.resp.configuration.RespServerConfigurationBuilder;
import org.infinispan.server.resp.test.RespTestingUtil;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.infinispan.test.fwk.TransportFlags;
import org.testng.annotations.AfterClass;
import io.lettuce.core.RedisClient;
import io.lettuce.core.api.StatefulRedisConnection;
public abstract class SingleNodeRespBaseTest extends SingleCacheManagerTest {
protected RedisClient client;
protected RespServer server;
protected StatefulRedisConnection<String, String> redisConnection;
protected static final int timeout = 60;
protected final TimeService timeService = new ControlledTimeService();
@Override
protected EmbeddedCacheManager createCacheManager() {
cacheManager = createTestCacheManager();
RespServerConfiguration serverConfiguration = serverConfiguration().build();
server = startServer(cacheManager, serverConfiguration);
client = createClient(30000, server.getPort());
redisConnection = client.connect();
cache = cacheManager.getCache(server.getConfiguration().defaultCacheName());
return cacheManager;
}
protected EmbeddedCacheManager createTestCacheManager() {
GlobalConfigurationBuilder globalBuilder = new GlobalConfigurationBuilder().nonClusteredDefault();
TestCacheManagerFactory.amendGlobalConfiguration(globalBuilder, new TransportFlags());
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.clustering().hash().keyPartitioner(new CRC16HashFunctionPartitioner()).numSegments(256);
EmbeddedCacheManager cacheManager = TestCacheManagerFactory.newDefaultCacheManager(true, globalBuilder, builder);
TestingUtil.replaceComponent(cacheManager, TimeService.class, timeService, true);
return cacheManager;
}
protected RespServerConfigurationBuilder serverConfiguration() {
String serverName = TestResourceTracker.getCurrentTestShortName();
return new RespServerConfigurationBuilder().name(serverName)
.host(RespTestingUtil.HOST)
.port(RespTestingUtil.port());
}
@AfterClass(alwaysRun = true)
@Override
protected void destroyAfterClass() {
super.destroyAfterClass();
log.debug("Test finished, close resp server");
killClient(client);
killServer(server);
}
}
| 3,297
| 45.450704
| 119
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/BaseMultipleRespTest.java
|
package org.infinispan.server.resp;
import static org.infinispan.server.resp.test.RespTestingUtil.createClient;
import static org.infinispan.server.resp.test.RespTestingUtil.killClient;
import static org.infinispan.server.resp.test.RespTestingUtil.killServer;
import org.infinispan.commons.test.TestResourceTracker;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.distribution.ch.impl.CRC16HashFunctionPartitioner;
import org.infinispan.server.resp.configuration.RespServerConfigurationBuilder;
import org.infinispan.server.resp.test.RespTestingUtil;
import org.infinispan.test.MultipleCacheManagersTest;
import org.testng.annotations.AfterClass;
import io.lettuce.core.RedisClient;
import io.lettuce.core.api.StatefulRedisConnection;
public abstract class BaseMultipleRespTest extends MultipleCacheManagersTest {
protected RedisClient client1;
protected RedisClient client2;
protected RespServer server1;
protected RespServer server2;
protected StatefulRedisConnection<String, String> redisConnection1;
protected StatefulRedisConnection<String, String> redisConnection2;
protected static final int timeout = 60;
@Override
protected void createCacheManagers() {
ConfigurationBuilder cacheBuilder = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, false);
amendCacheConfiguration(cacheBuilder);
cacheBuilder.clustering().hash().keyPartitioner(new CRC16HashFunctionPartitioner()).numSegments(256);
createCluster(cacheBuilder, 2);
waitForClusterToForm();
server1 = RespTestingUtil.startServer(cacheManagers.get(0), serverConfiguration(0).build());
server2 = RespTestingUtil.startServer(cacheManagers.get(1), serverConfiguration(1).build());
client1 = createClient(30000, server1.getPort());
client2 = createClient(30000, server2.getPort());
redisConnection1 = client1.connect();
redisConnection2 = client2.connect();
}
@AfterClass(alwaysRun = true)
@Override
protected void destroy() {
log.debug("Test finished, close resp server");
killClient(client1);
killClient(client2);
killServer(server1);
killServer(server2);
super.destroy();
}
protected RespServerConfigurationBuilder serverConfiguration(int offset) {
String serverName = TestResourceTracker.getCurrentTestShortName();
return new RespServerConfigurationBuilder().name(serverName)
.host(RespTestingUtil.HOST)
.port(RespTestingUtil.port() + offset);
}
protected void amendCacheConfiguration(ConfigurationBuilder builder) {
}
}
| 2,677
| 39.575758
| 107
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/RespSetCommandsTest.java
|
package org.infinispan.server.resp;
import static org.assertj.core.api.Assertions.assertThat;
import static org.infinispan.server.resp.test.RespTestingUtil.assertWrongType;
import org.testng.annotations.Test;
import io.lettuce.core.api.sync.RedisCommands;
@Test(groups = "functional", testName = "server.resp.RespSetCommandsTest")
public class RespSetCommandsTest extends SingleNodeRespBaseTest {
@Test
public void testSadd() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "sadd";
Long newValue = redis.sadd(key, "1", "2", "3");
assertThat(newValue.longValue()).isEqualTo(3L);
newValue = redis.sadd(key, "4", "5");
assertThat(newValue.longValue()).isEqualTo(2L);
newValue = redis.sadd(key, "5", "6");
assertThat(newValue.longValue()).isEqualTo(1L);
// SADD on an existing key that contains a String, not a Set!
// Set a String Command
assertWrongType(() -> redis.set("leads", "tristan"), () -> redis.sadd("leads", "william"));
// SADD on an existing key that contains a List, not a Set!
// Create a List
assertWrongType(() -> redis.lpush("listleads", "tristan"), () -> redis.sadd("listleads", "william"));
}
@Test
public void testSmembers() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "smembers";
redis.sadd(key, "e1", "e2", "e3");
assertThat(redis.smembers(key)).containsExactlyInAnyOrder("e1","e2","e3");
assertThat(redis.smembers("nonexistent")).isEmpty();
// SMEMBER on an existing key that contains a String, not a Set!
// Set a String Command
assertWrongType(() -> redis.set("leads", "tristan"), () -> redis.smembers("leads"));
// SMEMBER on an existing key that contains a List, not a Set!
// Create a List
assertWrongType(() -> redis.rpush("listleads", "tristan"), () -> redis.smembers("listleads"));
}
@Test
public void testScard() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "smembers";
redis.sadd(key, "e1", "e2", "e3");
assertThat(redis.scard(key)).isEqualTo(3);
assertThat(redis.scard("nonexistent")).isEqualTo(0);
// SCARD on an existing key that contains a String, not a Set!
// Set a String Command
assertWrongType(() -> redis.set("leads", "tristan"), () -> redis.scard("leads"));
// SCARD on an existing key that contains a List, not a Set!
// Create a List
assertWrongType(() -> redis.rpush("listleads", "tristan"), () -> redis.scard("listleads"));
}
@Test
public void testSinter() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "sinter";
redis.sadd(key, "e1", "e2", "e3");
// sinter with one set returns the set
assertThat(redis.sinter(key)).containsExactlyInAnyOrder("e1","e2","e3");
String key1 = "sinter1";
redis.sadd(key1, "e2", "e3", "e4");
// check intersection between 2 sets
assertThat(redis.sinter(key,key1)).containsExactlyInAnyOrder("e2","e3");
// intersect non existent sets returns empty set
assertThat(redis.sinter("nonexistent", "nonexistent1")).isEmpty();
assertThat(redis.sinter(key,key1,"nonexistent")).isEmpty();
// SINTER on an existing key that contains a String, not a Set!
// Set a String Command
assertWrongType(() -> redis.set("leads", "tristan"), () -> redis.sinter("leads", key));
// SINTER on an existing key that contains a List, not a Set!
// Create a List
assertWrongType(() -> redis.rpush("listleads", "tristan"), () -> redis.sinter("listleads", "william"));
}
@Test
public void testSintercard() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "sinter";
redis.sadd(key, "e1", "e2", "e3");
assertThat(redis.sintercard(key)).isEqualTo(3);
String key1 = "sinter1";
redis.sadd(key1, "e2", "e3", "e4");
assertThat(redis.sintercard(key,key1)).isEqualTo(2);
assertThat(redis.sintercard(1, key,key1)).isEqualTo(1);
assertThat(redis.sintercard("nonexistent", "nonexistent1")).isEqualTo(0);
assertThat(redis.sintercard(key,key1,"nonexistent")).isEqualTo(0);
// SINTERCARD on an existing key that contains a String, not a Set!
// Set a String Command
assertWrongType(() -> redis.set("leads", "tristan"), () -> redis.sintercard("leads", key));
// SINTERCARD on an existing key that contains a List, not a Set!
// Create a List
assertWrongType(() -> redis.rpush("listleads", "tristan"), () -> redis.sintercard("listleads", "william"));
}
@Test
public void testSinterstore() {
RedisCommands<String, String> redis = redisConnection.sync();
String key = "sinter";
redis.sadd(key, "e1", "e2", "e3");
assertThat(redis.sinterstore("destination", key)).isEqualTo(3);
String key1 = "sinter1";
redis.sadd(key1, "e2", "e3", "e4");
assertThat(redis.sinterstore("destination", key,key1)).isEqualTo(2);
assertThat(redis.smembers("destination")).containsExactlyInAnyOrder("e2","e3");
assertThat(redis.sinterstore("destination", "nonexistent", "nonexistent1")).isEqualTo(0);
assertThat(redis.smembers("destination")).isEmpty();
// SINTERSTORE on an existing key that contains a String, not a Set!
// Set a String Command
assertWrongType(() -> redis.set("leads", "tristan"), () -> redis.sinterstore("destination", "leads", key));
// SINTERSTORE on an existing key that contains a List, not a Set!
// Create a List
assertWrongType(() -> redis.rpush("listleads", "tristan"), () -> redis.sinterstore("destination", "listleads", "william"));
}
}
| 6,011
| 43.205882
| 131
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/test/RespTestingUtil.java
|
package org.infinispan.server.resp.test;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.time.Duration;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicInteger;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.commons.test.TestResourceTracker;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.core.logging.Log;
import org.infinispan.server.resp.RespServer;
import org.infinispan.server.resp.configuration.RespServerConfiguration;
import org.infinispan.server.resp.configuration.RespServerConfigurationBuilder;
import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisCommandExecutionException;
/**
* Utils for RESP tests.
*
* @author William Burns
* @since 14.0
*/
public class RespTestingUtil {
private static final Log log = LogFactory.getLog(RespTestingUtil.class, Log.class);
public static final String OK = "OK";
public static final String PONG = "PONG";
public static final String HOST = "127.0.0.1";
public static RedisClient createClient(long timeout, int port) {
RedisClient client = RedisClient.create("redis://" + HOST + ":" + port);
client.setDefaultTimeout(Duration.ofMillis(timeout));
return client;
}
public static RespServer startServer(EmbeddedCacheManager cacheManager) {
return startServer(cacheManager, UniquePortThreadLocal.INSTANCE.get());
}
public static RespServer startServer(EmbeddedCacheManager cacheManager, int port) {
String serverName = TestResourceTracker.getCurrentTestShortName();
return startServer(cacheManager, new RespServerConfigurationBuilder().name(serverName).host(HOST).port(port)
.build());
}
public static RespServer startServer(EmbeddedCacheManager cacheManager, RespServerConfiguration configuration) {
RespServer server = new RespServer();
server.start(configuration, cacheManager);
return server;
}
public static RespServer startServer(EmbeddedCacheManager cacheManager, String cacheName) {
return startServer(cacheManager, UniquePortThreadLocal.INSTANCE.get(), cacheName);
}
public static RespServer startServer(EmbeddedCacheManager cacheManager, int port, String cacheName) {
return startServer(cacheManager, port, cacheName, MediaType.APPLICATION_OCTET_STREAM);
}
public static RespServer startServer(EmbeddedCacheManager cacheManager, int port, String cacheName,
MediaType valueMediaType) {
RespServer server = new RespServer() {
@Override
protected void startCaches() {
getCacheManager().getCache(cacheName);
}
};
String serverName = TestResourceTracker.getCurrentTestShortName();
server.start(new RespServerConfigurationBuilder().name(serverName).host(HOST).port(port).build(),
cacheManager);
return server;
}
public static void killClient(RedisClient client) {
try {
if (client != null)
client.shutdown();
} catch (Throwable t) {
log.error("Error stopping client", t);
}
}
public static void killServer(RespServer server) {
if (server != null)
server.stop();
}
public static int port() {
return UniquePortThreadLocal.INSTANCE.get();
}
private static final class UniquePortThreadLocal extends ThreadLocal<Integer> {
static UniquePortThreadLocal INSTANCE = new UniquePortThreadLocal();
private static final AtomicInteger uniqueAddr = new AtomicInteger(
1600 + ThreadLocalRandom.current().nextInt(1024));
@Override
protected Integer initialValue() {
return uniqueAddr.getAndAdd(100);
}
}
/**
* Common assertion to check the Resp Wrong Type Error.
* This occurs when, for example, when setting a key string and then trying to
* apply a list command to that key.
*
* @param command1, sets a key value with a command
* @param command2, runs another command type on the same key of command1
*/
public static void assertWrongType(Runnable command1, Runnable command2) {
command1.run();
assertThatThrownBy(() -> {
command2.run();
}).isInstanceOf(RedisCommandExecutionException.class)
.hasMessageContaining("ERRWRONGTYPE");
}
}
| 4,430
| 34.448
| 115
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/test/SuperPerson.java
|
package org.infinispan.server.resp.test;
import static java.util.Objects.hash;
import org.infinispan.test.data.Person;
public class SuperPerson extends Person {
SuperPerson() {
}
SuperPerson(String name) {
super(name);
}
@Override
public boolean equals(Object o) {
return super.equals(o) && o instanceof SuperPerson && ((SuperPerson) o).isSuper();
}
public boolean isSuper() {
return true;
}
@Override
public int hashCode() {
return hash(super.hashCode(), isSuper());
}
@Override
public String toString() {
return "SuperPerson{" + "name='" + getName() + '\'' + ", isSuper=" + isSuper() + '}';
}
}
| 683
| 17.486486
| 91
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/test/MultimapSCI.java
|
package org.infinispan.server.resp.test;
import org.infinispan.protostream.SerializationContextInitializer;
import org.infinispan.protostream.annotations.AutoProtoSchemaBuilder;
import org.infinispan.test.TestDataSCI;
import org.infinispan.test.data.Person;
@AutoProtoSchemaBuilder(dependsOn = TestDataSCI.class, includeClasses = {
Person.class,
SuperPerson.class
}, schemaFileName = "test.resp.proto", schemaFilePath = "proto/generated", schemaPackageName = "org.infinispan.server.resp.test", service = false)
interface MultimapSCI extends SerializationContextInitializer {
MultimapSCI INSTANCE = new MultimapSCIImpl();
}
| 655
| 42.733333
| 146
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/test/CommonRespTests.java
|
package org.infinispan.server.resp.test;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNull;
import java.util.AbstractMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicReferenceArray;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.async.RedisAsyncCommands;
public class CommonRespTests {
public static void testPipeline(StatefulRedisConnection<String, String> redisConnection) throws ExecutionException,
InterruptedException, TimeoutException {
int commandCount = 35;
AtomicReference<Throwable> error = new AtomicReference<>();
AtomicInteger setCompleted = new AtomicInteger();
RedisAsyncCommands<String, String> redis = redisConnection.async();
for (int i = 0; i < commandCount; ++i) {
redis.set("key-" + i, "value-" + i).whenComplete((___, t) -> {
if (t != null) {
error.set(t);
}
setCompleted.incrementAndGet();
});
}
// This will effectively wait for all set commands above to be completed
redis.ping().get(10, TimeUnit.SECONDS);
Throwable throwable = error.get();
if (throwable != null) {
throw new AssertionError(throwable);
}
AtomicReferenceArray<Map.Entry<String, String>> atomicReferenceArray = new AtomicReferenceArray<>(commandCount + 1);
for (int i = 0; i < commandCount; ++i) {
String key = "key-" + i;
if (i == 13) {
redis.get("not-present")
.whenComplete((v, t) -> {
if (t != null) {
error.set(t);
} else {
atomicReferenceArray.set(commandCount, new AbstractMap.SimpleEntry<>("key-" + commandCount, v));
}
});
}
int j = i;
redis.get(key).whenComplete((v, t) -> {
if (t != null) {
error.set(t);
} else {
atomicReferenceArray.set(j, new AbstractMap.SimpleEntry<>(key, v));
}
});
}
redis.ping().get(10, TimeUnit.SECONDS);
throwable = error.get();
if (throwable != null) {
throw new AssertionError(throwable);
}
for (int i = 0; i < atomicReferenceArray.length(); ++i) {
Map.Entry<String, String> entry = atomicReferenceArray.get(i);
assertEquals("key-" + i, entry.getKey());
if (i == commandCount) {
assertNull(entry.getValue());
} else {
assertEquals("value-" + i, entry.getValue());
}
}
}
}
| 2,916
| 34.144578
| 122
|
java
|
null |
infinispan-main/server/resp/src/test/java/org/infinispan/server/resp/operation/OperationTest.java
|
package org.infinispan.server.resp.operation;
import static org.assertj.core.api.Assertions.assertThat;
import java.nio.charset.StandardCharsets;
import org.testng.annotations.Test;
@Test(groups = "unit", testName = "server.resp.operation.OperationTest")
public class OperationTest {
@Test
public void testLcs() {
byte[] val1 = "ohmytext".getBytes(StandardCharsets.US_ASCII);
byte[] val2 = "mynewtext".getBytes(StandardCharsets.US_ASCII);
var lcsOpts = new LCSOperation.LCSOperationContext(val1, val2,false, false, false, 0);
lcsOpts.lcsLength(val1, val2);
lcsOpts.backtrack(val1, val2);
assertThat(lcsOpts.getResult().lcs).isEqualTo(new byte[] {'m','y','t','e','x','t'});
}
}
| 713
| 30.043478
| 90
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/Resp3Handler.java
|
package org.infinispan.server.resp;
import static org.infinispan.server.resp.RespConstants.CRLF_STRING;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.CompletionStage;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import org.infinispan.AdvancedCache;
import org.infinispan.Cache;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.marshall.WrappedByteArray;
import org.infinispan.context.Flag;
import org.infinispan.multimap.impl.EmbeddedMultimapListCache;
import org.infinispan.multimap.impl.EmbeddedMultimapPairCache;
import org.infinispan.multimap.impl.EmbeddedMultimapSortedSetCache;
import org.infinispan.multimap.impl.EmbeddedSetCache;
import org.infinispan.security.AuthorizationManager;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.channel.ChannelHandlerContext;
public class Resp3Handler extends Resp3AuthHandler {
private static byte[] CRLF_BYTES = CRLF_STRING.getBytes();
protected AdvancedCache<byte[], byte[]> ignorePreviousValueCache;
protected EmbeddedMultimapListCache<byte[], byte[]> listMultimap;
protected EmbeddedMultimapPairCache<byte[], byte[], byte[]> mapMultimap;
// Entry type for SetBucket needs proper hashcode, equals methods. Using
// WrappedByteArray
protected EmbeddedSetCache<byte[], WrappedByteArray> embeddedSetCache;
protected EmbeddedMultimapSortedSetCache<byte[], byte[]> sortedSetMultimap;
private final MediaType valueMediaType;
Resp3Handler(RespServer respServer, MediaType valueMediaType) {
super(respServer);
this.valueMediaType = valueMediaType;
}
@Override
public void setCache(AdvancedCache<byte[], byte[]> cache) {
super.setCache(cache);
ignorePreviousValueCache = cache.withFlags(Flag.SKIP_CACHE_LOAD, Flag.IGNORE_RETURN_VALUES);
Cache toMultimap = cache.withMediaType(MediaType.APPLICATION_OCTET_STREAM, valueMediaType);
listMultimap = new EmbeddedMultimapListCache<>(toMultimap);
mapMultimap = new EmbeddedMultimapPairCache<>(toMultimap);
embeddedSetCache = new EmbeddedSetCache<>(toMultimap);
sortedSetMultimap = new EmbeddedMultimapSortedSetCache<>(toMultimap);
}
public EmbeddedMultimapListCache<byte[], byte[]> getListMultimap() {
return listMultimap;
}
public EmbeddedMultimapPairCache<byte[], byte[], byte[]> getHashMapMultimap() {
return mapMultimap;
}
public EmbeddedSetCache<byte[], WrappedByteArray> getEmbeddedSetCache() {
return embeddedSetCache;
}
public EmbeddedMultimapSortedSetCache<byte[], byte[]> getSortedSeMultimap() {
return sortedSetMultimap;
}
@Override
protected CompletionStage<RespRequestHandler> actualHandleRequest(ChannelHandlerContext ctx, RespCommand type,
List<byte[]> arguments) {
if (type instanceof Resp3Command) {
Resp3Command resp3Command = (Resp3Command) type;
return resp3Command.perform(this, ctx, arguments);
}
return super.actualHandleRequest(ctx, type, arguments);
}
protected static void handleLongResult(Long result, ByteBufPool alloc) {
ByteBufferUtils.writeLong(result, alloc);
}
protected static void handleDoubleResult(double result, ByteBufPool alloc) {
// TODO: this can be optimized to avoid the String allocation
handleBulkResult(Double.toString(result), alloc);
}
protected static void handleCollectionLongResult(Collection<Long> collection, ByteBufPool alloc) {
if (collection == null) {
handleNullResult(alloc);
} else {
String result = "*" + collection.size() + CRLF_STRING
+ collection.stream().map(value -> ":" + value + CRLF_STRING).collect(Collectors.joining());
ByteBufferUtils.stringToByteBuf(result, alloc);
}
}
public static void handleBulkResult(CharSequence result, ByteBufPool alloc) {
if (result == null) {
handleNullResult(alloc);
} else {
ByteBufferUtils.stringToByteBuf("$" + ByteBufUtil.utf8Bytes(result) + CRLF_STRING + result + CRLF_STRING,
alloc);
}
}
public static void handleCollectionBulkResult(Collection<WrappedByteArray> collection, ByteBufPool alloc) {
if (collection == null) {
handleNullResult(alloc);
return;
}
int dataLength = collection.stream().mapToInt(wba -> wba.getLength() + 5 + lenghtInChars(wba.getLength())).sum();
var buffer = allocAndWriteLengthPrefix('*', collection.size(), alloc, dataLength);
collection.forEach(wba -> writeBulkResult(wba.getBytes(), buffer));
}
private static void handleNullResult(ByteBufPool alloc) {
ByteBufferUtils.stringToByteBuf("$-1\r\n", alloc);
}
protected static void handleBulkResult(byte[] result, ByteBufPool alloc) {
if (result == null) {
handleNullResult(alloc);
return;
}
var buffer = allocAndWriteLengthPrefix('$', result.length, alloc, result.length + 2);
buffer.writeBytes(result);
buffer.writeBytes(CRLF_BYTES);
}
private static void writeBulkResult(byte[] result, ByteBuf buffer) {
writeLengthPrefix('$', result.length, buffer);
buffer.writeBytes(result);
buffer.writeBytes(CRLF_BYTES);
}
protected static void handleThrowable(ByteBufPool alloc, Throwable t) {
Consumer<ByteBufPool> writer = RespErrorUtil.handleException(t);
if (writer != null) {
writer.accept(alloc);
} else {
ByteBufferUtils.stringToByteBuf("-ERR " + t.getMessage() + CRLF_STRING, alloc);
}
}
public AdvancedCache<byte[], byte[]> ignorePreviousValuesCache() {
return ignorePreviousValueCache;
}
public CompletionStage<RespRequestHandler> delegate(ChannelHandlerContext ctx,
RespCommand command,
List<byte[]> arguments) {
return super.actualHandleRequest(ctx, command, arguments);
}
public void checkPermission(AuthorizationPermission authorizationPermission) {
AuthorizationManager authorizationManager = cache.getAuthorizationManager();
if (authorizationManager != null) {
authorizationManager.checkPermission(authorizationPermission);
}
}
protected static void handleArrayPrefix(int size, ByteBufPool alloc) {
allocAndWriteLengthPrefix('*', size, alloc, 0);
}
private static ByteBuf allocAndWriteLengthPrefix(char type, int size, ByteBufPool alloc, int additionalBytes) {
int strLength = lenghtInChars(size);
ByteBuf buffer = alloc.acquire(strLength + additionalBytes + 3);
buffer.writeByte(type);
ByteBufferUtils.setIntChars(size, strLength, buffer);
buffer.writeBytes(CRLF_BYTES);
return buffer;
}
private static int lenghtInChars(int size) {
int strLength = size == 0 ? 1 : (int) Math.log10(size) + 1;
return strLength;
}
private static ByteBuf writeLengthPrefix(char type, int size, ByteBuf buffer) {
int strLength = lenghtInChars(size);
buffer.writeByte(type);
ByteBufferUtils.setIntChars(size, strLength, buffer);
buffer.writeBytes(CRLF_BYTES);
return buffer;
}
}
| 7,333
| 37
| 119
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/RespDetector.java
|
package org.infinispan.server.resp;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.regex.Pattern;
import org.infinispan.server.core.ProtocolDetector;
import org.infinispan.server.core.transport.AccessControlFilter;
import org.infinispan.server.resp.logging.Log;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
/**
* Detect RESP connections
*/
public class RespDetector extends ProtocolDetector {
public static final String NAME = "resp-detector";
private static final Pattern RESP3_HANDSHAKE = Pattern.compile("^(?is)\\*[1-9]\r\n\\$[1-9]\r\n(HELLO|AUTH|COMMAND)\r\n.*");
public RespDetector(RespServer server) {
super(server);
}
@Override
public String getName() {
return NAME;
}
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
// We need to only see the RESP HELLO message
if (in.readableBytes() < 5) {
// noop, wait for further reads
return;
}
int i = in.readerIndex();
// RESP commands start with * to symbolize a STRING sequence
if (in.getByte(i) == 42) {
// The Redis CLI sends commands as array. Accept it only if it is a HELLO or AUTH command
CharSequence handshake = in.getCharSequence(i, in.readableBytes(), StandardCharsets.US_ASCII);
if (RESP3_HANDSHAKE.matcher(handshake).matches()) {
installRespHandler(ctx);
} else {
out.add("-ERR Only RESP3 supported\r\n");
}
} else if (in.getCharSequence(i, 5, StandardCharsets.US_ASCII).equals("HELLO")) {
installRespHandler(ctx);
}
// Remove this
ctx.pipeline().remove(this);
}
private void installRespHandler(ChannelHandlerContext ctx) {
// We found the RESP handshake, let's do some pipeline surgery
trimPipeline(ctx);
// Add the RESP server handler
ctx.pipeline().addLast(server.getInitializer());
// Make sure to fire registered on the newly installed handlers
ctx.fireChannelRegistered();
Log.SERVER.tracef("Detected RESP connection %s", ctx);
// Trigger any protocol-specific rules
ctx.pipeline().fireUserEventTriggered(AccessControlFilter.EVENT);
}
}
| 2,287
| 33.666667
| 126
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/RespConstants.java
|
package org.infinispan.server.resp;
import java.nio.charset.StandardCharsets;
public interface RespConstants {
byte SIMPLE_STRING = '+';
byte BULK_STRING = '$';
byte ARRAY = '*';
byte NUMERIC = ':';
byte HELLO = '@';
String CRLF_STRING = "\r\n";
byte[] CRLF = CRLF_STRING.getBytes(StandardCharsets.US_ASCII);
byte[] OK = "+OK\r\n".getBytes(StandardCharsets.US_ASCII);
byte[] NIL = "$-1\r\n".getBytes(StandardCharsets.US_ASCII);
}
| 461
| 24.666667
| 65
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/Consumers.java
|
package org.infinispan.server.resp;
import static org.infinispan.server.resp.RespConstants.CRLF_STRING;
import static org.infinispan.server.resp.RespConstants.OK;
import java.util.Collection;
import java.util.function.BiConsumer;
import org.infinispan.commons.marshall.WrappedByteArray;
import org.infinispan.server.resp.response.LCSResponse;
import org.infinispan.server.resp.response.SetResponse;
/**
* Utility class with Consumers
*
* @since 15.0
*/
public final class Consumers {
private Consumers() {
}
public static final BiConsumer<Object, ByteBufPool> OK_BICONSUMER = (ignore, alloc) -> alloc.acquire(OK.length)
.writeBytes(OK);
public static final BiConsumer<Long, ByteBufPool> LONG_BICONSUMER = Resp3Handler::handleLongResult;
public static final BiConsumer<Collection<Long>, ByteBufPool> COLLECTION_LONG_BICONSUMER = Resp3Handler::handleCollectionLongResult;
public static final BiConsumer<Double, ByteBufPool> DOUBLE_BICONSUMER = Resp3Handler::handleDoubleResult;
public static final BiConsumer<byte[], ByteBufPool> BULK_BICONSUMER = Resp3Handler::handleBulkResult;
public static final BiConsumer<Collection<WrappedByteArray>, ByteBufPool> COLLECTION_BULK_BICONSUMER = Resp3Handler::handleCollectionBulkResult;
public static final BiConsumer<byte[], ByteBufPool> GET_BICONSUMER = (innerValueBytes, alloc) -> {
if (innerValueBytes != null) {
ByteBufferUtils.bytesToResult(innerValueBytes, alloc);
} else {
ByteBufferUtils.stringToByteBuf("$-1\r\n", alloc);
}
};
public static final BiConsumer<Collection<byte[]>, ByteBufPool> GET_ARRAY_BICONSUMER = (innerValueBytes, alloc) -> {
if (innerValueBytes != null) {
ByteBufferUtils.bytesToResult(innerValueBytes, alloc);
} else {
ByteBufferUtils.stringToByteBuf("$-1\r\n", alloc);
}
};
public static final BiConsumer<byte[], ByteBufPool> DELETE_BICONSUMER = (prev, alloc) ->
ByteBufferUtils.stringToByteBuf(":" + (prev == null ? "0" : "1") + CRLF_STRING, alloc);
public static final BiConsumer<SetResponse, ByteBufPool> SET_BICONSUMER = (res, alloc) -> {
// The set operation has three return options, with a precedence:
//
// 1. Previous value or `nil`: when `GET` flag present;
// 2. `OK`: when set operation succeeded
// 3. `nil`: when set operation failed, e.g., tried using XX or NX.
if (res.isReturnValue()) {
GET_BICONSUMER.accept(res.value(), alloc);
return;
}
if (res.isSuccess()) {
OK_BICONSUMER.accept(res, alloc);
return;
}
GET_BICONSUMER.accept(null, alloc);
};
public static final BiConsumer<LCSResponse, ByteBufPool> LCS_BICONSUMER = (res, alloc) -> {
// If lcs present, return a bulk_string
if (res.lcs != null) {
Resp3Handler.handleBulkResult(res.lcs, alloc);
return;
}
// If idx is null then it's a justLen command, return a long
if (res.idx == null) {
Resp3Handler.handleLongResult(Long.valueOf(res.len), alloc);
return;
}
handleIdxArray(res, alloc);
};
private static void handleIdxArray(LCSResponse res, ByteBufPool alloc) {
// return idx. it's a 4 items array
Resp3Handler.handleArrayPrefix(4, alloc);
Resp3Handler.handleBulkResult("matches", alloc);
Resp3Handler.handleArrayPrefix(res.idx.size(), alloc);
for (var match : res.idx) {
// 2 positions + optional length
var size = match.length > 4 ? 3 : 2;
Resp3Handler.handleArrayPrefix(size, alloc);
Resp3Handler.handleArrayPrefix(2, alloc);
Resp3Handler.handleLongResult(match[0], alloc);
Resp3Handler.handleLongResult(match[1], alloc);
Resp3Handler.handleArrayPrefix(2, alloc);
Resp3Handler.handleLongResult(match[2], alloc);
Resp3Handler.handleLongResult(match[3], alloc);
if (size == 3) {
Resp3Handler.handleLongResult(match[4], alloc);
}
}
Resp3Handler.handleBulkResult("len", alloc);
Resp3Handler.handleLongResult((long) res.len, alloc);
}
}
| 4,177
| 36.63964
| 147
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/ByteBufferUtils.java
|
package org.infinispan.server.resp;
import static org.infinispan.server.resp.RespConstants.CRLF;
import static org.infinispan.server.resp.RespConstants.NIL;
import java.util.Collection;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.util.CharsetUtil;
/**
* Utility class with ByteBuffer Utils
*
* @since 14.0
*/
public final class ByteBufferUtils {
private ByteBufferUtils() {
}
static final byte[] DigitTens = {
'0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
'1', '1', '1', '1', '1', '1', '1', '1', '1', '1',
'2', '2', '2', '2', '2', '2', '2', '2', '2', '2',
'3', '3', '3', '3', '3', '3', '3', '3', '3', '3',
'4', '4', '4', '4', '4', '4', '4', '4', '4', '4',
'5', '5', '5', '5', '5', '5', '5', '5', '5', '5',
'6', '6', '6', '6', '6', '6', '6', '6', '6', '6',
'7', '7', '7', '7', '7', '7', '7', '7', '7', '7',
'8', '8', '8', '8', '8', '8', '8', '8', '8', '8',
'9', '9', '9', '9', '9', '9', '9', '9', '9', '9',
};
static final byte[] DigitOnes = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
};
public static ByteBuf bytesToResult(byte[] result, ByteBufPool alloc) {
int length = result.length;
int stringLength = stringSize(length);
// Need 5 extra for $ and 2 sets of /r/n
int exactSize = stringLength + length + 5;
ByteBuf buffer = alloc.acquire(exactSize);
buffer.writeByte('$');
// This method is anywhere from 10-100% faster than ByteBufUtil.writeAscii and avoids allocations
setIntChars(length, stringLength, buffer);
buffer.writeBytes(CRLF);
buffer.writeBytes(result);
buffer.writeBytes(CRLF);
return buffer;
}
public static ByteBuf writeLong(Long result, ByteBufPool alloc) {
if (result == null) {
return alloc.acquire(NIL.length).writeBytes(NIL);
}
// : + number of digits + \r\n
int size = 1 + stringSize(result) + 2;
ByteBuf buffer = alloc.acquire(size);
buffer.writeByte(':');
setIntChars(result, size - 3, buffer);
return buffer.writeBytes(CRLF);
}
public static ByteBuf bytesToResult(Collection<byte[]> results, ByteBufPool alloc) {
if (results.isEmpty())
return stringToByteBuf("*0\r\n", alloc);
int resultBytesSize = 0;
for (byte[] result: results) {
int length;
if (result == null) {
// $-1
resultBytesSize += 3;
} else if ((length = result.length) > 0) {
// $ + digit length (log10 + 1) + \r\n + byte length
resultBytesSize += (1 + (int) Math.log10(length) + 1 + 2 + length);
} else {
// $0 + \r\n
resultBytesSize += (2 + 2);
}
// /r/n
resultBytesSize += 2;
}
return bytesToResult(resultBytesSize, results, alloc);
}
public static ByteBuf bytesToResult(int resultBytesSize, Collection<byte[]> results, ByteBufPool alloc) {
int elements = results.size();
// * + digit length (log10 + 1) + \r\n + accumulated bytes
int byteAmount = 1 + (int) Math.log10(elements) + 1 + 2 + resultBytesSize;
ByteBuf byteBuf = alloc.apply(byteAmount);
byteBuf.writeCharSequence("*" + results.size(), CharsetUtil.US_ASCII);
byteBuf.writeBytes(CRLF);
for (byte[] value : results) {
if (value == null) {
byteBuf.writeCharSequence("$-1", CharsetUtil.US_ASCII);
} else {
byteBuf.writeCharSequence("$" + value.length, CharsetUtil.US_ASCII);
byteBuf.writeBytes(CRLF);
byteBuf.writeBytes(value);
}
byteBuf.writeBytes(CRLF);
}
return byteBuf;
}
// This code is a modified version of Integer.toString to write the underlying bytes directly to the ByteBuffer
// instead of creating a String around a byte[]
public static int setIntChars(long i, int index, ByteBuf buf) {
int writeIndex = buf.writerIndex();
long q;
int r;
int charPos = index;
boolean negative = i < 0;
if (!negative) {
i = -i;
}
// Generate two digits per iteration
while (i <= -100) {
q = i / 100;
r = (int)((q * 100) - i);
i = q;
buf.setByte(writeIndex + --charPos, DigitOnes[r]);
buf.setByte(writeIndex + --charPos, DigitTens[r]);
}
// We know there are at most two digits left at this point.
q = i / 10;
r = (int)((q * 10) - i);
buf.setByte(writeIndex + --charPos, (byte) ('0' + r));
// Whatever left is the remaining digit.
if (q < 0) {
buf.setByte(writeIndex + --charPos, (byte) ('0' - q));
}
if (negative) {
buf.setByte(writeIndex + --charPos, (byte) '-');
}
buf.writerIndex(writeIndex + index);
return charPos;
}
public static int stringSize(long x) {
int d = 1;
if (x >= 0) {
d = 0;
x = -x;
}
int p = -10;
for (int i = 1; i < 10; i++) {
if (x > p)
return i + d;
p = 10 * p;
}
return 10 + d;
}
public static ByteBuf stringToByteBuf(CharSequence string, ByteBufPool alloc) {
return stringToByteBufWithExtra(string, alloc, 0);
}
public static ByteBuf stringToByteBufWithExtra(CharSequence string, ByteBufPool alloc, int extraBytes) {
boolean release = true;
int stringBytes = ByteBufUtil.utf8Bytes(string);
int allocatedSize = stringBytes + extraBytes;
ByteBuf buffer = alloc.apply(allocatedSize);
try {
int beforeWriteIndex = buffer.writerIndex();
ByteBufUtil.reserveAndWriteUtf8(buffer, string, allocatedSize);
assert buffer.capacity() - buffer.writerIndex() >= extraBytes;
assert buffer.writerIndex() - beforeWriteIndex == stringBytes;
release = false;
} finally {
if (release) {
buffer.release();
}
}
return buffer;
}
}
| 6,620
| 31.940299
| 114
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/SubscriberHandler.java
|
package org.infinispan.server.resp;
import io.netty.buffer.ByteBuf;
import io.netty.channel.Channel;
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.commons.util.concurrent.CompletableFutures;
import org.infinispan.encoding.DataConversion;
import org.infinispan.metadata.Metadata;
import org.infinispan.notifications.Listener;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryCreated;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryModified;
import org.infinispan.notifications.cachelistener.event.CacheEntryEvent;
import org.infinispan.notifications.cachelistener.filter.CacheEventFilter;
import org.infinispan.notifications.cachelistener.filter.EventType;
import org.infinispan.server.resp.commands.PubSubResp3Command;
import org.infinispan.server.resp.commands.pubsub.KeyChannelUtils;
import org.infinispan.server.resp.logging.Log;
import org.infinispan.util.concurrent.CompletionStages;
import java.lang.invoke.MethodHandles;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletionStage;
import static org.infinispan.server.resp.RespConstants.CRLF_STRING;
public class SubscriberHandler extends CacheRespRequestHandler {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass(), Log.class);
private final Resp3Handler resp3Handler;
public SubscriberHandler(RespServer respServer, Resp3Handler prevHandler) {
super(respServer);
this.resp3Handler = prevHandler;
}
@Listener(clustered = true)
public static class PubSubListener {
private final Channel channel;
private final DataConversion keyConversion;
private final DataConversion valueConversion;
public PubSubListener(Channel channel, DataConversion keyConversion, DataConversion valueConversion) {
this.channel = channel;
this.keyConversion = keyConversion;
this.valueConversion = valueConversion;
}
@CacheEntryCreated
@CacheEntryModified
public CompletionStage<Void> onEvent(CacheEntryEvent<Object, Object> entryEvent) {
byte[] key = KeyChannelUtils.channelToKey((byte[]) keyConversion.fromStorage(entryEvent.getKey()));
byte[] value = (byte[]) valueConversion.fromStorage(entryEvent.getValue());
if (key.length > 0 && value != null && value.length > 0) {
// *3 + \r\n + $7 + \r\n + message + \r\n + $ + keylength (log10 + 1) + \r\n + key + \r\n +
// $ + valuelength (log 10 + 1) + \r\n + value + \r\n
int byteSize = 2 + 2 + 2 + 2 + 7 + 2 + 1 + (int) Math.log10(key.length) + 1
+ 2 + key.length + 2 + 1 + (int) Math.log10(value.length) + 1 + 2 + value.length + 2;
// TODO: this is technically an issue with concurrent events before/after register/unregister message
ByteBuf byteBuf = channel.alloc().buffer(byteSize, byteSize);
byteBuf.writeCharSequence("*3\r\n$7\r\nmessage\r\n$" + key.length + CRLF_STRING, CharsetUtil.US_ASCII);
byteBuf.writeBytes(key);
byteBuf.writeCharSequence("\r\n$" + value.length + CRLF_STRING, CharsetUtil.US_ASCII);
byteBuf.writeBytes(value);
byteBuf.writeByte('\r');
byteBuf.writeByte('\n');
assert byteBuf.writerIndex() == byteSize;
// TODO: add some back pressure? - something like ClientListenerRegistry?
channel.writeAndFlush(byteBuf, channel.voidPromise());
}
return CompletableFutures.completedNull();
}
}
public static class ListenerKeyFilter implements CacheEventFilter<Object, Object> {
private final byte[] key;
private final DataConversion conversion;
public ListenerKeyFilter(byte[] key, DataConversion conversion) {
this.key = key;
this.conversion = conversion;
}
@Override
public boolean accept(Object eventKey, Object oldValue, Metadata oldMetadata, Object newValue,
Metadata newMetadata, EventType eventType) {
return Arrays.equals(key, (byte[]) conversion.fromStorage(eventKey));
}
}
private Map<WrappedByteArray, PubSubListener> specificChannelSubscribers = new HashMap<>();
public Map<WrappedByteArray, PubSubListener> specificChannelSubscribers() {
return specificChannelSubscribers;
}
public Resp3Handler resp3Handler() {
return resp3Handler;
}
@Override
public void handleChannelDisconnect(ChannelHandlerContext ctx) {
removeAllListeners();
}
@Override
protected CompletionStage<RespRequestHandler> actualHandleRequest(ChannelHandlerContext ctx, RespCommand command, List<byte[]> arguments) {
initializeIfNecessary(ctx);
if (command instanceof PubSubResp3Command) {
PubSubResp3Command pubSubsCommand = (PubSubResp3Command) command;
return pubSubsCommand.perform(this, ctx, arguments);
}
return super.actualHandleRequest(ctx, command, arguments);
}
public CompletionStage<Void> handleStageListenerError(CompletionStage<Void> stage, byte[] keyChannel, boolean subscribeOrUnsubscribe) {
return stage.whenComplete((__, t) -> {
if (t != null) {
if (subscribeOrUnsubscribe) {
log.exceptionWhileRegisteringListener(t, CharsetUtil.UTF_8.decode(ByteBuffer.wrap(keyChannel)));
} else {
log.exceptionWhileRemovingListener(t, CharsetUtil.UTF_8.decode(ByteBuffer.wrap(keyChannel)));
}
}
});
}
public void removeAllListeners() {
for (Iterator<Map.Entry<WrappedByteArray, PubSubListener>> iterator = specificChannelSubscribers.entrySet().iterator(); iterator.hasNext(); ) {
Map.Entry<WrappedByteArray, PubSubListener> entry = iterator.next();
PubSubListener listener = entry.getValue();
cache.removeListenerAsync(listener);
iterator.remove();
}
}
public CompletionStage<RespRequestHandler> unsubscribeAll(ChannelHandlerContext ctx) {
var aggregateCompletionStage = CompletionStages.aggregateCompletionStage();
List<byte[]> channels = new ArrayList<>(specificChannelSubscribers.size());
for (Iterator<Map.Entry<WrappedByteArray, PubSubListener>> iterator = specificChannelSubscribers.entrySet().iterator(); iterator.hasNext(); ) {
Map.Entry<WrappedByteArray, PubSubListener> entry = iterator.next();
PubSubListener listener = entry.getValue();
CompletionStage<Void> stage = cache.removeListenerAsync(listener);
byte[] keyChannel = entry.getKey().getBytes();
channels.add(keyChannel);
aggregateCompletionStage.dependsOn(handleStageListenerError(stage, keyChannel, false));
iterator.remove();
}
return sendSubscriptions(ctx, aggregateCompletionStage.freeze(), channels, false);
}
public CompletionStage<RespRequestHandler> sendSubscriptions(ChannelHandlerContext ctx, CompletionStage<Void> stageToWaitFor,
Collection<byte[]> keyChannels, boolean subscribeOrUnsubscribe) {
return stageToReturn(stageToWaitFor, ctx, (__, alloc) -> {
for (byte[] keyChannel : keyChannels) {
String initialCharSeq = subscribeOrUnsubscribe ? "*2\r\n$9\r\nsubscribe\r\n$" : "*2\r\n$11\r\nunsubscribe\r\n$";
// Length of string (all ascii so 1 byte per) + (log10 + 1 = sizes of number as char in bytes) + \r\n + bytes themselves + \r\n
int sizeRequired = initialCharSeq.length() + (int) Math.log10(keyChannel.length) + 1 + 2 + keyChannel.length + 2;
ByteBuf subscribeBuffer = alloc.apply(sizeRequired);
int initialPos = subscribeBuffer.writerIndex();
subscribeBuffer.writeCharSequence(initialCharSeq + keyChannel.length + CRLF_STRING, CharsetUtil.US_ASCII);
subscribeBuffer.writeBytes(keyChannel);
subscribeBuffer.writeByte('\r');
subscribeBuffer.writeByte('\n');
assert subscribeBuffer.writerIndex() - initialPos == sizeRequired;
}
});
}
}
| 8,418
| 46.03352
| 149
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/RespHandler.java
|
package org.infinispan.server.resp;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.commons.util.Util;
import org.infinispan.server.resp.logging.Log;
import org.infinispan.util.concurrent.CompletionStages;
import org.infinispan.util.logging.LogFactory;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
public class RespHandler extends ChannelInboundHandlerAdapter {
protected final static Log log = LogFactory.getLog(RespHandler.class, Log.class);
protected final static int MINIMUM_BUFFER_SIZE;
protected final BaseRespDecoder resumeHandler;
protected RespRequestHandler requestHandler;
protected ByteBuf outboundBuffer;
// Variable to resume auto read when channel can be written to again. Some commands may resume themselves after
// flush and may not want to also resume on writability changes
protected boolean resumeAutoReadOnWritability;
static {
MINIMUM_BUFFER_SIZE = Integer.parseInt(System.getProperty("infinispan.resp.minimum-buffer-size", "4096"));
}
public RespHandler(BaseRespDecoder resumeHandler, RespRequestHandler requestHandler) {
this.resumeHandler = resumeHandler;
this.requestHandler = requestHandler;
}
protected ByteBuf allocateBuffer(ChannelHandlerContext ctx, int size) {
if (outboundBuffer != null) {
if (outboundBuffer.writableBytes() > size) {
return outboundBuffer;
}
log.tracef("Writing buffer %s as request is larger than remaining", outboundBuffer);
ctx.write(outboundBuffer, ctx.voidPromise());
}
int allocatedSize = Math.max(size, MINIMUM_BUFFER_SIZE);
outboundBuffer = ctx.alloc().buffer(allocatedSize, allocatedSize);
return outboundBuffer;
}
private void flushBufferIfNeeded(ChannelHandlerContext ctx, boolean runOnEventLoop) {
if (outboundBuffer != null) {
log.tracef("Writing and flushing buffer %s", outboundBuffer);
if (runOnEventLoop) {
ctx.channel().eventLoop().execute(() -> {
ctx.writeAndFlush(outboundBuffer, ctx.voidPromise());
outboundBuffer = null;
});
} else {
ctx.writeAndFlush(outboundBuffer, ctx.voidPromise());
outboundBuffer = null;
}
}
}
@Override
public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
ctx.channel().attr(RespRequestHandler.BYTE_BUF_POOL_ATTRIBUTE_KEY)
.set(size -> allocateBuffer(ctx, size));
super.channelRegistered(ctx);
}
@Override
public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
super.channelUnregistered(ctx);
requestHandler.handleChannelDisconnect(ctx);
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
// If we disabled auto read in the middle of a read, that means we are waiting on a pending command to complete
if (ctx.channel().config().isAutoRead()) {
flushBufferIfNeeded(ctx, false);
}
super.channelReadComplete(ctx);
}
@Override
public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
if (resumeAutoReadOnWritability && ctx.channel().isWritable()) {
resumeAutoReadOnWritability = false;
log.tracef("Re-enabling auto read for channel %s as channel is now writeable", ctx.channel());
resumeAutoRead(ctx);
}
super.channelWritabilityChanged(ctx);
}
protected void resumeAutoRead(ChannelHandlerContext ctx) {
ctx.channel().config().setAutoRead(true);
resumeHandler.resumeRead();
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
RespDecoder arg = (RespDecoder) msg;
handleCommandAndArguments(ctx, arg.getCommand(), arg.getArguments());
}
/**
* Handles the actual command request. This entails passing the command to the request handler and if
* the request is completed the decoder may parse more commands.
*
* @param ctx channel context in use for this command
* @param command the actual command
* @param arguments the arguments provided to the command. The list should not be retained as it is reused
*/
protected void handleCommandAndArguments(ChannelHandlerContext ctx, RespCommand command, List<byte[]> arguments) {
if (log.isTraceEnabled()) {
log.tracef("Received command: %s with arguments %s for %s", command, Util.toStr(arguments), ctx.channel());
}
CompletionStage<RespRequestHandler> stage = requestHandler.handleRequest(ctx, command, arguments);
if (CompletionStages.isCompletedSuccessfully(stage)) {
requestHandler = CompletionStages.join(stage);
if (outboundBuffer != null && outboundBuffer.readableBytes() > ctx.channel().bytesBeforeUnwritable()) {
log.tracef("Buffer will cause channel %s to be unwriteable - forcing flush", ctx.channel());
// Note the flush is done later after this task completes, since we don't want to resume reading yet
flushBufferIfNeeded(ctx, true);
ctx.channel().config().setAutoRead(false);
resumeAutoReadOnWritability = true;
return;
}
return;
}
log.tracef("Disabling auto read for channel %s until previous command is complete", ctx.channel());
// Disable reading any more from socket - until command is complete
ctx.channel().config().setAutoRead(false);
stage.whenComplete((handler, t) -> {
assert ctx.channel().eventLoop().inEventLoop();
if (t != null) {
exceptionCaught(ctx, t);
return;
}
// Instate the new handler if there was no exception
requestHandler = handler;
flushBufferIfNeeded(ctx, false);
log.tracef("Re-enabling auto read for channel %s as previous command is complete", ctx.channel());
resumeAutoRead(ctx);
});
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
log.unexpectedException(cause);
ByteBufferUtils.stringToByteBuf("-ERR Server Error Encountered: " + cause.getMessage() + "\\r\\n", requestHandler.allocatorToUse);
flushBufferIfNeeded(ctx, false);
ctx.close();
}
}
| 6,451
| 39.835443
| 136
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/Resp3AuthHandler.java
|
package org.infinispan.server.resp;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.server.core.transport.ConnectionMetadata;
import org.infinispan.server.resp.authentication.RespAuthenticator;
import org.infinispan.server.resp.commands.AuthResp3Command;
import javax.security.auth.Subject;
import javax.security.sasl.SaslException;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.CompletionStage;
public class Resp3AuthHandler extends CacheRespRequestHandler {
public Resp3AuthHandler(RespServer server) {
super(server);
}
@Override
protected CompletionStage<RespRequestHandler> actualHandleRequest(ChannelHandlerContext ctx, RespCommand command, List<byte[]> arguments) {
if (command instanceof AuthResp3Command) {
AuthResp3Command authCommand = (AuthResp3Command) command;
return authCommand.perform(this, ctx, arguments);
}
if (isAuthorized()) {
return super.actualHandleRequest(ctx, command, arguments);
} else {
handleUnauthorized(ctx);
}
return myStage;
}
public CompletionStage<Boolean> performAuth(ChannelHandlerContext ctx, byte[] username, byte[] password) {
return performAuth(ctx, new String(username, StandardCharsets.UTF_8), new String(password, StandardCharsets.UTF_8));
}
public CompletionStage<Boolean> performAuth(ChannelHandlerContext ctx) {
return performAuth(ctx, (String) null, null);
}
private CompletionStage<Boolean> performAuth(ChannelHandlerContext ctx, String username, String password) {
RespAuthenticator authenticator = respServer.getConfiguration().authentication().authenticator();
if (authenticator == null) {
return CompletableFutures.booleanStage(handleAuthResponse(ctx, null));
}
CompletionStage<Subject> authentication;
if (username == null && password == null) {
try {
authentication = canUseCertAuth()
? authenticator.clientCertAuth(ctx.channel())
: CompletableFutures.completedNull();
} catch (SaslException e) {
throw CompletableFutures.asCompletionException(e);
}
} else {
authentication = authenticator.usernamePasswordAuth(username, password.toCharArray());
}
return authentication
// Note we have to write to our variables in the event loop (in this case cache)
.thenApplyAsync(r -> handleAuthResponse(ctx, r), ctx.channel().eventLoop())
.exceptionally(t -> {
handleUnauthorized(ctx);
return false;
});
}
private boolean handleAuthResponse(ChannelHandlerContext ctx, Subject subject) {
assert ctx.channel().eventLoop().inEventLoop();
if (subject == null) {
ByteBufferUtils.stringToByteBuf("-ERR Client sent AUTH, but no password is set\r\n", allocatorToUse);
return false;
}
ConnectionMetadata metadata = ConnectionMetadata.getInstance(ctx.channel());
metadata.subject(subject);
setCache(cache.withSubject(subject));
Consumers.OK_BICONSUMER.accept(null, allocatorToUse);
return true;
}
private void handleUnauthorized(ChannelHandlerContext ctx) {
assert ctx.channel().eventLoop().inEventLoop();
ByteBufferUtils.stringToByteBuf("-WRONGPASS invalid username-password pair or user is disabled.\r\n", allocatorToUse);
}
public boolean isAuthorized() {
return this.getClass() != Resp3AuthHandler.class;
}
public boolean canUseCertAuth() {
RespAuthenticator authenticator = respServer.getConfiguration().authentication().authenticator();
return authenticator != null && authenticator.isClientCertAuthEnabled();
}
}
| 3,878
| 37.79
| 142
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/RespTypes.java
|
package org.infinispan.server.resp;
/**
* @since 15.0
**/
public enum RespTypes {
none,
hash,
list,
set,
stream,
string,
zset,
// Not a real Resp type
unknown
}
| 191
| 10.294118
| 35
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/CacheRespRequestHandler.java
|
package org.infinispan.server.resp;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.dataconversion.MediaType;
public class CacheRespRequestHandler extends RespRequestHandler {
protected final RespServer respServer;
protected AdvancedCache<byte[], byte[]> cache;
protected CacheRespRequestHandler(RespServer respServer) {
this.respServer = respServer;
setCache(respServer.getCache()
.withMediaType(MediaType.APPLICATION_OCTET_STREAM, MediaType.APPLICATION_OCTET_STREAM));
}
public AdvancedCache<byte[], byte[]> cache() {
return cache;
}
protected void setCache(AdvancedCache<byte[], byte[]> cache) {
this.cache = cache;
}
public RespServer respServer() {
return respServer;
}
}
| 774
| 26.678571
| 100
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/RespChannelInitializer.java
|
package org.infinispan.server.resp;
import org.infinispan.server.core.transport.ConnectionMetadata;
import org.infinispan.server.core.transport.NettyInitializer;
import io.netty.channel.Channel;
import io.netty.channel.ChannelPipeline;
/**
* Creates Netty Channels for the resp server.
*
* @author William Burns
*/
public class RespChannelInitializer implements NettyInitializer {
private final RespServer respServer;
/**
* Creates new {@link RespChannelInitializer}.
*
* @param respServer Resp Server this initializer belongs to.
*/
public RespChannelInitializer(RespServer respServer) {
this.respServer = respServer;
}
@Override
public void initializeChannel(Channel ch) {
ConnectionMetadata metadata = ConnectionMetadata.getInstance(ch);
metadata.protocolVersion("RESP3");
ChannelPipeline pipeline = ch.pipeline();
RespRequestHandler initialHandler;
if (respServer.getConfiguration().authentication().enabled()) {
initialHandler = new Resp3AuthHandler(respServer);
} else {
initialHandler = respServer.newHandler();
}
RespDecoder decoder = new RespDecoder();
pipeline.addLast(decoder);
pipeline.addLast(new RespHandler(decoder, initialHandler));
}
}
| 1,285
| 28.227273
| 71
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/RespErrorUtil.java
|
package org.infinispan.server.resp;
import java.util.concurrent.CompletionException;
import java.util.function.Consumer;
import org.infinispan.commons.CacheException;
public final class RespErrorUtil {
private RespErrorUtil() {
}
public static void noSuchKey(ByteBufPool allocatorToUse) {
ByteBufferUtils.stringToByteBuf(
"-ERR no such key\r\n", allocatorToUse);
}
public static void indexOutOfRange(ByteBufPool allocatorToUse) {
ByteBufferUtils.stringToByteBuf(
"-ERR index out of range\r\n", allocatorToUse);
}
public static void wrongType(ByteBufPool allocatorToUse) {
ByteBufferUtils.stringToByteBuf(
"-ERRWRONGTYPE Operation against a key holding the wrong kind of value\r\n", allocatorToUse);
}
public static void wrongArgumentNumber(RespCommand command, ByteBufPool allocatorToUse) {
ByteBufferUtils.stringToByteBuf(
"-ERR wrong number of arguments for '" + command.getName().toLowerCase() + "' command\r\n", allocatorToUse);
}
public static void unknownCommand(ByteBufPool allocator) {
ByteBufferUtils.stringToByteBuf("-ERR unknown command\r\n", allocator);
}
public static void mustBePositive(ByteBufPool allocator) {
ByteBufferUtils.stringToByteBuf(
"-ERR value is out of range, must be positive\r\n", allocator);
}
public static void syntaxError(ByteBufPool allocator) {
ByteBufferUtils.stringToByteBuf("-ERR syntax error\r\n", allocator);
}
public static void wrongArgumentCount(RespCommand command, ByteBufPool allocator) {
ByteBufferUtils.stringToByteBuf("ERR wrong number of arguments for '" + command.getName().toLowerCase() + "' command\r\n", allocator);
}
public static void valueNotInteger(ByteBufPool allocator) {
ByteBufferUtils.stringToByteBuf("-ERR value is not an integer or out of range\r\n", allocator);
}
public static void valueNotAValidFloat(ByteBufPool allocator) {
ByteBufferUtils.stringToByteBuf("-ERR value is not a valid float\r\n", allocator);
}
public static void customError(String message, ByteBufPool allocatorToUse) {
ByteBufferUtils.stringToByteBuf(
"-ERR " + message + "\r\n", allocatorToUse);
}
public static Consumer<ByteBufPool> handleException(Throwable t) {
Throwable ex = t;
while (ex instanceof CompletionException || ex instanceof CacheException) {
ex = ex.getCause();
}
if (ex instanceof ClassCastException) {
return RespErrorUtil::wrongType;
}
if (ex instanceof IndexOutOfBoundsException) {
return RespErrorUtil::indexOutOfRange;
}
if (ex instanceof NumberFormatException) {
return RespErrorUtil::valueNotInteger;
}
return null;
}
}
| 2,818
| 32.164706
| 140
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/RespServer.java
|
package org.infinispan.server.resp;
import static org.infinispan.commons.logging.Log.CONFIG;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.logging.Log;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.commons.time.TimeService;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.distribution.ch.impl.CRC16HashFunctionPartitioner;
import org.infinispan.factories.GlobalComponentRegistry;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.server.core.AbstractProtocolServer;
import org.infinispan.server.core.transport.NettyChannelInitializer;
import org.infinispan.server.core.transport.NettyInitializers;
import org.infinispan.server.iteration.DefaultIterationManager;
import org.infinispan.server.iteration.ExternalSourceIterationManager;
import org.infinispan.server.resp.configuration.RespServerConfiguration;
import org.infinispan.server.resp.filter.GlobMatchFilterConverterFactory;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInboundHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOutboundHandler;
import io.netty.channel.group.ChannelMatcher;
/**
* Server that supports RESP protocol
*
* @author William Burns
* @since 14.0
*/
public class RespServer extends AbstractProtocolServer<RespServerConfiguration> {
private static final Log log = LogFactory.getLog(RespServer.class);
public static final String RESP_SERVER_FEATURE = "resp-server";
private MediaType configuredValueType = MediaType.APPLICATION_OCTET_STREAM;
private DefaultIterationManager iterationManager;
private ExternalSourceIterationManager dataStructureIterationManager;
private TimeService timeService;
public RespServer() {
super("Resp");
}
@Override
protected void startInternal() {
GlobalComponentRegistry gcr = SecurityActions.getGlobalComponentRegistry(cacheManager);
this.timeService = gcr.getTimeService();
this.iterationManager = new DefaultIterationManager(gcr.getTimeService());
this.dataStructureIterationManager = new ExternalSourceIterationManager(gcr.getTimeService());
iterationManager.addKeyValueFilterConverterFactory(GlobMatchFilterConverterFactory.class.getName(), new GlobMatchFilterConverterFactory());
dataStructureIterationManager.addKeyValueFilterConverterFactory(GlobMatchFilterConverterFactory.class.getName(), new GlobMatchFilterConverterFactory(true));
if (!cacheManager.getCacheManagerConfiguration().features().isAvailable(RESP_SERVER_FEATURE)) {
throw CONFIG.featureDisabled(RESP_SERVER_FEATURE);
}
if (cacheManager.getCacheConfiguration(configuration.defaultCacheName()) == null) {
ConfigurationBuilder builder = new ConfigurationBuilder();
Configuration defaultCacheConfiguration = cacheManager.getDefaultCacheConfiguration();
if (defaultCacheConfiguration != null) { // We have a default configuration, use that
builder.read(defaultCacheConfiguration);
configuredValueType = builder.encoding().value().mediaType();
if (cacheManager.getCacheManagerConfiguration().isClustered() &&
!(builder.clustering().hash().keyPartitioner() instanceof CRC16HashFunctionPartitioner)) {
log.warn("Clustered RESP server should use CRC16HashFunctionPartitioner for key partitioning.");
}
} else {
if (cacheManager.getCacheManagerConfiguration().isClustered()) { // We are running in clustered mode
builder.clustering().cacheMode(CacheMode.REPL_SYNC);
// See: https://redis.io/docs/reference/cluster-spec/#key-distribution-model
builder.clustering().hash().keyPartitioner(new CRC16HashFunctionPartitioner()).numSegments(16384);
}
builder.encoding().key().mediaType(MediaType.APPLICATION_OCTET_STREAM_TYPE);
builder.encoding().value().mediaType(configuredValueType);
}
cacheManager.defineConfiguration(configuration.defaultCacheName(), builder.build());
}
super.startInternal();
}
@Override
public ChannelOutboundHandler getEncoder() {
return null;
}
@Override
public ChannelInboundHandler getDecoder() {
return null;
}
@Override
public ChannelInitializer<Channel> getInitializer() {
return new NettyInitializers(new NettyChannelInitializer<>(this, transport, null, null),
new RespChannelInitializer(this));
}
@Override
public ChannelMatcher getChannelMatcher() {
return channel -> channel.pipeline().get(RespDecoder.class) != null;
}
@Override
public void stop() {
super.stop();
}
/**
* Returns the cache being used by the Resp server
*/
public AdvancedCache<byte[], byte[]> getCache() {
return cacheManager.<byte[], byte[]>getCache(configuration.defaultCacheName()).getAdvancedCache();
}
public Resp3Handler newHandler() {
return new Resp3Handler(this, configuredValueType);
}
@Override
public void installDetector(Channel ch) {
ch.pipeline().addLast(RespDetector.NAME, new RespDetector(this));
}
public DefaultIterationManager getIterationManager() {
return iterationManager;
}
public ExternalSourceIterationManager getDataStructureIterationManager() {
return dataStructureIterationManager;
}
public TimeService getTimeService() {
return timeService;
}
}
| 5,710
| 40.686131
| 162
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/RespCommand.java
|
package org.infinispan.server.resp;
import static org.infinispan.server.resp.commands.Commands.ALL_COMMANDS;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.CompletionStage;
import java.util.function.Consumer;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.server.resp.logging.Log;
import org.infinispan.util.logging.LogFactory;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
public abstract class RespCommand {
protected final static Log log = LogFactory.getLog(RespCommand.class, Log.class);
private final String name;
private final int arity;
private final int firstKeyPos;
private final int lastKeyPos;
private final int steps;
private final byte[] bytes;
public boolean hasValidNumberOfArguments(List<byte[]> arguments){
// Command arity always includes the command's name itself (and the subcommand when applicable).
// A positive integer means a fixed number of arguments.
// A negative integer means a minimal number of arguments.
int numberOfArgs = Math.abs(arity) - 1;
if ((arity > 0 && arguments.size() != numberOfArgs)
|| (arity < 0 && arguments.size() < numberOfArgs)) {
// ERROR
return false;
}
return true;
}
public CompletionStage<RespRequestHandler> handleException(RespRequestHandler handler, Throwable t) {
Consumer<ByteBufPool> writer = RespErrorUtil.handleException(t);
if (writer != null) {
writer.accept(handler.allocator());
return handler.myStage();
}
throw CompletableFutures.asCompletionException(t);
}
/**
* @param arity the number of arguments
* @param firstKeyPos the position of the command's first key name argument. For most commands, the first key's position is 1.
* Position 0 is always the command name itself.
* @param lastKeyPos the position of the command's last key name argument. Redis commands usually accept one, two or multiple number of keys.
* Commands that accept a single key have both first key and last key set to 1.
* Commands that accept two key name arguments, e.g. BRPOPLPUSH, SMOVE and RENAME, have this value set to the position of their second key.
* Multi-key commands that accept an arbitrary number of keys, such as MSET, use the value -1.
* @param steps the step, or increment, between the first key and the position of the next key.
*/
protected RespCommand(int arity, int firstKeyPos, int lastKeyPos, int steps) {
this.name = this.getClass().getSimpleName();
this.arity = arity;
this.firstKeyPos = firstKeyPos;
this.lastKeyPos = lastKeyPos;
this.steps = steps;
this.bytes = name.getBytes(StandardCharsets.US_ASCII);
}
/**
* @param name the name of the command
* @param arity the number of arguments
* @param firstKeyPos the position of the command's first key name argument. For most commands, the first key's position is 1.
* Position 0 is always the command name itself.
* @param lastKeyPos the position of the command's last key name argument. Redis commands usually accept one, two or multiple number of keys.
* Commands that accept a single key have both first key and last key set to 1.
* Commands that accept two key name arguments, e.g. BRPOPLPUSH, SMOVE and RENAME, have this value set to the position of their second key.
* Multi-key commands that accept an arbitrary number of keys, such as MSET, use the value -1.
* @param steps the step, or increment, between the first key and the position of the next key.
*/
protected RespCommand(String name, int arity, int firstKeyPos, int lastKeyPos, int steps) {
this.name = name;
this.arity = arity;
this.firstKeyPos = firstKeyPos;
this.lastKeyPos = lastKeyPos;
this.steps = steps;
this.bytes = name.getBytes(StandardCharsets.US_ASCII);
}
public String getName() {
return name;
}
public static RespCommand fromByteBuf(ByteBuf buf, int commandLength) {
if (buf.readableBytes() < commandLength + 2) {
return null;
}
int readOffset = buf.readerIndex();
// We already asserted we have enough bytes, just mark them as read now, since we have to possibly read the
// bytes multiple times to check for various commands
buf.readerIndex(readOffset + commandLength + 2);
byte b = buf.getByte(readOffset);
byte ignoreCase = b >= 97 ? (byte) (b - 97) : (byte) (b - 65);
if (ignoreCase < 0 || ignoreCase > 25) {
return null;
}
RespCommand[] target = ALL_COMMANDS[ignoreCase];
if (target == null) {
return null;
}
for (RespCommand possible : target) {
if (possible.match(buf, commandLength, readOffset)) {
return possible;
}
}
return null;
}
public final boolean match(byte[] other) {
return match(Unpooled.wrappedBuffer(other), other.length, 0);
}
private boolean match(ByteBuf buf, int length, int offset) {
byte[] possibleBytes = bytes;
if (length == possibleBytes.length) {
boolean matches = true;
for (int i = 0; i < possibleBytes.length; ++i) {
byte upperByte = possibleBytes[i];
byte targetByte = buf.getByte(offset + i);
if (upperByte == targetByte || upperByte + 32 == targetByte) {
continue;
}
matches = false;
break;
}
return matches;
}
log.tracef("Unknown command %s", buf.getCharSequence(offset, length, StandardCharsets.US_ASCII));
return false;
}
public int getArity() {
return arity;
}
public int getFirstKeyPos() {
return firstKeyPos;
}
public int getLastKeyPos() {
return lastKeyPos;
}
public int getSteps() {
return steps;
}
@Override
public String toString() {
return name;
}
}
| 6,228
| 37.450617
| 161
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/RespRequestHandler.java
|
package org.infinispan.server.resp;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.Executor;
import java.util.function.BiConsumer;
import java.util.function.Function;
import org.infinispan.server.resp.commands.connection.QUIT;
import org.infinispan.util.concurrent.CompletionStages;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.AttributeKey;
public abstract class RespRequestHandler {
protected final CompletionStage<RespRequestHandler> myStage = CompletableFuture.completedFuture(this);
public static final AttributeKey<ByteBufPool> BYTE_BUF_POOL_ATTRIBUTE_KEY = AttributeKey.newInstance("buffer-pool");
ByteBufPool allocatorToUse;
protected void initializeIfNecessary(ChannelHandlerContext ctx) {
if (allocatorToUse == null) {
if (!ctx.channel().hasAttr(BYTE_BUF_POOL_ATTRIBUTE_KEY)) {
throw new IllegalStateException("BufferPool was not initialized in the context " + ctx);
}
allocatorToUse = ctx.channel().attr(BYTE_BUF_POOL_ATTRIBUTE_KEY).get();
}
}
public CompletionStage<RespRequestHandler> myStage() {
return myStage;
}
public ByteBufPool allocator() {
return allocatorToUse;
}
public final CompletionStage<RespRequestHandler> handleRequest(ChannelHandlerContext ctx, RespCommand command, List<byte[]> arguments) {
initializeIfNecessary(ctx);
if (command == null) {
RespErrorUtil.unknownCommand(allocatorToUse);
return myStage;
}
if (!command.hasValidNumberOfArguments(arguments)) {
RespErrorUtil.wrongArgumentNumber(command, allocator());
return myStage;
}
return actualHandleRequest(ctx, command, arguments);
}
/**
* Handles the RESP request returning a stage that when complete notifies the command has completed as well as
* providing the request handler for subsequent commands.
* <p>
* Implementations should never use the ByteBufAllocator in the context.
* Instead, they should use {@link #allocatorToUse} to retrieve a ByteBuffer.
* This ByteBuffer should only have bytes written to it adding up to the size requested.
* The ByteBuffer itself should never be written to the context or channel and flush should also never be invoked.
* Failure to do so may cause mis-ordering or responses as requests support pipelining and a ByteBuf may not be
* send down stream until later in the pipeline.
*
* @param ctx Netty context pipeline for this request
* @param type The command type
* @param arguments The remaining arguments to the command
* @return stage that when complete returns the new handler to instate. This stage <b>must</b> be completed on the event loop
*/
protected CompletionStage<RespRequestHandler> actualHandleRequest(ChannelHandlerContext ctx, RespCommand type, List<byte[]> arguments) {
if (type instanceof QUIT) {
ctx.close();
return myStage;
}
RespErrorUtil.unknownCommand(allocatorToUse);
return myStage;
}
public void handleChannelDisconnect(ChannelHandlerContext ctx) {
// Do nothing by default
}
public <E> CompletionStage<RespRequestHandler> stageToReturn(CompletionStage<E> stage, ChannelHandlerContext ctx,
BiConsumer<? super E, ByteBufPool> biConsumer) {
return stageToReturn(stage, ctx, Objects.requireNonNull(biConsumer), null);
}
public <E> CompletionStage<RespRequestHandler> stageToReturn(CompletionStage<E> stage, ChannelHandlerContext ctx,
Function<E, RespRequestHandler> handlerWhenComplete) {
return stageToReturn(stage, ctx, null, Objects.requireNonNull(handlerWhenComplete));
}
/**
* Handles ensuring that a stage TriConsumer is only invoked on the event loop. The TriConsumer can then do things
* such as writing to the underlying channel or update variables in a thread safe manner without additional
* synchronization or volatile variables.
* <p>
* If the TriConsumer provided is null the provided stage <b>must</b> be completed only on the event loop of the
* provided ctx.
* This can be done via the Async methods on {@link CompletionStage} such as {@link CompletionStage#thenApplyAsync(Function, Executor)};
* <p>
* If the returned stage was completed exceptionally, any exception is ignored, assumed to be handled in the
* <b>biConsumer</b> or further up the stage.
* The <b>handlerWhenComplete</b> is not invoked if the stage was completed exceptionally as well.
* If the <b>triConsumer</b> or <b>handlerWhenComplete</b> throw an exception when invoked the returned stage will
* complete with that exception.
* <p>
* This method can only be invoked on the event loop for the provided ctx.
*
* @param <E> The stage return value
* @param stage The stage that will complete. Note that if biConsumer is null this stage may only be completed on the event loop
* @param ctx The context used for this request, normally the event loop is the thing used
* @param biConsumer The consumer to be ran on
* @param handlerWhenComplete A function to map the result to which handler will be used for future requests. Only ever invoked on the event loop. May be null, if so the current handler is returned
* @return A stage that is only ever completed on the event loop that provides the new handler to use
*/
private <E> CompletionStage<RespRequestHandler> stageToReturn(CompletionStage<E> stage, ChannelHandlerContext ctx,
BiConsumer<? super E, ByteBufPool> biConsumer, Function<E, RespRequestHandler> handlerWhenComplete) {
assert ctx.channel().eventLoop().inEventLoop();
// Only one or the other can be null
assert (biConsumer != null && handlerWhenComplete == null) || (biConsumer == null && handlerWhenComplete != null) :
"triConsumer was: " + biConsumer + " and handlerWhenComplete was: " + handlerWhenComplete;
if (CompletionStages.isCompletedSuccessfully(stage)) {
E result = CompletionStages.join(stage);
try {
if (handlerWhenComplete != null) {
return CompletableFuture.completedFuture(handlerWhenComplete.apply(result));
}
biConsumer.accept(result, allocatorToUse);
} catch (Throwable t) {
return CompletableFuture.failedFuture(t);
}
return myStage;
}
if (biConsumer != null) {
// Note that this method is only ever invoked in the event loop, so this whenCompleteAsync can never complete
// until this request completes, meaning the thenApply will always be invoked in the event loop as well
return CompletionStages.handleAndComposeAsync(stage, (e, t) -> {
if (t != null) {
Resp3Handler.handleThrowable(allocatorToUse, t);
} else {
try {
biConsumer.accept(e, allocatorToUse);
} catch (Throwable innerT) {
return CompletableFuture.failedFuture(innerT);
}
}
return myStage;
}, ctx.channel().eventLoop());
}
return stage.handle((value, t) -> {
if (t != null) {
// If exception, never use handler
return this;
}
return handlerWhenComplete.apply(value);
});
}
}
| 7,522
| 45.438272
| 200
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/BaseRespDecoder.java
|
package org.infinispan.server.resp;
import org.infinispan.server.resp.logging.Log;
import org.infinispan.util.logging.LogFactory;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
public abstract class BaseRespDecoder extends ByteToMessageDecoder {
protected final static Log log = LogFactory.getLog(BaseRespDecoder.class, Log.class);
protected final Intrinsics.Resp2LongProcessor longProcessor = new Intrinsics.Resp2LongProcessor();
protected ChannelHandlerContext ctx;
@Override
public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
super.channelRegistered(ctx);
this.ctx = ctx;
}
public void resumeRead() {
// Also double check auto read in case if enabling auto read caused more bytes to be read which in turn disabled
// auto read again
if (internalBuffer().isReadable() && ctx.channel().config().isAutoRead()) {
// Schedule the read for later to prevent possible StackOverflow
ctx.channel().eventLoop().submit(() -> {
try {
// We HAVE to use our ctx otherwise a read may be in the wrong spot of the pipeline
channelRead(ctx, Unpooled.EMPTY_BUFFER);
channelReadComplete(ctx);
} catch (Throwable t) {
ctx.fireExceptionCaught(t);
}
});
}
}
}
| 1,438
| 35.897436
| 118
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/Intrinsics.java
|
package org.infinispan.server.resp;
import java.nio.charset.StandardCharsets;
import io.netty.buffer.ByteBuf;
import io.netty.util.ByteProcessor;
public class Intrinsics {
private static final int TERMINATOR_LENGTH = 2;
public static byte singleByte(ByteBuf buffer) {
if (buffer.isReadable()) {
return buffer.readByte();
} else return 0;
}
public static String simpleString(ByteBuf buf) {
// Find the end LF (would be nice to do this without iterating twice)
int offset = buf.forEachByte(ByteProcessor.FIND_LF);
if (offset <= 0) {
return null;
}
if (buf.getByte(offset - 1) != '\r') {
throw new IllegalStateException("No matching \r character found before \n");
}
String simpleString = buf.toString(buf.readerIndex(), offset - 1 - buf.readerIndex(), StandardCharsets.US_ASCII);
// toString doesn't move the reader index forward
buf.readerIndex(offset + 1);
return simpleString;
}
public static RespCommand simpleCommand(ByteBuf buf) {
// Find the end LF (would be nice to do this without iterating twice)
int offset = buf.forEachByte(ByteProcessor.FIND_LF);
if (offset <= 0) {
return null;
}
if (buf.getByte(offset - 1) != '\r') {
throw new IllegalStateException("No matching \r character found before \n");
}
return RespCommand.fromByteBuf(buf, offset - 1 - buf.readerIndex());
}
public static long readNumber(ByteBuf buf, Resp2LongProcessor longProcessor) {
long value = longProcessor.getValue(buf);
// The longProcessor can technically read up to only /r, we need to ensure there is /r and /n
if (longProcessor.complete && buf.readableBytes() >= longProcessor.bytesRead + TERMINATOR_LENGTH) {
buf.skipBytes(longProcessor.bytesRead + TERMINATOR_LENGTH);
}
return value;
}
public static byte[] readTerminatedBytes(ByteBuf buf) {
// Find the end LF (would be nice to do this without iterating twice)
int offset = buf.forEachByte(ByteProcessor.FIND_LF);
if (offset <= 0) {
return null;
}
if (buf.getByte(offset - 1) != '\r') {
throw new IllegalStateException("No matching \r character found before \n");
}
byte[] data = new byte[offset - 1 - buf.readerIndex()];
buf.readBytes(data);
buf.skipBytes(TERMINATOR_LENGTH);
return data;
}
/**
* This method is only used for numerics that when parsed must be 0 or positive
* If a valid number is returned, then the ByteBuf will have its read index moved to the next element
*/
private static int readSizeAndCheckRemainder(ByteBuf buf, Resp2LongProcessor longProcessor) {
buf.markReaderIndex();
int pos = buf.readerIndex();
long longSize = readNumber(buf, longProcessor);
if (longSize > Integer.MAX_VALUE) {
throw new IllegalArgumentException("Bytes cannot be longer than " + Integer.MAX_VALUE);
}
// If we didn't read any bytes then the number wasn't parsed properly
if (pos == buf.readerIndex()) {
return -1;
}
int size = (int) longSize;
if (size < 0) {
throw new IllegalArgumentException("Number cannot be negative");
}
if (buf.readableBytes() < size + TERMINATOR_LENGTH) {
buf.resetReaderIndex();
return -1;
}
return size;
}
public static String bulkString(ByteBuf buf, Resp2LongProcessor longProcessor) {
int size = readSizeAndCheckRemainder(buf, longProcessor);
if (size == -1) {
return null;
}
String stringValue = buf.toString(buf.readerIndex(), size, StandardCharsets.US_ASCII);
buf.skipBytes(size + TERMINATOR_LENGTH);
return stringValue;
}
public static RespCommand bulkCommand(ByteBuf buf, Resp2LongProcessor longProcessor) {
int size = readSizeAndCheckRemainder(buf, longProcessor);
if (size == -1) {
return null;
}
return RespCommand.fromByteBuf(buf, size);
}
public static byte[] bulkArray(ByteBuf buf, Resp2LongProcessor longProcessor) {
int size = readSizeAndCheckRemainder(buf, longProcessor);
if (size == -1) {
return null;
}
byte[] array = new byte[size];
buf.readBytes(array);
buf.skipBytes(TERMINATOR_LENGTH);
return array;
}
static class Resp2LongProcessor implements ByteProcessor {
long result;
int bytesRead;
boolean complete;
boolean negative;
boolean first;
public long getValue(ByteBuf buffer) {
this.result = 0;
this.bytesRead = 0;
this.complete = false;
this.first = true;
// We didn't have enough to read the number
if (buffer.forEachByte(this) == -1) {
complete = false;
return -1;
}
complete = true;
if (!this.negative) {
this.result = -this.result;
}
return this.result;
}
@Override
public boolean process(byte value) {
if (value == '\r') {
return false;
}
bytesRead++;
if (first) {
first = false;
if (value == '-') {
negative = true;
} else {
negative = false;
int digit = value - '0';
result = result * 10 - digit;
}
return true;
}
int digit = value - '0';
result = result * 10 - digit;
return true;
}
}
}
| 5,619
| 30.222222
| 119
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/ByteBufPool.java
|
package org.infinispan.server.resp;
import java.util.function.IntFunction;
import io.netty.buffer.ByteBuf;
@FunctionalInterface
public interface ByteBufPool extends IntFunction<ByteBuf> {
/**
* This method will return a pooled ByteBuf.
* This buffer may already have bytes written to it.
* A caller should only ever write additional bytes to the buffer and not change it in any other way.
* <p>
* The returned ByteBuf should never be written as the decoder will handle this instead
*
* @param requiredSize The amount of bytes required to be writable into the ByteBuf
* @return a ByteBuf to write those bytes to
*/
default ByteBuf acquire(int requiredSize) {
return apply(requiredSize);
}
}
| 744
| 31.391304
| 104
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/Util.java
|
package org.infinispan.server.resp;
import java.nio.charset.StandardCharsets;
import org.infinispan.commons.time.TimeService;
public class Util {
private Util() { }
/**
* Checks if target is equal to expected. This method is case-insensitive and only works with ASCII characters.
* The characters on expected must be in uppercase.
*
* @param expected: Upper case ASCII characters.
* @param target: ASCII characters to verify.
* @return true if target is equal to expected, false otherwise.
*/
public static boolean isAsciiBytesEquals(byte[] expected, byte[] target) {
if (expected.length != target.length) return false;
for (int i = 0; i < expected.length; i++) {
assert isAsciiUppercase(expected[i]) : "Expected byte is not uppercase ASCII";
assert isAsciiChar(target[i]) : "Target byte is not ASCII";
byte l = target[i];
byte r = expected[i];
if (l != r && l != (r - 32)) return false;
}
return true;
}
/**
* Checks if target is equal to expected. This method is case-insensitive and only works with ASCII characters.
* The expected char must be in uppercase.
*
* @param expected: Upper case ASCII character.
* @param actual: ASCII character to verify.
* @return true if actual is equal to expected, false otherwise.
*/
public static boolean caseInsensitiveAsciiCheck(char expected, byte actual) {
assert isAsciiUppercase((byte) expected) : "Expected byte is not uppercase ASCII";
assert isAsciiChar(actual) : "Target byte is not ASCII";
return expected == actual || expected == (actual - 32);
}
public static boolean isAsciiChar(byte b) {
return isAsciiLowercase(b) || isAsciiUppercase(b);
}
public static boolean isAsciiUppercase(byte b) {
return b >= 65 && b <= 90;
}
public static boolean isAsciiLowercase(byte b) {
return b >= 97 && b <= 122;
}
public static String utf8(byte[] b) {
return new String(b, StandardCharsets.UTF_8);
}
public static long toUnixTime(long time, TimeService timeService) {
if (time < 0) return time;
long unixTime = time + timeService.wallClockTime();
return unixTime < 0 ? 0 : unixTime;
}
public static long fromUnixTime(long unixTime, TimeService timeService) {
if (unixTime < 0) return unixTime;
long time = unixTime - timeService.wallClockTime();
return time < 0 ? 0 : time;
}
}
| 2,490
| 32.213333
| 114
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/configuration/package-info.java
|
/**
* Resp Protocol Server Configuration API
*
* @api.public
*/
package org.infinispan.server.resp.configuration;
| 118
| 16
| 49
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/configuration/RespAuthenticationConfiguration.java
|
package org.infinispan.server.resp.configuration;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.server.core.configuration.AuthenticationConfiguration;
import org.infinispan.server.resp.authentication.RespAuthenticator;
/**
* RespAuthenticationConfiguration.
*
* @author Tristan Tarrant
* @since 14.0
*/
public class RespAuthenticationConfiguration extends ConfigurationElement<RespAuthenticationConfiguration> implements AuthenticationConfiguration {
public static final AttributeDefinition<String> SECURITY_REALM = AttributeDefinition.builder("security-realm", null, String.class).immutable().build();
private final boolean enabled;
private final RespAuthenticator authenticator;
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(RespAuthenticationConfiguration.class, SECURITY_REALM);
}
RespAuthenticationConfiguration(AttributeSet attributes, RespAuthenticator authenticator, boolean enabled) {
super("authentication", attributes);
this.enabled = enabled;
this.authenticator = authenticator;
}
public boolean enabled() {
return enabled;
}
public RespAuthenticator authenticator() {
return authenticator;
}
public String securityRealm() {
return attributes.attribute(SECURITY_REALM).get();
}
}
| 1,516
| 34.27907
| 154
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/configuration/RespServerConfigurationBuilder.java
|
package org.infinispan.server.resp.configuration;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.core.admin.AdminOperationsHandler;
import org.infinispan.server.core.configuration.EncryptionConfigurationBuilder;
import org.infinispan.server.core.configuration.ProtocolServerConfigurationBuilder;
/**
* RespServerConfigurationBuilder.
*
* @author William Burns
* @since 14.0
*/
public class RespServerConfigurationBuilder extends ProtocolServerConfigurationBuilder<RespServerConfiguration, RespServerConfigurationBuilder, RespAuthenticationConfiguration> implements
Builder<RespServerConfiguration> {
private final RespAuthenticationConfigurationBuilder authentication = new RespAuthenticationConfigurationBuilder(this);
private final EncryptionConfigurationBuilder encryption = new EncryptionConfigurationBuilder(ssl());
public RespServerConfigurationBuilder() {
super(RespServerConfiguration.DEFAULT_RESP_PORT, RespServerConfiguration.attributeDefinitionSet());
this.defaultCacheName(RespServerConfiguration.DEFAULT_RESP_CACHE);
}
@Override
public AttributeSet attributes() {
return attributes;
}
@Override
public RespServerConfigurationBuilder self() {
return this;
}
/**
* Use {@link ProtocolServerConfigurationBuilder#defaultCacheName(String)} instead
*/
@Deprecated
public RespServerConfigurationBuilder cache(String cache) {
this.defaultCacheName(cache);
return this;
}
@Override
public RespServerConfigurationBuilder adminOperationsHandler(AdminOperationsHandler handler) {
// Ignore
return this;
}
@Override
public RespAuthenticationConfigurationBuilder authentication() {
return authentication;
}
public EncryptionConfigurationBuilder encryption() {
return encryption;
}
@Override
public RespServerConfiguration create() {
return new RespServerConfiguration(attributes.protect(), ipFilter.create(), ssl.create(), authentication.create(), encryption.create());
}
public RespServerConfiguration build(boolean validate) {
if (validate) {
validate();
}
return create();
}
@Override
public RespServerConfiguration build() {
return build(true);
}
@Override
public Builder<?> read(RespServerConfiguration template, Combine combine) {
super.read(template, combine);
this.authentication.read(template.authentication(), combine);
this.encryption.read(template.encryption(), combine);
return this;
}
}
| 2,713
| 30.55814
| 187
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/configuration/RespServerConfiguration.java
|
package org.infinispan.server.resp.configuration;
import org.infinispan.commons.configuration.BuiltBy;
import org.infinispan.commons.configuration.ConfigurationFor;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.core.configuration.EncryptionConfiguration;
import org.infinispan.server.core.configuration.IpFilterConfiguration;
import org.infinispan.server.core.configuration.ProtocolServerConfiguration;
import org.infinispan.server.core.configuration.SslConfiguration;
import org.infinispan.server.resp.RespServer;
/**
* RespServerConfiguration.
*
* @author William Burns
* @since 14.0
*/
@BuiltBy(RespServerConfigurationBuilder.class)
@ConfigurationFor(RespServer.class)
public class RespServerConfiguration extends ProtocolServerConfiguration<RespServerConfiguration, RespAuthenticationConfiguration> {
public static final int DEFAULT_RESP_PORT = 6379;
public static final String DEFAULT_RESP_CACHE = "respCache";
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(RespServerConfiguration.class, ProtocolServerConfiguration.attributeDefinitionSet());
}
private final RespAuthenticationConfiguration authentication;
private final EncryptionConfiguration encryption;
RespServerConfiguration(AttributeSet attributes, IpFilterConfiguration ipRules, SslConfiguration ssl,
RespAuthenticationConfiguration authentication, EncryptionConfiguration encryption) {
super("resp-connector", attributes, authentication, ssl, ipRules);
this.authentication = authentication;
this.encryption = encryption;
}
@Override
public RespAuthenticationConfiguration authentication() {
return authentication;
}
public EncryptionConfiguration encryption() {
return encryption;
}
}
| 1,848
| 37.520833
| 132
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/configuration/RespAuthenticationConfigurationBuilder.java
|
package org.infinispan.server.resp.configuration;
import static org.infinispan.server.resp.configuration.RespAuthenticationConfiguration.SECURITY_REALM;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.core.configuration.AbstractProtocolServerConfigurationChildBuilder;
import org.infinispan.server.core.configuration.AuthenticationConfigurationBuilder;
import org.infinispan.server.core.configuration.ProtocolServerConfigurationBuilder;
import org.infinispan.server.resp.authentication.RespAuthenticator;
import org.infinispan.server.resp.logging.Log;
/**
* RespAuthenticationConfigurationBuilder.
*
* @author Tristan Tarrant
* @since 14.0
*/
public class RespAuthenticationConfigurationBuilder extends AbstractProtocolServerConfigurationChildBuilder<RespServerConfiguration, RespAuthenticationConfigurationBuilder, RespAuthenticationConfiguration> implements AuthenticationConfigurationBuilder<RespAuthenticationConfiguration> {
private final AttributeSet attributes;
private RespAuthenticator authenticator;
private boolean enabled;
RespAuthenticationConfigurationBuilder(ProtocolServerConfigurationBuilder builder) {
super(builder);
attributes = RespAuthenticationConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public RespAuthenticationConfigurationBuilder enable() {
return enabled(true);
}
public RespAuthenticationConfigurationBuilder disable() {
return enabled(false);
}
public RespAuthenticationConfigurationBuilder enabled(boolean enabled) {
this.enabled = enabled;
return this;
}
public RespAuthenticationConfigurationBuilder securityRealm(String realm) {
attributes.attribute(SECURITY_REALM).set(realm);
return this;
}
public String securityRealm() {
return attributes.attribute(SECURITY_REALM).get();
}
public boolean hasSecurityRealm() {
return !attributes.attribute(SECURITY_REALM).isNull();
}
public RespAuthenticationConfigurationBuilder authenticator(RespAuthenticator authenticator) {
this.authenticator = authenticator;
return this.enable();
}
@Override
public void validate() {
if (enabled && authenticator == null) {
throw Log.CONFIG.authenticationWithoutAuthenticator();
}
}
@Override
public RespAuthenticationConfiguration create() {
return new RespAuthenticationConfiguration(attributes.protect(), authenticator, enabled);
}
@Override
public Builder<?> read(RespAuthenticationConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
return this;
}
@Override
public RespAuthenticationConfigurationBuilder self() {
return this;
}
}
| 2,959
| 31.527473
| 286
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/logging/Log.java
|
package org.infinispan.server.resp.logging;
import org.infinispan.commons.CacheConfigurationException;
import org.jboss.logging.BasicLogger;
import org.jboss.logging.Logger;
import org.jboss.logging.annotations.Cause;
import org.jboss.logging.annotations.LogMessage;
import org.jboss.logging.annotations.Message;
import org.jboss.logging.annotations.MessageLogger;
import org.jboss.logging.annotations.Once;
import java.nio.CharBuffer;
import static org.jboss.logging.Logger.Level.WARN;
/**
* Log abstraction for the Resp protocol server module. For this module, message ids
* ranging from 12001 to 13000 inclusively have been reserved.
*
* @author William Burns
* @since 14.0
*/
@MessageLogger(projectCode = "ISPN")
public interface Log extends BasicLogger {
Log CONFIG = Logger.getMessageLogger(Log.class, "org.infinispan.CONFIG");
Log SERVER = Logger.getMessageLogger(Log.class, "org.infinispan.SERVER");
// @Message(value = "Cache '%s' has expiration enabled which violates the RESP protocol.", id = 12001)
// CacheConfigurationException invalidExpiration(String cacheName);
@Message(value = "Cannot enable authentication without an authenticator.", id = 12002)
CacheConfigurationException authenticationWithoutAuthenticator();
@LogMessage(level = WARN)
@Message(value = "Received an unexpected exception.", id = 12003)
void unexpectedException(@Cause Throwable cause);
@LogMessage(level = WARN)
@Message(value = "An error occurred when removing the listener for channel %s", id = 12004)
void exceptionWhileRemovingListener(@Cause Throwable cause, CharBuffer channelName);
@LogMessage(level = WARN)
@Message(value = "There was an error adding listener for channel %s", id = 12005)
void exceptionWhileRegisteringListener(@Cause Throwable cause, CharBuffer channelName);
@LogMessage(level = WARN)
@Message(value = "LMOVE command can't guarantee atomicity and consistency when the source list and the destination list are different", id = 12006)
@Once
void lmoveConsistencyMessage();
}
| 2,058
| 39.372549
| 150
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/filter/GlobMatchFilterConverter.java
|
package org.infinispan.server.resp.filter;
import java.nio.charset.StandardCharsets;
import java.util.regex.Pattern;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.util.GlobUtils;
import org.infinispan.commons.util.Util;
import org.infinispan.filter.AbstractKeyValueFilterConverter;
import org.infinispan.metadata.Metadata;
import org.infinispan.protostream.annotations.ProtoFactory;
import org.infinispan.protostream.annotations.ProtoField;
import org.infinispan.protostream.annotations.ProtoName;
/**
* A {@link org.infinispan.filter.KeyValueFilterConverter} which matches the key against a glob pattern. Since the
* value is unused, it just returns an empty byte array
*
* @since 15.0
**/
@ProtoName("GlobMatchFilterConverter")
public class GlobMatchFilterConverter<K, V> extends AbstractKeyValueFilterConverter<byte[], V, byte[]> {
@ProtoField()
final String glob;
@ProtoField(number = 2, defaultValue = "false")
final boolean returnValue;
private transient final Pattern pattern;
@ProtoFactory
GlobMatchFilterConverter(String glob, boolean returnValue) {
this.glob = glob;
this.returnValue = returnValue;
this.pattern = Pattern.compile(GlobUtils.globToRegex(glob));
}
@Override
public MediaType format() {
return null;
}
@Override
public byte[] filterAndConvert(byte[] key, V value, Metadata metadata) {
String k = new String(key, StandardCharsets.UTF_8);
if (pattern.matcher(k).matches()) {
return returnValue ? (byte[]) value : Util.EMPTY_BYTE_ARRAY;
} else {
return null;
}
}
}
| 1,645
| 30.653846
| 114
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/filter/GlobMatchFilterConverterFactory.java
|
package org.infinispan.server.resp.filter;
import java.nio.charset.StandardCharsets;
import org.infinispan.filter.KeyValueFilterConverter;
import org.infinispan.filter.ParamKeyValueFilterConverterFactory;
/**
* @since 15.0
**/
public class GlobMatchFilterConverterFactory implements ParamKeyValueFilterConverterFactory<byte[], byte[], byte[]> {
private final boolean returnValue;
public GlobMatchFilterConverterFactory() {
this(false);
}
public GlobMatchFilterConverterFactory(boolean returnValue) {
this.returnValue = returnValue;
}
@Override
public KeyValueFilterConverter<byte[], byte[], byte[]> getFilterConverter(Object[] params) {
return new GlobMatchFilterConverter(new String((byte[]) params[0], StandardCharsets.UTF_8), returnValue);
}
}
| 798
| 27.535714
| 117
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/Commands.java
|
package org.infinispan.server.resp.commands;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.commands.cluster.CLUSTER;
import org.infinispan.server.resp.commands.connection.AUTH;
import org.infinispan.server.resp.commands.connection.CLIENT;
import org.infinispan.server.resp.commands.connection.COMMAND;
import org.infinispan.server.resp.commands.connection.DBSIZE;
import org.infinispan.server.resp.commands.connection.ECHO;
import org.infinispan.server.resp.commands.connection.HELLO;
import org.infinispan.server.resp.commands.connection.MEMORY;
import org.infinispan.server.resp.commands.connection.MODULE;
import org.infinispan.server.resp.commands.connection.PING;
import org.infinispan.server.resp.commands.connection.QUIT;
import org.infinispan.server.resp.commands.connection.READONLY;
import org.infinispan.server.resp.commands.connection.READWRITE;
import org.infinispan.server.resp.commands.connection.RESET;
import org.infinispan.server.resp.commands.connection.SELECT;
import org.infinispan.server.resp.commands.generic.EXISTS;
import org.infinispan.server.resp.commands.generic.EXPIRE;
import org.infinispan.server.resp.commands.generic.EXPIREAT;
import org.infinispan.server.resp.commands.generic.EXPIRETIME;
import org.infinispan.server.resp.commands.generic.FLUSHALL;
import org.infinispan.server.resp.commands.generic.FLUSHDB;
import org.infinispan.server.resp.commands.generic.PEXPIRETIME;
import org.infinispan.server.resp.commands.generic.PTTL;
import org.infinispan.server.resp.commands.generic.SCAN;
import org.infinispan.server.resp.commands.generic.TTL;
import org.infinispan.server.resp.commands.generic.TYPE;
import org.infinispan.server.resp.commands.hash.HDEL;
import org.infinispan.server.resp.commands.hash.HEXISTS;
import org.infinispan.server.resp.commands.hash.HGET;
import org.infinispan.server.resp.commands.hash.HGETALL;
import org.infinispan.server.resp.commands.hash.HINCRBY;
import org.infinispan.server.resp.commands.hash.HINCRBYFLOAT;
import org.infinispan.server.resp.commands.hash.HKEYS;
import org.infinispan.server.resp.commands.hash.HLEN;
import org.infinispan.server.resp.commands.hash.HMGET;
import org.infinispan.server.resp.commands.hash.HMSET;
import org.infinispan.server.resp.commands.hash.HRANDFIELD;
import org.infinispan.server.resp.commands.hash.HSCAN;
import org.infinispan.server.resp.commands.hash.HSET;
import org.infinispan.server.resp.commands.hash.HVALS;
import org.infinispan.server.resp.commands.list.LINDEX;
import org.infinispan.server.resp.commands.list.LINSERT;
import org.infinispan.server.resp.commands.list.LLEN;
import org.infinispan.server.resp.commands.list.LMOVE;
import org.infinispan.server.resp.commands.list.LPOP;
import org.infinispan.server.resp.commands.list.LPOS;
import org.infinispan.server.resp.commands.list.LPUSH;
import org.infinispan.server.resp.commands.list.LPUSHX;
import org.infinispan.server.resp.commands.list.LRANGE;
import org.infinispan.server.resp.commands.list.LREM;
import org.infinispan.server.resp.commands.list.LSET;
import org.infinispan.server.resp.commands.list.LTRIM;
import org.infinispan.server.resp.commands.list.RPOP;
import org.infinispan.server.resp.commands.list.RPOPLPUSH;
import org.infinispan.server.resp.commands.list.RPUSH;
import org.infinispan.server.resp.commands.list.RPUSHX;
import org.infinispan.server.resp.commands.pubsub.PSUBSCRIBE;
import org.infinispan.server.resp.commands.pubsub.PUBLISH;
import org.infinispan.server.resp.commands.pubsub.PUNSUBSCRIBE;
import org.infinispan.server.resp.commands.pubsub.SUBSCRIBE;
import org.infinispan.server.resp.commands.pubsub.UNSUBSCRIBE;
import org.infinispan.server.resp.commands.set.SADD;
import org.infinispan.server.resp.commands.set.SCARD;
import org.infinispan.server.resp.commands.set.SINTER;
import org.infinispan.server.resp.commands.set.SINTERCARD;
import org.infinispan.server.resp.commands.set.SINTERSTORE;
import org.infinispan.server.resp.commands.set.SMEMBERS;
import org.infinispan.server.resp.commands.sortedset.ZADD;
import org.infinispan.server.resp.commands.sortedset.ZCARD;
import org.infinispan.server.resp.commands.sortedset.ZCOUNT;
import org.infinispan.server.resp.commands.sortedset.ZPOPMAX;
import org.infinispan.server.resp.commands.sortedset.ZPOPMIN;
import org.infinispan.server.resp.commands.sortedset.ZRANGE;
import org.infinispan.server.resp.commands.sortedset.ZSCORE;
import org.infinispan.server.resp.commands.string.APPEND;
import org.infinispan.server.resp.commands.string.DECR;
import org.infinispan.server.resp.commands.string.DECRBY;
import org.infinispan.server.resp.commands.string.DEL;
import org.infinispan.server.resp.commands.string.GET;
import org.infinispan.server.resp.commands.string.GETDEL;
import org.infinispan.server.resp.commands.string.GETEX;
import org.infinispan.server.resp.commands.string.GETRANGE;
import org.infinispan.server.resp.commands.string.INCR;
import org.infinispan.server.resp.commands.string.INCRBY;
import org.infinispan.server.resp.commands.string.INCRBYFLOAT;
import org.infinispan.server.resp.commands.string.MGET;
import org.infinispan.server.resp.commands.string.MSET;
import org.infinispan.server.resp.commands.string.SET;
import org.infinispan.server.resp.commands.string.SETRANGE;
import org.infinispan.server.resp.commands.string.STRALGO;
import org.infinispan.server.resp.commands.string.STRLEN;
/**
* @since 15.0
**/
public final class Commands {
public static final RespCommand[][] ALL_COMMANDS;
static {
ALL_COMMANDS = new RespCommand[26][];
// Just manual for now, but we may want to dynamically at some point.
// NOTE that the order within the sub array matters, commands we want to have the lowest latency should be first
// in this array as they are looked up sequentially for matches
ALL_COMMANDS[0] = new RespCommand[]{new APPEND(), new AUTH()};
ALL_COMMANDS[2] = new RespCommand[]{new CONFIG(), new COMMAND(), new CLUSTER(), new CLIENT() };
// DEL should always be first here
ALL_COMMANDS[3] = new RespCommand[]{new DEL(), new DECR(), new DECRBY(), new DBSIZE()};
ALL_COMMANDS[4] = new RespCommand[]{new ECHO(), new EXISTS(), new EXPIRE(), new EXPIREAT(), new EXPIRETIME()};
ALL_COMMANDS[5] = new RespCommand[]{new FLUSHDB(), new FLUSHALL()};
// GET should always be first here
ALL_COMMANDS[6] = new RespCommand[]{new GET(), new GETDEL(), new GETEX(), new GETRANGE()};
ALL_COMMANDS[7] = new RespCommand[]{new HELLO(), new HGET(), new HSET(), new HLEN(), new HEXISTS(), new HDEL(), new HMGET(), new HKEYS(), new HVALS(), new HSCAN(), new HGETALL(), new HMSET(), new HINCRBY(), new HINCRBYFLOAT(), new HRANDFIELD()};
ALL_COMMANDS[8] = new RespCommand[]{new INCR(), new INCRBY(), new INCRBYFLOAT(), new INFO()};
ALL_COMMANDS[11] = new RespCommand[]{new LINDEX(), new LINSERT(), new LPUSH(), new LPUSHX(), new LPOP(), new LRANGE(), new LLEN(), new LPOS(), new LREM(), new LSET(), new LTRIM(), new LMOVE() };
ALL_COMMANDS[12] = new RespCommand[]{new MGET(), new MSET(), new MODULE(), new MEMORY()};
ALL_COMMANDS[15] = new RespCommand[]{new PUBLISH(), new PING(), new PSUBSCRIBE(), new PUNSUBSCRIBE(), new PTTL(), new PEXPIRETIME()};
ALL_COMMANDS[16] = new RespCommand[]{new QUIT()};
ALL_COMMANDS[17] = new RespCommand[]{new RPUSH(), new RPUSHX(), new RPOP(), new RESET(), new READWRITE(), new READONLY(), new RPOPLPUSH() };
// SET should always be first here
ALL_COMMANDS[18] = new RespCommand[]{new SET(), new SMEMBERS(), new SADD(), new STRLEN(), new SCARD(), new SINTER(), new SINTERSTORE(), new SINTERCARD(), new SUBSCRIBE(), new SELECT(), new STRALGO(), new SCAN(), new SETRANGE()};
ALL_COMMANDS[19] = new RespCommand[]{new TTL(), new TYPE()};
ALL_COMMANDS[20] = new RespCommand[]{new UNSUBSCRIBE()};
ALL_COMMANDS[25] = new RespCommand[]{new ZADD(), new ZCARD(), new ZCOUNT(), new ZPOPMAX(), new ZPOPMIN(), new ZRANGE(), new ZSCORE()};
}
public static List<RespCommand> all() {
List<RespCommand> respCommands = new ArrayList<>();
for (RespCommand[] commands : ALL_COMMANDS) {
if (commands != null) {
respCommands.addAll(Arrays.asList(commands));
}
}
return respCommands;
}
}
| 8,375
| 57.166667
| 251
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/INFO.java
|
package org.infinispan.server.resp.commands;
import static org.infinispan.server.resp.Resp3Handler.handleBulkResult;
import static org.infinispan.server.resp.RespConstants.CRLF_STRING;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
import java.util.EnumSet;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.commons.jdkspecific.ProcessInfo;
import org.infinispan.commons.util.Version;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespCommand;
import org.infinispan.server.resp.RespRequestHandler;
import io.netty.channel.ChannelHandlerContext;
/**
* <a href="https://redis.io/commands/info/">INFO</a>
*
* This implementation attempts to return all attributes that a real Redis server returns. However, in most
* cases, the values are set to 0, because they cannot be retrieved or don't make any sense in Infinispan.
*
* @since 15.0
*/
public class INFO extends RespCommand implements Resp3Command {
public INFO() {
super(-1, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
handler.checkPermission(AuthorizationPermission.ADMIN);
final EnumSet<Section> sections;
if (arguments.isEmpty()) {
sections = Section.DEFAULT.implies();
} else {
sections = EnumSet.noneOf(Section.class);
for (byte[] arg : arguments) {
String section = new String(arg, StandardCharsets.UTF_8);
sections.addAll(Section.valueOf(section.toUpperCase()).implies());
}
}
StringBuilder sb = new StringBuilder();
if (sections.contains(Section.SERVER)) {
sb.append("# Server\r\n");
sb.append("redis_version:");
sb.append(Version.getMajorMinor());
sb.append(CRLF_STRING);
sb.append("redis_git_sha1:");
sb.append(Version.getProperty("infinispan.build.commitid"));
sb.append(CRLF_STRING);
sb.append("redis_git_dirty:0\r\n");
sb.append("redis_build_id:");
sb.append(Version.getVersion());
sb.append(CRLF_STRING);
sb.append("redis_mode:");
switch (handler.cache().getCacheConfiguration().clustering().cacheMode()) {
case LOCAL:
sb.append("standalone\r\n");
break;
case REPL_ASYNC:
case REPL_SYNC:
sb.append("sentinel\r\n");
break;
case DIST_ASYNC:
case DIST_SYNC:
sb.append("cluster\r\n");
break;
}
sb.append("os:");
sb.append(System.getProperty("os.name"));
sb.append(' ');
sb.append(System.getProperty("os.version"));
sb.append(' ');
sb.append(System.getProperty("os.arch"));
sb.append(CRLF_STRING);
sb.append("arch_bits:");
sb.append(System.getProperty("os.arch").endsWith("64") ? "64" : "32");
sb.append(CRLF_STRING);
sb.append("monotonic_clock:POSIX clock_gettime\r\n");
sb.append("multiplexing_api:epoll\r\n"); // TODO: use server socket channel in use
sb.append("atomicvar_api:c11 - builtin\r\n");
sb.append("process_id:");
sb.append(ProcessInfo.getInstance().getPid());
sb.append(CRLF_STRING);
sb.append("process_supervised:no\r\n");
sb.append("run_id:0000000000000\r\n"); // get UUID
sb.append("tcp_port:");
sb.append(((InetSocketAddress) ctx.channel().localAddress()).getPort());
sb.append(CRLF_STRING);
sb.append("server_time_usec:");
sb.append(System.currentTimeMillis() * 1000);
sb.append(CRLF_STRING);
sb.append("uptime_in_seconds:0\r\n");
sb.append("uptime_in_days:0\r\n");
sb.append("hz:10\r\n");
sb.append("configured_hz:10\r\n");
sb.append("lru_clock:0\r\n");
sb.append("executable:server\r\n");
sb.append("config_file:infinispan.xml\r\n");
sb.append("io_threads_active:0\r\n");
sb.append(CRLF_STRING);
}
if (sections.contains(Section.CLIENTS)) {
sb.append("# Clients\r\n");
sb.append("connected_clients:1\r\n");
sb.append("cluster_connections:1\r\n");
sb.append("maxclients:10000\r\n");
sb.append("client_recent_max_input_buffer:0\r\n");
sb.append("client_recent_max_output_buffer:0\r\n");
sb.append("blocked_clients:0\r\n");
sb.append("tracking_clients:0\r\n");
sb.append("clients_in_timeout_table:0\r\n");
sb.append(CRLF_STRING);
}
if (sections.contains(Section.MEMORY)) {
sb.append("# Memory\r\n");
sb.append("used_memory:0\r\n");
sb.append("used_memory_human:0M\r\n");
sb.append("used_memory_rss:0\r\n");
sb.append("used_memory_rss_human:0M\r\n");
sb.append("used_memory_peak:0\r\n");
sb.append("used_memory_peak_human:0M\r\n");
sb.append("used_memory_peak_perc:0%\r\n");
sb.append("used_memory_overhead:0\r\n");
sb.append("used_memory_startup:0\r\n");
sb.append("used_memory_dataset:0\r\n");
sb.append("used_memory_dataset_perc:0%\r\n");
sb.append("allocator_allocated:0\r\n");
sb.append("allocator_active:0\r\n");
sb.append("allocator_resident:0\r\n");
sb.append("total_system_memory:0\r\n");
sb.append("total_system_memory_human:0G\r\n");
sb.append("used_memory_lua:0\r\n");
sb.append("used_memory_vm_eval:0\r\n");
sb.append("used_memory_lua_human:0K\r\n");
sb.append("used_memory_scripts_eval:0\r\n");
sb.append("number_of_cached_scripts:0\r\n");
sb.append("number_of_functions:0\r\n");
sb.append("number_of_libraries:0\r\n");
sb.append("used_memory_vm_functions:0\r\n");
sb.append("used_memory_vm_total:0\r\n");
sb.append("used_memory_vm_total_human:0K\r\n");
sb.append("used_memory_functions:0\r\n");
sb.append("used_memory_scripts:0\r\n");
sb.append("used_memory_scripts_human:0\r\n");
sb.append("maxmemory:0\r\n");
sb.append("maxmemory_human:0G\r\n");
sb.append("maxmemory_policy:allkeys-lru\r\n");
sb.append("allocator_frag_ratio:0\r\n");
sb.append("allocator_frag_bytes:0\r\n");
sb.append("allocator_rss_ratio:0\r\n");
sb.append("allocator_rss_bytes:0\r\n");
sb.append("rss_overhead_ratio:0\r\n");
sb.append("rss_overhead_bytes:0\r\n");
sb.append("mem_fragmentation_ratio:0\r\n");
sb.append("mem_fragmentation_bytes:0\r\n");
sb.append("mem_not_counted_for_evict:0\r\n");
sb.append("mem_replication_backlog:0\r\n");
sb.append("mem_total_replication_buffers:0\r\n");
sb.append("mem_clients_slaves:0\r\n");
sb.append("mem_clients_normal:0\r\n");
sb.append("mem_cluster_links:0\r\n");
sb.append("mem_aof_buffer:0\r\n");
sb.append("mem_allocator:none\r\n");
sb.append("active_defrag_running:0\r\n");
sb.append("lazyfree_pending_objects:0\r\n");
sb.append("lazyfreed_objects:0\r\n");
sb.append(CRLF_STRING);
}
if (sections.contains(Section.PERSISTENCE)) {
sb.append("# Persistence\r\n");
sb.append("loading:0\r\n");
sb.append("async_loading:0\r\n");
sb.append("current_cow_peak:0\r\n");
sb.append("current_cow_size:0\r\n");
sb.append("current_cow_size_age:0\r\n");
sb.append("current_fork_perc:0.00\r\n");
sb.append("current_save_keys_processed:0\r\n");
sb.append("current_save_keys_total:0\r\n");
sb.append("rdb_changes_since_last_save:0\r\n");
sb.append("rdb_bgsave_in_progress:0\r\n");
sb.append("rdb_last_save_time:0\r\n");
sb.append("rdb_last_bgsave_status:ok\r\n");
sb.append("rdb_last_bgsave_time_sec:-1\r\n");
sb.append("rdb_current_bgsave_time_sec:-1\r\n");
sb.append("rdb_saves:0\r\n");
sb.append("rdb_last_cow_size:0\r\n");
sb.append("rdb_last_load_keys_expired:0\r\n");
sb.append("rdb_last_load_keys_loaded:0\r\n");
sb.append("aof_enabled:0\r\n");
sb.append("aof_rewrite_in_progress:0\r\n");
sb.append("aof_rewrite_scheduled:0\r\n");
sb.append("aof_last_rewrite_time_sec:-1\r\n");
sb.append("aof_current_rewrite_time_sec:-1\r\n");
sb.append("aof_last_bgrewrite_status:ok\r\n");
sb.append("aof_rewrites:0\r\n");
sb.append("aof_rewrites_consecutive_failures:0\r\n");
sb.append("aof_last_write_status:ok\r\n");
sb.append("aof_last_cow_size:0\r\n");
sb.append("module_fork_in_progress:0\r\n");
sb.append("module_fork_last_cow_size:0\r\n");
sb.append(CRLF_STRING);
}
if (sections.contains(Section.STATS)) {
sb.append("# Stats\r\n");
sb.append("total_connections_received:0\r\n");
sb.append("total_commands_processed:0\r\n");
sb.append("instantaneous_ops_per_sec:0\r\n");
sb.append("total_net_input_bytes:0\r\n");
sb.append("total_net_output_bytes:0\r\n");
sb.append("total_net_repl_input_bytes:0\r\n");
sb.append("total_net_repl_output_bytes:0\r\n");
sb.append("instantaneous_input_kbps:0.00\r\n");
sb.append("instantaneous_output_kbps:0.00\r\n");
sb.append("instantaneous_input_repl_kbps:0.00\r\n");
sb.append("instantaneous_output_repl_kbps:0.00\r\n");
sb.append("rejected_connections:0\r\n");
sb.append("sync_full:0\r\n");
sb.append("sync_partial_ok:0\r\n");
sb.append("sync_partial_err:0\r\n");
sb.append("expired_keys:0\r\n");
sb.append("expired_stale_perc:0.00\r\n");
sb.append("expired_time_cap_reached_count:0\r\n");
sb.append("expire_cycle_cpu_milliseconds:0\r\n");
sb.append("evicted_keys:0\r\n");
sb.append("evicted_clients:0\r\n");
sb.append("total_eviction_exceeded_time:0\r\n");
sb.append("current_eviction_exceeded_time:0\r\n");
sb.append("keyspace_hits:0\r\n");
sb.append("keyspace_misses:0\r\n");
sb.append("pubsub_channels:0\r\n");
sb.append("pubsub_patterns:0\r\n");
sb.append("pubsubshard_channels:0\r\n");
sb.append("latest_fork_usec:0\r\n");
sb.append("total_forks:0\r\n");
sb.append("migrate_cached_sockets:0\r\n");
sb.append("slave_expires_tracked_keys:0\r\n");
sb.append("active_defrag_hits:0\r\n");
sb.append("active_defrag_misses:0\r\n");
sb.append("active_defrag_key_hits:0\r\n");
sb.append("active_defrag_key_misses:0\r\n");
sb.append("total_active_defrag_time:0\r\n");
sb.append("current_active_defrag_time:0\r\n");
sb.append("tracking_total_keys:0\r\n");
sb.append("tracking_total_items:0\r\n");
sb.append("tracking_total_prefixes:0\r\n");
sb.append("unexpected_error_replies:0\r\n");
sb.append("total_error_replies:0\r\n");
sb.append("dump_payload_sanitizations:0\r\n");
sb.append("total_reads_processed:0\r\n");
sb.append("total_writes_processed:0\r\n");
sb.append("io_threaded_reads_processed:0\r\n");
sb.append("io_threaded_writes_processed:0\r\n");
sb.append("reply_buffer_shrinks:0\r\n");
sb.append("reply_buffer_expands:0\r\n");
sb.append(CRLF_STRING);
}
if (sections.contains(Section.REPLICATION)) {
sb.append("# Replication\r\n");
sb.append("role:master\r\n");
sb.append("connected_slaves:0\r\n");
sb.append("master_failover_state:no-failover\r\n");
sb.append("master_replid:0000000000000000000000000000000000000000\r\n");
sb.append("master_replid2:0000000000000000000000000000000000000000\r\n");
sb.append("master_repl_offset:0\r\n");
sb.append("second_repl_offset:-1\r\n");
sb.append("repl_backlog_active:0\r\n");
sb.append("repl_backlog_size:0\r\n");
sb.append("repl_backlog_first_byte_offset:0\r\n");
sb.append("repl_backlog_histlen:0\r\n");
sb.append(CRLF_STRING);
}
if (sections.contains(Section.CPU)) {
sb.append("# CPU\r\n");
sb.append("used_cpu_sys:0\r\n");
sb.append("used_cpu_user:0\r\n");
sb.append("used_cpu_sys_children:0.000000\r\n");
sb.append("used_cpu_user_children:0.000000\r\n");
sb.append("used_cpu_sys_main_thread:0.000000\r\n");
sb.append("used_cpu_user_main_thread:0.000000\r\n");
sb.append(CRLF_STRING);
}
if (sections.contains(Section.MODULES)) {
sb.append("# Modules\r\n");
sb.append(CRLF_STRING);
}
if (sections.contains(Section.ERRORSTATS)) {
sb.append("# Errorstats\r\n");
sb.append("errorstat_ERR:count=0\r\n");
sb.append("errorstat_NOPERM:count=0\r\n");
sb.append("errorstat_WRONGTYPE:count=0\r\n");
sb.append(CRLF_STRING);
}
if (sections.contains(Section.CLUSTER)) {
sb.append("# Cluster\r\n");
sb.append("cluster_enabled:0\r\n");
sb.append(CRLF_STRING);
}
if (sections.contains(Section.KEYSPACE)) {
sb.append("# Keyspace\r\n");
sb.append("db0:keys=0,expires=0,avg_ttl=0\r\n");
}
handleBulkResult(sb, handler.allocator());
return handler.myStage();
}
enum Section {
SERVER,
CLIENTS,
MEMORY,
PERSISTENCE,
STATS,
REPLICATION,
CPU,
COMMANDSTATS,
LATENCYSTATS,
SENTINEL,
CLUSTER,
MODULES,
KEYSPACE,
ERRORSTATS,
ALL {
@Override
EnumSet<Section> implies() {
return EnumSet.complementOf(EnumSet.of(MODULES));
}
},
DEFAULT {
@Override
EnumSet<Section> implies() {
return EnumSet.of(SERVER, CLIENTS, MEMORY, PERSISTENCE, STATS, REPLICATION, CPU, MODULES, ERRORSTATS, CLUSTER, KEYSPACE);
}
},
EVERYTHING {
@Override
EnumSet<Section> implies() {
return EnumSet.allOf(Section.class);
}
};
EnumSet<Section> implies() {
return EnumSet.of(this);
}
}
}
| 14,818
| 39.711538
| 133
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/CONFIG.java
|
package org.infinispan.server.resp.commands;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.CompletionStage;
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 io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/config/
* @since 14.0
*/
public class CONFIG extends RespCommand implements Resp3Command {
public CONFIG() {
super(-2, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
String getOrSet = new String(arguments.get(0), StandardCharsets.UTF_8);
String name = new String(arguments.get(1), StandardCharsets.UTF_8);
if ("GET".equalsIgnoreCase(getOrSet)) {
if ("appendonly".equalsIgnoreCase(name)) {
ByteBufferUtils.stringToByteBuf("*2\r\n+" + name + "\r\n+no\r\n", handler.allocator());
} else if (name.indexOf('*') != -1 || name.indexOf('?') != -1) {
ByteBufferUtils.stringToByteBuf("-ERR CONFIG blob pattern matching not implemented\r\n", handler.allocator());
} else {
ByteBufferUtils.stringToByteBuf("*2\r\n+" + name + "\r\n+\r\n", handler.allocator());
}
} else if ("SET".equalsIgnoreCase(getOrSet)) {
Consumers.OK_BICONSUMER.accept(null, handler.allocator());
} else {
ByteBufferUtils.stringToByteBuf("-ERR CONFIG " + getOrSet + " not implemented\r\n", handler.allocator());
}
return handler.myStage();
}
}
| 1,859
| 38.574468
| 122
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/PubSubResp3Command.java
|
package org.infinispan.server.resp.commands;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.server.resp.RespRequestHandler;
import org.infinispan.server.resp.SubscriberHandler;
import java.util.List;
import java.util.concurrent.CompletionStage;
public interface PubSubResp3Command {
CompletionStage<RespRequestHandler> perform(SubscriberHandler handler, ChannelHandlerContext ctx, List<byte[]> arguments);
}
| 436
| 32.615385
| 125
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/ArgumentUtils.java
|
package org.infinispan.server.resp.commands;
import org.infinispan.server.resp.ByteBufferUtils;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.util.CharsetUtil;
/**
* Utility class to transform byte[] arguments.
*
* @since 15.0
*/
public final class ArgumentUtils {
private ArgumentUtils() {
}
/**
* Numbers are always ASCII.
*
* @param argument, byte[]
* @return String
*/
public static String toNumberString(byte[] argument) {
return new String(argument, CharsetUtil.US_ASCII);
}
/**
* Parse Double, removing an offset from the argument
* @param argument
* @param offset, starting from
* @return double value
*/
public static double toDouble(byte[] argument, int offset) {
if (argument == null || argument.length == 0)
throw new NumberFormatException("Empty argument");
return Double.parseDouble(new String(argument, offset, argument.length - offset, CharsetUtil.US_ASCII));
}
public static double toDouble(byte[] argument) {
if (argument == null || argument.length == 0)
throw new NumberFormatException("Empty argument");
return Double.parseDouble(toNumberString(argument));
}
public static long toLong(byte[] argument) {
if (argument == null || argument.length == 0)
throw new NumberFormatException("Empty argument");
boolean negative = false;
int i = 0;
if (argument[0] < '0') {
if ((argument[0] != '-' && argument[0] != '+') || argument.length == 1)
throw new NumberFormatException("Invalid character: " + argument[0]);
negative = true;
i = 1;
}
long result;
byte b = argument[i++];
if (b < '0' || b > '9')
throw new NumberFormatException("Invalid character: " + b);
result = (b - 48);
for (; i < argument.length; i++) {
b = argument[i];
if (b < '0' || b > '9')
throw new NumberFormatException("Invalid character: " + b);
result = (result << 3) + (result << 1) + (b - 48);
}
return negative ? -result : result;
}
public static int toInt(byte[] argument) {
long v = toLong(argument);
if (v > Integer.MAX_VALUE || v < Integer.MIN_VALUE)
throw new NumberFormatException("Value out of range: " + v);
return (int) v;
}
/**
* Checks if a possible numeric argument is "-inf".
* @param arg
* @return true if byte[] is -inf
*/
public static boolean isNegativeInf(byte[] arg) {
if (arg.length != 4)
return false;
return arg[0] == (byte) '-' && arg[1] == (byte) 'i' && arg[2] == (byte) 'n' && arg[3] == (byte) 'f';
}
/**
* Checks if a possible numeric argument is "+inf".
* @param arg
* @return true if byte[] is +inf
*/
public static boolean isPositiveInf(byte[] arg) {
if (arg.length != 4)
return false;
return arg[0] == (byte) '+' && arg[1] == (byte) 'i' && arg[2] == (byte) 'n' && arg[3] == (byte) 'f';
}
public static byte[] toByteArray(long value) {
int size = ByteBufferUtils.stringSize(value);
ByteBuf buf = Unpooled.wrappedBuffer(new byte[size]);
buf.resetWriterIndex();
ByteBufferUtils.setIntChars(value, size, buf);
return buf.array();
}
public static byte[] toByteArray(Number value) {
double d = value.doubleValue();
if (value instanceof Double && Math.rint(d) != d) {
return Double.toString(d).getBytes();
}
return toByteArray(value.longValue());
}
}
| 3,613
| 27.456693
| 110
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/AuthResp3Command.java
|
package org.infinispan.server.resp.commands;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.server.resp.Resp3AuthHandler;
import org.infinispan.server.resp.RespRequestHandler;
import java.util.List;
import java.util.concurrent.CompletionStage;
public interface AuthResp3Command {
CompletionStage<RespRequestHandler> perform(Resp3AuthHandler handler, ChannelHandlerContext ctx, List<byte[]> arguments);
}
| 432
| 32.307692
| 124
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/FamilyCommand.java
|
package org.infinispan.server.resp.commands;
import io.netty.channel.ChannelHandlerContext;
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.cluster.CLUSTER;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* An umbrella command.
* <p>
* This command represents a family of commands. Usually, the ones with multiple keywords, for example,
* {@link CLUSTER} or ACL.
*
* @since 15.0
*/
public abstract class FamilyCommand extends RespCommand implements Resp3Command {
public FamilyCommand(int arity, int firstKeyPos, int lastKeyPos, int steps) {
super(arity, firstKeyPos, lastKeyPos, steps);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments) {
byte[] subCommand = arguments.get(0);
for (RespCommand cmd : getFamilyCommands()) {
if (cmd.match(subCommand)) {
if (cmd instanceof Resp3Command) {
return ((Resp3Command) cmd).perform(handler, ctx, arguments);
}
if (cmd instanceof AuthResp3Command) {
return ((AuthResp3Command) cmd).perform(handler, ctx, arguments);
}
break;
}
}
ByteBufferUtils.stringToByteBuf("-ERR unknown command\r\n", handler.allocator());
return handler.myStage();
}
public abstract RespCommand[] getFamilyCommands();
}
| 1,615
| 31.979592
| 128
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/Resp3Command.java
|
package org.infinispan.server.resp.commands;
import java.util.List;
import java.util.concurrent.CompletionException;
import java.util.concurrent.CompletionStage;
import org.infinispan.commons.CacheException;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespErrorUtil;
import org.infinispan.server.resp.RespRequestHandler;
import io.netty.channel.ChannelHandlerContext;
public interface Resp3Command {
CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments);
default CompletionStage<RespRequestHandler> handleException(Resp3Handler handler, Throwable t) {
Throwable ex = t;
if (t instanceof CompletionException) {
ex = t.getCause();
}
if (ex instanceof CacheException) {
ex = ex.getCause();
}
if (ex instanceof ClassCastException) {
RespErrorUtil.wrongType(handler.allocator());
return handler.myStage();
}
if (ex instanceof IndexOutOfBoundsException) {
RespErrorUtil.indexOutOfRange(handler.allocator());
return handler.myStage();
}
throw new RuntimeException(t);
}
}
| 1,197
| 29.717949
| 120
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/hash/HMGET.java
|
package org.infinispan.server.resp.commands.hash;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.multimap.impl.EmbeddedMultimapPairCache;
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;
/**
* `<code>HMGET key field [field ...]</code>` command.
* <p>
* Returns the values associated with all <code>field</code>s in the hash stored at <code>key</code>, returning a list
* with the values in the same order of the <code>field</code>s. No error returns from <code>field</code>s or
* <code>key</code> that do not exist in the hash, and <code>null</code> is returned in the position.
*
* @since 15.0
* @see <a href="https://redis.io/commands/hmget/">Redis Documentation</a>
* @author José Bolina
*/
public class HMGET extends RespCommand implements Resp3Command {
public HMGET() {
super(-3, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments) {
EmbeddedMultimapPairCache<byte[], byte[], byte[]> multimap = handler.getHashMapMultimap();
CompletionStage<Collection<byte[]>> cs = multimap.get(arguments.get(0), arguments.subList(1, arguments.size()).toArray(new byte[0][]))
.thenApply(entries -> {
List<byte[]> result = new ArrayList<>(arguments.size() - 1);
for (byte[] argument : arguments.subList(1, arguments.size())) {
result.add(entries.get(argument));
}
return result;
});
return handler.stageToReturn(cs, ctx, Consumers.GET_ARRAY_BICONSUMER);
}
}
| 1,947
| 39.583333
| 140
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/hash/HINCRBY.java
|
package org.infinispan.server.resp.commands.hash;
import java.util.List;
import java.util.concurrent.CompletionStage;
import java.util.function.BiConsumer;
import org.infinispan.multimap.impl.EmbeddedMultimapPairCache;
import org.infinispan.server.resp.ByteBufPool;
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;
/**
* `<code>HINCRBY key field increment</code>` command.
* <p>
* Increments the long value at the <code>field</code> in the hash map stored at <code>key</code> by <code>increment</code>.
* The command returns an error if the stored value is not a numeric long.
*
* @since 15.0
* @see <a href="https://redis.io/commands/hincrby/">Redis Documentation</a>
* @author José Bolina
*/
public class HINCRBY extends RespCommand implements Resp3Command {
private static final BiConsumer<byte[], ByteBufPool> CONVERTER =
(value, pool) -> Consumers.LONG_BICONSUMER.accept(ArgumentUtils.toLong(value), pool);
public HINCRBY() {
super(4, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments) {
EmbeddedMultimapPairCache<byte[], byte[], byte[]> multimap = handler.getHashMapMultimap();
long delta = ArgumentUtils.toLong(arguments.get(2));
CompletionStage<byte[]> cs = multimap.compute(arguments.get(0), arguments.get(1), (ignore, prev) -> {
if (prev == null) return arguments.get(2);
// This is supposed to throw when the `prev` is not a long.
long prevLong = ArgumentUtils.toLong(prev);
return ArgumentUtils.toByteArray(prevLong + delta);
});
return handler.stageToReturn(cs, ctx, CONVERTER);
}
}
| 2,014
| 38.509804
| 128
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/hash/HLEN.java
|
package org.infinispan.server.resp.commands.hash;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.multimap.impl.EmbeddedMultimapPairCache;
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;
/**
* `<code>HLEN key</code>` command.
* <p>
* Retrieve the size of the hash map stored under the given key.
* </p>
*
* @since 15.0
* @see <a href="https://redis.io/commands/hlen/">Redis Documentation</a>
* @author José Bolina
*/
public class HLEN extends RespCommand implements Resp3Command {
public HLEN() {
super(2, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments) {
EmbeddedMultimapPairCache<byte[], byte[], byte[]> multimap = handler.getHashMapMultimap();
return handler.stageToReturn(multimap.size(arguments.get(0)), ctx, HSET.CONSUMER);
}
}
| 1,130
| 30.416667
| 128
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/hash/HSET.java
|
package org.infinispan.server.resp.commands.hash;
import java.util.List;
import java.util.concurrent.CompletionStage;
import java.util.function.BiConsumer;
import org.infinispan.server.resp.ByteBufPool;
import org.infinispan.server.resp.Consumers;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.RespErrorUtil;
import org.infinispan.server.resp.RespRequestHandler;
import io.netty.channel.ChannelHandlerContext;
/**
* Executes the `<code>HSET key field value [field value ...]</code>` command.
* <p>
* Sets the specified `<code>field</code>`-`<code>value</code>` pairs in the hash stored at the given `<code>key</code>`.
* </p>
*
* @since 15.0
* @see <a href="https://redis.io/commands/hset">Redis Documentation</a>
*/
public class HSET extends HMSET {
static final BiConsumer<Integer, ByteBufPool> CONSUMER = (r, t) -> Consumers.LONG_BICONSUMER.accept((long) r, t);
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments) {
// Arguments are the hash map key and N key-value pairs.
if ((arguments.size() & 1) == 0) {
RespErrorUtil.wrongArgumentNumber(this, handler.allocator());
return handler.myStage();
}
return handler.stageToReturn(setEntries(handler, arguments), ctx, CONSUMER);
}
}
| 1,369
| 34.128205
| 128
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/hash/HINCRBYFLOAT.java
|
package org.infinispan.server.resp.commands.hash;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.multimap.impl.EmbeddedMultimapPairCache;
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;
/**
* `<code>HINCRBYFLOAT key field increment</code>` command.
* <p>
* Increments the value at the <code>field</code> in the hash map stored at <code>key</code> by <code>increment</code>.
* The command fails if the stored value is not a number.
*
* @since 15.0
* @see <a href="https://redis.io/commands/hincrbyfloat/">Redis Documentation</a>
* @author José Bolina
*/
public class HINCRBYFLOAT extends RespCommand implements Resp3Command {
public HINCRBYFLOAT() {
super(4, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments) {
EmbeddedMultimapPairCache<byte[], byte[], byte[]> multimap = handler.getHashMapMultimap();
double delta = ArgumentUtils.toDouble(arguments.get(2));
CompletionStage<byte[]> cs = multimap.compute(arguments.get(0), arguments.get(1), (ignore, prev) -> {
if (prev == null) return arguments.get(2);
double prevDouble = ArgumentUtils.toDouble(prev);
return ArgumentUtils.toByteArray(prevDouble + delta);
});
return handler.stageToReturn(cs, ctx, Consumers.GET_BICONSUMER);
}
}
| 1,721
| 37.266667
| 128
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/hash/HGET.java
|
package org.infinispan.server.resp.commands.hash;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.multimap.impl.EmbeddedMultimapPairCache;
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;
/**
* `<code>HGET key field</code>` command.
* </p>
* Find the value associated with field in the hash stored at key.
*
* @since 15.0
* @see <a href="https://redis.io/commands/hget/">Redis Documentation</a>
* @author José Bolina
*/
public class HGET extends RespCommand implements Resp3Command {
public HGET() {
super(3, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx,
List<byte[]> arguments) {
EmbeddedMultimapPairCache<byte[], byte[], byte[]> hashMap = handler.getHashMapMultimap();
return handler.stageToReturn(hashMap.get(arguments.get(0), arguments.get(1)), ctx, Consumers.BULK_BICONSUMER);
}
}
| 1,209
| 31.702703
| 116
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/hash/HDEL.java
|
package org.infinispan.server.resp.commands.hash;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.multimap.impl.EmbeddedMultimapPairCache;
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;
/**
* `<code>HDEL key field [field ...]</code>` command.
* <p>
* Remove the given fields from the hash stored at key. Unknown fields are just ignored, and a non-existing key
* returns 0.
* </p>
*
* @since 15.0
* @see <a href="https://redis.io/commands/hdel/">Redis Documentation</a>
* @author José Bolina
*/
public class HDEL extends RespCommand implements Resp3Command {
public HDEL() {
super(-3, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments) {
EmbeddedMultimapPairCache<byte[], byte[], byte[]> multimap = handler.getHashMapMultimap();
return handler.stageToReturn(multimap.remove(arguments.get(0), arguments.subList(1, arguments.size())), ctx, HSET.CONSUMER);
}
}
| 1,255
| 32.945946
| 130
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/hash/HGETALL.java
|
package org.infinispan.server.resp.commands.hash;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletionStage;
import org.infinispan.multimap.impl.EmbeddedMultimapPairCache;
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;
/**
* `<code>HGETALL key</code>` command.
* <p>
* Returns the key-value pairs in the hash map stored at the given key.
* </p>
*
* @since 15.0
* @see <a href="https://redis.io/commands/hgetall/">Redis Documentation</a>
* @author José Bolina
*/
public class HGETALL extends RespCommand implements Resp3Command {
public HGETALL() {
super(2, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments) {
EmbeddedMultimapPairCache<byte[], byte[], byte[]> hashMap = handler.getHashMapMultimap();
CompletionStage<Collection<byte[]>> cs = hashMap.get(arguments.get(0))
.thenApply(res -> {
if (res == null) return null;
List<byte[]> keyValues = new ArrayList<>(res.size() * 2);
for (Map.Entry<byte[], byte[]> entry : res.entrySet()) {
keyValues.add(entry.getKey());
keyValues.add(entry.getValue());
}
return keyValues;
});
return handler.stageToReturn(cs, ctx, ByteBufferUtils::bytesToResult);
}
}
| 1,732
| 32.980392
| 128
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/hash/HMSET.java
|
package org.infinispan.server.resp.commands.hash;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletionStage;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.multimap.impl.EmbeddedMultimapPairCache;
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.util.concurrent.CompletionStages;
import io.netty.channel.ChannelHandlerContext;
/**
* Executes the `<code>HMSET key field value [field value ...]</code>` command.
* <p>
* Sets the specified `<code>field</code>`-`<code>value</code>` pairs in the hash stored at the given `<code>key</code>`.
* </p>
*
* Note this command is deprecated since Redis 4.0 in favor of {@link HSET}.
*
* @since 15.0
* @see <a href="https://redis.io/commands/hmset">Redis Documentation</a>
*/
public class HMSET extends RespCommand implements Resp3Command {
public HMSET() {
super(-4, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments) {
// Arguments are the hash map key and N key-value pairs.
if ((arguments.size() & 1) == 0) {
RespErrorUtil.wrongArgumentNumber(this, handler.allocator());
return handler.myStage();
}
return CompletionStages.handleAndCompose(setEntries(handler, arguments), (ignore, t) -> {
if (t != null) {
return handleException(handler, t);
}
return handler.stageToReturn(CompletableFutures.completedNull(), ctx, Consumers.OK_BICONSUMER);
});
}
protected CompletionStage<Integer> setEntries(Resp3Handler handler, List<byte[]> arguments) {
byte[] key = arguments.get(0);
EmbeddedMultimapPairCache<byte[], byte[], byte[]> hashMap = handler.getHashMapMultimap();
Map.Entry<byte[], byte[]>[] entries = new Map.Entry[(arguments.size() - 1) >> 1];
for (int i = 1; i < arguments.size(); i++) {
entries[i / 2] = Map.entry(arguments.get(i), arguments.get(++i));
}
return hashMap.set(key, entries);
}
}
| 2,355
| 35.8125
| 128
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/hash/HVALS.java
|
package org.infinispan.server.resp.commands.hash;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.multimap.impl.EmbeddedMultimapPairCache;
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;
/**
* `<code>HVALS key</code>` command.
* <p>
* Return all values in the hash map stored under <code>key</code>.
* </p>
*
* @since 15.0
* @see <a href="https://redis.io/commands/hvals/">Redis Documentation</a>
* @author José Bolina
*/
public class HVALS extends RespCommand implements Resp3Command {
public HVALS() {
super(2, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments) {
EmbeddedMultimapPairCache<byte[], byte[], byte[]> multimap = handler.getHashMapMultimap();
return handler.stageToReturn(multimap.values(arguments.get(0)), ctx, Consumers.GET_ARRAY_BICONSUMER);
}
}
| 1,201
| 31.486486
| 128
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/hash/HRANDFIELD.java
|
package org.infinispan.server.resp.commands.hash;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;
import org.infinispan.multimap.impl.EmbeddedMultimapPairCache;
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.Util;
import org.infinispan.server.resp.commands.ArgumentUtils;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* `<code>HRANDFIELD key [count [WITHVALUES]]</code>` command.
* <p>
* Returns <code>count</code> keys from the hash stored at <code>key</code>. Negative <code>count</code> can return
* duplicated keys.
*
* @since 15.0
* @see <a href="https://redis.io/commands/hrandfield/">Redis documentation</a>
* @author José Bolina
*/
public class HRANDFIELD extends RespCommand implements Resp3Command {
private static final byte[] WITH_VALUES = "WITHVALUES".getBytes(StandardCharsets.US_ASCII);
public HRANDFIELD() {
super(-2, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments) {
byte[] key = arguments.get(0);
int count = 1;
if (arguments.size() > 1) {
count = ArgumentUtils.toInt(arguments.get(1));
}
if (count == 0) {
ByteBufferUtils.bytesToResult(Collections.emptyList(), handler.allocator());
return handler.myStage();
}
boolean withValues = false;
if (arguments.size() > 2) {
// Syntax error, only a single option acceptable.
if (!Util.isAsciiBytesEquals(WITH_VALUES, arguments.get(2))) {
RespErrorUtil.syntaxError(handler.allocator());
return handler.myStage();
}
withValues = true;
}
EmbeddedMultimapPairCache<byte[], byte[], byte[]> multimap = handler.getHashMapMultimap();
int finalCount = count;
boolean finalWithValues = withValues;
CompletionStage<Collection<byte[]>> cs = multimap.subSelect(key, Math.abs(count))
.thenApply(e -> e == null ? null : readRandomFields(e, finalCount, finalWithValues));
return handler.stageToReturn(cs, ctx, Consumers.GET_ARRAY_BICONSUMER);
}
private Collection<byte[]> readRandomFields(Map<byte[], byte[]> values, int count, boolean withValues) {
if (count > 0) {
return values.entrySet().stream()
.map(entry -> withValues
? List.of(entry.getKey(), entry.getValue())
: List.of(entry.getKey()))
.flatMap(Collection::stream)
.collect(Collectors.toList());
}
// If the count is negative, we need to return `abs(count)` elements, including duplicates.
List<Map.Entry<byte[], byte[]>> entries = new ArrayList<>(values.entrySet());
return ThreadLocalRandom.current().ints(0, entries.size())
.limit(Math.abs(count))
.mapToObj(i -> {
var entry = entries.get(i);
return withValues
? List.of(entry.getKey(), entry.getValue())
: List.of(entry.getKey());
})
.flatMap(Collection::stream)
.collect(Collectors.toList());
}
}
| 3,745
| 36.838384
| 128
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/hash/HEXISTS.java
|
package org.infinispan.server.resp.commands.hash;
import java.util.List;
import java.util.concurrent.CompletionStage;
import java.util.function.Function;
import org.infinispan.multimap.impl.EmbeddedMultimapPairCache;
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;
/**
* `<code>HEXISTS key field</code>` command.
* <p>
* Verify if the specified <code>field</code> exists in the hash stored at <code>key</code>. Returns 1 if true,
* or 0, otherwise.
* </p>
*
* @since 15.0
* @see <a href="https://redis.io/commands/hexists">Redis Documentation</a>
* @author José Bolina
*/
public class HEXISTS extends RespCommand implements Resp3Command {
private static final Function<Boolean, Long> CONVERTER = b -> b ? 1L : 0L;
public HEXISTS() {
super(3, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments) {
EmbeddedMultimapPairCache<byte[], byte[], byte[]> multimap = handler.getHashMapMultimap();
CompletionStage<Long> cs = multimap.contains(arguments.get(0), arguments.get(1)).thenApply(CONVERTER);
return handler.stageToReturn(cs, ctx, Consumers.LONG_BICONSUMER);
}
}
| 1,469
| 34
| 128
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/hash/HKEYS.java
|
package org.infinispan.server.resp.commands.hash;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.multimap.impl.EmbeddedMultimapPairCache;
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;
/**
* `<code>HKEYS key</code>` command.
* <p>
* Return all keys in the hash map stored under <code>key</code>.
* </p>
*
* @since 15.0
* @see <a href="https://redis.io/commands/hkeys/">Redis Documentation</a>
* @author José Bolina
*/
public class HKEYS extends RespCommand implements Resp3Command {
public HKEYS() {
super(2, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler, ChannelHandlerContext ctx, List<byte[]> arguments) {
EmbeddedMultimapPairCache<byte[], byte[], byte[]> multimap = handler.getHashMapMultimap();
return handler.stageToReturn(multimap.keySet(arguments.get(0)), ctx, Consumers.GET_ARRAY_BICONSUMER);
}
}
| 1,199
| 31.432432
| 128
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/hash/HSCAN.java
|
package org.infinispan.server.resp.commands.hash;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.multimap.impl.EmbeddedMultimapPairCache;
import org.infinispan.server.iteration.IterationInitializationContext;
import org.infinispan.server.iteration.IterationManager;
import org.infinispan.server.iteration.map.MapIterationInitializationContext;
import org.infinispan.server.resp.Resp3Handler;
import org.infinispan.server.resp.commands.iteration.BaseIterationCommand;
/**
* `<code>HSCAN key cursor [MATCH pattern] [COUNT count]</code>` command.
* <p>
* Scan the key-value properties of the hash stored under <code>key</code>.
*
* @since 15.0
* @see <a href="https://redis.io/commands/hscan/">Redis Documentation</a>
* @author José Bolina
*/
public class HSCAN extends BaseIterationCommand {
public HSCAN() {
super(-3, 1, 1, 1);
}
@Override
protected IterationManager retrieveIterationManager(Resp3Handler handler) {
return handler.respServer().getDataStructureIterationManager();
}
@Override
protected CompletionStage<IterationInitializationContext> initializeIteration(Resp3Handler handler, List<byte[]> arguments) {
EmbeddedMultimapPairCache<byte[], byte[], byte[]> multimap = handler.getHashMapMultimap();
return multimap.get(arguments.get(0)).thenApply(entry -> {
if (entry == null) return null;
return MapIterationInitializationContext.withSource(entry);
});
}
@Override
protected String cursor(List<byte[]> raw) {
return new String(raw.get(1), StandardCharsets.US_ASCII);
}
@Override
protected List<byte[]> writeResponse(List<CacheEntry> response) {
List<byte[]> output = new ArrayList<>(2 * response.size());
for (CacheEntry<?, ?> e : response) {
output.add((byte[]) e.getKey());
output.add((byte[]) e.getValue());
}
return output;
}
}
| 2,062
| 32.819672
| 128
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/set/SADD.java
|
package org.infinispan.server.resp.commands.set;
import java.util.List;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.atomic.AtomicLong;
import org.infinispan.commons.marshall.WrappedByteArray;
import org.infinispan.multimap.impl.EmbeddedSetCache;
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 SADD operations
*
* @since 15.0
*/
public class SADD extends RespCommand implements Resp3Command {
public SADD() {
super(-3, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] key = arguments.get(0);
EmbeddedSetCache<byte[],WrappedByteArray> esc = handler.getEmbeddedSetCache();
AggregateCompletionStage<Void> aggregateCompletionStage = CompletionStages.aggregateCompletionStage();
var addedCount = new AtomicLong(0);
for (int i = 1; i < arguments.size(); i++) {
CompletionStage<Void> add = esc.add(key, new WrappedByteArray(arguments.get(i))).thenAccept((v) -> {if (v) addedCount.incrementAndGet();});
aggregateCompletionStage.dependsOn(add);
}
CompletionStage<Long> cs = aggregateCompletionStage.freeze().thenApply(ignore -> addedCount.get());
return handler.stageToReturn(cs, ctx, Consumers.LONG_BICONSUMER);
}
}
| 1,859
| 38.574468
| 148
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/set/SINTERCARD.java
|
package org.infinispan.server.resp.commands.set;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CompletionStage;
import org.infinispan.commons.marshall.WrappedByteArray;
import org.infinispan.multimap.impl.EmbeddedSetCache;
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/sintercard/
*
* Returns the cardinality of the resulting intersection set.
*
* When provided with the optional LIMIT argument (default 0 means unlimited),
* if the intersection cardinality reaches limit partway through the
* computation,
* the algorithm exits returning LIMIT
*
* @since 15.0
*/
public class SINTERCARD extends RespCommand implements Resp3Command {
static Set<WrappedByteArray> EMPTY_SET = new HashSet<>();
static String LIMIT_OPT = "LIMIT";
public SINTERCARD() {
super(-3, 0, 0, 0);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
EmbeddedSetCache<byte[], WrappedByteArray> esc = handler.getEmbeddedSetCache();
var keysNum = ArgumentUtils.toInt(arguments.get(0));
final int limit = processArgs(keysNum, arguments, handler);
if (limit < 0) { // Wrong args
return handler.myStage();
}
var keys = arguments.subList(1, keysNum + 1);
var uniqueKeys = SINTER.getUniqueKeys(handler, keys);
var allEntries= esc.getAll(uniqueKeys);
return handler.stageToReturn(allEntries.thenApply((sets) -> sets.size() == uniqueKeys.size() ? (long) SINTER.intersect(sets.values(), limit).size() : SINTER.checkTypesAndReturnEmpty(sets.values()).size()),
ctx,
Consumers.LONG_BICONSUMER);
}
private int processArgs(int keysNum, List<byte[]> arguments, Resp3Handler handler) {
// Wrong args num
if (arguments.size() < keysNum + 1) {
RespErrorUtil.customError("Number of keys can't be greater than number of args", handler.allocator());
return -1;
}
int optVal = 0;
if (arguments.size() > keysNum + 1) {
if (arguments.size() != keysNum + 3) {
// Options provided but wrong arg nums
RespErrorUtil.syntaxError(handler.allocator());
return -1;
}
var opt = new String(arguments.get(keysNum + 1)).toUpperCase();
if (!LIMIT_OPT.equals(opt)) {
// Wrong option provided
RespErrorUtil.syntaxError(handler.allocator());
return -1;
}
try {
optVal = ArgumentUtils.toInt(arguments.get(keysNum + 2));
if (optVal < 0) {
// Negative limit provided
RespErrorUtil.mustBePositive(handler.allocator());
return -1;
}
} catch (NumberFormatException ex) {
// Limit provided not an integer
RespErrorUtil.valueNotInteger(handler.allocator());
return -1;
}
}
return optVal;
}
}
| 3,429
| 35.489362
| 211
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/set/SINTER.java
|
package org.infinispan.server.resp.commands.set;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CompletionStage;
import java.util.stream.Collectors;
import org.infinispan.commons.marshall.WrappedByteArray;
import org.infinispan.multimap.impl.EmbeddedSetCache;
import org.infinispan.multimap.impl.SetBucket;
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/sinter/
*
* Returns the members of the set resulting from the intersection of all the
* given sets.
*
* @since 15.0
*/
public class SINTER extends RespCommand implements Resp3Command {
static Set<WrappedByteArray> EMPTY_SET = new HashSet<>();
public SINTER() {
super(-2, 1, -1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
EmbeddedSetCache<byte[], WrappedByteArray> esc = handler.getEmbeddedSetCache();
// Wrapping to exclude duplicate keys
var uniqueKeys = getUniqueKeys(handler, arguments);
var allEntries= esc.getAll(uniqueKeys);
return handler.stageToReturn(
allEntries
.thenApply((sets) -> sets.size()==uniqueKeys.size() ? intersect(sets.values(), 0) : checkTypesAndReturnEmpty(sets.values())),
ctx, Consumers.COLLECTION_BULK_BICONSUMER);
}
public static Set<byte[]> getUniqueKeys(Resp3Handler handler, List<byte[]> arguments) {
var wrappedArgs = arguments.stream().map(item -> new WrappedByteArray(item)).collect(Collectors.toSet());
return wrappedArgs.stream().map(item -> item.getBytes()).collect(Collectors.toSet());
}
public static Set<WrappedByteArray> checkTypesAndReturnEmpty(Collection<SetBucket<WrappedByteArray>> buckets) {
var iter = buckets.iterator();
// access all items to check for error
while (iter.hasNext()) {
var minSet = iter.next();
}
return EMPTY_SET;
}
public static Set<WrappedByteArray> intersect(Collection<SetBucket<WrappedByteArray>> buckets,
int limit) {
var iter = buckets.iterator();
// Return empty set if null or empty
if (!iter.hasNext()) {
return EMPTY_SET;
}
var minSet = iter.next();
if (minSet.isEmpty()) {
return EMPTY_SET;
}
// Find the smallest set in the sets list
while (iter.hasNext() && !minSet.isEmpty()) {
var el = iter.next();
minSet = minSet.size() <= el.size() ? minSet : el;
}
// Build a set with all the elements in minSet and in all the rest of the sets
// up to limit if non zero
var result = new HashSet<WrappedByteArray>();
for (var el : minSet.values()) {
if (!buckets.stream().anyMatch(set -> !set.contains(el))) {
result.add(el);
if (limit > 0 && result.size() >= limit) {
break;
}
}
}
return result;
}
}
| 3,303
| 33.061856
| 143
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/set/SCARD.java
|
package org.infinispan.server.resp.commands.set;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.commons.marshall.WrappedByteArray;
import org.infinispan.multimap.impl.EmbeddedSetCache;
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/scard/
*
* Returns the set cardinality (number of elements) of the set stored at key.
*
* @since 15.0
*/
public class SCARD extends RespCommand implements Resp3Command {
public SCARD() {
super(2, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
EmbeddedSetCache<byte[], WrappedByteArray> esc = handler.getEmbeddedSetCache();
return handler.stageToReturn(esc.size(arguments.get(0)), ctx, Consumers.LONG_BICONSUMER);
}
}
| 1,147
| 30.027027
| 95
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/set/SINTERSTORE.java
|
package org.infinispan.server.resp.commands.set;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CompletionStage;
import org.infinispan.commons.marshall.WrappedByteArray;
import org.infinispan.multimap.impl.EmbeddedSetCache;
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/sinterstore/
*
* This command is equal to SINTER, but instead of returning the resulting set,
* it is stored in destination. If destination already exists, it is
* overwritten.
*
* @since 15.0
*/
public class SINTERSTORE extends RespCommand implements Resp3Command {
static Set<WrappedByteArray> EMPTY_SET = new HashSet<>();
public SINTERSTORE() {
super(-3, 1, -1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
EmbeddedSetCache<byte[], WrappedByteArray> esc = handler.getEmbeddedSetCache();
var destination = arguments.get(0);
var keys = arguments.subList(1, arguments.size());
var uniqueKeys = SINTER.getUniqueKeys(handler, keys);
var allEntries= esc.getAll(uniqueKeys);
return handler.stageToReturn(
allEntries.thenCompose(sets -> handler.getEmbeddedSetCache().set(destination, SINTER.intersect(sets.values(), 0))),
ctx,
Consumers.LONG_BICONSUMER);
}
}
| 1,695
| 32.254902
| 127
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/set/SMEMBERS.java
|
package org.infinispan.server.resp.commands.set;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.commons.marshall.WrappedByteArray;
import org.infinispan.multimap.impl.EmbeddedSetCache;
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/smembers/
*
* Returns all the members of the set value stored at key.
*
* @since 15.0
*/
public class SMEMBERS extends RespCommand implements Resp3Command {
public SMEMBERS() {
super(2, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
EmbeddedSetCache<byte[], WrappedByteArray> esc = handler.getEmbeddedSetCache();
return handler.stageToReturn(esc.get(arguments.get(0)), ctx, Consumers.COLLECTION_BULK_BICONSUMER);
}
}
| 1,146
| 30.861111
| 105
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/SET.java
|
package org.infinispan.server.resp.commands.string;
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 org.infinispan.server.resp.operation.SetOperation;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/set/
* @since 14.0
*/
public class SET extends RespCommand implements Resp3Command {
public SET() {
super(-3, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
if (arguments.size() != 2) {
return handler
.stageToReturn(SetOperation.performOperation(handler.cache(), arguments, handler.respServer().getTimeService()), ctx,
Consumers.SET_BICONSUMER);
}
return handler.stageToReturn(
handler.ignorePreviousValuesCache().putAsync(arguments.get(0), arguments.get(1)),
ctx, Consumers.OK_BICONSUMER);
}
}
| 1,334
| 34.131579
| 132
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/STRLEN.java
|
package org.infinispan.server.resp.commands.string;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.server.resp.commands.Resp3Command;
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 java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
/**
* STRLEN Resp Command
*
* @link https://redis.io/commands/strlen/
* @since 15.0
*/
public class STRLEN extends RespCommand implements Resp3Command {
public STRLEN() {
super(2, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] keyBytes = arguments.get(0);
CompletableFuture<Long> strLenAsync = handler.cache().getAsync(keyBytes)
.thenApply(buff -> buff!=null ? buff.length : 0L);
return handler.stageToReturn(strLenAsync, ctx, Consumers.LONG_BICONSUMER);
}
}
| 1,195
| 32.222222
| 80
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/StringMutators.java
|
package org.infinispan.server.resp.commands.string;
import org.infinispan.Cache;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
/**
* StringMutators
*
* Container class for methods that change string entries on the cache
*/
final class StringMutators {
private StringMutators() {
}
static CompletionStage<Long> append(Cache<byte[], byte[]> cache, byte[] key, byte[] appendix) {
return cache.getAsync(key)
.thenCompose(currentValueBytes -> {
if (currentValueBytes != null) {
byte[] newValueBytes = new byte[currentValueBytes.length + appendix.length];
System.arraycopy(currentValueBytes, 0, newValueBytes, 0, currentValueBytes.length);
System.arraycopy(appendix, 0, newValueBytes, currentValueBytes.length, appendix.length);
return cache.replaceAsync(key, currentValueBytes, newValueBytes)
.thenCompose(replaced -> {
if (replaced) {
return CompletableFuture.completedFuture((long)newValueBytes.length);
}
return append(cache, key, appendix);
});
}
return cache.putIfAbsentAsync(key, appendix)
.thenCompose(prev -> {
if (prev != null) {
return append(cache, key, appendix);
}
return CompletableFuture.completedFuture((long)appendix.length);
});
});
}
}
| 1,663
| 38.619048
| 106
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/INCR.java
|
package org.infinispan.server.resp.commands.string;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.server.resp.commands.Resp3Command;
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 java.util.List;
import java.util.concurrent.CompletionStage;
/**
* @link https://redis.io/commands/incr/
* @since 14.0
*/
public class INCR extends RespCommand implements Resp3Command {
public INCR() {
super(2, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
return handler
.stageToReturn(CounterIncOrDec.counterIncOrDec(handler.cache(), arguments.get(0), true),
ctx, Consumers.LONG_BICONSUMER);
}
}
| 1,029
| 32.225806
| 100
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/GETEX.java
|
package org.infinispan.server.resp.commands.string;
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.Cache;
import org.infinispan.commons.time.TimeService;
import org.infinispan.commons.util.concurrent.CompletableFutures;
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.server.resp.operation.GetexOperation;
import io.netty.channel.ChannelHandlerContext;
/**
* GETEX Resp Command
*
* @link https://redis.io/commands/getex/
* @since 15.0
*/
public class GETEX extends RespCommand implements Resp3Command {
public GETEX() {
super(-2, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
if (arguments.size() > 1) {
return handler
.stageToReturn(performOperation(handler.cache(), arguments, handler.respServer().getTimeService()), ctx,
Consumers.GET_BICONSUMER);
}
byte[] keyBytes = arguments.get(0);
return handler.stageToReturn(handler.cache().getAsync(keyBytes), ctx, Consumers.GET_BICONSUMER);
}
private static CompletionStage<byte[]> performOperation(AdvancedCache<byte[], byte[]> cache,
List<byte[]> arguments, TimeService timeService) {
long expirationMs = GetexOperation.parseExpiration(arguments, timeService);
return getex(cache, arguments.get(0), expirationMs);
}
static CompletionStage<byte[]> getex(Cache<byte[], byte[]> cache, byte[] key, long expirationMs) {
return cache.getAsync(key)
.thenCompose(currentValueBytes -> {
if (currentValueBytes == null) {
return CompletableFutures.completedNull();
}
return cache.replaceAsync(key, currentValueBytes, currentValueBytes, expirationMs, TimeUnit.MILLISECONDS)
.thenCompose(replaced -> {
if (replaced) {
return CompletableFuture.completedFuture(currentValueBytes);
}
return getex(cache, key, expirationMs);
});
});
}
}
| 2,546
| 37.014925
| 120
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/MGET.java
|
package org.infinispan.server.resp.commands.string;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.atomic.AtomicInteger;
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 org.infinispan.util.concurrent.AggregateCompletionStage;
import org.infinispan.util.concurrent.CompletionStages;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/mget/
* @since 14.0
*/
public class MGET extends RespCommand implements Resp3Command {
public MGET() {
super(-2, 1, -1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
int keysToRetrieve = arguments.size();
if (keysToRetrieve == 0) {
ByteBufferUtils.stringToByteBuf("*0\r\n", handler.allocator());
return handler.myStage();
}
List<byte[]> results = Collections.synchronizedList(Arrays.asList(
new byte[keysToRetrieve][]));
AtomicInteger resultBytesSize = new AtomicInteger();
AggregateCompletionStage<Void> getStage = CompletionStages.aggregateCompletionStage();
for (int i = 0; i < keysToRetrieve; ++i) {
int innerCount = i;
byte[] keyBytes = arguments.get(i);
getStage.dependsOn(handler.cache().getAsync(keyBytes)
.whenComplete((returnValue, t) -> {
if (returnValue != null) {
results.set(innerCount, returnValue);
int length = returnValue.length;
if (length > 0) {
// $ + digit length (log10 + 1) + /r/n + byte length
resultBytesSize.addAndGet(1 + (int) Math.log10(length) + 1 + 2 + returnValue.length);
} else {
// $0 + /r/n
resultBytesSize.addAndGet(2 + 2);
}
} else {
// $-1
resultBytesSize.addAndGet(3);
}
// /r/n
resultBytesSize.addAndGet(2);
}));
}
return handler.stageToReturn(getStage.freeze(), ctx, (ignore, alloc) ->
ByteBufferUtils.bytesToResult(resultBytesSize.get(), results, alloc)
);
}
}
| 2,713
| 38.333333
| 109
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/DECRBY.java
|
package org.infinispan.server.resp.commands.string;
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.ArgumentUtils;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/decrby/
* @since 15.0
*/
public class DECRBY extends RespCommand implements Resp3Command {
public DECRBY() {
super(3, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
return handler.stageToReturn(CounterIncOrDec.counterIncOrDecBy(handler.cache(), arguments.get(0), ArgumentUtils.toLong(arguments.get(1)), false), ctx, Consumers.LONG_BICONSUMER);
}
}
| 1,106
| 34.709677
| 184
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/INCRBYFLOAT.java
|
package org.infinispan.server.resp.commands.string;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.server.resp.commands.Resp3Command;
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 java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* @link https://redis.io/commands/incrbyfloat/
* @since 15.0
*/
public class INCRBYFLOAT extends RespCommand implements Resp3Command {
public INCRBYFLOAT() {
super(3, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
return handler
.stageToReturn(
CounterIncOrDec.counterIncByDouble(handler.cache(), arguments.get(0),
new String(arguments.get(1), StandardCharsets.US_ASCII)),
ctx, Consumers.DOUBLE_BICONSUMER);
}
}
| 1,101
| 31.411765
| 87
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/GETDEL.java
|
package org.infinispan.server.resp.commands.string;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.server.resp.commands.Resp3Command;
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 java.util.List;
import java.util.concurrent.CompletionStage;
/**
* GETDEL Resp Command
*
* Get the value of key and delete the key. This command is similar to GET,
* except for the fact that it also deletes the key on success (if and only
* if the key's value type is a string).
* @link https://redis.io/commands/getdel/
* @since 15.0
*/
public class GETDEL extends RespCommand implements Resp3Command {
public GETDEL() {
super(2, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] keyBytes = arguments.get(0);
return handler.stageToReturn(handler.cache().removeAsync(keyBytes), ctx, Consumers.GET_BICONSUMER);
}
}
| 1,230
| 33.194444
| 105
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/APPEND.java
|
package org.infinispan.server.resp.commands.string;
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.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* @link https://redis.io/commands/append/
* @since 15.0
*/
public class APPEND extends RespCommand implements Resp3Command {
public APPEND() {
super(3, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
return handler
.stageToReturn(StringMutators.append(handler.cache(), arguments.get(0), arguments.get(1)),
ctx, Consumers.LONG_BICONSUMER);
}
}
| 947
| 29.580645
| 102
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/STRALGO.java
|
package org.infinispan.server.resp.commands.string;
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.RespRequestHandler;
import org.infinispan.server.resp.commands.Resp3Command;
import org.infinispan.server.resp.operation.LCSOperation;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* @link https://redis.io/commands/lcs/
* @since 15.0
*/
public class STRALGO extends RespCommand implements Resp3Command {
public STRALGO() {
super(-5, 1, 2, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
return handler.stageToReturn(LCSOperation.performOperation(handler.cache(), arguments), ctx, Consumers.LCS_BICONSUMER);
}
}
| 958
| 28.96875
| 125
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/DEL.java
|
package org.infinispan.server.resp.commands.string;
import java.util.List;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.BiConsumer;
import org.infinispan.server.resp.ByteBufPool;
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 org.infinispan.util.concurrent.AggregateCompletionStage;
import org.infinispan.util.concurrent.CompletionStages;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/del/
* @since 14.0
*/
public class DEL extends RespCommand implements Resp3Command {
private static final BiConsumer<AtomicInteger, ByteBufPool> AI_CONSUMER = (ai, buf) ->
Consumers.LONG_BICONSUMER.accept(ai.longValue(), buf);
public DEL() {
super(-2, 1, -1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
int keysToRemove = arguments.size();
if (keysToRemove == 1) {
byte[] keyBytes = arguments.get(0);
return handler.stageToReturn(handler.cache().removeAsync(keyBytes), ctx, Consumers.DELETE_BICONSUMER);
}
if (keysToRemove == 0) {
// TODO: is this an error?
ByteBufferUtils.stringToByteBuf(":0\r\n", handler.allocator());
return handler.myStage();
}
AtomicInteger removes = new AtomicInteger();
AggregateCompletionStage<AtomicInteger> deleteStages = CompletionStages.aggregateCompletionStage(removes);
for (byte[] keyBytesLoop : arguments) {
deleteStages.dependsOn(handler.cache().removeAsync(keyBytesLoop)
.thenAccept(prev -> {
if (prev != null) {
removes.incrementAndGet();
}
}));
}
return handler.stageToReturn(deleteStages.freeze(), ctx, AI_CONSUMER);
}
}
| 2,273
| 36.278689
| 112
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/GET.java
|
package org.infinispan.server.resp.commands.string;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.server.resp.commands.Resp3Command;
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 java.util.List;
import java.util.concurrent.CompletionStage;
/**
* GET Resp Command
*
* Get the value of key. If the key does not exist the special value nil is returned.
* An error is returned if the value stored at key is not a string, because GET only handles string values.
*
* @link https://redis.io/commands/get/
* @since 14.0
*/
public class GET extends RespCommand implements Resp3Command {
public GET() {
super(2, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] keyBytes = arguments.get(0);
return handler.stageToReturn(handler.cache().getAsync(keyBytes), ctx, Consumers.GET_BICONSUMER);
}
}
| 1,219
| 32.888889
| 107
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/CounterIncOrDec.java
|
package org.infinispan.server.resp.commands.string;
import io.netty.util.CharsetUtil;
import org.infinispan.Cache;
import org.infinispan.commons.CacheException;
import org.infinispan.server.resp.commands.ArgumentUtils;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
final class CounterIncOrDec {
private CounterIncOrDec() {
}
static CompletionStage<Long> counterIncOrDec(Cache<byte[], byte[]> cache, byte[] key, boolean increment) {
return counterIncOrDecBy(cache, key, 1, increment);
}
static CompletionStage<Long> counterIncOrDecBy(Cache<byte[], byte[]> cache, byte[] key, long by, boolean increment) {
return cache.getAsync(key)
.thenCompose(currentValueBytes -> {
if (currentValueBytes != null) {
String prevValue = ArgumentUtils.toNumberString(currentValueBytes);
long prevIntValue;
try {
prevIntValue = Long.parseLong(prevValue) + (increment ? by : -by);
} catch (NumberFormatException e) {
throw new CacheException("value is not an integer or out of range");
}
String newValueString = String.valueOf(prevIntValue);
byte[] newValueBytes = newValueString.getBytes(CharsetUtil.US_ASCII);
return cache.replaceAsync(key, currentValueBytes, newValueBytes)
.thenCompose(replaced -> {
if (replaced) {
return CompletableFuture.completedFuture(prevIntValue);
}
return counterIncOrDecBy(cache, key, by, increment);
});
}
long longValue = increment ? by : -by;
byte[] valueToPut = String.valueOf(longValue).getBytes(CharsetUtil.US_ASCII);
return cache.putIfAbsentAsync(key, valueToPut)
.thenCompose(prev -> {
if (prev != null) {
return counterIncOrDecBy(cache, key, by, increment);
}
return CompletableFuture.completedFuture(longValue);
});
});
}
static CompletionStage<Double> counterIncByDouble(Cache<byte[], byte[]> cache, byte[] key, String by) {
return counterIncByDouble(cache, key, Double.parseDouble(by));
}
static CompletionStage<Double> counterIncByDouble(Cache<byte[], byte[]> cache, byte[] key, Double by) {
return cache.getAsync(key)
.thenCompose(currentValueBytes -> {
if (currentValueBytes != null) {
String prevValue = ArgumentUtils.toNumberString(currentValueBytes);
double prevDoubleValue;
try {
prevDoubleValue = Double.parseDouble(prevValue) + by;
} catch (NumberFormatException e) {
throw new CacheException("value is not a valid float");
}
String newValueString = String.valueOf(prevDoubleValue);
byte[] newValueBytes = newValueString.getBytes(CharsetUtil.US_ASCII);
return cache.replaceAsync(key, currentValueBytes, newValueBytes)
.thenCompose(replaced -> {
if (replaced) {
return CompletableFuture.completedFuture(prevDoubleValue);
}
return counterIncByDouble(cache, key, by);
});
}
byte[] valueToPut = String.valueOf(by).getBytes(CharsetUtil.US_ASCII);
return cache.putIfAbsentAsync(key, valueToPut)
.thenCompose(prev -> {
if (prev != null) {
return counterIncByDouble(cache, key, by);
}
return CompletableFuture.completedFuture(by);
});
});
}
}
| 4,127
| 45.909091
| 120
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/SETRANGE.java
|
package org.infinispan.server.resp.commands.string;
import io.netty.buffer.Unpooled;
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.RespRequestHandler;
import org.infinispan.server.resp.commands.ArgumentUtils;
import org.infinispan.server.resp.commands.Resp3Command;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* SETRANGE Resp Command
*
* @link https://redis.io/commands/setrange/
* @since 15.0
*/
public class SETRANGE extends RespCommand implements Resp3Command {
public SETRANGE() {
super(4, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] keyBytes = arguments.get(0);
int offset = ArgumentUtils.toInt(arguments.get(1));
byte[] patch = arguments.get(2);
CompletionStage<Long> objectCompletableFuture = handler.cache().computeAsync(keyBytes, (ignoredKey, value) -> setrange(value, patch, offset)).thenApply(newValue -> (long)newValue.length);
return handler.stageToReturn(objectCompletableFuture, ctx, Consumers.LONG_BICONSUMER);
}
private byte[] setrange(byte[] value, byte[] patch, int offset) {
if (value==null) {
value = new byte[0];
}
if (patch.length+offset < value.length) {
var buf = Unpooled.wrappedBuffer(value);
buf.writerIndex(offset);
buf.writeBytes(patch, 0, patch.length);
return buf.array();
}
var buf = Unpooled.buffer(offset+patch.length);
try {
buf.writeBytes(value, 0, Math.min(value.length, offset));
buf.writerIndex(offset);
buf.writeBytes(patch, 0, patch.length);
return buf.array();
} catch (Throwable t) {
buf.release();
throw t;
}
}
}
| 1,992
| 32.779661
| 193
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/INCRBY.java
|
package org.infinispan.server.resp.commands.string;
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.ArgumentUtils;
import org.infinispan.server.resp.commands.Resp3Command;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/incrby/
* @since 15.0
*/
public class INCRBY extends RespCommand implements Resp3Command {
public INCRBY() {
super(3, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
return handler
.stageToReturn(CounterIncOrDec.counterIncOrDecBy(handler.cache(), arguments.get(0), ArgumentUtils.toLong(arguments.get(1)), true),
ctx, Consumers.LONG_BICONSUMER);
}
}
| 1,136
| 33.454545
| 142
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/GETRANGE.java
|
package org.infinispan.server.resp.commands.string;
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.RespRequestHandler;
import org.infinispan.server.resp.commands.ArgumentUtils;
import org.infinispan.server.resp.commands.Resp3Command;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletionStage;
/**
* GETRANGE Resp Command
*
* Returns the substring of the string value stored at key, determined by the
* offsets start and end (both are inclusive).
* Negative offsets can be used in order to provide an offset starting from the
* end of the string.
* So -1 means the last character, -2 the penultimate and so forth.
*
* The function handles out of range requests by limiting the resulting range to
* the actual length of the string.
*
* @link https://redis.io/commands/getrange/
* @since 15.0
*/
public class GETRANGE extends RespCommand implements Resp3Command {
private static byte[] EMPTYBYTES = new byte[0];
public GETRANGE() {
super(4, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
byte[] keyBytes = arguments.get(0);
int beginIndex = ArgumentUtils.toInt(arguments.get(1));
int lastIndex = ArgumentUtils.toInt(arguments.get(2));
CompletionStage<byte[]> objectCompletableFuture = handler.cache().getAsync(keyBytes)
.thenApply(value -> subrange(value, beginIndex, lastIndex));
return handler.stageToReturn(objectCompletableFuture, ctx, Consumers.BULK_BICONSUMER);
}
private byte[] subrange(byte[] arr, int begin, int end) {
// Deal with negative
if (begin < 0) {
begin = Math.max(0, arr.length + begin);
}
if (end < 0) {
end = arr.length + end;
} else {
end = Math.min(arr.length, end);
}
// Quick return for oo range
if (begin >= end || begin >= arr.length || end <= 0) {
return EMPTYBYTES;
}
return Arrays.copyOfRange(arr, begin, end+1);
}
}
| 2,260
| 33.784615
| 92
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/MSET.java
|
package org.infinispan.server.resp.commands.string;
import java.lang.invoke.MethodHandles;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.server.core.logging.Log;
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 org.infinispan.util.concurrent.AggregateCompletionStage;
import org.infinispan.util.concurrent.CompletionStages;
import io.netty.channel.ChannelHandlerContext;
/**
* @link https://redis.io/commands/mset/
* @since 14.0
*/
public class MSET extends RespCommand implements Resp3Command {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass(), Log.class);
public MSET() {
super(-3, 1, 1, 2);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
int keyValuePairCount = arguments.size();
if ((keyValuePairCount & 1) == 1) {
log.tracef("Received: %s count for keys and values combined, should be even for MSET", keyValuePairCount);
ByteBufferUtils.stringToByteBuf("-ERR Missing a value for a key\r\n", handler.allocator());
return handler.myStage();
}
AggregateCompletionStage<Void> setStage = CompletionStages.aggregateCompletionStage();
for (int i = 0; i < keyValuePairCount; i += 2) {
byte[] keyBytes = arguments.get(i);
byte[] valueBytes = arguments.get(i + 1);
setStage.dependsOn(handler.cache().putAsync(keyBytes, valueBytes));
}
return handler.stageToReturn(setStage.freeze(), ctx, Consumers.OK_BICONSUMER);
}
}
| 2,032
| 39.66
| 115
|
java
|
null |
infinispan-main/server/resp/src/main/java/org/infinispan/server/resp/commands/string/DECR.java
|
package org.infinispan.server.resp.commands.string;
import io.netty.channel.ChannelHandlerContext;
import org.infinispan.server.resp.commands.Resp3Command;
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 java.util.List;
import java.util.concurrent.CompletionStage;
/**
* @link https://redis.io/commands/decr/
* @since 14.0
*/
public class DECR extends RespCommand implements Resp3Command {
public DECR() {
super(2, 1, 1, 1);
}
@Override
public CompletionStage<RespRequestHandler> perform(Resp3Handler handler,
ChannelHandlerContext ctx,
List<byte[]> arguments) {
return handler.stageToReturn(CounterIncOrDec.counterIncOrDec(handler.cache(), arguments.get(0), false), ctx, Consumers.LONG_BICONSUMER);
}
}
| 999
| 33.482759
| 142
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.