connection) {
19 | super(TxSyncInvocationHandler.sync(connection));
20 | }
21 |
22 | }
23 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/dynamic/CommandFactory.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.dynamic;
2 |
3 | import io.lettuce.core.protocol.RedisCommand;
4 |
5 | /**
6 | * Strategy interface to create {@link RedisCommand}s.
7 | *
8 | * Implementing classes are required to construct {@link RedisCommand}s given an array of parameters for command execution.
9 | *
10 | * @author Mark Paluch
11 | * @since 5.0
12 | */
13 | @FunctionalInterface
14 | interface CommandFactory {
15 |
16 | /**
17 | * Create a new {@link RedisCommand} given {@code parameters}.
18 | *
19 | * @param parameters must not be {@code null}.
20 | * @return the {@link RedisCommand}.
21 | */
22 | RedisCommand createCommand(Object[] parameters);
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/event/metrics/MetricEventPublisher.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.event.metrics;
2 |
3 | import io.lettuce.core.event.Event;
4 |
5 | /**
6 | * Event publisher which publishes metrics by the use of {@link Event events}.
7 | *
8 | * @author Mark Paluch
9 | * @since 3.4
10 | */
11 | public interface MetricEventPublisher {
12 |
13 | /**
14 | * Emit immediately a metrics event.
15 | */
16 | void emitMetricsEvent();
17 |
18 | /**
19 | * Returns {@code true} if the metric collector is enabled.
20 | *
21 | * @return {@code true} if the metric collector is enabled
22 | */
23 | boolean isEnabled();
24 |
25 | /**
26 | * Shut down the event publisher.
27 | */
28 | void shutdown();
29 |
30 | }
31 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/tracing/TestConfig.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.tracing;
2 |
3 | import io.micrometer.core.instrument.MeterRegistry;
4 | import io.micrometer.core.instrument.observation.DefaultMeterObservationHandler;
5 | import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
6 | import io.micrometer.observation.ObservationRegistry;
7 |
8 | /**
9 | * @author Mark Paluch
10 | */
11 | class TestConfig {
12 |
13 | static final MeterRegistry METER_REGISTRY = new SimpleMeterRegistry();
14 |
15 | static final ObservationRegistry OBSERVATION_REGISTRY = ObservationRegistry.create();
16 |
17 | static {
18 | OBSERVATION_REGISTRY.observationConfig().observationHandler(new DefaultMeterObservationHandler(METER_REGISTRY));
19 | }
20 |
21 | }
22 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/output/KeyScanOutput.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.output;
2 |
3 | import java.nio.ByteBuffer;
4 |
5 | import io.lettuce.core.KeyScanCursor;
6 | import io.lettuce.core.codec.RedisCodec;
7 |
8 | /**
9 | * {@link io.lettuce.core.KeyScanCursor} for scan cursor output.
10 | *
11 | * @param Key type.
12 | * @param Value type.
13 | * @author Mark Paluch
14 | */
15 | public class KeyScanOutput extends ScanOutput> {
16 |
17 | public KeyScanOutput(RedisCodec codec) {
18 | super(codec, new KeyScanCursor());
19 | }
20 |
21 | @Override
22 | protected void setOutput(ByteBuffer bytes) {
23 | output.getKeys().add(bytes == null ? null : codec.decodeKey(bytes));
24 | }
25 |
26 | }
27 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/output/ValueScanOutput.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.output;
2 |
3 | import java.nio.ByteBuffer;
4 |
5 | import io.lettuce.core.ValueScanCursor;
6 | import io.lettuce.core.codec.RedisCodec;
7 |
8 | /**
9 | * {@link io.lettuce.core.ValueScanCursor} for scan cursor output.
10 | *
11 | * @param Key type.
12 | * @param Value type.
13 | * @author Mark Paluch
14 | */
15 | public class ValueScanOutput extends ScanOutput> {
16 |
17 | public ValueScanOutput(RedisCodec codec) {
18 | super(codec, new ValueScanCursor());
19 | }
20 |
21 | @Override
22 | protected void setOutput(ByteBuffer bytes) {
23 | output.getValues().add(bytes == null ? null : codec.decodeValue(bytes));
24 | }
25 |
26 | }
27 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/resource/ThreadFactoryProvider.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.resource;
2 |
3 | import java.util.concurrent.ThreadFactory;
4 |
5 | /**
6 | * Interface to provide a custom {@link java.util.concurrent.ThreadFactory}. Implementations are asked through
7 | * {@link #getThreadFactory(String)} to provide a thread factory for a given pool name.
8 | *
9 | * @since 6.1.1
10 | */
11 | @FunctionalInterface
12 | public interface ThreadFactoryProvider {
13 |
14 | /**
15 | * Return a {@link ThreadFactory} for the given {@code poolName}.
16 | *
17 | * @param poolName a descriptive pool name. Typically used as prefix for thread names.
18 | * @return the {@link ThreadFactory}.
19 | */
20 | ThreadFactory getThreadFactory(String poolName);
21 |
22 | }
23 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/resource/DnsResolvers.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.resource;
2 |
3 | import java.net.InetAddress;
4 | import java.net.UnknownHostException;
5 |
6 | /**
7 | * Predefined DNS resolvers.
8 | *
9 | * @author Mark Paluch
10 | * @since 4.2
11 | */
12 | public enum DnsResolvers implements DnsResolver {
13 |
14 | /**
15 | * Non-resolving {@link DnsResolver}. Returns an empty {@link InetAddress} to indicate an unresolved address.
16 | *
17 | * @see java.net.InetSocketAddress#createUnresolved(String, int)
18 | * @since 4.4
19 | */
20 | UNRESOLVED {
21 |
22 | @Override
23 | public InetAddress[] resolve(String host) throws UnknownHostException {
24 | return new InetAddress[0];
25 | }
26 |
27 | };
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/commands/transactional/BitTxCommandIntegrationTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.commands.transactional;
2 |
3 | import javax.inject.Inject;
4 |
5 | import io.lettuce.core.RedisClient;
6 | import io.lettuce.core.api.StatefulRedisConnection;
7 | import io.lettuce.core.commands.BitCommandIntegrationTests;
8 | import org.junit.jupiter.api.Tag;
9 |
10 | import static io.lettuce.TestTags.INTEGRATION_TEST;
11 |
12 | /**
13 | * @author Mark Paluch
14 | */
15 | @Tag(INTEGRATION_TEST)
16 | class BitTxCommandIntegrationTests extends BitCommandIntegrationTests {
17 |
18 | @Inject
19 | BitTxCommandIntegrationTests(RedisClient client, StatefulRedisConnection connection) {
20 | super(client, TxSyncInvocationHandler.sync(connection));
21 | }
22 |
23 | }
24 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/cluster/api/reactive/ReactiveExecutions.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.cluster.api.reactive;
2 |
3 | import java.util.Collection;
4 |
5 | import reactor.core.publisher.Flux;
6 | import io.lettuce.core.cluster.models.partitions.RedisClusterNode;
7 |
8 | /**
9 | * Execution holder for a reactive command to be executed on multiple nodes.
10 | *
11 | * @author Mark Paluch
12 | * @since 4.4
13 | */
14 | public interface ReactiveExecutions {
15 |
16 | /**
17 | * Return a {@link Flux} that contains a combined stream of the multi-node execution.
18 | *
19 | * @return
20 | */
21 | Flux flux();
22 |
23 | /**
24 | * @return collection of nodes on which the command was executed.
25 | */
26 | Collection nodes();
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/commands/reactive/HLLReactiveCommandIntegrationTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.commands.reactive;
2 |
3 | import javax.inject.Inject;
4 |
5 | import io.lettuce.core.api.StatefulRedisConnection;
6 | import io.lettuce.core.commands.HLLCommandIntegrationTests;
7 | import io.lettuce.test.ReactiveSyncInvocationHandler;
8 | import org.junit.jupiter.api.Tag;
9 |
10 | import static io.lettuce.TestTags.INTEGRATION_TEST;
11 |
12 | /**
13 | * @author Mark Paluch
14 | */
15 | @Tag(INTEGRATION_TEST)
16 | class HLLReactiveCommandIntegrationTests extends HLLCommandIntegrationTests {
17 |
18 | @Inject
19 | HLLReactiveCommandIntegrationTests(StatefulRedisConnection connection) {
20 | super(ReactiveSyncInvocationHandler.sync(connection));
21 | }
22 |
23 | }
24 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/commands/reactive/KeyReactiveCommandIntegrationTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.commands.reactive;
2 |
3 | import javax.inject.Inject;
4 |
5 | import io.lettuce.core.api.StatefulRedisConnection;
6 | import io.lettuce.core.commands.KeyCommandIntegrationTests;
7 | import io.lettuce.test.ReactiveSyncInvocationHandler;
8 | import org.junit.jupiter.api.Tag;
9 |
10 | import static io.lettuce.TestTags.INTEGRATION_TEST;
11 |
12 | /**
13 | * @author Mark Paluch
14 | */
15 | @Tag(INTEGRATION_TEST)
16 | class KeyReactiveCommandIntegrationTests extends KeyCommandIntegrationTests {
17 |
18 | @Inject
19 | KeyReactiveCommandIntegrationTests(StatefulRedisConnection connection) {
20 | super(ReactiveSyncInvocationHandler.sync(connection));
21 | }
22 |
23 | }
24 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/commands/reactive/SetReactiveCommandIntegrationTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.commands.reactive;
2 |
3 | import javax.inject.Inject;
4 |
5 | import io.lettuce.core.api.StatefulRedisConnection;
6 | import io.lettuce.core.commands.SetCommandIntegrationTests;
7 | import io.lettuce.test.ReactiveSyncInvocationHandler;
8 | import org.junit.jupiter.api.Tag;
9 |
10 | import static io.lettuce.TestTags.INTEGRATION_TEST;
11 |
12 | /**
13 | * @author Mark Paluch
14 | */
15 | @Tag(INTEGRATION_TEST)
16 | class SetReactiveCommandIntegrationTests extends SetCommandIntegrationTests {
17 |
18 | @Inject
19 | SetReactiveCommandIntegrationTests(StatefulRedisConnection connection) {
20 | super(ReactiveSyncInvocationHandler.sync(connection));
21 | }
22 |
23 | }
24 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/commands/reactive/ListReactiveCommandIntegrationTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.commands.reactive;
2 |
3 | import javax.inject.Inject;
4 |
5 | import io.lettuce.core.api.StatefulRedisConnection;
6 | import io.lettuce.core.commands.ListCommandIntegrationTests;
7 | import io.lettuce.test.ReactiveSyncInvocationHandler;
8 | import org.junit.jupiter.api.Tag;
9 |
10 | import static io.lettuce.TestTags.INTEGRATION_TEST;
11 |
12 | /**
13 | * @author Mark Paluch
14 | */
15 | @Tag(INTEGRATION_TEST)
16 | class ListReactiveCommandIntegrationTests extends ListCommandIntegrationTests {
17 |
18 | @Inject
19 | ListReactiveCommandIntegrationTests(StatefulRedisConnection connection) {
20 | super(ReactiveSyncInvocationHandler.sync(connection));
21 | }
22 |
23 | }
24 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/commands/reactive/SortReactiveCommandIntegrationTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.commands.reactive;
2 |
3 | import javax.inject.Inject;
4 |
5 | import io.lettuce.core.api.StatefulRedisConnection;
6 | import io.lettuce.core.commands.SortCommandIntegrationTests;
7 | import io.lettuce.test.ReactiveSyncInvocationHandler;
8 | import org.junit.jupiter.api.Tag;
9 |
10 | import static io.lettuce.TestTags.INTEGRATION_TEST;
11 |
12 | /**
13 | * @author Mark Paluch
14 | */
15 | @Tag(INTEGRATION_TEST)
16 | class SortReactiveCommandIntegrationTests extends SortCommandIntegrationTests {
17 |
18 | @Inject
19 | SortReactiveCommandIntegrationTests(StatefulRedisConnection connection) {
20 | super(ReactiveSyncInvocationHandler.sync(connection));
21 | }
22 |
23 | }
24 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/masterreplica/Timeout.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.masterreplica;
2 |
3 | import java.util.concurrent.TimeUnit;
4 |
5 | /**
6 | * Value object to represent a timeout.
7 | *
8 | * @author Mark Paluch
9 | * @since 4.2
10 | */
11 | class Timeout {
12 |
13 | private final long expiresMs;
14 |
15 | public Timeout(long timeout, TimeUnit timeUnit) {
16 | this.expiresMs = System.currentTimeMillis() + timeUnit.toMillis(timeout);
17 | }
18 |
19 | public boolean isExpired() {
20 | return expiresMs < System.currentTimeMillis();
21 | }
22 |
23 | public long remaining() {
24 |
25 | long diff = expiresMs - System.currentTimeMillis();
26 | if (diff > 0) {
27 | return diff;
28 | }
29 | return 0;
30 | }
31 |
32 | }
33 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/dynamic/ExecutableCommandLookupStrategy.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.dynamic;
2 |
3 | import java.lang.reflect.Method;
4 |
5 | /**
6 | * Strategy interface to resolve {@link ExecutableCommand} from a {@link Method} and {@link RedisCommandsMetadata}.
7 | *
8 | * @author Mark Paluch
9 | * @since 5.0
10 | */
11 | @FunctionalInterface
12 | interface ExecutableCommandLookupStrategy {
13 |
14 | /**
15 | * Resolve a {@link ExecutableCommand} given the {@link Method} and {@link RedisCommandsMetadata}.
16 | *
17 | * @param method must not be {@code null}.
18 | * @param metadata must not be {@code null}.
19 | * @return the {@link ExecutableCommand}.
20 | */
21 | ExecutableCommand resolveCommandMethod(CommandMethod method, RedisCommandsMetadata metadata);
22 |
23 | }
24 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/event/connection/ConnectionCreatedEvent.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.event.connection;
2 |
3 | import io.lettuce.core.event.Event;
4 |
5 | /**
6 | * Event for a created connection object. Creating a connection is the first step in establishing a Redis connection.
7 | *
8 | * @author Mark Paluch
9 | * @since 6.1
10 | */
11 | public class ConnectionCreatedEvent implements Event {
12 |
13 | private final String redisUri;
14 |
15 | private final String epId;
16 |
17 | public ConnectionCreatedEvent(String redisUri, String epId) {
18 | this.redisUri = redisUri;
19 | this.epId = epId;
20 | }
21 |
22 | public String getRedisUri() {
23 | return redisUri;
24 | }
25 |
26 | public String getEpId() {
27 | return epId;
28 | }
29 |
30 | }
31 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/protocol/ConnectionInitializer.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.protocol;
2 |
3 | import java.util.concurrent.CompletionStage;
4 |
5 | import io.netty.channel.Channel;
6 |
7 | /**
8 | * Initialize a connection to prepare it for usage.
9 | *
10 | * @author Mark Paluch
11 | * @since 6.0
12 | */
13 | public interface ConnectionInitializer {
14 |
15 | /**
16 | * Initialize the connection for usage. This method is invoked after establishing the transport connection and before the
17 | * connection is used for user-space commands.
18 | *
19 | * @param channel the {@link Channel} to initialize.
20 | * @return the {@link CompletionStage} that completes once the channel is fully initialized.
21 | */
22 | CompletionStage initialize(Channel channel);
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/commands/reactive/StreamReactiveCommandIntegrationTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.commands.reactive;
2 |
3 | import javax.inject.Inject;
4 |
5 | import io.lettuce.core.api.StatefulRedisConnection;
6 | import io.lettuce.core.commands.StreamCommandIntegrationTests;
7 | import io.lettuce.test.ReactiveSyncInvocationHandler;
8 | import org.junit.jupiter.api.Tag;
9 |
10 | import static io.lettuce.TestTags.INTEGRATION_TEST;
11 |
12 | /**
13 | * @author Mark Paluch
14 | */
15 | @Tag(INTEGRATION_TEST)
16 | class StreamReactiveCommandIntegrationTests extends StreamCommandIntegrationTests {
17 |
18 | @Inject
19 | StreamReactiveCommandIntegrationTests(StatefulRedisConnection connection) {
20 | super(ReactiveSyncInvocationHandler.sync(connection));
21 | }
22 |
23 | }
24 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/protocol/ProtocolKeyword.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.protocol;
2 |
3 | /**
4 | * Interface for protocol keywords providing an encoded representation.
5 | *
6 | * @author Mark Paluch
7 | */
8 | public interface ProtocolKeyword {
9 |
10 | /**
11 | *
12 | * @return byte[] encoded representation.
13 | */
14 | byte[] getBytes();
15 |
16 | /**
17 | *
18 | * @return name of the command.
19 | */
20 | String toString();
21 |
22 | /**
23 | * Return the keyword as a String. This method is retained for binary compatibility with existing integrations.
24 | *
25 | * @deprecated since 6.5, use {@link #toString()} instead.
26 | */
27 | @Deprecated
28 | default String name() {
29 | return this.toString();
30 | }
31 |
32 | }
33 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/commands/reactive/NumericReactiveCommandIntegrationTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.commands.reactive;
2 |
3 | import javax.inject.Inject;
4 |
5 | import io.lettuce.core.api.StatefulRedisConnection;
6 | import io.lettuce.core.commands.NumericCommandIntegrationTests;
7 | import io.lettuce.test.ReactiveSyncInvocationHandler;
8 | import org.junit.jupiter.api.Tag;
9 |
10 | import static io.lettuce.TestTags.INTEGRATION_TEST;
11 |
12 | /**
13 | * @author Mark Paluch
14 | */
15 | @Tag(INTEGRATION_TEST)
16 | class NumericReactiveCommandIntegrationTests extends NumericCommandIntegrationTests {
17 |
18 | @Inject
19 | NumericReactiveCommandIntegrationTests(StatefulRedisConnection connection) {
20 | super(ReactiveSyncInvocationHandler.sync(connection));
21 | }
22 |
23 | }
24 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/protocol/ConnectionFacade.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.protocol;
2 |
3 | /**
4 | * Represents a stateful connection facade. Connections can be activated and deactivated and particular actions can be executed
5 | * upon connection activation/deactivation.
6 | *
7 | * @author Mark Paluch
8 | */
9 | public interface ConnectionFacade {
10 |
11 | /**
12 | * Callback for a connection activated event. This method may invoke non-blocking connection operations to prepare the
13 | * connection after the connection was established.
14 | */
15 | void activated();
16 |
17 | /**
18 | * Callback for a connection deactivated event. This method may invoke non-blocking operations to cleanup the connection
19 | * after disconnection.
20 | */
21 | void deactivated();
22 |
23 | }
24 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/examples/ConnectToRedisSSL.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.examples;
2 |
3 | import io.lettuce.core.RedisClient;
4 | import io.lettuce.core.api.StatefulRedisConnection;
5 |
6 | /**
7 | * @author Mark Paluch
8 | */
9 | public class ConnectToRedisSSL {
10 |
11 | public static void main(String[] args) {
12 |
13 | // Syntax: rediss://[password@]host[:port][/databaseNumber]
14 | // Adopt the port to the stunnel port in front of your Redis instance
15 | RedisClient redisClient = RedisClient.create("rediss://password@localhost:6443/0");
16 |
17 | StatefulRedisConnection connection = redisClient.connect();
18 |
19 | System.out.println("Connected to Redis using SSL");
20 |
21 | connection.close();
22 | redisClient.shutdown();
23 | }
24 |
25 | }
26 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/ScanArgsUnitTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core;
2 |
3 | import static io.lettuce.TestTags.UNIT_TEST;
4 | import static org.assertj.core.api.Assertions.assertThat;
5 |
6 | import org.junit.jupiter.api.Tag;
7 | import org.junit.jupiter.api.Test;
8 |
9 | import io.lettuce.core.codec.StringCodec;
10 | import io.lettuce.core.protocol.CommandArgs;
11 |
12 | /**
13 | * @author Mark Paluch
14 | */
15 | @Tag(UNIT_TEST)
16 | class ScanArgsUnitTests {
17 |
18 | @Test
19 | void shouldEncodeMatchUsingUtf8() {
20 |
21 | ScanArgs args = ScanArgs.Builder.matches("ö");
22 |
23 | CommandArgs commandArgs = new CommandArgs<>(StringCodec.UTF8);
24 | args.build(commandArgs);
25 |
26 | assertThat(commandArgs.toCommandString()).isEqualTo("MATCH w7Y=");
27 | }
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/vector/VSimScoreAttribs.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2025, Redis Ltd. and Contributors
3 | * All rights reserved.
4 | *
5 | * Licensed under the MIT License.
6 | */
7 | package io.lettuce.core.vector;
8 |
9 | /**
10 | * Holder for a VSIM result entry that includes both the similarity score and the element attributes when WITHATTRIBS is
11 | * requested.
12 | */
13 | public final class VSimScoreAttribs {
14 |
15 | private final double score;
16 |
17 | private final String attributes;
18 |
19 | public VSimScoreAttribs(double score, String attributes) {
20 | this.score = score;
21 | this.attributes = attributes;
22 | }
23 |
24 | public double getScore() {
25 | return score;
26 | }
27 |
28 | public String getAttributes() {
29 | return attributes;
30 | }
31 |
32 | }
33 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/examples/ConnectToRedisUsingRedisSentinel.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.examples;
2 |
3 | import io.lettuce.core.RedisClient;
4 | import io.lettuce.core.api.StatefulRedisConnection;
5 |
6 | /**
7 | * @author Mark Paluch
8 | */
9 | public class ConnectToRedisUsingRedisSentinel {
10 |
11 | public static void main(String[] args) {
12 |
13 | // Syntax: redis-sentinel://[password@]host[:port][,host2[:port2]][/databaseNumber]#sentinelMasterId
14 | RedisClient redisClient = RedisClient.create("redis-sentinel://localhost:26379,localhost:26380/0#mymaster");
15 |
16 | StatefulRedisConnection connection = redisClient.connect();
17 |
18 | System.out.println("Connected to Redis using Redis Sentinel");
19 |
20 | connection.close();
21 | redisClient.shutdown();
22 | }
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/test/condition/EnabledOnCommand.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.test.condition;
2 |
3 | import java.lang.annotation.*;
4 |
5 | import org.junit.jupiter.api.extension.ExtendWith;
6 |
7 | /**
8 | * {@code @EnabledOnCommand} is used to signal that the annotated test class or test method is only enabledif the
9 | * specified command is available.
10 | *
11 | *
12 | * When applied at the class level, all test methods within that class will be enabled .
13 | */
14 | @Target({ ElementType.TYPE, ElementType.METHOD })
15 | @Retention(RetentionPolicy.RUNTIME)
16 | @Inherited
17 | @Documented
18 | @ExtendWith(EnabledOnCommandCondition.class)
19 | public @interface EnabledOnCommand {
20 |
21 | /**
22 | * Name of the Redis command to be available.
23 | *
24 | * @return
25 | */
26 | String value();
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/masterreplica/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Client support for Redis Master/Replica setups. {@link io.lettuce.core.masterreplica.MasterReplica} supports self-managed,
3 | * Redis Sentinel-managed, AWS ElastiCache and Azure Redis managed Master/Replica setups.
4 | *
5 | * Connections can be obtained by providing the {@link io.lettuce.core.RedisClient}, a {@link io.lettuce.core.RedisURI} and a
6 | * {@link io.lettuce.core.codec.RedisCodec}.
7 | *
8 | *
9 | *
10 | * RedisClient client = RedisClient.create();
11 | * StatefulRedisMasterReplicaConnection connection = MasterReplica.connect(client,
12 | * RedisURI.create("redis://localhost"), StringCodec.UTF8);
13 | * // ...
14 | *
15 | * connection.close();
16 | * client.shutdown();
17 | *
18 | */
19 | package io.lettuce.core.masterreplica;
20 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/support/caching/MapCacheAccessor.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.support.caching;
2 |
3 | import java.util.Map;
4 |
5 | /**
6 | * {@link CacheAccessor} implementation for {@link Map}-based cache implementations.
7 | *
8 | * @param Key type.
9 | * @param Value type.
10 | * @author Mark Paluch
11 | * @since 6.0
12 | */
13 | class MapCacheAccessor implements CacheAccessor {
14 |
15 | private final Map map;
16 |
17 | MapCacheAccessor(Map map) {
18 | this.map = map;
19 | }
20 |
21 | @Override
22 | public V get(K key) {
23 | return map.get(key);
24 | }
25 |
26 | @Override
27 | public void put(K key, V value) {
28 | map.put(key, value);
29 | }
30 |
31 | @Override
32 | public void evict(K key) {
33 | map.remove(key);
34 | }
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/commands/transactional/KeyTxCommandIntegrationTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.commands.transactional;
2 |
3 | import javax.inject.Inject;
4 |
5 | import org.junit.jupiter.api.Disabled;
6 |
7 | import io.lettuce.core.api.StatefulRedisConnection;
8 | import io.lettuce.core.commands.KeyCommandIntegrationTests;
9 | import org.junit.jupiter.api.Tag;
10 |
11 | import static io.lettuce.TestTags.INTEGRATION_TEST;
12 |
13 | /**
14 | * @author Mark Paluch
15 | */
16 | @Tag(INTEGRATION_TEST)
17 | public class KeyTxCommandIntegrationTests extends KeyCommandIntegrationTests {
18 |
19 | @Inject
20 | KeyTxCommandIntegrationTests(StatefulRedisConnection connection) {
21 | super(TxSyncInvocationHandler.sync(connection));
22 | }
23 |
24 | @Disabled
25 | @Override
26 | public void move() {
27 | }
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/CloseEvents.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core;
2 |
3 | import java.util.Set;
4 | import java.util.concurrent.ConcurrentHashMap;
5 |
6 | /**
7 | * Close Events Facility. Can register/unregister CloseListener and fire a closed event to all registered listeners.
8 | *
9 | * @author Mark Paluch
10 | * @since 3.0
11 | */
12 | class CloseEvents {
13 |
14 | private final Set listeners = ConcurrentHashMap.newKeySet();
15 |
16 | public void fireEventClosed(Object resource) {
17 | for (CloseListener listener : listeners) {
18 | listener.resourceClosed(resource);
19 | }
20 | }
21 |
22 | public void addListener(CloseListener listener) {
23 | listeners.add(listener);
24 | }
25 |
26 | interface CloseListener {
27 |
28 | void resourceClosed(Object resource);
29 |
30 | }
31 |
32 | }
33 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/event/connection/ConnectionActivatedEvent.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.event.connection;
2 |
3 | import java.net.SocketAddress;
4 |
5 | import io.lettuce.core.ClientOptions;
6 |
7 | /**
8 | * Event for a connection activation (after SSL-handshake, {@link ClientOptions#isPingBeforeActivateConnection() PING before
9 | * activation}, and buffered command replay).
10 | *
11 | * @author Mark Paluch
12 | * @since 3.4
13 | */
14 | public class ConnectionActivatedEvent extends ConnectionEventSupport {
15 |
16 | public ConnectionActivatedEvent(String redisUri, String epId, String channelId, SocketAddress local, SocketAddress remote) {
17 | super(redisUri, epId, channelId, local, remote);
18 | }
19 |
20 | public ConnectionActivatedEvent(SocketAddress local, SocketAddress remote) {
21 | super(local, remote);
22 | }
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/api/AsyncCloseable.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.api;
2 |
3 | import java.util.concurrent.CompletableFuture;
4 |
5 | /**
6 | * A {@link AsyncCloseable} is a resource that can be closed. The {@link #closeAsync()} method is invoked to request resources
7 | * release that the object is holding (such as open files).
8 | *
9 | * @since 6.2
10 | * @author Mark Paluch
11 | */
12 | public interface AsyncCloseable extends io.lettuce.core.internal.AsyncCloseable {
13 |
14 | /**
15 | * Requests to close this object and releases any system resources associated with it. If the object is already closed then
16 | * invoking this method has no effect.
17 | *
18 | * Calls to this method return a {@link CompletableFuture} that is notified with the outcome of the close request.
19 | */
20 | CompletableFuture closeAsync();
21 |
22 | }
23 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/pubsub/api/reactive/ChannelMessage.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.pubsub.api.reactive;
2 |
3 | /**
4 | * Message payload for a subscription to a channel.
5 | *
6 | * @author Mark Paluch
7 | */
8 | public class ChannelMessage {
9 |
10 | private final K channel;
11 |
12 | private final V message;
13 |
14 | /**
15 | *
16 | * @param channel the channel
17 | * @param message the message
18 | */
19 | public ChannelMessage(K channel, V message) {
20 | this.channel = channel;
21 | this.message = message;
22 | }
23 |
24 | /**
25 | *
26 | * @return the channel
27 | */
28 | public K getChannel() {
29 | return channel;
30 | }
31 |
32 | /**
33 | *
34 | * @return the message
35 | */
36 | public V getMessage() {
37 | return message;
38 | }
39 |
40 | }
41 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/test/RoutingInvocationHandler.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.test;
2 |
3 | import java.lang.reflect.InvocationHandler;
4 | import java.lang.reflect.Method;
5 |
6 | /**
7 | * @author Mark Paluch
8 | */
9 | public class RoutingInvocationHandler extends ConnectionDecoratingInvocationHandler {
10 |
11 | private final InvocationHandler delegate;
12 |
13 | public RoutingInvocationHandler(Object target, InvocationHandler delegate) {
14 | super(target);
15 | this.delegate = delegate;
16 | }
17 |
18 | @Override
19 | protected Object handleInvocation(Object proxy, Method method, Object[] args) throws Throwable {
20 |
21 | if (method.getName().equals("getStatefulConnection")) {
22 | return super.handleInvocation(proxy, method, args);
23 | }
24 |
25 | return delegate.invoke(proxy, method, args);
26 | }
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/.github/workflows/release-drafter.yml:
--------------------------------------------------------------------------------
1 | name: Release Drafter
2 |
3 | on: workflow_dispatch
4 |
5 | permissions:
6 | contents: read
7 |
8 | jobs:
9 | update_release_draft:
10 | permissions:
11 | # write permission is required to create a github release
12 | contents: write
13 | # write permission is required for autolabeler
14 | # otherwise, read permission is required at least
15 | pull-requests: write
16 | runs-on: ubuntu-latest
17 | steps:
18 | # Drafts your next Release notes as Pull Requests are merged into "master"
19 | - uses: release-drafter/release-drafter@v6
20 | with:
21 | # (Optional) specify config name to use, relative to .github/. Default: release-drafter.yml
22 | config-name: release-drafter-config.yml
23 | commitish: main
24 | env:
25 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
26 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/protocol/ActivationCommand.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.protocol;
2 |
3 | /**
4 | * Command wrapper to identify activation commands.
5 | *
6 | * @author Mark Paluch
7 | */
8 | class ActivationCommand extends CommandWrapper {
9 |
10 | public ActivationCommand(RedisCommand command) {
11 | super(command);
12 | }
13 |
14 | public static boolean isActivationCommand(RedisCommand command) {
15 |
16 | if (command instanceof ActivationCommand) {
17 | return true;
18 | }
19 |
20 | while (command instanceof CommandWrapper) {
21 | command = ((CommandWrapper) command).getDelegate();
22 |
23 | if (command instanceof ActivationCommand) {
24 | return true;
25 | }
26 | }
27 |
28 | return false;
29 | }
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/commands/reactive/FunctionReactiveCommandIntegrationTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.commands.reactive;
2 |
3 | import javax.inject.Inject;
4 |
5 | import io.lettuce.core.RedisClient;
6 | import io.lettuce.core.api.StatefulRedisConnection;
7 | import io.lettuce.core.commands.FunctionCommandIntegrationTests;
8 | import io.lettuce.test.ReactiveSyncInvocationHandler;
9 | import org.junit.jupiter.api.Tag;
10 |
11 | import static io.lettuce.TestTags.INTEGRATION_TEST;
12 |
13 | /**
14 | * @author Mark Paluch
15 | */
16 | @Tag(INTEGRATION_TEST)
17 | class FunctionReactiveCommandIntegrationTests extends FunctionCommandIntegrationTests {
18 |
19 | @Inject
20 | FunctionReactiveCommandIntegrationTests(RedisClient client, StatefulRedisConnection connection) {
21 | super(client, ReactiveSyncInvocationHandler.sync(connection));
22 | }
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/RedisConnectionStateAdapter.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core;
2 |
3 | import java.net.SocketAddress;
4 |
5 | /**
6 | * Convenience adapter with an empty implementation of all {@link RedisConnectionStateListener} callback methods.
7 | *
8 | * @author Mark Paluch
9 | * @since 4.4
10 | */
11 | public class RedisConnectionStateAdapter implements RedisConnectionStateListener {
12 |
13 | @Override
14 | public void onRedisConnected(RedisChannelHandler connection, SocketAddress socketAddress) {
15 | // empty adapter method
16 | }
17 |
18 | @Override
19 | public void onRedisDisconnected(RedisChannelHandler connection) {
20 | // empty adapter method
21 | }
22 |
23 | @Override
24 | public void onRedisExceptionCaught(RedisChannelHandler connection, Throwable cause) {
25 | // empty adapter method
26 | }
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/cluster/api/push/RedisClusterPushListener.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.cluster.api.push;
2 |
3 | import io.lettuce.core.api.push.PushMessage;
4 | import io.lettuce.core.cluster.models.partitions.RedisClusterNode;
5 |
6 | /**
7 | * Interface to be implemented by push message listeners that are interested in listening to {@link PushMessage} using Redis
8 | * Cluster.
9 | *
10 | * @author Mark Paluch
11 | * @since 6.0
12 | * @see PushMessage
13 | * @see io.lettuce.core.api.push.PushListener
14 | */
15 | @FunctionalInterface
16 | public interface RedisClusterPushListener {
17 |
18 | /**
19 | * Handle a push message.
20 | *
21 | * @param node the {@link RedisClusterNode} from which the {@code message} originates.
22 | * @param message message to respond to.
23 | */
24 | void onPushMessage(RedisClusterNode node, PushMessage message);
25 |
26 | }
27 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/dynamic/output/CommandOutputFactory.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.dynamic.output;
2 |
3 | import io.lettuce.core.codec.RedisCodec;
4 | import io.lettuce.core.output.CommandOutput;
5 |
6 | /**
7 | * Strategy interface to create {@link CommandOutput} given {@link RedisCodec}.
8 | *
9 | *
10 | * Implementing classes usually produce the same {@link CommandOutput} type.
11 | *
12 | * @author Mark Paluch
13 | * @since 5.0
14 | */
15 | @FunctionalInterface
16 | public interface CommandOutputFactory {
17 |
18 | /**
19 | * Create and initialize a new {@link CommandOutput} given {@link RedisCodec}.
20 | *
21 | * @param codec must not be {@code null}.
22 | * @param Key type.
23 | * @param Value type.
24 | * @return the new {@link CommandOutput}.
25 | */
26 | CommandOutput create(RedisCodec codec);
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/output/KeyStreamingOutput.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.output;
2 |
3 | import java.nio.ByteBuffer;
4 |
5 | import io.lettuce.core.codec.RedisCodec;
6 |
7 | /**
8 | * Streaming-Output of Keys. Returns the count of all keys (including null).
9 | *
10 | * @param Key type.
11 | * @param Value type.
12 | * @author Mark Paluch
13 | */
14 | public class KeyStreamingOutput extends CommandOutput {
15 |
16 | private final KeyStreamingChannel channel;
17 |
18 | public KeyStreamingOutput(RedisCodec codec, KeyStreamingChannel channel) {
19 | super(codec, Long.valueOf(0));
20 | this.channel = channel;
21 | }
22 |
23 | @Override
24 | public void set(ByteBuffer bytes) {
25 |
26 | channel.onKey(bytes == null ? null : codec.decodeKey(bytes));
27 | output = output.longValue() + 1;
28 | }
29 |
30 | }
31 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/commands/reactive/AclReactiveCommandIntegrationTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.commands.reactive;
2 |
3 | import javax.inject.Inject;
4 |
5 | import io.lettuce.core.api.StatefulRedisConnection;
6 | import io.lettuce.core.commands.AclCommandIntegrationTests;
7 | import io.lettuce.test.ReactiveSyncInvocationHandler;
8 | import org.junit.jupiter.api.Tag;
9 |
10 | import static io.lettuce.TestTags.INTEGRATION_TEST;
11 |
12 | /**
13 | * Integration tests though the reactive facade for {@link AclCommandIntegrationTests}.
14 | *
15 | * @author Mark Paluch
16 | */
17 | @Tag(INTEGRATION_TEST)
18 | class AclReactiveCommandIntegrationTests extends AclCommandIntegrationTests {
19 |
20 | @Inject
21 | AclReactiveCommandIntegrationTests(StatefulRedisConnection connection) {
22 | super(ReactiveSyncInvocationHandler.sync(connection));
23 | }
24 |
25 | }
26 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/commands/reactive/ScriptingReactiveCommandIntegrationTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.commands.reactive;
2 |
3 | import javax.inject.Inject;
4 |
5 | import io.lettuce.core.RedisClient;
6 | import io.lettuce.core.api.StatefulRedisConnection;
7 | import io.lettuce.core.commands.ScriptingCommandIntegrationTests;
8 | import io.lettuce.test.ReactiveSyncInvocationHandler;
9 | import org.junit.jupiter.api.Tag;
10 |
11 | import static io.lettuce.TestTags.INTEGRATION_TEST;
12 |
13 | /**
14 | * @author Mark Paluch
15 | */
16 | @Tag(INTEGRATION_TEST)
17 | class ScriptingReactiveCommandIntegrationTests extends ScriptingCommandIntegrationTests {
18 |
19 | @Inject
20 | ScriptingReactiveCommandIntegrationTests(RedisClient client, StatefulRedisConnection connection) {
21 | super(client, ReactiveSyncInvocationHandler.sync(connection));
22 | }
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/dynamic/batch/BatchExecutor.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.dynamic.batch;
2 |
3 | /**
4 | * Batch executor interface to enforce command queue flushing using {@link BatchSize}.
5 | *
6 | * Commands remain in a batch queue until the batch size is reached or the queue is {@link BatchExecutor#flush() flushed}. If
7 | * the batch size is not reached, commands remain not executed.
8 | *
9 | * Commands that fail during the batch cause a {@link BatchException} while non-failed commands remain executed successfully.
10 | *
11 | * @author Mark Paluch
12 | * @since 5.0
13 | * @see BatchSize
14 | */
15 | public interface BatchExecutor {
16 |
17 | /**
18 | * Flush the command queue resulting in the queued commands being executed.
19 | *
20 | * @throws BatchException if at least one command failed.
21 | */
22 | void flush() throws BatchException;
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/event/connection/JfrConnectionCreatedEvent.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.event.connection;
2 |
3 | import jdk.jfr.Category;
4 | import jdk.jfr.Event;
5 | import jdk.jfr.Label;
6 |
7 | /**
8 | * Flight recorder event variant of {@link ConnectionCreatedEvent}.
9 | *
10 | * @author Mark Paluch
11 | * @since 6.1
12 | */
13 | @Category({ "Lettuce", "Connection Events" })
14 | @Label("Connection Created")
15 | class JfrConnectionCreatedEvent extends Event {
16 |
17 | private final String redisUri;
18 |
19 | private final String epId;
20 |
21 | public JfrConnectionCreatedEvent(ConnectionCreatedEvent event) {
22 | this.redisUri = event.getRedisUri();
23 | this.epId = event.getEpId();
24 | }
25 |
26 | public String getRedisUri() {
27 | return redisUri;
28 | }
29 |
30 | public String getEpId() {
31 | return epId;
32 | }
33 |
34 | }
35 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/pubsub/PubSubCommandArgs.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.pubsub;
2 |
3 | import java.nio.ByteBuffer;
4 |
5 | import io.lettuce.core.codec.RedisCodec;
6 | import io.lettuce.core.protocol.CommandArgs;
7 |
8 | /**
9 | *
10 | * Command args for Pub/Sub connections. This implementation hides the first key as PubSub keys are not keys from the key-space.
11 | *
12 | * @author Mark Paluch
13 | * @since 4.2
14 | */
15 | class PubSubCommandArgs extends CommandArgs {
16 |
17 | /**
18 | * @param codec Codec used to encode/decode keys and values, must not be {@code null}.
19 | */
20 | public PubSubCommandArgs(RedisCodec codec) {
21 | super(codec);
22 | }
23 |
24 | /**
25 | *
26 | * @return always {@code null}.
27 | */
28 | @Override
29 | public ByteBuffer getFirstEncodedKey() {
30 | return null;
31 | }
32 |
33 | }
34 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/pubsub/PubSubMessage.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.pubsub;
2 |
3 | /**
4 | * Represents a Pub/Sub notification message.
5 | *
6 | * @author Mark Paluch
7 | * @since 6.0
8 | */
9 | public interface PubSubMessage {
10 |
11 | /**
12 | * @return the {@link PubSubOutput.Type} message type.
13 | */
14 | PubSubOutput.Type type();
15 |
16 | /**
17 | * @return name of the channel to which this notification belongs to.
18 | */
19 | K channel();
20 |
21 | /**
22 | * @return pattern that applies if the message was received through a pattern subscription. Can be {@code null}.
23 | */
24 | K pattern();
25 |
26 | /**
27 | * @return the subscriber count if applicable.
28 | */
29 | long count();
30 |
31 | /**
32 | * @return the message body, if applicable. Can be {@code null}.
33 | */
34 | V body();
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/output/ComplexDataParser.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2024, Redis Ltd. and Contributors
3 | * All rights reserved.
4 | *
5 | * Licensed under the MIT License.
6 | */
7 |
8 | package io.lettuce.core.output;
9 |
10 | /**
11 | * Any usage of the {@link ComplexOutput} comes hand in hand with a respective {@link ComplexDataParser} that is able to parse
12 | * the data extracted from the server to a meaningful Java object.
13 | *
14 | * @param the type of the parsed object
15 | * @author Tihomir Mateev
16 | * @see ComplexData
17 | * @see ComplexOutput
18 | * @since 6.5
19 | */
20 | public interface ComplexDataParser {
21 |
22 | /**
23 | * Parse the data extracted from the server to a specific domain object.
24 | *
25 | * @param data the data to parse
26 | * @return the parsed object
27 | * @since 6.5
28 | */
29 | T parse(ComplexData data);
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/output/ValueStreamingOutput.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.output;
2 |
3 | import java.nio.ByteBuffer;
4 |
5 | import io.lettuce.core.codec.RedisCodec;
6 |
7 | /**
8 | * Streaming-Output of Values. Returns the count of all values (including null).
9 | *
10 | * @param Key type.
11 | * @param Value type.
12 | * @author Mark Paluch
13 | */
14 | public class ValueStreamingOutput extends CommandOutput {
15 |
16 | private final ValueStreamingChannel channel;
17 |
18 | public ValueStreamingOutput(RedisCodec codec, ValueStreamingChannel channel) {
19 | super(codec, Long.valueOf(0));
20 | this.channel = channel;
21 | }
22 |
23 | @Override
24 | public void set(ByteBuffer bytes) {
25 |
26 | channel.onValue(bytes == null ? null : codec.decodeValue(bytes));
27 | output = output.longValue() + 1;
28 | }
29 |
30 | }
31 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/tracing/LettuceObservationConvention.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.tracing;
2 |
3 | import io.micrometer.observation.Observation;
4 | import io.micrometer.observation.ObservationConvention;
5 |
6 | /**
7 | * {@link ObservationConvention} for {@link LettuceObservationContext}.
8 | *
9 | * @author Mark Paluch
10 | * @since 6.3
11 | */
12 | public interface LettuceObservationConvention extends ObservationConvention {
13 |
14 | @Override
15 | default boolean supportsContext(Observation.Context context) {
16 | return context instanceof LettuceObservationContext;
17 | }
18 |
19 | /**
20 | * @return whether to attach the full command into the trace. Use this flag with caution as sensitive arguments will be
21 | * captured in the observation spans and metric tags.
22 | */
23 | boolean includeCommandArgsInSpanTags();
24 |
25 | }
26 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/TestRedisPublisher.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core;
2 |
3 | import java.util.function.Supplier;
4 |
5 | import io.lettuce.core.api.StatefulConnection;
6 | import io.lettuce.core.protocol.RedisCommand;
7 | import io.netty.util.concurrent.ImmediateEventExecutor;
8 |
9 | /**
10 | * @author Mark Paluch
11 | */
12 | public class TestRedisPublisher extends RedisPublisher {
13 |
14 | public TestRedisPublisher(RedisCommand staticCommand, StatefulConnection connection, boolean dissolve) {
15 | super(staticCommand, connection, dissolve, ImmediateEventExecutor.INSTANCE);
16 | }
17 |
18 | public TestRedisPublisher(Supplier> redisCommandSupplier, StatefulConnection connection,
19 | boolean dissolve) {
20 | super(redisCommandSupplier, connection, dissolve, ImmediateEventExecutor.INSTANCE);
21 | }
22 |
23 | }
24 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/test/resource/FastShutdown.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.test.resource;
2 |
3 | import java.util.concurrent.TimeUnit;
4 |
5 | import io.lettuce.core.AbstractRedisClient;
6 | import io.lettuce.core.resource.ClientResources;
7 |
8 | /**
9 | * @author Mark Paluch
10 | */
11 | public class FastShutdown {
12 |
13 | /**
14 | * Shut down a {@link AbstractRedisClient} with a timeout of 10ms.
15 | *
16 | * @param redisClient
17 | */
18 | public static void shutdown(AbstractRedisClient redisClient) {
19 | redisClient.shutdown(0, 10, TimeUnit.MILLISECONDS);
20 | }
21 |
22 | /**
23 | * Shut down a {@link ClientResources} client with a timeout of 10ms.
24 | *
25 | * @param clientResources
26 | */
27 | public static void shutdown(ClientResources clientResources) {
28 | clientResources.shutdown(0, 10, TimeUnit.MILLISECONDS);
29 | }
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/event/connection/ReauthenticationEvent.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2024, Redis Ltd. and Contributors
3 | * All rights reserved.
4 | *
5 | * Licensed under the MIT License.
6 | */
7 | package io.lettuce.core.event.connection;
8 |
9 | /**
10 | * Event fired on successful connection re-authentication
11 | *
12 | * @author Ivo Gaydajiev
13 | * @since 6.6.0
14 | * @see io.lettuce.core.RedisCredentialsProvider
15 | */
16 | public class ReauthenticationEvent implements AuthenticationEvent {
17 |
18 | private final String epId;
19 |
20 | /**
21 | * Create a new {@link ReauthenticationEvent} given a connection endpoint ID
22 | *
23 | * @param epId the connection endpoint ID
24 | */
25 | public ReauthenticationEvent(String epId) {
26 | this.epId = epId;
27 | }
28 |
29 | @Override
30 | public String getEpId() {
31 | return epId;
32 | }
33 |
34 | }
35 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/LimitUnitTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core;
2 |
3 | import static io.lettuce.TestTags.UNIT_TEST;
4 | import static org.assertj.core.api.Assertions.assertThat;
5 |
6 | import org.junit.jupiter.api.Tag;
7 | import org.junit.jupiter.api.Test;
8 |
9 | /**
10 | * @author Mark Paluch
11 | */
12 | @Tag(UNIT_TEST)
13 | class LimitUnitTests {
14 |
15 | @Test
16 | void create() {
17 |
18 | Limit limit = Limit.create(1, 2);
19 |
20 | assertThat(limit.getOffset()).isEqualTo(1);
21 | assertThat(limit.getCount()).isEqualTo(2);
22 | assertThat(limit.isLimited()).isTrue();
23 | }
24 |
25 | @Test
26 | void unlimited() {
27 |
28 | Limit limit = Limit.unlimited();
29 |
30 | assertThat(limit.getOffset()).isEqualTo(-1);
31 | assertThat(limit.getCount()).isEqualTo(-1);
32 | assertThat(limit.isLimited()).isFalse();
33 | }
34 |
35 | }
36 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/masterslave/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Client support for Redis Master/Slave setups. {@link io.lettuce.core.masterslave.MasterSlave} supports self-managed, Redis
3 | * Sentinel-managed, AWS ElastiCache and Azure Redis managed Master/Slave setups.
4 | *
5 | * Connections can be obtained by providing the {@link io.lettuce.core.RedisClient}, a {@link io.lettuce.core.RedisURI} and a
6 | * {@link io.lettuce.core.codec.RedisCodec}.
7 | *
8 | *
9 | *
10 | * RedisClient client = RedisClient.create();
11 | * StatefulRedisMasterSlaveConnection connection = MasterSlave.connect(client,
12 | * RedisURI.create("redis://localhost"), StringCodec.UTF8);
13 | * // ...
14 | *
15 | * connection.close();
16 | * client.shutdown();
17 | *
18 | *
19 | * @deprecated will be moved to {@code masterreplica} package with version 6.
20 | */
21 | package io.lettuce.core.masterslave;
22 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/event/connection/JfrConnectEvent.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.event.connection;
2 |
3 | import jdk.jfr.Category;
4 | import jdk.jfr.Event;
5 | import jdk.jfr.Label;
6 | import jdk.jfr.StackTrace;
7 |
8 | /**
9 | * Flight recorder event variant of {@link ConnectionCreatedEvent}.
10 | *
11 | * @author Mark Paluch
12 | * @since 6.1
13 | */
14 | @Category({ "Lettuce", "Connection Events" })
15 | @Label("Connect to a Redis server")
16 | @StackTrace(value = false)
17 | class JfrConnectEvent extends Event {
18 |
19 | private final String redisUri;
20 |
21 | private final String epId;
22 |
23 | public JfrConnectEvent(ConnectEvent event) {
24 | this.redisUri = event.getRedisUri();
25 | this.epId = event.getEpId();
26 | }
27 |
28 | public String getRedisUri() {
29 | return redisUri;
30 | }
31 |
32 | public String getEpId() {
33 | return epId;
34 | }
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/internal/AsyncCloseable.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.internal;
2 |
3 | import java.util.concurrent.CompletableFuture;
4 |
5 | /**
6 | * A {@link AsyncCloseable} is a resource that can be closed. The {@link #closeAsync()} method is invoked to request resources
7 | * release that the object is holding (such as open files).
8 | *
9 | * @since 5.1
10 | * @author Mark Paluch
11 | * @deprecated since 6.2, use {@link io.lettuce.core.api.AsyncCloseable} instead.
12 | */
13 | @Deprecated
14 | public interface AsyncCloseable {
15 |
16 | /**
17 | * Requests to close this object and releases any system resources associated with it. If the object is already closed then
18 | * invoking this method has no effect.
19 | *
20 | * Calls to this method return a {@link CompletableFuture} that is notified with the outcome of the close request.
21 | */
22 | CompletableFuture closeAsync();
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/cluster/commands/HashClusterCommandIntegrationTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.cluster.commands;
2 |
3 | import javax.inject.Inject;
4 |
5 | import io.lettuce.core.cluster.ClusterTestUtil;
6 | import io.lettuce.core.cluster.api.StatefulRedisClusterConnection;
7 | import io.lettuce.core.commands.HashCommandIntegrationTests;
8 | import org.junit.jupiter.api.Tag;
9 |
10 | import static io.lettuce.TestTags.INTEGRATION_TEST;
11 |
12 | /**
13 | * Integration tests for {@link io.lettuce.core.api.sync.RedisHashCommands} using Redis Cluster.
14 | *
15 | * @author Mark Paluch
16 | */
17 | @Tag(INTEGRATION_TEST)
18 | public class HashClusterCommandIntegrationTests extends HashCommandIntegrationTests {
19 |
20 | @Inject
21 | public HashClusterCommandIntegrationTests(StatefulRedisClusterConnection connection) {
22 | super(ClusterTestUtil.redisCommandsOverCluster(connection));
23 | }
24 |
25 | }
26 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/cluster/event/JfrAskRedirectionEvent.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.cluster.event;
2 |
3 | import jdk.jfr.Category;
4 | import jdk.jfr.Event;
5 | import jdk.jfr.Label;
6 | import jdk.jfr.StackTrace;
7 |
8 | /**
9 | * Flight recorder event variant of {@link AskRedirectionEvent}.
10 | *
11 | * @author Mark Paluch
12 | * @since 6.1
13 | */
14 | @Category({ "Lettuce", "Cluster Events" })
15 | @Label("ASK Redirection")
16 | @StackTrace(false)
17 | class JfrAskRedirectionEvent extends Event {
18 |
19 | private final String command;
20 |
21 | private final String key;
22 |
23 | private final int slot;
24 |
25 | private final String message;
26 |
27 | public JfrAskRedirectionEvent(RedirectionEventSupport event) {
28 | this.command = event.getCommand();
29 | this.key = event.getKey();
30 | this.slot = event.getSlot();
31 | this.message = event.getMessage();
32 | }
33 |
34 | }
35 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/commands/transactional/StreamTxCommandIntegrationTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.commands.transactional;
2 |
3 | import javax.inject.Inject;
4 |
5 | import org.junit.jupiter.api.Disabled;
6 | import org.junit.jupiter.api.Tag;
7 | import org.junit.jupiter.api.Test;
8 |
9 | import io.lettuce.core.api.StatefulRedisConnection;
10 | import io.lettuce.core.commands.StreamCommandIntegrationTests;
11 |
12 | import static io.lettuce.TestTags.INTEGRATION_TEST;
13 |
14 | /**
15 | * @author Mark Paluch
16 | */
17 | @Tag(INTEGRATION_TEST)
18 | class StreamTxCommandIntegrationTests extends StreamCommandIntegrationTests {
19 |
20 | @Inject
21 | StreamTxCommandIntegrationTests(StatefulRedisConnection connection) {
22 | super(TxSyncInvocationHandler.sync(connection));
23 | }
24 |
25 | @Test
26 | @Disabled("TX over TX doesn't work")
27 | public void xreadTransactional() {
28 | }
29 |
30 | }
31 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/cluster/event/JfrMovedRedirectionEvent.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.cluster.event;
2 |
3 | import jdk.jfr.Category;
4 | import jdk.jfr.Event;
5 | import jdk.jfr.Label;
6 | import jdk.jfr.StackTrace;
7 |
8 | /**
9 | * Flight recorder event variant of {@link MovedRedirectionEvent}.
10 | *
11 | * @author Mark Paluch
12 | * @since 6.1
13 | */
14 | @Category({ "Lettuce", "Cluster Events" })
15 | @Label("MOVED Redirection")
16 | @StackTrace(false)
17 | class JfrMovedRedirectionEvent extends Event {
18 |
19 | private final String command;
20 |
21 | private final String key;
22 |
23 | private final int slot;
24 |
25 | private final String message;
26 |
27 | public JfrMovedRedirectionEvent(RedirectionEventSupport event) {
28 | this.command = event.getCommand();
29 | this.key = event.getKey();
30 | this.slot = event.getSlot();
31 | this.message = event.getMessage();
32 | }
33 |
34 | }
35 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/masterreplica/SentinelTopologyRefreshEvent.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.masterreplica;
2 |
3 | import io.lettuce.core.event.Event;
4 |
5 | /**
6 | * Event triggered when Redis Sentinel indicates a topology change trigger.
7 | *
8 | * @author Mark Paluch
9 | * @since 6.1
10 | */
11 | class SentinelTopologyRefreshEvent implements Event {
12 |
13 | private final String source;
14 |
15 | private final String message;
16 |
17 | private final long delayMs;
18 |
19 | public SentinelTopologyRefreshEvent(String source, String message, long delayMs) {
20 | this.source = source;
21 | this.message = message;
22 | this.delayMs = delayMs;
23 | }
24 |
25 | public String getSource() {
26 | return source;
27 | }
28 |
29 | public String getMessage() {
30 | return message;
31 | }
32 |
33 | public long getDelayMs() {
34 | return delayMs;
35 | }
36 |
37 | }
38 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/RedisBusyException.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core;
2 |
3 | /**
4 | * Exception that gets thrown when Redis is busy executing a Lua script with a {@code BUSY} error response.
5 | *
6 | * @author Mark Paluch
7 | * @since 4.5
8 | */
9 | @SuppressWarnings("serial")
10 | public class RedisBusyException extends RedisCommandExecutionException {
11 |
12 | /**
13 | * Create a {@code RedisBusyException} with the specified detail message.
14 | *
15 | * @param msg the detail message.
16 | */
17 | public RedisBusyException(String msg) {
18 | super(msg);
19 | }
20 |
21 | /**
22 | * Create a {@code RedisNoScriptException} with the specified detail message and nested exception.
23 | *
24 | * @param msg the detail message.
25 | * @param cause the nested exception.
26 | */
27 | public RedisBusyException(String msg, Throwable cause) {
28 | super(msg, cause);
29 | }
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/.github/workflows/snapshot.yaml:
--------------------------------------------------------------------------------
1 | ---
2 |
3 | name: Publish Snapshot
4 |
5 | on:
6 | push:
7 | branches:
8 | - main
9 | - '[0-9].x'
10 | workflow_dispatch:
11 |
12 | jobs:
13 |
14 | snapshot:
15 | name: Deploy Snapshot
16 | runs-on: ubuntu-latest
17 | steps:
18 | - uses: actions/checkout@v4
19 | - name: Set up publishing to maven central
20 | uses: actions/setup-java@v4
21 | with:
22 | java-version: '8'
23 | distribution: 'temurin'
24 | cache: 'maven'
25 | server-id: central
26 | server-username: MAVEN_USERNAME
27 | server-password: MAVEN_PASSWORD
28 | - name: mvn offline
29 | run: |
30 | mvn -q dependency:go-offline
31 | - name: deploy
32 | run: |
33 | mvn --no-transfer-progress deploy
34 | env:
35 | MAVEN_USERNAME: ${{secrets.OSSH_USERNAME}}
36 | MAVEN_PASSWORD: ${{secrets.OSSH_TOKEN}}
37 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/masterreplica/MasterReplicaTopologyChangedEvent.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.masterreplica;
2 |
3 | import java.util.List;
4 |
5 | import io.lettuce.core.RedisURI;
6 | import io.lettuce.core.event.Event;
7 | import io.lettuce.core.models.role.RedisNodeDescription;
8 |
9 | /**
10 | * Event triggered after obtaining the Master/Replica topology.
11 | *
12 | * @author Mark Paluch
13 | * @since 6.1
14 | */
15 | class MasterReplicaTopologyChangedEvent implements Event {
16 |
17 | private final RedisURI source;
18 |
19 | private final List nodes;
20 |
21 | public MasterReplicaTopologyChangedEvent(RedisURI source, List nodes) {
22 | this.source = source;
23 | this.nodes = nodes;
24 | }
25 |
26 | public RedisURI getSource() {
27 | return source;
28 | }
29 |
30 | public List getNodes() {
31 | return nodes;
32 | }
33 |
34 | }
35 |
--------------------------------------------------------------------------------
/src/test/jmh/io/lettuce/core/cluster/EmptyRedisClusterClient.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.cluster;
2 |
3 | import java.net.SocketAddress;
4 | import java.util.Collections;
5 | import java.util.function.Supplier;
6 |
7 | import io.lettuce.core.EmptyStatefulRedisConnection;
8 | import io.lettuce.core.RedisChannelWriter;
9 | import io.lettuce.core.RedisURI;
10 | import io.lettuce.core.api.StatefulRedisConnection;
11 | import io.lettuce.core.codec.RedisCodec;
12 |
13 | /**
14 | * @author Mark Paluch
15 | */
16 | class EmptyRedisClusterClient extends RedisClusterClient {
17 |
18 | public EmptyRedisClusterClient(RedisURI initialUri) {
19 | super(null, Collections.singleton(initialUri));
20 | }
21 |
22 | StatefulRedisConnection connectToNode(RedisCodec codec, String nodeId, RedisChannelWriter clusterWriter,
23 | final Supplier socketAddressSupplier) {
24 | return EmptyStatefulRedisConnection.INSTANCE;
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/cluster/event/RedirectionEventSupport.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.cluster.event;
2 |
3 | import io.lettuce.core.event.Event;
4 |
5 | /**
6 | * @author Mark Paluch
7 | */
8 | public class RedirectionEventSupport implements Event {
9 |
10 | private final String command;
11 |
12 | private final String key;
13 |
14 | private final int slot;
15 |
16 | private final String message;
17 |
18 | public RedirectionEventSupport(String command, String key, int slot, String message) {
19 | this.command = command;
20 | this.key = key;
21 | this.slot = slot;
22 | this.message = message;
23 | }
24 |
25 | public String getCommand() {
26 | return command;
27 | }
28 |
29 | public String getKey() {
30 | return key;
31 | }
32 |
33 | public int getSlot() {
34 | return slot;
35 | }
36 |
37 | public String getMessage() {
38 | return message;
39 | }
40 |
41 | }
42 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/output/SocketAddressOutputUnitTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.output;
2 |
3 | import static io.lettuce.TestTags.UNIT_TEST;
4 | import static org.assertj.core.api.Assertions.assertThat;
5 |
6 | import java.net.InetSocketAddress;
7 | import java.nio.ByteBuffer;
8 |
9 | import org.junit.jupiter.api.Tag;
10 | import org.junit.jupiter.api.Test;
11 |
12 | import io.lettuce.core.codec.StringCodec;
13 |
14 | /**
15 | * @author Mark Paluch
16 | */
17 | @Tag(UNIT_TEST)
18 | class SocketAddressOutputUnitTests {
19 |
20 | @Test
21 | void shouldReportSocketAddress() {
22 |
23 | SocketAddressOutput output = new SocketAddressOutput<>(StringCodec.ASCII);
24 |
25 | output.set(ByteBuffer.wrap("localhost".getBytes()));
26 | output.set(ByteBuffer.wrap("6379".getBytes()));
27 |
28 | output.complete(0);
29 |
30 | assertThat(output.get()).isNotNull().isInstanceOf(InetSocketAddress.class);
31 | }
32 |
33 | }
34 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/examples/ConnectToElastiCacheMaster.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.examples;
2 |
3 | import io.lettuce.core.RedisClient;
4 | import io.lettuce.core.api.StatefulRedisConnection;
5 | import io.lettuce.core.resource.DefaultClientResources;
6 | import io.lettuce.core.resource.DirContextDnsResolver;
7 |
8 | /**
9 | * @author Mark Paluch
10 | */
11 | public class ConnectToElastiCacheMaster {
12 |
13 | public static void main(String[] args) {
14 |
15 | // Syntax: redis://[password@]host[:port][/databaseNumber]
16 |
17 | DefaultClientResources clientResources = DefaultClientResources.builder().build();
18 |
19 | RedisClient redisClient = RedisClient.create(clientResources, "redis://password@localhost:6379/0");
20 | StatefulRedisConnection connection = redisClient.connect();
21 |
22 | System.out.println("Connected to Redis");
23 |
24 | connection.close();
25 | redisClient.shutdown();
26 | }
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/examples/ConnectToRedisClusterSSL.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.examples;
2 |
3 | import io.lettuce.core.RedisURI;
4 | import io.lettuce.core.cluster.RedisClusterClient;
5 | import io.lettuce.core.cluster.api.StatefulRedisClusterConnection;
6 |
7 | /**
8 | * @author Mark Paluch
9 | */
10 | public class ConnectToRedisClusterSSL {
11 |
12 | public static void main(String[] args) {
13 |
14 | // Syntax: rediss://[password@]host[:port]
15 | RedisURI redisURI = RedisURI.create("rediss://password@localhost:7379");
16 | redisURI.setVerifyPeer(false); // depending on your setup, you might want to disable peer verification
17 |
18 | RedisClusterClient redisClient = RedisClusterClient.create(redisURI);
19 | StatefulRedisClusterConnection connection = redisClient.connect();
20 |
21 | System.out.println("Connected to Redis");
22 |
23 | connection.close();
24 | redisClient.shutdown();
25 | }
26 |
27 | }
28 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/RedisLoadingException.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core;
2 |
3 | /**
4 | * Exception that gets thrown when Redis is loading a dataset into memory and replying with a {@code LOADING} error response.
5 | *
6 | * @author Mark Paluch
7 | * @since 4.5
8 | */
9 | @SuppressWarnings("serial")
10 | public class RedisLoadingException extends RedisCommandExecutionException {
11 |
12 | /**
13 | * Create a {@code RedisLoadingException} with the specified detail message.
14 | *
15 | * @param msg the detail message.
16 | */
17 | public RedisLoadingException(String msg) {
18 | super(msg);
19 | }
20 |
21 | /**
22 | * Create a {@code RedisLoadingException} with the specified detail message and nested exception.
23 | *
24 | * @param msg the detail message.
25 | * @param cause the nested exception.
26 | */
27 | public RedisLoadingException(String msg, Throwable cause) {
28 | super(msg, cause);
29 | }
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/protocol/PushHandler.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.protocol;
2 |
3 | import java.util.Collection;
4 |
5 | import io.lettuce.core.api.push.PushListener;
6 |
7 | /**
8 | * A handler object that provides access to {@link PushListener}.
9 | *
10 | * @author Mark Paluch
11 | * @since 6.0
12 | */
13 | public interface PushHandler {
14 |
15 | /**
16 | * Add a new {@link PushListener listener}.
17 | *
18 | * @param listener the listener, must not be {@code null}.
19 | */
20 | void addListener(PushListener listener);
21 |
22 | /**
23 | * Remove an existing {@link PushListener listener}.
24 | *
25 | * @param listener the listener, must not be {@code null}.
26 | */
27 | void removeListener(PushListener listener);
28 |
29 | /**
30 | * Returns a collection of {@link PushListener}.
31 | *
32 | * @return the collection of listeners.
33 | */
34 | Collection getPushListeners();
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/test/resource/DefaultRedisClient.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.test.resource;
2 |
3 | import io.lettuce.core.RedisClient;
4 | import io.lettuce.core.RedisURI;
5 | import io.lettuce.test.settings.TestSettings;
6 |
7 | /**
8 | * @author Mark Paluch
9 | * @author Hari Mani
10 | */
11 | public class DefaultRedisClient {
12 |
13 | private static final DefaultRedisClient instance = new DefaultRedisClient();
14 |
15 | private final RedisClient redisClient;
16 |
17 | private DefaultRedisClient() {
18 | redisClient = RedisClient.create(RedisURI.Builder.redis(TestSettings.host(), TestSettings.port()).build());
19 | Runtime.getRuntime().addShutdownHook(new Thread(() -> FastShutdown.shutdown(redisClient)));
20 | }
21 |
22 | /**
23 | * Do not close the client.
24 | *
25 | * @return the default redis client for the tests.
26 | */
27 | public static RedisClient get() {
28 | return instance.redisClient;
29 | }
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/OrderingReadFromAccessor.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core;
2 |
3 | /**
4 | * Accessor for {@link ReadFrom} ordering. Internal utility class.
5 | *
6 | * @author Mark Paluch
7 | * @since 5.2
8 | */
9 | public abstract class OrderingReadFromAccessor {
10 |
11 | /**
12 | * Utility constructor.
13 | */
14 | private OrderingReadFromAccessor() {
15 | }
16 |
17 | /**
18 | * Returns whether this {@link ReadFrom} requires ordering of the resulting
19 | * {@link io.lettuce.core.models.role.RedisNodeDescription nodes}.
20 | *
21 | * @return {@code true} if code using {@link ReadFrom} should retain ordering or {@code false} to allow reordering of
22 | * {@link io.lettuce.core.models.role.RedisNodeDescription nodes}.
23 | * @since 5.2
24 | * @see ReadFrom#isOrderSensitive()
25 | */
26 | public static boolean isOrderSensitive(ReadFrom readFrom) {
27 | return readFrom.isOrderSensitive();
28 | }
29 |
30 | }
31 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/cluster/event/JfrTopologyRefreshEvent.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.cluster.event;
2 |
3 | import java.util.StringJoiner;
4 |
5 | import jdk.jfr.Category;
6 | import jdk.jfr.Event;
7 | import jdk.jfr.Label;
8 | import jdk.jfr.StackTrace;
9 | import io.lettuce.core.RedisURI;
10 |
11 | /**
12 | * Flight recorder event variant of {@link TopologyRefreshEvent}.
13 | *
14 | * @author Mark Paluch
15 | * @since 6.1
16 | */
17 | @Category({ "Lettuce", "Cluster Events" })
18 | @Label("Topology Refresh")
19 | @StackTrace(value = false)
20 | class JfrTopologyRefreshEvent extends Event {
21 |
22 | private final String sources;
23 |
24 | public JfrTopologyRefreshEvent(TopologyRefreshEvent event) {
25 |
26 | StringJoiner joiner = new StringJoiner(", ");
27 |
28 | for (RedisURI redisURI : event.getTopologyRefreshSource()) {
29 | joiner.add(redisURI.toString());
30 | }
31 |
32 | this.sources = joiner.toString();
33 | }
34 |
35 | }
36 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/masterreplica/RedisClientNodeConnectionFactory.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.masterreplica;
2 |
3 | import java.util.concurrent.CompletableFuture;
4 |
5 | import io.lettuce.core.RedisClient;
6 | import io.lettuce.core.RedisURI;
7 | import io.lettuce.core.api.StatefulRedisConnection;
8 | import io.lettuce.core.codec.RedisCodec;
9 |
10 | /**
11 | * {@link NodeConnectionFactory} implementation that on {@link RedisClient}.
12 | *
13 | * @author Mark Paluch
14 | */
15 | class RedisClientNodeConnectionFactory implements NodeConnectionFactory {
16 |
17 | private final RedisClient client;
18 |
19 | RedisClientNodeConnectionFactory(RedisClient client) {
20 | this.client = client;
21 | }
22 |
23 | @Override
24 | public CompletableFuture> connectToNodeAsync(RedisCodec codec,
25 | RedisURI redisURI) {
26 | return client.connectAsync(codec, redisURI).toCompletableFuture();
27 | }
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/cluster/PartitionSelectorException.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.cluster;
2 |
3 | import io.lettuce.core.cluster.models.partitions.Partitions;
4 |
5 | /**
6 | * Exception thrown when a partition selection fails (slot not covered, no read candidates available).
7 | *
8 | * @author Mark Paluch
9 | * @since 5.1
10 | */
11 | @SuppressWarnings("serial")
12 | public class PartitionSelectorException extends PartitionException {
13 |
14 | private final Partitions partitions;
15 |
16 | /**
17 | * Create a {@code UnknownPartitionException} with the specified detail message.
18 | *
19 | * @param msg the detail message.
20 | * @param partitions read-only view of the current topology view.
21 | */
22 | public PartitionSelectorException(String msg, Partitions partitions) {
23 |
24 | super(msg);
25 | this.partitions = partitions;
26 | }
27 |
28 | public Partitions getPartitions() {
29 | return partitions;
30 | }
31 |
32 | }
33 |
--------------------------------------------------------------------------------
/src/test/resources/spring-test.xml:
--------------------------------------------------------------------------------
1 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/cluster/topology/RedisClusterNodeSnapshot.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.cluster.topology;
2 |
3 | import io.lettuce.core.cluster.models.partitions.RedisClusterNode;
4 |
5 | /**
6 | * @author Mark Paluch
7 | */
8 | @SuppressWarnings("serial")
9 | class RedisClusterNodeSnapshot extends RedisClusterNode {
10 |
11 | private Long latencyNs;
12 |
13 | private Integer connectedClients;
14 |
15 | public RedisClusterNodeSnapshot() {
16 | }
17 |
18 | public RedisClusterNodeSnapshot(RedisClusterNode redisClusterNode) {
19 | super(redisClusterNode);
20 | }
21 |
22 | Long getLatencyNs() {
23 | return latencyNs;
24 | }
25 |
26 | void setLatencyNs(Long latencyNs) {
27 | this.latencyNs = latencyNs;
28 | }
29 |
30 | Integer getConnectedClients() {
31 | return connectedClients;
32 | }
33 |
34 | void setConnectedClients(Integer connectedClients) {
35 | this.connectedClients = connectedClients;
36 | }
37 |
38 | }
39 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/tracing/SocketAddressEndpoint.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.tracing;
2 |
3 | import java.net.InetSocketAddress;
4 | import java.net.SocketAddress;
5 |
6 | /**
7 | * {@link Tracing.Endpoint} based on a {@link SocketAddress}.
8 | *
9 | * @author Mark Paluch
10 | * @since 6.3
11 | */
12 | class SocketAddressEndpoint implements Tracing.Endpoint {
13 |
14 | private final SocketAddress socketAddress;
15 |
16 | public SocketAddressEndpoint(SocketAddress socketAddress) {
17 | this.socketAddress = socketAddress;
18 | }
19 |
20 | public SocketAddress getSocketAddress() {
21 | return socketAddress;
22 | }
23 |
24 | @Override
25 | public String toString() {
26 |
27 | if (socketAddress instanceof InetSocketAddress) {
28 | InetSocketAddress inet = (InetSocketAddress) socketAddress;
29 | return inet.getHostString() + ":" + inet.getPort();
30 | }
31 |
32 | return socketAddress.toString();
33 | }
34 |
35 | }
36 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/cluster/api/sync/NodeSelectionCommands.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.cluster.api.sync;
2 |
3 | import io.lettuce.core.cluster.api.NodeSelectionSupport;
4 |
5 | /**
6 | * Synchronous and thread-safe Redis API to execute commands on a {@link NodeSelectionSupport}.
7 | *
8 | * @author Mark Paluch
9 | * @author Tihomir Mateev
10 | */
11 | public interface NodeSelectionCommands extends BaseNodeSelectionCommands, NodeSelectionFunctionCommands,
12 | NodeSelectionGeoCommands, NodeSelectionHashCommands, NodeSelectionHLLCommands,
13 | NodeSelectionKeyCommands, NodeSelectionListCommands, NodeSelectionScriptingCommands,
14 | NodeSelectionServerCommands, NodeSelectionSetCommands, NodeSelectionSortedSetCommands,
15 | NodeSelectionStreamCommands, NodeSelectionStringCommands, NodeSelectionJsonCommands,
16 | NodeSelectionVectorSetCommands, NodeSelectionSearchCommands {
17 | }
18 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/models/role/RedisMasterInstance.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.models.role;
2 |
3 | import java.util.List;
4 |
5 | /**
6 | * Represents a upstream (master) instance.
7 | *
8 | * @author Mark Paluch
9 | * @since 3.0
10 | */
11 | @SuppressWarnings("serial")
12 | public class RedisMasterInstance extends RedisUpstreamInstance {
13 |
14 | public RedisMasterInstance() {
15 | }
16 |
17 | /**
18 | * Constructs a {@link RedisMasterInstance}
19 | *
20 | * @param replicationOffset the replication offset
21 | * @param replicas list of replicas, must not be {@code null} but may be empty
22 | */
23 | public RedisMasterInstance(long replicationOffset, List replicas) {
24 | super(replicationOffset, replicas);
25 | }
26 |
27 | /**
28 | * @return always {@link io.lettuce.core.models.role.RedisInstance.Role#MASTER}
29 | */
30 | @Override
31 | public Role getRole() {
32 | return Role.MASTER;
33 | }
34 |
35 | }
36 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/RedisNoScriptException.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core;
2 |
3 | /**
4 | * Exception that gets thrown when Redis indicates absence of a Lua script referenced by its SHA1 digest with a {@code NOSCRIPT}
5 | * error response.
6 | *
7 | * @author Mark Paluch
8 | * @since 4.5
9 | */
10 | @SuppressWarnings("serial")
11 | public class RedisNoScriptException extends RedisCommandExecutionException {
12 |
13 | /**
14 | * Create a {@code RedisNoScriptException} with the specified detail message.
15 | *
16 | * @param msg the detail message.
17 | */
18 | public RedisNoScriptException(String msg) {
19 | super(msg);
20 | }
21 |
22 | /**
23 | * Create a {@code RedisNoScriptException} with the specified detail message and nested exception.
24 | *
25 | * @param msg the detail message.
26 | * @param cause the nested exception.
27 | */
28 | public RedisNoScriptException(String msg, Throwable cause) {
29 | super(msg, cause);
30 | }
31 |
32 | }
33 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/dynamic/CommandMethodVerifier.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.dynamic;
2 |
3 | import io.lettuce.core.dynamic.segment.CommandSegments;
4 |
5 | /**
6 | * Verifies {@link CommandMethod} declarations by checking available Redis commands.
7 | *
8 | * @author Mark Paluch
9 | * @since 5.0
10 | */
11 | @FunctionalInterface
12 | interface CommandMethodVerifier {
13 |
14 | /**
15 | * Default instance that does not verify commands.
16 | */
17 | CommandMethodVerifier NONE = (commandSegments, commandMethod) -> {
18 | };
19 |
20 | /**
21 | * Verify a {@link CommandMethod} with its {@link CommandSegments}. This method verifies that the command exists and that
22 | * the required number of arguments is declared.
23 | *
24 | * @param commandSegments must not be {@code null}.
25 | * @param commandMethod must not be {@code null}.
26 | */
27 | void validate(CommandSegments commandSegments, CommandMethod commandMethod) throws CommandMethodSyntaxException;
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/protocol/TransactionalCommandUnitTests.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.protocol;
2 |
3 | import static io.lettuce.TestTags.UNIT_TEST;
4 | import static org.assertj.core.api.Assertions.assertThat;
5 |
6 | import org.junit.jupiter.api.Tag;
7 | import org.junit.jupiter.api.Test;
8 |
9 | import io.lettuce.core.RedisException;
10 | import io.lettuce.core.codec.StringCodec;
11 | import io.lettuce.core.output.StatusOutput;
12 |
13 | /**
14 | * @author Mark Paluch
15 | */
16 | @Tag(UNIT_TEST)
17 | class TransactionalCommandUnitTests {
18 |
19 | @Test
20 | void shouldCompleteOnException() {
21 |
22 | RedisCommand inner = new Command<>(CommandType.SET, new StatusOutput<>(StringCodec.UTF8));
23 |
24 | TransactionalCommand command = new TransactionalCommand<>(new AsyncCommand<>(inner));
25 |
26 | command.completeExceptionally(new RedisException("foo"));
27 |
28 | assertThat(command).isCompletedExceptionally();
29 | }
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/dynamic/BatchTasks.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.dynamic;
2 |
3 | import java.util.Collections;
4 | import java.util.Iterator;
5 | import java.util.List;
6 |
7 | import io.lettuce.core.protocol.RedisCommand;
8 |
9 | /**
10 | * Result of a batching request. Contains references to the batched {@link RedisCommand}s.
11 | *
12 | * @author Mark Paluch
13 | * @since 5.0
14 | */
15 | class BatchTasks implements Iterable> {
16 |
17 | public static final BatchTasks EMPTY = new BatchTasks(Collections.emptyList());
18 |
19 | private final List> futures;
20 |
21 | BatchTasks(List> futures) {
22 | this.futures = futures;
23 | }
24 |
25 | @Override
26 | public Iterator> iterator() {
27 | return futures.iterator();
28 | }
29 |
30 | @SuppressWarnings("rawtypes")
31 | public RedisCommand[] toArray() {
32 | return futures.toArray(new RedisCommand[0]);
33 | }
34 |
35 | }
36 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/examples/ReadWriteExample.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.examples;
2 |
3 | import io.lettuce.core.RedisClient;
4 | import io.lettuce.core.RedisURI;
5 | import io.lettuce.core.api.StatefulRedisConnection;
6 | import io.lettuce.core.api.sync.RedisCommands;
7 |
8 | /**
9 | * @author Mark Paluch
10 | */
11 | public class ReadWriteExample {
12 |
13 | public static void main(String[] args) {
14 |
15 | // Syntax: redis://[password@]host[:port][/databaseNumber]
16 | RedisClient redisClient = RedisClient.create(RedisURI.create("redis://password@localhost:6379/0"));
17 |
18 | StatefulRedisConnection connection = redisClient.connect();
19 |
20 | System.out.println("Connected to Redis");
21 |
22 | RedisCommands sync = connection.sync();
23 |
24 | sync.set("foo", "bar");
25 | String value = sync.get("foo");
26 | System.out.println(value);
27 |
28 | connection.close();
29 | redisClient.shutdown();
30 | }
31 |
32 | }
33 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/masterreplica/NodeConnectionFactory.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.masterreplica;
2 |
3 | import java.net.SocketAddress;
4 | import java.util.concurrent.CompletableFuture;
5 |
6 | import io.lettuce.core.RedisURI;
7 | import io.lettuce.core.api.StatefulRedisConnection;
8 | import io.lettuce.core.codec.RedisCodec;
9 |
10 | /**
11 | * Factory interface to obtain {@link StatefulRedisConnection connections} to Redis nodes.
12 | *
13 | * @author Mark Paluch
14 | * @since 4.4
15 | */
16 | interface NodeConnectionFactory {
17 |
18 | /**
19 | * Connects to a {@link SocketAddress} with the given {@link RedisCodec} asynchronously.
20 | *
21 | * @param codec must not be {@code null}.
22 | * @param redisURI must not be {@code null}.
23 | * @param Key type.
24 | * @param Value type.
25 | * @return a new {@link StatefulRedisConnection}
26 | */
27 | CompletableFuture> connectToNodeAsync(RedisCodec codec, RedisURI redisURI);
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/dynamic/intercept/MethodInterceptor.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.dynamic.intercept;
2 |
3 | /**
4 | * Intercepts calls on an interface on its way to the target. These are nested "on top" of the target.
5 | *
6 | *
7 | * Implementing classes are required to implement the {@link #invoke(MethodInvocation)} method to modify the original behavior.
8 | *
9 | * @author Mark Paluch
10 | * @since 5.0
11 | */
12 | public interface MethodInterceptor {
13 |
14 | /**
15 | * Implement this method to perform extra treatments before and after the invocation. Polite implementations would certainly
16 | * like to invoke {@link MethodInvocation#proceed()}.
17 | *
18 | * @param invocation the method invocation
19 | * @return the result of the call to {@link MethodInvocation#proceed()}, might be intercepted by the interceptor.
20 | * @throws Throwable if the interceptors or the target-object throws an exception.
21 | */
22 | Object invoke(MethodInvocation invocation) throws Throwable;
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/masterreplica/JfrSentinelTopologyRefreshEvent.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.masterreplica;
2 |
3 | import static jdk.jfr.Timespan.*;
4 |
5 | import jdk.jfr.Category;
6 | import jdk.jfr.Event;
7 | import jdk.jfr.Label;
8 | import jdk.jfr.StackTrace;
9 | import jdk.jfr.Timespan;
10 |
11 | /**
12 | * Flight recorder event variant of {@link SentinelTopologyRefreshEvent}.
13 | *
14 | * @author Mark Paluch
15 | * @since 6.1
16 | */
17 | @Category({ "Lettuce", "Master/Replica Events" })
18 | @Label("Sentinel Topology Refresh Trigger")
19 | @StackTrace(false)
20 | class JfrSentinelTopologyRefreshEvent extends Event {
21 |
22 | private final String source;
23 |
24 | private final String message;
25 |
26 | @Timespan(value = MILLISECONDS)
27 | private final long delay;
28 |
29 | public JfrSentinelTopologyRefreshEvent(SentinelTopologyRefreshEvent event) {
30 | this.source = event.getSource();
31 | this.message = event.getMessage();
32 | this.delay = event.getDelayMs();
33 | }
34 |
35 | }
36 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/test/MutableClock.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.test;
2 |
3 | import java.time.Clock;
4 | import java.time.Duration;
5 | import java.time.Instant;
6 | import java.time.ZoneId;
7 | import java.util.concurrent.atomic.AtomicReference;
8 |
9 | public class MutableClock extends Clock {
10 |
11 | AtomicReference currentTime = new AtomicReference<>(Instant.now());
12 |
13 | public MutableClock() {
14 | this.currentTime.set(Instant.now());
15 | }
16 |
17 | public MutableClock(Instant startTime) {
18 | this.currentTime.set(startTime);
19 | }
20 |
21 | @Override
22 | public ZoneId getZone() {
23 | return ZoneId.systemDefault();
24 | }
25 |
26 | @Override
27 | public Clock withZone(ZoneId zone) {
28 | return this;
29 | }
30 |
31 | @Override
32 | public Instant instant() {
33 | return currentTime.get();
34 | }
35 |
36 | public void tick(Duration duration) {
37 | currentTime.set(currentTime.get().plus(duration));
38 | }
39 |
40 | };
41 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/output/ValueScanStreamingOutput.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.output;
2 |
3 | import java.nio.ByteBuffer;
4 |
5 | import io.lettuce.core.StreamScanCursor;
6 | import io.lettuce.core.codec.RedisCodec;
7 |
8 | /**
9 | * Streaming API for multiple Values. You can implement this interface in order to receive a call to {@code onValue} on every
10 | * key.
11 | *
12 | * @param Key type.
13 | * @param Value type.
14 | * @author Mark Paluch
15 | */
16 | public class ValueScanStreamingOutput extends ScanOutput {
17 |
18 | private final ValueStreamingChannel channel;
19 |
20 | public ValueScanStreamingOutput(RedisCodec codec, ValueStreamingChannel channel) {
21 | super(codec, new StreamScanCursor());
22 | this.channel = channel;
23 | }
24 |
25 | @Override
26 | protected void setOutput(ByteBuffer bytes) {
27 | channel.onValue(bytes == null ? null : codec.decodeValue(bytes));
28 | output.setCount(output.getCount() + 1);
29 | }
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/RedisCommandTimeoutException.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core;
2 |
3 | /**
4 | * Exception thrown when the command waiting timeout is exceeded.
5 | *
6 | * @author Mark Paluch
7 | */
8 | @SuppressWarnings("serial")
9 | public class RedisCommandTimeoutException extends RedisException {
10 |
11 | /**
12 | * Create a {@code RedisCommandTimeoutException} with a default message.
13 | */
14 | public RedisCommandTimeoutException() {
15 | super("Command timed out");
16 | }
17 |
18 | /**
19 | * Create a {@code RedisCommandTimeoutException} with the specified detail message.
20 | *
21 | * @param msg the detail message.
22 | */
23 | public RedisCommandTimeoutException(String msg) {
24 | super(msg);
25 | }
26 |
27 | /**
28 | * Create a {@code RedisException} with the specified nested exception.
29 | *
30 | * @param cause the nested exception.
31 | */
32 | public RedisCommandTimeoutException(Throwable cause) {
33 | super(cause);
34 | }
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/output/EncodedComplexOutput.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2025, Redis Ltd. and Contributors
3 | * All rights reserved.
4 | *
5 | * Licensed under the MIT License.
6 | */
7 |
8 | package io.lettuce.core.output;
9 |
10 | import io.lettuce.core.codec.RedisCodec;
11 |
12 | import java.nio.ByteBuffer;
13 |
14 | public class EncodedComplexOutput extends ComplexOutput {
15 |
16 | /**
17 | * Constructs a new instance of the {@link ComplexOutput}
18 | *
19 | * @param codec the {@link RedisCodec} to be applied
20 | * @param parser
21 | */
22 | public EncodedComplexOutput(RedisCodec codec, ComplexDataParser parser) {
23 | super(codec, parser);
24 | }
25 |
26 | @Override
27 | public void set(ByteBuffer bytes) {
28 | data.storeObject(bytes == null ? null : bytes.asReadOnlyBuffer());
29 | }
30 |
31 | @Override
32 | public void setSingle(ByteBuffer bytes) {
33 | data.storeObject(bytes == null ? null : bytes.asReadOnlyBuffer());
34 | }
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/event/connection/JfrConnectedEvent.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.event.connection;
2 |
3 | import jdk.jfr.Category;
4 | import jdk.jfr.Event;
5 | import jdk.jfr.Label;
6 | import jdk.jfr.StackTrace;
7 |
8 | /**
9 | * Flight recorder event variant of {@link ConnectedEvent}.
10 | *
11 | * @author Mark Paluch
12 | * @since 6.1
13 | */
14 | @Category({ "Lettuce", "Connection Events" })
15 | @Label("Connected")
16 | @StackTrace(false)
17 | class JfrConnectedEvent extends Event {
18 |
19 | private final String redisUri;
20 |
21 | private final String epId;
22 |
23 | private final String channelId;
24 |
25 | private final String local;
26 |
27 | private final String remote;
28 |
29 | public JfrConnectedEvent(ConnectionEventSupport event) {
30 | this.redisUri = event.getRedisUri();
31 | this.epId = event.getChannelId();
32 | this.channelId = event.getChannelId();
33 | this.local = event.localAddress().toString();
34 | this.remote = event.remoteAddress().toString();
35 | }
36 |
37 | }
38 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/output/KeyScanStreamingOutput.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.output;
2 |
3 | import java.nio.ByteBuffer;
4 |
5 | import io.lettuce.core.StreamScanCursor;
6 | import io.lettuce.core.codec.RedisCodec;
7 |
8 | /**
9 | * Streaming API for multiple Keys. You can implement this interface in order to receive a call to {@code onKey} on every key.
10 | * Key uniqueness is not guaranteed.
11 | *
12 | * @param Key type.
13 | * @param Value type.
14 | * @author Mark Paluch
15 | */
16 | public class KeyScanStreamingOutput extends ScanOutput {
17 |
18 | private final KeyStreamingChannel channel;
19 |
20 | public KeyScanStreamingOutput(RedisCodec codec, KeyStreamingChannel channel) {
21 | super(codec, new StreamScanCursor());
22 | this.channel = channel;
23 | }
24 |
25 | @Override
26 | protected void setOutput(ByteBuffer bytes) {
27 | channel.onKey(bytes == null ? null : codec.decodeKey(bytes));
28 | output.setCount(output.getCount() + 1);
29 | }
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/core/ByteBufferCodec.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core;
2 |
3 | import java.nio.ByteBuffer;
4 |
5 | import io.lettuce.core.codec.RedisCodec;
6 |
7 | /**
8 | * @author Mark Paluch
9 | */
10 | public class ByteBufferCodec implements RedisCodec {
11 |
12 | @Override
13 | public ByteBuffer decodeKey(ByteBuffer bytes) {
14 |
15 | ByteBuffer decoupled = ByteBuffer.allocate(bytes.remaining());
16 | decoupled.put(bytes);
17 | return (ByteBuffer) decoupled.flip();
18 | }
19 |
20 | @Override
21 | public ByteBuffer decodeValue(ByteBuffer bytes) {
22 |
23 | ByteBuffer decoupled = ByteBuffer.allocate(bytes.remaining());
24 | decoupled.put(bytes);
25 | return (ByteBuffer) decoupled.flip();
26 | }
27 |
28 | @Override
29 | public ByteBuffer encodeKey(ByteBuffer key) {
30 | return key.asReadOnlyBuffer();
31 | }
32 |
33 | @Override
34 | public ByteBuffer encodeValue(ByteBuffer value) {
35 | return value.asReadOnlyBuffer();
36 | }
37 |
38 | }
39 |
--------------------------------------------------------------------------------
/src/test/java/io/lettuce/test/KeyValueStreamingAdapter.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.test;
2 |
3 | import java.util.LinkedHashMap;
4 | import java.util.Map;
5 | import java.util.concurrent.locks.ReentrantLock;
6 |
7 | import io.lettuce.core.output.KeyStreamingChannel;
8 | import io.lettuce.core.output.KeyValueStreamingChannel;
9 |
10 | /**
11 | * Adapter for a {@link KeyStreamingChannel}. Stores the output in a map.
12 | *
13 | * @param Key type.
14 | * @param Value type.
15 | * @author Mark Paluch
16 | * @since 3.0
17 | */
18 | public class KeyValueStreamingAdapter implements KeyValueStreamingChannel {
19 |
20 | private final Map map = new LinkedHashMap<>();
21 |
22 | private final ReentrantLock lock = new ReentrantLock();
23 |
24 | @Override
25 | public void onKeyValue(K key, V value) {
26 |
27 | lock.lock();
28 | try {
29 | map.put(key, value);
30 | } finally {
31 | lock.unlock();
32 | }
33 | }
34 |
35 | public Map getMap() {
36 | return map;
37 | }
38 |
39 | }
40 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/event/connection/JfrDisconnectedEvent.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.event.connection;
2 |
3 | import jdk.jfr.Category;
4 | import jdk.jfr.Event;
5 | import jdk.jfr.Label;
6 | import jdk.jfr.StackTrace;
7 |
8 | /**
9 | * Flight recorder event variant of {@link DisconnectedEvent}.
10 | *
11 | * @author Mark Paluch
12 | * @since 6.1
13 | */
14 | @Category({ "Lettuce", "Connection Events" })
15 | @Label("Disconnected")
16 | @StackTrace(false)
17 | class JfrDisconnectedEvent extends Event {
18 |
19 | private final String redisUri;
20 |
21 | private final String epId;
22 |
23 | private final String channelId;
24 |
25 | private final String local;
26 |
27 | private final String remote;
28 |
29 | public JfrDisconnectedEvent(ConnectionEventSupport event) {
30 | this.redisUri = event.getRedisUri();
31 | this.epId = event.getChannelId();
32 | this.channelId = event.getChannelId();
33 | this.local = event.localAddress().toString();
34 | this.remote = event.remoteAddress().toString();
35 | }
36 |
37 | }
38 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/output/SocketAddressOutput.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.output;
2 |
3 | import java.net.InetSocketAddress;
4 | import java.net.SocketAddress;
5 | import java.nio.ByteBuffer;
6 |
7 | import io.lettuce.core.codec.RedisCodec;
8 |
9 | /**
10 | * Output capturing a hostname and port (both string elements) into a {@link SocketAddress}.
11 | *
12 | * @author Mark Paluch
13 | * @since 5.0.1
14 | */
15 | public class SocketAddressOutput extends CommandOutput {
16 |
17 | private String hostname;
18 |
19 | private boolean hasHostname;
20 |
21 | public SocketAddressOutput(RedisCodec codec) {
22 | super(codec, null);
23 | }
24 |
25 | @Override
26 | public void set(ByteBuffer bytes) {
27 |
28 | if (!hasHostname) {
29 | hostname = decodeString(bytes);
30 | hasHostname = true;
31 | return;
32 | }
33 |
34 | int port = Integer.parseInt(decodeString(bytes));
35 | output = InetSocketAddress.createUnresolved(hostname, port);
36 | }
37 |
38 | }
39 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/json/JsonType.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2024, Redis Ltd. and Contributors
3 | * All rights reserved.
4 | *
5 | * Licensed under the MIT License.
6 | */
7 |
8 | package io.lettuce.core.json;
9 |
10 | /**
11 | * JSON types as returned by the JSON.TYPE command
12 | *
13 | * @see io.lettuce.core.api.sync.RedisCommands#jsonType
14 | * @since 6.5
15 | * @author Tihomir Mateev
16 | */
17 | public enum JsonType {
18 |
19 | OBJECT, ARRAY, STRING, INTEGER, NUMBER, BOOLEAN, UNKNOWN;
20 |
21 | public static JsonType fromString(String s) {
22 | switch (s) {
23 | case "object":
24 | return OBJECT;
25 | case "array":
26 | return ARRAY;
27 | case "string":
28 | return STRING;
29 | case "integer":
30 | return INTEGER;
31 | case "number":
32 | return NUMBER;
33 | case "boolean":
34 | return BOOLEAN;
35 | default:
36 | return UNKNOWN;
37 | }
38 | }
39 |
40 | }
41 |
--------------------------------------------------------------------------------
/src/main/java/io/lettuce/core/output/MapScanOutput.java:
--------------------------------------------------------------------------------
1 | package io.lettuce.core.output;
2 |
3 | import java.nio.ByteBuffer;
4 |
5 | import io.lettuce.core.MapScanCursor;
6 | import io.lettuce.core.codec.RedisCodec;
7 |
8 | /**
9 | * {@link io.lettuce.core.MapScanCursor} for scan cursor output.
10 | *
11 | * @param Key type.
12 | * @param Value type.
13 | * @author Mark Paluch
14 | */
15 | public class MapScanOutput