redis
diff --git a/‎.gitignore‎
Lines changed: 2 additions & 1 deletion b/‎.gitignore‎
Lines changed: 2 additions & 1 deletion
diff --git a/‎src/main/java/io/lettuce/core/AbstractRedisClient.java‎
Lines changed: 12 additions & 1 deletion b/‎src/main/java/io/lettuce/core/AbstractRedisClient.java‎
Lines changed: 12 additions & 1 deletion
diff --git a/‎src/main/java/io/lettuce/core/ClientOptions.java‎
Lines changed: 37 additions & 1 deletion b/‎src/main/java/io/lettuce/core/ClientOptions.java‎
Lines changed: 37 additions & 1 deletion
diff --git a/‎src/main/java/io/lettuce/core/ConnectionBuilder.java‎
Lines changed: 17 additions & 3 deletions b/‎src/main/java/io/lettuce/core/ConnectionBuilder.java‎
Lines changed: 17 additions & 3 deletions
diff --git a/‎src/main/java/io/lettuce/core/ConnectionMetadata.java‎
Lines changed: 12 additions & 0 deletions b/‎src/main/java/io/lettuce/core/ConnectionMetadata.java‎
Lines changed: 12 additions & 0 deletions
@@ -16,4 +16,5 @@ dependency-reduced-pom.xml
 .idea
 .flattened-pom.xml
 *.java-version
-*.DS_Store
+*.DS_Store
+.vscode*
@@ -20,6 +20,8 @@
 package io.lettuce.core;
 
 import java.io.Closeable;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.time.Duration;
 import java.util.ArrayList;
@@ -34,6 +36,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import io.lettuce.core.MaintenanceEventsOptions.AddressTypeSource;
 import reactor.core.publisher.Mono;
 import io.lettuce.core.event.command.CommandListener;
 import io.lettuce.core.event.connection.ConnectEvent;
@@ -586,8 +589,16 @@ private CompletableFuture<Void> closeClientResources(long quietPeriod, long time
     }
 
     protected RedisHandshake createHandshake(ConnectionState state) {
+        AddressTypeSource source = null;
+        if (clientOptions.getMaintenanceEventsOptions().supportsMaintenanceEvents()) {
+            LettuceAssert.notNull(clientOptions.getMaintenanceEventsOptions().getAddressTypeSource(),
+                    "Address type source must not be null");
+
+            source = clientOptions.getMaintenanceEventsOptions().getAddressTypeSource();
+        }
+
         return new RedisHandshake(clientOptions.getConfiguredProtocolVersion(), clientOptions.isPingBeforeActivateConnection(),
-                state);
+                state, source);
     }
 
 }
@@ -51,6 +51,8 @@ public class ClientOptions implements Serializable {
 
     public static final boolean DEFAULT_AUTO_RECONNECT = true;
 
+    public static final MaintenanceEventsOptions DEFAULT_MAINTENANCE_EVENTS_OPTIONS = MaintenanceEventsOptions.enabled();
+
     public static final Predicate<RedisCommand<?, ?, ?>> DEFAULT_REPLAY_FILTER = (cmd) -> false;
 
     public static final int DEFAULT_BUFFER_USAGE_RATIO = 3;
@@ -93,6 +95,8 @@ public class ClientOptions implements Serializable {
 
     private final boolean autoReconnect;
 
+    private final MaintenanceEventsOptions maintenanceEventsOptions;
+
     private final Predicate<RedisCommand<?, ?, ?>> replayFilter;
 
     private final DecodeBufferPolicy decodeBufferPolicy;
@@ -127,6 +131,7 @@ public class ClientOptions implements Serializable {
 
     protected ClientOptions(Builder builder) {
         this.autoReconnect = builder.autoReconnect;
+        this.maintenanceEventsOptions = builder.maintenanceEventsOptions;
         this.replayFilter = builder.replayFilter;
         this.decodeBufferPolicy = builder.decodeBufferPolicy;
         this.disconnectedBehavior = builder.disconnectedBehavior;
@@ -147,6 +152,7 @@ protected ClientOptions(Builder builder) {
 
     protected ClientOptions(ClientOptions original) {
         this.autoReconnect = original.isAutoReconnect();
+        this.maintenanceEventsOptions = original.getMaintenanceEventsOptions();
         this.replayFilter = original.getReplayFilter();
         this.decodeBufferPolicy = original.getDecodeBufferPolicy();
         this.disconnectedBehavior = original.getDisconnectedBehavior();
@@ -200,6 +206,8 @@ public static class Builder {
 
         private boolean autoReconnect = DEFAULT_AUTO_RECONNECT;
 
+        private MaintenanceEventsOptions maintenanceEventsOptions = DEFAULT_MAINTENANCE_EVENTS_OPTIONS;
+
         private Predicate<RedisCommand<?, ?, ?>> replayFilter = DEFAULT_REPLAY_FILTER;
 
         private DecodeBufferPolicy decodeBufferPolicy = DecodeBufferPolicies.ratio(DEFAULT_BUFFER_USAGE_RATIO);
@@ -247,6 +255,21 @@ public Builder autoReconnect(boolean autoReconnect) {
             return this;
         }
 
+        /**
+         * Configure whether the driver should listen for server events that notify on current maintenance activities. When
+         * enabled, this option will help with the connection handover and reduce the number of failed commands. This feature
+         * requires the server to support maintenance events. Defaults to {@code false}. See
+         * {@link #DEFAULT_MAINTENANCE_EVENTS_OPTIONS}.
+         *
+         * @param maintenanceEventsOptions true/false
+         * @return {@code this}
+         * @since 7.0
+         */
+        public Builder supportMaintenanceEvents(MaintenanceEventsOptions maintenanceEventsOptions) {
+            this.maintenanceEventsOptions = maintenanceEventsOptions;
+            return this;
+        }
+
         /**
          * When {@link #autoReconnect(boolean)} is set to true, this {@link Predicate} is used to filter commands to replay when
          * the connection is reestablished after a disconnect. Returning <code>false</code> means the command will not be
@@ -507,7 +530,8 @@ public ClientOptions build() {
     public ClientOptions.Builder mutate() {
         Builder builder = new Builder();
 
-        builder.autoReconnect(isAutoReconnect()).replayFilter(getReplayFilter()).decodeBufferPolicy(getDecodeBufferPolicy())
+        builder.autoReconnect(isAutoReconnect()).supportMaintenanceEvents(getMaintenanceEventsOptions())
+                .replayFilter(getReplayFilter()).decodeBufferPolicy(getDecodeBufferPolicy())
                 .disconnectedBehavior(getDisconnectedBehavior()).reauthenticateBehavior(getReauthenticateBehaviour())
                 .readOnlyCommands(getReadOnlyCommands()).publishOnScheduler(isPublishOnScheduler())
                 .pingBeforeActivateConnection(isPingBeforeActivateConnection()).protocolVersion(getConfiguredProtocolVersion())
@@ -531,6 +555,18 @@ public boolean isAutoReconnect() {
         return autoReconnect;
     }
 
+    /**
+     * Returns the {@link MaintenanceEventsOptions} to listen for server events that notify on current maintenance activities.
+     *
+     * @return {@link MaintenanceEventsOptions}
+     * @since 7.0
+     * @see #DEFAULT_MAINTENANCE_EVENTS_OPTIONS
+     * @see #getMaintenanceEventsOptions()
+     */
+    public MaintenanceEventsOptions getMaintenanceEventsOptions() {
+        return maintenanceEventsOptions;
+    }
+
     /**
      * Controls which {@link RedisCommand} will be replayed after a re-connect. The {@link Predicate} returns <code>true</code>
      * if command should be filtered out and not replayed. Defaults to {@link #DEFAULT_REPLAY_FILTER}.
 
@@ -27,6 +27,8 @@
 import java.util.function.Function;
 import java.util.function.Supplier;
 
+import io.lettuce.core.protocol.MaintenanceAwareComponent;
+import io.lettuce.core.protocol.MaintenanceAwareConnectionWatchdog;
 import jdk.net.ExtendedSocketOptions;
 import reactor.core.publisher.Mono;
 import io.lettuce.core.internal.LettuceAssert;
@@ -153,9 +155,21 @@ protected ConnectionWatchdog createConnectionWatchdog() {
         LettuceAssert.assertState(bootstrap != null, "Bootstrap must be set for autoReconnect=true");
         LettuceAssert.assertState(socketAddressSupplier != null, "SocketAddressSupplier must be set for autoReconnect=true");
 
-        ConnectionWatchdog watchdog = new ConnectionWatchdog(clientResources.reconnectDelay(), clientOptions, bootstrap,
-                clientResources.timer(), clientResources.eventExecutorGroup(), socketAddressSupplier, reconnectionListener,
-                connection, clientResources.eventBus(), endpoint);
+        ConnectionWatchdog watchdog;
+        if (clientOptions.getMaintenanceEventsOptions().supportsMaintenanceEvents()) {
+            MaintenanceAwareConnectionWatchdog maintenanceAwareWatchdog = new MaintenanceAwareConnectionWatchdog(
+                    clientResources.reconnectDelay(), clientOptions, bootstrap, clientResources.timer(),
+                    clientResources.eventExecutorGroup(), socketAddressSupplier, reconnectionListener, connection,
+                    clientResources.eventBus(), endpoint);
+            if (connection.getChannelWriter() instanceof MaintenanceAwareComponent) {
+                maintenanceAwareWatchdog.setMaintenanceEventListener((MaintenanceAwareComponent) connection.getChannelWriter());
+            }
+            watchdog = maintenanceAwareWatchdog;
+        } else {
+            watchdog = new ConnectionWatchdog(clientResources.reconnectDelay(), clientOptions, bootstrap,
+                    clientResources.timer(), clientResources.eventExecutorGroup(), socketAddressSupplier, reconnectionListener,
+                    connection, clientResources.eventBus(), endpoint);
+        }
 
         endpoint.registerConnectionWatchdog(watchdog);
 
 
@@ -11,6 +11,8 @@ class ConnectionMetadata {
 
     private volatile String libraryVersion;
 
+    private volatile boolean sslEnabled;
+
     public ConnectionMetadata() {
     }
 
@@ -23,13 +25,15 @@ public void apply(RedisURI redisURI) {
         setClientName(redisURI.getClientName());
         setLibraryName(redisURI.getLibraryName());
         setLibraryVersion(redisURI.getLibraryVersion());
+        setSslEnabled(redisURI.isSsl());
     }
 
     public void apply(ConnectionMetadata metadata) {
 
         setClientName(metadata.getClientName());
         setLibraryName(metadata.getLibraryName());
         setLibraryVersion(metadata.getLibraryVersion());
+        setSslEnabled(metadata.isSslEnabled());
     }
 
     protected void setClientName(String clientName) {
@@ -56,4 +60,12 @@ String getLibraryVersion() {
         return libraryVersion;
     }
 
+    boolean isSslEnabled() {
+        return sslEnabled;
+    }
+
+    void setSslEnabled(boolean sslEnabled) {
+        this.sslEnabled = sslEnabled;
+    }
+
 }
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,8 @@ class ConnectionMetadata {`
`11`	`11`
`12`	`12`	`private volatile String libraryVersion;`
`13`	`13`
	`14`	`+ private volatile boolean sslEnabled;`
	`15`	`+`
`14`	`16`	`public ConnectionMetadata() {`
`15`	`17`	`}`
`16`	`18`
`@@ -23,13 +25,15 @@ public void apply(RedisURI redisURI) {`
`23`	`25`	`setClientName(redisURI.getClientName());`
`24`	`26`	`setLibraryName(redisURI.getLibraryName());`
`25`	`27`	`setLibraryVersion(redisURI.getLibraryVersion());`
	`28`	`+ setSslEnabled(redisURI.isSsl());`
`26`	`29`	`}`
`27`	`30`
`28`	`31`	`public void apply(ConnectionMetadata metadata) {`
`29`	`32`
`30`	`33`	`setClientName(metadata.getClientName());`
`31`	`34`	`setLibraryName(metadata.getLibraryName());`
`32`	`35`	`setLibraryVersion(metadata.getLibraryVersion());`
	`36`	`+ setSslEnabled(metadata.isSslEnabled());`
`33`	`37`	`}`
`34`	`38`
`35`	`39`	`protected void setClientName(String clientName) {`
`@@ -56,4 +60,12 @@ String getLibraryVersion() {`
`56`	`60`	`return libraryVersion;`
`57`	`61`	`}`
`58`	`62`
	`63`	`+ boolean isSslEnabled() {`
	`64`	`+ return sslEnabled;`
	`65`	`+ }`
	`66`	`+`
	`67`	`+ void setSslEnabled(boolean sslEnabled) {`
	`68`	`+ this.sslEnabled = sslEnabled;`
	`69`	`+ }`
	`70`	`+`
`59`	`71`	`}`