Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.redisson.RedissonStream Maven / Gradle / Ivy
Easy Redis Java client and Real-Time Data Platform. Valkey compatible. Sync/Async/RxJava3/Reactive API. Client side caching. Over 50 Redis based Java objects and services: JCache API, Apache Tomcat, Hibernate, Spring, Set, Multimap, SortedSet, Map, List, Queue, Deque, Semaphore, Lock, AtomicLong, Map Reduce, Bloom filter, Scheduler, RPC
/**
* Copyright (c) 2013-2024 Nikita Koksharov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.redisson;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import org.redisson.api.*;
import org.redisson.api.listener.*;
import org.redisson.api.stream.*;
import org.redisson.client.codec.Codec;
import org.redisson.client.codec.StringCodec;
import org.redisson.client.protocol.RedisCommand;
import org.redisson.client.protocol.RedisCommands;
import org.redisson.client.protocol.decoder.*;
import org.redisson.command.CommandAsyncExecutor;
import org.redisson.misc.CompletableFutureWrapper;
/**
*
* @author Nikita Koksharov
*
* @param key type
* @param value type
*/
public class RedissonStream extends RedissonExpirable implements RStream {
public RedissonStream(Codec codec, CommandAsyncExecutor connectionManager, String name) {
super(codec, connectionManager, name);
}
public RedissonStream(CommandAsyncExecutor connectionManager, String name) {
super(connectionManager, name);
}
protected void checkKey(Object key) {
if (key == null) {
throw new NullPointerException("key can't be null");
}
}
protected void checkValue(Object value) {
if (value == null) {
throw new NullPointerException("value can't be null");
}
}
@Override
public void createGroup(StreamCreateGroupArgs args) {
get(createGroupAsync(args));
}
@Override
public RFuture createGroupAsync(StreamCreateGroupArgs args) {
StreamCreateGroupParams pps = (StreamCreateGroupParams) args;
List params = new LinkedList<>();
params.add("CREATE");
params.add(getRawName());
params.add(pps.getName());
params.add(pps.getId());
if (pps.isMakeStream()) {
params.add("MKSTREAM");
}
if (pps.getEntriesRead() > 0) {
params.add("ENTRIESREAD");
params.add(pps.getEntriesRead());
}
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XGROUP, params.toArray());
}
@Override
public RFuture ackAsync(String groupName, StreamMessageId... ids) {
List params = new ArrayList();
params.add(getRawName());
params.add(groupName);
params.addAll(Arrays.asList(ids));
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XACK, params.toArray());
}
@Override
public long ack(String groupName, StreamMessageId... id) {
return get(ackAsync(groupName, id));
}
@Override
public RFuture getPendingInfoAsync(String groupName) {
return commandExecutor.readAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XPENDING, getRawName(), groupName);
}
@Override
public PendingResult getPendingInfo(String groupName) {
return get(getPendingInfoAsync(groupName));
}
@Override
public RFuture> listPendingAsync(String groupName, String consumerName, StreamMessageId startId, StreamMessageId endId, int count) {
return commandExecutor.readAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XPENDING_ENTRIES, getRawName(), groupName, startId, endId, count, consumerName);
}
@Override
public RFuture> listPendingAsync(String groupName, StreamMessageId startId, StreamMessageId endId, int count) {
return commandExecutor.readAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XPENDING_ENTRIES, getRawName(), groupName, startId, endId, count);
}
@Override
public RFuture> listPendingAsync(String groupName, StreamMessageId startId, StreamMessageId endId, long idleTime, TimeUnit idleTimeUnit, int count) {
return commandExecutor.readAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XPENDING_ENTRIES, getRawName(), groupName, "IDLE", idleTimeUnit.toMillis(idleTime), startId, endId, count);
}
@Override
public RFuture> listPendingAsync(String groupName, String consumerName, StreamMessageId startId, StreamMessageId endId, long idleTime, TimeUnit idleTimeUnit, int count) {
return commandExecutor.readAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XPENDING_ENTRIES, getRawName(), groupName, "IDLE", idleTimeUnit.toMillis(idleTime), startId, endId, count, consumerName);
}
@Override
public List listPending(String groupName, StreamMessageId startId, StreamMessageId endId, int count) {
return get(listPendingAsync(groupName, startId, endId, count));
}
@Override
public List listPending(String groupName, String consumerName, StreamMessageId startId, StreamMessageId endId, int count) {
return get(listPendingAsync(groupName, consumerName, startId, endId, count));
}
@Override
public List listPending(String groupName, StreamMessageId startId, StreamMessageId endId, long idleTime, TimeUnit idleTimeUnit, int count) {
return get(listPendingAsync(groupName, startId, endId, idleTime, idleTimeUnit, count));
}
@Override
public List listPending(String groupName, String consumerName, StreamMessageId startId, StreamMessageId endId, long idleTime, TimeUnit idleTimeUnit, int count) {
return get(listPendingAsync(groupName, consumerName, startId, endId, idleTime, idleTimeUnit, count));
}
@Override
public List fastClaim(String groupName, String consumerName, long idleTime, TimeUnit idleTimeUnit,
StreamMessageId... ids) {
return get(fastClaimAsync(groupName, consumerName, idleTime, idleTimeUnit, ids));
}
@Override
public RFuture> fastClaimAsync(String groupName, String consumerName, long idleTime,
TimeUnit idleTimeUnit, StreamMessageId... ids) {
List params = new ArrayList();
params.add(getRawName());
params.add(groupName);
params.add(consumerName);
params.add(idleTimeUnit.toMillis(idleTime));
for (StreamMessageId id : ids) {
params.add(id.toString());
}
params.add("JUSTID");
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XCLAIM_IDS, params.toArray());
}
@Override
public AutoClaimResult autoClaim(String groupName, String consumerName, long idleTime, TimeUnit idleTimeUnit, StreamMessageId startId, int count) {
return get(autoClaimAsync(groupName, consumerName, idleTime, idleTimeUnit, startId, count));
}
@Override
public RFuture> autoClaimAsync(String groupName, String consumerName, long idleTime, TimeUnit idleTimeUnit, StreamMessageId startId, int count) {
List params = new ArrayList<>();
params.add(getRawName());
params.add(groupName);
params.add(consumerName);
params.add(idleTimeUnit.toMillis(idleTime));
params.add(startId.toString());
params.add("COUNT");
params.add(count);
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.XAUTOCLAIM, params.toArray());
}
@Override
public FastAutoClaimResult fastAutoClaim(String groupName, String consumerName, long idleTime, TimeUnit idleTimeUnit, StreamMessageId startId, int count) {
return get(fastAutoClaimAsync(groupName, consumerName, idleTime, idleTimeUnit, startId, count));
}
@Override
public Map>> readGroup(String groupName, String consumerName, StreamMultiReadGroupArgs args) {
return get(readGroupAsync(groupName, consumerName, args));
}
@Override
public Map> readGroup(String groupName, String consumerName, StreamReadGroupArgs args) {
return get(readGroupAsync(groupName, consumerName, args));
}
@Override
public RFuture>>> readGroupAsync(String groupName, String consumerName, StreamMultiReadGroupArgs args) {
StreamMultiReadGroupParams rp = (StreamMultiReadGroupParams) args;
List params = new ArrayList<>();
params.add("GROUP");
params.add(groupName);
params.add(consumerName);
if (rp.getCount() > 0) {
params.add("COUNT");
params.add(rp.getCount());
}
if (rp.getTimeout() != null) {
params.add("BLOCK");
params.add(rp.getTimeout().toMillis());
}
if (rp.isNoAck()) {
params.add("NOACK");
}
params.add("STREAMS");
params.add(getRawName());
params.addAll(rp.getOffsets().keySet());
if (rp.getId1() == null) {
params.add(">");
} else {
params.add(rp.getId1().toString());
}
for (StreamMessageId nextId : rp.getOffsets().values()) {
params.add(nextId.toString());
}
if (rp.getTimeout() != null) {
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.XREADGROUP_BLOCKING, params.toArray());
}
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.XREADGROUP, params.toArray());
}
@Override
public RFuture>> readGroupAsync(String groupName, String consumerName, StreamReadGroupArgs args) {
StreamReadGroupParams rp = (StreamReadGroupParams) args;
List params = new ArrayList<>();
params.add("GROUP");
params.add(groupName);
params.add(consumerName);
if (rp.getCount() > 0) {
params.add("COUNT");
params.add(rp.getCount());
}
if (rp.getTimeout() != null) {
params.add("BLOCK");
params.add(rp.getTimeout().toMillis());
}
if (rp.isNoAck()) {
params.add("NOACK");
}
params.add("STREAMS");
params.add(getRawName());
if (rp.getId1() == null) {
params.add(">");
} else {
params.add(rp.getId1().toString());
}
if (rp.getTimeout() != null) {
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.XREADGROUP_BLOCKING_SINGLE, params.toArray());
}
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.XREADGROUP_SINGLE, params.toArray());
}
@Override
public RFuture fastAutoClaimAsync(String groupName, String consumerName, long idleTime, TimeUnit idleTimeUnit, StreamMessageId startId, int count) {
List params = new ArrayList<>();
params.add(getRawName());
params.add(groupName);
params.add(consumerName);
params.add(idleTimeUnit.toMillis(idleTime));
params.add(startId.toString());
params.add("COUNT");
params.add(count);
params.add("JUSTID");
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.XAUTOCLAIM_IDS, params.toArray());
}
@Override
public RFuture>> claimAsync(String groupName, String consumerName, long idleTime,
TimeUnit idleTimeUnit, StreamMessageId... ids) {
List params = new ArrayList();
params.add(getRawName());
params.add(groupName);
params.add(consumerName);
params.add(idleTimeUnit.toMillis(idleTime));
for (StreamMessageId id : ids) {
params.add(id.toString());
}
return commandExecutor.writeAsync(getRawName(), codec, RedisCommands.XCLAIM, params.toArray());
}
@Override
public Map> claim(String groupName, String consumerName, long idleTime, TimeUnit idleTimeUnit,
StreamMessageId... ids) {
return get(claimAsync(groupName, consumerName, idleTime, idleTimeUnit, ids));
}
private RFuture addAllCustomAsync(StreamMessageId id, Map entries, int trimLen, boolean trimStrict) {
List params = new ArrayList(entries.size()*2 + 1);
params.add(getRawName());
if (trimLen > 0) {
params.add("MAXLEN");
if (!trimStrict) {
params.add("~");
}
params.add(trimLen);
}
if (id == null) {
params.add("*");
} else {
params.add(id.toString());
}
for (java.util.Map.Entry t : entries.entrySet()) {
checkKey(t.getKey());
checkValue(t.getValue());
params.add(encodeMapKey(t.getKey()));
params.add(encodeMapValue(t.getValue()));
}
if (id == null) {
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XADD, params.toArray());
}
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XADD_VOID, params.toArray());
}
@Override
public long size() {
return get(sizeAsync());
}
@Override
public RFuture sizeAsync() {
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XLEN, getRawName());
}
@Override
public Map>> read(StreamMultiReadArgs args) {
return get(readAsync(args));
}
@Override
public RFuture>>> readAsync(StreamMultiReadArgs args) {
StreamMultiReadParams rp = (StreamMultiReadParams) args;
List params = new ArrayList<>();
if (rp.getCount() > 0) {
params.add("COUNT");
params.add(rp.getCount());
}
if (rp.getTimeout() != null) {
params.add("BLOCK");
params.add(rp.getTimeout().toMillis());
}
params.add("STREAMS");
params.add(getRawName());
params.addAll(rp.getOffsets().keySet());
params.add(rp.getId1());
for (StreamMessageId nextId : rp.getOffsets().values()) {
params.add(nextId.toString());
}
if (rp.getTimeout() != null) {
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.XREAD_BLOCKING, params.toArray());
}
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.XREAD, params.toArray());
}
@Override
public Map> read(StreamReadArgs args) {
return get(readAsync(args));
}
@Override
public RFuture>> readAsync(StreamReadArgs args) {
StreamReadParams rp = (StreamReadParams) args;
List params = new ArrayList();
if (rp.getCount() > 0) {
params.add("COUNT");
params.add(rp.getCount());
}
if (rp.getTimeout() != null) {
params.add("BLOCK");
params.add(rp.getTimeout().toMillis());
}
params.add("STREAMS");
params.add(getRawName());
params.add(rp.getId1());
if (rp.getTimeout() != null) {
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.XREAD_BLOCKING_SINGLE, params.toArray());
}
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.XREAD_SINGLE, params.toArray());
}
@Override
public StreamMessageId add(StreamAddArgs args) {
return get(addAsync(args));
}
@Override
public void add(StreamMessageId id, StreamAddArgs args) {
get(addAsync(id, args));
}
@Override
public RFuture addAsync(StreamAddArgs args) {
return addCustomAsync(null, args);
}
@Override
public RFuture addAsync(StreamMessageId id, StreamAddArgs args) {
return addCustomAsync(id, args);
}
public RFuture addCustomAsync(StreamMessageId id, StreamAddArgs args) {
StreamAddParams pps = (StreamAddParams) args;
List params = new LinkedList();
params.add(getRawName());
if (pps.isNoMakeStream()) {
params.add("NOMKSTREAM");
}
if (pps.getMaxLen() > 0) {
params.add("MAXLEN");
if (!pps.isTrimStrict()) {
params.add("~");
}
params.add(pps.getMaxLen());
}
if (pps.getMinId() != null) {
params.add("MINID");
if (!pps.isTrimStrict()) {
params.add("~");
}
params.add(pps.getMinId());
}
if (pps.getLimit() > 0) {
params.add("LIMIT");
params.add(pps.getLimit());
}
if (id == null) {
params.add("*");
} else {
params.add(id.toString());
}
for (java.util.Map.Entry t : pps.getEntries().entrySet()) {
checkKey(t.getKey());
checkValue(t.getValue());
params.add(encodeMapKey(t.getKey()));
params.add(encodeMapValue(t.getValue()));
}
if (id == null) {
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XADD, params.toArray());
}
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XADD_VOID, params.toArray());
}
private RFuture addCustomAsync(StreamMessageId id, K key, V value, int trimLen, boolean trimStrict) {
List params = new LinkedList();
params.add(getRawName());
if (trimLen > 0) {
params.add("MAXLEN");
if (!trimStrict) {
params.add("~");
}
params.add(trimLen);
}
if (id == null) {
params.add("*");
} else {
params.add(id.toString());
}
checkKey(key);
checkValue(value);
params.add(encodeMapKey(key));
params.add(encodeMapValue(value));
if (id == null) {
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XADD, params.toArray());
}
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XADD_VOID, params.toArray());
}
@Override
public RFuture>> rangeAsync(int count, StreamMessageId startId, StreamMessageId endId) {
List params = new LinkedList();
params.add(getRawName());
params.add(startId);
params.add(endId);
if (count > 0) {
params.add("COUNT");
params.add(count);
}
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.XRANGE, params.toArray());
}
@Override
public Map> range(int count, StreamMessageId startId, StreamMessageId endId) {
return get(rangeAsync(count, startId, endId));
}
@Override
public RFuture>> rangeReversedAsync(int count, StreamMessageId startId, StreamMessageId endId) {
List params = new LinkedList();
params.add(getRawName());
params.add(startId);
params.add(endId);
if (count > 0) {
params.add("COUNT");
params.add(count);
}
return commandExecutor.readAsync(getRawName(), codec, RedisCommands.XREVRANGE, params.toArray());
}
@Override
public Map> rangeReversed(int count, StreamMessageId startId, StreamMessageId endId) {
return get(rangeReversedAsync(count, startId, endId));
}
@Override
public RFuture>> rangeAsync(StreamMessageId startId, StreamMessageId endId) {
return rangeAsync(0, startId, endId);
}
@Override
public RFuture>> rangeReversedAsync(StreamMessageId startId, StreamMessageId endId) {
return rangeReversedAsync(0, startId, endId);
}
@Override
public Map> range(StreamMessageId startId, StreamMessageId endId) {
return range(0, startId, endId);
}
@Override
public Map> rangeReversed(StreamMessageId startId, StreamMessageId endId) {
return rangeReversed(0, startId, endId);
}
@Override
public RFuture removeAsync(StreamMessageId... ids) {
List params = new ArrayList();
params.add(getRawName());
params.addAll(Arrays.asList(ids));
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XDEL, params.toArray());
}
@Override
public long remove(StreamMessageId... ids) {
return get(removeAsync(ids));
}
@Override
public RFuture removeGroupAsync(String groupName) {
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XGROUP, "DESTROY", getRawName(), groupName);
}
@Override
public void removeGroup(String groupName) {
get(removeGroupAsync(groupName));
}
@Override
public void createConsumer(String groupName, String consumerName) {
get(createConsumerAsync(groupName, consumerName));
}
@Override
public RFuture createConsumerAsync(String groupName, String consumerName) {
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XGROUP, "CREATECONSUMER", getRawName(), groupName, consumerName);
}
@Override
public RFuture removeConsumerAsync(String groupName, String consumerName) {
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XGROUP_LONG, "DELCONSUMER", getRawName(), groupName, consumerName);
}
@Override
public long removeConsumer(String groupName, String consumerName) {
return get(removeConsumerAsync(groupName, consumerName));
}
@Override
public RFuture updateGroupMessageIdAsync(String groupName, StreamMessageId id) {
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XGROUP, "SETID", getRawName(), groupName, id);
}
@Override
public void updateGroupMessageId(String groupName, StreamMessageId id) {
get(updateGroupMessageIdAsync(groupName, id));
}
@Override
public StreamInfo getInfo() {
return get(getInfoAsync());
}
@Override
public RFuture> getInfoAsync() {
RedisCommand> xinfoStream = new RedisCommand<>("XINFO", "STREAM",
new ListMultiDecoder2(
new StreamInfoDecoder(),
new CodecDecoder(),
new ObjectMapReplayDecoder(codec)));
return commandExecutor.readAsync(getRawName(), StringCodec.INSTANCE, xinfoStream, getRawName());
}
@Override
public List listGroups() {
return get(listGroupsAsync());
}
@Override
public RFuture> listGroupsAsync() {
return commandExecutor.readAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XINFO_GROUPS, getRawName());
}
@Override
public List listConsumers(String groupName) {
return get(listConsumersAsync(groupName));
}
@Override
public RFuture> listConsumersAsync(String groupName) {
return commandExecutor.readAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XINFO_CONSUMERS, getRawName(), groupName);
}
private static final RedisCommand>> EVAL_XRANGE = new RedisCommand("EVAL", RedisCommands.XRANGE.getReplayMultiDecoder());
@Override
public RFuture>> pendingRangeAsync(String groupName, StreamMessageId startId,
StreamMessageId endId, int count) {
return commandExecutor.evalReadAsync(getRawName(), codec, EVAL_XRANGE,
"local pendingData = redis.call('xpending', KEYS[1], ARGV[1], ARGV[2], ARGV[3], ARGV[4]);" +
"local result = {}; " +
"for i = 1, #pendingData, 1 do " +
"local value = redis.call('xrange', KEYS[1], pendingData[i][1], pendingData[i][1]);" +
"table.insert(result, value[1]);" +
"end; " +
"return result;",
Collections.singletonList(getRawName()),
groupName, startId, endId, count);
}
@Override
public RFuture>> pendingRangeAsync(String groupName, String consumerName,
StreamMessageId startId, StreamMessageId endId, int count) {
return commandExecutor.evalReadAsync(getRawName(), codec, EVAL_XRANGE,
"local pendingData = redis.call('xpending', KEYS[1], ARGV[1], ARGV[2], ARGV[3], ARGV[4], ARGV[5]);" +
"local result = {}; " +
"for i = 1, #pendingData, 1 do " +
"local value = redis.call('xrange', KEYS[1], pendingData[i][1], pendingData[i][1]);" +
"table.insert(result, value[1]);" +
"end; " +
"return result;",
Collections.singletonList(getRawName()),
groupName, startId, endId, count, consumerName);
}
@Override
public RFuture>> pendingRangeAsync(String groupName, StreamMessageId startId,
StreamMessageId endId, long idleTime, TimeUnit idleTimeUnit, int count) {
return commandExecutor.evalReadAsync(getRawName(), codec, EVAL_XRANGE,
"local pendingData = redis.call('xpending', KEYS[1], ARGV[1], 'IDLE', ARGV[2], ARGV[3], ARGV[4], ARGV[5]);" +
"local result = {}; " +
"for i = 1, #pendingData, 1 do " +
"local value = redis.call('xrange', KEYS[1], pendingData[i][1], pendingData[i][1]);" +
"table.insert(result, value[1]);" +
"end; " +
"return result;",
Collections.singletonList(getRawName()),
groupName, idleTimeUnit.toMillis(idleTime), startId, endId, count);
}
@Override
public RFuture>> pendingRangeAsync(String groupName, String consumerName,
StreamMessageId startId, StreamMessageId endId, long idleTime, TimeUnit idleTimeUnit, int count) {
return commandExecutor.evalReadAsync(getRawName(), codec, EVAL_XRANGE,
"local pendingData = redis.call('xpending', KEYS[1], ARGV[1], 'IDLE', ARGV[2], ARGV[3], ARGV[4], ARGV[5], ARGV[6]);" +
"local result = {}; " +
"for i = 1, #pendingData, 1 do " +
"local value = redis.call('xrange', KEYS[1], pendingData[i][1], pendingData[i][1]);" +
"table.insert(result, value[1]);" +
"end; " +
"return result;",
Collections.singletonList(getRawName()),
groupName, idleTimeUnit.toMillis(idleTime), startId, endId, count, consumerName);
}
@Override
public Map> pendingRange(String groupName, StreamMessageId startId, StreamMessageId endId, long idleTime, TimeUnit idleTimeUnit, int count) {
return get(pendingRangeAsync(groupName, startId, endId, idleTime, idleTimeUnit, count));
}
@Override
public Map> pendingRange(String groupName, String consumerName, StreamMessageId startId, StreamMessageId endId, long idleTime, TimeUnit idleTimeUnit, int count) {
return get(pendingRangeAsync(groupName, consumerName, startId, endId, idleTime, idleTimeUnit, count));
}
@Override
public Map> pendingRange(String groupName, String consumerName, StreamMessageId startId,
StreamMessageId endId, int count) {
return get(pendingRangeAsync(groupName, consumerName, startId, endId, count));
}
@Override
public Map> pendingRange(String groupName, StreamMessageId startId, StreamMessageId endId,
int count) {
return get(pendingRangeAsync(groupName, startId, endId, count));
}
@Override
public long trim(StreamTrimArgs args) {
return get(trimAsync(args));
}
@Override
public RFuture trimAsync(StreamTrimArgs args) {
return trimAsync(args, true);
}
private RFuture trimAsync(StreamTrimArgs args, boolean trimStrict) {
StreamTrimParams pps = (StreamTrimParams) args;
List params = new LinkedList<>();
params.add(getRawName());
if (pps.getMaxLen() != null) {
params.add("MAXLEN");
if (!trimStrict) {
params.add("~");
}
params.add(pps.getMaxLen());
}
if (pps.getMinId() != null) {
params.add("MINID");
if (!trimStrict) {
params.add("~");
}
params.add(pps.getMinId());
}
if (pps.getLimit() > 0) {
params.add("LIMIT");
params.add(pps.getLimit());
}
return commandExecutor.writeAsync(getRawName(), StringCodec.INSTANCE, RedisCommands.XTRIM, params.toArray());
}
@Override
public long trimNonStrict(StreamTrimArgs args) {
return get(trimNonStrictAsync(args));
}
@Override
public RFuture trimNonStrictAsync(StreamTrimArgs args) {
return trimAsync(args, false);
}
@Override
public RFuture addListenerAsync(ObjectListener listener) {
if (listener instanceof StreamAddListener) {
return addListenerAsync("__keyevent@*:xadd", (StreamAddListener) listener, StreamAddListener::onAdd);
}
if (listener instanceof StreamRemoveListener) {
return addListenerAsync("__keyevent@*:xdel", (StreamRemoveListener) listener, StreamRemoveListener::onRemove);
}
if (listener instanceof StreamCreateConsumerListener) {
return addListenerAsync("__keyevent@*:xgroup-createconsumer", (StreamCreateConsumerListener) listener, StreamCreateConsumerListener::onCreateConsumer);
}
if (listener instanceof StreamRemoveConsumerListener) {
return addListenerAsync("__keyevent@*:xgroup-delconsumer", (StreamRemoveConsumerListener) listener, StreamRemoveConsumerListener::onRemoveConsumer);
}
if (listener instanceof StreamCreateGroupListener) {
return addListenerAsync("__keyevent@*:xgroup-create", (StreamCreateGroupListener) listener, StreamCreateGroupListener::onCreateGroup);
}
if (listener instanceof StreamRemoveGroupListener) {
return addListenerAsync("__keyevent@*:xgroup-destroy", (StreamRemoveGroupListener) listener, StreamRemoveGroupListener::onRemoveGroup);
}
if (listener instanceof TrackingListener) {
return addTrackingListenerAsync((TrackingListener) listener);
}
return super.addListenerAsync(listener);
}
@Override
public int addListener(ObjectListener listener) {
if (listener instanceof StreamAddListener) {
return addListener("__keyevent@*:xadd", (StreamAddListener) listener, StreamAddListener::onAdd);
}
if (listener instanceof StreamRemoveListener) {
return addListener("__keyevent@*:xdel", (StreamRemoveListener) listener, StreamRemoveListener::onRemove);
}
if (listener instanceof StreamCreateConsumerListener) {
return addListener("__keyevent@*:xgroup-createconsumer", (StreamCreateConsumerListener) listener, StreamCreateConsumerListener::onCreateConsumer);
}
if (listener instanceof StreamRemoveConsumerListener) {
return addListener("__keyevent@*:xgroup-delconsumer", (StreamRemoveConsumerListener) listener, StreamRemoveConsumerListener::onRemoveConsumer);
}
if (listener instanceof StreamCreateGroupListener) {
return addListener("__keyevent@*:xgroup-create", (StreamCreateGroupListener) listener, StreamCreateGroupListener::onCreateGroup);
}
if (listener instanceof StreamRemoveGroupListener) {
return addListener("__keyevent@*:xgroup-destroy", (StreamRemoveGroupListener) listener, StreamRemoveGroupListener::onRemoveGroup);
}
if (listener instanceof StreamTrimListener) {
return addListener("__keyevent@*:xtrim", (StreamTrimListener) listener, StreamTrimListener::onTrim);
}
if (listener instanceof TrackingListener) {
return addTrackingListener((TrackingListener) listener);
}
return super.addListener(listener);
}
@Override
public void removeListener(int listenerId) {
removeTrackingListener(listenerId);
removeListener(listenerId, "__keyevent@*:xadd", "__keyevent@*:xdel", "__keyevent@*:xgroup-createconsumer",
"__keyevent@*:xgroup-delconsumer", "__keyevent@*:xgroup-create", "__keyevent@*:xgroup-destroy", "__keyevent@*:xtrim");
super.removeListener(listenerId);
}
@Override
public RFuture removeListenerAsync(int listenerId) {
RFuture f1 = removeTrackingListenerAsync(listenerId);
RFuture f2 = removeListenerAsync(listenerId,
"__keyevent@*:xadd", "__keyevent@*:xdel", "__keyevent@*:xgroup-createconsumer",
"__keyevent@*:xgroup-delconsumer", "__keyevent@*:xgroup-create", "__keyevent@*:xgroup-destroy", "__keyevent@*:xtrim");
return new CompletableFutureWrapper<>(CompletableFuture.allOf(f1.toCompletableFuture(), f2.toCompletableFuture()));
}
}
