feat(tfo): add preview support for TFO

This update adds preview support for TCP Fast Open.

When TFO is enabled the driver either sends Bolt Handshake (for non-encrypted connections) or TLS handshake (for encrypted connections).

The TCP Fast Open is only supported when all of the following is true:
- The system the driver is running on supports and has TCP Fast Open enabled.
- One of the following connection URI schemes is used:
  - neo4j
  - neo4j+s
  - neo4j+ssc
  - bolt
  - bolt+s
  - bolt+ssc
- One of the following Netty Native Transports that is compatible with the system the driver is running on is added to the runtime by the user:
 - netty-transport-native-io_uring (Netty 4.2+ only)
 - netty-transport-native-epoll
 - netty-transport-native-kqueue

Even when all of the above is true, it is important to make sure that the endpoint the driver connects to also supports and has TCP Fast Open enabled.

At present, this is an opt-in `Config` option available via `ConfigBuilder#withTcpFastOpenEnabled(boolean)`. It is `false` by default.

Author: injectives

driver/src/main/java/org/neo4j/driver/Config.java

@@ -156,11 +156,20 @@ public final class Config implements Serializable {
     private final boolean telemetryDisabled;
     /**
      * The {@link ObservationProvider} if configured.
+     *
      * @since 6.0.0
      */
     @Preview(name = "Observability")
     private final transient ObservationProvider observationProvider;
 
+    /**
+     * Defines whether the driver should try using TCP Fast Open if the runtime supports it. This option is ignored
+     * when the conditions described in {@link ConfigBuilder#withTcpFastOpenEnabled(boolean)} are not met.
+     * @since 6.0.0
+     */
+    @Preview(name = "TFO")
+    private final boolean tcpFastOpenEnabled;
+
     private Config(ConfigBuilder builder) {
         this.logging = builder.logging;
         this.logLeakedSessions = builder.logLeakedSessions;
@@ -183,6 +192,7 @@ private Config(ConfigBuilder builder) {
         this.eventLoopThreads = builder.eventLoopThreads;
         this.telemetryDisabled = builder.telemetryDisabled;
         this.observationProvider = builder.observationProvider;
+        this.tcpFastOpenEnabled = builder.tcpFastOpenEnabled;
     }
 
     /**
@@ -403,6 +413,20 @@ public Optional<ObservationProvider> observationProvider() {
         return Optional.ofNullable(observationProvider);
     }
 
+    /**
+     * Returns whether the driver should try using TCP Fast Open if the runtime supports it. This option is ignored
+     * when the conditions described in {@link ConfigBuilder#withTcpFastOpenEnabled(boolean)} are not met.
+     * <p>
+     * The default is {@literal false}.
+     *
+     * @return {@literal true} to enable and {@literal false} to disable
+     * @since 6.0.0
+     */
+    @Preview(name = "TFO")
+    public boolean isTcpFastOpenEnabled() {
+        return tcpFastOpenEnabled;
+    }
+
     /**
      * Used to build new config instances
      */
@@ -425,6 +449,7 @@ public static final class ConfigBuilder {
         private long fetchSize = 1000;
         private int eventLoopThreads = 0;
         private ObservationProvider observationProvider;
+        private boolean tcpFastOpenEnabled;
 
         @SuppressWarnings("deprecation")
         private NotificationConfig notificationConfig = NotificationConfig.defaultConfig();
@@ -874,6 +899,47 @@ public ConfigBuilder withTelemetryDisabled(boolean telemetryDisabled) {
             return this;
         }
 
+        /**
+         * Sets whether the driver should try using TCP Fast Open if the runtime supports it. This option is ignored
+         * when the conditions described below are not met.
+         * <p>
+         * The default is {@literal false}.
+         * <p>
+         * The TCP Fast Open is only supported when all of the following is true:
+         * <ul>
+         *     <li>The system the driver is running on supports and has TCP Fast Open enabled.</li>
+         *     <li>One of the following connection URI schemes is used:
+         *     <ul>
+         *           <li>neo4j</li>
+         *           <li>neo4j+s</li>
+         *           <li>neo4j+ssc</li>
+         *           <li>bolt</li>
+         *           <li>bolt+s</li>
+         *           <li>bolt+ssc</li>
+         *     </ul>
+         *     </li>
+         *     <li>One of the following Netty Native Transports that is compatible with the system the driver is running on
+         *     is added to the runtime by the user:
+         *     <ul>
+         *         <li>netty-transport-native-io_uring (Netty 4.2+ only)</li>
+         *         <li>netty-transport-native-epoll</li>
+         *         <li>netty-transport-native-kqueue</li>
+         *     </ul>
+         *     </li>
+         * </ul>
+         * <p>
+         * Even when all of the above is true, it is important to make sure that the endpoint the driver connects to also
+         * supports and has TCP Fast Open enabled.
+         * @param enabled {@literal true} to enable and {@literal false} to disable
+         * @return this builder
+         * @since 6.0.0
+         */
+        @Preview(name = "TFO")
+        public ConfigBuilder withTcpFastOpenEnabled(boolean enabled) {
+            this.tcpFastOpenEnabled = enabled;
+            return this;
+        }
+
         /**
          * Create a config instance from this builder.
          *

driver/src/main/java/org/neo4j/driver/internal/DriverFactory.java

@@ -361,7 +361,7 @@ private BoltConnectionSourceFactory createPooledBoltConnectionSource(
                     eventLoopGroup,
                     clock,
                     loggingProvider,
-                    config.eventLoopThreads(),
+                    config,
                     observationProvider,
                     boltConnectionProviderFactory);
             var listeningBoltConnectionProvider = BoltConnectionListener.listeningBoltConnectionProvider(
@@ -401,20 +401,21 @@ private BoltConnectionProvider createBoltConnectionProvider(
             ScheduledExecutorService eventLoopGroup,
             Clock clock,
             LoggingProvider loggingProvider,
-            int eventLoopThreads,
+            Config config,
             BoltObservationProvider observationProvider,
             BoltConnectionProviderFactory boltConnectionProviderFactory) {
         var additionalConfig = new HashMap<String, Object>();
         additionalConfig.put("clock", clock);
         if (eventLoopGroup != null) {
             additionalConfig.put("eventLoopGroup", eventLoopGroup);
-        } else if (eventLoopThreads > 0) {
-            additionalConfig.put("eventLoopThreads", eventLoopThreads);
+        } else if (config.eventLoopThreads() > 0) {
+            additionalConfig.put("eventLoopThreads", config.eventLoopThreads());
         }
         var localAddress = localAddress();
         if (localAddress != null) {
             additionalConfig.put("localAddress", localAddress);
         }
+        additionalConfig.put("enableFastOpen", config.isTcpFastOpenEnabled());
         return boltConnectionProviderFactory.create(
                 loggingProvider, BoltValueFactory.getInstance(), observationProvider, additionalConfig);
     }