+ * This is used by the expiration-based implementation of the {@link AuthTokenManager} supplied by the
+ * {@link AuthTokenManagers}.
+ *
+ * @param utcExpirationTimestamp the UTC expiration timestamp
+ * @return a new instance of a type holding both the token and its UTC expiration timestamp
+ * @since 5.8
+ * @see AuthTokenManagers#expirationBased(Supplier)
+ * @see AuthTokenManagers#expirationBasedAsync(Supplier)
+ */
+ default AuthTokenAndExpiration expiringAt(long utcExpirationTimestamp) {
+ return new InternalAuthTokenAndExpiration(this, utcExpirationTimestamp);
+ }
+}
diff --git a/driver/src/main/java/org/neo4j/driver/AuthTokenAndExpiration.java b/driver/src/main/java/org/neo4j/driver/AuthTokenAndExpiration.java
new file mode 100644
index 0000000000..ca1f8c6681
--- /dev/null
+++ b/driver/src/main/java/org/neo4j/driver/AuthTokenAndExpiration.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver;
+
+import java.util.function.Supplier;
+import org.neo4j.driver.internal.security.InternalAuthTokenAndExpiration;
+
+/**
+ * A container used by the expiration based {@link AuthTokenManager} implementation provided by the driver, it contains an
+ * {@link AuthToken} and its UTC expiration timestamp.
+ *
+ * This is used by the expiration-based implementation of the {@link AuthTokenManager} supplied by the
+ * {@link AuthTokenManagers}.
+ *
+ * @since 5.8
+ * @see AuthTokenManagers#expirationBased(Supplier)
+ * @see AuthTokenManagers#expirationBasedAsync(Supplier)
+ */
+public sealed interface AuthTokenAndExpiration permits InternalAuthTokenAndExpiration {
+ /**
+ * Returns the {@link AuthToken}.
+ *
+ * @return the token
+ */
+ AuthToken authToken();
+
+ /**
+ * Returns the token's UTC expiration timestamp.
+ *
+ * @return the token's UTC expiration timestamp
+ */
+ long expirationTimestamp();
+}
diff --git a/driver/src/main/java/org/neo4j/driver/AuthTokenManager.java b/driver/src/main/java/org/neo4j/driver/AuthTokenManager.java
new file mode 100644
index 0000000000..c43ea8c754
--- /dev/null
+++ b/driver/src/main/java/org/neo4j/driver/AuthTokenManager.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver;
+
+import java.util.concurrent.CompletionStage;
+
+/**
+ * A manager of {@link AuthToken} instances used by the driver.
+ *
+ * The manager must manage tokens for the same identity. Therefore, it is not intended for a change of identity.
+ *
+ * Implementations should supply the same token unless it needs to be updated since a change of token might result in
+ * extra processing by the driver.
+ *
+ * Driver initializes new connections with a token supplied by the manager. If token changes, driver action depends on
+ * connection's Bolt protocol version:
+ *
+ *
Bolt 5.1 or above - {@code LOGOFF} and {@code LOGON} messages are dispatched to update the token on next interaction
+ *
Bolt 5.0 or below - connection is closed an a new one is initialized with the new token
+ *
+ *
+ * All implementations of this interface must be thread-safe and non-blocking for caller threads. For instance, IO operations must not
+ * be done on the calling thread.
+ * @since 5.8
+ */
+public interface AuthTokenManager {
+ /**
+ * Returns a {@link CompletionStage} for a valid {@link AuthToken}.
+ *
+ * Driver invokes this method often to check if token has changed.
+ *
+ * Failures will surface via the driver API, like {@link Session#beginTransaction()} method and others.
+ * @return a stage for a valid token, must not be {@code null} or complete with {@code null}
+ * @see org.neo4j.driver.exceptions.AuthTokenManagerExecutionException
+ */
+ CompletionStage getToken();
+
+ /**
+ * Handles an error notification emitted by the server if the token is expired.
+ *
+ * This will be called when driver emits the {@link org.neo4j.driver.exceptions.TokenExpiredRetryableException}.
+ *
+ * @param authToken the expired token
+ */
+ void onExpired(AuthToken authToken);
+}
diff --git a/driver/src/main/java/org/neo4j/driver/AuthTokenManagers.java b/driver/src/main/java/org/neo4j/driver/AuthTokenManagers.java
new file mode 100644
index 0000000000..ad99a66300
--- /dev/null
+++ b/driver/src/main/java/org/neo4j/driver/AuthTokenManagers.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver;
+
+import java.time.Clock;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ForkJoinPool;
+import java.util.function.Supplier;
+import org.neo4j.driver.internal.security.ExpirationBasedAuthTokenManager;
+
+/**
+ * Implementations of {@link AuthTokenManager}.
+ *
+ * @since 5.8
+ */
+public final class AuthTokenManagers {
+ private AuthTokenManagers() {}
+
+ /**
+ * Returns an {@link AuthTokenManager} that manages {@link AuthToken} instances with UTC expiration timestamp.
+ *
+ * The implementation will only use the token supplier when it needs a new token instance. This includes the
+ * following conditions:
+ *
+ *
token's UTC timestamp is expired
+ *
server rejects the current token (see {@link AuthTokenManager#onExpired(AuthToken)})
+ *
+ *
+ * The supplier will be called by a task running in the {@link ForkJoinPool#commonPool()} as documented in the
+ * {@link CompletableFuture#supplyAsync(Supplier)}.
+ *
+ * @param newTokenSupplier a new token supplier
+ * @return a new token manager
+ */
+ public static AuthTokenManager expirationBased(Supplier newTokenSupplier) {
+ return expirationBasedAsync(() -> CompletableFuture.supplyAsync(newTokenSupplier));
+ }
+
+ /**
+ * Returns an {@link AuthTokenManager} that manages {@link AuthToken} instances with UTC expiration timestamp.
+ *
+ * The implementation will only use the token supplier when it needs a new token instance. This includes the
+ * following conditions:
+ *
+ *
token's UTC timestamp is expired
+ *
server rejects the current token (see {@link AuthTokenManager#onExpired(AuthToken)})
+ *
+ *
+ * The provided supplier and its completion stages must be non-blocking as documented in the {@link AuthTokenManager}.
+ *
+ * @param newTokenStageSupplier a new token stage supplier
+ * @return a new token manager
+ */
+ public static AuthTokenManager expirationBasedAsync(
+ Supplier> newTokenStageSupplier) {
+ return new ExpirationBasedAuthTokenManager(newTokenStageSupplier, Clock.systemUTC());
+ }
+}
diff --git a/driver/src/main/java/org/neo4j/driver/Driver.java b/driver/src/main/java/org/neo4j/driver/Driver.java
index d0fd2bc7e6..16680e2f35 100644
--- a/driver/src/main/java/org/neo4j/driver/Driver.java
+++ b/driver/src/main/java/org/neo4j/driver/Driver.java
@@ -142,6 +142,42 @@ default T session(Class sessionClass) {
return session(sessionClass, SessionConfig.defaultConfig());
}
+ /**
+ * Instantiate a new session of a supported type with the supplied {@link AuthToken}.
+ *
+ * This method allows creating a session with a different {@link AuthToken} to the one used on the driver level.
+ * The minimum Bolt protocol version is 5.1. An {@link IllegalStateException} will be emitted on session interaction
+ * for previous Bolt versions.
+ *
+ *
+ * @param sessionClass session type class, must not be null
+ * @param sessionAuthToken a token, null will result in driver-level configuration being used
+ * @return session instance
+ * @param session type
+ * @throws IllegalArgumentException for unsupported session types
+ * @since 5.8
+ */
+ default T session(Class sessionClass, AuthToken sessionAuthToken) {
+ return session(sessionClass, SessionConfig.defaultConfig(), sessionAuthToken);
+ }
+
/**
* Create a new session of supported type with a specified {@link SessionConfig session configuration}.
*
@@ -170,7 +206,45 @@ default T session(Class sessionClass) {
* @throws IllegalArgumentException for unsupported session types
* @since 5.2
*/
- T session(Class sessionClass, SessionConfig sessionConfig);
+ default T session(Class sessionClass, SessionConfig sessionConfig) {
+ return session(sessionClass, sessionConfig, null);
+ }
+
+ /**
+ * Instantiate a new session of a supported type with the supplied {@link SessionConfig session configuration} and
+ * {@link AuthToken}.
+ *
+ * This method allows creating a session with a different {@link AuthToken} to the one used on the driver level.
+ * The minimum Bolt protocol version is 5.1. An {@link IllegalStateException} will be emitted on session interaction
+ * for previous Bolt versions.
+ *
+ *
+ * @param sessionClass session type class, must not be null
+ * @param sessionConfig session config, must not be null
+ * @param sessionAuthToken a token, null will result in driver-level configuration being used
+ * @return session instance
+ * @param session type
+ * @throws IllegalArgumentException for unsupported session types
+ * @since 5.8
+ */
+ T session(Class sessionClass, SessionConfig sessionConfig, AuthToken sessionAuthToken);
/**
* Create a new general purpose {@link RxSession} with default {@link SessionConfig session configuration}. The {@link RxSession} provides a reactive way to
@@ -323,6 +397,24 @@ default AsyncSession asyncSession(SessionConfig sessionConfig) {
*/
CompletionStage verifyConnectivityAsync();
+ /**
+ * Verifies if the given {@link AuthToken} is valid.
+ *
+ * This check works on Bolt 5.1 version or above only.
+ * @param authToken the token
+ * @return the verification outcome
+ * @since 5.8
+ */
+ boolean verifyAuthentication(AuthToken authToken);
+
+ /**
+ * Checks if session auth is supported.
+ * @return the check outcome
+ * @since 5.8
+ * @see Driver#session(Class, SessionConfig, AuthToken)
+ */
+ boolean supportsSessionAuth();
+
/**
* Returns true if the server or cluster the driver connects to supports multi-databases, otherwise false.
*
diff --git a/driver/src/main/java/org/neo4j/driver/GraphDatabase.java b/driver/src/main/java/org/neo4j/driver/GraphDatabase.java
index 3c564c0c59..a936336acb 100644
--- a/driver/src/main/java/org/neo4j/driver/GraphDatabase.java
+++ b/driver/src/main/java/org/neo4j/driver/GraphDatabase.java
@@ -18,8 +18,12 @@
*/
package org.neo4j.driver;
+import static java.util.Objects.requireNonNull;
+
import java.net.URI;
import org.neo4j.driver.internal.DriverFactory;
+import org.neo4j.driver.internal.security.StaticAuthTokenManager;
+import org.neo4j.driver.internal.security.ValidatingAuthTokenManager;
/**
* Creates {@link Driver drivers}, optionally letting you {@link #driver(URI, Config)} to configure them.
@@ -114,12 +118,79 @@ public static Driver driver(String uri, AuthToken authToken, Config config) {
* @return a new driver to the database instance specified by the URL
*/
public static Driver driver(URI uri, AuthToken authToken, Config config) {
+ if (authToken == null) {
+ authToken = AuthTokens.none();
+ }
return driver(uri, authToken, config, new DriverFactory());
}
- static Driver driver(URI uri, AuthToken authToken, Config config, DriverFactory driverFactory) {
+ /**
+ * Returns a driver for a Neo4j instance with the default configuration settings and the provided
+ * {@link AuthTokenManager}.
+ *
+ * @param uri the URL to a Neo4j instance
+ * @param authTokenManager manager to use
+ * @return a new driver to the database instance specified by the URL
+ * @since 5.8
+ * @see AuthTokenManager
+ */
+ public static Driver driver(URI uri, AuthTokenManager authTokenManager) {
+ return driver(uri, authTokenManager, Config.defaultConfig());
+ }
+
+ /**
+ * Returns a driver for a Neo4j instance with the default configuration settings and the provided
+ * {@link AuthTokenManager}.
+ *
+ * @param uri the URL to a Neo4j instance
+ * @param authTokenManager manager to use
+ * @return a new driver to the database instance specified by the URL
+ * @since 5.8
+ * @see AuthTokenManager
+ */
+ public static Driver driver(String uri, AuthTokenManager authTokenManager) {
+ return driver(URI.create(uri), authTokenManager);
+ }
+
+ /**
+ * Returns a driver for a Neo4j instance with the provided {@link AuthTokenManager} and custom configuration.
+ *
+ * @param uri the URL to a Neo4j instance
+ * @param authTokenManager manager to use
+ * @param config user defined configuration
+ * @return a new driver to the database instance specified by the URL
+ * @since 5.8
+ * @see AuthTokenManager
+ */
+ public static Driver driver(URI uri, AuthTokenManager authTokenManager, Config config) {
+ return driver(uri, authTokenManager, config, new DriverFactory());
+ }
+
+ /**
+ * Returns a driver for a Neo4j instance with the provided {@link AuthTokenManager} and custom configuration.
+ *
+ * @param uri the URL to a Neo4j instance
+ * @param authTokenManager manager to use
+ * @param config user defined configuration
+ * @return a new driver to the database instance specified by the URL
+ * @since 5.8
+ * @see AuthTokenManager
+ */
+ public static Driver driver(String uri, AuthTokenManager authTokenManager, Config config) {
+ return driver(URI.create(uri), authTokenManager, config);
+ }
+
+ private static Driver driver(URI uri, AuthToken authToken, Config config, DriverFactory driverFactory) {
+ config = getOrDefault(config);
+ return driverFactory.newInstance(uri, new StaticAuthTokenManager(authToken), config);
+ }
+
+ private static Driver driver(
+ URI uri, AuthTokenManager authTokenManager, Config config, DriverFactory driverFactory) {
+ requireNonNull(authTokenManager, "authTokenManager must not be null");
config = getOrDefault(config);
- return driverFactory.newInstance(uri, authToken, config);
+ return driverFactory.newInstance(
+ uri, new ValidatingAuthTokenManager(authTokenManager, config.logging()), config);
}
private static Config getOrDefault(Config config) {
diff --git a/driver/src/main/java/org/neo4j/driver/exceptions/AuthTokenManagerExecutionException.java b/driver/src/main/java/org/neo4j/driver/exceptions/AuthTokenManagerExecutionException.java
new file mode 100644
index 0000000000..b2ca018c6a
--- /dev/null
+++ b/driver/src/main/java/org/neo4j/driver/exceptions/AuthTokenManagerExecutionException.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.exceptions;
+
+import java.io.Serial;
+import org.neo4j.driver.AuthTokenManager;
+
+/**
+ * The {@link org.neo4j.driver.AuthTokenManager} execution has lead to an unexpected result.
+ *
+ * Possible causes include:
+ *
+ *
{@link AuthTokenManager#getToken()} returned {@code null}
+ *
{@link AuthTokenManager#getToken()} returned a {@link java.util.concurrent.CompletionStage} that completed with {@code null}
+ *
{@link AuthTokenManager#getToken()} returned a {@link java.util.concurrent.CompletionStage} that completed with a token that was not creeated using {@link org.neo4j.driver.AuthTokens}
+ *
{@link AuthTokenManager#getToken()} has thrown an exception
+ *
{@link AuthTokenManager#getToken()} returned a {@link java.util.concurrent.CompletionStage} that completed exceptionally
+ *
+ * @since 5.8
+ */
+public class AuthTokenManagerExecutionException extends ClientException {
+ @Serial
+ private static final long serialVersionUID = -5964665406806723214L;
+
+ /**
+ * Constructs a new instance.
+ * @param message the message
+ * @param cause the cause
+ */
+ public AuthTokenManagerExecutionException(String message, Throwable cause) {
+ super(message, cause);
+ }
+}
diff --git a/driver/src/main/java/org/neo4j/driver/exceptions/DiscoveryException.java b/driver/src/main/java/org/neo4j/driver/exceptions/DiscoveryException.java
index 4cc8db5ed7..8830e35057 100644
--- a/driver/src/main/java/org/neo4j/driver/exceptions/DiscoveryException.java
+++ b/driver/src/main/java/org/neo4j/driver/exceptions/DiscoveryException.java
@@ -25,7 +25,7 @@
* While this error is not fatal and we might be able to recover if we continue trying on another server.
* If we fail to get a valid routing table from all routing servers known to this driver,
* then we will end up with a fatal error {@link ServiceUnavailableException}.
- *
+ *
* If you see this error in your logs, it is safe to ignore if your cluster is temporarily changing structure during that time.
*/
public class DiscoveryException extends Neo4jException {
diff --git a/driver/src/main/java/org/neo4j/driver/exceptions/TokenExpiredRetryableException.java b/driver/src/main/java/org/neo4j/driver/exceptions/TokenExpiredRetryableException.java
new file mode 100644
index 0000000000..8006265b06
--- /dev/null
+++ b/driver/src/main/java/org/neo4j/driver/exceptions/TokenExpiredRetryableException.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.exceptions;
+
+import java.io.Serial;
+import org.neo4j.driver.AuthTokenManager;
+
+/**
+ * The token provided by the {@link AuthTokenManager} has expired.
+ *
+ * This is a retryable variant of {@link TokenExpiredException} used when the driver has an explicit
+ * {@link AuthTokenManager} that might supply a new token following this failure.
+ *
+ * Error code: Neo.ClientError.Security.TokenExpired
+ * @since 5.8
+ * @see TokenExpiredException
+ * @see AuthTokenManager
+ * @see org.neo4j.driver.GraphDatabase#driver(String, AuthTokenManager)
+ */
+public class TokenExpiredRetryableException extends TokenExpiredException implements RetryableException {
+ @Serial
+ private static final long serialVersionUID = -6672756500436910942L;
+
+ /**
+ * Constructs a new instance.
+ * @param code the code
+ * @param message the message
+ */
+ public TokenExpiredRetryableException(String code, String message) {
+ super(code, message);
+ }
+}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/ConnectionSettings.java b/driver/src/main/java/org/neo4j/driver/internal/ConnectionSettings.java
index f6560eb610..4a73da2401 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/ConnectionSettings.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/ConnectionSettings.java
@@ -18,25 +18,25 @@
*/
package org.neo4j.driver.internal;
-import org.neo4j.driver.AuthToken;
+import org.neo4j.driver.AuthTokenManager;
/**
* The connection settings are used whenever a new connection is
* established to a server, specifically as part of the INIT request.
*/
public class ConnectionSettings {
- private final AuthToken authToken;
+ private final AuthTokenManager authTokenManager;
private final String userAgent;
private final int connectTimeoutMillis;
- public ConnectionSettings(AuthToken authToken, String userAgent, int connectTimeoutMillis) {
- this.authToken = authToken;
+ public ConnectionSettings(AuthTokenManager authTokenManager, String userAgent, int connectTimeoutMillis) {
+ this.authTokenManager = authTokenManager;
this.userAgent = userAgent;
this.connectTimeoutMillis = connectTimeoutMillis;
}
- public AuthToken authToken() {
- return authToken;
+ public AuthTokenManager authTokenProvider() {
+ return authTokenManager;
}
public String userAgent() {
diff --git a/driver/src/main/java/org/neo4j/driver/internal/DirectConnectionProvider.java b/driver/src/main/java/org/neo4j/driver/internal/DirectConnectionProvider.java
index a336e10100..0f68ee2694 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/DirectConnectionProvider.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/DirectConnectionProvider.java
@@ -19,16 +19,19 @@
package org.neo4j.driver.internal;
import static org.neo4j.driver.internal.async.ConnectionContext.PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER;
-import static org.neo4j.driver.internal.messaging.request.MultiDatabaseUtil.supportsMultiDatabase;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
+import java.util.function.Function;
+import org.neo4j.driver.AuthToken;
import org.neo4j.driver.internal.async.ConnectionContext;
import org.neo4j.driver.internal.async.connection.DirectConnection;
+import org.neo4j.driver.internal.messaging.request.MultiDatabaseUtil;
import org.neo4j.driver.internal.spi.Connection;
import org.neo4j.driver.internal.spi.ConnectionPool;
import org.neo4j.driver.internal.spi.ConnectionProvider;
import org.neo4j.driver.internal.util.Futures;
+import org.neo4j.driver.internal.util.SessionAuthUtil;
/**
* Simple {@link ConnectionProvider connection provider} that obtains connections form the given pool only for the given address.
@@ -46,7 +49,7 @@ public class DirectConnectionProvider implements ConnectionProvider {
public CompletionStage acquireConnection(ConnectionContext context) {
CompletableFuture databaseNameFuture = context.databaseNameFuture();
databaseNameFuture.complete(DatabaseNameUtil.defaultDatabase());
- return acquireConnection()
+ return acquirePooledConnection(context.overrideAuthToken())
.thenApply(connection -> new DirectConnection(
connection,
Futures.joinNowOrElseThrow(databaseNameFuture, PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER),
@@ -56,7 +59,7 @@ public CompletionStage acquireConnection(ConnectionContext context)
@Override
public CompletionStage verifyConnectivity() {
- return acquireConnection().thenCompose(Connection::release);
+ return acquirePooledConnection(null).thenCompose(Connection::release);
}
@Override
@@ -66,9 +69,18 @@ public CompletionStage close() {
@Override
public CompletionStage supportsMultiDb() {
- return acquireConnection().thenCompose(conn -> {
- boolean supportsMultiDatabase = supportsMultiDatabase(conn);
- return conn.release().thenApply(ignored -> supportsMultiDatabase);
+ return detectFeature(MultiDatabaseUtil::supportsMultiDatabase);
+ }
+
+ @Override
+ public CompletionStage supportsSessionAuth() {
+ return detectFeature(SessionAuthUtil::supportsSessionAuth);
+ }
+
+ private CompletionStage detectFeature(Function featureDetectionFunction) {
+ return acquirePooledConnection(null).thenCompose(conn -> {
+ boolean featureDetected = featureDetectionFunction.apply(conn);
+ return conn.release().thenApply(ignored -> featureDetected);
});
}
@@ -80,7 +92,7 @@ public BoltServerAddress getAddress() {
* Used only for grabbing a connection with the server after hello message.
* This connection cannot be directly used for running any queries as it is missing necessary connection context
*/
- private CompletionStage acquireConnection() {
- return connectionPool.acquire(address);
+ private CompletionStage acquirePooledConnection(AuthToken authToken) {
+ return connectionPool.acquire(address, authToken);
}
}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/DriverFactory.java b/driver/src/main/java/org/neo4j/driver/internal/DriverFactory.java
index 1c9d682c68..5b60d7a317 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/DriverFactory.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/DriverFactory.java
@@ -18,6 +18,7 @@
*/
package org.neo4j.driver.internal;
+import static java.util.Objects.requireNonNull;
import static org.neo4j.driver.internal.Scheme.isRoutingScheme;
import static org.neo4j.driver.internal.cluster.IdentityResolver.IDENTITY_RESOLVER;
import static org.neo4j.driver.internal.util.ErrorUtil.addSuppressed;
@@ -28,9 +29,8 @@
import io.netty.util.internal.logging.InternalLoggerFactory;
import java.net.URI;
import java.time.Clock;
-import java.util.Objects;
import java.util.function.Supplier;
-import org.neo4j.driver.AuthToken;
+import org.neo4j.driver.AuthTokenManager;
import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.Config;
import org.neo4j.driver.Driver;
@@ -58,6 +58,7 @@
import org.neo4j.driver.internal.retry.RetryLogic;
import org.neo4j.driver.internal.security.SecurityPlan;
import org.neo4j.driver.internal.security.SecurityPlans;
+import org.neo4j.driver.internal.security.StaticAuthTokenManager;
import org.neo4j.driver.internal.spi.ConnectionPool;
import org.neo4j.driver.internal.spi.ConnectionProvider;
import org.neo4j.driver.internal.util.Futures;
@@ -67,17 +68,18 @@ public class DriverFactory {
public static final String NO_ROUTING_CONTEXT_ERROR_MESSAGE =
"Routing parameters are not supported with scheme 'bolt'. Given URI: ";
- public final Driver newInstance(URI uri, AuthToken authToken, Config config) {
- return newInstance(uri, authToken, config, null, null, null);
+ public final Driver newInstance(URI uri, AuthTokenManager authTokenManager, Config config) {
+ return newInstance(uri, authTokenManager, config, null, null, null);
}
public final Driver newInstance(
URI uri,
- AuthToken authToken,
+ AuthTokenManager authTokenManager,
Config config,
SecurityPlan securityPlan,
EventLoopGroup eventLoopGroup,
Supplier rediscoverySupplier) {
+ requireNonNull(authTokenManager, "authTokenProvider must not be null");
Bootstrap bootstrap;
boolean ownsEventLoopGroup;
@@ -94,7 +96,7 @@ public final Driver newInstance(
securityPlan = SecurityPlans.createSecurityPlan(settings, uri.getScheme());
}
- authToken = authToken == null ? AuthTokens.none() : authToken;
+ authTokenManager = authTokenManager == null ? new StaticAuthTokenManager(AuthTokens.none()) : authTokenManager;
BoltServerAddress address = new BoltServerAddress(uri);
RoutingSettings routingSettings =
@@ -107,7 +109,7 @@ public final Driver newInstance(
MetricsProvider metricsProvider = getOrCreateMetricsProvider(config, createClock());
ConnectionPool connectionPool = createConnectionPool(
- authToken,
+ authTokenManager,
securityPlan,
bootstrap,
metricsProvider,
@@ -129,7 +131,7 @@ public final Driver newInstance(
}
protected ConnectionPool createConnectionPool(
- AuthToken authToken,
+ AuthTokenManager authTokenManager,
SecurityPlan securityPlan,
Bootstrap bootstrap,
MetricsProvider metricsProvider,
@@ -138,7 +140,7 @@ protected ConnectionPool createConnectionPool(
RoutingContext routingContext) {
Clock clock = createClock();
ConnectionSettings settings =
- new ConnectionSettings(authToken, config.userAgent(), config.connectionTimeoutMillis());
+ new ConnectionSettings(authTokenManager, config.userAgent(), config.connectionTimeoutMillis());
ChannelConnector connector = createConnector(settings, securityPlan, config, clock, routingContext);
PoolSettings poolSettings = new PoolSettings(
config.maxConnectionPoolSize(),
@@ -292,7 +294,7 @@ protected LoadBalancer createLoadBalancer(
Supplier rediscoverySupplier) {
var loadBalancingStrategy = new LeastConnectedLoadBalancingStrategy(connectionPool, config.logging());
var resolver = createResolver(config);
- var domainNameResolver = Objects.requireNonNull(getDomainNameResolver(), "domainNameResolver must not be null");
+ var domainNameResolver = requireNonNull(getDomainNameResolver(), "domainNameResolver must not be null");
var clock = createClock();
var logging = config.logging();
if (rediscoverySupplier == null) {
diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalDriver.java b/driver/src/main/java/org/neo4j/driver/internal/InternalDriver.java
index a5e9981c4c..a0673f18de 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/InternalDriver.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/InternalDriver.java
@@ -21,8 +21,11 @@
import static java.util.Objects.requireNonNull;
import static org.neo4j.driver.internal.util.Futures.completedWithNull;
+import java.util.Set;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.atomic.AtomicBoolean;
+import org.neo4j.driver.AccessMode;
+import org.neo4j.driver.AuthToken;
import org.neo4j.driver.BaseSession;
import org.neo4j.driver.BookmarkManager;
import org.neo4j.driver.BookmarkManagerConfig;
@@ -37,6 +40,8 @@
import org.neo4j.driver.Session;
import org.neo4j.driver.SessionConfig;
import org.neo4j.driver.async.AsyncSession;
+import org.neo4j.driver.exceptions.Neo4jException;
+import org.neo4j.driver.exceptions.UnsupportedFeatureException;
import org.neo4j.driver.internal.async.InternalAsyncSession;
import org.neo4j.driver.internal.async.NetworkSession;
import org.neo4j.driver.internal.metrics.DevNullMetricsProvider;
@@ -49,6 +54,11 @@
import org.neo4j.driver.types.TypeSystem;
public class InternalDriver implements Driver {
+ private static final Set INVALID_TOKEN_CODES = Set.of(
+ "Neo.ClientError.Security.CredentialsExpired",
+ "Neo.ClientError.Security.Forbidden",
+ "Neo.ClientError.Security.TokenExpired",
+ "Neo.ClientError.Security.Unauthorized");
private final BookmarkManager queryBookmarkManager =
BookmarkManagers.defaultManager(BookmarkManagerConfig.builder().build());
private final SecurityPlan securityPlan;
@@ -81,21 +91,23 @@ public BookmarkManager executableQueryBookmarkManager() {
@SuppressWarnings({"unchecked", "deprecation"})
@Override
- public T session(Class sessionClass, SessionConfig sessionConfig) {
+ public T session(
+ Class sessionClass, SessionConfig sessionConfig, AuthToken sessionAuthToken) {
requireNonNull(sessionClass, "sessionClass must not be null");
requireNonNull(sessionClass, "sessionConfig must not be null");
T session;
if (Session.class.isAssignableFrom(sessionClass)) {
- session = (T) new InternalSession(newSession(sessionConfig));
+ session = (T) new InternalSession(newSession(sessionConfig, sessionAuthToken));
} else if (AsyncSession.class.isAssignableFrom(sessionClass)) {
- session = (T) new InternalAsyncSession(newSession(sessionConfig));
+ session = (T) new InternalAsyncSession(newSession(sessionConfig, sessionAuthToken));
} else if (org.neo4j.driver.reactive.ReactiveSession.class.isAssignableFrom(sessionClass)) {
- session = (T) new org.neo4j.driver.internal.reactive.InternalReactiveSession(newSession(sessionConfig));
+ session = (T) new org.neo4j.driver.internal.reactive.InternalReactiveSession(
+ newSession(sessionConfig, sessionAuthToken));
} else if (org.neo4j.driver.reactivestreams.ReactiveSession.class.isAssignableFrom(sessionClass)) {
- session = (T)
- new org.neo4j.driver.internal.reactivestreams.InternalReactiveSession(newSession(sessionConfig));
+ session = (T) new org.neo4j.driver.internal.reactivestreams.InternalReactiveSession(
+ newSession(sessionConfig, sessionAuthToken));
} else if (RxSession.class.isAssignableFrom(sessionClass)) {
- session = (T) new InternalRxSession(newSession(sessionConfig));
+ session = (T) new InternalRxSession(newSession(sessionConfig, sessionAuthToken));
} else {
throw new IllegalArgumentException(
String.format("Unsupported session type '%s'", sessionClass.getCanonicalName()));
@@ -144,6 +156,33 @@ public CompletionStage verifyConnectivityAsync() {
return sessionFactory.verifyConnectivity();
}
+ @Override
+ public boolean verifyAuthentication(AuthToken authToken) {
+ var config = SessionConfig.builder()
+ .withDatabase("system")
+ .withDefaultAccessMode(AccessMode.READ)
+ .build();
+ try (var session = session(Session.class, config, authToken)) {
+ session.run("SHOW DEFAULT DATABASE").consume();
+ return true;
+ } catch (RuntimeException e) {
+ if (e instanceof Neo4jException neo4jException) {
+ if (e instanceof UnsupportedFeatureException) {
+ throw new UnsupportedFeatureException(
+ "Unable to verify authentication due to an unsupported feature", e);
+ } else if (INVALID_TOKEN_CODES.contains(neo4jException.code())) {
+ return false;
+ }
+ }
+ throw e;
+ }
+ }
+
+ @Override
+ public boolean supportsSessionAuth() {
+ return Futures.blockingGet(sessionFactory.supportsSessionAuth());
+ }
+
@Override
public boolean supportsMultiDb() {
return Futures.blockingGet(supportsMultiDbAsync());
@@ -174,9 +213,9 @@ private static RuntimeException driverCloseException() {
return new IllegalStateException("This driver instance has already been closed");
}
- public NetworkSession newSession(SessionConfig config) {
+ public NetworkSession newSession(SessionConfig config, AuthToken overrideAuthToken) {
assertOpen();
- NetworkSession session = sessionFactory.newInstance(config);
+ NetworkSession session = sessionFactory.newInstance(config, overrideAuthToken);
if (closed.get()) {
// session does not immediately acquire connection, it is fine to just throw
throw driverCloseException();
diff --git a/driver/src/main/java/org/neo4j/driver/internal/SessionFactory.java b/driver/src/main/java/org/neo4j/driver/internal/SessionFactory.java
index f2407f0f1a..fb334cad99 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/SessionFactory.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/SessionFactory.java
@@ -19,15 +19,18 @@
package org.neo4j.driver.internal;
import java.util.concurrent.CompletionStage;
+import org.neo4j.driver.AuthToken;
import org.neo4j.driver.SessionConfig;
import org.neo4j.driver.internal.async.NetworkSession;
public interface SessionFactory {
- NetworkSession newInstance(SessionConfig sessionConfig);
+ NetworkSession newInstance(SessionConfig sessionConfig, AuthToken overrideAuthToken);
CompletionStage verifyConnectivity();
CompletionStage close();
CompletionStage supportsMultiDb();
+
+ CompletionStage supportsSessionAuth();
}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/SessionFactoryImpl.java b/driver/src/main/java/org/neo4j/driver/internal/SessionFactoryImpl.java
index 737ebd8d3d..91f8aed98b 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/SessionFactoryImpl.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/SessionFactoryImpl.java
@@ -25,6 +25,7 @@
import java.util.Set;
import java.util.concurrent.CompletionStage;
import org.neo4j.driver.AccessMode;
+import org.neo4j.driver.AuthToken;
import org.neo4j.driver.Bookmark;
import org.neo4j.driver.BookmarkManager;
import org.neo4j.driver.Config;
@@ -54,7 +55,7 @@ public class SessionFactoryImpl implements SessionFactory {
}
@Override
- public NetworkSession newInstance(SessionConfig sessionConfig) {
+ public NetworkSession newInstance(SessionConfig sessionConfig, AuthToken overrideAuthToken) {
return createSession(
connectionProvider,
retryLogic,
@@ -65,7 +66,8 @@ public NetworkSession newInstance(SessionConfig sessionConfig) {
sessionConfig.impersonatedUser().orElse(null),
logging,
sessionConfig.bookmarkManager().orElse(NoOpBookmarkManager.INSTANCE),
- sessionConfig.notificationConfig());
+ sessionConfig.notificationConfig(),
+ overrideAuthToken);
}
private Set toDistinctSet(Iterable bookmarks) {
@@ -115,6 +117,11 @@ public CompletionStage supportsMultiDb() {
return connectionProvider.supportsMultiDb();
}
+ @Override
+ public CompletionStage supportsSessionAuth() {
+ return connectionProvider.supportsSessionAuth();
+ }
+
/**
* Get the underlying connection provider.
*
@@ -136,7 +143,8 @@ private NetworkSession createSession(
String impersonatedUser,
Logging logging,
BookmarkManager bookmarkManager,
- NotificationConfig notificationConfig) {
+ NotificationConfig notificationConfig,
+ AuthToken authToken) {
Objects.requireNonNull(bookmarks, "bookmarks may not be null");
Objects.requireNonNull(bookmarkManager, "bookmarkManager may not be null");
return leakedSessionsLoggingEnabled
@@ -150,7 +158,8 @@ private NetworkSession createSession(
fetchSize,
logging,
bookmarkManager,
- notificationConfig)
+ notificationConfig,
+ authToken)
: new NetworkSession(
connectionProvider,
retryLogic,
@@ -161,6 +170,7 @@ private NetworkSession createSession(
fetchSize,
logging,
bookmarkManager,
- notificationConfig);
+ notificationConfig,
+ authToken);
}
}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/ConnectionContext.java b/driver/src/main/java/org/neo4j/driver/internal/async/ConnectionContext.java
index 07a41e992b..1280df712d 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/ConnectionContext.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/ConnectionContext.java
@@ -22,6 +22,7 @@
import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;
import org.neo4j.driver.AccessMode;
+import org.neo4j.driver.AuthToken;
import org.neo4j.driver.Bookmark;
import org.neo4j.driver.internal.DatabaseName;
import org.neo4j.driver.internal.spi.ConnectionProvider;
@@ -40,4 +41,6 @@ public interface ConnectionContext {
Set rediscoveryBookmarks();
String impersonatedUser();
+
+ AuthToken overrideAuthToken();
}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/ImmutableConnectionContext.java b/driver/src/main/java/org/neo4j/driver/internal/async/ImmutableConnectionContext.java
index a45b1382de..4fb56d730b 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/ImmutableConnectionContext.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/ImmutableConnectionContext.java
@@ -25,6 +25,7 @@
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import org.neo4j.driver.AccessMode;
+import org.neo4j.driver.AuthToken;
import org.neo4j.driver.Bookmark;
import org.neo4j.driver.internal.DatabaseName;
import org.neo4j.driver.internal.spi.Connection;
@@ -68,6 +69,11 @@ public String impersonatedUser() {
return null;
}
+ @Override
+ public AuthToken overrideAuthToken() {
+ return null;
+ }
+
/**
* A simple context is used to test connectivity with a remote server/cluster. As long as there is a read only service, the connection shall be established
* successfully. Depending on whether multidb is supported or not, this method returns different context for routing table discovery.
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/LeakLoggingNetworkSession.java b/driver/src/main/java/org/neo4j/driver/internal/async/LeakLoggingNetworkSession.java
index 266fbb61b4..9def045cf5 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/LeakLoggingNetworkSession.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/LeakLoggingNetworkSession.java
@@ -22,6 +22,7 @@
import java.util.Set;
import org.neo4j.driver.AccessMode;
+import org.neo4j.driver.AuthToken;
import org.neo4j.driver.Bookmark;
import org.neo4j.driver.BookmarkManager;
import org.neo4j.driver.Logging;
@@ -44,7 +45,8 @@ public LeakLoggingNetworkSession(
long fetchSize,
Logging logging,
BookmarkManager bookmarkManager,
- NotificationConfig notificationConfig) {
+ NotificationConfig notificationConfig,
+ AuthToken overrideAuthToken) {
super(
connectionProvider,
retryLogic,
@@ -55,7 +57,8 @@ public LeakLoggingNetworkSession(
fetchSize,
logging,
bookmarkManager,
- notificationConfig);
+ notificationConfig,
+ overrideAuthToken);
this.stackTrace = captureStackTrace();
}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/NetworkSession.java b/driver/src/main/java/org/neo4j/driver/internal/async/NetworkSession.java
index 79cad9010e..f57df5218e 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/NetworkSession.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/NetworkSession.java
@@ -32,6 +32,7 @@
import java.util.concurrent.CompletionStage;
import java.util.concurrent.atomic.AtomicBoolean;
import org.neo4j.driver.AccessMode;
+import org.neo4j.driver.AuthToken;
import org.neo4j.driver.Bookmark;
import org.neo4j.driver.BookmarkManager;
import org.neo4j.driver.Logger;
@@ -88,7 +89,8 @@ public NetworkSession(
long fetchSize,
Logging logging,
BookmarkManager bookmarkManager,
- NotificationConfig notificationConfig) {
+ NotificationConfig notificationConfig,
+ AuthToken overrideAuthToken) {
Objects.requireNonNull(bookmarks, "bookmarks may not be null");
Objects.requireNonNull(bookmarkManager, "bookmarkManager may not be null");
this.connectionProvider = connectionProvider;
@@ -101,8 +103,8 @@ public NetworkSession(
.orElse(new CompletableFuture<>());
this.bookmarkManager = bookmarkManager;
this.lastReceivedBookmarks = bookmarks;
- this.connectionContext =
- new NetworkSessionConnectionContext(databaseNameFuture, determineBookmarks(false), impersonatedUser);
+ this.connectionContext = new NetworkSessionConnectionContext(
+ databaseNameFuture, determineBookmarks(false), impersonatedUser, overrideAuthToken);
this.fetchSize = fetchSize;
this.notificationConfig = notificationConfig;
}
@@ -402,12 +404,17 @@ private static class NetworkSessionConnectionContext implements ConnectionContex
// As only those bookmarks could carry extra system bookmarks
private final Set rediscoveryBookmarks;
private final String impersonatedUser;
+ private final AuthToken authToken;
private NetworkSessionConnectionContext(
- CompletableFuture databaseNameFuture, Set bookmarks, String impersonatedUser) {
+ CompletableFuture databaseNameFuture,
+ Set bookmarks,
+ String impersonatedUser,
+ AuthToken authToken) {
this.databaseNameFuture = databaseNameFuture;
this.rediscoveryBookmarks = bookmarks;
this.impersonatedUser = impersonatedUser;
+ this.authToken = authToken;
}
private ConnectionContext contextWithMode(AccessMode mode) {
@@ -434,5 +441,10 @@ public Set rediscoveryBookmarks() {
public String impersonatedUser() {
return impersonatedUser;
}
+
+ @Override
+ public AuthToken overrideAuthToken() {
+ return authToken;
+ }
}
}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelAttributes.java b/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelAttributes.java
index 6ae0d80d72..f1c7fea7ba 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelAttributes.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelAttributes.java
@@ -26,8 +26,10 @@
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
+import java.util.concurrent.CompletionStage;
import org.neo4j.driver.internal.BoltServerAddress;
import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher;
+import org.neo4j.driver.internal.async.pool.AuthContext;
import org.neo4j.driver.internal.messaging.BoltPatchesListener;
import org.neo4j.driver.internal.messaging.BoltProtocolVersion;
@@ -45,6 +47,8 @@ public final class ChannelAttributes {
newInstance("authorizationStateListener");
private static final AttributeKey> BOLT_PATCHES_LISTENERS =
newInstance("boltPatchesListeners");
+ private static final AttributeKey> HELLO_STAGE = newInstance("helloStage");
+ private static final AttributeKey AUTH_CONTEXT = newInstance("authContext");
// configuration hints provided by the server
private static final AttributeKey CONNECTION_READ_TIMEOUT = newInstance("connectionReadTimeout");
@@ -154,6 +158,22 @@ public static Set boltPatchesListeners(Channel channel) {
return boltPatchesListeners != null ? boltPatchesListeners : Collections.emptySet();
}
+ public static CompletionStage helloStage(Channel channel) {
+ return get(channel, HELLO_STAGE);
+ }
+
+ public static void setHelloStage(Channel channel, CompletionStage helloStage) {
+ setOnce(channel, HELLO_STAGE, helloStage);
+ }
+
+ public static AuthContext authContext(Channel channel) {
+ return get(channel, AUTH_CONTEXT);
+ }
+
+ public static void setAuthContext(Channel channel, AuthContext authContext) {
+ setOnce(channel, AUTH_CONTEXT, authContext);
+ }
+
private static T get(Channel channel, AttributeKey key) {
return channel.attr(key).get();
}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelConnectorImpl.java b/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelConnectorImpl.java
index 4f76e8a79c..a2fd833ec5 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelConnectorImpl.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelConnectorImpl.java
@@ -30,7 +30,7 @@
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.time.Clock;
-import org.neo4j.driver.AuthToken;
+import org.neo4j.driver.AuthTokenManager;
import org.neo4j.driver.Logging;
import org.neo4j.driver.NotificationConfig;
import org.neo4j.driver.internal.BoltServerAddress;
@@ -42,7 +42,7 @@
public class ChannelConnectorImpl implements ChannelConnector {
private final String userAgent;
- private final AuthToken authToken;
+ private final AuthTokenManager authTokenManager;
private final RoutingContext routingContext;
private final SecurityPlan securityPlan;
private final ChannelPipelineBuilder pipelineBuilder;
@@ -82,7 +82,7 @@ public ChannelConnectorImpl(
DomainNameResolver domainNameResolver,
NotificationConfig notificationConfig) {
this.userAgent = connectionSettings.userAgent();
- this.authToken = connectionSettings.authToken();
+ this.authTokenManager = connectionSettings.authTokenProvider();
this.routingContext = routingContext;
this.connectTimeoutMillis = connectionSettings.connectTimeoutMillis();
this.securityPlan = requireNonNull(securityPlan);
@@ -97,7 +97,8 @@ public ChannelConnectorImpl(
@Override
public ChannelFuture connect(BoltServerAddress address, Bootstrap bootstrap) {
bootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, connectTimeoutMillis);
- bootstrap.handler(new NettyChannelInitializer(address, securityPlan, connectTimeoutMillis, clock, logging));
+ bootstrap.handler(new NettyChannelInitializer(
+ address, securityPlan, connectTimeoutMillis, authTokenManager, clock, logging));
bootstrap.resolver(addressResolverGroup);
SocketAddress socketAddress;
@@ -144,6 +145,6 @@ private void installHandshakeCompletedListeners(
// add listener that sends an INIT message. connection is now fully established. channel pipeline if fully
// set to send/receive messages for a selected protocol version
handshakeCompleted.addListener(new HandshakeCompletedListener(
- userAgent, authToken, routingContext, connectionInitialized, notificationConfig));
+ userAgent, routingContext, connectionInitialized, notificationConfig, clock));
}
}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/HandshakeCompletedListener.java b/driver/src/main/java/org/neo4j/driver/internal/async/connection/HandshakeCompletedListener.java
index 3fdda59ca9..93da0778dd 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/HandshakeCompletedListener.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/connection/HandshakeCompletedListener.java
@@ -19,41 +19,70 @@
package org.neo4j.driver.internal.async.connection;
import static java.util.Objects.requireNonNull;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.authContext;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelPromise;
-import org.neo4j.driver.AuthToken;
+import java.time.Clock;
import org.neo4j.driver.NotificationConfig;
import org.neo4j.driver.internal.cluster.RoutingContext;
import org.neo4j.driver.internal.messaging.BoltProtocol;
+import org.neo4j.driver.internal.messaging.v51.BoltProtocolV51;
public class HandshakeCompletedListener implements ChannelFutureListener {
private final String userAgent;
- private final AuthToken authToken;
private final RoutingContext routingContext;
private final ChannelPromise connectionInitializedPromise;
private final NotificationConfig notificationConfig;
+ private final Clock clock;
public HandshakeCompletedListener(
String userAgent,
- AuthToken authToken,
RoutingContext routingContext,
ChannelPromise connectionInitializedPromise,
- NotificationConfig notificationConfig) {
+ NotificationConfig notificationConfig,
+ Clock clock) {
+ requireNonNull(clock, "clock must not be null");
this.userAgent = requireNonNull(userAgent);
- this.authToken = requireNonNull(authToken);
this.routingContext = routingContext;
this.connectionInitializedPromise = requireNonNull(connectionInitializedPromise);
this.notificationConfig = notificationConfig;
+ this.clock = clock;
}
@Override
public void operationComplete(ChannelFuture future) {
if (future.isSuccess()) {
BoltProtocol protocol = BoltProtocol.forChannel(future.channel());
- protocol.initializeChannel(
- userAgent, authToken, routingContext, connectionInitializedPromise, notificationConfig);
+ // pre Bolt 5.1
+ if (BoltProtocolV51.VERSION.compareTo(protocol.version()) > 0) {
+ var channel = connectionInitializedPromise.channel();
+ var authContext = authContext(channel);
+ authContext
+ .getAuthTokenManager()
+ .getToken()
+ .whenCompleteAsync(
+ (authToken, throwable) -> {
+ if (throwable != null) {
+ connectionInitializedPromise.setFailure(throwable);
+ } else {
+ authContext.initiateAuth(authToken);
+ authContext.setValidToken(authToken);
+ protocol.initializeChannel(
+ userAgent,
+ authToken,
+ routingContext,
+ connectionInitializedPromise,
+ notificationConfig,
+ clock);
+ }
+ },
+ channel.eventLoop());
+ } else {
+ protocol.initializeChannel(
+ userAgent, null, routingContext, connectionInitializedPromise, notificationConfig, clock);
+ }
} else {
connectionInitializedPromise.setFailure(future.cause());
}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/NettyChannelInitializer.java b/driver/src/main/java/org/neo4j/driver/internal/async/connection/NettyChannelInitializer.java
index eea5d2f22d..70a9b0faef 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/NettyChannelInitializer.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/connection/NettyChannelInitializer.java
@@ -18,6 +18,7 @@
*/
package org.neo4j.driver.internal.async.connection;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setAuthContext;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setCreationTimestamp;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setMessageDispatcher;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setServerAddress;
@@ -29,15 +30,18 @@
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLEngine;
import javax.net.ssl.SSLParameters;
+import org.neo4j.driver.AuthTokenManager;
import org.neo4j.driver.Logging;
import org.neo4j.driver.internal.BoltServerAddress;
import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher;
+import org.neo4j.driver.internal.async.pool.AuthContext;
import org.neo4j.driver.internal.security.SecurityPlan;
public class NettyChannelInitializer extends ChannelInitializer {
private final BoltServerAddress address;
private final SecurityPlan securityPlan;
private final int connectTimeoutMillis;
+ private final AuthTokenManager authTokenManager;
private final Clock clock;
private final Logging logging;
@@ -45,11 +49,13 @@ public NettyChannelInitializer(
BoltServerAddress address,
SecurityPlan securityPlan,
int connectTimeoutMillis,
+ AuthTokenManager authTokenManager,
Clock clock,
Logging logging) {
this.address = address;
this.securityPlan = securityPlan;
this.connectTimeoutMillis = connectTimeoutMillis;
+ this.authTokenManager = authTokenManager;
this.clock = clock;
this.logging = logging;
}
@@ -87,5 +93,6 @@ private void updateChannelAttributes(Channel channel) {
setServerAddress(channel, address);
setCreationTimestamp(channel, clock.millis());
setMessageDispatcher(channel, new InboundMessageDispatcher(channel, logging));
+ setAuthContext(channel, new AuthContext(authTokenManager));
}
}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcher.java b/driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcher.java
index 8f5e71470a..0960460ed7 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcher.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcher.java
@@ -19,6 +19,7 @@
package org.neo4j.driver.internal.async.inbound;
import static java.util.Objects.requireNonNull;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.authContext;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.authorizationStateListener;
import static org.neo4j.driver.internal.messaging.request.ResetMessage.RESET;
import static org.neo4j.driver.internal.util.ErrorUtil.addSuppressed;
@@ -33,10 +34,13 @@
import org.neo4j.driver.Value;
import org.neo4j.driver.exceptions.AuthorizationExpiredException;
import org.neo4j.driver.exceptions.ClientException;
+import org.neo4j.driver.exceptions.TokenExpiredException;
+import org.neo4j.driver.exceptions.TokenExpiredRetryableException;
import org.neo4j.driver.internal.handlers.ResetResponseHandler;
import org.neo4j.driver.internal.logging.ChannelActivityLogger;
import org.neo4j.driver.internal.logging.ChannelErrorLogger;
import org.neo4j.driver.internal.messaging.ResponseMessageHandler;
+import org.neo4j.driver.internal.security.StaticAuthTokenManager;
import org.neo4j.driver.internal.spi.ResponseHandler;
import org.neo4j.driver.internal.util.ErrorUtil;
@@ -114,8 +118,19 @@ public void handleFailureMessage(String code, String message) {
}
Throwable currentError = this.currentError;
- if (currentError instanceof AuthorizationExpiredException) {
- authorizationStateListener(channel).onExpired((AuthorizationExpiredException) currentError, channel);
+ if (currentError instanceof AuthorizationExpiredException authorizationExpiredException) {
+ authorizationStateListener(channel).onExpired(authorizationExpiredException, channel);
+ } else if (currentError instanceof TokenExpiredException tokenExpiredException) {
+ var authContext = authContext(channel);
+ var authTokenProvider = authContext.getAuthTokenManager();
+ if (!(authTokenProvider instanceof StaticAuthTokenManager)) {
+ currentError = new TokenExpiredRetryableException(
+ tokenExpiredException.code(), tokenExpiredException.getMessage());
+ }
+ var authToken = authContext.getAuthToken();
+ if (authToken != null && authContext.isManaged()) {
+ authTokenProvider.onExpired(authToken);
+ }
} else {
// write a RESET to "acknowledge" the failure
enqueue(new ResetResponseHandler(this));
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/pool/AuthContext.java b/driver/src/main/java/org/neo4j/driver/internal/async/pool/AuthContext.java
new file mode 100644
index 0000000000..314bf2d19b
--- /dev/null
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/pool/AuthContext.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.async.pool;
+
+import static java.util.Objects.requireNonNull;
+
+import org.neo4j.driver.AuthToken;
+import org.neo4j.driver.AuthTokenManager;
+
+public class AuthContext {
+ private final AuthTokenManager authTokenManager;
+ private AuthToken authToken;
+ private Long authTimestamp;
+ private boolean pendingLogoff;
+ private boolean managed;
+ private AuthToken validToken;
+
+ public AuthContext(AuthTokenManager authTokenManager) {
+ requireNonNull(authTokenManager, "authTokenProvider must not be null");
+ this.authTokenManager = authTokenManager;
+ this.managed = true;
+ }
+
+ public void initiateAuth(AuthToken authToken) {
+ initiateAuth(authToken, true);
+ }
+
+ public void initiateAuth(AuthToken authToken, boolean managed) {
+ requireNonNull(authToken, "authToken must not be null");
+ this.authToken = authToken;
+ authTimestamp = null;
+ pendingLogoff = false;
+ this.managed = managed;
+ }
+
+ public AuthToken getAuthToken() {
+ return authToken;
+ }
+
+ public void finishAuth(long authTimestamp) {
+ this.authTimestamp = authTimestamp;
+ }
+
+ public Long getAuthTimestamp() {
+ return authTimestamp;
+ }
+
+ public void markPendingLogoff() {
+ pendingLogoff = true;
+ }
+
+ public boolean isPendingLogoff() {
+ return pendingLogoff;
+ }
+
+ public void setValidToken(AuthToken validToken) {
+ this.validToken = validToken;
+ }
+
+ public AuthToken getValidToken() {
+ return validToken;
+ }
+
+ public boolean isManaged() {
+ return managed;
+ }
+
+ public AuthTokenManager getAuthTokenManager() {
+ return authTokenManager;
+ }
+}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImpl.java b/driver/src/main/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImpl.java
index ec309e4c3f..92811db312 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImpl.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImpl.java
@@ -19,6 +19,7 @@
package org.neo4j.driver.internal.async.pool;
import static java.lang.String.format;
+import static java.util.Objects.requireNonNull;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setAuthorizationStateListener;
import static org.neo4j.driver.internal.util.Futures.combineErrors;
import static org.neo4j.driver.internal.util.Futures.completeWithNullIfNoError;
@@ -41,6 +42,8 @@
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.function.Supplier;
+import org.neo4j.driver.AuthToken;
import org.neo4j.driver.Logger;
import org.neo4j.driver.Logging;
import org.neo4j.driver.exceptions.ClientException;
@@ -58,7 +61,7 @@ public class ConnectionPoolImpl implements ConnectionPool {
private final ChannelConnector connector;
private final Bootstrap bootstrap;
private final NettyChannelTracker nettyChannelTracker;
- private final NettyChannelHealthChecker channelHealthChecker;
+ private final Supplier channelHealthCheckerSupplier;
private final PoolSettings settings;
private final Logger log;
private final MetricsListener metricsListener;
@@ -69,6 +72,7 @@ public class ConnectionPoolImpl implements ConnectionPool {
private final AtomicBoolean closed = new AtomicBoolean();
private final CompletableFuture closeFuture = new CompletableFuture<>();
private final ConnectionFactory connectionFactory;
+ private final Clock clock;
public ConnectionPoolImpl(
ChannelConnector connector,
@@ -83,7 +87,6 @@ public ConnectionPoolImpl(
bootstrap,
new NettyChannelTracker(
metricsListener, bootstrap.config().group().next(), logging),
- new NettyChannelHealthChecker(settings, clock, logging),
settings,
metricsListener,
logging,
@@ -96,26 +99,27 @@ protected ConnectionPoolImpl(
ChannelConnector connector,
Bootstrap bootstrap,
NettyChannelTracker nettyChannelTracker,
- NettyChannelHealthChecker nettyChannelHealthChecker,
PoolSettings settings,
MetricsListener metricsListener,
Logging logging,
Clock clock,
boolean ownsEventLoopGroup,
ConnectionFactory connectionFactory) {
+ requireNonNull(clock, "clock must not be null");
this.connector = connector;
this.bootstrap = bootstrap;
this.nettyChannelTracker = nettyChannelTracker;
- this.channelHealthChecker = nettyChannelHealthChecker;
+ this.channelHealthCheckerSupplier = () -> new NettyChannelHealthChecker(settings, clock, logging);
this.settings = settings;
this.metricsListener = metricsListener;
this.log = logging.getLog(getClass());
this.ownsEventLoopGroup = ownsEventLoopGroup;
this.connectionFactory = connectionFactory;
+ this.clock = clock;
}
@Override
- public CompletionStage acquire(BoltServerAddress address) {
+ public CompletionStage acquire(BoltServerAddress address, AuthToken overrideAuthToken) {
log.trace("Acquiring a connection from pool towards %s", address);
assertNotClosed();
@@ -123,13 +127,13 @@ public CompletionStage acquire(BoltServerAddress address) {
ListenerEvent acquireEvent = metricsListener.createListenerEvent();
metricsListener.beforeAcquiringOrCreating(pool.id(), acquireEvent);
- CompletionStage channelFuture = pool.acquire();
+ CompletionStage channelFuture = pool.acquire(overrideAuthToken);
return channelFuture.handle((channel, error) -> {
try {
processAcquisitionError(pool, address, error);
assertNotClosed(address, channel, pool);
- setAuthorizationStateListener(channel, channelHealthChecker);
+ setAuthorizationStateListener(channel, pool.healthChecker());
Connection connection = connectionFactory.createConnection(channel, pool);
metricsListener.afterAcquiredOrCreated(pool.id(), acquireEvent);
@@ -261,9 +265,10 @@ ExtendedChannelPool newPool(BoltServerAddress address) {
connector,
bootstrap,
nettyChannelTracker,
- channelHealthChecker,
+ channelHealthCheckerSupplier.get(),
settings.connectionAcquisitionTimeout(),
- settings.maxConnectionPoolSize());
+ settings.maxConnectionPoolSize(),
+ clock);
}
private ExtendedChannelPool getOrCreatePool(BoltServerAddress address) {
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/pool/ExtendedChannelPool.java b/driver/src/main/java/org/neo4j/driver/internal/async/pool/ExtendedChannelPool.java
index ec3c541480..a13676fc9c 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/pool/ExtendedChannelPool.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/pool/ExtendedChannelPool.java
@@ -20,9 +20,10 @@
import io.netty.channel.Channel;
import java.util.concurrent.CompletionStage;
+import org.neo4j.driver.AuthToken;
public interface ExtendedChannelPool {
- CompletionStage acquire();
+ CompletionStage acquire(AuthToken overrideAuthToken);
CompletionStage release(Channel channel);
@@ -31,4 +32,6 @@ public interface ExtendedChannelPool {
String id();
CompletionStage close();
+
+ NettyChannelHealthChecker healthChecker();
}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelHealthChecker.java b/driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelHealthChecker.java
index 4a7a0c28db..ea84180ef4 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelHealthChecker.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelHealthChecker.java
@@ -18,37 +18,40 @@
*/
package org.neo4j.driver.internal.async.pool;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.authContext;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.creationTimestamp;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.lastUsedTimestamp;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.messageDispatcher;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.protocolVersion;
import io.netty.channel.Channel;
import io.netty.channel.pool.ChannelHealthChecker;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.Promise;
+import io.netty.util.concurrent.PromiseNotifier;
import java.time.Clock;
-import java.util.Optional;
-import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.atomic.AtomicLong;
import org.neo4j.driver.Logger;
import org.neo4j.driver.Logging;
import org.neo4j.driver.exceptions.AuthorizationExpiredException;
import org.neo4j.driver.internal.async.connection.AuthorizationStateListener;
import org.neo4j.driver.internal.handlers.PingResponseHandler;
import org.neo4j.driver.internal.messaging.request.ResetMessage;
+import org.neo4j.driver.internal.messaging.v51.BoltProtocolV51;
public class NettyChannelHealthChecker implements ChannelHealthChecker, AuthorizationStateListener {
private final PoolSettings poolSettings;
private final Clock clock;
private final Logging logging;
private final Logger log;
- private final AtomicReference> minCreationTimestampMillisOpt;
+ private final AtomicLong minAuthTimestamp;
public NettyChannelHealthChecker(PoolSettings poolSettings, Clock clock, Logging logging) {
this.poolSettings = poolSettings;
this.clock = clock;
this.logging = logging;
this.log = logging.getLog(getClass());
- this.minCreationTimestampMillisOpt = new AtomicReference<>(Optional.empty());
+ this.minAuthTimestamp = new AtomicLong(-1);
}
@Override
@@ -56,31 +59,79 @@ public Future isHealthy(Channel channel) {
if (isTooOld(channel)) {
return channel.eventLoop().newSucceededFuture(Boolean.FALSE);
}
- if (hasBeenIdleForTooLong(channel)) {
- return ping(channel);
- }
- return ACTIVE.isHealthy(channel);
+ Promise result = channel.eventLoop().newPromise();
+ ACTIVE.isHealthy(channel).addListener(future -> {
+ if (future.isCancelled()) {
+ result.setSuccess(Boolean.FALSE);
+ } else if (!future.isSuccess()) {
+ var throwable = future.cause();
+ if (throwable != null) {
+ result.setFailure(throwable);
+ } else {
+ result.setSuccess(Boolean.FALSE);
+ }
+ } else {
+ if (!(Boolean) future.get()) {
+ result.setSuccess(Boolean.FALSE);
+ } else {
+ authContext(channel)
+ .getAuthTokenManager()
+ .getToken()
+ .whenCompleteAsync(
+ (authToken, throwable) -> {
+ if (throwable != null || authToken == null) {
+ result.setSuccess(Boolean.FALSE);
+ } else {
+ var authContext = authContext(channel);
+ if (authContext.getAuthTimestamp() != null) {
+ authContext.setValidToken(authToken);
+ var equal = authToken.equals(authContext.getAuthToken());
+ if (isAuthExpiredByFailure(channel) || !equal) {
+ // Bolt versions prior to 5.1 do not support auth renewal
+ if (BoltProtocolV51.VERSION.compareTo(protocolVersion(channel))
+ > 0) {
+ result.setSuccess(Boolean.FALSE);
+ } else {
+ authContext.markPendingLogoff();
+ var downstreamCheck = hasBeenIdleForTooLong(channel)
+ ? ping(channel)
+ : channel.eventLoop()
+ .newSucceededFuture(Boolean.TRUE);
+ downstreamCheck.addListener(new PromiseNotifier<>(result));
+ }
+ } else {
+ var downstreamCheck = hasBeenIdleForTooLong(channel)
+ ? ping(channel)
+ : channel.eventLoop()
+ .newSucceededFuture(Boolean.TRUE);
+ downstreamCheck.addListener(new PromiseNotifier<>(result));
+ }
+ } else {
+ result.setSuccess(Boolean.FALSE);
+ }
+ }
+ },
+ channel.eventLoop());
+ }
+ }
+ });
+ return result;
+ }
+
+ private boolean isAuthExpiredByFailure(Channel channel) {
+ var authTimestamp = authContext(channel).getAuthTimestamp();
+ return authTimestamp != null && authTimestamp <= minAuthTimestamp.get();
}
@Override
public void onExpired(AuthorizationExpiredException e, Channel channel) {
- long ts = creationTimestamp(channel);
- // Override current value ONLY if the new one is greater
- minCreationTimestampMillisOpt.getAndUpdate(
- prev -> Optional.of(prev.filter(prevTs -> ts <= prevTs).orElse(ts)));
+ var now = clock.millis();
+ minAuthTimestamp.getAndUpdate(prev -> Math.max(prev, now));
}
private boolean isTooOld(Channel channel) {
- long creationTimestampMillis = creationTimestamp(channel);
- Optional minCreationTimestampMillisOpt = this.minCreationTimestampMillisOpt.get();
-
- if (minCreationTimestampMillisOpt.isPresent()
- && creationTimestampMillis <= minCreationTimestampMillisOpt.get()) {
- log.trace(
- "The channel %s is marked for closure as its creation timestamp is older than or equal to the acceptable minimum timestamp: %s <= %s",
- channel, creationTimestampMillis, minCreationTimestampMillisOpt.get());
- return true;
- } else if (poolSettings.maxConnectionLifetimeEnabled()) {
+ if (poolSettings.maxConnectionLifetimeEnabled()) {
+ long creationTimestampMillis = creationTimestamp(channel);
long currentTimestampMillis = clock.millis();
long ageMillis = currentTimestampMillis - creationTimestampMillis;
@@ -92,7 +143,6 @@ private boolean isTooOld(Channel channel) {
"Failed acquire channel %s from the pool because it is too old: %s > %s",
channel, ageMillis, maxAgeMillis);
}
-
return tooOld;
}
return false;
diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelPool.java b/driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelPool.java
index 2b0627171a..892b83d98a 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelPool.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelPool.java
@@ -19,6 +19,10 @@
package org.neo4j.driver.internal.async.pool;
import static java.util.Objects.requireNonNull;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.authContext;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.helloStage;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.messageDispatcher;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.protocolVersion;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setPoolId;
import static org.neo4j.driver.internal.util.Futures.asCompletionStage;
@@ -26,14 +30,24 @@
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelPromise;
-import io.netty.channel.pool.ChannelHealthChecker;
import io.netty.channel.pool.FixedChannelPool;
+import java.time.Clock;
import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.atomic.AtomicBoolean;
+import org.neo4j.driver.AuthToken;
+import org.neo4j.driver.exceptions.UnsupportedFeatureException;
import org.neo4j.driver.internal.BoltServerAddress;
import org.neo4j.driver.internal.async.connection.ChannelConnector;
+import org.neo4j.driver.internal.handlers.LogoffResponseHandler;
+import org.neo4j.driver.internal.handlers.LogonResponseHandler;
+import org.neo4j.driver.internal.messaging.request.LogoffMessage;
+import org.neo4j.driver.internal.messaging.request.LogonMessage;
import org.neo4j.driver.internal.metrics.ListenerEvent;
+import org.neo4j.driver.internal.security.InternalAuthToken;
+import org.neo4j.driver.internal.util.Futures;
+import org.neo4j.driver.internal.util.SessionAuthUtil;
public class NettyChannelPool implements ExtendedChannelPool {
/**
@@ -49,19 +63,25 @@ public class NettyChannelPool implements ExtendedChannelPool {
private final AtomicBoolean closed = new AtomicBoolean(false);
private final String id;
private final CompletableFuture closeFuture = new CompletableFuture<>();
+ private final NettyChannelHealthChecker healthChecker;
+ private final Clock clock;
NettyChannelPool(
BoltServerAddress address,
ChannelConnector connector,
Bootstrap bootstrap,
NettyChannelTracker handler,
- ChannelHealthChecker healthCheck,
+ NettyChannelHealthChecker healthCheck,
long acquireTimeoutMillis,
- int maxConnections) {
+ int maxConnections,
+ Clock clock) {
requireNonNull(address);
requireNonNull(connector);
requireNonNull(handler);
+ requireNonNull(clock);
this.id = poolId(address);
+ this.healthChecker = healthCheck;
+ this.clock = clock;
this.delegate =
new FixedChannelPool(
bootstrap,
@@ -105,8 +125,104 @@ public CompletionStage close() {
}
@Override
- public CompletionStage acquire() {
- return asCompletionStage(delegate.acquire());
+ public NettyChannelHealthChecker healthChecker() {
+ return healthChecker;
+ }
+
+ @Override
+ public CompletionStage acquire(AuthToken overrideAuthToken) {
+ return asCompletionStage(delegate.acquire()).thenCompose(channel -> auth(channel, overrideAuthToken));
+ }
+
+ private CompletionStage auth(Channel channel, AuthToken overrideAuthToken) {
+ CompletionStage authStage;
+ var authContext = authContext(channel);
+ if (overrideAuthToken != null) {
+ // check protocol version
+ var protocolVersion = protocolVersion(channel);
+ if (!SessionAuthUtil.supportsSessionAuth(protocolVersion)) {
+ authStage = Futures.failedFuture(new UnsupportedFeatureException(String.format(
+ "Detected Bolt %s connection that does not support the auth token override feature, please make sure to have all servers communicating over Bolt 5.1 or above to use the feature",
+ protocolVersion)));
+ } else {
+ // auth or re-auth only if necessary
+ if (!overrideAuthToken.equals(authContext.getAuthToken())) {
+ CompletableFuture logoffFuture;
+ if (authContext.getAuthTimestamp() != null) {
+ logoffFuture = new CompletableFuture<>();
+ messageDispatcher(channel).enqueue(new LogoffResponseHandler(logoffFuture));
+ channel.write(LogoffMessage.INSTANCE);
+ } else {
+ logoffFuture = null;
+ }
+ var logonFuture = new CompletableFuture();
+ messageDispatcher(channel).enqueue(new LogonResponseHandler(logonFuture, channel, clock));
+ authContext.initiateAuth(overrideAuthToken, false);
+ authContext.setValidToken(null);
+ channel.write(new LogonMessage(((InternalAuthToken) overrideAuthToken).toMap()));
+ if (logoffFuture == null) {
+ authStage = helloStage(channel)
+ .thenCompose(ignored -> logonFuture)
+ .thenApply(ignored -> channel);
+ channel.flush();
+ } else {
+ // do not await for re-login
+ authStage = CompletableFuture.completedStage(channel);
+ }
+ } else {
+ authStage = CompletableFuture.completedStage(channel);
+ }
+ }
+ } else {
+ var validToken = authContext.getValidToken();
+ authContext.setValidToken(null);
+ var stage = validToken != null
+ ? CompletableFuture.completedStage(validToken)
+ : authContext.getAuthTokenManager().getToken();
+ authStage = stage.thenComposeAsync(
+ latestAuthToken -> {
+ CompletionStage result;
+ if (authContext.getAuthTimestamp() != null) {
+ if (!authContext.getAuthToken().equals(latestAuthToken) || authContext.isPendingLogoff()) {
+ var logoffFuture = new CompletableFuture();
+ messageDispatcher(channel).enqueue(new LogoffResponseHandler(logoffFuture));
+ channel.write(LogoffMessage.INSTANCE);
+ var logonFuture = new CompletableFuture();
+ messageDispatcher(channel)
+ .enqueue(new LogonResponseHandler(logonFuture, channel, clock));
+ authContext.initiateAuth(latestAuthToken);
+ channel.write(new LogonMessage(((InternalAuthToken) latestAuthToken).toMap()));
+ // do not await for re-login
+ result = CompletableFuture.completedStage(channel);
+ } else {
+ result = CompletableFuture.completedStage(channel);
+ }
+ } else {
+ var logonFuture = new CompletableFuture();
+ messageDispatcher(channel).enqueue(new LogonResponseHandler(logonFuture, channel, clock));
+ result = helloStage(channel)
+ .thenCompose(ignored -> logonFuture)
+ .thenApply(ignored -> channel);
+ authContext.initiateAuth(latestAuthToken);
+ channel.writeAndFlush(new LogonMessage(((InternalAuthToken) latestAuthToken).toMap()));
+ }
+ return result;
+ },
+ channel.eventLoop());
+ }
+ return authStage.handle((ignored, throwable) -> {
+ if (throwable != null) {
+ channel.close();
+ release(channel);
+ if (throwable instanceof RuntimeException runtimeException) {
+ throw runtimeException;
+ } else {
+ throw new CompletionException(throwable);
+ }
+ } else {
+ return channel;
+ }
+ });
}
@Override
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/Rediscovery.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/Rediscovery.java
index 87120d13b8..26107ec54f 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cluster/Rediscovery.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cluster/Rediscovery.java
@@ -22,6 +22,7 @@
import java.util.List;
import java.util.Set;
import java.util.concurrent.CompletionStage;
+import org.neo4j.driver.AuthToken;
import org.neo4j.driver.Bookmark;
import org.neo4j.driver.internal.BoltServerAddress;
import org.neo4j.driver.internal.spi.ConnectionPool;
@@ -39,10 +40,15 @@ public interface Rediscovery {
* @param connectionPool the connection pool for connection acquisition
* @param bookmarks the bookmarks that are presented to the server
* @param impersonatedUser the impersonated user for cluster composition lookup, should be {@code null} for non-impersonated requests
+ * @param overrideAuthToken the override auth token
* @return cluster composition lookup result
*/
CompletionStage lookupClusterComposition(
- RoutingTable routingTable, ConnectionPool connectionPool, Set bookmarks, String impersonatedUser);
+ RoutingTable routingTable,
+ ConnectionPool connectionPool,
+ Set bookmarks,
+ String impersonatedUser,
+ AuthToken overrideAuthToken);
List resolve() throws UnknownHostException;
}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RediscoveryImpl.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/RediscoveryImpl.java
index 4b4c0524d0..4992b23953 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RediscoveryImpl.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cluster/RediscoveryImpl.java
@@ -34,9 +34,11 @@
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.CompletionStage;
+import org.neo4j.driver.AuthToken;
import org.neo4j.driver.Bookmark;
import org.neo4j.driver.Logger;
import org.neo4j.driver.Logging;
+import org.neo4j.driver.exceptions.AuthTokenManagerExecutionException;
import org.neo4j.driver.exceptions.AuthorizationExpiredException;
import org.neo4j.driver.exceptions.ClientException;
import org.neo4j.driver.exceptions.DiscoveryException;
@@ -100,12 +102,14 @@ public CompletionStage lookupClusterComposition(
RoutingTable routingTable,
ConnectionPool connectionPool,
Set bookmarks,
- String impersonatedUser) {
+ String impersonatedUser,
+ AuthToken overrideAuthToken) {
CompletableFuture result = new CompletableFuture<>();
// if we failed discovery, we will chain all errors into this one.
ServiceUnavailableException baseError = new ServiceUnavailableException(
String.format(NO_ROUTERS_AVAILABLE, routingTable.database().description()));
- lookupClusterComposition(routingTable, connectionPool, result, bookmarks, impersonatedUser, baseError);
+ lookupClusterComposition(
+ routingTable, connectionPool, result, bookmarks, impersonatedUser, overrideAuthToken, baseError);
return result;
}
@@ -115,8 +119,9 @@ private void lookupClusterComposition(
CompletableFuture result,
Set bookmarks,
String impersonatedUser,
+ AuthToken overrideAuthToken,
Throwable baseError) {
- lookup(routingTable, pool, bookmarks, impersonatedUser, baseError)
+ lookup(routingTable, pool, bookmarks, impersonatedUser, overrideAuthToken, baseError)
.whenComplete((compositionLookupResult, completionError) -> {
Throwable error = Futures.completionExceptionCause(completionError);
if (error != null) {
@@ -134,15 +139,16 @@ private CompletionStage lookup(
ConnectionPool connectionPool,
Set bookmarks,
String impersonatedUser,
+ AuthToken overrideAuthToken,
Throwable baseError) {
CompletionStage compositionStage;
if (routingTable.preferInitialRouter()) {
compositionStage = lookupOnInitialRouterThenOnKnownRouters(
- routingTable, connectionPool, bookmarks, impersonatedUser, baseError);
+ routingTable, connectionPool, bookmarks, impersonatedUser, overrideAuthToken, baseError);
} else {
compositionStage = lookupOnKnownRoutersThenOnInitialRouter(
- routingTable, connectionPool, bookmarks, impersonatedUser, baseError);
+ routingTable, connectionPool, bookmarks, impersonatedUser, overrideAuthToken, baseError);
}
return compositionStage;
@@ -153,15 +159,23 @@ private CompletionStage lookupOnKnownRoutersThen
ConnectionPool connectionPool,
Set bookmarks,
String impersonatedUser,
+ AuthToken authToken,
Throwable baseError) {
Set seenServers = new HashSet<>();
- return lookupOnKnownRouters(routingTable, connectionPool, seenServers, bookmarks, impersonatedUser, baseError)
+ return lookupOnKnownRouters(
+ routingTable, connectionPool, seenServers, bookmarks, impersonatedUser, authToken, baseError)
.thenCompose(compositionLookupResult -> {
if (compositionLookupResult != null) {
return completedFuture(compositionLookupResult);
}
return lookupOnInitialRouter(
- routingTable, connectionPool, seenServers, bookmarks, impersonatedUser, baseError);
+ routingTable,
+ connectionPool,
+ seenServers,
+ bookmarks,
+ impersonatedUser,
+ authToken,
+ baseError);
});
}
@@ -170,15 +184,29 @@ private CompletionStage lookupOnInitialRouterThe
ConnectionPool connectionPool,
Set bookmarks,
String impersonatedUser,
+ AuthToken overrideAuthToken,
Throwable baseError) {
Set seenServers = emptySet();
- return lookupOnInitialRouter(routingTable, connectionPool, seenServers, bookmarks, impersonatedUser, baseError)
+ return lookupOnInitialRouter(
+ routingTable,
+ connectionPool,
+ seenServers,
+ bookmarks,
+ impersonatedUser,
+ overrideAuthToken,
+ baseError)
.thenCompose(compositionLookupResult -> {
if (compositionLookupResult != null) {
return completedFuture(compositionLookupResult);
}
return lookupOnKnownRouters(
- routingTable, connectionPool, new HashSet<>(), bookmarks, impersonatedUser, baseError);
+ routingTable,
+ connectionPool,
+ new HashSet<>(),
+ bookmarks,
+ impersonatedUser,
+ overrideAuthToken,
+ baseError);
});
}
@@ -188,6 +216,7 @@ private CompletionStage lookupOnKnownRouters(
Set seenServers,
Set bookmarks,
String impersonatedUser,
+ AuthToken authToken,
Throwable baseError) {
CompletableFuture result = completedWithNull();
for (BoltServerAddress address : routingTable.routers()) {
@@ -203,6 +232,7 @@ private CompletionStage lookupOnKnownRouters(
seenServers,
bookmarks,
impersonatedUser,
+ authToken,
baseError);
}
});
@@ -217,6 +247,7 @@ private CompletionStage lookupOnInitialRouter(
Set seenServers,
Set bookmarks,
String impersonatedUser,
+ AuthToken overrideAuthToken,
Throwable baseError) {
List resolvedRouters;
try {
@@ -234,7 +265,15 @@ private CompletionStage lookupOnInitialRouter(
return completedFuture(composition);
}
return lookupOnRouter(
- address, false, routingTable, connectionPool, null, bookmarks, impersonatedUser, baseError);
+ address,
+ false,
+ routingTable,
+ connectionPool,
+ null,
+ bookmarks,
+ impersonatedUser,
+ overrideAuthToken,
+ baseError);
});
}
return result.thenApply(composition ->
@@ -249,6 +288,7 @@ private CompletionStage lookupOnRouter(
Set seenServers,
Set bookmarks,
String impersonatedUser,
+ AuthToken overrideAuthToken,
Throwable baseError) {
CompletableFuture addressFuture = CompletableFuture.completedFuture(routerAddress);
@@ -256,7 +296,7 @@ private CompletionStage lookupOnRouter(
.thenApply(address ->
resolveAddress ? resolveByDomainNameOrThrowCompletionException(address, routingTable) : address)
.thenApply(address -> addAndReturn(seenServers, address))
- .thenCompose(connectionPool::acquire)
+ .thenCompose(address -> connectionPool.acquire(address, overrideAuthToken))
.thenApply(connection -> ImpersonationUtil.ensureImpersonationSupport(connection, impersonatedUser))
.thenCompose(connection -> provider.getClusterComposition(
connection, routingTable.database(), bookmarks, impersonatedUser))
@@ -297,6 +337,8 @@ private boolean mustAbortDiscovery(Throwable throwable) {
} else if (throwable instanceof IllegalStateException
&& ConnectionPool.CONNECTION_POOL_CLOSED_ERROR_MESSAGE.equals(throwable.getMessage())) {
abort = true;
+ } else if (throwable instanceof AuthTokenManagerExecutionException) {
+ abort = true;
} else if (throwable instanceof UnsupportedFeatureException) {
abort = true;
} else if (throwable instanceof ClientException) {
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableHandlerImpl.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableHandlerImpl.java
index ed6bdc9669..0f910ab99d 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableHandlerImpl.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableHandlerImpl.java
@@ -84,7 +84,12 @@ public synchronized CompletionStage ensureRoutingTable(ConnectionC
refreshRoutingTableFuture = resultFuture;
rediscovery
- .lookupClusterComposition(routingTable, connectionPool, context.rediscoveryBookmarks(), null)
+ .lookupClusterComposition(
+ routingTable,
+ connectionPool,
+ context.rediscoveryBookmarks(),
+ null,
+ context.overrideAuthToken())
.whenComplete((composition, completionError) -> {
Throwable error = Futures.completionExceptionCause(completionError);
if (error != null) {
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableRegistryImpl.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableRegistryImpl.java
index 75dee25982..1d1f96dbf7 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableRegistryImpl.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableRegistryImpl.java
@@ -121,7 +121,11 @@ private CompletionStage ensureDatabaseNameIsComplet
new ClusterRoutingTable(DatabaseNameUtil.defaultDatabase(), clock);
rediscovery
.lookupClusterComposition(
- routingTable, connectionPool, context.rediscoveryBookmarks(), impersonatedUser)
+ routingTable,
+ connectionPool,
+ context.rediscoveryBookmarks(),
+ impersonatedUser,
+ context.overrideAuthToken())
.thenCompose(compositionLookupResult -> {
DatabaseName databaseName = DatabaseNameUtil.database(compositionLookupResult
.getClusterComposition()
diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/LoadBalancer.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/LoadBalancer.java
index b452d6b0b8..ca4cbdfdfe 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/LoadBalancer.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/LoadBalancer.java
@@ -22,7 +22,6 @@
import static java.util.Objects.requireNonNull;
import static org.neo4j.driver.internal.async.ConnectionContext.PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER;
import static org.neo4j.driver.internal.async.ImmutableConnectionContext.simple;
-import static org.neo4j.driver.internal.messaging.request.MultiDatabaseUtil.supportsMultiDatabase;
import static org.neo4j.driver.internal.util.Futures.completedWithNull;
import static org.neo4j.driver.internal.util.Futures.completionExceptionCause;
import static org.neo4j.driver.internal.util.Futures.failedFuture;
@@ -34,7 +33,9 @@
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
+import java.util.function.Function;
import org.neo4j.driver.AccessMode;
+import org.neo4j.driver.AuthToken;
import org.neo4j.driver.Logger;
import org.neo4j.driver.Logging;
import org.neo4j.driver.exceptions.SecurityException;
@@ -48,10 +49,12 @@
import org.neo4j.driver.internal.cluster.RoutingTable;
import org.neo4j.driver.internal.cluster.RoutingTableRegistry;
import org.neo4j.driver.internal.cluster.RoutingTableRegistryImpl;
+import org.neo4j.driver.internal.messaging.request.MultiDatabaseUtil;
import org.neo4j.driver.internal.spi.Connection;
import org.neo4j.driver.internal.spi.ConnectionPool;
import org.neo4j.driver.internal.spi.ConnectionProvider;
import org.neo4j.driver.internal.util.Futures;
+import org.neo4j.driver.internal.util.SessionAuthUtil;
public class LoadBalancer implements ConnectionProvider {
private static final String CONNECTION_ACQUISITION_COMPLETION_FAILURE_MESSAGE =
@@ -103,7 +106,7 @@ public LoadBalancer(
@Override
public CompletionStage acquireConnection(ConnectionContext context) {
return routingTables.ensureRoutingTable(context).thenCompose(handler -> acquire(
- context.mode(), handler.routingTable())
+ context.mode(), handler.routingTable(), context.overrideAuthToken())
.thenApply(connection -> new RoutingConnection(
connection,
Futures.joinNowOrElseThrow(
@@ -138,6 +141,20 @@ public CompletionStage close() {
@Override
public CompletionStage supportsMultiDb() {
+ return detectFeature(
+ "Failed to perform multi-databases feature detection with the following servers: ",
+ MultiDatabaseUtil::supportsMultiDatabase);
+ }
+
+ @Override
+ public CompletionStage supportsSessionAuth() {
+ return detectFeature(
+ "Failed to perform session auth feature detection with the following servers: ",
+ SessionAuthUtil::supportsSessionAuth);
+ }
+
+ private CompletionStage detectFeature(
+ String baseErrorMessagePrefix, Function featureDetectionFunction) {
List addresses;
try {
@@ -146,8 +163,7 @@ public CompletionStage supportsMultiDb() {
return failedFuture(error);
}
CompletableFuture result = completedWithNull();
- Throwable baseError = new ServiceUnavailableException(
- "Failed to perform multi-databases feature detection with the following servers: " + addresses);
+ Throwable baseError = new ServiceUnavailableException(baseErrorMessagePrefix + addresses);
for (BoltServerAddress address : addresses) {
result = onErrorContinue(result, baseError, completionError -> {
@@ -156,7 +172,10 @@ public CompletionStage supportsMultiDb() {
if (error instanceof SecurityException) {
return failedFuture(error);
}
- return supportsMultiDb(address);
+ return connectionPool.acquire(address, null).thenCompose(conn -> {
+ boolean featureDetected = featureDetectionFunction.apply(conn);
+ return conn.release().thenApply(ignored -> featureDetected);
+ });
});
}
return onErrorContinue(result, baseError, completionError -> {
@@ -174,17 +193,11 @@ public RoutingTableRegistry getRoutingTableRegistry() {
return routingTables;
}
- private CompletionStage supportsMultiDb(BoltServerAddress address) {
- return connectionPool.acquire(address).thenCompose(conn -> {
- boolean supportsMultiDatabase = supportsMultiDatabase(conn);
- return conn.release().thenApply(ignored -> supportsMultiDatabase);
- });
- }
-
- private CompletionStage acquire(AccessMode mode, RoutingTable routingTable) {
+ private CompletionStage acquire(
+ AccessMode mode, RoutingTable routingTable, AuthToken overrideAuthToken) {
CompletableFuture result = new CompletableFuture<>();
List attemptExceptions = new ArrayList<>();
- acquire(mode, routingTable, result, attemptExceptions);
+ acquire(mode, routingTable, result, overrideAuthToken, attemptExceptions);
return result;
}
@@ -192,6 +205,7 @@ private void acquire(
AccessMode mode,
RoutingTable routingTable,
CompletableFuture result,
+ AuthToken overrideAuthToken,
List attemptErrors) {
List addresses = getAddressesByMode(mode, routingTable);
BoltServerAddress address = selectAddress(mode, addresses);
@@ -205,7 +219,7 @@ private void acquire(
return;
}
- connectionPool.acquire(address).whenComplete((connection, completionError) -> {
+ connectionPool.acquire(address, overrideAuthToken).whenComplete((connection, completionError) -> {
Throwable error = completionExceptionCause(completionError);
if (error != null) {
if (error instanceof ServiceUnavailableException) {
@@ -214,7 +228,9 @@ private void acquire(
log.debug(attemptMessage, error);
attemptErrors.add(error);
routingTable.forget(address);
- eventExecutorGroup.next().execute(() -> acquire(mode, routingTable, result, attemptErrors));
+ eventExecutorGroup
+ .next()
+ .execute(() -> acquire(mode, routingTable, result, overrideAuthToken, attemptErrors));
} else {
result.completeExceptionally(error);
}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/HelloResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/HelloResponseHandler.java
index 210b49d14f..8e2fb99328 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/handlers/HelloResponseHandler.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/handlers/HelloResponseHandler.java
@@ -18,6 +18,8 @@
*/
package org.neo4j.driver.internal.handlers;
+import static java.util.Objects.requireNonNull;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.authContext;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.boltPatchesListeners;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.protocolVersion;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setConnectionId;
@@ -28,6 +30,7 @@
import io.netty.channel.Channel;
import io.netty.channel.ChannelPromise;
+import java.time.Clock;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
@@ -45,10 +48,13 @@ public class HelloResponseHandler implements ResponseHandler {
private final ChannelPromise connectionInitializedPromise;
private final Channel channel;
+ private final Clock clock;
- public HelloResponseHandler(ChannelPromise connectionInitializedPromise) {
+ public HelloResponseHandler(ChannelPromise connectionInitializedPromise, Clock clock) {
+ requireNonNull(clock, "clock must not be null");
this.connectionInitializedPromise = connectionInitializedPromise;
this.channel = connectionInitializedPromise.channel();
+ this.clock = clock;
}
@Override
@@ -70,6 +76,10 @@ public void onSuccess(Map metadata) {
}
}
+ var authContext = authContext(channel);
+ if (authContext.getAuthToken() != null) {
+ authContext.finishAuth(clock.millis());
+ }
connectionInitializedPromise.setSuccess();
} catch (Throwable error) {
onFailure(error);
diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/HelloV51ResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/HelloV51ResponseHandler.java
new file mode 100644
index 0000000000..d9a4c6dde6
--- /dev/null
+++ b/driver/src/main/java/org/neo4j/driver/internal/handlers/HelloV51ResponseHandler.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.handlers;
+
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setConnectionId;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setServerAgent;
+import static org.neo4j.driver.internal.util.MetadataExtractor.extractServer;
+
+import io.netty.channel.Channel;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import org.neo4j.driver.Value;
+import org.neo4j.driver.internal.spi.ResponseHandler;
+
+public class HelloV51ResponseHandler implements ResponseHandler {
+ private static final String CONNECTION_ID_METADATA_KEY = "connection_id";
+
+ private final Channel channel;
+ private final CompletableFuture helloFuture;
+
+ public HelloV51ResponseHandler(Channel channel, CompletableFuture helloFuture) {
+ this.channel = channel;
+ this.helloFuture = helloFuture;
+ }
+
+ @Override
+ public void onSuccess(Map metadata) {
+ try {
+ var serverAgent = extractServer(metadata).asString();
+ setServerAgent(channel, serverAgent);
+
+ String connectionId = extractConnectionId(metadata);
+ setConnectionId(channel, connectionId);
+
+ helloFuture.complete(null);
+ } catch (Throwable error) {
+ onFailure(error);
+ throw error;
+ }
+ }
+
+ @Override
+ public void onFailure(Throwable error) {
+ channel.close().addListener(future -> helloFuture.completeExceptionally(error));
+ }
+
+ @Override
+ public void onRecord(Value[] fields) {
+ throw new UnsupportedOperationException();
+ }
+
+ private static String extractConnectionId(Map metadata) {
+ Value value = metadata.get(CONNECTION_ID_METADATA_KEY);
+ if (value == null || value.isNull()) {
+ throw new IllegalStateException("Unable to extract " + CONNECTION_ID_METADATA_KEY
+ + " from a response to HELLO message. " + "Received metadata: " + metadata);
+ }
+ return value.asString();
+ }
+}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/LogoffResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/LogoffResponseHandler.java
new file mode 100644
index 0000000000..3d60e57209
--- /dev/null
+++ b/driver/src/main/java/org/neo4j/driver/internal/handlers/LogoffResponseHandler.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.handlers;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import org.neo4j.driver.Value;
+import org.neo4j.driver.exceptions.ProtocolException;
+import org.neo4j.driver.internal.spi.ResponseHandler;
+
+public class LogoffResponseHandler implements ResponseHandler {
+ private final CompletableFuture future;
+
+ public LogoffResponseHandler(CompletableFuture future) {
+ this.future = requireNonNull(future, "future must not be null");
+ }
+
+ @Override
+ public void onSuccess(Map metadata) {
+ future.complete(null);
+ }
+
+ @Override
+ public void onFailure(Throwable error) {
+ future.completeExceptionally(error);
+ }
+
+ @Override
+ public void onRecord(Value[] fields) {
+ this.future.completeExceptionally(new ProtocolException("Records are not supported on LOGON"));
+ }
+}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/LogonResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/LogonResponseHandler.java
index acbad6fc42..e6868b5d96 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/handlers/LogonResponseHandler.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/handlers/LogonResponseHandler.java
@@ -18,35 +18,41 @@
*/
package org.neo4j.driver.internal.handlers;
+import static java.util.Objects.requireNonNull;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.authContext;
+
import io.netty.channel.Channel;
-import io.netty.channel.ChannelPromise;
+import java.time.Clock;
import java.util.Map;
+import java.util.concurrent.CompletableFuture;
import org.neo4j.driver.Value;
import org.neo4j.driver.exceptions.ProtocolException;
import org.neo4j.driver.internal.spi.ResponseHandler;
public class LogonResponseHandler implements ResponseHandler {
-
- private final ChannelPromise connectionInitializedPromise;
+ private final CompletableFuture future;
private final Channel channel;
+ private final Clock clock;
- public LogonResponseHandler(ChannelPromise connectionInitializedPromise) {
- this.connectionInitializedPromise = connectionInitializedPromise;
- this.channel = connectionInitializedPromise.channel();
+ public LogonResponseHandler(CompletableFuture future, Channel channel, Clock clock) {
+ this.future = requireNonNull(future, "future must not be null");
+ this.channel = requireNonNull(channel, "channel must not be null");
+ this.clock = requireNonNull(clock, "clock must not be null");
}
@Override
public void onSuccess(Map metadata) {
- connectionInitializedPromise.setSuccess();
+ authContext(channel).finishAuth(clock.millis());
+ future.complete(null);
}
@Override
public void onFailure(Throwable error) {
- channel.close().addListener(future -> connectionInitializedPromise.setFailure(error));
+ channel.close().addListener(future -> this.future.completeExceptionally(error));
}
@Override
public void onRecord(Value[] fields) {
- throw new ProtocolException("records not supported");
+ future.completeExceptionally(new ProtocolException("Records are not supported on LOGON"));
}
}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocol.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocol.java
index 0e55baffc2..799aba7d7d 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocol.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocol.java
@@ -22,6 +22,7 @@
import io.netty.channel.Channel;
import io.netty.channel.ChannelPromise;
+import java.time.Clock;
import java.util.Set;
import java.util.concurrent.CompletionStage;
import java.util.function.Consumer;
@@ -64,13 +65,15 @@ public interface BoltProtocol {
* @param routingContext the configured routing context
* @param channelInitializedPromise the promise to be notified when initialization is completed.
* @param notificationConfig the notification configuration
+ * @param clock the clock to use
*/
void initializeChannel(
String userAgent,
AuthToken authToken,
RoutingContext routingContext,
ChannelPromise channelInitializedPromise,
- NotificationConfig notificationConfig);
+ NotificationConfig notificationConfig,
+ Clock clock);
/**
* Prepare to close channel before it is closed.
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/LogoffMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/LogoffMessageEncoder.java
new file mode 100644
index 0000000000..ec55f1a077
--- /dev/null
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/LogoffMessageEncoder.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.messaging.encode;
+
+import static org.neo4j.driver.internal.util.Preconditions.checkArgument;
+
+import java.io.IOException;
+import org.neo4j.driver.internal.messaging.Message;
+import org.neo4j.driver.internal.messaging.MessageEncoder;
+import org.neo4j.driver.internal.messaging.ValuePacker;
+import org.neo4j.driver.internal.messaging.request.LogoffMessage;
+
+public class LogoffMessageEncoder implements MessageEncoder {
+ @Override
+ public void encode(Message message, ValuePacker packer) throws IOException {
+ checkArgument(message, LogoffMessage.class);
+ packer.packStructHeader(0, message.signature());
+ }
+}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/LogoffMessage.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/request/LogoffMessage.java
new file mode 100644
index 0000000000..fd475bca58
--- /dev/null
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/request/LogoffMessage.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.messaging.request;
+
+import org.neo4j.driver.internal.messaging.Message;
+
+public class LogoffMessage implements Message {
+ public static final byte SIGNATURE = 0x6B;
+
+ public static final LogoffMessage INSTANCE = new LogoffMessage();
+
+ private LogoffMessage() {}
+
+ @Override
+ public byte signature() {
+ return SIGNATURE;
+ }
+
+ @Override
+ public String toString() {
+ return "LOGOFF";
+ }
+}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3.java
index a5f964d777..3c9de0fa25 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3.java
@@ -28,6 +28,7 @@
import io.netty.channel.Channel;
import io.netty.channel.ChannelPromise;
+import java.time.Clock;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
@@ -83,7 +84,8 @@ public void initializeChannel(
AuthToken authToken,
RoutingContext routingContext,
ChannelPromise channelInitializedPromise,
- NotificationConfig notificationConfig) {
+ NotificationConfig notificationConfig,
+ Clock clock) {
var exception = verifyNotificationConfigSupported(notificationConfig);
if (exception != null) {
channelInitializedPromise.setFailure(exception);
@@ -108,7 +110,7 @@ public void initializeChannel(
notificationConfig);
}
- HelloResponseHandler handler = new HelloResponseHandler(channelInitializedPromise);
+ HelloResponseHandler handler = new HelloResponseHandler(channelInitializedPromise, clock);
messageDispatcher(channel).enqueue(handler);
channel.writeAndFlush(message, channel.voidPromise());
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v51/BoltProtocolV51.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v51/BoltProtocolV51.java
index a667f1247d..8c7fa70288 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v51/BoltProtocolV51.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/v51/BoltProtocolV51.java
@@ -19,21 +19,21 @@
package org.neo4j.driver.internal.messaging.v51;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.messageDispatcher;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setHelloStage;
import io.netty.channel.ChannelPromise;
+import java.time.Clock;
import java.util.Collections;
+import java.util.concurrent.CompletableFuture;
import org.neo4j.driver.AuthToken;
import org.neo4j.driver.NotificationConfig;
import org.neo4j.driver.internal.cluster.RoutingContext;
-import org.neo4j.driver.internal.handlers.HelloResponseHandler;
-import org.neo4j.driver.internal.handlers.LogonResponseHandler;
+import org.neo4j.driver.internal.handlers.HelloV51ResponseHandler;
import org.neo4j.driver.internal.messaging.BoltProtocol;
import org.neo4j.driver.internal.messaging.BoltProtocolVersion;
import org.neo4j.driver.internal.messaging.MessageFormat;
import org.neo4j.driver.internal.messaging.request.HelloMessage;
-import org.neo4j.driver.internal.messaging.request.LogonMessage;
import org.neo4j.driver.internal.messaging.v5.BoltProtocolV5;
-import org.neo4j.driver.internal.security.InternalAuthToken;
public class BoltProtocolV51 extends BoltProtocolV5 {
public static final BoltProtocolVersion VERSION = new BoltProtocolVersion(5, 1);
@@ -45,7 +45,8 @@ public void initializeChannel(
AuthToken authToken,
RoutingContext routingContext,
ChannelPromise channelInitializedPromise,
- NotificationConfig notificationConfig) {
+ NotificationConfig notificationConfig,
+ Clock clock) {
var exception = verifyNotificationConfigSupported(notificationConfig);
if (exception != null) {
channelInitializedPromise.setFailure(exception);
@@ -61,10 +62,11 @@ public void initializeChannel(
message = new HelloMessage(userAgent, Collections.emptyMap(), null, false, notificationConfig);
}
- messageDispatcher(channel).enqueue(new HelloResponseHandler(channel.voidPromise()));
- messageDispatcher(channel).enqueue(new LogonResponseHandler(channelInitializedPromise));
+ var helloFuture = new CompletableFuture();
+ setHelloStage(channel, helloFuture);
+ messageDispatcher(channel).enqueue(new HelloV51ResponseHandler(channel, helloFuture));
channel.write(message, channel.voidPromise());
- channel.writeAndFlush(new LogonMessage(((InternalAuthToken) authToken).toMap()));
+ channelInitializedPromise.setSuccess();
}
@Override
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v51/MessageWriterV51.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v51/MessageWriterV51.java
index d36f8af518..be40f72c9f 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v51/MessageWriterV51.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/v51/MessageWriterV51.java
@@ -27,6 +27,7 @@
import org.neo4j.driver.internal.messaging.encode.DiscardMessageEncoder;
import org.neo4j.driver.internal.messaging.encode.GoodbyeMessageEncoder;
import org.neo4j.driver.internal.messaging.encode.HelloMessageEncoder;
+import org.neo4j.driver.internal.messaging.encode.LogoffMessageEncoder;
import org.neo4j.driver.internal.messaging.encode.LogonMessageEncoder;
import org.neo4j.driver.internal.messaging.encode.PullMessageEncoder;
import org.neo4j.driver.internal.messaging.encode.ResetMessageEncoder;
@@ -38,6 +39,7 @@
import org.neo4j.driver.internal.messaging.request.DiscardMessage;
import org.neo4j.driver.internal.messaging.request.GoodbyeMessage;
import org.neo4j.driver.internal.messaging.request.HelloMessage;
+import org.neo4j.driver.internal.messaging.request.LogoffMessage;
import org.neo4j.driver.internal.messaging.request.LogonMessage;
import org.neo4j.driver.internal.messaging.request.PullMessage;
import org.neo4j.driver.internal.messaging.request.ResetMessage;
@@ -56,6 +58,7 @@ private static Map buildEncoders() {
Map result = Iterables.newHashMapWithSize(9);
result.put(HelloMessage.SIGNATURE, new HelloMessageEncoder());
result.put(LogonMessage.SIGNATURE, new LogonMessageEncoder());
+ result.put(LogoffMessage.SIGNATURE, new LogoffMessageEncoder());
result.put(GoodbyeMessage.SIGNATURE, new GoodbyeMessageEncoder());
result.put(RunWithMetadataMessage.SIGNATURE, new RunWithMetadataMessageEncoder());
result.put(RouteMessage.SIGNATURE, new RouteV44MessageEncoder());
diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v52/BoltProtocolV52.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v52/BoltProtocolV52.java
index 11b47f5d18..c542f2fe05 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v52/BoltProtocolV52.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/v52/BoltProtocolV52.java
@@ -18,50 +18,16 @@
*/
package org.neo4j.driver.internal.messaging.v52;
-import static org.neo4j.driver.internal.async.connection.ChannelAttributes.messageDispatcher;
-
-import io.netty.channel.ChannelPromise;
-import java.util.Collections;
-import org.neo4j.driver.AuthToken;
import org.neo4j.driver.NotificationConfig;
import org.neo4j.driver.exceptions.Neo4jException;
-import org.neo4j.driver.internal.cluster.RoutingContext;
-import org.neo4j.driver.internal.handlers.HelloResponseHandler;
-import org.neo4j.driver.internal.handlers.LogonResponseHandler;
import org.neo4j.driver.internal.messaging.BoltProtocol;
import org.neo4j.driver.internal.messaging.BoltProtocolVersion;
-import org.neo4j.driver.internal.messaging.request.HelloMessage;
-import org.neo4j.driver.internal.messaging.request.LogonMessage;
import org.neo4j.driver.internal.messaging.v51.BoltProtocolV51;
-import org.neo4j.driver.internal.security.InternalAuthToken;
public class BoltProtocolV52 extends BoltProtocolV51 {
public static final BoltProtocolVersion VERSION = new BoltProtocolVersion(5, 2);
public static final BoltProtocol INSTANCE = new BoltProtocolV52();
- @Override
- public void initializeChannel(
- String userAgent,
- AuthToken authToken,
- RoutingContext routingContext,
- ChannelPromise channelInitializedPromise,
- NotificationConfig notificationConfig) {
- var channel = channelInitializedPromise.channel();
- HelloMessage message;
-
- if (routingContext.isServerRoutingEnabled()) {
- message = new HelloMessage(
- userAgent, Collections.emptyMap(), routingContext.toMap(), false, notificationConfig);
- } else {
- message = new HelloMessage(userAgent, Collections.emptyMap(), null, false, notificationConfig);
- }
-
- messageDispatcher(channel).enqueue(new HelloResponseHandler(channel.voidPromise()));
- messageDispatcher(channel).enqueue(new LogonResponseHandler(channelInitializedPromise));
- channel.write(message, channel.voidPromise());
- channel.writeAndFlush(new LogonMessage(((InternalAuthToken) authToken).toMap()));
- }
-
@Override
protected Neo4jException verifyNotificationConfigSupported(NotificationConfig notificationConfig) {
return null;
diff --git a/driver/src/main/java/org/neo4j/driver/internal/security/ExpirationBasedAuthTokenManager.java b/driver/src/main/java/org/neo4j/driver/internal/security/ExpirationBasedAuthTokenManager.java
new file mode 100644
index 0000000000..cb1d95944e
--- /dev/null
+++ b/driver/src/main/java/org/neo4j/driver/internal/security/ExpirationBasedAuthTokenManager.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.security;
+
+import static java.util.Objects.requireNonNull;
+import static org.neo4j.driver.internal.util.Futures.failedFuture;
+import static org.neo4j.driver.internal.util.LockUtil.executeWithLock;
+
+import java.time.Clock;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.function.Supplier;
+import org.neo4j.driver.AuthToken;
+import org.neo4j.driver.AuthTokenAndExpiration;
+import org.neo4j.driver.AuthTokenManager;
+
+public class ExpirationBasedAuthTokenManager implements AuthTokenManager {
+ private final ReadWriteLock lock = new ReentrantReadWriteLock();
+ private final Supplier> freshTokenSupplier;
+ private final Clock clock;
+ private CompletableFuture tokenFuture;
+ private AuthTokenAndExpiration token;
+
+ public ExpirationBasedAuthTokenManager(
+ Supplier> freshTokenSupplier, Clock clock) {
+ this.freshTokenSupplier = freshTokenSupplier;
+ this.clock = clock;
+ }
+
+ public CompletionStage getToken() {
+ var validTokenFuture = executeWithLock(lock.readLock(), this::getValidTokenFuture);
+ if (validTokenFuture == null) {
+ var fetchFromUpstream = new AtomicBoolean();
+ validTokenFuture = executeWithLock(lock.writeLock(), () -> {
+ if (getValidTokenFuture() == null) {
+ tokenFuture = new CompletableFuture<>();
+ token = null;
+ fetchFromUpstream.set(true);
+ }
+ return tokenFuture;
+ });
+ if (fetchFromUpstream.get()) {
+ getFromUpstream().whenComplete(this::handleUpstreamResult);
+ }
+ }
+ return validTokenFuture;
+ }
+
+ public void onExpired(AuthToken authToken) {
+ executeWithLock(lock.writeLock(), () -> {
+ if (token != null && token.authToken().equals(authToken)) {
+ unsetTokenState();
+ }
+ });
+ }
+
+ private void handleUpstreamResult(AuthTokenAndExpiration authTokenAndExpiration, Throwable throwable) {
+ if (throwable != null) {
+ var previousTokenFuture = executeWithLock(lock.writeLock(), this::unsetTokenState);
+ // notify downstream consumers of the failure
+ previousTokenFuture.completeExceptionally(throwable);
+ } else {
+ if (isValid(authTokenAndExpiration)) {
+ var previousTokenFuture = executeWithLock(lock.writeLock(), this::unsetTokenState);
+ // notify downstream consumers of the invalid token
+ previousTokenFuture.completeExceptionally(
+ new IllegalStateException("invalid token served by upstream"));
+ } else {
+ var currentTokenFuture = executeWithLock(lock.writeLock(), () -> {
+ token = authTokenAndExpiration;
+ return tokenFuture;
+ });
+ currentTokenFuture.complete(authTokenAndExpiration.authToken());
+ }
+ }
+ }
+
+ private CompletableFuture unsetTokenState() {
+ var previousTokenFuture = tokenFuture;
+ tokenFuture = null;
+ token = null;
+ return previousTokenFuture;
+ }
+
+ private CompletionStage getFromUpstream() {
+ CompletionStage upstreamStage;
+ try {
+ upstreamStage = freshTokenSupplier.get();
+ requireNonNull(upstreamStage, "upstream supplied a null value");
+ } catch (Throwable t) {
+ upstreamStage = failedFuture(t);
+ }
+ return upstreamStage;
+ }
+
+ private boolean isValid(AuthTokenAndExpiration token) {
+ return token == null || token.expirationTimestamp() < clock.millis();
+ }
+
+ private CompletableFuture getValidTokenFuture() {
+ CompletableFuture validTokenFuture = null;
+ if (tokenFuture != null) {
+ if (token != null) {
+ var expirationTimestamp = token.expirationTimestamp();
+ validTokenFuture = expirationTimestamp > clock.millis() ? tokenFuture : null;
+ } else {
+ validTokenFuture = tokenFuture;
+ }
+ }
+ return validTokenFuture;
+ }
+}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/security/InternalAuthTokenAndExpiration.java b/driver/src/main/java/org/neo4j/driver/internal/security/InternalAuthTokenAndExpiration.java
new file mode 100644
index 0000000000..0e4d90fb6e
--- /dev/null
+++ b/driver/src/main/java/org/neo4j/driver/internal/security/InternalAuthTokenAndExpiration.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.security;
+
+import org.neo4j.driver.AuthToken;
+import org.neo4j.driver.AuthTokenAndExpiration;
+
+public record InternalAuthTokenAndExpiration(AuthToken authToken, long expirationTimestamp)
+ implements AuthTokenAndExpiration {}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/security/StaticAuthTokenManager.java b/driver/src/main/java/org/neo4j/driver/internal/security/StaticAuthTokenManager.java
new file mode 100644
index 0000000000..ecbbd1c2d2
--- /dev/null
+++ b/driver/src/main/java/org/neo4j/driver/internal/security/StaticAuthTokenManager.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.security;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.neo4j.driver.AuthToken;
+import org.neo4j.driver.AuthTokenManager;
+import org.neo4j.driver.exceptions.TokenExpiredException;
+
+public class StaticAuthTokenManager implements AuthTokenManager {
+ private final AtomicBoolean expired = new AtomicBoolean();
+ private final AuthToken authToken;
+
+ public StaticAuthTokenManager(AuthToken authToken) {
+ requireNonNull(authToken, "authToken must not be null");
+ this.authToken = authToken;
+ }
+
+ @Override
+ public CompletionStage getToken() {
+ return expired.get()
+ ? CompletableFuture.failedFuture(new TokenExpiredException(null, "authToken is expired"))
+ : CompletableFuture.completedFuture(authToken);
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {
+ if (authToken.equals(this.authToken)) {
+ expired.set(true);
+ }
+ }
+}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/security/ValidatingAuthTokenManager.java b/driver/src/main/java/org/neo4j/driver/internal/security/ValidatingAuthTokenManager.java
new file mode 100644
index 0000000000..9ac60a4ce9
--- /dev/null
+++ b/driver/src/main/java/org/neo4j/driver/internal/security/ValidatingAuthTokenManager.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.security;
+
+import static java.util.Objects.requireNonNull;
+import static java.util.concurrent.CompletableFuture.failedFuture;
+import static org.neo4j.driver.internal.util.Futures.completionExceptionCause;
+
+import java.util.Objects;
+import java.util.concurrent.CompletionStage;
+import org.neo4j.driver.AuthToken;
+import org.neo4j.driver.AuthTokenManager;
+import org.neo4j.driver.Logger;
+import org.neo4j.driver.Logging;
+import org.neo4j.driver.exceptions.AuthTokenManagerExecutionException;
+
+public class ValidatingAuthTokenManager implements AuthTokenManager {
+ private final Logger log;
+ private final AuthTokenManager delegate;
+
+ public ValidatingAuthTokenManager(AuthTokenManager delegate, Logging logging) {
+ requireNonNull(delegate, "delegate must not be null");
+ requireNonNull(logging, "logging must not be null");
+ this.delegate = delegate;
+ this.log = logging.getLog(getClass());
+ }
+
+ @Override
+ public CompletionStage getToken() {
+ CompletionStage tokenStage;
+ try {
+ tokenStage = delegate.getToken();
+ } catch (Throwable throwable) {
+ tokenStage = failedFuture(throwable);
+ }
+ if (tokenStage == null) {
+ tokenStage = failedFuture(new NullPointerException(String.format(
+ "null returned by %s.getToken method", delegate.getClass().getName())));
+ }
+ return tokenStage
+ .thenApply(token -> Objects.requireNonNull(token, "token must not be null"))
+ .handle((token, throwable) -> {
+ if (throwable != null) {
+ throw new AuthTokenManagerExecutionException(
+ String.format(
+ "invalid execution outcome on %s.getToken method",
+ delegate.getClass().getName()),
+ completionExceptionCause(throwable));
+ }
+ return token;
+ });
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {
+ requireNonNull(authToken, "authToken must not be null");
+ try {
+ delegate.onExpired(authToken);
+ } catch (Throwable throwable) {
+ log.warn(String.format(
+ "%s has been thrown by %s.onExpired method",
+ throwable.getClass().getName(), delegate.getClass().getName()));
+ log.debug(
+ String.format(
+ "%s has been thrown by %s.onExpired method",
+ throwable.getClass().getName(), delegate.getClass().getName()),
+ throwable);
+ }
+ }
+}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/spi/ConnectionPool.java b/driver/src/main/java/org/neo4j/driver/internal/spi/ConnectionPool.java
index dd8eef4c41..9e4ef4fda6 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/spi/ConnectionPool.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/spi/ConnectionPool.java
@@ -20,13 +20,14 @@
import java.util.Set;
import java.util.concurrent.CompletionStage;
+import org.neo4j.driver.AuthToken;
import org.neo4j.driver.internal.BoltServerAddress;
import org.neo4j.driver.net.ServerAddress;
public interface ConnectionPool {
String CONNECTION_POOL_CLOSED_ERROR_MESSAGE = "Pool closed";
- CompletionStage acquire(BoltServerAddress address);
+ CompletionStage acquire(BoltServerAddress address, AuthToken overrideAuthToken);
void retainAll(Set addressesToRetain);
diff --git a/driver/src/main/java/org/neo4j/driver/internal/spi/ConnectionProvider.java b/driver/src/main/java/org/neo4j/driver/internal/spi/ConnectionProvider.java
index bc95b94126..934189652c 100644
--- a/driver/src/main/java/org/neo4j/driver/internal/spi/ConnectionProvider.java
+++ b/driver/src/main/java/org/neo4j/driver/internal/spi/ConnectionProvider.java
@@ -36,4 +36,6 @@ public interface ConnectionProvider {
CompletionStage close();
CompletionStage supportsMultiDb();
+
+ CompletionStage supportsSessionAuth();
}
diff --git a/driver/src/main/java/org/neo4j/driver/internal/util/SessionAuthUtil.java b/driver/src/main/java/org/neo4j/driver/internal/util/SessionAuthUtil.java
new file mode 100644
index 0000000000..f7ec584e2c
--- /dev/null
+++ b/driver/src/main/java/org/neo4j/driver/internal/util/SessionAuthUtil.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.util;
+
+import org.neo4j.driver.internal.messaging.BoltProtocolVersion;
+import org.neo4j.driver.internal.messaging.v51.BoltProtocolV51;
+import org.neo4j.driver.internal.spi.Connection;
+
+public class SessionAuthUtil {
+ public static boolean supportsSessionAuth(Connection connection) {
+ return supportsSessionAuth(connection.protocol().version());
+ }
+
+ public static boolean supportsSessionAuth(BoltProtocolVersion version) {
+ return BoltProtocolV51.VERSION.compareTo(version) <= 0;
+ }
+}
diff --git a/driver/src/test/java/org/neo4j/driver/GraphDatabaseTest.java b/driver/src/test/java/org/neo4j/driver/GraphDatabaseTest.java
index e86e1d21a7..7e2ecd5fd7 100644
--- a/driver/src/test/java/org/neo4j/driver/GraphDatabaseTest.java
+++ b/driver/src/test/java/org/neo4j/driver/GraphDatabaseTest.java
@@ -26,24 +26,11 @@
import static org.neo4j.driver.Logging.none;
import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING;
-import io.netty.util.concurrent.EventExecutorGroup;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.URI;
-import java.util.Iterator;
-import java.util.List;
-import java.util.function.Supplier;
import org.junit.jupiter.api.Test;
import org.neo4j.driver.exceptions.ServiceUnavailableException;
-import org.neo4j.driver.internal.BoltServerAddress;
-import org.neo4j.driver.internal.DriverFactory;
-import org.neo4j.driver.internal.InternalDriver;
-import org.neo4j.driver.internal.cluster.Rediscovery;
-import org.neo4j.driver.internal.cluster.RoutingSettings;
-import org.neo4j.driver.internal.metrics.MetricsProvider;
-import org.neo4j.driver.internal.retry.RetryLogic;
-import org.neo4j.driver.internal.security.SecurityPlan;
-import org.neo4j.driver.internal.spi.ConnectionPool;
import org.neo4j.driver.testutil.TestUtil;
class GraphDatabaseTest {
@@ -106,6 +93,58 @@ void shouldFailToCreateEncryptedDriverWhenServerDoesNotRespond() throws IOExcept
testFailureWhenServerDoesNotRespond(true);
}
+ @Test
+ void shouldAcceptNullTokenOnFactoryWithString() {
+ AuthToken token = null;
+ GraphDatabase.driver("neo4j://host", token);
+ }
+
+ @Test
+ void shouldAcceptNullTokenOnFactoryWithUri() {
+ AuthToken token = null;
+ GraphDatabase.driver(URI.create("neo4j://host"), token);
+ }
+
+ @Test
+ void shouldAcceptNullTokenOnFactoryWithStringAndConfig() {
+ AuthToken token = null;
+ GraphDatabase.driver("neo4j://host", token, Config.defaultConfig());
+ }
+
+ @Test
+ void shouldAcceptNullTokenOnFactoryWithUriAndConfig() {
+ AuthToken token = null;
+ GraphDatabase.driver(URI.create("neo4j://host"), token, Config.defaultConfig());
+ }
+
+ @Test
+ void shouldRejectNullAuthTokenManagerOnFactoryWithString() {
+ AuthTokenManager manager = null;
+ assertThrows(NullPointerException.class, () -> GraphDatabase.driver("neo4j://host", manager));
+ }
+
+ @Test
+ void shouldRejectNullAuthTokenManagerOnFactoryWithUri() {
+ AuthTokenManager manager = null;
+ assertThrows(NullPointerException.class, () -> GraphDatabase.driver(URI.create("neo4j://host"), manager));
+ }
+
+ @Test
+ void shouldRejectNullAuthTokenManagerOnFactoryWithStringAndConfig() {
+ AuthTokenManager manager = null;
+ assertThrows(
+ NullPointerException.class,
+ () -> GraphDatabase.driver("neo4j://host", manager, Config.defaultConfig()));
+ }
+
+ @Test
+ void shouldRejectNullAuthTokenManagerOnFactoryWithUriAndConfig() {
+ AuthTokenManager manager = null;
+ assertThrows(
+ NullPointerException.class,
+ () -> GraphDatabase.driver(URI.create("neo4j://host"), manager, Config.defaultConfig()));
+ }
+
private static void testFailureWhenServerDoesNotRespond(boolean encrypted) throws IOException {
try (ServerSocket server = new ServerSocket(0)) // server that accepts connections but does not reply
{
@@ -131,26 +170,4 @@ private static Config createConfig(boolean encrypted, int timeoutMillis) {
return configBuilder.build();
}
-
- private static class MockSupplyingDriverFactory extends DriverFactory {
- private final Iterator driverIterator;
-
- private MockSupplyingDriverFactory(List drivers) {
- driverIterator = drivers.iterator();
- }
-
- @Override
- protected InternalDriver createRoutingDriver(
- SecurityPlan securityPlan,
- BoltServerAddress address,
- ConnectionPool connectionPool,
- EventExecutorGroup eventExecutorGroup,
- RoutingSettings routingSettings,
- RetryLogic retryLogic,
- MetricsProvider metricsProvider,
- Supplier rediscoverySupplier,
- Config config) {
- return driverIterator.next();
- }
- }
}
diff --git a/driver/src/test/java/org/neo4j/driver/ParametersTest.java b/driver/src/test/java/org/neo4j/driver/ParametersTest.java
index 15de822025..d7231b6991 100644
--- a/driver/src/test/java/org/neo4j/driver/ParametersTest.java
+++ b/driver/src/test/java/org/neo4j/driver/ParametersTest.java
@@ -112,6 +112,7 @@ private Session mockedSession() {
UNLIMITED_FETCH_SIZE,
DEV_NULL_LOGGING,
mock(BookmarkManager.class),
+ null,
null);
return new InternalSession(session);
}
diff --git a/driver/src/test/java/org/neo4j/driver/integration/ChannelConnectorImplIT.java b/driver/src/test/java/org/neo4j/driver/integration/ChannelConnectorImplIT.java
index 6073114a30..a95b7e3072 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/ChannelConnectorImplIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/ChannelConnectorImplIT.java
@@ -29,6 +29,7 @@
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING;
+import static org.neo4j.driver.internal.util.Neo4jFeature.BOLT_V51;
import static org.neo4j.driver.testutil.TestUtil.await;
import io.netty.bootstrap.Bootstrap;
@@ -48,6 +49,7 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
import org.neo4j.driver.AuthToken;
+import org.neo4j.driver.AuthTokenManager;
import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.RevocationCheckingStrategy;
import org.neo4j.driver.exceptions.AuthenticationException;
@@ -62,6 +64,8 @@
import org.neo4j.driver.internal.cluster.RoutingContext;
import org.neo4j.driver.internal.security.SecurityPlan;
import org.neo4j.driver.internal.security.SecurityPlanImpl;
+import org.neo4j.driver.internal.security.StaticAuthTokenManager;
+import org.neo4j.driver.internal.util.DisabledOnNeo4jWith;
import org.neo4j.driver.internal.util.FakeClock;
import org.neo4j.driver.testutil.DatabaseExtension;
import org.neo4j.driver.testutil.ParallelizableIT;
@@ -87,7 +91,7 @@ void tearDown() {
@Test
void shouldConnect() throws Exception {
- ChannelConnector connector = newConnector(neo4j.authToken());
+ ChannelConnector connector = newConnector(neo4j.authTokenManager());
ChannelFuture channelFuture = connector.connect(neo4j.address(), bootstrap);
assertTrue(channelFuture.await(10, TimeUnit.SECONDS));
@@ -99,7 +103,7 @@ void shouldConnect() throws Exception {
@Test
void shouldSetupHandlers() throws Exception {
- ChannelConnector connector = newConnector(neo4j.authToken(), trustAllCertificates(), 10_000);
+ ChannelConnector connector = newConnector(neo4j.authTokenManager(), trustAllCertificates(), 10_000);
ChannelFuture channelFuture = connector.connect(neo4j.address(), bootstrap);
assertTrue(channelFuture.await(10, TimeUnit.SECONDS));
@@ -114,7 +118,7 @@ void shouldSetupHandlers() throws Exception {
@Test
void shouldFailToConnectToWrongAddress() throws Exception {
- ChannelConnector connector = newConnector(neo4j.authToken());
+ ChannelConnector connector = newConnector(neo4j.authTokenManager());
ChannelFuture channelFuture = connector.connect(new BoltServerAddress("wrong-localhost"), bootstrap);
assertTrue(channelFuture.await(10, TimeUnit.SECONDS));
@@ -127,10 +131,12 @@ void shouldFailToConnectToWrongAddress() throws Exception {
assertFalse(channel.isActive());
}
+ // Beginning with Bolt 5.1 auth is not sent on HELLO message.
+ @DisabledOnNeo4jWith(BOLT_V51)
@Test
void shouldFailToConnectWithWrongCredentials() throws Exception {
AuthToken authToken = AuthTokens.basic("neo4j", "wrong-password");
- ChannelConnector connector = newConnector(authToken);
+ ChannelConnector connector = newConnector(new StaticAuthTokenManager(authToken));
ChannelFuture channelFuture = connector.connect(neo4j.address(), bootstrap);
assertTrue(channelFuture.await(10, TimeUnit.SECONDS));
@@ -143,7 +149,7 @@ void shouldFailToConnectWithWrongCredentials() throws Exception {
@Test
void shouldEnforceConnectTimeout() throws Exception {
- ChannelConnector connector = newConnector(neo4j.authToken(), 1000);
+ ChannelConnector connector = newConnector(neo4j.authTokenManager(), 1000);
// try connect to a non-routable ip address 10.0.0.0, it will never respond
ChannelFuture channelFuture = connector.connect(new BoltServerAddress("10.0.0.0"), bootstrap);
@@ -180,7 +186,7 @@ void shouldThrowServiceUnavailableExceptionOnFailureDuringConnect() throws Excep
}
});
- ChannelConnector connector = newConnector(neo4j.authToken());
+ ChannelConnector connector = newConnector(neo4j.authTokenManager());
ChannelFuture channelFuture = connector.connect(address, bootstrap);
// connect operation should fail with ServiceUnavailableException
@@ -192,7 +198,7 @@ private void testReadTimeoutOnConnect(SecurityPlan securityPlan) throws IOExcept
{
int timeoutMillis = 1_000;
BoltServerAddress address = new BoltServerAddress("localhost", server.getLocalPort());
- ChannelConnector connector = newConnector(neo4j.authToken(), securityPlan, timeoutMillis);
+ ChannelConnector connector = newConnector(neo4j.authTokenManager(), securityPlan, timeoutMillis);
ChannelFuture channelFuture = connector.connect(address, bootstrap);
@@ -201,17 +207,18 @@ private void testReadTimeoutOnConnect(SecurityPlan securityPlan) throws IOExcept
}
}
- private ChannelConnectorImpl newConnector(AuthToken authToken) throws Exception {
- return newConnector(authToken, Integer.MAX_VALUE);
+ private ChannelConnectorImpl newConnector(AuthTokenManager authTokenManager) throws Exception {
+ return newConnector(authTokenManager, Integer.MAX_VALUE);
}
- private ChannelConnectorImpl newConnector(AuthToken authToken, int connectTimeoutMillis) throws Exception {
- return newConnector(authToken, trustAllCertificates(), connectTimeoutMillis);
+ private ChannelConnectorImpl newConnector(AuthTokenManager authTokenManager, int connectTimeoutMillis)
+ throws Exception {
+ return newConnector(authTokenManager, trustAllCertificates(), connectTimeoutMillis);
}
private ChannelConnectorImpl newConnector(
- AuthToken authToken, SecurityPlan securityPlan, int connectTimeoutMillis) {
- ConnectionSettings settings = new ConnectionSettings(authToken, "test", connectTimeoutMillis);
+ AuthTokenManager authTokenManager, SecurityPlan securityPlan, int connectTimeoutMillis) {
+ ConnectionSettings settings = new ConnectionSettings(authTokenManager, "test", connectTimeoutMillis);
return new ChannelConnectorImpl(
settings,
securityPlan,
diff --git a/driver/src/test/java/org/neo4j/driver/integration/ConnectionHandlingIT.java b/driver/src/test/java/org/neo4j/driver/integration/ConnectionHandlingIT.java
index cc2e5c8155..e960bfbf48 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/ConnectionHandlingIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/ConnectionHandlingIT.java
@@ -47,6 +47,7 @@
import org.junit.jupiter.api.extension.RegisterExtension;
import org.mockito.Mockito;
import org.neo4j.driver.AuthToken;
+import org.neo4j.driver.AuthTokenManager;
import org.neo4j.driver.Config;
import org.neo4j.driver.Driver;
import org.neo4j.driver.Logging;
@@ -92,9 +93,14 @@ class ConnectionHandlingIT {
@BeforeEach
void createDriver() {
DriverFactoryWithConnectionPool driverFactory = new DriverFactoryWithConnectionPool();
- AuthToken auth = neo4j.authToken();
+ var authTokenProvider = neo4j.authTokenManager();
driver = driverFactory.newInstance(
- neo4j.uri(), auth, Config.builder().withFetchSize(1).build(), SecurityPlanImpl.insecure(), null, null);
+ neo4j.uri(),
+ authTokenProvider,
+ Config.builder().withFetchSize(1).build(),
+ SecurityPlanImpl.insecure(),
+ null,
+ null);
connectionPool = driverFactory.connectionPool;
connectionPool.startMemorizing(); // start memorizing connections after driver creation
}
@@ -447,14 +453,14 @@ private static class DriverFactoryWithConnectionPool extends DriverFactory {
@Override
protected ConnectionPool createConnectionPool(
- AuthToken authToken,
+ AuthTokenManager authTokenManager,
SecurityPlan securityPlan,
Bootstrap bootstrap,
MetricsProvider ignored,
Config config,
boolean ownsEventLoopGroup,
RoutingContext routingContext) {
- ConnectionSettings connectionSettings = new ConnectionSettings(authToken, "test", 1000);
+ ConnectionSettings connectionSettings = new ConnectionSettings(authTokenManager, "test", 1000);
PoolSettings poolSettings = new PoolSettings(
config.maxConnectionPoolSize(),
config.connectionAcquisitionTimeoutMillis(),
@@ -488,8 +494,8 @@ void startMemorizing() {
}
@Override
- public CompletionStage acquire(final BoltServerAddress address) {
- Connection connection = await(super.acquire(address));
+ public CompletionStage acquire(final BoltServerAddress address, AuthToken overrideAuthToken) {
+ Connection connection = await(super.acquire(address, overrideAuthToken));
if (memorize) {
// this connection pool returns spies so spies will be returned to the pool
diff --git a/driver/src/test/java/org/neo4j/driver/integration/ConnectionPoolIT.java b/driver/src/test/java/org/neo4j/driver/integration/ConnectionPoolIT.java
index 29a3130a18..c067de57de 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/ConnectionPoolIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/ConnectionPoolIT.java
@@ -71,7 +71,7 @@ void cleanup() throws Exception {
@Test
void shouldRecoverFromDownedServer() throws Throwable {
// Given a driver
- driver = GraphDatabase.driver(neo4j.uri(), neo4j.authToken());
+ driver = GraphDatabase.driver(neo4j.uri(), neo4j.authTokenManager());
// and given I'm heavily using it to acquire and release sessions
sessionGrabber = new SessionGrabber(driver);
@@ -95,7 +95,7 @@ void shouldDisposeChannelsBasedOnMaxLifetime() throws Exception {
.withMaxConnectionLifetime(maxConnLifetimeHours, TimeUnit.HOURS)
.build();
driver = driverFactory.newInstance(
- neo4j.uri(), neo4j.authToken(), config, SecurityPlanImpl.insecure(), null, null);
+ neo4j.uri(), neo4j.authTokenManager(), config, SecurityPlanImpl.insecure(), null, null);
// force driver create channel and return it to the pool
startAndCloseTransactions(driver, 1);
@@ -137,7 +137,7 @@ void shouldRespectMaxConnectionPoolSize() {
.withEventLoopThreads(1)
.build();
- driver = GraphDatabase.driver(neo4j.uri(), neo4j.authToken(), config);
+ driver = GraphDatabase.driver(neo4j.uri(), neo4j.authTokenManager(), config);
ClientException e =
assertThrows(ClientException.class, () -> startAndCloseTransactions(driver, maxPoolSize + 1));
diff --git a/driver/src/test/java/org/neo4j/driver/integration/DirectDriverIT.java b/driver/src/test/java/org/neo4j/driver/integration/DirectDriverIT.java
index 0f5680244b..43e3fd8bc9 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/DirectDriverIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/DirectDriverIT.java
@@ -55,7 +55,7 @@ void shouldAllowIPv6Address() {
BoltServerAddress address = new BoltServerAddress(uri);
// When
- driver = GraphDatabase.driver(uri, neo4j.authToken());
+ driver = GraphDatabase.driver(uri, neo4j.authTokenManager());
// Then
assertThat(driver, is(directDriverWithAddress(address)));
@@ -68,7 +68,7 @@ void shouldRejectInvalidAddress() {
// When & Then
IllegalArgumentException e =
- assertThrows(IllegalArgumentException.class, () -> GraphDatabase.driver(uri, neo4j.authToken()));
+ assertThrows(IllegalArgumentException.class, () -> GraphDatabase.driver(uri, neo4j.authTokenManager()));
assertThat(e.getMessage(), equalTo("Scheme must not be null"));
}
@@ -79,7 +79,7 @@ void shouldRegisterSingleServer() {
BoltServerAddress address = new BoltServerAddress(uri);
// When
- driver = GraphDatabase.driver(uri, neo4j.authToken());
+ driver = GraphDatabase.driver(uri, neo4j.authTokenManager());
// Then
assertThat(driver, is(directDriverWithAddress(address)));
diff --git a/driver/src/test/java/org/neo4j/driver/integration/DriverCloseIT.java b/driver/src/test/java/org/neo4j/driver/integration/DriverCloseIT.java
index 442a76964f..4d0cd0e845 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/DriverCloseIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/DriverCloseIT.java
@@ -85,6 +85,6 @@ void useSessionAfterDriverIsClosed() {
}
private static Driver createDriver() {
- return GraphDatabase.driver(neo4j.uri(), neo4j.authToken());
+ return GraphDatabase.driver(neo4j.uri(), neo4j.authTokenManager());
}
}
diff --git a/driver/src/test/java/org/neo4j/driver/integration/EncryptionIT.java b/driver/src/test/java/org/neo4j/driver/integration/EncryptionIT.java
index b6c366ea3a..99ed11db21 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/EncryptionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/EncryptionIT.java
@@ -97,7 +97,7 @@ private void testMatchingEncryption(BoltTlsLevel tlsLevel, boolean driverEncrypt
URI uri = URI.create(String.format(
"%s://%s:%s", scheme, neo4j.uri().getHost(), neo4j.uri().getPort()));
- try (Driver driver = GraphDatabase.driver(uri, neo4j.authToken(), config)) {
+ try (Driver driver = GraphDatabase.driver(uri, neo4j.authTokenManager(), config)) {
assertThat(driver.isEncrypted(), equalTo(driverEncrypted));
try (Session session = driver.session()) {
@@ -116,9 +116,9 @@ private void testMismatchingEncryption(BoltTlsLevel tlsLevel, boolean driverEncr
neo4j.deleteAndStartNeo4j(tlsConfig);
Config config = newConfig(driverEncrypted);
- ServiceUnavailableException e = assertThrows(
- ServiceUnavailableException.class, () -> GraphDatabase.driver(neo4j.uri(), neo4j.authToken(), config)
- .verifyConnectivity());
+ ServiceUnavailableException e = assertThrows(ServiceUnavailableException.class, () -> GraphDatabase.driver(
+ neo4j.uri(), neo4j.authTokenManager(), config)
+ .verifyConnectivity());
assertThat(e.getMessage(), startsWith("Connection to the database terminated"));
}
diff --git a/driver/src/test/java/org/neo4j/driver/integration/ErrorIT.java b/driver/src/test/java/org/neo4j/driver/integration/ErrorIT.java
index 95c24f2778..ed9239d539 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/ErrorIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/ErrorIT.java
@@ -48,7 +48,6 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInfo;
import org.junit.jupiter.api.extension.RegisterExtension;
-import org.neo4j.driver.AuthToken;
import org.neo4j.driver.Config;
import org.neo4j.driver.Driver;
import org.neo4j.driver.GraphDatabase;
@@ -258,12 +257,12 @@ private Throwable testChannelErrorHandling(Consumer messag
new ChannelTrackingDriverFactoryWithFailingMessageFormat(new FakeClock());
URI uri = session.uri();
- AuthToken authToken = session.authToken();
+ var authTokenProvider = session.authTokenManager();
Config config = Config.builder().withLogging(DEV_NULL_LOGGING).build();
Throwable queryError = null;
try (Driver driver =
- driverFactory.newInstance(uri, authToken, config, SecurityPlanImpl.insecure(), null, null)) {
+ driverFactory.newInstance(uri, authTokenProvider, config, SecurityPlanImpl.insecure(), null, null)) {
driver.verifyConnectivity();
try (Session session = driver.session()) {
messageFormatSetup.accept(driverFactory.getFailingMessageFormat());
diff --git a/driver/src/test/java/org/neo4j/driver/integration/GraphDatabaseAuthClusterIT.java b/driver/src/test/java/org/neo4j/driver/integration/GraphDatabaseAuthClusterIT.java
new file mode 100644
index 0000000000..a9db6a0dcf
--- /dev/null
+++ b/driver/src/test/java/org/neo4j/driver/integration/GraphDatabaseAuthClusterIT.java
@@ -0,0 +1,641 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.integration;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.reactivestreams.FlowAdapters.toPublisher;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledIfSystemProperty;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.neo4j.driver.AuthToken;
+import org.neo4j.driver.AuthTokenManager;
+import org.neo4j.driver.GraphDatabase;
+import org.neo4j.driver.async.AsyncSession;
+import org.neo4j.driver.async.ResultCursor;
+import org.neo4j.driver.exceptions.AuthTokenManagerExecutionException;
+import org.neo4j.driver.reactive.ReactiveSession;
+import org.neo4j.driver.testutil.cc.LocalOrRemoteClusterExtension;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+@DisabledIfSystemProperty(named = "skipDockerTests", matches = "^true$")
+class GraphDatabaseAuthClusterIT {
+ @RegisterExtension
+ static final LocalOrRemoteClusterExtension clusterRule = new LocalOrRemoteClusterExtension();
+
+ @Test
+ void shouldEmitNullStageAsErrorOnDiscovery() {
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return null;
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager);
+ var session = driver.session()) {
+ assertThrows(AuthTokenManagerExecutionException.class, () -> session.run("RETURN 1"));
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnQueryExecution() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get() ? null : clusterRule.getAuthToken().getToken();
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager);
+ var session = driver.session()) {
+ session.run("RETURN 1").consume();
+ returnNull.set(true);
+ assertThrows(AuthTokenManagerExecutionException.class, () -> session.run("RETURN 1"));
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnQueryExecutionAndRecoverIfSubsequentStageIsValid() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get() ? null : clusterRule.getAuthToken().getToken();
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager);
+ var session = driver.session()) {
+ session.run("RETURN 1").consume();
+ returnNull.set(true);
+ assertThrows(AuthTokenManagerExecutionException.class, () -> session.run("RETURN 1"));
+ returnNull.set(false);
+ session.run("RETURN 1").consume();
+ }
+ }
+
+ @Test
+ void shouldEmitInvalidTokenAsErrorOnDiscovery() {
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return CompletableFuture.completedFuture(null);
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager);
+ var session = driver.session()) {
+ var exception = assertThrows(AuthTokenManagerExecutionException.class, () -> session.run("RETURN 1"));
+ assertTrue(exception.getCause() instanceof NullPointerException);
+ }
+ }
+
+ @Test
+ void shouldInvalidTokenAsErrorOnQueryExecution() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get()
+ ? CompletableFuture.completedFuture(null)
+ : clusterRule.getAuthToken().getToken();
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager);
+ var session = driver.session()) {
+ session.run("RETURN 1").consume();
+ returnNull.set(true);
+ assertThrows(AuthTokenManagerExecutionException.class, () -> session.run("RETURN 1"));
+ }
+ }
+
+ @Test
+ void shouldInvalidTokenAsErrorOnQueryExecutionAndRecoverIfSubsequentStageIsValid() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get()
+ ? CompletableFuture.completedFuture(null)
+ : clusterRule.getAuthToken().getToken();
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager);
+ var session = driver.session()) {
+ session.run("RETURN 1").consume();
+ returnNull.set(true);
+ assertThrows(AuthTokenManagerExecutionException.class, () -> session.run("RETURN 1"));
+ returnNull.set(false);
+ session.run("RETURN 1").consume();
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnDiscoveryAsync() {
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return null;
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(AsyncSession.class);
+ var exception = assertThrows(
+ CompletionException.class,
+ () -> session.runAsync("RETURN 1").toCompletableFuture().join());
+ assertTrue(exception.getCause() instanceof AuthTokenManagerExecutionException);
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnQueryExecutionAsync() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get() ? null : clusterRule.getAuthToken().getToken();
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(AsyncSession.class);
+ session.runAsync("RETURN 1")
+ .thenCompose(ResultCursor::consumeAsync)
+ .toCompletableFuture()
+ .join();
+ returnNull.set(true);
+ var exception = assertThrows(
+ CompletionException.class,
+ () -> session.runAsync("RETURN 1").toCompletableFuture().join());
+ assertTrue(exception.getCause() instanceof AuthTokenManagerExecutionException);
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnQueryExecutionAndRecoverIfSubsequentStageIsValidAsync() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get() ? null : clusterRule.getAuthToken().getToken();
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(AsyncSession.class);
+ session.runAsync("RETURN 1")
+ .thenCompose(ResultCursor::consumeAsync)
+ .toCompletableFuture()
+ .join();
+ returnNull.set(true);
+ var exception = assertThrows(
+ CompletionException.class,
+ () -> session.runAsync("RETURN 1").toCompletableFuture().join());
+ assertTrue(exception.getCause() instanceof AuthTokenManagerExecutionException);
+ returnNull.set(false);
+ session.runAsync("RETURN 1")
+ .thenCompose(ResultCursor::consumeAsync)
+ .toCompletableFuture()
+ .join();
+ }
+ }
+
+ @Test
+ void shouldEmitInvalidTokenAsErrorOnDiscoveryAsync() {
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return CompletableFuture.completedFuture(null);
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(AsyncSession.class);
+ var exception = assertThrows(
+ CompletionException.class,
+ () -> session.runAsync("RETURN 1").toCompletableFuture().join());
+ assertTrue(exception.getCause() instanceof AuthTokenManagerExecutionException);
+ assertTrue(exception.getCause().getCause() instanceof NullPointerException);
+ }
+ }
+
+ @Test
+ void shouldInvalidTokenAsErrorOnQueryExecutionAsync() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get()
+ ? CompletableFuture.completedFuture(null)
+ : clusterRule.getAuthToken().getToken();
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(AsyncSession.class);
+ session.runAsync("RETURN 1")
+ .thenCompose(ResultCursor::consumeAsync)
+ .toCompletableFuture()
+ .join();
+ returnNull.set(true);
+ var exception = assertThrows(
+ CompletionException.class,
+ () -> session.runAsync("RETURN 1").toCompletableFuture().join());
+ assertTrue(exception.getCause() instanceof AuthTokenManagerExecutionException);
+ assertTrue(exception.getCause().getCause() instanceof NullPointerException);
+ }
+ }
+
+ @Test
+ void shouldInvalidTokenAsErrorOnQueryExecutionAndRecoverIfSubsequentStageIsValidAsync() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get()
+ ? CompletableFuture.completedFuture(null)
+ : clusterRule.getAuthToken().getToken();
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(AsyncSession.class);
+ session.runAsync("RETURN 1")
+ .thenCompose(ResultCursor::consumeAsync)
+ .toCompletableFuture()
+ .join();
+ returnNull.set(true);
+ var exception = assertThrows(
+ CompletionException.class,
+ () -> session.runAsync("RETURN 1").toCompletableFuture().join());
+ assertTrue(exception.getCause() instanceof AuthTokenManagerExecutionException);
+ assertTrue(exception.getCause().getCause() instanceof NullPointerException);
+ returnNull.set(false);
+ session.runAsync("RETURN 1")
+ .thenCompose(ResultCursor::consumeAsync)
+ .toCompletableFuture()
+ .join();
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnDiscoveryFlux() {
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return null;
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(ReactiveSession.class);
+ StepVerifier.create(toPublisher(session.run("RETURN 1")))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException)
+ .verify();
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnQueryExecutionFlux() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get() ? null : clusterRule.getAuthToken().getToken();
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(ReactiveSession.class);
+ StepVerifier.create(Mono.fromDirect(toPublisher(session.run("RETURN 1")))
+ .flatMap(result -> Mono.fromDirect(toPublisher(result.consume()))))
+ .expectNextCount(1)
+ .verifyComplete();
+ returnNull.set(true);
+ StepVerifier.create(toPublisher(session.run("RETURN 1")))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException)
+ .verify();
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnQueryExecutionAndRecoverIfSubsequentStageIsValidFlux() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get() ? null : clusterRule.getAuthToken().getToken();
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(ReactiveSession.class);
+ StepVerifier.create(Mono.fromDirect(toPublisher(session.run("RETURN 1")))
+ .flatMap(result -> Mono.fromDirect(toPublisher(result.consume()))))
+ .expectNextCount(1)
+ .verifyComplete();
+ returnNull.set(true);
+ StepVerifier.create(toPublisher(session.run("RETURN 1")))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException)
+ .verify();
+ returnNull.set(false);
+ StepVerifier.create(Mono.fromDirect(toPublisher(session.run("RETURN 1")))
+ .flatMap(result -> Mono.fromDirect(toPublisher(result.consume()))))
+ .expectNextCount(1)
+ .verifyComplete();
+ }
+ }
+
+ @Test
+ void shouldEmitInvalidTokenAsErrorOnDiscoveryFlux() {
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return CompletableFuture.completedFuture(null);
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(ReactiveSession.class);
+ StepVerifier.create(toPublisher(session.run("RETURN 1")))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException
+ && error.getCause() instanceof NullPointerException)
+ .verify();
+ }
+ }
+
+ @Test
+ void shouldInvalidTokenAsErrorOnQueryExecutionFlux() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get()
+ ? CompletableFuture.completedFuture(null)
+ : clusterRule.getAuthToken().getToken();
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(ReactiveSession.class);
+ StepVerifier.create(Mono.fromDirect(toPublisher(session.run("RETURN 1")))
+ .flatMap(result -> Mono.fromDirect(toPublisher(result.consume()))))
+ .expectNextCount(1)
+ .verifyComplete();
+ returnNull.set(true);
+ StepVerifier.create(toPublisher(session.run("RETURN 1")))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException
+ && error.getCause() instanceof NullPointerException)
+ .verify();
+ }
+ }
+
+ @Test
+ void shouldInvalidTokenAsErrorOnQueryExecutionAndRecoverIfSubsequentStageIsValidFlux() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get()
+ ? CompletableFuture.completedFuture(null)
+ : clusterRule.getAuthToken().getToken();
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(ReactiveSession.class);
+ StepVerifier.create(Mono.fromDirect(toPublisher(session.run("RETURN 1")))
+ .flatMap(result -> Mono.fromDirect(toPublisher(result.consume()))))
+ .expectNextCount(1)
+ .verifyComplete();
+ returnNull.set(true);
+ StepVerifier.create(toPublisher(session.run("RETURN 1")))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException
+ && error.getCause() instanceof NullPointerException)
+ .verify();
+ returnNull.set(false);
+ StepVerifier.create(Mono.fromDirect(toPublisher(session.run("RETURN 1")))
+ .flatMap(result -> Mono.fromDirect(toPublisher(result.consume()))))
+ .expectNextCount(1)
+ .verifyComplete();
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnDiscoveryReactiveStreams() {
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return null;
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(org.neo4j.driver.reactivestreams.ReactiveSession.class);
+ StepVerifier.create(session.run("RETURN 1"))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException)
+ .verify();
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnQueryExecutionReactiveStreams() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get() ? null : clusterRule.getAuthToken().getToken();
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(org.neo4j.driver.reactivestreams.ReactiveSession.class);
+ StepVerifier.create(Mono.fromDirect(session.run("RETURN 1"))
+ .flatMap(result -> Mono.fromDirect(result.consume())))
+ .expectNextCount(1)
+ .verifyComplete();
+ returnNull.set(true);
+ StepVerifier.create(session.run("RETURN 1"))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException)
+ .verify();
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnQueryExecutionAndRecoverIfSubsequentStageIsValidReactiveStreams() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get() ? null : clusterRule.getAuthToken().getToken();
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(org.neo4j.driver.reactivestreams.ReactiveSession.class);
+ StepVerifier.create(Mono.fromDirect(session.run("RETURN 1"))
+ .flatMap(result -> Mono.fromDirect(result.consume())))
+ .expectNextCount(1)
+ .verifyComplete();
+ returnNull.set(true);
+ StepVerifier.create(session.run("RETURN 1"))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException)
+ .verify();
+ returnNull.set(false);
+ StepVerifier.create(Mono.fromDirect(session.run("RETURN 1"))
+ .flatMap(result -> Mono.fromDirect(result.consume())))
+ .expectNextCount(1)
+ .verifyComplete();
+ }
+ }
+
+ @Test
+ void shouldEmitInvalidTokenAsErrorOnDiscoveryReactiveStreams() {
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return CompletableFuture.completedFuture(null);
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(org.neo4j.driver.reactivestreams.ReactiveSession.class);
+ StepVerifier.create(session.run("RETURN 1"))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException
+ && error.getCause() instanceof NullPointerException)
+ .verify();
+ }
+ }
+
+ @Test
+ void shouldInvalidTokenAsErrorOnQueryExecutionReactiveStreams() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get()
+ ? CompletableFuture.completedFuture(null)
+ : clusterRule.getAuthToken().getToken();
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(org.neo4j.driver.reactivestreams.ReactiveSession.class);
+ StepVerifier.create(Mono.fromDirect(session.run("RETURN 1"))
+ .flatMap(result -> Mono.fromDirect(result.consume())))
+ .expectNextCount(1)
+ .verifyComplete();
+ returnNull.set(true);
+ StepVerifier.create(session.run("RETURN 1"))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException
+ && error.getCause() instanceof NullPointerException)
+ .verify();
+ }
+ }
+
+ @Test
+ void shouldInvalidTokenAsErrorOnQueryExecutionAndRecoverIfSubsequentStageIsValidReactiveStreams() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get()
+ ? CompletableFuture.completedFuture(null)
+ : clusterRule.getAuthToken().getToken();
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(clusterRule.getClusterUri(), manager)) {
+ var session = driver.session(org.neo4j.driver.reactivestreams.ReactiveSession.class);
+ StepVerifier.create(Mono.fromDirect(session.run("RETURN 1"))
+ .flatMap(result -> Mono.fromDirect(result.consume())))
+ .expectNextCount(1)
+ .verifyComplete();
+ returnNull.set(true);
+ StepVerifier.create(session.run("RETURN 1"))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException
+ && error.getCause() instanceof NullPointerException)
+ .verify();
+ returnNull.set(false);
+ StepVerifier.create(Mono.fromDirect(session.run("RETURN 1"))
+ .flatMap(result -> Mono.fromDirect(result.consume())))
+ .expectNextCount(1)
+ .verifyComplete();
+ }
+ }
+}
diff --git a/driver/src/test/java/org/neo4j/driver/integration/GraphDatabaseAuthDirectIT.java b/driver/src/test/java/org/neo4j/driver/integration/GraphDatabaseAuthDirectIT.java
new file mode 100644
index 0000000000..13ba46d749
--- /dev/null
+++ b/driver/src/test/java/org/neo4j/driver/integration/GraphDatabaseAuthDirectIT.java
@@ -0,0 +1,640 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.integration;
+
+import static java.util.concurrent.CompletableFuture.completedFuture;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.reactivestreams.FlowAdapters.toPublisher;
+
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.neo4j.driver.AuthToken;
+import org.neo4j.driver.AuthTokenManager;
+import org.neo4j.driver.AuthTokens;
+import org.neo4j.driver.GraphDatabase;
+import org.neo4j.driver.async.AsyncSession;
+import org.neo4j.driver.async.ResultCursor;
+import org.neo4j.driver.exceptions.AuthTokenManagerExecutionException;
+import org.neo4j.driver.reactive.ReactiveSession;
+import org.neo4j.driver.testutil.DatabaseExtension;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+class GraphDatabaseAuthDirectIT {
+ @RegisterExtension
+ static final DatabaseExtension neo4j = new DatabaseExtension();
+
+ @Test
+ void shouldEmitNullStageAsErrorOnInitialInteraction() {
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return null;
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager);
+ var session = driver.session()) {
+ assertThrows(AuthTokenManagerExecutionException.class, () -> session.run("RETURN 1"));
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnQueryExecution() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get() ? null : completedFuture(AuthTokens.basic("neo4j", neo4j.adminPassword()));
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager);
+ var session = driver.session()) {
+ session.run("RETURN 1").consume();
+ returnNull.set(true);
+ assertThrows(AuthTokenManagerExecutionException.class, () -> session.run("RETURN 1"));
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnQueryExecutionAndRecoverIfSubsequentStageIsValid() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get() ? null : completedFuture(AuthTokens.basic("neo4j", neo4j.adminPassword()));
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager);
+ var session = driver.session()) {
+ session.run("RETURN 1").consume();
+ returnNull.set(true);
+ assertThrows(AuthTokenManagerExecutionException.class, () -> session.run("RETURN 1"));
+ returnNull.set(false);
+ session.run("RETURN 1").consume();
+ }
+ }
+
+ @Test
+ void shouldEmitInvalidTokenAsErrorOnInitialInteraction() {
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return completedFuture(null);
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager);
+ var session = driver.session()) {
+ var exception = assertThrows(AuthTokenManagerExecutionException.class, () -> session.run("RETURN 1"));
+ assertTrue(exception.getCause() instanceof NullPointerException);
+ }
+ }
+
+ @Test
+ void shouldInvalidTokenAsErrorOnQueryExecution() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get()
+ ? completedFuture(null)
+ : completedFuture(AuthTokens.basic("neo4j", neo4j.adminPassword()));
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager);
+ var session = driver.session()) {
+ session.run("RETURN 1").consume();
+ returnNull.set(true);
+ assertThrows(AuthTokenManagerExecutionException.class, () -> session.run("RETURN 1"));
+ }
+ }
+
+ @Test
+ void shouldInvalidTokenAsErrorOnQueryExecutionAndRecoverIfSubsequentStageIsValid() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get()
+ ? completedFuture(null)
+ : completedFuture(AuthTokens.basic("neo4j", neo4j.adminPassword()));
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager);
+ var session = driver.session()) {
+ session.run("RETURN 1").consume();
+ returnNull.set(true);
+ assertThrows(AuthTokenManagerExecutionException.class, () -> session.run("RETURN 1"));
+ returnNull.set(false);
+ session.run("RETURN 1").consume();
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnInitialInteractionAsync() {
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return null;
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(AsyncSession.class);
+ var exception = assertThrows(
+ CompletionException.class,
+ () -> session.runAsync("RETURN 1").toCompletableFuture().join());
+ assertTrue(exception.getCause() instanceof AuthTokenManagerExecutionException);
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnQueryExecutionAsync() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get() ? null : completedFuture(AuthTokens.basic("neo4j", neo4j.adminPassword()));
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(AsyncSession.class);
+ session.runAsync("RETURN 1")
+ .thenCompose(ResultCursor::consumeAsync)
+ .toCompletableFuture()
+ .join();
+ returnNull.set(true);
+ var exception = assertThrows(
+ CompletionException.class,
+ () -> session.runAsync("RETURN 1").toCompletableFuture().join());
+ assertTrue(exception.getCause() instanceof AuthTokenManagerExecutionException);
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnQueryExecutionAndRecoverIfSubsequentStageIsValidAsync() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get() ? null : completedFuture(AuthTokens.basic("neo4j", neo4j.adminPassword()));
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(AsyncSession.class);
+ session.runAsync("RETURN 1")
+ .thenCompose(ResultCursor::consumeAsync)
+ .toCompletableFuture()
+ .join();
+ returnNull.set(true);
+ var exception = assertThrows(
+ CompletionException.class,
+ () -> session.runAsync("RETURN 1").toCompletableFuture().join());
+ assertTrue(exception.getCause() instanceof AuthTokenManagerExecutionException);
+ returnNull.set(false);
+ session.runAsync("RETURN 1")
+ .thenCompose(ResultCursor::consumeAsync)
+ .toCompletableFuture()
+ .join();
+ }
+ }
+
+ @Test
+ void shouldEmitInvalidTokenAsErrorOnInitialInteractionAsync() {
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return completedFuture(null);
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(AsyncSession.class);
+ var exception = assertThrows(
+ CompletionException.class,
+ () -> session.runAsync("RETURN 1").toCompletableFuture().join());
+ assertTrue(exception.getCause() instanceof AuthTokenManagerExecutionException);
+ assertTrue(exception.getCause().getCause() instanceof NullPointerException);
+ }
+ }
+
+ @Test
+ void shouldInvalidTokenAsErrorOnQueryExecutionAsync() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get()
+ ? completedFuture(null)
+ : completedFuture(AuthTokens.basic("neo4j", neo4j.adminPassword()));
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(AsyncSession.class);
+ session.runAsync("RETURN 1")
+ .thenCompose(ResultCursor::consumeAsync)
+ .toCompletableFuture()
+ .join();
+ returnNull.set(true);
+ var exception = assertThrows(
+ CompletionException.class,
+ () -> session.runAsync("RETURN 1").toCompletableFuture().join());
+ assertTrue(exception.getCause() instanceof AuthTokenManagerExecutionException);
+ assertTrue(exception.getCause().getCause() instanceof NullPointerException);
+ }
+ }
+
+ @Test
+ void shouldInvalidTokenAsErrorOnQueryExecutionAndRecoverIfSubsequentStageIsValidAsync() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get()
+ ? completedFuture(null)
+ : completedFuture(AuthTokens.basic("neo4j", neo4j.adminPassword()));
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(AsyncSession.class);
+ session.runAsync("RETURN 1")
+ .thenCompose(ResultCursor::consumeAsync)
+ .toCompletableFuture()
+ .join();
+ returnNull.set(true);
+ var exception = assertThrows(
+ CompletionException.class,
+ () -> session.runAsync("RETURN 1").toCompletableFuture().join());
+ assertTrue(exception.getCause() instanceof AuthTokenManagerExecutionException);
+ assertTrue(exception.getCause().getCause() instanceof NullPointerException);
+ returnNull.set(false);
+ session.runAsync("RETURN 1")
+ .thenCompose(ResultCursor::consumeAsync)
+ .toCompletableFuture()
+ .join();
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnInitialInteractionFlux() {
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return null;
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(ReactiveSession.class);
+ StepVerifier.create(toPublisher(session.run("RETURN 1")))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException)
+ .verify();
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnQueryExecutionFlux() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get() ? null : completedFuture(AuthTokens.basic("neo4j", neo4j.adminPassword()));
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(ReactiveSession.class);
+ StepVerifier.create(Mono.fromDirect(toPublisher(session.run("RETURN 1")))
+ .flatMap(result -> Mono.fromDirect(toPublisher(result.consume()))))
+ .expectNextCount(1)
+ .verifyComplete();
+ returnNull.set(true);
+ StepVerifier.create(toPublisher(session.run("RETURN 1")))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException)
+ .verify();
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnQueryExecutionAndRecoverIfSubsequentStageIsValidFlux() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get() ? null : completedFuture(AuthTokens.basic("neo4j", neo4j.adminPassword()));
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(ReactiveSession.class);
+ StepVerifier.create(Mono.fromDirect(toPublisher(session.run("RETURN 1")))
+ .flatMap(result -> Mono.fromDirect(toPublisher(result.consume()))))
+ .expectNextCount(1)
+ .verifyComplete();
+ returnNull.set(true);
+ StepVerifier.create(toPublisher(session.run("RETURN 1")))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException)
+ .verify();
+ returnNull.set(false);
+ StepVerifier.create(Mono.fromDirect(toPublisher(session.run("RETURN 1")))
+ .flatMap(result -> Mono.fromDirect(toPublisher(result.consume()))))
+ .expectNextCount(1)
+ .verifyComplete();
+ }
+ }
+
+ @Test
+ void shouldEmitInvalidTokenAsErrorOnInitialInteractionFlux() {
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return completedFuture(null);
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(ReactiveSession.class);
+ StepVerifier.create(toPublisher(session.run("RETURN 1")))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException
+ && error.getCause() instanceof NullPointerException)
+ .verify();
+ }
+ }
+
+ @Test
+ void shouldInvalidTokenAsErrorOnQueryExecutionFlux() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get()
+ ? completedFuture(null)
+ : completedFuture(AuthTokens.basic("neo4j", neo4j.adminPassword()));
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(ReactiveSession.class);
+ StepVerifier.create(Mono.fromDirect(toPublisher(session.run("RETURN 1")))
+ .flatMap(result -> Mono.fromDirect(toPublisher(result.consume()))))
+ .expectNextCount(1)
+ .verifyComplete();
+ returnNull.set(true);
+ StepVerifier.create(toPublisher(session.run("RETURN 1")))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException
+ && error.getCause() instanceof NullPointerException)
+ .verify();
+ }
+ }
+
+ @Test
+ void shouldInvalidTokenAsErrorOnQueryExecutionAndRecoverIfSubsequentStageIsValidFlux() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get()
+ ? completedFuture(null)
+ : completedFuture(AuthTokens.basic("neo4j", neo4j.adminPassword()));
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(ReactiveSession.class);
+ StepVerifier.create(Mono.fromDirect(toPublisher(session.run("RETURN 1")))
+ .flatMap(result -> Mono.fromDirect(toPublisher(result.consume()))))
+ .expectNextCount(1)
+ .verifyComplete();
+ returnNull.set(true);
+ StepVerifier.create(toPublisher(session.run("RETURN 1")))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException
+ && error.getCause() instanceof NullPointerException)
+ .verify();
+ returnNull.set(false);
+ StepVerifier.create(Mono.fromDirect(toPublisher(session.run("RETURN 1")))
+ .flatMap(result -> Mono.fromDirect(toPublisher(result.consume()))))
+ .expectNextCount(1)
+ .verifyComplete();
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnInitialInteractionReactiveStreams() {
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return null;
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(org.neo4j.driver.reactivestreams.ReactiveSession.class);
+ StepVerifier.create(session.run("RETURN 1"))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException)
+ .verify();
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnQueryExecutionReactiveStreams() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get() ? null : completedFuture(AuthTokens.basic("neo4j", neo4j.adminPassword()));
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(org.neo4j.driver.reactivestreams.ReactiveSession.class);
+ StepVerifier.create(Mono.fromDirect(session.run("RETURN 1"))
+ .flatMap(result -> Mono.fromDirect(result.consume())))
+ .expectNextCount(1)
+ .verifyComplete();
+ returnNull.set(true);
+ StepVerifier.create(session.run("RETURN 1"))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException)
+ .verify();
+ }
+ }
+
+ @Test
+ void shouldEmitNullStageAsErrorOnQueryExecutionAndRecoverIfSubsequentStageIsValidReactiveStreams() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get() ? null : completedFuture(AuthTokens.basic("neo4j", neo4j.adminPassword()));
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(org.neo4j.driver.reactivestreams.ReactiveSession.class);
+ StepVerifier.create(Mono.fromDirect(session.run("RETURN 1"))
+ .flatMap(result -> Mono.fromDirect(result.consume())))
+ .expectNextCount(1)
+ .verifyComplete();
+ returnNull.set(true);
+ StepVerifier.create(session.run("RETURN 1"))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException)
+ .verify();
+ returnNull.set(false);
+ StepVerifier.create(Mono.fromDirect(session.run("RETURN 1"))
+ .flatMap(result -> Mono.fromDirect(result.consume())))
+ .expectNextCount(1)
+ .verifyComplete();
+ }
+ }
+
+ @Test
+ void shouldEmitInvalidTokenAsErrorOnInitialInteractionReactiveStreams() {
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return completedFuture(null);
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(org.neo4j.driver.reactivestreams.ReactiveSession.class);
+ StepVerifier.create(session.run("RETURN 1"))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException
+ && error.getCause() instanceof NullPointerException)
+ .verify();
+ }
+ }
+
+ @Test
+ void shouldInvalidTokenAsErrorOnQueryExecutionReactiveStreams() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get()
+ ? completedFuture(null)
+ : completedFuture(AuthTokens.basic("neo4j", neo4j.adminPassword()));
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(org.neo4j.driver.reactivestreams.ReactiveSession.class);
+ StepVerifier.create(Mono.fromDirect(session.run("RETURN 1"))
+ .flatMap(result -> Mono.fromDirect(result.consume())))
+ .expectNextCount(1)
+ .verifyComplete();
+ returnNull.set(true);
+ StepVerifier.create(session.run("RETURN 1"))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException
+ && error.getCause() instanceof NullPointerException)
+ .verify();
+ }
+ }
+
+ @Test
+ void shouldInvalidTokenAsErrorOnQueryExecutionAndRecoverIfSubsequentStageIsValidReactiveStreams() {
+ var returnNull = new AtomicBoolean();
+ var manager = new AuthTokenManager() {
+ @Override
+ public CompletionStage getToken() {
+ return returnNull.get()
+ ? completedFuture(null)
+ : completedFuture(AuthTokens.basic("neo4j", neo4j.adminPassword()));
+ }
+
+ @Override
+ public void onExpired(AuthToken authToken) {}
+ };
+ try (var driver = GraphDatabase.driver(neo4j.uri(), manager)) {
+ var session = driver.session(org.neo4j.driver.reactivestreams.ReactiveSession.class);
+ StepVerifier.create(Mono.fromDirect(session.run("RETURN 1"))
+ .flatMap(result -> Mono.fromDirect(result.consume())))
+ .expectNextCount(1)
+ .verifyComplete();
+ returnNull.set(true);
+ StepVerifier.create(session.run("RETURN 1"))
+ .expectErrorMatches(error -> error instanceof AuthTokenManagerExecutionException
+ && error.getCause() instanceof NullPointerException)
+ .verify();
+ returnNull.set(false);
+ StepVerifier.create(Mono.fromDirect(session.run("RETURN 1"))
+ .flatMap(result -> Mono.fromDirect(result.consume())))
+ .expectNextCount(1)
+ .verifyComplete();
+ }
+ }
+}
diff --git a/driver/src/test/java/org/neo4j/driver/integration/LoadCSVIT.java b/driver/src/test/java/org/neo4j/driver/integration/LoadCSVIT.java
index 58aef46a6e..eda9cb9362 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/LoadCSVIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/LoadCSVIT.java
@@ -40,7 +40,7 @@ class LoadCSVIT {
@Test
void shouldLoadCSV() throws Throwable {
- try (Driver driver = GraphDatabase.driver(neo4j.uri(), neo4j.authToken());
+ try (Driver driver = GraphDatabase.driver(neo4j.uri(), neo4j.authTokenManager());
Session session = driver.session()) {
String csvFileUrl = createLocalIrisData(session);
diff --git a/driver/src/test/java/org/neo4j/driver/integration/LoggingIT.java b/driver/src/test/java/org/neo4j/driver/integration/LoggingIT.java
index 3a135fa1dc..377082e70a 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/LoggingIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/LoggingIT.java
@@ -53,7 +53,7 @@ void logShouldRecordDebugAndTraceInfo() {
Config config = Config.builder().withLogging(logging).build();
- try (Driver driver = GraphDatabase.driver(neo4j.uri(), neo4j.authToken(), config)) {
+ try (Driver driver = GraphDatabase.driver(neo4j.uri(), neo4j.authTokenManager(), config)) {
// When
try (Session session = driver.session()) {
session.run("CREATE (a {name:'Cat'})");
diff --git a/driver/src/test/java/org/neo4j/driver/integration/MetricsIT.java b/driver/src/test/java/org/neo4j/driver/integration/MetricsIT.java
index fc6e7f3b39..fc6ef46f57 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/MetricsIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/MetricsIT.java
@@ -49,7 +49,7 @@ class MetricsIT {
void createDriver() {
driver = GraphDatabase.driver(
neo4j.uri(),
- neo4j.authToken(),
+ neo4j.authTokenManager(),
Config.builder().withMetricsAdapter(MetricsAdapter.MICROMETER).build());
}
diff --git a/driver/src/test/java/org/neo4j/driver/integration/RoutingDriverIT.java b/driver/src/test/java/org/neo4j/driver/integration/RoutingDriverIT.java
index e328682204..20ab833c1d 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/RoutingDriverIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/RoutingDriverIT.java
@@ -47,7 +47,7 @@ void shouldBeAbleToConnectSingleInstanceWithNeo4jScheme() throws Throwable {
URI uri = URI.create(String.format(
"neo4j://%s:%s", neo4j.uri().getHost(), neo4j.uri().getPort()));
- try (Driver driver = GraphDatabase.driver(uri, neo4j.authToken());
+ try (Driver driver = GraphDatabase.driver(uri, neo4j.authTokenManager());
Session session = driver.session()) {
assertThat(driver, is(clusterDriver()));
@@ -60,7 +60,7 @@ void shouldBeAbleToConnectSingleInstanceWithNeo4jScheme() throws Throwable {
void shouldBeAbleToRunQueryOnNeo4j() throws Throwable {
URI uri = URI.create(String.format(
"neo4j://%s:%s", neo4j.uri().getHost(), neo4j.uri().getPort()));
- try (Driver driver = GraphDatabase.driver(uri, neo4j.authToken());
+ try (Driver driver = GraphDatabase.driver(uri, neo4j.authTokenManager());
Session session = driver.session(forDatabase("neo4j"))) {
assertThat(driver, is(clusterDriver()));
diff --git a/driver/src/test/java/org/neo4j/driver/integration/ServerKilledIT.java b/driver/src/test/java/org/neo4j/driver/integration/ServerKilledIT.java
index c8217b0f62..08a8708ecd 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/ServerKilledIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/ServerKilledIT.java
@@ -66,7 +66,7 @@ private static Stream data() {
@MethodSource("data")
void shouldRecoverFromServerRestart(String name, Config.ConfigBuilder configBuilder) {
// Given config with sessionLivenessCheckTimeout not set, i.e. turned off
- try (Driver driver = GraphDatabase.driver(neo4j.uri(), neo4j.authToken(), configBuilder.build())) {
+ try (Driver driver = GraphDatabase.driver(neo4j.uri(), neo4j.authTokenManager(), configBuilder.build())) {
acquireAndReleaseConnections(4, driver);
// When
@@ -127,6 +127,7 @@ private static void acquireAndReleaseConnections(int count, Driver driver) {
private Driver createDriver(Clock clock, Config config) {
DriverFactory factory = new DriverFactoryWithClock(clock);
- return factory.newInstance(neo4j.uri(), neo4j.authToken(), config, SecurityPlanImpl.insecure(), null, null);
+ return factory.newInstance(
+ neo4j.uri(), neo4j.authTokenManager(), config, SecurityPlanImpl.insecure(), null, null);
}
}
diff --git a/driver/src/test/java/org/neo4j/driver/integration/SessionBoltV3IT.java b/driver/src/test/java/org/neo4j/driver/integration/SessionBoltV3IT.java
index 143d148028..6622fb7a72 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/SessionBoltV3IT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/SessionBoltV3IT.java
@@ -273,7 +273,7 @@ void shouldSendGoodbyeWhenClosingDriver() {
MessageRecordingDriverFactory driverFactory = new MessageRecordingDriverFactory();
try (Driver otherDriver = driverFactory.newInstance(
- driver.uri(), driver.authToken(), defaultConfig(), SecurityPlanImpl.insecure(), null, null)) {
+ driver.uri(), driver.authTokenManager(), defaultConfig(), SecurityPlanImpl.insecure(), null, null)) {
List sessions = new ArrayList<>();
List txs = new ArrayList<>();
for (int i = 0; i < txCount; i++) {
diff --git a/driver/src/test/java/org/neo4j/driver/integration/SessionIT.java b/driver/src/test/java/org/neo4j/driver/integration/SessionIT.java
index 4655f8fe66..324d10b90b 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/SessionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/SessionIT.java
@@ -129,7 +129,7 @@ void shouldKnowSessionIsClosed() {
@Test
void shouldHandleNullConfig() {
// Given
- driver = GraphDatabase.driver(neo4j.uri(), neo4j.authToken(), null);
+ driver = GraphDatabase.driver(neo4j.uri(), neo4j.authTokenManager(), null);
Session session = driver.session();
// When
@@ -782,7 +782,7 @@ void shouldNotRetryOnConnectionAcquisitionTimeout() {
.withEventLoopThreads(1)
.build();
- driver = GraphDatabase.driver(neo4j.uri(), neo4j.authToken(), config);
+ driver = GraphDatabase.driver(neo4j.uri(), neo4j.authTokenManager(), config);
for (int i = 0; i < maxPoolSize; i++) {
driver.session().beginTransaction();
@@ -907,7 +907,7 @@ void shouldAllowLongRunningQueryWithConnectTimeout() throws Exception {
.withConnectionTimeout(connectionTimeoutMs, TimeUnit.MILLISECONDS)
.build();
- try (Driver driver = GraphDatabase.driver(neo4j.uri(), neo4j.authToken(), config)) {
+ try (Driver driver = GraphDatabase.driver(neo4j.uri(), neo4j.authTokenManager(), config)) {
Session session1 = driver.session();
Session session2 = driver.session();
@@ -1273,7 +1273,7 @@ private Driver newDriverWithoutRetries() {
private Driver newDriverWithFixedRetries(int maxRetriesCount) {
DriverFactory driverFactory = new DriverFactoryWithFixedRetryLogic(maxRetriesCount);
return driverFactory.newInstance(
- neo4j.uri(), neo4j.authToken(), noLoggingConfig(), SecurityPlanImpl.insecure(), null, null);
+ neo4j.uri(), neo4j.authTokenManager(), noLoggingConfig(), SecurityPlanImpl.insecure(), null, null);
}
private Driver newDriverWithLimitedRetries(int maxTxRetryTime, TimeUnit unit) {
@@ -1281,7 +1281,7 @@ private Driver newDriverWithLimitedRetries(int maxTxRetryTime, TimeUnit unit) {
.withLogging(DEV_NULL_LOGGING)
.withMaxTransactionRetryTime(maxTxRetryTime, unit)
.build();
- return GraphDatabase.driver(neo4j.uri(), neo4j.authToken(), config);
+ return GraphDatabase.driver(neo4j.uri(), neo4j.authTokenManager(), config);
}
private static Config noLoggingConfig() {
diff --git a/driver/src/test/java/org/neo4j/driver/integration/SharedEventLoopIT.java b/driver/src/test/java/org/neo4j/driver/integration/SharedEventLoopIT.java
index ca2348533e..efe5fe1397 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/SharedEventLoopIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/SharedEventLoopIT.java
@@ -82,7 +82,7 @@ void testDriverShouldUseSharedEventLoop() {
private Driver createDriver(EventLoopGroup eventLoopGroup) {
return driverFactory.newInstance(
neo4j.uri(),
- neo4j.authToken(),
+ neo4j.authTokenManager(),
Config.defaultConfig(),
SecurityPlanImpl.insecure(),
eventLoopGroup,
diff --git a/driver/src/test/java/org/neo4j/driver/integration/TransactionIT.java b/driver/src/test/java/org/neo4j/driver/integration/TransactionIT.java
index 1d3cfb4384..64b9e8b372 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/TransactionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/TransactionIT.java
@@ -350,7 +350,7 @@ void shouldThrowWhenConnectionKilledDuringTransaction() {
Config config = Config.builder().withLogging(DEV_NULL_LOGGING).build();
try (Driver driver = factory.newInstance(
- session.uri(), session.authToken(), config, SecurityPlanImpl.insecure(), null, null)) {
+ session.uri(), session.authTokenManager(), config, SecurityPlanImpl.insecure(), null, null)) {
ServiceUnavailableException e = assertThrows(ServiceUnavailableException.class, () -> {
try (Session session1 = driver.session();
Transaction tx = session1.beginTransaction()) {
diff --git a/driver/src/test/java/org/neo4j/driver/integration/TrustCustomCertificateIT.java b/driver/src/test/java/org/neo4j/driver/integration/TrustCustomCertificateIT.java
index c8c7358813..f048a02b9a 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/TrustCustomCertificateIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/TrustCustomCertificateIT.java
@@ -84,7 +84,7 @@ private void shouldBeAbleToRunCypher(Supplier driverSupplier) {
private Driver createDriverWithCustomCertificate(File cert) {
return GraphDatabase.driver(
neo4j.uri(),
- neo4j.authToken(),
+ neo4j.authTokenManager(),
Config.builder()
.withEncryption()
.withTrustStrategy(trustCustomCertificateSignedBy(cert))
diff --git a/driver/src/test/java/org/neo4j/driver/integration/UnmanagedTransactionIT.java b/driver/src/test/java/org/neo4j/driver/integration/UnmanagedTransactionIT.java
index ab857f88b1..75d8d735de 100644
--- a/driver/src/test/java/org/neo4j/driver/integration/UnmanagedTransactionIT.java
+++ b/driver/src/test/java/org/neo4j/driver/integration/UnmanagedTransactionIT.java
@@ -64,7 +64,7 @@ class UnmanagedTransactionIT {
@BeforeEach
void setUp() {
- session = ((InternalDriver) neo4j.driver()).newSession(SessionConfig.defaultConfig());
+ session = ((InternalDriver) neo4j.driver()).newSession(SessionConfig.defaultConfig(), null);
}
@AfterEach
@@ -199,8 +199,8 @@ private void testCommitAndRollbackFailurePropagation(boolean commit) {
Config config = Config.builder().withLogging(DEV_NULL_LOGGING).build();
try (Driver driver = driverFactory.newInstance(
- neo4j.uri(), neo4j.authToken(), config, SecurityPlanImpl.insecure(), null, null)) {
- NetworkSession session = ((InternalDriver) driver).newSession(SessionConfig.defaultConfig());
+ neo4j.uri(), neo4j.authTokenManager(), config, SecurityPlanImpl.insecure(), null, null)) {
+ NetworkSession session = ((InternalDriver) driver).newSession(SessionConfig.defaultConfig(), null);
{
UnmanagedTransaction tx = beginTransaction(session);
diff --git a/driver/src/test/java/org/neo4j/driver/internal/CustomSecurityPlanTest.java b/driver/src/test/java/org/neo4j/driver/internal/CustomSecurityPlanTest.java
index cf2cb78b71..7c5be11664 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/CustomSecurityPlanTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/CustomSecurityPlanTest.java
@@ -27,12 +27,13 @@
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.Test;
-import org.neo4j.driver.AuthToken;
+import org.neo4j.driver.AuthTokenManager;
import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.Config;
import org.neo4j.driver.internal.cluster.RoutingContext;
import org.neo4j.driver.internal.metrics.MetricsProvider;
import org.neo4j.driver.internal.security.SecurityPlan;
+import org.neo4j.driver.internal.security.StaticAuthTokenManager;
import org.neo4j.driver.internal.spi.ConnectionPool;
class CustomSecurityPlanTest {
@@ -44,7 +45,7 @@ void testCustomSecurityPlanUsed() {
driverFactory.newInstance(
URI.create("neo4j://somewhere:1234"),
- AuthTokens.none(),
+ new StaticAuthTokenManager(AuthTokens.none()),
Config.defaultConfig(),
securityPlan,
null,
@@ -69,7 +70,7 @@ protected InternalDriver createDriver(
@Override
protected ConnectionPool createConnectionPool(
- AuthToken authToken,
+ AuthTokenManager authTokenManager,
SecurityPlan securityPlan,
Bootstrap bootstrap,
MetricsProvider metricsProvider,
@@ -78,7 +79,13 @@ protected ConnectionPool createConnectionPool(
RoutingContext routingContext) {
capturedSecurityPlans.add(securityPlan);
return super.createConnectionPool(
- authToken, securityPlan, bootstrap, metricsProvider, config, ownsEventLoopGroup, routingContext);
+ authTokenManager,
+ securityPlan,
+ bootstrap,
+ metricsProvider,
+ config,
+ ownsEventLoopGroup,
+ routingContext);
}
}
}
diff --git a/driver/src/test/java/org/neo4j/driver/internal/DirectConnectionProviderTest.java b/driver/src/test/java/org/neo4j/driver/internal/DirectConnectionProviderTest.java
index 8461a4cbca..aeff200c0d 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/DirectConnectionProviderTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/DirectConnectionProviderTest.java
@@ -110,7 +110,7 @@ void shouldIgnoreDatabaseNameAndAccessModeWhenObtainConnectionFromPool() throws
assertThat(acquired1, instanceOf(DirectConnection.class));
assertSame(connection, ((DirectConnection) acquired1).connection());
- verify(pool).acquire(address);
+ verify(pool).acquire(address, null);
}
@ParameterizedTest
@@ -155,7 +155,7 @@ private static ConnectionPool poolMock(
CompletableFuture[] otherConnectionFutures = Stream.of(otherConnections)
.map(CompletableFuture::completedFuture)
.toArray(CompletableFuture[]::new);
- when(pool.acquire(address)).thenReturn(completedFuture(connection), otherConnectionFutures);
+ when(pool.acquire(address, null)).thenReturn(completedFuture(connection), otherConnectionFutures);
return pool;
}
}
diff --git a/driver/src/test/java/org/neo4j/driver/internal/DriverFactoryTest.java b/driver/src/test/java/org/neo4j/driver/internal/DriverFactoryTest.java
index 4b54793b11..ab092c071b 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/DriverFactoryTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/DriverFactoryTest.java
@@ -52,6 +52,7 @@
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.neo4j.driver.AuthToken;
+import org.neo4j.driver.AuthTokenManager;
import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.Config;
import org.neo4j.driver.Driver;
@@ -72,6 +73,7 @@
import org.neo4j.driver.internal.metrics.MicrometerMetricsProvider;
import org.neo4j.driver.internal.retry.RetryLogic;
import org.neo4j.driver.internal.security.SecurityPlan;
+import org.neo4j.driver.internal.security.StaticAuthTokenManager;
import org.neo4j.driver.internal.spi.Connection;
import org.neo4j.driver.internal.spi.ConnectionPool;
import org.neo4j.driver.internal.spi.ConnectionProvider;
@@ -115,7 +117,7 @@ void usesStandardSessionFactoryWhenNothingConfigured(String uri) {
createDriver(uri, factory, config);
SessionFactory capturedFactory = factory.capturedSessionFactory;
- assertThat(capturedFactory.newInstance(SessionConfig.defaultConfig()), instanceOf(NetworkSession.class));
+ assertThat(capturedFactory.newInstance(SessionConfig.defaultConfig(), null), instanceOf(NetworkSession.class));
}
@ParameterizedTest
@@ -128,7 +130,7 @@ void usesLeakLoggingSessionFactoryWhenConfigured(String uri) {
SessionFactory capturedFactory = factory.capturedSessionFactory;
assertThat(
- capturedFactory.newInstance(SessionConfig.defaultConfig()),
+ capturedFactory.newInstance(SessionConfig.defaultConfig(), null),
instanceOf(LeakLoggingNetworkSession.class));
}
@@ -203,7 +205,12 @@ void shouldUseBuiltInRediscoveryByDefault() {
// WHEN
var driver = driverFactory.newInstance(
- URI.create("neo4j://localhost:7687"), AuthTokens.none(), Config.defaultConfig(), null, null, null);
+ URI.create("neo4j://localhost:7687"),
+ new StaticAuthTokenManager(AuthTokens.none()),
+ Config.defaultConfig(),
+ null,
+ null,
+ null);
// THEN
var sessionFactory = ((InternalDriver) driver).getSessionFactory();
@@ -224,7 +231,7 @@ void shouldUseSuppliedRediscovery() {
// WHEN
var driver = driverFactory.newInstance(
URI.create("neo4j://localhost:7687"),
- AuthTokens.none(),
+ new StaticAuthTokenManager(AuthTokens.none()),
Config.defaultConfig(),
null,
null,
@@ -244,13 +251,13 @@ private Driver createDriver(String uri, DriverFactory driverFactory) {
private Driver createDriver(String uri, DriverFactory driverFactory, Config config) {
AuthToken auth = AuthTokens.none();
- return driverFactory.newInstance(URI.create(uri), auth, config);
+ return driverFactory.newInstance(URI.create(uri), new StaticAuthTokenManager(auth), config);
}
private static ConnectionPool connectionPoolMock() {
ConnectionPool pool = mock(ConnectionPool.class);
Connection connection = mock(Connection.class);
- when(pool.acquire(any(BoltServerAddress.class))).thenReturn(completedFuture(connection));
+ when(pool.acquire(any(BoltServerAddress.class), any(AuthToken.class))).thenReturn(completedFuture(connection));
when(pool.close()).thenReturn(completedWithNull());
return pool;
}
@@ -287,7 +294,7 @@ protected InternalDriver createRoutingDriver(
@Override
protected ConnectionPool createConnectionPool(
- AuthToken authToken,
+ AuthTokenManager authTokenManager,
SecurityPlan securityPlan,
Bootstrap bootstrap,
MetricsProvider metricsProvider,
@@ -333,7 +340,7 @@ protected SessionFactory createSessionFactory(
@Override
protected ConnectionPool createConnectionPool(
- AuthToken authToken,
+ AuthTokenManager authTokenManager,
SecurityPlan securityPlan,
Bootstrap bootstrap,
MetricsProvider metricsProvider,
@@ -358,7 +365,7 @@ protected Bootstrap createBootstrap(int ignored) {
@Override
protected ConnectionPool createConnectionPool(
- AuthToken authToken,
+ AuthTokenManager authTokenManager,
SecurityPlan securityPlan,
Bootstrap bootstrap,
MetricsProvider metricsProvider,
diff --git a/driver/src/test/java/org/neo4j/driver/internal/SessionFactoryImplTest.java b/driver/src/test/java/org/neo4j/driver/internal/SessionFactoryImplTest.java
index 8fe6c36812..d9fdaf2d0b 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/SessionFactoryImplTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/SessionFactoryImplTest.java
@@ -39,11 +39,11 @@ void createsNetworkSessions() {
SessionFactory factory = newSessionFactory(config);
NetworkSession readSession = factory.newInstance(
- builder().withDefaultAccessMode(AccessMode.READ).build());
+ builder().withDefaultAccessMode(AccessMode.READ).build(), null);
assertThat(readSession, instanceOf(NetworkSession.class));
NetworkSession writeSession = factory.newInstance(
- builder().withDefaultAccessMode(AccessMode.WRITE).build());
+ builder().withDefaultAccessMode(AccessMode.WRITE).build(), null);
assertThat(writeSession, instanceOf(NetworkSession.class));
}
@@ -56,11 +56,11 @@ void createsLeakLoggingNetworkSessions() {
SessionFactory factory = newSessionFactory(config);
NetworkSession readSession = factory.newInstance(
- builder().withDefaultAccessMode(AccessMode.READ).build());
+ builder().withDefaultAccessMode(AccessMode.READ).build(), null);
assertThat(readSession, instanceOf(LeakLoggingNetworkSession.class));
NetworkSession writeSession = factory.newInstance(
- builder().withDefaultAccessMode(AccessMode.WRITE).build());
+ builder().withDefaultAccessMode(AccessMode.WRITE).build(), null);
assertThat(writeSession, instanceOf(LeakLoggingNetworkSession.class));
}
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/LeakLoggingNetworkSessionTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/LeakLoggingNetworkSessionTest.java
index 1606047906..8c42e242b3 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/LeakLoggingNetworkSessionTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/LeakLoggingNetworkSessionTest.java
@@ -102,6 +102,7 @@ private static LeakLoggingNetworkSession newSession(Logging logging, boolean ope
FetchSizeUtil.UNLIMITED_FETCH_SIZE,
logging,
mock(BookmarkManager.class),
+ null,
null);
}
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/connection/ChannelAttributesTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/connection/ChannelAttributesTest.java
index 2a151da7c8..fad2eae9bb 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/connection/ChannelAttributesTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/connection/ChannelAttributesTest.java
@@ -22,6 +22,7 @@
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.mock;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.authContext;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.authorizationStateListener;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.connectionId;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.connectionReadTimeout;
@@ -31,6 +32,7 @@
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.protocolVersion;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.serverAddress;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.serverAgent;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setAuthContext;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setAuthorizationStateListener;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setConnectionId;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setConnectionReadTimeout;
@@ -47,6 +49,7 @@
import org.junit.jupiter.api.Test;
import org.neo4j.driver.internal.BoltServerAddress;
import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher;
+import org.neo4j.driver.internal.async.pool.AuthContext;
import org.neo4j.driver.internal.messaging.BoltProtocolVersion;
class ChannelAttributesTest {
@@ -195,4 +198,18 @@ void shouldFailToSetConnectionReadTimeoutTwice() {
setConnectionReadTimeout(channel, timeout);
assertThrows(IllegalStateException.class, () -> setConnectionReadTimeout(channel, timeout));
}
+
+ @Test
+ void shouldSetAndGetAuthContext() {
+ var context = mock(AuthContext.class);
+ setAuthContext(channel, context);
+ assertEquals(context, authContext(channel));
+ }
+
+ @Test
+ void shouldFailToSetAuthContextTwice() {
+ var context = mock(AuthContext.class);
+ setAuthContext(channel, context);
+ assertThrows(IllegalStateException.class, () -> setAuthContext(channel, context));
+ }
}
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/connection/HandshakeCompletedListenerTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/connection/HandshakeCompletedListenerTest.java
index 934b7c96c9..61869859d5 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/connection/HandshakeCompletedListenerTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/connection/HandshakeCompletedListenerTest.java
@@ -18,12 +18,17 @@
*/
package org.neo4j.driver.internal.async.connection;
+import static java.util.concurrent.CompletableFuture.completedFuture;
+import static java.util.concurrent.CompletableFuture.failedFuture;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.then;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setAuthContext;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setMessageDispatcher;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setProtocolVersion;
import static org.neo4j.driver.testutil.TestUtil.await;
@@ -31,19 +36,25 @@
import io.netty.channel.ChannelPromise;
import io.netty.channel.embedded.EmbeddedChannel;
import java.io.IOException;
+import java.time.Clock;
import java.util.Collections;
+import java.util.concurrent.CompletionException;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
+import org.neo4j.driver.AuthTokenManager;
import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher;
+import org.neo4j.driver.internal.async.pool.AuthContext;
import org.neo4j.driver.internal.cluster.RoutingContext;
import org.neo4j.driver.internal.handlers.HelloResponseHandler;
import org.neo4j.driver.internal.messaging.BoltProtocolVersion;
import org.neo4j.driver.internal.messaging.Message;
import org.neo4j.driver.internal.messaging.request.HelloMessage;
import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3;
+import org.neo4j.driver.internal.messaging.v5.BoltProtocolV5;
import org.neo4j.driver.internal.security.InternalAuthToken;
import org.neo4j.driver.internal.spi.ResponseHandler;
+import org.neo4j.driver.internal.util.Futures;
class HandshakeCompletedListenerTest {
private static final String USER_AGENT = "user-agent";
@@ -59,7 +70,7 @@ void tearDown() {
void shouldFailConnectionInitializedPromiseWhenHandshakeFails() {
ChannelPromise channelInitializedPromise = channel.newPromise();
HandshakeCompletedListener listener = new HandshakeCompletedListener(
- "user-agent", authToken(), RoutingContext.EMPTY, channelInitializedPromise, null);
+ "user-agent", RoutingContext.EMPTY, channelInitializedPromise, null, mock(Clock.class));
ChannelPromise handshakeCompletedPromise = channel.newPromise();
IOException cause = new IOException("Bad handshake");
@@ -73,10 +84,44 @@ void shouldFailConnectionInitializedPromiseWhenHandshakeFails() {
@Test
void shouldWriteInitializationMessageInBoltV3WhenHandshakeCompleted() {
+ var authTokenManager = mock(AuthTokenManager.class);
+ var authToken = authToken();
+ given(authTokenManager.getToken()).willReturn(completedFuture(authToken));
+ var authContext = mock(AuthContext.class);
+ given(authContext.getAuthTokenManager()).willReturn(authTokenManager);
+ setAuthContext(channel, authContext);
testWritingOfInitializationMessage(
BoltProtocolV3.VERSION,
new HelloMessage(USER_AGENT, authToken().toMap(), Collections.emptyMap(), false, null),
HelloResponseHandler.class);
+ then(authContext).should().initiateAuth(authToken);
+ }
+
+ @Test
+ void shouldFailPromiseWhenTokenStageCompletesExceptionally() {
+ // given
+ var channelInitializedPromise = channel.newPromise();
+ var listener = new HandshakeCompletedListener(
+ "agent", mock(RoutingContext.class), channelInitializedPromise, null, mock(Clock.class));
+ var handshakeCompletedPromise = channel.newPromise();
+ handshakeCompletedPromise.setSuccess();
+ setProtocolVersion(channel, BoltProtocolV5.VERSION);
+ var authContext = mock(AuthContext.class);
+ setAuthContext(channel, authContext);
+ var authTokeManager = mock(AuthTokenManager.class);
+ given(authContext.getAuthTokenManager()).willReturn(authTokeManager);
+ var exception = mock(Throwable.class);
+ given(authTokeManager.getToken()).willReturn(failedFuture(exception));
+
+ // when
+ listener.operationComplete(handshakeCompletedPromise);
+ channel.runPendingTasks();
+
+ // then
+ var future = Futures.asCompletionStage(channelInitializedPromise).toCompletableFuture();
+ var actualException =
+ assertThrows(CompletionException.class, future::join).getCause();
+ assertEquals(exception, actualException);
}
private void testWritingOfInitializationMessage(
@@ -89,7 +134,7 @@ private void testWritingOfInitializationMessage(
ChannelPromise channelInitializedPromise = channel.newPromise();
HandshakeCompletedListener listener = new HandshakeCompletedListener(
- USER_AGENT, authToken(), RoutingContext.EMPTY, channelInitializedPromise, null);
+ USER_AGENT, RoutingContext.EMPTY, channelInitializedPromise, null, mock(Clock.class));
ChannelPromise handshakeCompletedPromise = channel.newPromise();
handshakeCompletedPromise.setSuccess();
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/connection/NettyChannelInitializerTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/connection/NettyChannelInitializerTest.java
index c9b8d99640..9c3b096b41 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/connection/NettyChannelInitializerTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/connection/NettyChannelInitializerTest.java
@@ -28,6 +28,7 @@
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.neo4j.driver.internal.BoltServerAddress.LOCAL_DEFAULT;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.authContext;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.creationTimestamp;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.messageDispatcher;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.serverAddress;
@@ -44,10 +45,12 @@
import javax.net.ssl.SSLParameters;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
+import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.RevocationCheckingStrategy;
import org.neo4j.driver.internal.BoltServerAddress;
import org.neo4j.driver.internal.security.SecurityPlan;
import org.neo4j.driver.internal.security.SecurityPlanImpl;
+import org.neo4j.driver.internal.security.StaticAuthTokenManager;
import org.neo4j.driver.internal.util.FakeClock;
class NettyChannelInitializerTest {
@@ -103,13 +106,19 @@ void shouldUpdateChannelAttributes() {
assertEquals(LOCAL_DEFAULT, serverAddress(channel));
assertEquals(42L, creationTimestamp(channel));
assertNotNull(messageDispatcher(channel));
+ assertNotNull(authContext(channel));
}
@Test
void shouldIncludeSniHostName() throws Exception {
BoltServerAddress address = new BoltServerAddress("database.neo4j.com", 8989);
NettyChannelInitializer initializer = new NettyChannelInitializer(
- address, trustAllCertificates(), 10000, Clock.systemUTC(), DEV_NULL_LOGGING);
+ address,
+ trustAllCertificates(),
+ 10000,
+ new StaticAuthTokenManager(AuthTokens.none()),
+ Clock.systemUTC(),
+ DEV_NULL_LOGGING);
initializer.initChannel(channel);
@@ -154,7 +163,13 @@ private static NettyChannelInitializer newInitializer(SecurityPlan securityPlan,
private static NettyChannelInitializer newInitializer(
SecurityPlan securityPlan, int connectTimeoutMillis, Clock clock) {
- return new NettyChannelInitializer(LOCAL_DEFAULT, securityPlan, connectTimeoutMillis, clock, DEV_NULL_LOGGING);
+ return new NettyChannelInitializer(
+ LOCAL_DEFAULT,
+ securityPlan,
+ connectTimeoutMillis,
+ new StaticAuthTokenManager(AuthTokens.none()),
+ clock,
+ DEV_NULL_LOGGING);
}
private static SecurityPlan trustAllCertificates() throws GeneralSecurityException {
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcherTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcherTest.java
index 5166b5e8d4..f475d83b96 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcherTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcherTest.java
@@ -30,20 +30,25 @@
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.ArgumentMatchers.contains;
import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.then;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.only;
+import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.neo4j.driver.Values.value;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setAuthContext;
import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING;
import static org.neo4j.driver.internal.messaging.request.ResetMessage.RESET;
import io.netty.channel.Channel;
import io.netty.channel.ChannelConfig;
import io.netty.channel.DefaultChannelId;
+import io.netty.channel.embedded.EmbeddedChannel;
import io.netty.util.Attribute;
import java.util.HashMap;
import java.util.Map;
@@ -52,12 +57,17 @@
import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.ArgumentCaptor;
import org.mockito.InOrder;
+import org.neo4j.driver.AuthTokenManager;
+import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.Logger;
import org.neo4j.driver.Logging;
import org.neo4j.driver.Value;
import org.neo4j.driver.Values;
import org.neo4j.driver.exceptions.ClientException;
import org.neo4j.driver.exceptions.Neo4jException;
+import org.neo4j.driver.exceptions.TokenExpiredException;
+import org.neo4j.driver.exceptions.TokenExpiredRetryableException;
+import org.neo4j.driver.internal.async.pool.AuthContext;
import org.neo4j.driver.internal.logging.ChannelActivityLogger;
import org.neo4j.driver.internal.logging.ChannelErrorLogger;
import org.neo4j.driver.internal.messaging.Message;
@@ -65,6 +75,7 @@
import org.neo4j.driver.internal.messaging.response.IgnoredMessage;
import org.neo4j.driver.internal.messaging.response.RecordMessage;
import org.neo4j.driver.internal.messaging.response.SuccessMessage;
+import org.neo4j.driver.internal.security.StaticAuthTokenManager;
import org.neo4j.driver.internal.spi.ResponseHandler;
import org.neo4j.driver.internal.value.IntegerValue;
@@ -428,11 +439,76 @@ void shouldCreateChannelErrorLoggerAndLogDebugMessageOnChannelError() {
verify(errorLogger).debug(contains(throwable.getClass().toString()));
}
+ @Test
+ void shouldEmitTokenExpiredRetryableExceptionAndNotifyAuthTokenManager() {
+ // given
+ var channel = new EmbeddedChannel();
+ var authTokenManager = mock(AuthTokenManager.class);
+ var authContext = mock(AuthContext.class);
+ given(authContext.isManaged()).willReturn(true);
+ given(authContext.getAuthTokenManager()).willReturn(authTokenManager);
+ var authToken = AuthTokens.basic("username", "password");
+ given(authContext.getAuthToken()).willReturn(authToken);
+ setAuthContext(channel, authContext);
+ var dispatcher = newDispatcher(channel);
+ var handler = mock(ResponseHandler.class);
+ dispatcher.enqueue(handler);
+ var code = "Neo.ClientError.Security.TokenExpired";
+ var message = "message";
+
+ // when
+ dispatcher.handleFailureMessage(code, message);
+
+ // then
+ assertEquals(0, dispatcher.queuedHandlersCount());
+ verifyFailure(handler, code, message, TokenExpiredRetryableException.class);
+ assertEquals(code, ((Neo4jException) dispatcher.currentError()).code());
+ assertEquals(message, dispatcher.currentError().getMessage());
+ then(authTokenManager).should().onExpired(authToken);
+ }
+
+ @Test
+ void shouldEmitTokenExpiredExceptionAndNotifyAuthTokenManager() {
+ // given
+ var channel = new EmbeddedChannel();
+ var authToken = AuthTokens.basic("username", "password");
+ var authTokenManager = spy(new StaticAuthTokenManager(authToken));
+ var authContext = mock(AuthContext.class);
+ given(authContext.isManaged()).willReturn(true);
+ given(authContext.getAuthTokenManager()).willReturn(authTokenManager);
+ given(authContext.getAuthToken()).willReturn(authToken);
+ setAuthContext(channel, authContext);
+ var dispatcher = newDispatcher(channel);
+ var handler = mock(ResponseHandler.class);
+ dispatcher.enqueue(handler);
+ var code = "Neo.ClientError.Security.TokenExpired";
+ var message = "message";
+
+ // when
+ dispatcher.handleFailureMessage(code, message);
+
+ // then
+ assertEquals(0, dispatcher.queuedHandlersCount());
+ verifyFailure(handler, code, message, TokenExpiredException.class);
+ assertEquals(code, ((Neo4jException) dispatcher.currentError()).code());
+ assertEquals(message, dispatcher.currentError().getMessage());
+ then(authTokenManager).should().onExpired(authToken);
+ }
+
private static void verifyFailure(ResponseHandler handler) {
+ verifyFailure(handler, FAILURE_CODE, FAILURE_MESSAGE, null);
+ }
+
+ private static void verifyFailure(
+ ResponseHandler handler, String code, String message, Class exceptionCls) {
ArgumentCaptor captor = ArgumentCaptor.forClass(Neo4jException.class);
verify(handler).onFailure(captor.capture());
- assertEquals(FAILURE_CODE, captor.getValue().code());
- assertEquals(FAILURE_MESSAGE, captor.getValue().getMessage());
+ var value = captor.getValue();
+ assertEquals(code, value.code());
+ assertEquals(message, value.getMessage());
+ if (exceptionCls != null) {
+ assertEquals(exceptionCls, value.getClass());
+ }
}
private static InboundMessageDispatcher newDispatcher() {
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/pool/AuthContextTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/pool/AuthContextTest.java
new file mode 100644
index 0000000000..494cd5e9d5
--- /dev/null
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/pool/AuthContextTest.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.async.pool;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+
+import org.junit.jupiter.api.Test;
+import org.neo4j.driver.AuthTokenManager;
+import org.neo4j.driver.AuthTokens;
+
+class AuthContextTest {
+ @Test
+ void shouldRejectNullAuthTokenManager() {
+ assertThrows(NullPointerException.class, () -> new AuthContext(null));
+ }
+
+ @Test
+ void shouldStartUnauthenticated() {
+ // given
+ var authTokenManager = mock(AuthTokenManager.class);
+
+ // when
+ var authContext = new AuthContext(authTokenManager);
+
+ // then
+ assertEquals(authTokenManager, authContext.getAuthTokenManager());
+ assertNull(authContext.getAuthToken());
+ assertNull(authContext.getAuthTimestamp());
+ assertFalse(authContext.isPendingLogoff());
+ }
+
+ @Test
+ void shouldInitiateAuth() {
+ // given
+ var authTokenManager = mock(AuthTokenManager.class);
+ var authContext = new AuthContext(authTokenManager);
+ var authToken = AuthTokens.basic("username", "password");
+
+ // when
+ authContext.initiateAuth(authToken);
+
+ // then
+ assertEquals(authTokenManager, authContext.getAuthTokenManager());
+ assertEquals(authContext.getAuthToken(), authToken);
+ assertNull(authContext.getAuthTimestamp());
+ assertFalse(authContext.isPendingLogoff());
+ }
+
+ @Test
+ void shouldRejectNullToken() {
+ // given
+ var authTokenManager = mock(AuthTokenManager.class);
+ var authContext = new AuthContext(authTokenManager);
+
+ // when & then
+ assertThrows(NullPointerException.class, () -> authContext.initiateAuth(null));
+ }
+
+ @Test
+ void shouldInitiateAuthAfterAnotherAuth() {
+ // given
+ var authTokenManager = mock(AuthTokenManager.class);
+ var authContext = new AuthContext(authTokenManager);
+ var authToken = AuthTokens.basic("username", "password1");
+ authContext.initiateAuth(AuthTokens.basic("username", "password0"));
+ authContext.finishAuth(1L);
+
+ // when
+ authContext.initiateAuth(authToken);
+
+ // then
+ assertEquals(authTokenManager, authContext.getAuthTokenManager());
+ assertEquals(authContext.getAuthToken(), authToken);
+ assertNull(authContext.getAuthTimestamp());
+ assertFalse(authContext.isPendingLogoff());
+ }
+
+ @Test
+ void shouldFinishAuth() {
+ // given
+ var authTokenManager = mock(AuthTokenManager.class);
+ var authContext = new AuthContext(authTokenManager);
+ var authToken = AuthTokens.basic("username", "password");
+ authContext.initiateAuth(authToken);
+ var ts = 1L;
+
+ // when
+ authContext.finishAuth(ts);
+
+ // then
+ assertEquals(authTokenManager, authContext.getAuthTokenManager());
+ assertEquals(authContext.getAuthToken(), authToken);
+ assertEquals(authContext.getAuthTimestamp(), ts);
+ assertFalse(authContext.isPendingLogoff());
+ }
+
+ @Test
+ void shouldSetPendingLogoff() {
+ // given
+ var authTokenManager = mock(AuthTokenManager.class);
+ var authContext = new AuthContext(authTokenManager);
+ var authToken = AuthTokens.basic("username", "password");
+ authContext.initiateAuth(authToken);
+ var ts = 1L;
+ authContext.finishAuth(ts);
+
+ // when
+ authContext.markPendingLogoff();
+
+ // then
+ assertEquals(authTokenManager, authContext.getAuthTokenManager());
+ assertEquals(authContext.getAuthToken(), authToken);
+ assertEquals(authContext.getAuthTimestamp(), ts);
+ assertTrue(authContext.isPendingLogoff());
+ }
+}
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImplIT.java b/driver/src/test/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImplIT.java
index 09e8173bf1..4c25ff1dd8 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImplIT.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImplIT.java
@@ -70,24 +70,24 @@ void tearDown() {
@Test
void shouldAcquireConnectionWhenPoolIsEmpty() {
- Connection connection = await(pool.acquire(neo4j.address()));
+ Connection connection = await(pool.acquire(neo4j.address(), null));
assertNotNull(connection);
}
@Test
void shouldAcquireIdleConnection() {
- Connection connection1 = await(pool.acquire(neo4j.address()));
+ Connection connection1 = await(pool.acquire(neo4j.address(), null));
await(connection1.release());
- Connection connection2 = await(pool.acquire(neo4j.address()));
+ Connection connection2 = await(pool.acquire(neo4j.address(), null));
assertNotNull(connection2);
}
@Test
void shouldBeAbleToClosePoolInIOWorkerThread() throws Throwable {
// In the IO worker thread of a channel obtained from a pool, we shall be able to close the pool.
- CompletionStage future = pool.acquire(neo4j.address())
+ CompletionStage future = pool.acquire(neo4j.address(), null)
.thenCompose(Connection::release)
// This shall close all pools
.whenComplete((ignored, error) -> pool.retainAll(Collections.emptySet()));
@@ -99,18 +99,19 @@ void shouldBeAbleToClosePoolInIOWorkerThread() throws Throwable {
@Test
void shouldFailToAcquireConnectionToWrongAddress() {
ServiceUnavailableException e = assertThrows(
- ServiceUnavailableException.class, () -> await(pool.acquire(new BoltServerAddress("wrong-localhost"))));
+ ServiceUnavailableException.class,
+ () -> await(pool.acquire(new BoltServerAddress("wrong-localhost"), null)));
assertThat(e.getMessage(), startsWith("Unable to connect"));
}
@Test
void shouldFailToAcquireWhenPoolClosed() {
- Connection connection = await(pool.acquire(neo4j.address()));
+ Connection connection = await(pool.acquire(neo4j.address(), null));
await(connection.release());
await(pool.close());
- IllegalStateException e = assertThrows(IllegalStateException.class, () -> pool.acquire(neo4j.address()));
+ IllegalStateException e = assertThrows(IllegalStateException.class, () -> pool.acquire(neo4j.address(), null));
assertThat(e.getMessage(), startsWith("Pool closed"));
}
@@ -122,19 +123,19 @@ void shouldNotCloseWhenClosed() {
@Test
void shouldFailToAcquireConnectionWhenPoolIsClosed() {
- await(pool.acquire(neo4j.address()));
+ await(pool.acquire(neo4j.address(), null));
ExtendedChannelPool channelPool = this.pool.getPool(neo4j.address());
await(channelPool.close());
ServiceUnavailableException error =
- assertThrows(ServiceUnavailableException.class, () -> await(pool.acquire(neo4j.address())));
+ assertThrows(ServiceUnavailableException.class, () -> await(pool.acquire(neo4j.address(), null)));
assertThat(error.getMessage(), containsString("closed while acquiring a connection"));
assertThat(error.getCause(), instanceOf(IllegalStateException.class));
assertThat(error.getCause().getMessage(), containsString("FixedChannelPool was closed"));
}
- private ConnectionPoolImpl newPool() throws Exception {
+ private ConnectionPoolImpl newPool() {
FakeClock clock = new FakeClock();
- ConnectionSettings connectionSettings = new ConnectionSettings(neo4j.authToken(), "test", 5000);
+ ConnectionSettings connectionSettings = new ConnectionSettings(neo4j.authTokenManager(), "test", 5000);
ChannelConnector connector = new ChannelConnectorImpl(
connectionSettings,
SecurityPlanImpl.insecure(),
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImplTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImplTest.java
index 993e1d167d..20d7a17cc2 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImplTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImplTest.java
@@ -35,6 +35,7 @@
import io.netty.channel.Channel;
import java.util.HashSet;
import java.util.concurrent.ExecutionException;
+import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.neo4j.driver.internal.BoltServerAddress;
@@ -61,9 +62,9 @@ void shouldRetainSpecifiedAddresses() {
NettyChannelTracker nettyChannelTracker = mock(NettyChannelTracker.class);
TestConnectionPool pool = newConnectionPool(nettyChannelTracker);
- pool.acquire(ADDRESS_1);
- pool.acquire(ADDRESS_2);
- pool.acquire(ADDRESS_3);
+ pool.acquire(ADDRESS_1, null);
+ pool.acquire(ADDRESS_2, null);
+ pool.acquire(ADDRESS_3, null);
pool.retainAll(new HashSet<>(asList(ADDRESS_1, ADDRESS_2, ADDRESS_3)));
for (ExtendedChannelPool channelPool : pool.channelPoolsByAddress.values()) {
@@ -76,9 +77,9 @@ void shouldClosePoolsWhenRetaining() {
NettyChannelTracker nettyChannelTracker = mock(NettyChannelTracker.class);
TestConnectionPool pool = newConnectionPool(nettyChannelTracker);
- pool.acquire(ADDRESS_1);
- pool.acquire(ADDRESS_2);
- pool.acquire(ADDRESS_3);
+ pool.acquire(ADDRESS_1, null);
+ pool.acquire(ADDRESS_2, null);
+ pool.acquire(ADDRESS_3, null);
when(nettyChannelTracker.inUseChannelCount(ADDRESS_1)).thenReturn(2);
when(nettyChannelTracker.inUseChannelCount(ADDRESS_2)).thenReturn(0);
@@ -95,9 +96,9 @@ void shouldNotClosePoolsWithActiveConnectionsWhenRetaining() {
NettyChannelTracker nettyChannelTracker = mock(NettyChannelTracker.class);
TestConnectionPool pool = newConnectionPool(nettyChannelTracker);
- pool.acquire(ADDRESS_1);
- pool.acquire(ADDRESS_2);
- pool.acquire(ADDRESS_3);
+ pool.acquire(ADDRESS_1, null);
+ pool.acquire(ADDRESS_2, null);
+ pool.acquire(ADDRESS_3, null);
when(nettyChannelTracker.inUseChannelCount(ADDRESS_1)).thenReturn(1);
when(nettyChannelTracker.inUseChannelCount(ADDRESS_2)).thenReturn(42);
@@ -109,6 +110,7 @@ void shouldNotClosePoolsWithActiveConnectionsWhenRetaining() {
assertTrue(pool.getPool(ADDRESS_3).isClosed());
}
+ @Disabled("to fix")
@Test
void shouldRegisterAuthorizationStateListenerWithChannel() throws ExecutionException, InterruptedException {
NettyChannelTracker nettyChannelTracker = mock(NettyChannelTracker.class);
@@ -116,7 +118,7 @@ void shouldRegisterAuthorizationStateListenerWithChannel() throws ExecutionExcep
ArgumentCaptor channelArgumentCaptor = ArgumentCaptor.forClass(Channel.class);
TestConnectionPool pool = newConnectionPool(nettyChannelTracker, nettyChannelHealthChecker);
- pool.acquire(ADDRESS_1).toCompletableFuture().get();
+ pool.acquire(ADDRESS_1, null).toCompletableFuture().get();
verify(nettyChannelTracker).channelAcquired(channelArgumentCaptor.capture());
Channel channel = channelArgumentCaptor.getValue();
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/pool/NettyChannelHealthCheckerTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/pool/NettyChannelHealthCheckerTest.java
index a536cefe63..67de25bcbb 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/pool/NettyChannelHealthCheckerTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/pool/NettyChannelHealthCheckerTest.java
@@ -18,13 +18,23 @@
*/
package org.neo4j.driver.internal.async.pool;
+import static java.util.concurrent.CompletableFuture.completedFuture;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.junit.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.then;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.authContext;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setAuthContext;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setCreationTimestamp;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setLastUsedTimestamp;
import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setMessageDispatcher;
+import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setProtocolVersion;
import static org.neo4j.driver.internal.async.pool.PoolSettings.DEFAULT_CONNECTION_ACQUISITION_TIMEOUT;
import static org.neo4j.driver.internal.async.pool.PoolSettings.DEFAULT_IDLE_TIME_BEFORE_CONNECTION_TEST;
import static org.neo4j.driver.internal.async.pool.PoolSettings.DEFAULT_MAX_CONNECTION_POOL_SIZE;
@@ -33,22 +43,34 @@
import static org.neo4j.driver.internal.util.Iterables.single;
import static org.neo4j.driver.testutil.TestUtil.await;
-import io.netty.channel.Channel;
import io.netty.channel.embedded.EmbeddedChannel;
import io.netty.util.concurrent.Future;
import java.time.Clock;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
-import java.util.stream.Collectors;
import java.util.stream.IntStream;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.neo4j.driver.AuthTokenManager;
+import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.Value;
import org.neo4j.driver.exceptions.AuthorizationExpiredException;
import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher;
+import org.neo4j.driver.internal.messaging.BoltProtocolVersion;
import org.neo4j.driver.internal.messaging.request.ResetMessage;
+import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3;
+import org.neo4j.driver.internal.messaging.v4.BoltProtocolV4;
+import org.neo4j.driver.internal.messaging.v41.BoltProtocolV41;
+import org.neo4j.driver.internal.messaging.v42.BoltProtocolV42;
+import org.neo4j.driver.internal.messaging.v43.BoltProtocolV43;
+import org.neo4j.driver.internal.messaging.v44.BoltProtocolV44;
+import org.neo4j.driver.internal.messaging.v5.BoltProtocolV5;
+import org.neo4j.driver.internal.messaging.v51.BoltProtocolV51;
+import org.neo4j.driver.internal.security.StaticAuthTokenManager;
class NettyChannelHealthCheckerTest {
private final EmbeddedChannel channel = new EmbeddedChannel();
@@ -57,6 +79,10 @@ class NettyChannelHealthCheckerTest {
@BeforeEach
void setUp() {
setMessageDispatcher(channel, dispatcher);
+ var authContext = new AuthContext(new StaticAuthTokenManager(AuthTokens.none()));
+ authContext.initiateAuth(AuthTokens.none());
+ authContext.finishAuth(Clock.systemUTC().millis());
+ setAuthContext(channel, authContext);
}
@AfterEach
@@ -92,41 +118,110 @@ void shouldAllowVeryOldChannelsWhenMaxLifetimeDisabled() {
setCreationTimestamp(channel, 0);
Future healthy = healthChecker.isHealthy(channel);
+ channel.runPendingTasks();
assertThat(await(healthy), is(true));
}
- @Test
- void shouldFailAllConnectionsCreatedOnOrBeforeExpirationTimestamp() {
+ public static List boltVersionsBefore51() {
+ return List.of(
+ BoltProtocolV3.VERSION,
+ BoltProtocolV4.VERSION,
+ BoltProtocolV41.VERSION,
+ BoltProtocolV42.VERSION,
+ BoltProtocolV43.VERSION,
+ BoltProtocolV44.VERSION,
+ BoltProtocolV5.VERSION);
+ }
+
+ @ParameterizedTest
+ @MethodSource("boltVersionsBefore51")
+ void shouldFailAllConnectionsCreatedOnOrBeforeExpirationTimestamp(BoltProtocolVersion boltProtocolVersion) {
PoolSettings settings = new PoolSettings(
DEFAULT_MAX_CONNECTION_POOL_SIZE,
DEFAULT_CONNECTION_ACQUISITION_TIMEOUT,
NOT_CONFIGURED,
DEFAULT_IDLE_TIME_BEFORE_CONNECTION_TEST);
- Clock clock = Clock.systemUTC();
+ Clock clock = mock(Clock.class);
NettyChannelHealthChecker healthChecker = newHealthChecker(settings, clock);
- long initialTimestamp = clock.millis();
- List channels = IntStream.range(0, 100)
+ var authToken = AuthTokens.basic("username", "password");
+ var authTokenManager = mock(AuthTokenManager.class);
+ given(authTokenManager.getToken()).willReturn(completedFuture(authToken));
+ List channels = IntStream.range(0, 100)
.mapToObj(i -> {
- Channel channel = new EmbeddedChannel();
- setCreationTimestamp(channel, initialTimestamp + i);
+ var channel = new EmbeddedChannel();
+ setProtocolVersion(channel, boltProtocolVersion);
+ setCreationTimestamp(channel, i);
+ var authContext = mock(AuthContext.class);
+ setAuthContext(channel, authContext);
+ given(authContext.getAuthTokenManager()).willReturn(authTokenManager);
+ given(authContext.getAuthToken()).willReturn(authToken);
+ given(authContext.getAuthTimestamp()).willReturn((long) i);
return channel;
})
- .collect(Collectors.toList());
+ .toList();
int authorizationExpiredChannelIndex = channels.size() / 2 - 1;
+ given(clock.millis()).willReturn((long) authorizationExpiredChannelIndex);
healthChecker.onExpired(
new AuthorizationExpiredException("", ""), channels.get(authorizationExpiredChannelIndex));
for (int i = 0; i < channels.size(); i++) {
- Channel channel = channels.get(i);
- boolean health = Objects.requireNonNull(await(healthChecker.isHealthy(channel)));
+ var channel = channels.get(i);
+ var future = healthChecker.isHealthy(channel);
+ channel.runPendingTasks();
+ boolean health = Objects.requireNonNull(await(future));
boolean expectedHealth = i > authorizationExpiredChannelIndex;
assertEquals(expectedHealth, health, String.format("Channel %d has failed the check", i));
}
}
+ @Test
+ void shouldMarkForLogoffAllConnectionsCreatedOnOrBeforeExpirationTimestamp() {
+ PoolSettings settings = new PoolSettings(
+ DEFAULT_MAX_CONNECTION_POOL_SIZE,
+ DEFAULT_CONNECTION_ACQUISITION_TIMEOUT,
+ NOT_CONFIGURED,
+ DEFAULT_IDLE_TIME_BEFORE_CONNECTION_TEST);
+ Clock clock = mock(Clock.class);
+ NettyChannelHealthChecker healthChecker = newHealthChecker(settings, clock);
+
+ var authToken = AuthTokens.basic("username", "password");
+ var authTokenManager = mock(AuthTokenManager.class);
+ given(authTokenManager.getToken()).willReturn(completedFuture(authToken));
+ List channels = IntStream.range(0, 100)
+ .mapToObj(i -> {
+ var channel = new EmbeddedChannel();
+ setProtocolVersion(channel, BoltProtocolV51.VERSION);
+ setCreationTimestamp(channel, i);
+ var authContext = mock(AuthContext.class);
+ setAuthContext(channel, authContext);
+ given(authContext.getAuthTokenManager()).willReturn(authTokenManager);
+ given(authContext.getAuthToken()).willReturn(authToken);
+ given(authContext.getAuthTimestamp()).willReturn((long) i);
+ return channel;
+ })
+ .toList();
+
+ int authorizationExpiredChannelIndex = channels.size() / 2 - 1;
+ given(clock.millis()).willReturn((long) authorizationExpiredChannelIndex);
+ healthChecker.onExpired(
+ new AuthorizationExpiredException("", ""), channels.get(authorizationExpiredChannelIndex));
+
+ for (int i = 0; i < channels.size(); i++) {
+ var channel = channels.get(i);
+ var future = healthChecker.isHealthy(channel);
+ channel.runPendingTasks();
+ boolean health = Objects.requireNonNull(await(future));
+ assertTrue(health, String.format("Channel %d has failed the check", i));
+ boolean pendingLogoff = i <= authorizationExpiredChannelIndex;
+ then(authContext(channel))
+ .should(pendingLogoff ? times(1) : never())
+ .markPendingLogoff();
+ }
+ }
+
@Test
void shouldUseGreatestExpirationTimestamp() {
PoolSettings settings = new PoolSettings(
@@ -138,16 +233,22 @@ void shouldUseGreatestExpirationTimestamp() {
NettyChannelHealthChecker healthChecker = newHealthChecker(settings, clock);
long initialTimestamp = clock.millis();
- Channel channel1 = new EmbeddedChannel();
- Channel channel2 = new EmbeddedChannel();
+ var channel1 = new EmbeddedChannel();
+ var channel2 = new EmbeddedChannel();
setCreationTimestamp(channel1, initialTimestamp);
setCreationTimestamp(channel2, initialTimestamp + 100);
+ setAuthContext(channel1, new AuthContext(new StaticAuthTokenManager(AuthTokens.none())));
+ setAuthContext(channel2, new AuthContext(new StaticAuthTokenManager(AuthTokens.none())));
healthChecker.onExpired(new AuthorizationExpiredException("", ""), channel2);
healthChecker.onExpired(new AuthorizationExpiredException("", ""), channel1);
- assertFalse(Objects.requireNonNull(await(healthChecker.isHealthy(channel1))));
- assertFalse(Objects.requireNonNull(await(healthChecker.isHealthy(channel2))));
+ var healthy = healthChecker.isHealthy(channel1);
+ channel1.runPendingTasks();
+ assertFalse(Objects.requireNonNull(await(healthy)));
+ healthy = healthChecker.isHealthy(channel2);
+ channel2.runPendingTasks();
+ assertFalse(Objects.requireNonNull(await(healthy)));
}
@Test
@@ -184,6 +285,7 @@ private void testPing(boolean resetMessageSuccessful) {
setLastUsedTimestamp(channel, clock.millis() - idleTimeBeforeConnectionTest * 2);
Future healthy = healthChecker.isHealthy(channel);
+ channel.runPendingTasks();
assertEquals(ResetMessage.RESET, single(channel.outboundMessages()));
assertFalse(healthy.isDone());
@@ -210,10 +312,12 @@ private void testActiveConnectionCheck(boolean channelActive) {
if (channelActive) {
Future healthy = healthChecker.isHealthy(channel);
+ channel.runPendingTasks();
assertThat(await(healthy), is(true));
} else {
channel.close().syncUninterruptibly();
Future healthy = healthChecker.isHealthy(channel);
+ channel.runPendingTasks();
assertThat(await(healthy), is(false));
}
}
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/pool/NettyChannelPoolIT.java b/driver/src/test/java/org/neo4j/driver/internal/async/pool/NettyChannelPoolIT.java
index 2f83714237..f94cd03db8 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/pool/NettyChannelPoolIT.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/pool/NettyChannelPoolIT.java
@@ -26,6 +26,7 @@
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
import static org.neo4j.driver.Values.value;
import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING;
import static org.neo4j.driver.testutil.TestUtil.await;
@@ -33,6 +34,7 @@
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.pool.ChannelHealthChecker;
+import java.time.Clock;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeoutException;
@@ -40,7 +42,8 @@
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
-import org.neo4j.driver.AuthToken;
+import org.mockito.invocation.InvocationOnMock;
+import org.neo4j.driver.AuthTokenManager;
import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.Value;
import org.neo4j.driver.exceptions.AuthenticationException;
@@ -52,8 +55,12 @@
import org.neo4j.driver.internal.metrics.DevNullMetricsListener;
import org.neo4j.driver.internal.security.InternalAuthToken;
import org.neo4j.driver.internal.security.SecurityPlanImpl;
+import org.neo4j.driver.internal.security.StaticAuthTokenManager;
+import org.neo4j.driver.internal.util.DisabledOnNeo4jWith;
+import org.neo4j.driver.internal.util.EnabledOnNeo4jWith;
import org.neo4j.driver.internal.util.FakeClock;
import org.neo4j.driver.internal.util.ImmediateSchedulingEventExecutor;
+import org.neo4j.driver.internal.util.Neo4jFeature;
import org.neo4j.driver.testutil.DatabaseExtension;
import org.neo4j.driver.testutil.ParallelizableIT;
@@ -66,6 +73,10 @@ class NettyChannelPoolIT {
private NettyChannelTracker poolHandler;
private NettyChannelPool pool;
+ private static Object answer(InvocationOnMock a) {
+ return ChannelHealthChecker.ACTIVE.isHealthy(a.getArgument(0));
+ }
+
@BeforeEach
void setUp() {
bootstrap = BootstrapFactory.newBootstrap(1);
@@ -83,10 +94,10 @@ void tearDown() {
}
@Test
- void shouldAcquireAndReleaseWithCorrectCredentials() throws Exception {
- pool = newPool(neo4j.authToken());
+ void shouldAcquireAndReleaseWithCorrectCredentials() {
+ pool = newPool(neo4j.authTokenManager());
- Channel channel = await(pool.acquire());
+ Channel channel = await(pool.acquire(null));
assertNotNull(channel);
verify(poolHandler).channelCreated(eq(channel), any());
verify(poolHandler, never()).channelReleased(channel);
@@ -95,16 +106,28 @@ void shouldAcquireAndReleaseWithCorrectCredentials() throws Exception {
verify(poolHandler).channelReleased(channel);
}
+ @DisabledOnNeo4jWith(Neo4jFeature.BOLT_V51)
@Test
- void shouldFailToAcquireWithWrongCredentials() throws Exception {
- pool = newPool(AuthTokens.basic("wrong", "wrong"));
+ void shouldFailToAcquireWithWrongCredentialsBolt50AndBelow() {
+ pool = newPool(new StaticAuthTokenManager(AuthTokens.basic("wrong", "wrong")));
- assertThrows(AuthenticationException.class, () -> await(pool.acquire()));
+ assertThrows(AuthenticationException.class, () -> await(pool.acquire(null)));
verify(poolHandler, never()).channelCreated(any());
verify(poolHandler, never()).channelReleased(any());
}
+ @EnabledOnNeo4jWith(Neo4jFeature.BOLT_V51)
+ @Test
+ void shouldFailToAcquireWithWrongCredentials() {
+ pool = newPool(new StaticAuthTokenManager(AuthTokens.basic("wrong", "wrong")));
+
+ assertThrows(AuthenticationException.class, () -> await(pool.acquire(null)));
+
+ verify(poolHandler).channelCreated(any(), any());
+ verify(poolHandler).channelReleased(any());
+ }
+
@Test
void shouldAllowAcquireAfterFailures() throws Exception {
int maxConnections = 2;
@@ -115,7 +138,7 @@ void shouldAllowAcquireAfterFailures() throws Exception {
authTokenMap.put("credentials", value("wrong"));
InternalAuthToken authToken = new InternalAuthToken(authTokenMap);
- pool = newPool(authToken, maxConnections);
+ pool = newPool(new StaticAuthTokenManager(authToken), maxConnections);
for (int i = 0; i < maxConnections; i++) {
AuthenticationException e = assertThrows(AuthenticationException.class, () -> acquire(pool));
@@ -129,7 +152,7 @@ void shouldAllowAcquireAfterFailures() throws Exception {
@Test
void shouldLimitNumberOfConcurrentConnections() throws Exception {
int maxConnections = 5;
- pool = newPool(neo4j.authToken(), maxConnections);
+ pool = newPool(neo4j.authTokenManager(), maxConnections);
for (int i = 0; i < maxConnections; i++) {
assertNotNull(acquire(pool));
@@ -145,7 +168,7 @@ void shouldTrackActiveChannels() throws Exception {
DevNullMetricsListener.INSTANCE, new ImmediateSchedulingEventExecutor(), DEV_NULL_LOGGING);
poolHandler = tracker;
- pool = newPool(neo4j.authToken());
+ pool = newPool(neo4j.authTokenManager());
Channel channel1 = acquire(pool);
Channel channel2 = acquire(pool);
@@ -162,12 +185,12 @@ void shouldTrackActiveChannels() throws Exception {
assertEquals(2, tracker.inUseChannelCount(neo4j.address()));
}
- private NettyChannelPool newPool(AuthToken authToken) {
- return newPool(authToken, 100);
+ private NettyChannelPool newPool(AuthTokenManager authTokenManager) {
+ return newPool(authTokenManager, 100);
}
- private NettyChannelPool newPool(AuthToken authToken, int maxConnections) {
- ConnectionSettings settings = new ConnectionSettings(authToken, "test", 5_000);
+ private NettyChannelPool newPool(AuthTokenManager authTokenManager, int maxConnections) {
+ ConnectionSettings settings = new ConnectionSettings(authTokenManager, "test", 5_000);
ChannelConnectorImpl connector = new ChannelConnectorImpl(
settings,
SecurityPlanImpl.insecure(),
@@ -176,15 +199,24 @@ private NettyChannelPool newPool(AuthToken authToken, int maxConnections) {
RoutingContext.EMPTY,
DefaultDomainNameResolver.getInstance(),
null);
+ var nettyChannelHealthChecker = mock(NettyChannelHealthChecker.class);
+ when(nettyChannelHealthChecker.isHealthy(any())).thenAnswer(NettyChannelPoolIT::answer);
return new NettyChannelPool(
- neo4j.address(), connector, bootstrap, poolHandler, ChannelHealthChecker.ACTIVE, 1_000, maxConnections);
+ neo4j.address(),
+ connector,
+ bootstrap,
+ poolHandler,
+ nettyChannelHealthChecker,
+ 1_000,
+ maxConnections,
+ Clock.systemUTC());
}
- private static Channel acquire(NettyChannelPool pool) throws Exception {
- return await(pool.acquire());
+ private static Channel acquire(NettyChannelPool pool) {
+ return await(pool.acquire(null));
}
- private void release(Channel channel) throws Exception {
+ private void release(Channel channel) {
await(pool.release(channel));
}
}
diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/pool/TestConnectionPool.java b/driver/src/test/java/org/neo4j/driver/internal/async/pool/TestConnectionPool.java
index 2ecab71a37..38a729ac1d 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/async/pool/TestConnectionPool.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/async/pool/TestConnectionPool.java
@@ -33,6 +33,7 @@
import java.util.Map;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.atomic.AtomicBoolean;
+import org.neo4j.driver.AuthToken;
import org.neo4j.driver.Logging;
import org.neo4j.driver.internal.BoltServerAddress;
import org.neo4j.driver.internal.async.connection.ChannelConnector;
@@ -57,7 +58,6 @@ public TestConnectionPool(
mock(ChannelConnector.class),
bootstrap,
nettyChannelTracker,
- nettyChannelHealthChecker,
settings,
metricsListener,
logging,
@@ -77,7 +77,7 @@ ExtendedChannelPool newPool(BoltServerAddress address) {
private final AtomicBoolean isClosed = new AtomicBoolean(false);
@Override
- public CompletionStage acquire() {
+ public CompletionStage acquire(AuthToken overrideAuthToken) {
EmbeddedChannel channel = new EmbeddedChannel();
setServerAddress(channel, address);
setPoolId(channel, id());
@@ -111,6 +111,11 @@ public CompletionStage close() {
isClosed.set(true);
return completedWithNull();
}
+
+ @Override
+ public NettyChannelHealthChecker healthChecker() {
+ return mock(NettyChannelHealthChecker.class);
+ }
};
channelPoolsByAddress.put(address, channelPool);
return channelPool;
diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/RediscoveryTest.java b/driver/src/test/java/org/neo4j/driver/internal/cluster/RediscoveryTest.java
index 003078fada..b826260c53 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/cluster/RediscoveryTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/cluster/RediscoveryTest.java
@@ -54,12 +54,14 @@
import java.util.List;
import java.util.Map;
import java.util.Set;
+import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.ArgumentCaptor;
import org.neo4j.driver.Logger;
import org.neo4j.driver.Logging;
+import org.neo4j.driver.exceptions.AuthTokenManagerExecutionException;
import org.neo4j.driver.exceptions.AuthenticationException;
import org.neo4j.driver.exceptions.AuthorizationExpiredException;
import org.neo4j.driver.exceptions.ClientException;
@@ -67,6 +69,7 @@
import org.neo4j.driver.exceptions.ProtocolException;
import org.neo4j.driver.exceptions.ServiceUnavailableException;
import org.neo4j.driver.exceptions.SessionExpiredException;
+import org.neo4j.driver.exceptions.UnsupportedFeatureException;
import org.neo4j.driver.internal.BoltServerAddress;
import org.neo4j.driver.internal.DatabaseName;
import org.neo4j.driver.internal.DefaultDomainNameResolver;
@@ -93,7 +96,7 @@ void shouldUseFirstRouterInTable() {
RoutingTable table = routingTableMock(B);
ClusterComposition actualComposition = await(
- rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null))
+ rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))
.getClusterComposition();
assertEquals(expectedComposition, actualComposition);
@@ -115,7 +118,7 @@ void shouldSkipFailingRouters() {
RoutingTable table = routingTableMock(A, B, C);
ClusterComposition actualComposition = await(
- rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null))
+ rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))
.getClusterComposition();
assertEquals(expectedComposition, actualComposition);
@@ -139,7 +142,7 @@ void shouldFailImmediatelyOnAuthError() {
AuthenticationException error = assertThrows(
AuthenticationException.class,
- () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null)));
+ () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)));
assertEquals(authError, error);
verify(table).forget(A);
}
@@ -159,7 +162,7 @@ void shouldUseAnotherRouterOnAuthorizationExpiredException() {
RoutingTable table = routingTableMock(A, B, C);
ClusterComposition actualComposition = await(
- rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null))
+ rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))
.getClusterComposition();
assertEquals(expectedComposition, actualComposition);
@@ -187,7 +190,7 @@ void shouldFailImmediatelyOnBookmarkErrors(String code) {
ClientException actualError = assertThrows(
ClientException.class,
- () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null)));
+ () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)));
assertEquals(error, actualError);
verify(table).forget(A);
}
@@ -206,7 +209,7 @@ void shouldFailImmediatelyOnClosedPoolError() {
IllegalStateException actualError = assertThrows(
IllegalStateException.class,
- () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null)));
+ () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)));
assertEquals(error, actualError);
verify(table).forget(A);
}
@@ -228,7 +231,7 @@ void shouldFallbackToInitialRouterWhenKnownRoutersFail() {
RoutingTable table = routingTableMock(B, C);
ClusterComposition actualComposition = await(
- rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null))
+ rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))
.getClusterComposition();
assertEquals(expectedComposition, actualComposition);
@@ -236,6 +239,7 @@ void shouldFallbackToInitialRouterWhenKnownRoutersFail() {
verify(table).forget(C);
}
+ @Disabled("this test looks wrong")
@Test
void shouldFailImmediatelyWhenClusterCompositionProviderReturnsFailure() {
ClusterComposition validComposition =
@@ -256,7 +260,7 @@ void shouldFailImmediatelyWhenClusterCompositionProviderReturnsFailure() {
// When
ClusterComposition composition = await(
- rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null))
+ rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))
.getClusterComposition();
assertEquals(validComposition, composition);
@@ -290,7 +294,7 @@ void shouldResolveInitialRouterAddress() {
RoutingTable table = routingTableMock(B, C);
ClusterComposition actualComposition = await(
- rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null))
+ rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))
.getClusterComposition();
assertEquals(expectedComposition, actualComposition);
@@ -319,7 +323,7 @@ void shouldResolveInitialRouterAddressUsingCustomResolver() {
RoutingTable table = routingTableMock(B, C);
ClusterComposition actualComposition = await(
- rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null))
+ rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))
.getClusterComposition();
assertEquals(expectedComposition, actualComposition);
@@ -344,7 +348,7 @@ void shouldPropagateFailureWhenResolverFails() {
RuntimeException error = assertThrows(
RuntimeException.class,
- () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null)));
+ () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)));
assertEquals("Resolver fails!", error.getMessage());
verify(resolver).resolve(A);
@@ -367,7 +371,7 @@ void shouldRecordAllErrorsWhenNoRouterRespond() {
ServiceUnavailableException e = assertThrows(
ServiceUnavailableException.class,
- () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null)));
+ () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)));
assertThat(e.getMessage(), containsString("Could not perform discovery"));
assertThat(e.getSuppressed().length, equalTo(3));
assertThat(e.getSuppressed()[0].getCause(), equalTo(first));
@@ -393,7 +397,7 @@ void shouldUseInitialRouterAfterDiscoveryReturnsNoWriters() {
table.update(noWritersComposition);
ClusterComposition composition2 = await(
- rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null))
+ rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))
.getClusterComposition();
assertEquals(validComposition, composition2);
}
@@ -413,7 +417,7 @@ void shouldUseInitialRouterToStartWith() {
RoutingTable table = routingTableMock(true, B, C, D);
ClusterComposition composition = await(
- rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null))
+ rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))
.getClusterComposition();
assertEquals(validComposition, composition);
}
@@ -435,7 +439,7 @@ void shouldUseKnownRoutersWhenInitialRouterFails() {
RoutingTable table = routingTableMock(true, D, E);
ClusterComposition composition = await(
- rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null))
+ rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))
.getClusterComposition();
assertEquals(validComposition, composition);
verify(table).forget(initialRouter);
@@ -458,7 +462,7 @@ void shouldNotLogWhenSingleRetryAttemptFails() {
ServiceUnavailableException e = assertThrows(
ServiceUnavailableException.class,
- () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null)));
+ () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)));
assertThat(e.getMessage(), containsString("Could not perform discovery"));
// rediscovery should not log about retries and should not schedule any retries
@@ -483,6 +487,44 @@ void shouldResolveToIP() throws UnknownHostException {
assertEquals(new BoltServerAddress(A.host(), localhost.getHostAddress(), A.port()), addresses.get(0));
}
+ @Test
+ void shouldFailImmediatelyOnAuthTokenManagerExecutionException() {
+ var exception = new AuthTokenManagerExecutionException("message", mock(Throwable.class));
+
+ Map responsesByAddress = new HashMap<>();
+ responsesByAddress.put(A, new RuntimeException("Hi!")); // first router -> non-fatal failure
+ responsesByAddress.put(B, exception); // second router -> fatal auth error
+
+ ClusterCompositionProvider compositionProvider = compositionProviderMock(responsesByAddress);
+ Rediscovery rediscovery = newRediscovery(A, compositionProvider, mock(ServerAddressResolver.class));
+ RoutingTable table = routingTableMock(A, B, C);
+
+ var actualException = assertThrows(
+ AuthTokenManagerExecutionException.class,
+ () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)));
+ assertEquals(exception, actualException);
+ verify(table).forget(A);
+ }
+
+ @Test
+ void shouldFailImmediatelyOnUnsupportedFeatureException() {
+ var exception = new UnsupportedFeatureException("message", mock(Throwable.class));
+
+ Map responsesByAddress = new HashMap<>();
+ responsesByAddress.put(A, new RuntimeException("Hi!")); // first router -> non-fatal failure
+ responsesByAddress.put(B, exception); // second router -> fatal auth error
+
+ ClusterCompositionProvider compositionProvider = compositionProviderMock(responsesByAddress);
+ Rediscovery rediscovery = newRediscovery(A, compositionProvider, mock(ServerAddressResolver.class));
+ RoutingTable table = routingTableMock(A, B, C);
+
+ var actualException = assertThrows(
+ UnsupportedFeatureException.class,
+ () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)));
+ assertEquals(exception, actualException);
+ verify(table).forget(A);
+ }
+
private Rediscovery newRediscovery(
BoltServerAddress initialRouter,
ClusterCompositionProvider compositionProvider,
@@ -526,7 +568,7 @@ private static ServerAddressResolver resolverMock(BoltServerAddress address, Bol
private static ConnectionPool asyncConnectionPoolMock() {
ConnectionPool pool = mock(ConnectionPool.class);
- when(pool.acquire(any())).then(invocation -> {
+ when(pool.acquire(any(), any())).then(invocation -> {
BoltServerAddress address = invocation.getArgument(0);
return completedFuture(asyncConnectionMock(address));
});
diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingTableHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingTableHandlerTest.java
index 1de0071440..dfd5dfa130 100644
--- a/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingTableHandlerTest.java
+++ b/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingTableHandlerTest.java
@@ -107,14 +107,14 @@ void acquireShouldUpdateRoutingTableWhenKnownRoutingTableIsStale() {
Set routers = new LinkedHashSet<>(singletonList(router1));
ClusterComposition clusterComposition = new ClusterComposition(42, readers, writers, routers, null);
Rediscovery rediscovery = mock(RediscoveryImpl.class);
- when(rediscovery.lookupClusterComposition(eq(routingTable), eq(connectionPool), any(), any()))
+ when(rediscovery.lookupClusterComposition(eq(routingTable), eq(connectionPool), any(), any(), any()))
.thenReturn(completedFuture(new ClusterCompositionLookupResult(clusterComposition)));
RoutingTableHandler handler = newRoutingTableHandler(routingTable, rediscovery, connectionPool);
assertNotNull(await(handler.ensureRoutingTable(simple(false))));
- verify(rediscovery).lookupClusterComposition(eq(routingTable), eq(connectionPool), any(), any());
+ verify(rediscovery).lookupClusterComposition(eq(routingTable), eq(connectionPool), any(), any(), any());
assertArrayEquals(
new BoltServerAddress[] {reader1, reader2},
routingTable.readers().toArray());
@@ -152,7 +152,7 @@ void shouldRetainAllFetchedAddressesInConnectionPoolAfterFetchingOfRoutingTable(
ConnectionPool connectionPool = newConnectionPoolMock();
Rediscovery rediscovery = newRediscoveryMock();
- when(rediscovery.lookupClusterComposition(any(), any(), any(), any()))
+ when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any()))
.thenReturn(completedFuture(new ClusterCompositionLookupResult(
new ClusterComposition(42, asOrderedSet(A, B), asOrderedSet(B, C), asOrderedSet(A, C), null))));
@@ -195,7 +195,7 @@ void shouldRemoveRoutingTableHandlerIfFailedToLookup() throws Throwable {
RoutingTable routingTable = new ClusterRoutingTable(defaultDatabase(), new FakeClock());
Rediscovery rediscovery = newRediscoveryMock();
- when(rediscovery.lookupClusterComposition(any(), any(), any(), any()))
+ when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any()))
.thenReturn(Futures.failedFuture(new RuntimeException("Bang!")));
ConnectionPool connectionPool = newConnectionPoolMock();
@@ -211,7 +211,7 @@ void shouldRemoveRoutingTableHandlerIfFailedToLookup() throws Throwable {
private void testRediscoveryWhenStale(AccessMode mode) {
ConnectionPool connectionPool = mock(ConnectionPool.class);
- when(connectionPool.acquire(LOCAL_DEFAULT)).thenReturn(completedFuture(mock(Connection.class)));
+ when(connectionPool.acquire(LOCAL_DEFAULT, null)).thenReturn(completedFuture(mock(Connection.class)));
RoutingTable routingTable = newStaleRoutingTableMock(mode);
Rediscovery rediscovery = newRediscoveryMock();
@@ -221,12 +221,12 @@ private void testRediscoveryWhenStale(AccessMode mode) {
assertEquals(routingTable, actual);
verify(routingTable).isStaleFor(mode);
- verify(rediscovery).lookupClusterComposition(eq(routingTable), eq(connectionPool), any(), any());
+ verify(rediscovery).lookupClusterComposition(eq(routingTable), eq(connectionPool), any(), any(), any());
}
private void testNoRediscoveryWhenNotStale(AccessMode staleMode, AccessMode notStaleMode) {
ConnectionPool connectionPool = mock(ConnectionPool.class);
- when(connectionPool.acquire(LOCAL_DEFAULT)).thenReturn(completedFuture(mock(Connection.class)));
+ when(connectionPool.acquire(LOCAL_DEFAULT, null)).thenReturn(completedFuture(mock(Connection.class)));
RoutingTable routingTable = newStaleRoutingTableMock(staleMode);
Rediscovery rediscovery = newRediscoveryMock();
@@ -235,7 +235,8 @@ private void testNoRediscoveryWhenNotStale(AccessMode staleMode, AccessMode notS
assertNotNull(await(handler.ensureRoutingTable(contextWithMode(notStaleMode))));
verify(routingTable).isStaleFor(notStaleMode);
- verify(rediscovery, never()).lookupClusterComposition(eq(routingTable), eq(connectionPool), any(), any());
+ verify(rediscovery, never())
+ .lookupClusterComposition(eq(routingTable), eq(connectionPool), any(), any(), any());
}
private static RoutingTable newStaleRoutingTableMock(AccessMode mode) {
@@ -258,7 +259,8 @@ private static Rediscovery newRediscoveryMock() {
Rediscovery rediscovery = mock(RediscoveryImpl.class);
Set noServers = Collections.emptySet();
ClusterComposition clusterComposition = new ClusterComposition(1, noServers, noServers, noServers, null);
- when(rediscovery.lookupClusterComposition(any(RoutingTable.class), any(ConnectionPool.class), any(), any()))
+ when(rediscovery.lookupClusterComposition(
+ any(RoutingTable.class), any(ConnectionPool.class), any(), any(), any()))
.thenReturn(completedFuture(new ClusterCompositionLookupResult(clusterComposition)));
return rediscovery;
}
@@ -269,7 +271,7 @@ private static ConnectionPool newConnectionPoolMock() {
private static ConnectionPool newConnectionPoolMockWithFailures(Set