diff --git a/benchkit-backend/LICENSES.txt b/benchkit-backend/LICENSES.txt new file mode 100644 index 0000000000..836ba67225 --- /dev/null +++ b/benchkit-backend/LICENSES.txt @@ -0,0 +1,250 @@ +This file contains the full license text of the included third party +libraries. For an overview of the licenses see the NOTICE.txt file. + + +------------------------------------------------------------------------------ +Apache Software License, Version 2.0 + Jackson-annotations + Jackson-core + jackson-databind + Netty/Buffer + Netty/Codec + Netty/Codec/HTTP + Netty/Common + Netty/Handler + Netty/Resolver + Netty/TomcatNative [OpenSSL - Classes] + Netty/Transport + Netty/Transport/Native/Unix/Common + Non-Blocking Reactive Foundation for the JVM +------------------------------------------------------------------------------ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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. + + + +------------------------------------------------------------------------------ +MIT No Attribution License + reactive-streams +------------------------------------------------------------------------------ + +MIT No Attribution + +Copyright + +Permission is hereby granted, free of charge, to any person obtaining a copy of this +software and associated documentation files (the "Software"), to deal in the Software +without restriction, including without limitation the rights to use, copy, modify, +merge, publish, distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + + + diff --git a/benchkit-backend/NOTICE.txt b/benchkit-backend/NOTICE.txt new file mode 100644 index 0000000000..d1f14e0749 --- /dev/null +++ b/benchkit-backend/NOTICE.txt @@ -0,0 +1,38 @@ +Copyright (c) "Neo4j" +Neo4j Sweden AB [https://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. + +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. + +Full license texts are found in LICENSES.txt. + + +Third-party licenses +-------------------- + +Apache Software License, Version 2.0 + Jackson-annotations + Jackson-core + jackson-databind + Netty/Buffer + Netty/Codec + Netty/Codec/HTTP + Netty/Common + Netty/Handler + Netty/Resolver + Netty/TomcatNative [OpenSSL - Classes] + Netty/Transport + Netty/Transport/Native/Unix/Common + Non-Blocking Reactive Foundation for the JVM + +MIT No Attribution License + reactive-streams + diff --git a/benchkit-backend/pom.xml b/benchkit-backend/pom.xml new file mode 100644 index 0000000000..442e88a26d --- /dev/null +++ b/benchkit-backend/pom.xml @@ -0,0 +1,90 @@ + + + 4.0.0 + + + neo4j-java-driver-parent + org.neo4j.driver + 5.18-SNAPSHOT + + + benchkit-backend + + Neo4j Java Driver Benchkit Backend + Integration component for use with Benchkit + https://github.com/neo4j/neo4j-java-driver + + + ${project.basedir}/.. + ,-processing + + + + + org.neo4j.driver + neo4j-java-driver + ${project.version} + + + io.netty + netty-handler + + + io.netty + netty-codec-http + + + com.fasterxml.jackson.core + jackson-core + + + com.fasterxml.jackson.core + jackson-databind + + + org.projectlombok + lombok + + + + + org.junit.jupiter + junit-jupiter + test + + + + + + + org.apache.maven.plugins + maven-shade-plugin + + + package + + shade + + + + + neo4j.org.testkit.backend.Runner + + + benchkit-backend + + + + + + + + + scm:git:git://github.com/neo4j/neo4j-java-driver.git + scm:git:git@github.com:neo4j/neo4j-java-driver.git + https://github.com/neo4j/neo4j-java-driver + + + diff --git a/benchkit-backend/src/main/java/neo4j/org/testkit/backend/Config.java b/benchkit-backend/src/main/java/neo4j/org/testkit/backend/Config.java new file mode 100644 index 0000000000..56f0e461e8 --- /dev/null +++ b/benchkit-backend/src/main/java/neo4j/org/testkit/backend/Config.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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 neo4j.org.testkit.backend; + +import java.net.URI; +import java.util.logging.Level; +import org.neo4j.driver.AuthToken; +import org.neo4j.driver.AuthTokens; +import org.neo4j.driver.Logging; + +public record Config(int port, URI uri, AuthToken authToken, Logging logging) { + static Config load() { + var env = System.getenv(); + var port = Integer.parseInt(env.getOrDefault("TEST_BACKEND_PORT", "9000")); + var neo4jHost = env.getOrDefault("TEST_NEO4J_HOST", "localhost"); + var neo4jPort = Integer.parseInt(env.getOrDefault("TEST_NEO4J_PORT", "7687")); + var neo4jScheme = env.getOrDefault("TEST_NEO4J_SCHEME", "neo4j"); + var neo4jUser = env.getOrDefault("TEST_NEO4J_USER", "neo4j"); + var neo4jPassword = env.getOrDefault("TEST_NEO4J_PASS", "password"); + var level = env.get("TEST_BACKEND_LOGGING_LEVEL"); + var logging = level == null || level.isEmpty() ? Logging.none() : Logging.console(Level.parse(level)); + return new Config( + port, + URI.create(String.format("%s://%s:%d", neo4jScheme, neo4jHost, neo4jPort)), + AuthTokens.basic(neo4jUser, neo4jPassword), + logging); + } +} diff --git a/benchkit-backend/src/main/java/neo4j/org/testkit/backend/Runner.java b/benchkit-backend/src/main/java/neo4j/org/testkit/backend/Runner.java new file mode 100644 index 0000000000..ee1948f60f --- /dev/null +++ b/benchkit-backend/src/main/java/neo4j/org/testkit/backend/Runner.java @@ -0,0 +1,67 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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 neo4j.org.testkit.backend; + +import io.netty.bootstrap.ServerBootstrap; +import io.netty.channel.ChannelInitializer; +import io.netty.channel.EventLoopGroup; +import io.netty.channel.nio.NioEventLoopGroup; +import io.netty.channel.socket.SocketChannel; +import io.netty.channel.socket.nio.NioServerSocketChannel; +import io.netty.handler.codec.http.HttpObjectAggregator; +import io.netty.handler.codec.http.HttpServerCodec; +import java.util.concurrent.Executors; +import neo4j.org.testkit.backend.channel.handler.HttpRequestHandler; +import neo4j.org.testkit.backend.handler.ReadyHandler; +import neo4j.org.testkit.backend.handler.WorkloadHandler; +import org.neo4j.driver.GraphDatabase; + +public class Runner { + public static void main(String[] args) throws InterruptedException { + var config = Config.load(); + var driver = GraphDatabase.driver( + config.uri(), + config.authToken(), + org.neo4j.driver.Config.builder().withLogging(config.logging()).build()); + + EventLoopGroup group = new NioEventLoopGroup(); + var logging = config.logging(); + var executor = Executors.newCachedThreadPool(); + var workloadHandler = new WorkloadHandler(driver, executor, logging); + var readyHandler = new ReadyHandler(driver, logging); + try { + var bootstrap = new ServerBootstrap(); + bootstrap + .group(group) + .channel(NioServerSocketChannel.class) + .localAddress(config.port()) + .childHandler(new ChannelInitializer() { + @Override + protected void initChannel(SocketChannel channel) { + var pipeline = channel.pipeline(); + pipeline.addLast("codec", new HttpServerCodec()); + pipeline.addLast("aggregator", new HttpObjectAggregator(512 * 1024)); + pipeline.addLast(new HttpRequestHandler(workloadHandler, readyHandler, logging)); + } + }); + var server = bootstrap.bind().sync(); + server.channel().closeFuture().sync(); + } finally { + group.shutdownGracefully().sync(); + } + } +} diff --git a/benchkit-backend/src/main/java/neo4j/org/testkit/backend/channel/handler/HttpRequestHandler.java b/benchkit-backend/src/main/java/neo4j/org/testkit/backend/channel/handler/HttpRequestHandler.java new file mode 100644 index 0000000000..1e2e85b9e3 --- /dev/null +++ b/benchkit-backend/src/main/java/neo4j/org/testkit/backend/channel/handler/HttpRequestHandler.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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 neo4j.org.testkit.backend.channel.handler; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import io.netty.channel.ChannelFutureListener; +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.SimpleChannelInboundHandler; +import io.netty.handler.codec.http.DefaultFullHttpResponse; +import io.netty.handler.codec.http.FullHttpRequest; +import io.netty.handler.codec.http.FullHttpResponse; +import io.netty.handler.codec.http.HttpHeaderNames; +import io.netty.handler.codec.http.HttpMethod; +import io.netty.handler.codec.http.HttpResponseStatus; +import io.netty.handler.codec.http.HttpUtil; +import io.netty.handler.codec.http.HttpVersion; +import java.nio.charset.StandardCharsets; +import java.util.Objects; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionException; +import java.util.concurrent.CompletionStage; +import neo4j.org.testkit.backend.handler.ReadyHandler; +import neo4j.org.testkit.backend.handler.WorkloadHandler; +import neo4j.org.testkit.backend.request.WorkloadRequest; +import org.neo4j.driver.Logger; +import org.neo4j.driver.Logging; + +public class HttpRequestHandler extends SimpleChannelInboundHandler { + private final ObjectMapper objectMapper = new ObjectMapper(); + private final WorkloadHandler workloadHandler; + private final ReadyHandler readyHandler; + private final Logger logger; + + public HttpRequestHandler(WorkloadHandler workloadHandler, ReadyHandler readyHandler, Logging logging) { + this.workloadHandler = Objects.requireNonNull(workloadHandler); + this.readyHandler = Objects.requireNonNull(readyHandler); + this.logger = logging.getLog(getClass()); + } + + @Override + public void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) { + if (HttpUtil.is100ContinueExpected(request)) { + send100Continue(ctx); + } + + CompletionStage responseStage; + if ("/workload".equals(request.uri()) && HttpMethod.PUT.equals(request.method())) { + var content = request.content().toString(StandardCharsets.UTF_8); + responseStage = CompletableFuture.completedStage(null) + .thenApply(ignored -> { + try { + return objectMapper.readValue(content, WorkloadRequest.class); + } catch (JsonProcessingException e) { + throw new CompletionException(e); + } + }) + .thenCompose(workloadRequest -> workloadHandler.handle(request.protocolVersion(), workloadRequest)); + } else if ("/ready".equals(request.uri()) && HttpMethod.GET.equals(request.method())) { + responseStage = readyHandler.ready(request.protocolVersion()); + } else { + logger.warn("Unknown request %s with %s method.", request.uri(), request.method()); + responseStage = CompletableFuture.completedFuture( + new DefaultFullHttpResponse(request.protocolVersion(), HttpResponseStatus.INTERNAL_SERVER_ERROR)); + } + + responseStage.whenComplete((response, throwable) -> { + response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8"); + ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE); + }); + } + + private static void send100Continue(ChannelHandlerContext ctx) { + ctx.writeAndFlush(new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE)); + } + + @Override + public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { + logger.error("An unexpected error occured.", cause); + ctx.close(); + } +} diff --git a/benchkit-backend/src/main/java/neo4j/org/testkit/backend/handler/ReadyHandler.java b/benchkit-backend/src/main/java/neo4j/org/testkit/backend/handler/ReadyHandler.java new file mode 100644 index 0000000000..96ba83720a --- /dev/null +++ b/benchkit-backend/src/main/java/neo4j/org/testkit/backend/handler/ReadyHandler.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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 neo4j.org.testkit.backend.handler; + +import io.netty.handler.codec.http.DefaultFullHttpResponse; +import io.netty.handler.codec.http.FullHttpResponse; +import io.netty.handler.codec.http.HttpResponseStatus; +import io.netty.handler.codec.http.HttpVersion; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import org.neo4j.driver.Driver; +import org.neo4j.driver.Logger; +import org.neo4j.driver.Logging; + +public class ReadyHandler { + private final Driver driver; + private final Logger logger; + + public ReadyHandler(Driver driver, Logging logging) { + this.driver = driver; + this.logger = logging.getLog(getClass()); + } + + public CompletionStage ready(HttpVersion httpVersion) { + return CompletableFuture.completedStage(null) + .thenComposeAsync(ignored -> driver.verifyConnectivityAsync()) + .handle((ignored, throwable) -> { + HttpResponseStatus status; + if (throwable != null) { + logger.error("An error occured during workload handling.", throwable); + status = HttpResponseStatus.INTERNAL_SERVER_ERROR; + } else { + status = HttpResponseStatus.NO_CONTENT; + } + return new DefaultFullHttpResponse(httpVersion, status); + }); + } +} diff --git a/benchkit-backend/src/main/java/neo4j/org/testkit/backend/handler/WorkloadHandler.java b/benchkit-backend/src/main/java/neo4j/org/testkit/backend/handler/WorkloadHandler.java new file mode 100644 index 0000000000..6cf062a9a8 --- /dev/null +++ b/benchkit-backend/src/main/java/neo4j/org/testkit/backend/handler/WorkloadHandler.java @@ -0,0 +1,286 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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 neo4j.org.testkit.backend.handler; + +import io.netty.handler.codec.http.DefaultFullHttpResponse; +import io.netty.handler.codec.http.FullHttpResponse; +import io.netty.handler.codec.http.HttpResponseStatus; +import io.netty.handler.codec.http.HttpVersion; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import java.util.concurrent.Executor; +import java.util.concurrent.TimeUnit; +import java.util.function.BiConsumer; +import java.util.stream.Stream; +import neo4j.org.testkit.backend.request.WorkloadRequest; +import org.neo4j.driver.AccessMode; +import org.neo4j.driver.Driver; +import org.neo4j.driver.Logger; +import org.neo4j.driver.Logging; +import org.neo4j.driver.QueryConfig; +import org.neo4j.driver.RoutingControl; +import org.neo4j.driver.Session; +import org.neo4j.driver.SessionConfig; +import org.neo4j.driver.SimpleQueryRunner; +import org.neo4j.driver.TransactionCallback; + +public class WorkloadHandler { + private final Driver driver; + private final Executor executor; + private final Logger logger; + + public WorkloadHandler(Driver driver, Executor executor, Logging logging) { + this.driver = Objects.requireNonNull(driver); + this.executor = Objects.requireNonNull(executor); + this.logger = logging.getLog(getClass()); + } + + public CompletionStage handle(HttpVersion httpVersion, WorkloadRequest workloadRequest) { + return CompletableFuture.completedStage(null) + .thenComposeAsync( + ignored -> switch (workloadRequest.getMethod()) { + case "executeQuery" -> executeQuery(workloadRequest); + case "sessionRun" -> sessionRun(workloadRequest); + case "executeRead", "executeWrite" -> execute(workloadRequest); + default -> CompletableFuture.failedStage( + new IllegalArgumentException("Unknown workload type.")); + }, + executor) + .handle((ignored, throwable) -> { + HttpResponseStatus status; + if (throwable != null) { + logger.error("An error occured during workload handling.", throwable); + status = HttpResponseStatus.INTERNAL_SERVER_ERROR; + } else { + status = HttpResponseStatus.NO_CONTENT; + } + return new DefaultFullHttpResponse(httpVersion, status); + }); + } + + private CompletionStage executeQuery(WorkloadRequest workloadRequest) { + var routingControl = + switch (workloadRequest.getRouting()) { + case "read" -> RoutingControl.READ; + case "write" -> RoutingControl.WRITE; + default -> null; + }; + if (routingControl == null) { + return CompletableFuture.failedStage(new IllegalArgumentException("Unknown routing.")); + } + return switch (workloadRequest.getMode()) { + case "sequentialSessions" -> runAsStage(() -> executeQueriesSequentially( + workloadRequest.getQueries(), workloadRequest.getDatabase(), routingControl)); + case "parallelSessions" -> executeQueriesConcurrently( + workloadRequest.getQueries(), workloadRequest.getDatabase(), routingControl); + default -> CompletableFuture.failedStage(new IllegalArgumentException("Unknown workload type.")); + }; + } + + private void executeQueriesSequentially( + List queries, String database, RoutingControl routingControl) { + for (var query : queries) { + executeQuery(query.getText(), query.getParameters(), database, routingControl); + } + } + + private CompletionStage executeQueriesConcurrently( + List queries, String database, RoutingControl routingControl) { + return runAsStage( + queries.stream() + .map(query -> + () -> executeQuery(query.getText(), query.getParameters(), database, routingControl)), + executor); + } + + @SuppressWarnings("unchecked") + private void executeQuery(String query, Map parameters, String database, RoutingControl routingControl) { + var configBuilder = QueryConfig.builder().withRouting(routingControl); + if (database != null) { + configBuilder.withDatabase(database); + } + driver.executableQuery(query) + .withParameters((Map) parameters) + .withConfig(configBuilder.build()) + .execute(); + } + + private CompletionStage sessionRun(WorkloadRequest workloadRequest) { + var accessMode = + switch (workloadRequest.getRouting()) { + case "read" -> AccessMode.READ; + case "write" -> AccessMode.WRITE; + default -> null; + }; + if (accessMode == null) { + return CompletableFuture.failedStage(new IllegalArgumentException("Unknown routing.")); + } + return switch (workloadRequest.getMode()) { + case "sequentialSessions" -> runAsStage(() -> + runInMultipleSessions(workloadRequest.getQueries(), workloadRequest.getDatabase(), accessMode)); + case "sequentialTransactions" -> runAsStage( + () -> runInSingleSession(workloadRequest.getQueries(), workloadRequest.getDatabase(), accessMode)); + case "parallelSessions" -> runInConcurrentSessions( + workloadRequest.getQueries(), workloadRequest.getDatabase(), accessMode); + default -> CompletableFuture.failedStage(new IllegalArgumentException("Unknown workload type.")); + }; + } + + private void runInMultipleSessions(List queries, String database, AccessMode accessMode) { + for (var query : queries) { + try (var session = driver.session(sessionConfigBuilder(database) + .withDefaultAccessMode(accessMode) + .build())) { + run(session, query.getText(), query.getParameters()); + } + } + } + + private void runInSingleSession(List queries, String database, AccessMode accessMode) { + try (var session = driver.session( + sessionConfigBuilder(database).withDefaultAccessMode(accessMode).build())) { + for (var query : queries) { + run(session, query.getText(), query.getParameters()); + } + } + } + + private CompletionStage runInConcurrentSessions( + List queries, String database, AccessMode accessMode) { + return runAsStage( + queries.stream() + .map(query -> () -> runInSingleSession(Collections.singletonList(query), database, accessMode)), + executor); + } + + private void run(SimpleQueryRunner queryRunner, String query, Map parameters) { + @SuppressWarnings("unchecked") + var result = queryRunner.run(query, (Map) parameters); + while (result.hasNext()) { + result.next(); + } + } + + private CompletionStage execute(WorkloadRequest workloadRequest) { + BiConsumer> runner = + switch (workloadRequest.getRouting()) { + case "read" -> Session::executeRead; + case "write" -> Session::executeWrite; + default -> null; + }; + if (runner == null) { + return CompletableFuture.failedStage(new IllegalArgumentException("Unknown routing.")); + } + return switch (workloadRequest.getMode()) { + case "sequentialSessions" -> runAsStage(() -> + executeInMultipleSessions(runner, workloadRequest.getQueries(), workloadRequest.getDatabase())); + case "sequentialTransactions" -> runAsStage( + () -> executeSingleSession(runner, workloadRequest.getQueries(), workloadRequest.getDatabase())); + case "sequentialQueries" -> runAsStage(() -> + executeInSingleTransaction(runner, workloadRequest.getQueries(), workloadRequest.getDatabase())); + case "parallelSessions" -> executeConcurrently( + runner, workloadRequest.getQueries(), workloadRequest.getDatabase()); + default -> CompletableFuture.failedStage(new IllegalArgumentException("Unknown workload type.")); + }; + } + + private void executeInMultipleSessions( + BiConsumer> runner, + List queries, + String database) { + for (var query : queries) { + try (var session = driver.session(sessionConfigBuilder(database).build())) { + runner.accept(session, tx -> { + run(tx, query.getText(), query.getParameters()); + return null; + }); + } + } + } + + private void executeSingleSession( + BiConsumer> runner, + List queries, + String database) { + try (var session = driver.session(sessionConfigBuilder(database).build())) { + for (var query : queries) { + runner.accept(session, tx -> { + run(tx, query.getText(), query.getParameters()); + return null; + }); + } + } + } + + private void executeInSingleTransaction( + BiConsumer> runner, + List queries, + String database) { + var configBuilder = SessionConfig.builder(); + if (database != null) { + configBuilder.withDatabase(database); + } + try (var session = driver.session(configBuilder.build())) { + runner.accept(session, tx -> { + for (var query : queries) { + run(tx, query.getText(), query.getParameters()); + } + return null; + }); + } + } + + private CompletionStage executeConcurrently( + BiConsumer> runner, + List queries, + String database) { + return runAsStage( + queries.stream() + .map(query -> () -> executeSingleSession(runner, Collections.singletonList(query), database)), + executor); + } + + private CompletionStage runAsStage(Runnable runnable) { + var future = new CompletableFuture(); + try { + runnable.run(); + future.complete(null); + } catch (Throwable throwable) { + future.completeExceptionally(throwable); + } + return future; + } + + private CompletionStage runAsStage(Stream runnables, Executor executor) { + return CompletableFuture.allOf(runnables + .map(runnable -> CompletableFuture.runAsync(runnable, executor)) + .toArray(CompletableFuture[]::new)) + .orTimeout(1, TimeUnit.MINUTES); + } + + private SessionConfig.Builder sessionConfigBuilder(String database) { + var configBuilder = SessionConfig.builder(); + if (database != null) { + configBuilder.withDatabase(database); + } + return configBuilder; + } +} diff --git a/benchkit-backend/src/main/java/neo4j/org/testkit/backend/request/WorkloadRequest.java b/benchkit-backend/src/main/java/neo4j/org/testkit/backend/request/WorkloadRequest.java new file mode 100644 index 0000000000..4ee9330b43 --- /dev/null +++ b/benchkit-backend/src/main/java/neo4j/org/testkit/backend/request/WorkloadRequest.java @@ -0,0 +1,36 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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 neo4j.org.testkit.backend.request; + +import java.util.List; +import java.util.Map; +import lombok.Data; + +@Data +public class WorkloadRequest { + String method; + List queries; + String database; + String routing; + String mode; + + @Data + public static class Query { + String text; + Map parameters; + } +} diff --git a/benchkit/Dockerfile b/benchkit/Dockerfile new file mode 100644 index 0000000000..4fbf5efdbd --- /dev/null +++ b/benchkit/Dockerfile @@ -0,0 +1,7 @@ +FROM maven:3.9.2-eclipse-temurin-17 as build +COPY . /driver +RUN cd /driver && mvn --show-version --batch-mode clean install -P !determine-revision -DskipTests + +FROM eclipse-temurin:17-jre +COPY --from=build /driver/benchkit-backend/target/benchkit-backend.jar /benchkit-backend.jar +CMD java -jar benchkit-backend.jar diff --git a/bundle/pom.xml b/bundle/pom.xml index 24986756fd..2d108187c9 100644 --- a/bundle/pom.xml +++ b/bundle/pom.xml @@ -6,7 +6,7 @@ org.neo4j.driver neo4j-java-driver-parent - 5.15-SNAPSHOT + 5.18-SNAPSHOT .. diff --git a/driver/clirr-ignored-differences.xml b/driver/clirr-ignored-differences.xml index 8cc7629950..689965a781 100644 --- a/driver/clirr-ignored-differences.xml +++ b/driver/clirr-ignored-differences.xml @@ -597,4 +597,10 @@ 8001 + + org/neo4j/driver/ExecutableQuery + 7012 + org.neo4j.driver.ExecutableQuery withAuthToken(org.neo4j.driver.AuthToken) + + diff --git a/driver/pom.xml b/driver/pom.xml index 9111682edd..2f38c6ef0c 100644 --- a/driver/pom.xml +++ b/driver/pom.xml @@ -6,7 +6,7 @@ org.neo4j.driver neo4j-java-driver-parent - 5.15-SNAPSHOT + 5.18-SNAPSHOT neo4j-java-driver @@ -20,7 +20,7 @@ ${project.basedir}/.. ${basedir}/target/classes-without-jpms ,-try - --add-opens org.neo4j.driver/org.neo4j.driver.internal.util.messaging=ALL-UNNAMED + --add-opens org.neo4j.driver/org.neo4j.driver.internal.bolt.basicimpl.util.messaging=ALL-UNNAMED --add-opens org.neo4j.driver/org.neo4j.driver.internal.util=ALL-UNNAMED --add-opens org.neo4j.driver/org.neo4j.driver.internal.async=ALL-UNNAMED blockHoundTest false @@ -106,6 +106,10 @@ neo4j test + + commons-codec + commons-codec + org.reactivestreams reactive-streams-tck @@ -114,6 +118,10 @@ ch.qos.logback logback-classic + + com.tngtech.archunit + archunit-junit5 + diff --git a/driver/src/main/java/org/neo4j/driver/Config.java b/driver/src/main/java/org/neo4j/driver/Config.java index 35ac38162c..9f25792011 100644 --- a/driver/src/main/java/org/neo4j/driver/Config.java +++ b/driver/src/main/java/org/neo4j/driver/Config.java @@ -31,10 +31,8 @@ import java.util.concurrent.TimeUnit; import java.util.logging.Level; import org.neo4j.driver.exceptions.UnsupportedFeatureException; +import org.neo4j.driver.internal.RoutingSettings; import org.neo4j.driver.internal.SecuritySettings; -import org.neo4j.driver.internal.async.pool.PoolSettings; -import org.neo4j.driver.internal.cluster.RoutingSettings; -import org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil; import org.neo4j.driver.internal.retry.ExponentialBackoffRetryLogic; import org.neo4j.driver.net.ServerAddressResolver; import org.neo4j.driver.util.Experimental; @@ -359,10 +357,10 @@ public boolean isTelemetryDisabled() { public static final class ConfigBuilder { private Logging logging = DEV_NULL_LOGGING; private boolean logLeakedSessions; - private int maxConnectionPoolSize = PoolSettings.DEFAULT_MAX_CONNECTION_POOL_SIZE; - private long idleTimeBeforeConnectionTest = PoolSettings.DEFAULT_IDLE_TIME_BEFORE_CONNECTION_TEST; - private long maxConnectionLifetimeMillis = PoolSettings.DEFAULT_MAX_CONNECTION_LIFETIME; - private long connectionAcquisitionTimeoutMillis = PoolSettings.DEFAULT_CONNECTION_ACQUISITION_TIMEOUT; + private int maxConnectionPoolSize = 100; + private long idleTimeBeforeConnectionTest = -1; + private long maxConnectionLifetimeMillis = TimeUnit.HOURS.toMillis(1); + private long connectionAcquisitionTimeoutMillis = TimeUnit.SECONDS.toMillis(60); private String userAgent = format("neo4j-java/%s", driverVersion()); private final SecuritySettings.SecuritySettingsBuilder securitySettingsBuilder = new SecuritySettings.SecuritySettingsBuilder(); @@ -371,7 +369,7 @@ public static final class ConfigBuilder { private long maxTransactionRetryTimeMillis = ExponentialBackoffRetryLogic.DEFAULT_MAX_RETRY_TIME_MS; private ServerAddressResolver resolver; private MetricsAdapter metricsAdapter = MetricsAdapter.DEV_NULL; - private long fetchSize = FetchSizeUtil.DEFAULT_FETCH_SIZE; + private long fetchSize = 1000; private int eventLoopThreads = 0; private NotificationConfig notificationConfig = NotificationConfig.defaultConfig(); @@ -602,7 +600,11 @@ public ConfigBuilder withRoutingTablePurgeDelay(long delay, TimeUnit unit) { * @return this builder */ public ConfigBuilder withFetchSize(long size) { - this.fetchSize = FetchSizeUtil.assertValidFetchSize(size); + if (size <= 0 && size != -1) { + throw new IllegalArgumentException(String.format( + "The record fetch size may not be 0 or negative. Illegal record fetch size: %s.", size)); + } + this.fetchSize = size; return this; } diff --git a/driver/src/main/java/org/neo4j/driver/Driver.java b/driver/src/main/java/org/neo4j/driver/Driver.java index f2f6a1cd7d..ffaa25719d 100644 --- a/driver/src/main/java/org/neo4j/driver/Driver.java +++ b/driver/src/main/java/org/neo4j/driver/Driver.java @@ -19,6 +19,7 @@ import java.util.concurrent.CompletionStage; import org.neo4j.driver.async.AsyncSession; import org.neo4j.driver.exceptions.ClientException; +import org.neo4j.driver.exceptions.UnsupportedFeatureException; import org.neo4j.driver.reactive.ReactiveSession; import org.neo4j.driver.reactive.RxSession; import org.neo4j.driver.types.TypeSystem; @@ -143,7 +144,7 @@ default T session(Class sessionClass) { * 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 + * The minimum Bolt protocol version is 5.1. An {@link UnsupportedFeatureException} will be emitted on session interaction * for previous Bolt versions. *

* Supported types are: @@ -214,7 +215,7 @@ default T session(Class sessionClass, SessionConfig s * {@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 + * The minimum Bolt protocol version is 5.1. An {@link UnsupportedFeatureException} will be emitted on session interaction * for previous Bolt versions. *

* Supported types are: @@ -333,6 +334,10 @@ default AsyncSession asyncSession(SessionConfig sessionConfig) { * Close all the resources assigned to this driver, including open connections and IO threads. *

* This operation works the same way as {@link #closeAsync()} but blocks until all resources are closed. + *

+ * Please note that this method is intended for graceful shutdown only and expects that all driver interactions have + * either been finished or no longer awaited for. Pending driver API calls may not be completed after this method is + * invoked. */ @Override void close(); @@ -342,6 +347,10 @@ default AsyncSession asyncSession(SessionConfig sessionConfig) { *

* This operation is asynchronous and returns a {@link CompletionStage}. This stage is completed with * {@code null} when all resources are closed. It is completed exceptionally if termination fails. + *

+ * Please note that this method is intended for graceful shutdown only and expects that all driver interactions have + * either been finished or no longer awaited for. Pending driver API calls may not be completed after this method is + * invoked. * * @return a {@link CompletionStage completion stage} that represents the asynchronous close. */ diff --git a/driver/src/main/java/org/neo4j/driver/ExecutableQuery.java b/driver/src/main/java/org/neo4j/driver/ExecutableQuery.java index 2664a116d5..abd5c3e9d9 100644 --- a/driver/src/main/java/org/neo4j/driver/ExecutableQuery.java +++ b/driver/src/main/java/org/neo4j/driver/ExecutableQuery.java @@ -22,6 +22,7 @@ import java.util.function.Consumer; import java.util.stream.Collector; import java.util.stream.Collectors; +import org.neo4j.driver.exceptions.UnsupportedFeatureException; import org.neo4j.driver.internal.EagerResultValue; import org.neo4j.driver.summary.ResultSummary; @@ -97,7 +98,7 @@ public interface ExecutableQuery { /** * Sets query parameters. * - * @param parameters parameters map, must not be {@code null} + * @param parameters parameters map, must not be {@literal null} * @return a new executable query */ ExecutableQuery withParameters(Map parameters); @@ -107,11 +108,27 @@ public interface ExecutableQuery { *

* By default, {@link ExecutableQuery} has {@link QueryConfig#defaultConfig()} value. * - * @param config query config, must not be {@code null} + * @param config query config, must not be {@literal null} * @return a new executable query */ ExecutableQuery withConfig(QueryConfig config); + /** + * Sets an {@link AuthToken} to be used for this query. + *

+ * The default value is {@literal null}. + *

+ * The minimum Bolt protocol version for this feature is 5.1. An {@link UnsupportedFeatureException} will be emitted on + * query execution for previous Bolt versions. + * + * @param authToken the {@link AuthToken} for this query or {@literal null} to use the driver default + * @return a new executable query + * @since 5.18 + */ + default ExecutableQuery withAuthToken(AuthToken authToken) { + throw new UnsupportedFeatureException("Session AuthToken is not supported."); + } + /** * Executes query, collects all results eagerly and returns a result. * diff --git a/driver/src/main/java/org/neo4j/driver/GraphDatabase.java b/driver/src/main/java/org/neo4j/driver/GraphDatabase.java index 4f068f2ac4..3a711144b5 100644 --- a/driver/src/main/java/org/neo4j/driver/GraphDatabase.java +++ b/driver/src/main/java/org/neo4j/driver/GraphDatabase.java @@ -29,6 +29,7 @@ * @since 1.0 */ public final class GraphDatabase { + private GraphDatabase() {} /** diff --git a/driver/src/main/java/org/neo4j/driver/Logging.java b/driver/src/main/java/org/neo4j/driver/Logging.java index 6a90c91dca..6a9e12edda 100644 --- a/driver/src/main/java/org/neo4j/driver/Logging.java +++ b/driver/src/main/java/org/neo4j/driver/Logging.java @@ -73,9 +73,9 @@ * Example of driver configuration with SLF4J logging: * 

  * {@code
- * Driver driver = GraphDatabase.driver("bolt://localhost:7687",
+ * Driver driver = GraphDatabase.driver("neo4j://localhost:7687",
  *                                         AuthTokens.basic("neo4j", "password"),
- *                                         Config.build().withLogging(Logging.slf4j()).toConfig());
+ *                                         Config.builder().withLogging(Logging.slf4j()).build());
  * }
  *
* diff --git a/driver/src/main/java/org/neo4j/driver/Session.java b/driver/src/main/java/org/neo4j/driver/Session.java index 41eee27751..b1db6f652d 100644 --- a/driver/src/main/java/org/neo4j/driver/Session.java +++ b/driver/src/main/java/org/neo4j/driver/Session.java @@ -175,7 +175,7 @@ default T executeWrite(TransactionCallback callback) { * The driver will attempt committing the transaction when the provided unit of work completes successfully. Any exception emitted by the unit of work * will result in a rollback attempt. *

- * The provided unit of work should not return {@link Result} object as it won't be valid outside the scope of the transaction. + * This method works equivalently to {@link #executeWrite(TransactionCallback)}, but does not have a return value. * * @param contextConsumer the consumer representing the unit of work. */ @@ -223,7 +223,7 @@ default void executeWriteWithoutResult(Consumer contextConsu * The driver will attempt committing the transaction when the provided unit of work completes successfully. Any exception emitted by the unit of work * will result in a rollback attempt and abortion of execution unless exception is considered to be valid for retry attempt by the driver. *

- * The provided unit of work should not return {@link Result} object as it won't be valid outside the scope of the transaction. + * This method works equivalently to {@link #executeWrite(TransactionCallback, TransactionConfig)}, but does not have a return value. * * @param contextConsumer the consumer representing the unit of work. * @param config the transaction configuration for the managed transaction. diff --git a/driver/src/main/java/org/neo4j/driver/SessionConfig.java b/driver/src/main/java/org/neo4j/driver/SessionConfig.java index fe98b00c95..d3e1bd954f 100644 --- a/driver/src/main/java/org/neo4j/driver/SessionConfig.java +++ b/driver/src/main/java/org/neo4j/driver/SessionConfig.java @@ -17,7 +17,6 @@ package org.neo4j.driver; import static java.util.Objects.requireNonNull; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.assertValidFetchSize; import java.io.Serial; import java.io.Serializable; @@ -341,7 +340,11 @@ public Builder withDatabase(String database) { * @return this builder */ public Builder withFetchSize(long size) { - this.fetchSize = assertValidFetchSize(size); + if (size <= 0 && size != -1) { + throw new IllegalArgumentException(String.format( + "The record fetch size may not be 0 or negative. Illegal record fetch size: %s.", size)); + } + this.fetchSize = size; return this; } diff --git a/driver/src/main/java/org/neo4j/driver/internal/BoltLogger.java b/driver/src/main/java/org/neo4j/driver/internal/BoltLogger.java new file mode 100644 index 0000000000..17a19c33d0 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/BoltLogger.java @@ -0,0 +1,67 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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; + +import java.util.ResourceBundle; +import org.neo4j.driver.Logger; + +public class BoltLogger implements System.Logger { + private final Logger logger; + + public BoltLogger(Logger logger) { + this.logger = logger; + } + + @Override + public String getName() { + throw new RuntimeException(new UnsupportedOperationException("getName() not supported")); + } + + @Override + public boolean isLoggable(Level level) { + return switch (level) { + case ALL -> logger.isTraceEnabled() && logger.isDebugEnabled(); + case TRACE -> logger.isTraceEnabled(); + case DEBUG -> logger.isDebugEnabled(); + case INFO, WARNING, ERROR -> true; + case OFF -> false; + }; + } + + @Override + public void log(Level level, ResourceBundle bundle, String msg, Throwable thrown) { + switch (level) { + case ALL, OFF -> {} + case TRACE -> logger.trace(msg, thrown); + case DEBUG -> logger.debug(msg, thrown); + case INFO -> logger.info(msg, thrown); + case WARNING -> logger.warn(msg, thrown); + case ERROR -> logger.error(msg, thrown); + } + } + + @Override + public void log(Level level, ResourceBundle bundle, String format, Object... params) { + switch (level) { + case TRACE -> logger.trace(format, params); + case DEBUG -> logger.debug(format, params); + case INFO -> logger.info(format, params); + case WARNING -> logger.warn(format, params); + case ALL, OFF, ERROR -> {} + } + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/BoltLoggingProvider.java b/driver/src/main/java/org/neo4j/driver/internal/BoltLoggingProvider.java new file mode 100644 index 0000000000..1448239e4e --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/BoltLoggingProvider.java @@ -0,0 +1,38 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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; + +import org.neo4j.driver.Logging; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; + +public class BoltLoggingProvider implements LoggingProvider { + private final Logging logging; + + public BoltLoggingProvider(Logging logging) { + this.logging = logging; + } + + @Override + public System.Logger getLog(Class cls) { + return new BoltLogger(logging.getLog(cls)); + } + + @Override + public System.Logger getLog(String name) { + return new BoltLogger(logging.getLog(name)); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/DirectConnectionProvider.java b/driver/src/main/java/org/neo4j/driver/internal/DirectConnectionProvider.java deleted file mode 100644 index 190ba137d0..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/DirectConnectionProvider.java +++ /dev/null @@ -1,95 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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; - -import static org.neo4j.driver.internal.async.ConnectionContext.PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER; - -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. - */ -public class DirectConnectionProvider implements ConnectionProvider { - private final BoltServerAddress address; - private final ConnectionPool connectionPool; - - DirectConnectionProvider(BoltServerAddress address, ConnectionPool connectionPool) { - this.address = address; - this.connectionPool = connectionPool; - } - - @Override - public CompletionStage acquireConnection(ConnectionContext context) { - var databaseNameFuture = context.databaseNameFuture(); - databaseNameFuture.complete(DatabaseNameUtil.defaultDatabase()); - return acquirePooledConnection(context.overrideAuthToken()) - .thenApply(connection -> new DirectConnection( - connection, - Futures.joinNowOrElseThrow(databaseNameFuture, PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER), - context.mode(), - context.impersonatedUser())); - } - - @Override - public CompletionStage verifyConnectivity() { - return acquirePooledConnection(null).thenCompose(Connection::release); - } - - @Override - public CompletionStage close() { - return connectionPool.close(); - } - - @Override - public CompletionStage supportsMultiDb() { - 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); - }); - } - - public BoltServerAddress getAddress() { - return address; - } - - /** - * 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 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 9167abffe7..3f9d259255 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/DriverFactory.java +++ b/driver/src/main/java/org/neo4j/driver/internal/DriverFactory.java @@ -17,47 +17,41 @@ 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; +import static org.neo4j.driver.internal.IdentityResolver.IDENTITY_RESOLVER; import io.netty.bootstrap.Bootstrap; import io.netty.channel.EventLoopGroup; import io.netty.util.concurrent.EventExecutorGroup; -import io.netty.util.internal.logging.InternalLoggerFactory; import java.net.URI; import java.time.Clock; -import java.util.function.Supplier; +import java.util.LinkedHashSet; +import java.util.Set; +import java.util.function.Function; +import java.util.stream.Collectors; import org.neo4j.driver.AuthTokenManager; import org.neo4j.driver.Config; import org.neo4j.driver.Driver; import org.neo4j.driver.Logging; import org.neo4j.driver.MetricsAdapter; -import org.neo4j.driver.internal.async.connection.BootstrapFactory; -import org.neo4j.driver.internal.async.connection.ChannelConnector; -import org.neo4j.driver.internal.async.connection.ChannelConnectorImpl; -import org.neo4j.driver.internal.async.pool.ConnectionPoolImpl; -import org.neo4j.driver.internal.async.pool.PoolSettings; -import org.neo4j.driver.internal.cluster.Rediscovery; -import org.neo4j.driver.internal.cluster.RediscoveryImpl; -import org.neo4j.driver.internal.cluster.RoutingContext; -import org.neo4j.driver.internal.cluster.RoutingProcedureClusterCompositionProvider; -import org.neo4j.driver.internal.cluster.RoutingSettings; -import org.neo4j.driver.internal.cluster.loadbalancing.LeastConnectedLoadBalancingStrategy; -import org.neo4j.driver.internal.cluster.loadbalancing.LoadBalancer; -import org.neo4j.driver.internal.logging.NettyLogging; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.DefaultDomainNameResolver; +import org.neo4j.driver.internal.bolt.api.DomainNameResolver; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.SecurityPlan; +import org.neo4j.driver.internal.bolt.basicimpl.NettyBoltConnectionProvider; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.BootstrapFactory; +import org.neo4j.driver.internal.bolt.pooledimpl.PooledBoltConnectionProvider; +import org.neo4j.driver.internal.bolt.routedimpl.RoutedBoltConnectionProvider; import org.neo4j.driver.internal.metrics.DevNullMetricsProvider; import org.neo4j.driver.internal.metrics.InternalMetricsProvider; import org.neo4j.driver.internal.metrics.MetricsProvider; import org.neo4j.driver.internal.metrics.MicrometerMetricsProvider; import org.neo4j.driver.internal.retry.ExponentialBackoffRetryLogic; 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.spi.ConnectionPool; -import org.neo4j.driver.internal.spi.ConnectionProvider; import org.neo4j.driver.internal.util.DriverInfoUtil; -import org.neo4j.driver.internal.util.Futures; +import org.neo4j.driver.net.ServerAddress; import org.neo4j.driver.net.ServerAddressResolver; public class DriverFactory { @@ -65,16 +59,16 @@ public class DriverFactory { "Routing parameters are not supported with scheme 'bolt'. Given URI: "; public final Driver newInstance(URI uri, AuthTokenManager authTokenManager, Config config) { - return newInstance(uri, authTokenManager, config, null, null, null); + return newInstance(uri, authTokenManager, config, null, null); } + @SuppressWarnings("deprecation") public final Driver newInstance( URI uri, AuthTokenManager authTokenManager, Config config, SecurityPlan securityPlan, - EventLoopGroup eventLoopGroup, - Supplier rediscoverySupplier) { + EventLoopGroup eventLoopGroup) { requireNonNull(authTokenManager, "authTokenProvider must not be null"); Bootstrap bootstrap; @@ -92,61 +86,25 @@ public final Driver newInstance( securityPlan = SecurityPlans.createSecurityPlan(settings, uri.getScheme()); } - var address = new BoltServerAddress(uri); + var address = new InternalServerAddress(uri); var routingSettings = new RoutingSettings(config.routingTablePurgeDelayMillis(), new RoutingContext(uri)); - InternalLoggerFactory.setDefaultFactory(new NettyLogging(config.logging())); EventExecutorGroup eventExecutorGroup = bootstrap.config().group(); var retryLogic = createRetryLogic(config.maxTransactionRetryTimeMillis(), eventExecutorGroup, config.logging()); var metricsProvider = getOrCreateMetricsProvider(config, createClock()); - var connectionPool = createConnectionPool( - authTokenManager, - securityPlan, - bootstrap, - metricsProvider, - config, - ownsEventLoopGroup, - routingSettings.routingContext()); return createDriver( uri, securityPlan, address, - connectionPool, eventExecutorGroup, + bootstrap.group(), routingSettings, retryLogic, metricsProvider, - rediscoverySupplier, - config); - } - - protected ConnectionPool createConnectionPool( - AuthTokenManager authTokenManager, - SecurityPlan securityPlan, - Bootstrap bootstrap, - MetricsProvider metricsProvider, - Config config, - boolean ownsEventLoopGroup, - RoutingContext routingContext) { - var clock = createClock(); - var settings = new ConnectionSettings(authTokenManager, config.userAgent(), config.connectionTimeoutMillis()); - var boltAgent = DriverInfoUtil.boltAgent(); - var connector = createConnector(settings, securityPlan, config, clock, routingContext, boltAgent); - var poolSettings = new PoolSettings( - config.maxConnectionPoolSize(), - config.connectionAcquisitionTimeoutMillis(), - config.maxConnectionLifetimeMillis(), - config.idleTimeBeforeConnectionTest()); - return new ConnectionPoolImpl( - connector, - bootstrap, - poolSettings, - metricsProvider.metricsListener(), - config.logging(), - clock, - ownsEventLoopGroup); + config, + authTokenManager); } protected static MetricsProvider getOrCreateMetricsProvider(Config config, Clock clock) { @@ -162,104 +120,85 @@ protected static MetricsProvider getOrCreateMetricsProvider(Config config, Clock }; } - protected ChannelConnector createConnector( - ConnectionSettings settings, - SecurityPlan securityPlan, - Config config, - Clock clock, - RoutingContext routingContext, - BoltAgent boltAgent) { - return new ChannelConnectorImpl( - settings, - securityPlan, - config.logging(), - clock, - routingContext, - getDomainNameResolver(), - config.notificationConfig(), - boltAgent); - } - private InternalDriver createDriver( URI uri, SecurityPlan securityPlan, - BoltServerAddress address, - ConnectionPool connectionPool, + ServerAddress address, EventExecutorGroup eventExecutorGroup, + EventLoopGroup eventLoopGroup, RoutingSettings routingSettings, RetryLogic retryLogic, MetricsProvider metricsProvider, - Supplier rediscoverySupplier, - Config config) { + Config config, + AuthTokenManager authTokenManager) { + BoltConnectionProvider boltConnectionProvider = null; try { - var scheme = uri.getScheme().toLowerCase(); - - if (isRoutingScheme(scheme)) { - return createRoutingDriver( - securityPlan, - address, - connectionPool, - eventExecutorGroup, - routingSettings, - retryLogic, - metricsProvider, - rediscoverySupplier, - config); + if (uri.getScheme().startsWith("bolt")) { + var routingContext = new RoutingContext(uri); + if (routingContext.isDefined()) { + throw new IllegalArgumentException(NO_ROUTING_CONTEXT_ERROR_MESSAGE + "'" + uri + "'"); + } + boltConnectionProvider = new PooledBoltConnectionProvider( + new NettyBoltConnectionProvider( + eventLoopGroup, + createClock(), + getDomainNameResolver(), + new BoltLoggingProvider(config.logging())), + config.maxConnectionPoolSize(), + config.connectionAcquisitionTimeoutMillis(), + config.maxConnectionLifetimeMillis(), + config.idleTimeBeforeConnectionTest(), + createClock(), + new BoltLoggingProvider(config.logging())); } else { - assertNoRoutingContext(uri, routingSettings); - return createDirectDriver(securityPlan, address, connectionPool, retryLogic, metricsProvider, config); + var serverAddressResolver = config.resolver() != null ? config.resolver() : IDENTITY_RESOLVER; + Function> boltAddressResolver = + (boltAddress) -> serverAddressResolver.resolve(address).stream() + .map(serverAddress -> new BoltServerAddress(serverAddress.host(), serverAddress.port())) + .collect(Collectors.toCollection(LinkedHashSet::new)); + var routingContext = new RoutingContext(uri); + routingContext.toMap(); + boltConnectionProvider = new RoutedBoltConnectionProvider( + () -> new PooledBoltConnectionProvider( + new NettyBoltConnectionProvider( + eventLoopGroup, + createClock(), + getDomainNameResolver(), + new BoltLoggingProvider(config.logging())), + config.maxConnectionPoolSize(), + config.connectionAcquisitionTimeoutMillis(), + config.maxConnectionLifetimeMillis(), + config.idleTimeBeforeConnectionTest(), + createClock(), + new BoltLoggingProvider(config.logging())), + boltAddressResolver, + getDomainNameResolver(), + createClock(), + new BoltLoggingProvider(config.logging())); } + var boltAgent = DriverInfoUtil.boltAgent(); + boltConnectionProvider.init( + new BoltServerAddress(address.host(), address.port()), + securityPlan, + new RoutingContext(uri), + boltAgent, + config.userAgent(), + config.connectionTimeoutMillis(), + metricsProvider.metricsListener()); + // todo assertNoRoutingContext(uri, routingSettings); + var sessionFactory = createSessionFactory(boltConnectionProvider, retryLogic, config, authTokenManager); + var driver = createDriver(securityPlan, sessionFactory, metricsProvider, config); + var log = config.logging().getLog(getClass()); + log.info("Routing driver instance %s created for server address %s", driver.hashCode(), address); + return driver; } catch (Throwable driverError) { - // we need to close the connection pool if driver creation threw exception - closeConnectionPoolAndSuppressError(connectionPool, driverError); + if (boltConnectionProvider != null) { + boltConnectionProvider.close().toCompletableFuture().join(); + } throw driverError; } } - /** - * Creates a new driver for "bolt" scheme. - *

- * This method is protected only for testing - */ - protected InternalDriver createDirectDriver( - SecurityPlan securityPlan, - BoltServerAddress address, - ConnectionPool connectionPool, - RetryLogic retryLogic, - MetricsProvider metricsProvider, - Config config) { - ConnectionProvider connectionProvider = new DirectConnectionProvider(address, connectionPool); - var sessionFactory = createSessionFactory(connectionProvider, retryLogic, config); - var driver = createDriver(securityPlan, sessionFactory, metricsProvider, config); - var log = config.logging().getLog(getClass()); - log.info("Direct driver instance %s created for server address %s", driver.hashCode(), address); - return driver; - } - - /** - * Creates new a new driver for "neo4j" scheme. - *

- * This method is protected only for testing - */ - protected InternalDriver createRoutingDriver( - SecurityPlan securityPlan, - BoltServerAddress address, - ConnectionPool connectionPool, - EventExecutorGroup eventExecutorGroup, - RoutingSettings routingSettings, - RetryLogic retryLogic, - MetricsProvider metricsProvider, - Supplier rediscoverySupplier, - Config config) { - ConnectionProvider connectionProvider = createLoadBalancer( - address, connectionPool, eventExecutorGroup, config, routingSettings, rediscoverySupplier); - var sessionFactory = createSessionFactory(connectionProvider, retryLogic, config); - var driver = createDriver(securityPlan, sessionFactory, metricsProvider, config); - var log = config.logging().getLog(getClass()); - log.info("Routing driver instance %s created for server address %s", driver.hashCode(), address); - return driver; - } - /** * Creates new {@link Driver}. *

@@ -268,63 +207,14 @@ protected InternalDriver createRoutingDriver( protected InternalDriver createDriver( SecurityPlan securityPlan, SessionFactory sessionFactory, MetricsProvider metricsProvider, Config config) { return new InternalDriver( - securityPlan, sessionFactory, metricsProvider, config.isTelemetryDisabled(), config.logging()); - } - - /** - * Creates new {@link LoadBalancer} for the routing driver. - *

- * This method is protected only for testing - */ - protected LoadBalancer createLoadBalancer( - BoltServerAddress address, - ConnectionPool connectionPool, - EventExecutorGroup eventExecutorGroup, - Config config, - RoutingSettings routingSettings, - Supplier rediscoverySupplier) { - var loadBalancingStrategy = new LeastConnectedLoadBalancingStrategy(connectionPool, config.logging()); - var resolver = createResolver(config); - var domainNameResolver = requireNonNull(getDomainNameResolver(), "domainNameResolver must not be null"); - var clock = createClock(); - var logging = config.logging(); - if (rediscoverySupplier == null) { - rediscoverySupplier = - () -> createRediscovery(address, resolver, routingSettings, clock, logging, domainNameResolver); - } - var loadBalancer = new LoadBalancer( - connectionPool, - rediscoverySupplier.get(), - routingSettings, - loadBalancingStrategy, - eventExecutorGroup, - clock, - logging); - handleNewLoadBalancer(loadBalancer); - return loadBalancer; - } - - protected Rediscovery createRediscovery( - BoltServerAddress initialRouter, - ServerAddressResolver resolver, - RoutingSettings settings, - Clock clock, - Logging logging, - DomainNameResolver domainNameResolver) { - var clusterCompositionProvider = - new RoutingProcedureClusterCompositionProvider(clock, settings.routingContext(), logging); - return new RediscoveryImpl(initialRouter, clusterCompositionProvider, resolver, logging, domainNameResolver); + securityPlan, + sessionFactory, + metricsProvider, + config.isTelemetryDisabled(), + config.notificationConfig(), + config.logging()); } - /** - * Handles new {@link LoadBalancer} instance. - *

- * This method is protected for Testkit backend usage only. - * - * @param loadBalancer the new load balancer instance. - */ - protected void handleNewLoadBalancer(LoadBalancer loadBalancer) {} - private static ServerAddressResolver createResolver(Config config) { var configuredResolver = config.resolver(); return configuredResolver != null ? configuredResolver : IDENTITY_RESOLVER; @@ -343,8 +233,11 @@ protected Clock createClock() { * This method is protected only for testing */ protected SessionFactory createSessionFactory( - ConnectionProvider connectionProvider, RetryLogic retryLogic, Config config) { - return new SessionFactoryImpl(connectionProvider, retryLogic, config); + BoltConnectionProvider connectionProvider, + RetryLogic retryLogic, + Config config, + AuthTokenManager authTokenManager) { + return new SessionFactoryImpl(connectionProvider, retryLogic, config, authTokenManager); } /** @@ -392,12 +285,4 @@ private static void assertNoRoutingContext(URI uri, RoutingSettings routingSetti throw new IllegalArgumentException(NO_ROUTING_CONTEXT_ERROR_MESSAGE + "'" + uri + "'"); } } - - private static void closeConnectionPoolAndSuppressError(ConnectionPool connectionPool, Throwable mainError) { - try { - Futures.blockingGet(connectionPool.close()); - } catch (Throwable closeError) { - addSuppressed(mainError, closeError); - } - } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/IdentityResolver.java b/driver/src/main/java/org/neo4j/driver/internal/IdentityResolver.java similarity index 96% rename from driver/src/main/java/org/neo4j/driver/internal/cluster/IdentityResolver.java rename to driver/src/main/java/org/neo4j/driver/internal/IdentityResolver.java index 86db822c37..9e10d489f9 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/IdentityResolver.java +++ b/driver/src/main/java/org/neo4j/driver/internal/IdentityResolver.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal; import static java.util.Collections.singleton; diff --git a/driver/src/main/java/org/neo4j/driver/internal/ImpersonationUtil.java b/driver/src/main/java/org/neo4j/driver/internal/ImpersonationUtil.java deleted file mode 100644 index 86f3a8d6bb..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/ImpersonationUtil.java +++ /dev/null @@ -1,38 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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; - -import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.internal.messaging.v44.BoltProtocolV44; -import org.neo4j.driver.internal.spi.Connection; - -public class ImpersonationUtil { - public static final String IMPERSONATION_UNSUPPORTED_ERROR_MESSAGE = - "Detected connection that does not support impersonation, please make sure to have all servers running 4.4 version or above and communicating" - + " over Bolt version 4.4 or above when using impersonation feature"; - - public static Connection ensureImpersonationSupport(Connection connection, String impersonatedUser) { - if (impersonatedUser != null && !supportsImpersonation(connection)) { - throw new ClientException(IMPERSONATION_UNSUPPORTED_ERROR_MESSAGE); - } - return connection; - } - - private static boolean supportsImpersonation(Connection connection) { - return connection.protocol().version().compareTo(BoltProtocolV44.VERSION) >= 0; - } -} 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 5730440b9e..b5fc631124 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/InternalDriver.java +++ b/driver/src/main/java/org/neo4j/driver/internal/InternalDriver.java @@ -33,6 +33,7 @@ import org.neo4j.driver.Logger; import org.neo4j.driver.Logging; import org.neo4j.driver.Metrics; +import org.neo4j.driver.NotificationConfig; import org.neo4j.driver.Query; import org.neo4j.driver.QueryConfig; import org.neo4j.driver.Session; @@ -42,10 +43,10 @@ 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.bolt.api.SecurityPlan; import org.neo4j.driver.internal.metrics.DevNullMetricsProvider; import org.neo4j.driver.internal.metrics.MetricsProvider; import org.neo4j.driver.internal.reactive.InternalRxSession; -import org.neo4j.driver.internal.security.SecurityPlan; import org.neo4j.driver.internal.types.InternalTypeSystem; import org.neo4j.driver.internal.util.Futures; import org.neo4j.driver.reactive.RxSession; @@ -67,23 +68,26 @@ public class InternalDriver implements Driver { private final AtomicBoolean closed = new AtomicBoolean(false); private final MetricsProvider metricsProvider; + private final NotificationConfig notificationConfig; InternalDriver( SecurityPlan securityPlan, SessionFactory sessionFactory, MetricsProvider metricsProvider, boolean telemetryDisabled, + NotificationConfig notificationConfig, Logging logging) { this.securityPlan = securityPlan; this.sessionFactory = sessionFactory; this.metricsProvider = metricsProvider; this.log = logging.getLog(getClass()); this.telemetryDisabled = telemetryDisabled; + this.notificationConfig = notificationConfig; } @Override public ExecutableQuery executableQuery(String query) { - return new InternalExecutableQuery(this, new Query(query), QueryConfig.defaultConfig()); + return new InternalExecutableQuery(this, new Query(query), QueryConfig.defaultConfig(), null); } @Override @@ -99,17 +103,17 @@ public T session( requireNonNull(sessionClass, "sessionConfig must not be null"); T session; if (Session.class.isAssignableFrom(sessionClass)) { - session = (T) new InternalSession(newSession(sessionConfig, sessionAuthToken)); + session = (T) new InternalSession(newSession(sessionConfig, notificationConfig, sessionAuthToken)); } else if (AsyncSession.class.isAssignableFrom(sessionClass)) { - session = (T) new InternalAsyncSession(newSession(sessionConfig, sessionAuthToken)); + session = (T) new InternalAsyncSession(newSession(sessionConfig, notificationConfig, sessionAuthToken)); } else if (org.neo4j.driver.reactive.ReactiveSession.class.isAssignableFrom(sessionClass)) { session = (T) new org.neo4j.driver.internal.reactive.InternalReactiveSession( - newSession(sessionConfig, sessionAuthToken)); + newSession(sessionConfig, notificationConfig, sessionAuthToken)); } else if (org.neo4j.driver.reactivestreams.ReactiveSession.class.isAssignableFrom(sessionClass)) { session = (T) new org.neo4j.driver.internal.reactivestreams.InternalReactiveSession( - newSession(sessionConfig, sessionAuthToken)); + newSession(sessionConfig, notificationConfig, sessionAuthToken)); } else if (RxSession.class.isAssignableFrom(sessionClass)) { - session = (T) new InternalRxSession(newSession(sessionConfig, sessionAuthToken)); + session = (T) new InternalRxSession(newSession(sessionConfig, notificationConfig, sessionAuthToken)); } else { throw new IllegalArgumentException( String.format("Unsupported session type '%s'", sessionClass.getCanonicalName())); @@ -215,9 +219,10 @@ private static RuntimeException driverCloseException() { return new IllegalStateException("This driver instance has already been closed"); } - public NetworkSession newSession(SessionConfig config, AuthToken overrideAuthToken) { + public NetworkSession newSession( + SessionConfig config, NotificationConfig notificationConfig, AuthToken overrideAuthToken) { assertOpen(); - var session = sessionFactory.newInstance(config, overrideAuthToken, telemetryDisabled); + var session = sessionFactory.newInstance(config, notificationConfig, overrideAuthToken, telemetryDisabled); 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/InternalExecutableQuery.java b/driver/src/main/java/org/neo4j/driver/internal/InternalExecutableQuery.java index ad7cfc9b19..9e785851ed 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/InternalExecutableQuery.java +++ b/driver/src/main/java/org/neo4j/driver/internal/InternalExecutableQuery.java @@ -21,41 +21,50 @@ import java.util.Map; import java.util.stream.Collector; import org.neo4j.driver.AccessMode; +import org.neo4j.driver.AuthToken; import org.neo4j.driver.Driver; import org.neo4j.driver.ExecutableQuery; import org.neo4j.driver.Query; import org.neo4j.driver.QueryConfig; import org.neo4j.driver.Record; import org.neo4j.driver.RoutingControl; +import org.neo4j.driver.Session; import org.neo4j.driver.SessionConfig; import org.neo4j.driver.TransactionCallback; import org.neo4j.driver.TransactionConfig; -import org.neo4j.driver.internal.telemetry.TelemetryApi; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; public class InternalExecutableQuery implements ExecutableQuery { private final Driver driver; private final Query query; private final QueryConfig config; + private final AuthToken authToken; - public InternalExecutableQuery(Driver driver, Query query, QueryConfig config) { + public InternalExecutableQuery(Driver driver, Query query, QueryConfig config, AuthToken authToken) { requireNonNull(driver, "driver must not be null"); requireNonNull(query, "query must not be null"); requireNonNull(config, "config must not be null"); this.driver = driver; this.query = query; this.config = config; + this.authToken = authToken; } @Override public ExecutableQuery withParameters(Map parameters) { requireNonNull(parameters, "parameters must not be null"); - return new InternalExecutableQuery(driver, query.withParameters(parameters), config); + return new InternalExecutableQuery(driver, query.withParameters(parameters), config, authToken); } @Override public ExecutableQuery withConfig(QueryConfig config) { requireNonNull(config, "config must not be null"); - return new InternalExecutableQuery(driver, query, config); + return new InternalExecutableQuery(driver, query, config, authToken); + } + + @Override + public ExecutableQuery withAuthToken(AuthToken authToken) { + return new InternalExecutableQuery(driver, query, config, authToken); } @Override @@ -68,7 +77,7 @@ public T execute(Collector recordCollector, ResultFinish var supplier = recordCollector.supplier(); var accumulator = recordCollector.accumulator(); var finisher = recordCollector.finisher(); - try (var session = (InternalSession) driver.session(sessionConfigBuilder.build())) { + try (var session = (InternalSession) driver.session(Session.class, sessionConfigBuilder.build(), authToken)) { TransactionCallback txCallback = tx -> { var result = tx.run(query); var container = supplier.get(); @@ -89,22 +98,27 @@ public T execute(Collector recordCollector, ResultFinish } // For testing only - public Driver driver() { + Driver driver() { return driver; } // For testing only - public String query() { + String query() { return query.text(); } // For testing only - public Map parameters() { + Map parameters() { return query.parameters().asMap(); } // For testing only - public QueryConfig config() { + QueryConfig config() { return config; } + + // For testing only + AuthToken authToken() { + return authToken; + } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalResult.java b/driver/src/main/java/org/neo4j/driver/internal/InternalResult.java index 0947af1bbd..371438482d 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/InternalResult.java +++ b/driver/src/main/java/org/neo4j/driver/internal/InternalResult.java @@ -28,15 +28,15 @@ import org.neo4j.driver.async.ResultCursor; import org.neo4j.driver.exceptions.ClientException; import org.neo4j.driver.exceptions.NoSuchRecordException; -import org.neo4j.driver.internal.spi.Connection; +import org.neo4j.driver.internal.bolt.api.BoltConnection; import org.neo4j.driver.internal.util.Futures; import org.neo4j.driver.summary.ResultSummary; public class InternalResult implements Result { - private final Connection connection; + private final BoltConnection connection; private final ResultCursor cursor; - public InternalResult(Connection connection, ResultCursor cursor) { + public InternalResult(BoltConnection connection, ResultCursor cursor) { this.connection = connection; this.cursor = cursor; } @@ -110,6 +110,6 @@ private T blockingGet(CompletionStage stage) { } private void terminateConnectionOnThreadInterrupt() { - connection.terminateAndRelease("Thread interrupted while waiting for result to arrive"); + connection.close(); } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalServerAddress.java b/driver/src/main/java/org/neo4j/driver/internal/InternalServerAddress.java new file mode 100644 index 0000000000..a41591fb25 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/InternalServerAddress.java @@ -0,0 +1,102 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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; + +import java.net.URI; +import java.util.Objects; +import org.neo4j.driver.net.ServerAddress; + +public record InternalServerAddress(String host, int port) implements ServerAddress { + public static final int DEFAULT_PORT = 7687; + + public InternalServerAddress { + Objects.requireNonNull(host, "host"); + requireValidPort(port); + } + + private static int requireValidPort(int port) { + if (port >= 0 && port <= 65_535) { + return port; + } + throw new IllegalArgumentException("Illegal port: " + port); + } + + public InternalServerAddress(String address) { + this(uriFrom(address)); + } + + public InternalServerAddress(URI uri) { + this(hostFrom(uri), portFrom(uri)); + } + + private static String hostFrom(URI uri) { + var host = uri.getHost(); + if (host == null) { + throw invalidAddressFormat(uri); + } + return host; + } + + private static int portFrom(URI uri) { + var port = uri.getPort(); + return port == -1 ? DEFAULT_PORT : port; + } + + private static RuntimeException invalidAddressFormat(URI uri) { + return invalidAddressFormat(uri.toString()); + } + + private static RuntimeException invalidAddressFormat(String address) { + return new IllegalArgumentException("Invalid address format `" + address + "`"); + } + + private static URI uriFrom(String address) { + String scheme; + String hostPort; + + var schemeSplit = address.split("://"); + if (schemeSplit.length == 1) { + // URI can't parse addresses without scheme, prepend fake "bolt://" to reuse the parsing facility + scheme = "bolt://"; + hostPort = hostPortFrom(schemeSplit[0]); + } else if (schemeSplit.length == 2) { + scheme = schemeSplit[0] + "://"; + hostPort = hostPortFrom(schemeSplit[1]); + } else { + throw invalidAddressFormat(address); + } + + return URI.create(scheme + hostPort); + } + + private static String hostPortFrom(String address) { + if (address.startsWith("[")) { + // expected to be an IPv6 address like [::1] or [::1]:7687 + return address; + } + + var containsSingleColon = address.indexOf(":") == address.lastIndexOf(":"); + if (containsSingleColon) { + // expected to be an IPv4 address with or without port like 127.0.0.1 or 127.0.0.1:7687 + return address; + } + + // address contains multiple colons and does not start with '[' + // expected to be an IPv6 address without brackets + return "[" + address + "]"; + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java b/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java index 5d6de6e997..8dda400db7 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java +++ b/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java @@ -31,9 +31,9 @@ import org.neo4j.driver.TransactionWork; import org.neo4j.driver.exceptions.ClientException; import org.neo4j.driver.internal.async.NetworkSession; -import org.neo4j.driver.internal.spi.Connection; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; import org.neo4j.driver.internal.telemetry.ApiTelemetryWork; -import org.neo4j.driver.internal.telemetry.TelemetryApi; import org.neo4j.driver.internal.util.Futures; public class InternalSession extends AbstractQueryRunner implements Session { @@ -200,7 +200,7 @@ private Transaction beginTransaction( private void terminateConnectionOnThreadInterrupt(String reason) { // try to get current connection if it has been acquired - Connection connection = null; + BoltConnection connection = null; try { connection = Futures.getNow(session.connectionAsync()); } catch (Throwable ignore) { @@ -208,7 +208,7 @@ private void terminateConnectionOnThreadInterrupt(String reason) { } if (connection != null) { - connection.terminateAndRelease(reason); + connection.forceClose(reason); } } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalTransaction.java b/driver/src/main/java/org/neo4j/driver/internal/InternalTransaction.java index df8254c816..ef328e5378 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/InternalTransaction.java +++ b/driver/src/main/java/org/neo4j/driver/internal/InternalTransaction.java @@ -55,7 +55,7 @@ public Result run(Query query) { var cursor = Futures.blockingGet( tx.runAsync(query), () -> terminateConnectionOnThreadInterrupt("Thread interrupted while running query in transaction")); - return new InternalResult(tx.connection(), cursor); + return new InternalResult(null, cursor); } @Override @@ -80,6 +80,6 @@ public void terminate() { } private void terminateConnectionOnThreadInterrupt(String reason) { - tx.connection().terminateAndRelease(reason); + tx.connection().forceClose(reason); } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/NotificationConfigMapper.java b/driver/src/main/java/org/neo4j/driver/internal/NotificationConfigMapper.java new file mode 100644 index 0000000000..608d7aa85d --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/NotificationConfigMapper.java @@ -0,0 +1,65 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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; + +import java.util.stream.Collectors; +import org.neo4j.driver.internal.bolt.api.NotificationCategory; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.NotificationSeverity; + +public class NotificationConfigMapper { + public static NotificationConfig map(org.neo4j.driver.NotificationConfig config) { + var original = (InternalNotificationConfig) config; + var disabledCategories = original.disabledCategories(); + return new NotificationConfig( + map(original.minimumSeverity()), + disabledCategories != null + ? disabledCategories.stream() + .map(NotificationConfigMapper::map) + .collect(Collectors.toSet()) + : null); + } + + private static NotificationSeverity map(org.neo4j.driver.NotificationSeverity severity) { + if (severity == null) { + return null; + } + var original = (InternalNotificationSeverity) severity; + return switch (original.type()) { + case INFORMATION -> NotificationSeverity.INFORMATION; + case WARNING -> NotificationSeverity.WARNING; + case OFF -> NotificationSeverity.OFF; + }; + } + + private static NotificationCategory map(org.neo4j.driver.NotificationCategory category) { + if (category == null) { + return null; + } + var original = (InternalNotificationCategory) category; + return switch (original.type()) { + case HINT -> new NotificationCategory(NotificationCategory.Type.HINT); + case UNRECOGNIZED -> new NotificationCategory(NotificationCategory.Type.UNRECOGNIZED); + case UNSUPPORTED -> new NotificationCategory(NotificationCategory.Type.UNSUPPORTED); + case PERFORMANCE -> new NotificationCategory(NotificationCategory.Type.PERFORMANCE); + case DEPRECATION -> new NotificationCategory(NotificationCategory.Type.DEPRECATION); + case SECURITY -> new NotificationCategory(NotificationCategory.Type.SECURITY); + case TOPOLOGY -> new NotificationCategory(NotificationCategory.Type.TOPOLOGY); + case GENERIC -> new NotificationCategory(NotificationCategory.Type.GENERIC); + }; + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingSettings.java b/driver/src/main/java/org/neo4j/driver/internal/RoutingSettings.java similarity index 90% rename from driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingSettings.java rename to driver/src/main/java/org/neo4j/driver/internal/RoutingSettings.java index a9f1f53746..c29826f34d 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingSettings.java +++ b/driver/src/main/java/org/neo4j/driver/internal/RoutingSettings.java @@ -14,10 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal; import static java.util.concurrent.TimeUnit.SECONDS; +import org.neo4j.driver.internal.bolt.api.RoutingContext; + public record RoutingSettings(long routingTablePurgeDelayMs, RoutingContext routingContext) { public static final long STALE_ROUTING_TABLE_PURGE_DELAY_MS = SECONDS.toMillis(30); } 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 01e303787d..552c2a3ab7 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/SessionFactory.java +++ b/driver/src/main/java/org/neo4j/driver/internal/SessionFactory.java @@ -18,11 +18,16 @@ import java.util.concurrent.CompletionStage; import org.neo4j.driver.AuthToken; +import org.neo4j.driver.NotificationConfig; import org.neo4j.driver.SessionConfig; import org.neo4j.driver.internal.async.NetworkSession; public interface SessionFactory { - NetworkSession newInstance(SessionConfig sessionConfig, AuthToken overrideAuthToken, boolean telemetryDisabled); + NetworkSession newInstance( + SessionConfig sessionConfig, + NotificationConfig notificationConfig, + AuthToken overrideAuthToken, + boolean telemetryDisabled); CompletionStage verifyConnectivity(); 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 de8ac27b94..30b8323f85 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/SessionFactoryImpl.java +++ b/driver/src/main/java/org/neo4j/driver/internal/SessionFactoryImpl.java @@ -24,6 +24,7 @@ import java.util.concurrent.CompletionStage; import org.neo4j.driver.AccessMode; import org.neo4j.driver.AuthToken; +import org.neo4j.driver.AuthTokenManager; import org.neo4j.driver.Bookmark; import org.neo4j.driver.BookmarkManager; import org.neo4j.driver.Config; @@ -32,27 +33,39 @@ import org.neo4j.driver.SessionConfig; import org.neo4j.driver.internal.async.LeakLoggingNetworkSession; import org.neo4j.driver.internal.async.NetworkSession; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.DatabaseNameUtil; import org.neo4j.driver.internal.retry.RetryLogic; -import org.neo4j.driver.internal.spi.ConnectionProvider; +import org.neo4j.driver.internal.security.InternalAuthToken; public class SessionFactoryImpl implements SessionFactory { - private final ConnectionProvider connectionProvider; + private final BoltConnectionProvider connectionProvider; private final RetryLogic retryLogic; private final Logging logging; private final boolean leakedSessionsLoggingEnabled; private final long defaultFetchSize; + private final AuthTokenManager authTokenManager; - SessionFactoryImpl(ConnectionProvider connectionProvider, RetryLogic retryLogic, Config config) { + SessionFactoryImpl( + BoltConnectionProvider connectionProvider, + RetryLogic retryLogic, + Config config, + AuthTokenManager authTokenManager) { this.connectionProvider = connectionProvider; this.leakedSessionsLoggingEnabled = config.logLeakedSessions(); this.retryLogic = retryLogic; this.logging = config.logging(); this.defaultFetchSize = config.fetchSize(); + this.authTokenManager = authTokenManager; } @Override public NetworkSession newInstance( - SessionConfig sessionConfig, AuthToken overrideAuthToken, boolean telemetryDisabled) { + SessionConfig sessionConfig, + NotificationConfig notificationConfig, + AuthToken overrideAuthToken, + boolean telemetryDisabled) { return createSession( connectionProvider, retryLogic, @@ -63,9 +76,11 @@ public NetworkSession newInstance( sessionConfig.impersonatedUser().orElse(null), logging, sessionConfig.bookmarkManager().orElse(NoOpBookmarkManager.INSTANCE), + notificationConfig, sessionConfig.notificationConfig(), overrideAuthToken, - telemetryDisabled); + telemetryDisabled, + authTokenManager); } private Set toDistinctSet(Iterable bookmarks) { @@ -102,7 +117,10 @@ private DatabaseName parseDatabaseName(SessionConfig sessionConfig) { @Override public CompletionStage verifyConnectivity() { - return connectionProvider.verifyConnectivity(); + return authTokenManager + .getToken() + .thenApply(authToken -> ((InternalAuthToken) authToken).toMap()) + .thenCompose(connectionProvider::verifyConnectivity); } @Override @@ -112,12 +130,18 @@ public CompletionStage close() { @Override public CompletionStage supportsMultiDb() { - return connectionProvider.supportsMultiDb(); + return authTokenManager + .getToken() + .thenApply(authToken -> ((InternalAuthToken) authToken).toMap()) + .thenCompose(connectionProvider::supportsMultiDb); } @Override public CompletionStage supportsSessionAuth() { - return connectionProvider.supportsSessionAuth(); + return authTokenManager + .getToken() + .thenApply(authToken -> ((InternalAuthToken) authToken).toMap()) + .thenCompose(connectionProvider::supportsSessionAuth); } /** @@ -127,12 +151,11 @@ public CompletionStage supportsSessionAuth() { * * @return the connection provider used by this factory. */ - public ConnectionProvider getConnectionProvider() { - return connectionProvider; - } - + // public ConnectionProvider getConnectionProvider() { + // return connectionProvider; + // } private NetworkSession createSession( - ConnectionProvider connectionProvider, + BoltConnectionProvider connectionProvider, RetryLogic retryLogic, DatabaseName databaseName, AccessMode mode, @@ -141,9 +164,11 @@ private NetworkSession createSession( String impersonatedUser, Logging logging, BookmarkManager bookmarkManager, + NotificationConfig driverNotificationConfig, NotificationConfig notificationConfig, AuthToken authToken, - boolean telemetryDisabled) { + boolean telemetryDisabled, + AuthTokenManager authTokenManager) { Objects.requireNonNull(bookmarks, "bookmarks may not be null"); Objects.requireNonNull(bookmarkManager, "bookmarkManager may not be null"); return leakedSessionsLoggingEnabled @@ -157,9 +182,11 @@ private NetworkSession createSession( fetchSize, logging, bookmarkManager, + driverNotificationConfig, notificationConfig, authToken, - telemetryDisabled) + telemetryDisabled, + authTokenManager) : new NetworkSession( connectionProvider, retryLogic, @@ -170,8 +197,14 @@ private NetworkSession createSession( fetchSize, logging, bookmarkManager, + driverNotificationConfig, notificationConfig, authToken, - telemetryDisabled); + telemetryDisabled, + authTokenManager); + } + + public BoltConnectionProvider getConnectionProvider() { + return connectionProvider; } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/BoltConnectionWithAuthTokenManager.java b/driver/src/main/java/org/neo4j/driver/internal/async/BoltConnectionWithAuthTokenManager.java new file mode 100644 index 0000000000..3ae83101af --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/async/BoltConnectionWithAuthTokenManager.java @@ -0,0 +1,294 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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; + +import java.time.Duration; +import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.concurrent.CompletionStage; +import org.neo4j.driver.AuthTokenManager; +import org.neo4j.driver.Value; +import org.neo4j.driver.exceptions.SecurityException; +import org.neo4j.driver.exceptions.SecurityRetryableException; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.AuthData; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltConnectionState; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.ResponseHandler; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; +import org.neo4j.driver.internal.bolt.api.TransactionType; +import org.neo4j.driver.internal.bolt.api.summary.BeginSummary; +import org.neo4j.driver.internal.bolt.api.summary.CommitSummary; +import org.neo4j.driver.internal.bolt.api.summary.DiscardSummary; +import org.neo4j.driver.internal.bolt.api.summary.LogoffSummary; +import org.neo4j.driver.internal.bolt.api.summary.LogonSummary; +import org.neo4j.driver.internal.bolt.api.summary.PullSummary; +import org.neo4j.driver.internal.bolt.api.summary.ResetSummary; +import org.neo4j.driver.internal.bolt.api.summary.RollbackSummary; +import org.neo4j.driver.internal.bolt.api.summary.RouteSummary; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.api.summary.TelemetrySummary; +import org.neo4j.driver.internal.security.InternalAuthToken; + +public class BoltConnectionWithAuthTokenManager implements BoltConnection { + private final BoltConnection delegate; + private final AuthTokenManager authTokenManager; + + public BoltConnectionWithAuthTokenManager(BoltConnection delegate, AuthTokenManager authTokenManager) { + this.delegate = Objects.requireNonNull(delegate); + this.authTokenManager = Objects.requireNonNull(authTokenManager); + } + + @Override + public CompletionStage route( + DatabaseName databaseName, String impersonatedUser, Set bookmarks) { + return delegate.route(databaseName, impersonatedUser, bookmarks).thenApply(ignored -> this); + } + + @Override + public CompletionStage beginTransaction( + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, + Set bookmarks, + TransactionType transactionType, + Duration txTimeout, + Map txMetadata, + NotificationConfig notificationConfig) { + return delegate.beginTransaction( + databaseName, + accessMode, + impersonatedUser, + bookmarks, + transactionType, + txTimeout, + txMetadata, + notificationConfig) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage runInAutoCommitTransaction( + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, + Set bookmarks, + String query, + Map parameters, + Duration txTimeout, + Map txMetadata, + NotificationConfig notificationConfig) { + return delegate.runInAutoCommitTransaction( + databaseName, + accessMode, + impersonatedUser, + bookmarks, + query, + parameters, + txTimeout, + txMetadata, + notificationConfig) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage run(String query, Map parameters) { + return delegate.run(query, parameters).thenApply(ignored -> this); + } + + @Override + public CompletionStage pull(long qid, long request) { + return delegate.pull(qid, request).thenApply(ignored -> this); + } + + @Override + public CompletionStage discard(long qid, long number) { + return delegate.discard(qid, number).thenApply(ignored -> this); + } + + @Override + public CompletionStage commit() { + return delegate.commit().thenApply(ignored -> this); + } + + @Override + public CompletionStage rollback() { + return delegate.rollback().thenApply(ignored -> this); + } + + @Override + public CompletionStage reset() { + return delegate.reset().thenApply(ignored -> this); + } + + @Override + public CompletionStage logoff() { + return delegate.logoff().thenApply(ignored -> this); + } + + @Override + public CompletionStage logon(Map authMap) { + return delegate.logon(authMap).thenApply(ignored -> this); + } + + @Override + public CompletionStage telemetry(TelemetryApi telemetryApi) { + return delegate.telemetry(telemetryApi).thenApply(ignored -> this); + } + + @Override + public CompletionStage clear() { + return delegate.clear(); + } + + @Override + public CompletionStage flush(ResponseHandler handler) { + return delegate.flush(new ResponseHandler() { + private Throwable error; + + @Override + public void onError(Throwable throwable) { + if (error == null) { + error = mapSecurityError(throwable); + handler.onError(error); + } + } + + @Override + public void onBeginSummary(BeginSummary summary) { + handler.onBeginSummary(summary); + } + + @Override + public void onRunSummary(RunSummary summary) { + handler.onRunSummary(summary); + } + + @Override + public void onRecord(Value[] fields) { + handler.onRecord(fields); + } + + @Override + public void onPullSummary(PullSummary summary) { + handler.onPullSummary(summary); + } + + @Override + public void onDiscardSummary(DiscardSummary summary) { + handler.onDiscardSummary(summary); + } + + @Override + public void onCommitSummary(CommitSummary summary) { + handler.onCommitSummary(summary); + } + + @Override + public void onRollbackSummary(RollbackSummary summary) { + handler.onRollbackSummary(summary); + } + + @Override + public void onResetSummary(ResetSummary summary) { + handler.onResetSummary(summary); + } + + @Override + public void onRouteSummary(RouteSummary summary) { + handler.onRouteSummary(summary); + } + + @Override + public void onLogoffSummary(LogoffSummary summary) { + handler.onLogoffSummary(summary); + } + + @Override + public void onLogonSummary(LogonSummary summary) { + handler.onLogonSummary(summary); + } + + @Override + public void onTelemetrySummary(TelemetrySummary summary) { + handler.onTelemetrySummary(summary); + } + + @Override + public void onComplete() { + handler.onComplete(); + } + }); + } + + @Override + public CompletionStage forceClose(String reason) { + return delegate.forceClose(reason); + } + + @Override + public CompletionStage close() { + return delegate.close(); + } + + @Override + public BoltConnectionState state() { + return delegate.state(); + } + + @Override + public CompletionStage authData() { + return delegate.authData(); + } + + @Override + public String serverAgent() { + return delegate.serverAgent(); + } + + @Override + public BoltServerAddress serverAddress() { + return delegate.serverAddress(); + } + + @Override + public BoltProtocolVersion protocolVersion() { + return delegate.protocolVersion(); + } + + @Override + public boolean telemetrySupported() { + return delegate.telemetrySupported(); + } + + private Throwable mapSecurityError(Throwable throwable) { + if (throwable instanceof SecurityException securityException) { + var authData = delegate.authData().toCompletableFuture().getNow(null); + if (authData != null + && authTokenManager.handleSecurityException( + new InternalAuthToken(authData.authMap()), securityException)) { + throwable = new SecurityRetryableException(securityException); + } + } + return throwable; + } +} 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 cc91d97e27..3281e28859 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 @@ -18,19 +18,15 @@ import java.util.Set; 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; +import org.neo4j.driver.internal.bolt.api.DatabaseName; /** * Describes what kind of connection to return by {@link ConnectionProvider} */ public interface ConnectionContext { - Supplier PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER = - () -> new IllegalStateException("Pending database name encountered."); CompletableFuture databaseNameFuture(); 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 f30efc41a7..93174cce17 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 @@ -16,8 +16,8 @@ */ package org.neo4j.driver.internal.async; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.DatabaseNameUtil.systemDatabase; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.systemDatabase; import java.util.Collections; import java.util.Set; @@ -25,8 +25,8 @@ 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; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; /** * A {@link Connection} shall fulfil this {@link ImmutableConnectionContext} when acquired from a connection provider. diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncSession.java b/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncSession.java index f2419e0925..bf765c77cc 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncSession.java +++ b/driver/src/main/java/org/neo4j/driver/internal/async/InternalAsyncSession.java @@ -18,7 +18,6 @@ import static java.util.Collections.emptyMap; import static org.neo4j.driver.internal.util.Futures.completedWithNull; -import static org.neo4j.driver.internal.util.Futures.failedFuture; import java.util.HashSet; import java.util.Map; @@ -36,8 +35,8 @@ import org.neo4j.driver.async.ResultCursor; import org.neo4j.driver.exceptions.ClientException; import org.neo4j.driver.internal.InternalBookmark; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; import org.neo4j.driver.internal.telemetry.ApiTelemetryWork; -import org.neo4j.driver.internal.telemetry.TelemetryApi; import org.neo4j.driver.internal.util.Futures; public class InternalAsyncSession extends AsyncAbstractQueryRunner implements AsyncSession { @@ -187,7 +186,7 @@ private CompletionStage safeExecuteWork( return result == null ? completedWithNull() : result; } catch (Throwable workError) { // work threw an exception, wrap it in a future and proceed - return failedFuture(workError); + return CompletableFuture.failedFuture(workError); } } 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 f05ec9a4b1..ef309575aa 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 @@ -23,20 +23,20 @@ import java.util.stream.Collectors; import org.neo4j.driver.AccessMode; import org.neo4j.driver.AuthToken; +import org.neo4j.driver.AuthTokenManager; import org.neo4j.driver.Bookmark; import org.neo4j.driver.BookmarkManager; import org.neo4j.driver.Logging; import org.neo4j.driver.NotificationConfig; -import org.neo4j.driver.internal.DatabaseName; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.api.DatabaseName; import org.neo4j.driver.internal.retry.RetryLogic; -import org.neo4j.driver.internal.spi.ConnectionProvider; -import org.neo4j.driver.internal.util.Futures; public class LeakLoggingNetworkSession extends NetworkSession { private final String stackTrace; public LeakLoggingNetworkSession( - ConnectionProvider connectionProvider, + BoltConnectionProvider connectionProvider, RetryLogic retryLogic, DatabaseName databaseName, AccessMode mode, @@ -45,9 +45,11 @@ public LeakLoggingNetworkSession( long fetchSize, Logging logging, BookmarkManager bookmarkManager, + NotificationConfig driverNotificationConfig, NotificationConfig notificationConfig, AuthToken overrideAuthToken, - boolean telemetryDisabled) { + boolean telemetryDisabled, + AuthTokenManager authTokenManager) { super( connectionProvider, retryLogic, @@ -58,9 +60,11 @@ public LeakLoggingNetworkSession( fetchSize, logging, bookmarkManager, + driverNotificationConfig, notificationConfig, overrideAuthToken, - telemetryDisabled); + telemetryDisabled, + authTokenManager); this.stackTrace = captureStackTrace(); } @@ -72,15 +76,16 @@ protected void finalize() throws Throwable { } private void logLeakIfNeeded() { - var isOpen = Futures.blockingGet(currentConnectionIsOpen()); - if (isOpen) { - log.error( - "Neo4j Session object leaked, please ensure that your application " - + "fully consumes results in Sessions or explicitly calls `close` on Sessions before disposing of the objects.\n" - + "Session was create at:\n" - + stackTrace, - null); - } + // var isOpen = Futures.blockingGet(currentConnectionIsOpen()); + // if (isOpen) { + // log.error( + // "Neo4j Session object leaked, please ensure that your application " + // + "fully consumes results in Sessions or explicitly calls `close` on Sessions + // before disposing of the objects.\n" + // + "Session was create at:\n" + // + stackTrace, + // null); + // } } private static String captureStackTrace() { diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/NetworkConnection.java b/driver/src/main/java/org/neo4j/driver/internal/async/NetworkConnection.java deleted file mode 100644 index b94ba7566d..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/async/NetworkConnection.java +++ /dev/null @@ -1,315 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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; - -import static java.util.Collections.emptyMap; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.poolId; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setTerminationReason; -import static org.neo4j.driver.internal.util.Futures.asCompletionStage; -import static org.neo4j.driver.internal.util.LockUtil.executeWithLock; - -import io.netty.channel.Channel; -import io.netty.channel.ChannelHandler; -import java.time.Clock; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionStage; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.locks.Lock; -import java.util.concurrent.locks.ReentrantLock; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; -import org.neo4j.driver.internal.async.inbound.ConnectionReadTimeoutHandler; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; -import org.neo4j.driver.internal.async.pool.ExtendedChannelPool; -import org.neo4j.driver.internal.handlers.ChannelReleasingResetResponseHandler; -import org.neo4j.driver.internal.handlers.ResetResponseHandler; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -import org.neo4j.driver.internal.messaging.request.DiscardAllMessage; -import org.neo4j.driver.internal.messaging.request.DiscardMessage; -import org.neo4j.driver.internal.messaging.request.PullAllMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.ResetMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.metrics.ListenerEvent; -import org.neo4j.driver.internal.metrics.MetricsListener; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; - -/** - * This connection represents a simple network connection to a remote server. It wraps a channel obtained from a connection pool. The life cycle of this - * connection start from the moment the channel is borrowed out of the pool and end at the time the connection is released back to the pool. - */ -public class NetworkConnection implements Connection { - private final Logger log; - private final Lock lock; - private final Channel channel; - private final InboundMessageDispatcher messageDispatcher; - private final String serverAgent; - private final BoltServerAddress serverAddress; - private final boolean telemetryEnabled; - private final BoltProtocol protocol; - private final ExtendedChannelPool channelPool; - private final CompletableFuture releaseFuture; - private final Clock clock; - private final MetricsListener metricsListener; - private final ListenerEvent inUseEvent; - - private final Long connectionReadTimeout; - - private Status status = Status.OPEN; - private TerminationAwareStateLockingExecutor terminationAwareStateLockingExecutor; - private ChannelHandler connectionReadTimeoutHandler; - - public NetworkConnection( - Channel channel, - ExtendedChannelPool channelPool, - Clock clock, - MetricsListener metricsListener, - Logging logging) { - this.log = logging.getLog(getClass()); - this.lock = new ReentrantLock(); - this.channel = channel; - this.messageDispatcher = ChannelAttributes.messageDispatcher(channel); - this.serverAgent = ChannelAttributes.serverAgent(channel); - this.serverAddress = ChannelAttributes.serverAddress(channel); - this.telemetryEnabled = ChannelAttributes.telemetryEnabled(channel); - this.protocol = BoltProtocol.forChannel(channel); - this.channelPool = channelPool; - this.releaseFuture = new CompletableFuture<>(); - this.clock = clock; - this.metricsListener = metricsListener; - this.inUseEvent = metricsListener.createListenerEvent(); - this.connectionReadTimeout = - ChannelAttributes.connectionReadTimeout(channel).orElse(null); - metricsListener.afterConnectionCreated(poolId(this.channel), this.inUseEvent); - } - - @Override - public boolean isOpen() { - return executeWithLock(lock, () -> status == Status.OPEN); - } - - @Override - public void enableAutoRead() { - if (isOpen()) { - setAutoRead(true); - } - } - - @Override - public void disableAutoRead() { - if (isOpen()) { - setAutoRead(false); - } - } - - @Override - public void write(Message message, ResponseHandler handler) { - if (verifyOpen(handler)) { - writeMessageInEventLoop(message, handler, false); - } - } - - @Override - public void writeAndFlush(Message message, ResponseHandler handler) { - if (verifyOpen(handler)) { - writeMessageInEventLoop(message, handler, true); - } - } - - @Override - public boolean isTelemetryEnabled() { - return telemetryEnabled; - } - - @Override - public CompletionStage reset(Throwable throwable) { - var result = new CompletableFuture(); - var handler = new ResetResponseHandler(messageDispatcher, result, throwable); - writeResetMessageIfNeeded(handler, true); - return result; - } - - @Override - public CompletionStage release() { - if (executeWithLock(lock, () -> updateStateIfOpen(Status.RELEASED))) { - var handler = new ChannelReleasingResetResponseHandler( - channel, channelPool, messageDispatcher, clock, releaseFuture); - - writeResetMessageIfNeeded(handler, false); - metricsListener.afterConnectionReleased(poolId(this.channel), this.inUseEvent); - } - return releaseFuture; - } - - @Override - public void terminateAndRelease(String reason) { - if (executeWithLock(lock, () -> updateStateIfOpen(Status.TERMINATED))) { - setTerminationReason(channel, reason); - asCompletionStage(channel.close()) - .exceptionally(throwable -> null) - .thenCompose(ignored -> channelPool.release(channel)) - .whenComplete((ignored, throwable) -> { - releaseFuture.complete(null); - metricsListener.afterConnectionReleased(poolId(this.channel), this.inUseEvent); - }); - } - } - - @Override - public String serverAgent() { - return serverAgent; - } - - @Override - public BoltServerAddress serverAddress() { - return serverAddress; - } - - @Override - public BoltProtocol protocol() { - return protocol; - } - - @Override - public void bindTerminationAwareStateLockingExecutor(TerminationAwareStateLockingExecutor executor) { - executeWithLock(lock, () -> { - if (this.terminationAwareStateLockingExecutor != null) { - throw new IllegalStateException("terminationAwareStateLockingExecutor is already set"); - } - this.terminationAwareStateLockingExecutor = executor; - }); - } - - private boolean updateStateIfOpen(Status newStatus) { - if (Status.OPEN.equals(status)) { - status = newStatus; - return true; - } else { - return false; - } - } - - private void writeResetMessageIfNeeded(ResponseHandler resetHandler, boolean isSessionReset) { - channel.eventLoop().execute(() -> { - if (isSessionReset && !isOpen()) { - resetHandler.onSuccess(emptyMap()); - } else { - // auto-read could've been disabled, re-enable it to automatically receive response for RESET - setAutoRead(true); - - messageDispatcher.enqueue(resetHandler); - channel.writeAndFlush(ResetMessage.RESET).addListener(future -> registerConnectionReadTimeout(channel)); - } - }); - } - - private void writeMessageInEventLoop(Message message, ResponseHandler handler, boolean flush) { - channel.eventLoop() - .execute(() -> terminationAwareStateLockingExecutor(message).execute(causeOfTermination -> { - if (causeOfTermination == null) { - messageDispatcher.enqueue(handler); - - if (flush) { - channel.writeAndFlush(message) - .addListener(future -> registerConnectionReadTimeout(channel)); - } else { - channel.write(message, channel.voidPromise()); - } - } else { - handler.onFailure(causeOfTermination); - } - })); - } - - private void setAutoRead(boolean value) { - channel.config().setAutoRead(value); - } - - private boolean verifyOpen(ResponseHandler handler) { - var connectionStatus = executeWithLock(lock, () -> status); - return switch (connectionStatus) { - case OPEN -> true; - case RELEASED -> { - Exception error = - new IllegalStateException("Connection has been released to the pool and can't be used"); - if (handler != null) { - handler.onFailure(error); - } - yield false; - } - case TERMINATED -> { - Exception terminatedError = - new IllegalStateException("Connection has been terminated and can't be used"); - if (handler != null) { - handler.onFailure(terminatedError); - } - yield false; - } - }; - } - - private void registerConnectionReadTimeout(Channel channel) { - if (!channel.eventLoop().inEventLoop()) { - throw new IllegalStateException("This method may only be called in the EventLoop"); - } - - if (connectionReadTimeout != null && connectionReadTimeoutHandler == null) { - connectionReadTimeoutHandler = new ConnectionReadTimeoutHandler(connectionReadTimeout, TimeUnit.SECONDS); - channel.pipeline().addFirst(connectionReadTimeoutHandler); - log.debug("Added ConnectionReadTimeoutHandler"); - messageDispatcher.setBeforeLastHandlerHook((messageType) -> { - channel.pipeline().remove(connectionReadTimeoutHandler); - connectionReadTimeoutHandler = null; - messageDispatcher.setBeforeLastHandlerHook(null); - log.debug("Removed ConnectionReadTimeoutHandler"); - }); - } - } - - private TerminationAwareStateLockingExecutor terminationAwareStateLockingExecutor(Message message) { - var result = (TerminationAwareStateLockingExecutor) consumer -> consumer.accept(null); - if (isQueryMessage(message)) { - var lockingExecutor = executeWithLock(lock, () -> this.terminationAwareStateLockingExecutor); - if (lockingExecutor != null) { - result = lockingExecutor; - } - } - return result; - } - - private boolean isQueryMessage(Message message) { - return message instanceof RunWithMetadataMessage - || message instanceof PullMessage - || message instanceof PullAllMessage - || message instanceof DiscardMessage - || message instanceof DiscardAllMessage - || message instanceof CommitMessage - || message instanceof RollbackMessage; - } - - private enum Status { - OPEN, - RELEASED, - TERMINATED - } -} 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 cc102342c1..2543339975 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 @@ -18,46 +18,70 @@ import static java.util.concurrent.CompletableFuture.completedFuture; import static org.neo4j.driver.internal.util.Futures.completedWithNull; +import static org.neo4j.driver.internal.util.Futures.completionExceptionCause; +import java.util.ArrayList; import java.util.Collections; import java.util.HashSet; +import java.util.List; +import java.util.Map; import java.util.Objects; import java.util.Set; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionException; import java.util.concurrent.CompletionStage; +import java.util.concurrent.TimeoutException; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicReference; import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collectors; import org.neo4j.driver.AccessMode; import org.neo4j.driver.AuthToken; +import org.neo4j.driver.AuthTokenManager; import org.neo4j.driver.Bookmark; import org.neo4j.driver.BookmarkManager; import org.neo4j.driver.Logger; import org.neo4j.driver.Logging; -import org.neo4j.driver.NotificationConfig; import org.neo4j.driver.Query; +import org.neo4j.driver.Record; import org.neo4j.driver.TransactionConfig; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; import org.neo4j.driver.async.ResultCursor; import org.neo4j.driver.exceptions.ClientException; +import org.neo4j.driver.exceptions.SecurityException; import org.neo4j.driver.exceptions.TransactionNestingException; +import org.neo4j.driver.exceptions.UnsupportedFeatureException; import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.DatabaseName; import org.neo4j.driver.internal.FailableCursor; -import org.neo4j.driver.internal.ImpersonationUtil; -import org.neo4j.driver.internal.cursor.AsyncResultCursor; -import org.neo4j.driver.internal.cursor.ResultCursorFactory; +import org.neo4j.driver.internal.InternalRecord; +import org.neo4j.driver.internal.NotificationConfigMapper; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.DatabaseNameUtil; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.ResponseHandler; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; +import org.neo4j.driver.internal.bolt.api.exception.MinVersionAcquisitionException; +import org.neo4j.driver.internal.bolt.api.summary.DiscardSummary; +import org.neo4j.driver.internal.bolt.api.summary.PullSummary; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.cursor.DisposableResultCursorImpl; +import org.neo4j.driver.internal.cursor.ResultCursorImpl; import org.neo4j.driver.internal.cursor.RxResultCursor; +import org.neo4j.driver.internal.cursor.RxResultCursorImpl; import org.neo4j.driver.internal.logging.PrefixedLogger; import org.neo4j.driver.internal.retry.RetryLogic; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ConnectionProvider; +import org.neo4j.driver.internal.security.InternalAuthToken; import org.neo4j.driver.internal.telemetry.ApiTelemetryWork; -import org.neo4j.driver.internal.telemetry.TelemetryApi; +import org.neo4j.driver.internal.util.ErrorUtil; import org.neo4j.driver.internal.util.Futures; public class NetworkSession { - private final ConnectionProvider connectionProvider; + private final BoltConnectionProvider boltConnectionProvider; private final NetworkSessionConnectionContext connectionContext; private final AccessMode mode; private final RetryLogic retryLogic; @@ -66,18 +90,20 @@ public class NetworkSession { private final long fetchSize; private volatile CompletionStage transactionStage = completedWithNull(); - private volatile CompletionStage connectionStage = completedWithNull(); + private volatile CompletionStage connectionStage = completedWithNull(); private volatile CompletionStage resultCursorStage = completedWithNull(); private final AtomicBoolean open = new AtomicBoolean(true); private final BookmarkManager bookmarkManager; private volatile Set lastUsedBookmarks = Collections.emptySet(); private volatile Set lastReceivedBookmarks; + private final NotificationConfig driverNotificationConfig; private final NotificationConfig notificationConfig; private final boolean telemetryDisabled; + private final AuthTokenManager authTokenManager; public NetworkSession( - ConnectionProvider connectionProvider, + BoltConnectionProvider boltConnectionProvider, RetryLogic retryLogic, DatabaseName databaseName, AccessMode mode, @@ -86,12 +112,14 @@ public NetworkSession( long fetchSize, Logging logging, BookmarkManager bookmarkManager, - NotificationConfig notificationConfig, + org.neo4j.driver.NotificationConfig driverNotificationConfig, + org.neo4j.driver.NotificationConfig notificationConfig, AuthToken overrideAuthToken, - boolean telemetryDisabled) { + boolean telemetryDisabled, + AuthTokenManager authTokenManager) { Objects.requireNonNull(bookmarks, "bookmarks may not be null"); Objects.requireNonNull(bookmarkManager, "bookmarkManager may not be null"); - this.connectionProvider = connectionProvider; + this.boltConnectionProvider = Objects.requireNonNull(boltConnectionProvider); this.mode = mode; this.retryLogic = retryLogic; this.logging = logging; @@ -105,28 +133,201 @@ public NetworkSession( this.connectionContext = new NetworkSessionConnectionContext( databaseNameFuture, determineBookmarks(false), impersonatedUser, overrideAuthToken); this.fetchSize = fetchSize; - this.notificationConfig = notificationConfig; + this.driverNotificationConfig = NotificationConfigMapper.map(driverNotificationConfig); + this.notificationConfig = NotificationConfigMapper.map(notificationConfig); this.telemetryDisabled = telemetryDisabled; + this.authTokenManager = authTokenManager; } public CompletionStage runAsync(Query query, TransactionConfig config) { - var newResultCursorStage = - buildResultCursorFactory(query, config).thenCompose(ResultCursorFactory::asyncResult); + return ensureNoOpenTxBeforeRunningQuery() + .thenCompose(ignore -> acquireConnection(mode)) + .thenCompose(connection -> { + var cursorFuture = new CompletableFuture(); + var parameters = query.parameters().asMap(Values::value); + var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.AUTO_COMMIT_TRANSACTION); + apiTelemetryWork.setEnabled(!telemetryDisabled); + var session = this; + var cursorStage = apiTelemetryWork + .pipelineTelemetryIfEnabled(connection) + .thenCompose(conn -> conn.runInAutoCommitTransaction( + connectionContext.databaseNameFuture.getNow(null), + asBoltAccessMode(mode), + connectionContext.impersonatedUser, + determineBookmarks(true).stream() + .map(Bookmark::value) + .collect(Collectors.toSet()), + query.text(), + parameters, + config.timeout(), + config.metadata(), + notificationConfig)) + .thenCompose(conn -> conn.pull(-1, fetchSize)) + .thenCompose(conn -> conn.flush(new ResponseHandler() { + private RunSummary runSummary; + private final List records = new ArrayList<>(); + private PullSummary pullSummary; + private Throwable error; + + @Override + public void onError(Throwable throwable) { + error = completionExceptionCause(throwable); + if (error instanceof IllegalStateException) { + error = ErrorUtil.newConnectionTerminatedError(); + } + } + + @Override + public void onRunSummary(RunSummary summary) { + runSummary = summary; + } + + @Override + public void onRecord(Value[] fields) { + records.add(new InternalRecord(runSummary.keys(), fields)); + } + + @Override + public void onPullSummary(PullSummary summary) { + pullSummary = summary; + } - resultCursorStage = newResultCursorStage.exceptionally(error -> null); - return newResultCursorStage - .thenCompose(AsyncResultCursor::mapSuccessfulRunCompletionAsync) - .thenApply(Function.identity()); // convert the return type + @Override + public void onDiscardSummary(DiscardSummary summary) { + cursorFuture.getNow(null).delegate().onDiscardSummary(summary); + } + + @Override + public void onComplete() { + if (runSummary != null) { + cursorFuture.complete(new DisposableResultCursorImpl(new ResultCursorImpl( + connection, + query, + fetchSize, + null, + session::handleNewBookmark, + true, + runSummary, + () -> null, + records, + pullSummary, + null, + error))); + } else { + cursorFuture.completeExceptionally(error); + } + } + })) + .thenCompose(flushResult -> cursorFuture) + .handle((resultCursor, throwable) -> { + var error = completionExceptionCause(throwable); + if (error != null) { + return connection + .close() + .handle((ignored, closeError) -> { + if (closeError != null) { + error.addSuppressed(closeError); + } + if (error instanceof RuntimeException runtimeException) { + throw runtimeException; + } else { + throw new CompletionException(error); + } + }); + } else { + return CompletableFuture.completedStage(resultCursor); + } + }) + .thenCompose(Function.identity()); + resultCursorStage = cursorStage.exceptionally(error -> null); + return cursorStage.thenApply(Function.identity()); + }); } public CompletionStage runRx( Query query, TransactionConfig config, CompletionStage cursorPublishStage) { - var newResultCursorStage = buildResultCursorFactory(query, config).thenCompose(ResultCursorFactory::rxResult); - resultCursorStage = newResultCursorStage - .thenCompose(cursor -> cursor == null ? CompletableFuture.completedFuture(null) : cursorPublishStage) - .exceptionally(throwable -> null); - return newResultCursorStage; + return ensureNoOpenTxBeforeRunningQuery() + .thenCompose(ignore -> acquireConnection(mode)) + .thenCompose(connection -> { + var cursorFuture = new CompletableFuture(); + var parameters = query.parameters().asMap(Values::value); + var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.AUTO_COMMIT_TRANSACTION); + apiTelemetryWork.setEnabled(!telemetryDisabled); + var session = this; + var runFailed = new AtomicBoolean(false); + var cursorStage = apiTelemetryWork + .pipelineTelemetryIfEnabled(connection) + .thenCompose(conn -> conn.runInAutoCommitTransaction( + connectionContext.databaseNameFuture.getNow(null), + asBoltAccessMode(mode), + connectionContext.impersonatedUser, + determineBookmarks(true).stream() + .map(Bookmark::value) + .collect(Collectors.toSet()), + query.text(), + parameters, + config.timeout(), + config.metadata(), + notificationConfig)) + .thenCompose(conn -> conn.flush(new ResponseHandler() { + @Override + public void onError(Throwable throwable) { + throwable = Futures.completionExceptionCause(throwable); + if (throwable instanceof IllegalStateException) { + throwable = ErrorUtil.newConnectionTerminatedError(); + } + runFailed.set(true); + cursorFuture.complete(new RxResultCursorImpl( + connection, + query, + null, + throwable, + () -> null, + session::handleNewBookmark, + (ignored) -> {}, + true, + () -> null)); + } + + @Override + public void onRunSummary(RunSummary summary) { + cursorFuture.complete(new RxResultCursorImpl( + connection, + query, + summary, + null, + () -> null, + session::handleNewBookmark, + (ignored) -> {}, + true, + () -> null)); + } + })) + .thenCompose(flushResult -> cursorFuture) + .handle((resultCursor, throwable) -> { + var error = completionExceptionCause(throwable); + if (error != null) { + return connection.close().handle((ignored, closeError) -> { + if (closeError != null) { + error.addSuppressed(closeError); + } + if (error instanceof RuntimeException runtimeException) { + throw runtimeException; + } else { + throw new CompletionException(error); + } + }); + } else if (runFailed.get()) { + return connection.close().handle((ignored1, ignored2) -> resultCursor); + } else { + return CompletableFuture.completedStage(resultCursor); + } + }) + .thenCompose(Function.identity()); + resultCursorStage = cursorStage.exceptionally(error -> null); + return cursorStage.thenApply(Function.identity()); + }); } public CompletionStage beginTransactionAsync( @@ -140,12 +341,12 @@ public CompletionStage beginTransactionAsync( } public CompletionStage beginTransactionAsync( - AccessMode mode, TransactionConfig config, ApiTelemetryWork apiTelemetryWork) { + org.neo4j.driver.AccessMode mode, TransactionConfig config, ApiTelemetryWork apiTelemetryWork) { return beginTransactionAsync(mode, config, null, apiTelemetryWork, true); } public CompletionStage beginTransactionAsync( - AccessMode mode, + org.neo4j.driver.AccessMode mode, TransactionConfig config, String txType, ApiTelemetryWork apiTelemetryWork, @@ -157,11 +358,14 @@ public CompletionStage beginTransactionAsync( // create a chain that acquires connection and starts a transaction var newTransactionStage = ensureNoOpenTxBeforeStartingTx() .thenCompose(ignore -> acquireConnection(mode)) - .thenApply(connection -> - ImpersonationUtil.ensureImpersonationSupport(connection, connection.impersonatedUser())) + // .thenApply(connection -> ImpersonationUtil.ensureImpersonationSupport(connection, + // connection.impersonatedUser())) .thenCompose(connection -> { var tx = new UnmanagedTransaction( connection, + connectionContext.databaseNameFuture.getNow(null), + asBoltAccessMode(mode), + connectionContext.impersonatedUser, this::handleNewBookmark, fetchSize, notificationConfig, @@ -198,10 +402,24 @@ public CompletionStage resetAsync() { .thenCompose(ignore -> connectionStage) .thenCompose(connection -> { if (connection != null) { - // there exists an active connection, send a RESET message over it - return connection.reset(terminationException.get()); + var future = new CompletableFuture(); + return connection + .reset() + .thenCompose(conn -> conn.flush(new ResponseHandler() { + @Override + public void onError(Throwable throwable) { + future.completeExceptionally(throwable); + } + + @Override + public void onComplete() { + future.complete(null); + } + })) + .thenCompose(ignored -> future); + } else { + return completedWithNull(); } - return completedWithNull(); }); } @@ -217,14 +435,14 @@ public CompletionStage releaseConnectionAsync() { return connectionStage.thenCompose(connection -> { if (connection != null) { // there exists connection, try to release it back to the pool - return connection.release(); + return connection.close(); } // no connection so return null return completedWithNull(); }); } - public CompletionStage connectionAsync() { + public CompletionStage connectionAsync() { return connectionStage; } @@ -258,51 +476,22 @@ public CompletionStage closeAsync() { return completedWithNull(); } - protected CompletionStage currentConnectionIsOpen() { - return connectionStage.handle((connection, error) -> error == null - && // no acquisition error - connection != null - && // some connection has actually been acquired - connection.isOpen()); // and it's still open - } - - private CompletionStage buildResultCursorFactory(Query query, TransactionConfig config) { - ensureSessionIsOpen(); - - return ensureNoOpenTxBeforeRunningQuery() - .thenCompose(ignore -> acquireConnection(mode)) - .thenApply(connection -> - ImpersonationUtil.ensureImpersonationSupport(connection, connection.impersonatedUser())) - .thenCompose(connection -> { - try { - var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.AUTO_COMMIT_TRANSACTION); - apiTelemetryWork.setEnabled(!telemetryDisabled); - var telemetryStage = apiTelemetryWork.execute(connection, connection.protocol()); - var factory = connection - .protocol() - .runInAutoCommitTransaction( - connection, - query, - determineBookmarks(true), - this::handleNewBookmark, - config, - fetchSize, - notificationConfig, - logging); - var future = completedFuture(factory); - telemetryStage.whenComplete((unused, throwable) -> { - if (throwable != null) { - future.completeExceptionally(throwable); - } - }); - return future; - } catch (Throwable e) { - return Futures.failedFuture(e); - } - }); + // protected CompletionStage currentConnectionIsOpen() { + // return connectionStage.handle((connection, error) -> error == null + // && // no acquisition error + // connection != null + // && // some connection has actually been acquired + // connection.isOpen()); // and it's still open + // } + + private org.neo4j.driver.internal.bolt.api.AccessMode asBoltAccessMode(AccessMode mode) { + return switch (mode) { + case WRITE -> org.neo4j.driver.internal.bolt.api.AccessMode.WRITE; + case READ -> org.neo4j.driver.internal.bolt.api.AccessMode.READ; + }; } - private CompletionStage acquireConnection(AccessMode mode) { + private CompletionStage acquireConnection(AccessMode mode) { var currentConnectionStage = connectionStage; var newConnectionStage = resultCursorStage @@ -328,11 +517,80 @@ private CompletionStage acquireConnection(AccessMode mode) { } }) .thenCompose(existingConnection -> { - if (existingConnection != null && existingConnection.isOpen()) { - // there somehow is an existing open connection, this should not happen, just a precondition - throw new IllegalStateException("Existing open connection detected"); + // if (existingConnection != null && existingConnection.isOpen()) { + // // there somehow is an existing open connection, this should not happen, + // just a precondition + // throw new IllegalStateException("Existing open connection detected"); + // } + var databaseName = connectionContext.databaseNameFuture.getNow(null); + + Supplier>> tokenStageSupplier; + BoltProtocolVersion minVersion = null; + if (connectionContext.impersonatedUser() != null) { + minVersion = new BoltProtocolVersion(4, 4); + } + var overrideAuthToken = connectionContext.overrideAuthToken(); + if (overrideAuthToken != null) { + tokenStageSupplier = () -> CompletableFuture.completedStage(connectionContext.authToken) + .thenApply(token -> ((InternalAuthToken) token).toMap()); + minVersion = new BoltProtocolVersion(5, 1); + } else { + tokenStageSupplier = () -> + authTokenManager.getToken().thenApply(token -> ((InternalAuthToken) token).toMap()); } - return connectionProvider.acquireConnection(connectionContext.contextWithMode(mode)); + return boltConnectionProvider + .connect( + databaseName, + tokenStageSupplier, + switch (mode) { + case WRITE -> org.neo4j.driver.internal.bolt.api.AccessMode.WRITE; + case READ -> org.neo4j.driver.internal.bolt.api.AccessMode.READ; + }, + connectionContext.rediscoveryBookmarks().stream() + .map(Bookmark::value) + .collect(Collectors.toSet()), + connectionContext.impersonatedUser(), + minVersion, + driverNotificationConfig, + (name) -> connectionContext + .databaseNameFuture() + .complete(name == null ? DatabaseNameUtil.defaultDatabase() : name)) + .thenApply(connection -> (BoltConnection) new BoltConnectionWithAuthTokenManager( + connection, + overrideAuthToken != null + ? new AuthTokenManager() { + @Override + public CompletionStage getToken() { + return null; + } + + @Override + public boolean handleSecurityException( + AuthToken authToken, SecurityException exception) { + return false; + } + } + : authTokenManager)) + .exceptionally(throwable -> { + throwable = Futures.completionExceptionCause(throwable); + if (throwable instanceof TimeoutException) { + throw new ClientException(throwable.getMessage(), throwable); + } + if (throwable + instanceof MinVersionAcquisitionException minVersionAcquisitionException) { + if (overrideAuthToken == null && connectionContext.impersonatedUser() != null) { + throw new ClientException( + "Detected connection that does not support impersonation, please make sure to have all servers running 4.4 version or above and communicating" + + " over Bolt version 4.4 or above when using impersonation feature"); + } else { + throw new CompletionException(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", + minVersionAcquisitionException.version()))); + } + } else { + throw new CompletionException(throwable); + } + }); }); connectionStage = newConnectionStage.exceptionally(error -> null); diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/TerminationAwareBoltConnection.java b/driver/src/main/java/org/neo4j/driver/internal/async/TerminationAwareBoltConnection.java new file mode 100644 index 0000000000..e754a42585 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/async/TerminationAwareBoltConnection.java @@ -0,0 +1,221 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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; + +import java.time.Duration; +import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import org.neo4j.driver.Value; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.AuthData; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltConnectionState; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.ResponseHandler; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; +import org.neo4j.driver.internal.bolt.api.TransactionType; + +public class TerminationAwareBoltConnection implements BoltConnection { + private final BoltConnection delegate; + private final TerminationAwareStateLockingExecutor executor; + + public TerminationAwareBoltConnection(BoltConnection delegate, TerminationAwareStateLockingExecutor executor) { + this.delegate = Objects.requireNonNull(delegate); + this.executor = Objects.requireNonNull(executor); + } + + public CompletionStage clearAndReset() { + var future = new CompletableFuture(); + var thisVal = this; + delegate.clear() + .thenCompose(BoltConnection::reset) + .thenCompose(connection -> connection.flush(new ResponseHandler() { + @Override + public void onError(Throwable throwable) { + future.completeExceptionally(throwable); + } + + @Override + public void onComplete() { + future.complete(thisVal); + } + })) + .whenComplete((result, throwable) -> { + if (throwable != null) { + future.completeExceptionally(throwable); + } + }); + return future; + } + + @Override + public boolean telemetrySupported() { + return delegate.telemetrySupported(); + } + + @Override + public BoltProtocolVersion protocolVersion() { + return delegate.protocolVersion(); + } + + @Override + public BoltServerAddress serverAddress() { + return delegate.serverAddress(); + } + + @Override + public String serverAgent() { + return delegate.serverAgent(); + } + + @Override + public CompletionStage authData() { + return delegate.authData(); + } + + @Override + public BoltConnectionState state() { + return delegate.state(); + } + + @Override + public CompletionStage close() { + return delegate.close(); + } + + @Override + public CompletionStage forceClose(String reason) { + return delegate.forceClose(reason); + } + + @Override + public CompletionStage flush(ResponseHandler handler) { + return executor.execute(causeOfTermination -> { + if (causeOfTermination == null) { + return delegate.flush(handler); + } else { + return CompletableFuture.failedStage(causeOfTermination); + } + }); + } + + @Override + public CompletionStage telemetry(TelemetryApi telemetryApi) { + return delegate.telemetry(telemetryApi); + } + + @Override + public CompletionStage clear() { + return delegate.clear(); + } + + @Override + public CompletionStage logon(Map authMap) { + return delegate.logon(authMap); + } + + @Override + public CompletionStage logoff() { + return delegate.logoff(); + } + + @Override + public CompletionStage reset() { + return delegate.reset(); + } + + @Override + public CompletionStage rollback() { + return delegate.rollback(); + } + + @Override + public CompletionStage commit() { + return delegate.commit(); + } + + @Override + public CompletionStage discard(long qid, long number) { + return delegate.discard(qid, number); + } + + @Override + public CompletionStage pull(long qid, long request) { + return delegate.pull(qid, request); + } + + @Override + public CompletionStage run(String query, Map parameters) { + return delegate.run(query, parameters); + } + + @Override + public CompletionStage runInAutoCommitTransaction( + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, + Set bookmarks, + String query, + Map parameters, + Duration txTimeout, + Map txMetadata, + NotificationConfig notificationConfig) { + return delegate.runInAutoCommitTransaction( + databaseName, + accessMode, + impersonatedUser, + bookmarks, + query, + parameters, + txTimeout, + txMetadata, + notificationConfig); + } + + @Override + public CompletionStage beginTransaction( + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, + Set bookmarks, + TransactionType transactionType, + Duration txTimeout, + Map txMetadata, + NotificationConfig notificationConfig) { + return delegate.beginTransaction( + databaseName, + accessMode, + impersonatedUser, + bookmarks, + transactionType, + txTimeout, + txMetadata, + notificationConfig); + } + + @Override + public CompletionStage route( + DatabaseName databaseName, String impersonatedUser, Set bookmarks) { + return delegate.route(databaseName, impersonatedUser, bookmarks); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/TerminationAwareStateLockingExecutor.java b/driver/src/main/java/org/neo4j/driver/internal/async/TerminationAwareStateLockingExecutor.java index b91c014243..ae8a4c2f2d 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/TerminationAwareStateLockingExecutor.java +++ b/driver/src/main/java/org/neo4j/driver/internal/async/TerminationAwareStateLockingExecutor.java @@ -17,6 +17,7 @@ package org.neo4j.driver.internal.async; import java.util.function.Consumer; +import java.util.function.Function; @FunctionalInterface public interface TerminationAwareStateLockingExecutor { @@ -25,5 +26,5 @@ public interface TerminationAwareStateLockingExecutor { * * @param causeOfTerminationConsumer the consumer accepting */ - void execute(Consumer causeOfTerminationConsumer); + T execute(Function causeOfTerminationConsumer); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/UnmanagedTransaction.java b/driver/src/main/java/org/neo4j/driver/internal/async/UnmanagedTransaction.java index 5b58e37722..f75da06a98 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/UnmanagedTransaction.java +++ b/driver/src/main/java/org/neo4j/driver/internal/async/UnmanagedTransaction.java @@ -17,15 +17,15 @@ package org.neo4j.driver.internal.async; import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.neo4j.driver.internal.util.Futures.asCompletionException; import static org.neo4j.driver.internal.util.Futures.combineErrors; import static org.neo4j.driver.internal.util.Futures.completedWithNull; -import static org.neo4j.driver.internal.util.Futures.failedFuture; import static org.neo4j.driver.internal.util.Futures.futureCompletingConsumer; import static org.neo4j.driver.internal.util.LockUtil.executeWithLock; +import java.util.ArrayList; import java.util.Arrays; import java.util.EnumSet; +import java.util.List; import java.util.Set; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionStage; @@ -34,22 +34,39 @@ import java.util.function.BiFunction; import java.util.function.Consumer; import java.util.function.Function; +import java.util.stream.Collectors; import org.neo4j.driver.Bookmark; import org.neo4j.driver.Logging; -import org.neo4j.driver.NotificationConfig; import org.neo4j.driver.Query; +import org.neo4j.driver.Record; import org.neo4j.driver.TransactionConfig; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; import org.neo4j.driver.async.ResultCursor; -import org.neo4j.driver.exceptions.AuthorizationExpiredException; import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.exceptions.ConnectionReadTimeoutException; import org.neo4j.driver.exceptions.TransactionTerminatedException; import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.cursor.AsyncResultCursor; +import org.neo4j.driver.internal.InternalRecord; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.ResponseHandler; +import org.neo4j.driver.internal.bolt.api.TransactionType; +import org.neo4j.driver.internal.bolt.api.summary.BeginSummary; +import org.neo4j.driver.internal.bolt.api.summary.CommitSummary; +import org.neo4j.driver.internal.bolt.api.summary.DiscardSummary; +import org.neo4j.driver.internal.bolt.api.summary.PullSummary; +import org.neo4j.driver.internal.bolt.api.summary.RollbackSummary; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.api.summary.TelemetrySummary; +import org.neo4j.driver.internal.cursor.DisposableResultCursorImpl; +import org.neo4j.driver.internal.cursor.ResultCursorImpl; import org.neo4j.driver.internal.cursor.RxResultCursor; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.spi.Connection; +import org.neo4j.driver.internal.cursor.RxResultCursorImpl; import org.neo4j.driver.internal.telemetry.ApiTelemetryWork; +import org.neo4j.driver.internal.util.ErrorUtil; +import org.neo4j.driver.internal.util.Futures; public class UnmanagedTransaction implements TerminationAwareStateLockingExecutor { private enum State { @@ -86,8 +103,7 @@ private enum State { "Can't rollback, transaction has been requested to be committed"; private static final EnumSet OPEN_STATES = EnumSet.of(State.ACTIVE, State.TERMINATED); - private final Connection connection; - private final BoltProtocol protocol; + private final TerminationAwareBoltConnection connection; private final Consumer bookmarkConsumer; private final ResultCursorsHolder resultCursors; private final long fetchSize; @@ -99,12 +115,18 @@ private enum State { private CompletionStage terminationStage; private final NotificationConfig notificationConfig; private final CompletableFuture beginFuture = new CompletableFuture<>(); + private final DatabaseName databaseName; + private final AccessMode accessMode; + private final String impersonatedUser; private final Logging logging; private final ApiTelemetryWork apiTelemetryWork; public UnmanagedTransaction( - Connection connection, + BoltConnection connection, + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, Consumer bookmarkConsumer, long fetchSize, NotificationConfig notificationConfig, @@ -112,6 +134,9 @@ public UnmanagedTransaction( Logging logging) { this( connection, + databaseName, + accessMode, + impersonatedUser, bookmarkConsumer, fetchSize, new ResultCursorsHolder(), @@ -121,51 +146,89 @@ public UnmanagedTransaction( } protected UnmanagedTransaction( - Connection connection, + BoltConnection connection, + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, Consumer bookmarkConsumer, long fetchSize, ResultCursorsHolder resultCursors, NotificationConfig notificationConfig, ApiTelemetryWork apiTelemetryWork, Logging logging) { - this.connection = connection; - this.protocol = connection.protocol(); + this.connection = new TerminationAwareBoltConnection(connection, this); + this.databaseName = databaseName; + this.accessMode = accessMode; + this.impersonatedUser = impersonatedUser; this.bookmarkConsumer = bookmarkConsumer; this.resultCursors = resultCursors; this.fetchSize = fetchSize; this.notificationConfig = notificationConfig; this.logging = logging; this.apiTelemetryWork = apiTelemetryWork; - - connection.bindTerminationAwareStateLockingExecutor(this); } // flush = false is only supported for async mode with a single subsequent run public CompletionStage beginAsync( Set initialBookmarks, TransactionConfig config, String txType, boolean flush) { - apiTelemetryWork.execute(connection, protocol).whenComplete((unused, throwable) -> { - if (throwable != null) { - beginFuture.completeExceptionally(throwable); - } - }); - - protocol.beginTransaction(connection, initialBookmarks, config, txType, notificationConfig, logging, flush) - .handle((ignore, beginError) -> { - if (beginError != null) { - if (beginError instanceof AuthorizationExpiredException) { - connection.terminateAndRelease(AuthorizationExpiredException.DESCRIPTION); - } else if (beginError instanceof ConnectionReadTimeoutException) { - connection.terminateAndRelease(beginError.getMessage()); - } else { - connection.release(); - } - throw asCompletionException(beginError); + var bookmarks = initialBookmarks.stream().map(Bookmark::value).collect(Collectors.toSet()); + + return apiTelemetryWork + .pipelineTelemetryIfEnabled(connection) + .thenCompose(connection -> connection.beginTransaction( + databaseName, + accessMode, + impersonatedUser, + bookmarks, + TransactionType.DEFAULT, + config.timeout(), + config.metadata(), + notificationConfig)) + .thenCompose(connection -> { + if (flush) { + connection + .flush(new ResponseHandler() { + private Throwable error; + + @Override + public void onError(Throwable throwable) { + if (error == null) { + error = throwable; + connection.close().whenComplete((ignored, closeThrowable) -> { + if (closeThrowable != null) { + throwable.addSuppressed(closeThrowable); + } + beginFuture.completeExceptionally(throwable); + }); + } + } + + @Override + public void onTelemetrySummary(TelemetrySummary summary) { + apiTelemetryWork.acknowledge(); + } + + @Override + public void onBeginSummary(BeginSummary summary) { + beginFuture.complete(null); + } + }) + .whenComplete((ignored, throwable) -> { + if (throwable != null) { + connection.close().whenComplete((closeResult, closeThrowable) -> { + if (closeThrowable != null) { + throwable.addSuppressed(closeThrowable); + } + beginFuture.completeExceptionally(throwable); + }); + } + }); + return beginFuture.thenApply(ignored -> this); + } else { + return CompletableFuture.completedFuture(this); } - return this; - }) - .whenComplete(futureCompletingConsumer(beginFuture)); - return flush ? beginFuture : CompletableFuture.completedFuture(this); + }); } public CompletionStage closeAsync() { @@ -186,20 +249,157 @@ public CompletionStage rollbackAsync() { public CompletionStage runAsync(Query query) { ensureCanRunQueries(); - var cursorStage = protocol.runInUnmanagedTransaction(connection, query, this, fetchSize) - .asyncResult(); - resultCursors.add(cursorStage); - return beginFuture.thenCompose(ignored -> cursorStage - .thenCompose(AsyncResultCursor::mapSuccessfulRunCompletionAsync) - .thenApply(Function.identity())); + var cursorFuture = new CompletableFuture(); + var parameters = query.parameters().asMap(Values::value); + var transaction = this; + var st = connection + .run(query.text(), parameters) + .thenCompose(ignored2 -> connection.pull(-1, fetchSize)) + .thenCompose(ignored2 -> connection.flush(new ResponseHandler() { + private RunSummary runSummary; + private final List records = new ArrayList<>(); + private PullSummary pullSummary; + private DiscardSummary discardSummary; + private Throwable error; + + @Override + public void onError(Throwable throwable) { + if (error == null) { + error = throwable; + } else { + error.addSuppressed(throwable); + } + } + + @Override + public void onTelemetrySummary(TelemetrySummary summary) { + apiTelemetryWork.acknowledge(); + } + + @Override + public void onRunSummary(RunSummary summary) { + runSummary = summary; + } + + @Override + public void onRecord(Value[] fields) { + records.add(new InternalRecord(runSummary.keys(), fields)); + } + + @Override + public void onPullSummary(PullSummary summary) { + pullSummary = summary; + } + + @Override + public void onDiscardSummary(DiscardSummary summary) { + discardSummary = summary; + } + + @Override + public void onComplete() { + Throwable cursorError = null; + if (error != null) { + error = Futures.completionExceptionCause(error); + if (error instanceof IllegalStateException) { + error = ErrorUtil.newConnectionTerminatedError(); + } + //noinspection ThrowableNotThrown + markTerminated(error); + if (beginFuture.completeExceptionally(error)) { + return; + } else { + if (runSummary != null) { + cursorError = error; + } else { + cursorFuture.completeExceptionally(error); + } + } + } + beginFuture.complete(transaction); + if (runSummary != null) { + cursorFuture.complete(new DisposableResultCursorImpl(new ResultCursorImpl( + connection, + query, + fetchSize, + transaction::markTerminated, + (bookmark) -> {}, + false, + runSummary, + () -> executeWithLock(lock, () -> causeOfTermination), + records, + pullSummary, + discardSummary, + cursorError))); + } + } + })); + + return beginFuture.thenCompose(ignored -> { + var cursorStage = st.thenCompose(flushResult -> cursorFuture); + resultCursors.add(cursorStage); + return cursorStage.thenApply(Function.identity()); + }); } public CompletionStage runRx(Query query) { ensureCanRunQueries(); - var cursorStage = protocol.runInUnmanagedTransaction(connection, query, this, fetchSize) - .rxResult(); - resultCursors.add(cursorStage); - return cursorStage; + var cursorFuture = new CompletableFuture(); + var parameters = query.parameters().asMap(Values::value); + var transaction = this; + var st = connection + .run(query.text(), parameters) + .thenCompose(ignored2 -> connection.flush(new ResponseHandler() { + @Override + public void onError(Throwable throwable) { + throwable = Futures.completionExceptionCause(throwable); + if (throwable instanceof IllegalStateException) { + throwable = ErrorUtil.newConnectionTerminatedError(); + } + if (beginFuture.completeExceptionally(throwable)) { + //noinspection ThrowableNotThrown + markTerminated(throwable); + } else { + //noinspection ThrowableNotThrown + markTerminated(throwable); + cursorFuture.complete(new RxResultCursorImpl( + connection, + query, + null, + throwable, + () -> executeWithLock(lock, () -> causeOfTermination), + bookmark -> {}, + transaction::markTerminated, + false, + () -> executeWithLock(lock, () -> causeOfTermination))); + } + } + + @Override + public void onTelemetrySummary(TelemetrySummary summary) { + apiTelemetryWork.acknowledge(); + } + + @Override + public void onRunSummary(RunSummary summary) { + cursorFuture.complete(new RxResultCursorImpl( + connection, + query, + summary, + null, + () -> executeWithLock(lock, () -> causeOfTermination), + bookmark -> {}, + transaction::markTerminated, + false, + () -> executeWithLock(lock, () -> causeOfTermination))); + } + })); + + return beginFuture.thenCompose(ignored -> { + var cursorStage = st.thenCompose(flushResult -> cursorFuture); + resultCursors.add(cursorStage); + return cursorStage.thenApply(Function.identity()); + }); } public boolean isOpen() { @@ -221,6 +421,10 @@ public Throwable markTerminated(Throwable cause) { }); } + public BoltConnection connection() { + return connection; + } + private void addSuppressedWhenNotCaptured(Throwable currentCause, Throwable newCause) { if (currentCause != newCause) { var noneMatch = Arrays.stream(currentCause.getSuppressed()).noneMatch(suppressed -> suppressed == newCause); @@ -230,31 +434,29 @@ private void addSuppressedWhenNotCaptured(Throwable currentCause, Throwable newC } } - public Connection connection() { - return connection; - } - - @Override - public void execute(Consumer causeOfTerminationConsumer) { - executeWithLock(lock, () -> causeOfTerminationConsumer.accept(causeOfTermination)); - } - + @SuppressWarnings("ThrowableNotThrown") public CompletionStage terminateAsync() { return executeWithLock(lock, () -> { if (!isOpen() || commitFuture != null || rollbackFuture != null) { - return failedFuture(new ClientException("Can't terminate closed or closing transaction")); + return CompletableFuture.failedFuture( + new ClientException("Can't terminate closed or closing transaction")); } else { if (state == State.TERMINATED) { return terminationStage != null ? terminationStage : completedFuture(null); } else { - var terminationException = markTerminated(null); - terminationStage = connection.reset(terminationException); + markTerminated(null); + terminationStage = connection.clearAndReset().thenApply(ignored -> null); return terminationStage; } } }); } + @Override + public T execute(Function causeOfTerminationConsumer) { + return executeWithLock(lock, () -> causeOfTerminationConsumer.apply(causeOfTermination)); + } + private void ensureCanRunQueries() { executeWithLock(lock, () -> { if (state == State.COMMITTED) { @@ -287,19 +489,69 @@ private CompletionStage doCommitAsync(Throwable cursorFailure) { + "It has been rolled back either because of an error or explicit termination", cursorFailure != causeOfTermination ? causeOfTermination : null) : null); - return exception != null - ? failedFuture(exception) - : protocol.commitTransaction(connection).thenAccept(bookmarkConsumer); + + if (exception != null) { + return CompletableFuture.failedFuture(exception); + } else { + var commitSummary = new CompletableFuture(); + connection + .commit() + .thenCompose(connection -> connection.flush(new ResponseHandler() { + @Override + public void onError(Throwable throwable) { + commitSummary.completeExceptionally(throwable); + } + + @Override + public void onCommitSummary(CommitSummary summary) { + summary.bookmark() + .map(bookmark -> new DatabaseBookmark(null, Bookmark.from(bookmark))) + .ifPresent(bookmarkConsumer); + commitSummary.complete(summary); + } + })) + .exceptionally(throwable -> { + commitSummary.completeExceptionally(throwable); + return null; + }); + // todo bookmarkConsumer.accept(summary.getBookmark()) + return commitSummary.thenApply(summary -> null); + } } private CompletionStage doRollbackAsync() { - return executeWithLock(lock, () -> state) == State.TERMINATED - ? completedWithNull() - : protocol.rollbackTransaction(connection); + if (executeWithLock(lock, () -> state) == State.TERMINATED) { + return completedWithNull(); + } else { + var rollbackFuture = new CompletableFuture(); + connection + .rollback() + .thenCompose(connection -> connection.flush(new ResponseHandler() { + @Override + public void onError(Throwable throwable) { + rollbackFuture.completeExceptionally(throwable); + } + + @Override + public void onRollbackSummary(RollbackSummary summary) { + rollbackFuture.complete(null); + } + })) + .exceptionally(throwable -> { + rollbackFuture.completeExceptionally(throwable); + return null; + }); + + return rollbackFuture; + } } private static BiFunction handleCommitOrRollback(Throwable cursorFailure) { return (ignore, commitOrRollbackError) -> { + commitOrRollbackError = Futures.completionExceptionCause(commitOrRollbackError); + if (commitOrRollbackError instanceof IllegalStateException) { + commitOrRollbackError = ErrorUtil.newConnectionTerminatedError(); + } var combinedError = combineErrors(cursorFailure, commitOrRollbackError); if (combinedError != null) { throw combinedError; @@ -308,7 +560,7 @@ private static BiFunction handleCommitOrRollback(Throwabl }; } - private void handleTransactionCompletion(boolean commitAttempt, Throwable throwable) { + private CompletionStage handleTransactionCompletion(boolean commitAttempt, Throwable throwable) { executeWithLock(lock, () -> { if (commitAttempt && throwable == null) { state = State.COMMITTED; @@ -316,13 +568,12 @@ private void handleTransactionCompletion(boolean commitAttempt, Throwable throwa state = State.ROLLED_BACK; } }); - if (throwable instanceof AuthorizationExpiredException) { - connection.terminateAndRelease(AuthorizationExpiredException.DESCRIPTION); - } else if (throwable instanceof ConnectionReadTimeoutException) { - connection.terminateAndRelease(throwable.getMessage()); - } else { - connection.release(); // release in background - } + return connection + .close() + .exceptionally(th -> null) + .thenCompose(ignored -> throwable != null + ? CompletableFuture.failedStage(throwable) + : CompletableFuture.completedStage(null)); } private CompletionStage closeAsync(boolean commit, boolean completeWithNullIfNotOpen) { @@ -331,15 +582,15 @@ private CompletionStage closeAsync(boolean commit, boolean completeWithNul if (completeWithNullIfNotOpen && !isOpen()) { resultStage = completedWithNull(); } else if (state == State.COMMITTED) { - resultStage = failedFuture( + resultStage = CompletableFuture.failedFuture( new ClientException(commit ? CANT_COMMIT_COMMITTED_MSG : CANT_ROLLBACK_COMMITTED_MSG)); } else if (state == State.ROLLED_BACK) { - resultStage = failedFuture( + resultStage = CompletableFuture.failedFuture( new ClientException(commit ? CANT_COMMIT_ROLLED_BACK_MSG : CANT_ROLLBACK_ROLLED_BACK_MSG)); } else { if (commit) { if (rollbackFuture != null) { - resultStage = failedFuture(new ClientException(CANT_COMMIT_ROLLING_BACK_MSG)); + resultStage = CompletableFuture.failedFuture(new ClientException(CANT_COMMIT_ROLLING_BACK_MSG)); } else if (commitFuture != null) { resultStage = commitFuture; } else { @@ -347,7 +598,7 @@ private CompletionStage closeAsync(boolean commit, boolean completeWithNul } } else { if (commitFuture != null) { - resultStage = failedFuture(new ClientException(CANT_ROLLBACK_COMMITTING_MSG)); + resultStage = CompletableFuture.failedFuture(new ClientException(CANT_ROLLBACK_COMMITTING_MSG)); } else if (rollbackFuture != null) { resultStage = rollbackFuture; } else { @@ -371,7 +622,8 @@ private CompletionStage closeAsync(boolean commit, boolean completeWithNul resultCursors .retrieveNotConsumedError() .thenCompose(targetAction) - .whenComplete((ignored, throwable) -> handleTransactionCompletion(commit, throwable)) + .handle((ignored, throwable) -> handleTransactionCompletion(commit, throwable)) + .thenCompose(Function.identity()) .whenComplete(futureCompletingConsumer(targetFuture)); stage = targetFuture; } 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 deleted file mode 100644 index 788c711de7..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelConnectorImpl.java +++ /dev/null @@ -1,152 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.connection; - -import static java.util.Objects.requireNonNull; - -import io.netty.bootstrap.Bootstrap; -import io.netty.channel.ChannelFuture; -import io.netty.channel.ChannelOption; -import io.netty.channel.ChannelPromise; -import io.netty.resolver.AddressResolverGroup; -import java.net.InetSocketAddress; -import java.net.SocketAddress; -import java.time.Clock; -import org.neo4j.driver.AuthTokenManager; -import org.neo4j.driver.Logging; -import org.neo4j.driver.NotificationConfig; -import org.neo4j.driver.internal.BoltAgent; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.ConnectionSettings; -import org.neo4j.driver.internal.DomainNameResolver; -import org.neo4j.driver.internal.async.inbound.ConnectTimeoutHandler; -import org.neo4j.driver.internal.cluster.RoutingContext; -import org.neo4j.driver.internal.security.SecurityPlan; - -public class ChannelConnectorImpl implements ChannelConnector { - private final String userAgent; - private final BoltAgent boltAgent; - private final AuthTokenManager authTokenManager; - private final RoutingContext routingContext; - private final SecurityPlan securityPlan; - private final ChannelPipelineBuilder pipelineBuilder; - private final int connectTimeoutMillis; - private final Logging logging; - private final Clock clock; - private final DomainNameResolver domainNameResolver; - private final AddressResolverGroup addressResolverGroup; - private final NotificationConfig notificationConfig; - - public ChannelConnectorImpl( - ConnectionSettings connectionSettings, - SecurityPlan securityPlan, - Logging logging, - Clock clock, - RoutingContext routingContext, - DomainNameResolver domainNameResolver, - NotificationConfig notificationConfig, - BoltAgent boltAgent) { - this( - connectionSettings, - securityPlan, - new ChannelPipelineBuilderImpl(), - logging, - clock, - routingContext, - domainNameResolver, - notificationConfig, - boltAgent); - } - - public ChannelConnectorImpl( - ConnectionSettings connectionSettings, - SecurityPlan securityPlan, - ChannelPipelineBuilder pipelineBuilder, - Logging logging, - Clock clock, - RoutingContext routingContext, - DomainNameResolver domainNameResolver, - NotificationConfig notificationConfig, - BoltAgent boltAgent) { - this.userAgent = connectionSettings.userAgent(); - this.boltAgent = requireNonNull(boltAgent); - this.authTokenManager = connectionSettings.authTokenProvider(); - this.routingContext = routingContext; - this.connectTimeoutMillis = connectionSettings.connectTimeoutMillis(); - this.securityPlan = requireNonNull(securityPlan); - this.pipelineBuilder = pipelineBuilder; - this.logging = requireNonNull(logging); - this.clock = requireNonNull(clock); - this.domainNameResolver = requireNonNull(domainNameResolver); - this.addressResolverGroup = new NettyDomainNameResolverGroup(this.domainNameResolver); - this.notificationConfig = notificationConfig; - } - - @Override - public ChannelFuture connect(BoltServerAddress address, Bootstrap bootstrap) { - bootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, connectTimeoutMillis); - bootstrap.handler(new NettyChannelInitializer( - address, securityPlan, connectTimeoutMillis, authTokenManager, clock, logging)); - bootstrap.resolver(addressResolverGroup); - - SocketAddress socketAddress; - try { - socketAddress = - new InetSocketAddress(domainNameResolver.resolve(address.connectionHost())[0], address.port()); - } catch (Throwable t) { - socketAddress = InetSocketAddress.createUnresolved(address.connectionHost(), address.port()); - } - - var channelConnected = bootstrap.connect(socketAddress); - - var channel = channelConnected.channel(); - var handshakeCompleted = channel.newPromise(); - var connectionInitialized = channel.newPromise(); - - installChannelConnectedListeners(address, channelConnected, handshakeCompleted); - installHandshakeCompletedListeners(handshakeCompleted, connectionInitialized); - - return connectionInitialized; - } - - private void installChannelConnectedListeners( - BoltServerAddress address, ChannelFuture channelConnected, ChannelPromise handshakeCompleted) { - var pipeline = channelConnected.channel().pipeline(); - - // add timeout handler to the pipeline when channel is connected. it's needed to limit amount of time code - // spends in TLS and Bolt handshakes. prevents infinite waiting when database does not respond - channelConnected.addListener(future -> pipeline.addFirst(new ConnectTimeoutHandler(connectTimeoutMillis))); - - // add listener that sends Bolt handshake bytes when channel is connected - channelConnected.addListener( - new ChannelConnectedListener(address, pipelineBuilder, handshakeCompleted, logging)); - } - - private void installHandshakeCompletedListeners( - ChannelPromise handshakeCompleted, ChannelPromise connectionInitialized) { - var pipeline = handshakeCompleted.channel().pipeline(); - - // remove timeout handler from the pipeline once TLS and Bolt handshakes are completed. regular protocol - // messages will flow next and we do not want to have read timeout for them - handshakeCompleted.addListener(future -> pipeline.remove(ConnectTimeoutHandler.class)); - - // 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, boltAgent, routingContext, connectionInitialized, notificationConfig, clock)); - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/DirectConnection.java b/driver/src/main/java/org/neo4j/driver/internal/async/connection/DirectConnection.java deleted file mode 100644 index c151420811..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/DirectConnection.java +++ /dev/null @@ -1,129 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.connection; - -import java.util.concurrent.CompletionStage; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.DirectConnectionProvider; -import org.neo4j.driver.internal.async.TerminationAwareStateLockingExecutor; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; - -/** - * This is a connection used by {@link DirectConnectionProvider} to connect to a remote database. - */ -public class DirectConnection implements Connection { - private final Connection delegate; - private final AccessMode mode; - private final DatabaseName databaseName; - private final String impersonatedUser; - - public DirectConnection(Connection delegate, DatabaseName databaseName, AccessMode mode, String impersonatedUser) { - this.delegate = delegate; - this.mode = mode; - this.databaseName = databaseName; - this.impersonatedUser = impersonatedUser; - } - - public Connection connection() { - return delegate; - } - - @Override - public boolean isOpen() { - return delegate.isOpen(); - } - - @Override - public void enableAutoRead() { - delegate.enableAutoRead(); - } - - @Override - public void disableAutoRead() { - delegate.disableAutoRead(); - } - - @Override - public boolean isTelemetryEnabled() { - return delegate.isTelemetryEnabled(); - } - - @Override - public void write(Message message, ResponseHandler handler) { - delegate.write(message, handler); - } - - @Override - public void writeAndFlush(Message message, ResponseHandler handler) { - delegate.writeAndFlush(message, handler); - } - - @Override - public CompletionStage reset(Throwable throwable) { - return delegate.reset(throwable); - } - - @Override - public CompletionStage release() { - return delegate.release(); - } - - @Override - public void terminateAndRelease(String reason) { - delegate.terminateAndRelease(reason); - } - - @Override - public String serverAgent() { - return delegate.serverAgent(); - } - - @Override - public BoltServerAddress serverAddress() { - return delegate.serverAddress(); - } - - @Override - public BoltProtocol protocol() { - return delegate.protocol(); - } - - @Override - public void bindTerminationAwareStateLockingExecutor(TerminationAwareStateLockingExecutor executor) { - delegate.bindTerminationAwareStateLockingExecutor(executor); - } - - @Override - public AccessMode mode() { - return mode; - } - - @Override - public DatabaseName databaseName() { - return this.databaseName; - } - - @Override - public String impersonatedUser() { - return impersonatedUser; - } -} 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 deleted file mode 100644 index b848b54c09..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/HandshakeCompletedListener.java +++ /dev/null @@ -1,99 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.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 java.time.Clock; -import org.neo4j.driver.NotificationConfig; -import org.neo4j.driver.internal.BoltAgent; -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 BoltAgent boltAgent; - private final RoutingContext routingContext; - private final ChannelPromise connectionInitializedPromise; - private final NotificationConfig notificationConfig; - private final Clock clock; - - public HandshakeCompletedListener( - String userAgent, - BoltAgent boltAgent, - RoutingContext routingContext, - ChannelPromise connectionInitializedPromise, - NotificationConfig notificationConfig, - Clock clock) { - requireNonNull(clock, "clock must not be null"); - this.userAgent = requireNonNull(userAgent); - this.boltAgent = requireNonNull(boltAgent); - this.routingContext = routingContext; - this.connectionInitializedPromise = requireNonNull(connectionInitializedPromise); - this.notificationConfig = notificationConfig; - this.clock = clock; - } - - @Override - public void operationComplete(ChannelFuture future) { - if (future.isSuccess()) { - var protocol = BoltProtocol.forChannel(future.channel()); - // 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, - boltAgent, - authToken, - routingContext, - connectionInitializedPromise, - notificationConfig, - clock); - } - }, - channel.eventLoop()); - } else { - protocol.initializeChannel( - userAgent, - boltAgent, - null, - routingContext, - connectionInitializedPromise, - notificationConfig, - clock); - } - } else { - connectionInitializedPromise.setFailure(future.cause()); - } - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/RoutingConnection.java b/driver/src/main/java/org/neo4j/driver/internal/async/connection/RoutingConnection.java deleted file mode 100644 index c8e74dcd28..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/RoutingConnection.java +++ /dev/null @@ -1,137 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.connection; - -import java.util.concurrent.CompletionStage; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.RoutingErrorHandler; -import org.neo4j.driver.internal.async.TerminationAwareStateLockingExecutor; -import org.neo4j.driver.internal.handlers.RoutingResponseHandler; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; - -/** - * A connection used by the routing driver. - */ -public class RoutingConnection implements Connection { - private final Connection delegate; - private final AccessMode accessMode; - private final RoutingErrorHandler errorHandler; - private final DatabaseName databaseName; - private final String impersonatedUser; - - public RoutingConnection( - Connection delegate, - DatabaseName databaseName, - AccessMode accessMode, - String impersonatedUser, - RoutingErrorHandler errorHandler) { - this.delegate = delegate; - this.databaseName = databaseName; - this.accessMode = accessMode; - this.impersonatedUser = impersonatedUser; - this.errorHandler = errorHandler; - } - - @Override - public void enableAutoRead() { - delegate.enableAutoRead(); - } - - @Override - public void disableAutoRead() { - delegate.disableAutoRead(); - } - - @Override - public void write(Message message, ResponseHandler handler) { - delegate.write(message, newRoutingResponseHandler(handler)); - } - - @Override - public void writeAndFlush(Message message, ResponseHandler handler) { - delegate.writeAndFlush(message, newRoutingResponseHandler(handler)); - } - - @Override - public CompletionStage reset(Throwable throwable) { - return delegate.reset(throwable); - } - - @Override - public boolean isOpen() { - return delegate.isOpen(); - } - - @Override - public CompletionStage release() { - return delegate.release(); - } - - @Override - public void terminateAndRelease(String reason) { - delegate.terminateAndRelease(reason); - } - - @Override - public String serverAgent() { - return delegate.serverAgent(); - } - - @Override - public BoltServerAddress serverAddress() { - return delegate.serverAddress(); - } - - @Override - public BoltProtocol protocol() { - return delegate.protocol(); - } - - @Override - public void bindTerminationAwareStateLockingExecutor(TerminationAwareStateLockingExecutor executor) { - delegate.bindTerminationAwareStateLockingExecutor(executor); - } - - @Override - public AccessMode mode() { - return this.accessMode; - } - - @Override - public DatabaseName databaseName() { - return this.databaseName; - } - - @Override - public String impersonatedUser() { - return impersonatedUser; - } - - @Override - public boolean isTelemetryEnabled() { - return delegate.isTelemetryEnabled(); - } - - private RoutingResponseHandler newRoutingResponseHandler(ResponseHandler handler) { - return new RoutingResponseHandler(handler, serverAddress(), accessMode, errorHandler); - } -} 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 deleted file mode 100644 index d853dc686c..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/async/pool/AuthContext.java +++ /dev/null @@ -1,85 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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 deleted file mode 100644 index f74b01f0cb..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImpl.java +++ /dev/null @@ -1,332 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.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; -import static org.neo4j.driver.internal.util.LockUtil.executeWithLock; -import static org.neo4j.driver.internal.util.LockUtil.executeWithLockAsync; - -import io.netty.bootstrap.Bootstrap; -import io.netty.channel.Channel; -import io.netty.channel.EventLoopGroup; -import java.time.Clock; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionException; -import java.util.concurrent.CompletionStage; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; -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; -import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.async.connection.ChannelConnector; -import org.neo4j.driver.internal.metrics.MetricsListener; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ConnectionPool; -import org.neo4j.driver.internal.util.Futures; -import org.neo4j.driver.net.ServerAddress; - -public class ConnectionPoolImpl implements ConnectionPool { - private final ChannelConnector connector; - private final Bootstrap bootstrap; - private final NettyChannelTracker nettyChannelTracker; - private final Supplier channelHealthCheckerSupplier; - private final PoolSettings settings; - private final Logger log; - private final MetricsListener metricsListener; - private final boolean ownsEventLoopGroup; - - private final ReadWriteLock addressToPoolLock = new ReentrantReadWriteLock(); - private final Map addressToPool = new HashMap<>(); - private final AtomicBoolean closed = new AtomicBoolean(); - private final CompletableFuture closeFuture = new CompletableFuture<>(); - private final ConnectionFactory connectionFactory; - private final Clock clock; - - public ConnectionPoolImpl( - ChannelConnector connector, - Bootstrap bootstrap, - PoolSettings settings, - MetricsListener metricsListener, - Logging logging, - Clock clock, - boolean ownsEventLoopGroup) { - this( - connector, - bootstrap, - new NettyChannelTracker( - metricsListener, bootstrap.config().group().next(), logging), - settings, - metricsListener, - logging, - clock, - ownsEventLoopGroup, - new NetworkConnectionFactory(clock, metricsListener, logging)); - } - - protected ConnectionPoolImpl( - ChannelConnector connector, - Bootstrap bootstrap, - NettyChannelTracker nettyChannelTracker, - 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.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, AuthToken overrideAuthToken) { - log.trace("Acquiring a connection from pool towards %s", address); - - assertNotClosed(); - var pool = getOrCreatePool(address); - - var acquireEvent = metricsListener.createListenerEvent(); - metricsListener.beforeAcquiringOrCreating(pool.id(), acquireEvent); - var channelFuture = pool.acquire(overrideAuthToken); - - return channelFuture.handle((channel, error) -> { - try { - processAcquisitionError(pool, address, error); - assertNotClosed(address, channel, pool); - setAuthorizationStateListener(channel, pool.healthChecker()); - var connection = connectionFactory.createConnection(channel, pool); - - metricsListener.afterAcquiredOrCreated(pool.id(), acquireEvent); - return connection; - } finally { - metricsListener.afterAcquiringOrCreating(pool.id()); - } - }); - } - - @Override - public void retainAll(Set addressesToRetain) { - executeWithLock(addressToPoolLock.writeLock(), () -> { - var entryIterator = addressToPool.entrySet().iterator(); - while (entryIterator.hasNext()) { - var entry = entryIterator.next(); - var address = entry.getKey(); - if (!addressesToRetain.contains(address)) { - var activeChannels = nettyChannelTracker.inUseChannelCount(address); - if (activeChannels == 0) { - // address is not present in updated routing table and has no active connections - // it's now safe to terminate corresponding connection pool and forget about it - var pool = entry.getValue(); - entryIterator.remove(); - if (pool != null) { - log.info( - "Closing connection pool towards %s, it has no active connections " - + "and is not in the routing table registry.", - address); - closePoolInBackground(address, pool); - } - } - } - } - }); - } - - @Override - public int inUseConnections(ServerAddress address) { - return nettyChannelTracker.inUseChannelCount(address); - } - - private int idleConnections(ServerAddress address) { - return nettyChannelTracker.idleChannelCount(address); - } - - @Override - public CompletionStage close() { - if (closed.compareAndSet(false, true)) { - nettyChannelTracker.prepareToCloseChannels(); - - executeWithLockAsync(addressToPoolLock.writeLock(), () -> { - // We can only shutdown event loop group when all netty pools are fully closed, - // otherwise the netty pools might missing threads (from event loop group) to execute clean ups. - return closeAllPools().whenComplete((ignored, pollCloseError) -> { - addressToPool.clear(); - if (!ownsEventLoopGroup) { - completeWithNullIfNoError(closeFuture, pollCloseError); - } else { - shutdownEventLoopGroup(pollCloseError); - } - }); - }); - } - return closeFuture; - } - - @Override - public boolean isOpen(BoltServerAddress address) { - return executeWithLock(addressToPoolLock.readLock(), () -> addressToPool.containsKey(address)); - } - - @Override - public String toString() { - return executeWithLock( - addressToPoolLock.readLock(), () -> "ConnectionPoolImpl{" + "pools=" + addressToPool + '}'); - } - - private void processAcquisitionError(ExtendedChannelPool pool, BoltServerAddress serverAddress, Throwable error) { - var cause = Futures.completionExceptionCause(error); - if (cause != null) { - if (cause instanceof TimeoutException) { - // NettyChannelPool returns future failed with TimeoutException if acquire operation takes more than - // configured time, translate this exception to a prettier one and re-throw - metricsListener.afterTimedOutToAcquireOrCreate(pool.id()); - throw new ClientException( - "Unable to acquire connection from the pool within configured maximum time of " - + settings.connectionAcquisitionTimeout() + "ms"); - } else if (pool.isClosed()) { - // There is a race condition where a thread tries to acquire a connection while the pool is closed by - // another concurrent thread. - // Treat as failed to obtain connection for a direct driver. For a routing driver, this error should be - // retried. - throw new ServiceUnavailableException( - format("Connection pool for server %s is closed while acquiring a connection.", serverAddress), - cause); - } else { - // some unknown error happened during connection acquisition, propagate it - throw new CompletionException(cause); - } - } - } - - private void assertNotClosed() { - if (closed.get()) { - throw new IllegalStateException(CONNECTION_POOL_CLOSED_ERROR_MESSAGE); - } - } - - private void assertNotClosed(BoltServerAddress address, Channel channel, ExtendedChannelPool pool) { - if (closed.get()) { - pool.release(channel); - closePoolInBackground(address, pool); - executeWithLock(addressToPoolLock.writeLock(), () -> addressToPool.remove(address)); - assertNotClosed(); - } - } - - // for testing only - ExtendedChannelPool getPool(BoltServerAddress address) { - return executeWithLock(addressToPoolLock.readLock(), () -> addressToPool.get(address)); - } - - ExtendedChannelPool newPool(BoltServerAddress address) { - return new NettyChannelPool( - address, - connector, - bootstrap, - nettyChannelTracker, - channelHealthCheckerSupplier.get(), - settings.connectionAcquisitionTimeout(), - settings.maxConnectionPoolSize(), - clock); - } - - private ExtendedChannelPool getOrCreatePool(BoltServerAddress address) { - var existingPool = executeWithLock(addressToPoolLock.readLock(), () -> addressToPool.get(address)); - return existingPool != null - ? existingPool - : executeWithLock(addressToPoolLock.writeLock(), () -> { - var pool = addressToPool.get(address); - if (pool == null) { - pool = newPool(address); - // before the connection pool is added I can register the metrics for the pool. - metricsListener.registerPoolMetrics( - pool.id(), - address, - () -> this.inUseConnections(address), - () -> this.idleConnections(address)); - addressToPool.put(address, pool); - } - return pool; - }); - } - - private CompletionStage closePool(ExtendedChannelPool pool) { - return pool.close() - .whenComplete((ignored, error) -> - // after the connection pool is removed/close, I can remove its metrics. - metricsListener.removePoolMetrics(pool.id())); - } - - private void closePoolInBackground(BoltServerAddress address, ExtendedChannelPool pool) { - // Close in the background - closePool(pool).whenComplete((ignored, error) -> { - if (error != null) { - log.warn(format("An error occurred while closing connection pool towards %s.", address), error); - } - }); - } - - private EventLoopGroup eventLoopGroup() { - return bootstrap.config().group(); - } - - private void shutdownEventLoopGroup(Throwable pollCloseError) { - // This is an attempt to speed up the shut down procedure of the driver - // This timeout is needed for `closePoolInBackground` to finish background job, especially for races between - // `acquire` and `close`. - eventLoopGroup().shutdownGracefully(200, 15_000, TimeUnit.MILLISECONDS); - - Futures.asCompletionStage(eventLoopGroup().terminationFuture()) - .whenComplete((ignore, eventLoopGroupTerminationError) -> { - var combinedErrors = combineErrors(pollCloseError, eventLoopGroupTerminationError); - completeWithNullIfNoError(closeFuture, combinedErrors); - }); - } - - private CompletableFuture closeAllPools() { - return CompletableFuture.allOf(addressToPool.entrySet().stream() - .map(entry -> { - var address = entry.getKey(); - var pool = entry.getValue(); - log.info("Closing connection pool towards %s", address); - // Wait for all pools to be closed. - return closePool(pool).toCompletableFuture(); - }) - .toArray(CompletableFuture[]::new)); - } -} 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 deleted file mode 100644 index af3b916a17..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelHealthChecker.java +++ /dev/null @@ -1,191 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.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.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicLong; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.async.connection.AuthorizationStateListener; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; -import org.neo4j.driver.internal.async.inbound.ConnectionReadTimeoutHandler; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; -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 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.minAuthTimestamp = new AtomicLong(-1); - } - - @Override - public Future isHealthy(Channel channel) { - if (isTooOld(channel)) { - return channel.eventLoop().newSucceededFuture(Boolean.FALSE); - } - 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() { - var now = clock.millis(); - minAuthTimestamp.getAndUpdate(prev -> Math.max(prev, now)); - } - - private boolean isTooOld(Channel channel) { - if (poolSettings.maxConnectionLifetimeEnabled()) { - var creationTimestampMillis = creationTimestamp(channel); - var currentTimestampMillis = clock.millis(); - - var ageMillis = currentTimestampMillis - creationTimestampMillis; - var maxAgeMillis = poolSettings.maxConnectionLifetime(); - - var tooOld = ageMillis > maxAgeMillis; - if (tooOld) { - log.trace( - "Failed acquire channel %s from the pool because it is too old: %s > %s", - channel, ageMillis, maxAgeMillis); - } - return tooOld; - } - return false; - } - - private boolean hasBeenIdleForTooLong(Channel channel) { - if (poolSettings.idleTimeBeforeConnectionTestEnabled()) { - var lastUsedTimestamp = lastUsedTimestamp(channel); - if (lastUsedTimestamp != null) { - var idleTime = clock.millis() - lastUsedTimestamp; - var idleTooLong = idleTime > poolSettings.idleTimeBeforeConnectionTest(); - - if (idleTooLong) { - log.trace("Channel %s has been idle for %s and needs a ping", channel, idleTime); - } - - return idleTooLong; - } - } - return false; - } - - private Future ping(Channel channel) { - Promise result = channel.eventLoop().newPromise(); - var messageDispatcher = messageDispatcher(channel); - messageDispatcher.enqueue(new PingResponseHandler(result, channel, logging)); - attachConnectionReadTimeoutHandler(channel, messageDispatcher); - channel.writeAndFlush(ResetMessage.RESET, channel.voidPromise()); - return result; - } - - private void attachConnectionReadTimeoutHandler(Channel channel, InboundMessageDispatcher messageDispatcher) { - ChannelAttributes.connectionReadTimeout(channel).ifPresent(connectionReadTimeout -> { - var connectionReadTimeoutHandler = - new ConnectionReadTimeoutHandler(connectionReadTimeout, TimeUnit.SECONDS); - channel.pipeline().addFirst(connectionReadTimeoutHandler); - log.debug("Added ConnectionReadTimeoutHandler"); - messageDispatcher.setBeforeLastHandlerHook((messageType) -> { - channel.pipeline().remove(connectionReadTimeoutHandler); - messageDispatcher.setBeforeLastHandlerHook(null); - log.debug("Removed ConnectionReadTimeoutHandler"); - }); - }); - } -} 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 deleted file mode 100644 index e792bd0c50..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelPool.java +++ /dev/null @@ -1,240 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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 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; - -import io.netty.bootstrap.Bootstrap; -import io.netty.channel.Channel; -import io.netty.channel.ChannelFuture; -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.security.InternalAuthToken; -import org.neo4j.driver.internal.util.Futures; -import org.neo4j.driver.internal.util.SessionAuthUtil; - -public class NettyChannelPool implements ExtendedChannelPool { - /** - * Unlimited amount of parties are allowed to request channels from the pool. - */ - private static final int MAX_PENDING_ACQUIRES = Integer.MAX_VALUE; - /** - * Do not check channels when they are returned to the pool. - */ - private static final boolean RELEASE_HEALTH_CHECK = false; - - private final FixedChannelPool delegate; - 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, - NettyChannelHealthChecker healthCheck, - long acquireTimeoutMillis, - 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, - handler, - healthCheck, - FixedChannelPool.AcquireTimeoutAction.FAIL, - acquireTimeoutMillis, - maxConnections, - MAX_PENDING_ACQUIRES, - RELEASE_HEALTH_CHECK) { - @Override - protected ChannelFuture connectChannel(Bootstrap bootstrap) { - var creatingEvent = handler.channelCreating(id); - var connectedChannelFuture = connector.connect(address, bootstrap); - var channel = connectedChannelFuture.channel(); - // This ensures that handler.channelCreated is called before SimpleChannelPool calls - // handler.channelAcquired - var trackedChannelFuture = channel.newPromise(); - connectedChannelFuture.addListener(future -> { - if (future.isSuccess()) { - // notify pool handler about a successful connection - setPoolId(channel, id); - handler.channelCreated(channel, creatingEvent); - trackedChannelFuture.setSuccess(); - } else { - handler.channelFailedToCreate(id); - trackedChannelFuture.setFailure(future.cause()); - } - }); - return trackedChannelFuture; - } - }; - } - - @Override - public CompletionStage close() { - if (closed.compareAndSet(false, true)) { - asCompletionStage(delegate.closeAsync(), closeFuture); - } - return closeFuture; - } - - @Override - 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 { - 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 - public CompletionStage release(Channel channel) { - return asCompletionStage(delegate.release(channel)); - } - - @Override - public boolean isClosed() { - return closed.get(); - } - - @Override - public String id() { - return this.id; - } - - private String poolId(BoltServerAddress serverAddress) { - return String.format("%s:%d-%d", serverAddress.host(), serverAddress.port(), this.hashCode()); - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelTracker.java b/driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelTracker.java deleted file mode 100644 index f17cded182..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelTracker.java +++ /dev/null @@ -1,170 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.neo4j.driver.internal.async.connection.ChannelAttributes.poolId; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.serverAddress; -import static org.neo4j.driver.internal.util.LockUtil.executeWithLock; - -import io.netty.channel.Channel; -import io.netty.channel.ChannelFutureListener; -import io.netty.channel.group.ChannelGroup; -import io.netty.channel.group.DefaultChannelGroup; -import io.netty.channel.pool.ChannelPoolHandler; -import io.netty.util.concurrent.EventExecutor; -import java.util.HashMap; -import java.util.Map; -import java.util.concurrent.locks.Lock; -import java.util.concurrent.locks.ReentrantReadWriteLock; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.metrics.ListenerEvent; -import org.neo4j.driver.internal.metrics.MetricsListener; -import org.neo4j.driver.net.ServerAddress; - -public class NettyChannelTracker implements ChannelPoolHandler { - private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - private final Lock read = lock.readLock(); - private final Lock write = lock.writeLock(); - private final Map addressToInUseChannelCount = new HashMap<>(); - private final Map addressToIdleChannelCount = new HashMap<>(); - private final Logger log; - private final MetricsListener metricsListener; - private final ChannelFutureListener closeListener = future -> channelClosed(future.channel()); - private final ChannelGroup allChannels; - - public NettyChannelTracker(MetricsListener metricsListener, EventExecutor eventExecutor, Logging logging) { - this(metricsListener, new DefaultChannelGroup("all-connections", eventExecutor), logging); - } - - public NettyChannelTracker(MetricsListener metricsListener, ChannelGroup channels, Logging logging) { - this.metricsListener = metricsListener; - this.log = logging.getLog(getClass()); - this.allChannels = channels; - } - - @Override - public void channelReleased(Channel channel) { - executeWithLock(write, () -> { - decrementInUse(channel); - incrementIdle(channel); - channel.closeFuture().addListener(closeListener); - }); - - log.debug("Channel [0x%s] released back to the pool", channel.id()); - } - - @Override - public void channelAcquired(Channel channel) { - executeWithLock(write, () -> { - incrementInUse(channel); - decrementIdle(channel); - channel.closeFuture().removeListener(closeListener); - }); - - log.debug( - "Channel [0x%s] acquired from the pool. Local address: %s, remote address: %s", - channel.id(), channel.localAddress(), channel.remoteAddress()); - } - - @Override - public void channelCreated(Channel channel) { - throw new IllegalStateException("Untraceable channel created."); - } - - public void channelCreated(Channel channel, ListenerEvent creatingEvent) { - // when it is created, we count it as idle as it has not been acquired out of the pool - executeWithLock(write, () -> incrementIdle(channel)); - - metricsListener.afterCreated(poolId(channel), creatingEvent); - allChannels.add(channel); - log.debug( - "Channel [0x%s] created. Local address: %s, remote address: %s", - channel.id(), channel.localAddress(), channel.remoteAddress()); - } - - public ListenerEvent channelCreating(String poolId) { - var creatingEvent = metricsListener.createListenerEvent(); - metricsListener.beforeCreating(poolId, creatingEvent); - return creatingEvent; - } - - public void channelFailedToCreate(String poolId) { - metricsListener.afterFailedToCreate(poolId); - } - - public void channelClosed(Channel channel) { - executeWithLock(write, () -> decrementIdle(channel)); - metricsListener.afterClosed(poolId(channel)); - } - - public int inUseChannelCount(ServerAddress address) { - return executeWithLock(read, () -> addressToInUseChannelCount.getOrDefault(address, 0)); - } - - public int idleChannelCount(ServerAddress address) { - return executeWithLock(read, () -> addressToIdleChannelCount.getOrDefault(address, 0)); - } - - public void prepareToCloseChannels() { - for (var channel : allChannels) { - var protocol = BoltProtocol.forChannel(channel); - try { - protocol.prepareToCloseChannel(channel); - } catch (Throwable e) { - // only logging it - log.debug( - "Failed to prepare to close Channel %s due to error %s. " - + "It is safe to ignore this error as the channel will be closed despite if it is successfully prepared to close or not.", - channel, e.getMessage()); - } - } - } - - private void incrementInUse(Channel channel) { - increment(channel, addressToInUseChannelCount); - } - - private void decrementInUse(Channel channel) { - var address = serverAddress(channel); - if (!addressToInUseChannelCount.containsKey(address)) { - throw new IllegalStateException("No count exists for address '" + address + "' in the 'in use' count"); - } - var count = addressToInUseChannelCount.get(address); - addressToInUseChannelCount.put(address, count - 1); - } - - private void incrementIdle(Channel channel) { - increment(channel, addressToIdleChannelCount); - } - - private void decrementIdle(Channel channel) { - var address = serverAddress(channel); - if (!addressToIdleChannelCount.containsKey(address)) { - throw new IllegalStateException("No count exists for address '" + address + "' in the 'idle' count"); - } - var count = addressToIdleChannelCount.get(address); - addressToIdleChannelCount.put(address, count - 1); - } - - private void increment(Channel channel, Map countMap) { - ServerAddress address = serverAddress(channel); - var count = countMap.computeIfAbsent(address, k -> 0); - countMap.put(address, count + 1); - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/pool/NetworkConnectionFactory.java b/driver/src/main/java/org/neo4j/driver/internal/async/pool/NetworkConnectionFactory.java deleted file mode 100644 index c349e40b35..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/async/pool/NetworkConnectionFactory.java +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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 io.netty.channel.Channel; -import java.time.Clock; -import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.async.NetworkConnection; -import org.neo4j.driver.internal.metrics.MetricsListener; -import org.neo4j.driver.internal.spi.Connection; - -public class NetworkConnectionFactory implements ConnectionFactory { - private final Clock clock; - private final MetricsListener metricsListener; - private final Logging logging; - - public NetworkConnectionFactory(Clock clock, MetricsListener metricsListener, Logging logging) { - this.clock = clock; - this.metricsListener = metricsListener; - this.logging = logging; - } - - @Override - public Connection createConnection(Channel channel, ExtendedChannelPool pool) { - return new NetworkConnection(channel, pool, clock, metricsListener, logging); - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/pool/PoolSettings.java b/driver/src/main/java/org/neo4j/driver/internal/async/pool/PoolSettings.java deleted file mode 100644 index 056a869888..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/async/pool/PoolSettings.java +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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 java.util.concurrent.TimeUnit; - -public record PoolSettings( - int maxConnectionPoolSize, - long connectionAcquisitionTimeout, - long maxConnectionLifetime, - long idleTimeBeforeConnectionTest) { - public static final int NOT_CONFIGURED = -1; - - public static final int DEFAULT_MAX_CONNECTION_POOL_SIZE = 100; - public static final long DEFAULT_IDLE_TIME_BEFORE_CONNECTION_TEST = NOT_CONFIGURED; - public static final long DEFAULT_MAX_CONNECTION_LIFETIME = TimeUnit.HOURS.toMillis(1); - public static final long DEFAULT_CONNECTION_ACQUISITION_TIMEOUT = TimeUnit.SECONDS.toMillis(60); - - public boolean idleTimeBeforeConnectionTestEnabled() { - return idleTimeBeforeConnectionTest >= 0; - } - - public boolean maxConnectionLifetimeEnabled() { - return maxConnectionLifetime > 0; - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/AccessMode.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/AccessMode.java new file mode 100644 index 0000000000..e4a6eb51ae --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/AccessMode.java @@ -0,0 +1,22 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api; + +public enum AccessMode { + READ, + WRITE +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/ResultCursorFactory.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/AuthData.java similarity index 73% rename from driver/src/main/java/org/neo4j/driver/internal/cursor/ResultCursorFactory.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/AuthData.java index aa82348d51..2d034b4051 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cursor/ResultCursorFactory.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/AuthData.java @@ -14,12 +14,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cursor; +package org.neo4j.driver.internal.bolt.api; -import java.util.concurrent.CompletionStage; +import java.util.Map; +import org.neo4j.driver.Value; -public interface ResultCursorFactory { - CompletionStage asyncResult(); +public interface AuthData { + Map authMap(); - CompletionStage rxResult(); + long authAckMillis(); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/BoltAgent.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltAgent.java similarity index 94% rename from driver/src/main/java/org/neo4j/driver/internal/BoltAgent.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltAgent.java index ef4016258d..50b4b7c85a 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/BoltAgent.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltAgent.java @@ -14,6 +14,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal; +package org.neo4j.driver.internal.bolt.api; public record BoltAgent(String product, String platform, String language, String languageDetails) {} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltConnection.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltConnection.java new file mode 100644 index 0000000000..d7a52f3af0 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltConnection.java @@ -0,0 +1,93 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api; + +import java.time.Duration; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CompletionStage; +import org.neo4j.driver.Value; + +/** + * TODO + */ +public interface BoltConnection { + CompletionStage route(DatabaseName databaseName, String impersonatedUser, Set bookmarks); + + CompletionStage beginTransaction( + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, + Set bookmarks, + TransactionType transactionType, + Duration txTimeout, + Map txMetadata, + NotificationConfig notificationConfig); + + CompletionStage runInAutoCommitTransaction( + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, + Set bookmarks, + String query, + Map parameters, + Duration txTimeout, + Map txMetadata, + NotificationConfig notificationConfig); + + CompletionStage run(String query, Map parameters); + + CompletionStage pull(long qid, long request); + + CompletionStage discard(long qid, long number); + + CompletionStage commit(); + + CompletionStage rollback(); + + CompletionStage reset(); + + CompletionStage logoff(); + + CompletionStage logon(Map authMap); + + CompletionStage telemetry(TelemetryApi telemetryApi); + + CompletionStage clear(); + + CompletionStage flush(ResponseHandler handler); + + CompletionStage forceClose(String reason); + + CompletionStage close(); + + // ----- MUTABLE DATA ----- + + BoltConnectionState state(); + + CompletionStage authData(); + + // ----- IMMUTABLE DATA ----- + + String serverAgent(); + + BoltServerAddress serverAddress(); + + BoltProtocolVersion protocolVersion(); + + boolean telemetrySupported(); +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltConnectionProvider.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltConnectionProvider.java new file mode 100644 index 0000000000..b497bf7951 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltConnectionProvider.java @@ -0,0 +1,53 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api; + +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CompletionStage; +import java.util.function.Consumer; +import java.util.function.Supplier; +import org.neo4j.driver.Value; + +public interface BoltConnectionProvider { + CompletionStage init( + BoltServerAddress address, + SecurityPlan securityPlan, + RoutingContext routingContext, + BoltAgent boltAgent, + String userAgent, + int connectTimeoutMillis, + MetricsListener metricsListener); + + CompletionStage connect( + DatabaseName databaseName, + Supplier>> authMapStageSupplier, + AccessMode mode, + Set bookmarks, + String impersonatedUser, + BoltProtocolVersion minVersion, + NotificationConfig notificationConfig, + Consumer databaseNameConsumer); + + CompletionStage verifyConnectivity(Map authMap); + + CompletionStage supportsMultiDb(Map authMap); + + CompletionStage supportsSessionAuth(Map authMap); + + CompletionStage close(); +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltConnectionState.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltConnectionState.java new file mode 100644 index 0000000000..f979af9af7 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltConnectionState.java @@ -0,0 +1,24 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api; + +public enum BoltConnectionState { + OPEN, + ERROR, + FAILURE, + CLOSED +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocolVersion.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltProtocolVersion.java similarity index 98% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocolVersion.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltProtocolVersion.java index 837098ed29..31c9655f51 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocolVersion.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltProtocolVersion.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging; +package org.neo4j.driver.internal.bolt.api; import java.util.Objects; diff --git a/driver/src/main/java/org/neo4j/driver/internal/BoltServerAddress.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltServerAddress.java similarity index 92% rename from driver/src/main/java/org/neo4j/driver/internal/BoltServerAddress.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltServerAddress.java index 0ac54cfe2c..964444c50a 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/BoltServerAddress.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/BoltServerAddress.java @@ -14,19 +14,18 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal; +package org.neo4j.driver.internal.bolt.api; import static java.util.Objects.requireNonNull; import java.net.URI; import java.util.Objects; import java.util.stream.Stream; -import org.neo4j.driver.net.ServerAddress; /** * Holds a host and port pair that denotes a Bolt server address. */ -public class BoltServerAddress implements ServerAddress { +public class BoltServerAddress { public static final int DEFAULT_PORT = 7687; public static final BoltServerAddress LOCAL_DEFAULT = new BoltServerAddress("localhost", DEFAULT_PORT); @@ -58,12 +57,6 @@ public BoltServerAddress(String host, String connectionHost, int port) { : String.format("%s(%s):%d", host, connectionHost, port); } - public static BoltServerAddress from(ServerAddress address) { - return address instanceof BoltServerAddress - ? (BoltServerAddress) address - : new BoltServerAddress(address.host(), address.port()); - } - @Override public boolean equals(Object o) { if (this == o) { @@ -86,12 +79,10 @@ public String toString() { return stringValue; } - @Override public String host() { return host; } - @Override public int port() { return port; } diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/ClusterComposition.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/ClusterComposition.java similarity index 79% rename from driver/src/main/java/org/neo4j/driver/internal/cluster/ClusterComposition.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/ClusterComposition.java index 0e3eb68730..162d574a8a 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/ClusterComposition.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/ClusterComposition.java @@ -14,15 +14,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal.bolt.api; import java.util.LinkedHashSet; import java.util.Objects; import java.util.Set; import java.util.function.Function; -import org.neo4j.driver.Record; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.BoltServerAddress; public final class ClusterComposition { private static final long MAX_TTL = Long.MAX_VALUE / 1000L; @@ -43,9 +41,6 @@ private ClusterComposition(long expirationTimestamp, String databaseName) { this.databaseName = databaseName; } - /** - * For testing - */ public ClusterComposition( long expirationTimestamp, Set readers, @@ -117,30 +112,6 @@ public String toString() { + databaseName + '}'; } - public static ClusterComposition parse(Record record, long now) { - if (record == null) { - return null; - } - - final var result = new ClusterComposition( - expirationTimestamp(now, record), record.get("db").asString(null)); - record.get("servers").asList((Function) value -> { - result.servers(value.get("role").asString()) - .addAll(value.get("addresses").asList(OF_BoltServerAddress)); - return null; - }); - return result; - } - - private static long expirationTimestamp(long now, Record record) { - var ttl = record.get("ttl").asLong(); - var expirationTimestamp = now + ttl * 1000; - if (ttl < 0 || ttl >= MAX_TTL || expirationTimestamp < 0) { - expirationTimestamp = Long.MAX_VALUE; - } - return expirationTimestamp; - } - private Set servers(String role) { return switch (role) { case "READ" -> readers; diff --git a/driver/src/main/java/org/neo4j/driver/internal/DatabaseName.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/DatabaseName.java similarity index 94% rename from driver/src/main/java/org/neo4j/driver/internal/DatabaseName.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/DatabaseName.java index 47aced6744..c41b8ce160 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/DatabaseName.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/DatabaseName.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal; +package org.neo4j.driver.internal.bolt.api; import java.util.Optional; diff --git a/driver/src/main/java/org/neo4j/driver/internal/DatabaseNameUtil.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/DatabaseNameUtil.java similarity index 97% rename from driver/src/main/java/org/neo4j/driver/internal/DatabaseNameUtil.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/DatabaseNameUtil.java index 7a0007fc9a..04840a109a 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/DatabaseNameUtil.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/DatabaseNameUtil.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal; +package org.neo4j.driver.internal.bolt.api; import java.util.Objects; import java.util.Optional; diff --git a/driver/src/main/java/org/neo4j/driver/internal/DefaultDomainNameResolver.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/DefaultDomainNameResolver.java similarity index 96% rename from driver/src/main/java/org/neo4j/driver/internal/DefaultDomainNameResolver.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/DefaultDomainNameResolver.java index 29930addf6..7e3cd4b585 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/DefaultDomainNameResolver.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/DefaultDomainNameResolver.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal; +package org.neo4j.driver.internal.bolt.api; import java.net.InetAddress; import java.net.UnknownHostException; diff --git a/driver/src/main/java/org/neo4j/driver/internal/DomainNameResolver.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/DomainNameResolver.java similarity index 96% rename from driver/src/main/java/org/neo4j/driver/internal/DomainNameResolver.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/DomainNameResolver.java index ca321bf64d..5d8804a14b 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/DomainNameResolver.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/DomainNameResolver.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal; +package org.neo4j.driver.internal.bolt.api; import java.net.InetAddress; import java.net.UnknownHostException; diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalDatabaseName.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/InternalDatabaseName.java similarity index 97% rename from driver/src/main/java/org/neo4j/driver/internal/InternalDatabaseName.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/InternalDatabaseName.java index 3398b15511..f1bc317a8b 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/InternalDatabaseName.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/InternalDatabaseName.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal; +package org.neo4j.driver.internal.bolt.api; import static java.util.Objects.requireNonNull; diff --git a/driver/src/main/java/org/neo4j/driver/internal/metrics/ListenerEvent.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/ListenerEvent.java similarity index 94% rename from driver/src/main/java/org/neo4j/driver/internal/metrics/ListenerEvent.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/ListenerEvent.java index 710f6f99bc..c4745bae04 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/metrics/ListenerEvent.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/ListenerEvent.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.metrics; +package org.neo4j.driver.internal.bolt.api; public interface ListenerEvent { void start(); diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/pool/ConnectionFactory.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/LoggingProvider.java similarity index 72% rename from driver/src/main/java/org/neo4j/driver/internal/async/pool/ConnectionFactory.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/LoggingProvider.java index 809874e1ae..d6c68dfeae 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/pool/ConnectionFactory.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/LoggingProvider.java @@ -14,11 +14,10 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.pool; +package org.neo4j.driver.internal.bolt.api; -import io.netty.channel.Channel; -import org.neo4j.driver.internal.spi.Connection; +public interface LoggingProvider { + System.Logger getLog(Class cls); -public interface ConnectionFactory { - Connection createConnection(Channel channel, ExtendedChannelPool pool); + System.Logger getLog(String name); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/metrics/MetricsListener.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/MetricsListener.java similarity index 95% rename from driver/src/main/java/org/neo4j/driver/internal/metrics/MetricsListener.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/MetricsListener.java index 26ff72d122..30228e9f21 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/metrics/MetricsListener.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/MetricsListener.java @@ -14,12 +14,11 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.metrics; +package org.neo4j.driver.internal.bolt.api; import java.util.concurrent.TimeUnit; import java.util.function.IntSupplier; import org.neo4j.driver.Config; -import org.neo4j.driver.net.ServerAddress; public interface MetricsListener { /** @@ -97,7 +96,7 @@ public interface MetricsListener { ListenerEvent createListenerEvent(); void registerPoolMetrics( - String poolId, ServerAddress serverAddress, IntSupplier inUseSupplier, IntSupplier idleSupplier); + String poolId, BoltServerAddress serverAddress, IntSupplier inUseSupplier, IntSupplier idleSupplier); void removePoolMetrics(String poolId); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/NotificationCategory.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/NotificationCategory.java new file mode 100644 index 0000000000..7bcda3d285 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/NotificationCategory.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api; + +import java.util.Arrays; +import java.util.Objects; +import java.util.Optional; + +public record NotificationCategory(Type type) { + public NotificationCategory { + Objects.requireNonNull(type, "type must not be null"); + } + + public enum Type { + HINT, + UNRECOGNIZED, + UNSUPPORTED, + PERFORMANCE, + DEPRECATION, + SECURITY, + TOPOLOGY, + GENERIC + } + + public static Optional valueOf(String value) { + return Arrays.stream(Type.values()) + .filter(type -> type.toString().equals(value)) + .findFirst() + .map(NotificationCategory::new); + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/DriverInfoUtilTest.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/NotificationConfig.java similarity index 65% rename from driver/src/test/java/org/neo4j/driver/internal/util/DriverInfoUtilTest.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/NotificationConfig.java index f787c8199d..9a4be60b0a 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/DriverInfoUtilTest.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/NotificationConfig.java @@ -14,17 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.util; +package org.neo4j.driver.internal.bolt.api; -import static org.junit.jupiter.api.Assertions.assertTrue; +import java.util.Set; -import org.junit.jupiter.api.Test; - -class DriverInfoUtilTest { - @Test - void shouldIncludeValidProduct() { - var boltAgent = DriverInfoUtil.boltAgent(); - - assertTrue(boltAgent.product().matches("^neo4j-java/.+$")); +public record NotificationConfig(NotificationSeverity minimumSeverity, Set disabledCategories) { + public static NotificationConfig defaultConfig() { + return new NotificationConfig(null, null); } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/NotificationSeverity.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/NotificationSeverity.java new file mode 100644 index 0000000000..22d9cb3f16 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/NotificationSeverity.java @@ -0,0 +1,57 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api; + +import java.util.Arrays; +import java.util.Objects; +import java.util.Optional; + +public record NotificationSeverity(Type type, int level) implements Comparable { + public static final NotificationSeverity OFF = + new NotificationSeverity(NotificationSeverity.Type.OFF, Integer.MAX_VALUE); + + public static NotificationSeverity INFORMATION = + new NotificationSeverity(NotificationSeverity.Type.INFORMATION, 800); + + public static NotificationSeverity WARNING = new NotificationSeverity(NotificationSeverity.Type.WARNING, 900); + + public NotificationSeverity { + Objects.requireNonNull(type, "type must not be null"); + } + + @Override + public int compareTo(NotificationSeverity severity) { + return Integer.compare(this.level, severity.level()); + } + + public enum Type { + INFORMATION, + WARNING, + OFF + } + + public static Optional valueOf(String value) { + return Arrays.stream(Type.values()) + .filter(type -> type.toString().equals(value)) + .findFirst() + .map(type -> switch (type) { + case INFORMATION -> NotificationSeverity.INFORMATION; + case WARNING -> NotificationSeverity.WARNING; + case OFF -> NotificationSeverity.OFF; + }); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/ResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/ResponseHandler.java new file mode 100644 index 0000000000..ea8beca0e0 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/ResponseHandler.java @@ -0,0 +1,87 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api; + +import org.neo4j.driver.Value; +import org.neo4j.driver.internal.bolt.api.summary.BeginSummary; +import org.neo4j.driver.internal.bolt.api.summary.CommitSummary; +import org.neo4j.driver.internal.bolt.api.summary.DiscardSummary; +import org.neo4j.driver.internal.bolt.api.summary.LogoffSummary; +import org.neo4j.driver.internal.bolt.api.summary.LogonSummary; +import org.neo4j.driver.internal.bolt.api.summary.PullSummary; +import org.neo4j.driver.internal.bolt.api.summary.ResetSummary; +import org.neo4j.driver.internal.bolt.api.summary.RollbackSummary; +import org.neo4j.driver.internal.bolt.api.summary.RouteSummary; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.api.summary.TelemetrySummary; + +public interface ResponseHandler { + + void onError(Throwable throwable); + + default void onBeginSummary(BeginSummary summary) { + // ignored + } + + default void onRunSummary(RunSummary summary) { + // ignored + } + + default void onRecord(Value[] fields) { + // ignored + } + + default void onPullSummary(PullSummary summary) { + // ignored + } + + default void onDiscardSummary(DiscardSummary summary) { + // ignored + } + + default void onCommitSummary(CommitSummary summary) { + // ignored + } + + default void onRollbackSummary(RollbackSummary summary) { + // ignored + } + + default void onResetSummary(ResetSummary summary) { + // ignored + } + + default void onRouteSummary(RouteSummary summary) { + // ignored + } + + default void onLogoffSummary(LogoffSummary summary) { + // ignored + } + + default void onLogonSummary(LogonSummary summary) { + // ignored + } + + default void onTelemetrySummary(TelemetrySummary summary) { + // ignored + } + + default void onComplete() { + // ignored + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/ResultSummary.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/ResultSummary.java new file mode 100644 index 0000000000..dfa191befa --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/ResultSummary.java @@ -0,0 +1,40 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api; + +/** + * The result summary of running a query. The result summary interface can be used to + * investigate details about the result, like the type of query run, how many and which + * kinds of updates have been executed, and query plan and profiling information if + * available. + *

+ * The result summary is only available after all result records have been consumed. + *

+ * Keeping the result summary around does not influence the lifecycle of any associated + * session and/or transaction. + * + * @author Neo4j Drivers Team + * @since 1.0.0 + */ +public interface ResultSummary { + + /** + * Returns counters for operations the query triggered. + * @return counters for operations the query triggered + */ + SummaryCounters counters(); +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingContext.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/RoutingContext.java similarity index 94% rename from driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingContext.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/RoutingContext.java index f57d710ce6..9a071d5f0b 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingContext.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/RoutingContext.java @@ -14,18 +14,18 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal.bolt.api; import static java.util.Collections.emptyMap; import static java.util.Collections.unmodifiableMap; +import static org.neo4j.driver.internal.bolt.api.Scheme.isRoutingScheme; import java.net.URI; import java.util.HashMap; import java.util.Map; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.Scheme; public class RoutingContext { + public static final RoutingContext EMPTY = new RoutingContext(); private static final String ROUTING_ADDRESS_KEY = "address"; @@ -38,7 +38,7 @@ private RoutingContext() { } public RoutingContext(URI uri) { - this.isServerRoutingEnabled = Scheme.isRoutingScheme(uri.getScheme()); + this.isServerRoutingEnabled = isRoutingScheme(uri.getScheme()); this.context = unmodifiableMap(parseParameters(uri)); } diff --git a/driver/src/test/java/org/neo4j/driver/internal/InternalPairTest.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/Scheme.java similarity index 57% rename from driver/src/test/java/org/neo4j/driver/internal/InternalPairTest.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/Scheme.java index e51c32fdba..a40e1ee164 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/InternalPairTest.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/Scheme.java @@ -14,19 +14,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal; +package org.neo4j.driver.internal.bolt.api; -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.neo4j.driver.Values.value; +import java.util.List; -import org.junit.jupiter.api.Test; +class Scheme { + public static final String NEO4J_URI_SCHEME = "neo4j"; + public static final String NEO4J_HIGH_TRUST_URI_SCHEME = "neo4j+s"; + public static final String NEO4J_LOW_TRUST_URI_SCHEME = "neo4j+ssc"; -class InternalPairTest { - @Test - void testMethods() { - var pair = InternalPair.of("k", value("v")); - assertThat(pair.key(), equalTo("k")); - assertThat(pair.value(), equalTo(value("v"))); + static boolean isRoutingScheme(String scheme) { + return List.of(NEO4J_LOW_TRUST_URI_SCHEME, NEO4J_HIGH_TRUST_URI_SCHEME, NEO4J_URI_SCHEME) + .contains(scheme); } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/security/SecurityPlan.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/SecurityPlan.java similarity index 84% rename from driver/src/main/java/org/neo4j/driver/internal/security/SecurityPlan.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/SecurityPlan.java index b832c9cccc..f9669fd234 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/security/SecurityPlan.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/SecurityPlan.java @@ -14,10 +14,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.security; +package org.neo4j.driver.internal.bolt.api; import javax.net.ssl.SSLContext; -import org.neo4j.driver.RevocationCheckingStrategy; /** * A SecurityPlan consists of encryption and trust details. @@ -28,6 +27,4 @@ public interface SecurityPlan { SSLContext sslContext(); boolean requiresHostnameVerification(); - - RevocationCheckingStrategy revocationCheckingStrategy(); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/SecurityPlanImpl.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/SecurityPlanImpl.java new file mode 100644 index 0000000000..cde4f15fab --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/SecurityPlanImpl.java @@ -0,0 +1,49 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api; + +import javax.net.ssl.SSLContext; + +/** + * A SecurityPlan consists of encryption and trust details. + */ +public class SecurityPlanImpl implements SecurityPlan { + private final boolean requiresEncryption; + private final SSLContext sslContext; + private final boolean requiresHostnameVerification; + + public SecurityPlanImpl(boolean requiresEncryption, SSLContext sslContext, boolean requiresHostnameVerification) { + this.requiresEncryption = requiresEncryption; + this.sslContext = sslContext; + this.requiresHostnameVerification = requiresHostnameVerification; + } + + @Override + public boolean requiresEncryption() { + return requiresEncryption; + } + + @Override + public SSLContext sslContext() { + return sslContext; + } + + @Override + public boolean requiresHostnameVerification() { + return requiresHostnameVerification; + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/SummaryCounters.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/SummaryCounters.java new file mode 100644 index 0000000000..8dbbd98bbb --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/SummaryCounters.java @@ -0,0 +1,112 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api; + +/** + * Contains counters for various operations that a query triggered. + * + * @author Neo4j Drivers Team + * @since 1.0.0 + */ +public interface SummaryCounters { + + int totalCount(); + + /** + * Whether there were any updates at all, eg. any of the counters are greater than 0. + * @return true if the query made any updates + */ + boolean containsUpdates(); + + /** + * Returns the number of nodes created. + * @return number of nodes created. + */ + int nodesCreated(); + + /** + * Returns the number of nodes deleted. + * @return number of nodes deleted. + */ + int nodesDeleted(); + + /** + * Returns the number of relationships created. + * @return number of relationships created. + */ + int relationshipsCreated(); + + /** + * Returns the number of relationships deleted. + * @return number of relationships deleted. + */ + int relationshipsDeleted(); + + /** + * Returns the number of properties (on both nodes and relationships) set. + * @return number of properties (on both nodes and relationships) set. + */ + int propertiesSet(); + + /** + * Returns the number of labels added to nodes. + * @return number of labels added to nodes. + */ + int labelsAdded(); + + /** + * Returns the number of labels removed from nodes. + * @return number of labels removed from nodes. + */ + int labelsRemoved(); + + /** + * Returns the number of indexes added to the schema. + * @return number of indexes added to the schema. + */ + int indexesAdded(); + + /** + * Returns the number of indexes removed from the schema. + * @return number of indexes removed from the schema. + */ + int indexesRemoved(); + + /** + * Returns the number of constraints added to the schema. + * @return number of constraints added to the schema. + */ + int constraintsAdded(); + + /** + * Returns the number of constraints removed from the schema. + * @return number of constraints removed from the schema. + */ + int constraintsRemoved(); + + /** + * If the query updated the system graph in any way, this method will return true. + * @return true if the system graph has been updated. + */ + boolean containsSystemUpdates(); + + /** + * Returns the number of system updates performed by this query. + * @return the number of system updates performed by this query. + */ + int systemUpdates(); +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/telemetry/TelemetryApi.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/TelemetryApi.java similarity index 95% rename from driver/src/main/java/org/neo4j/driver/internal/telemetry/TelemetryApi.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/TelemetryApi.java index 26bc725587..0da5db6773 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/telemetry/TelemetryApi.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/TelemetryApi.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.telemetry; +package org.neo4j.driver.internal.bolt.api; /** * An enum of valid telemetry metrics. diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/TransactionType.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/TransactionType.java new file mode 100644 index 0000000000..6249bdfea5 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/TransactionType.java @@ -0,0 +1,22 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api; + +public enum TransactionType { + DEFAULT, + UNCONSTRAINED +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/exception/MessageIgnoredException.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/exception/MessageIgnoredException.java new file mode 100644 index 0000000000..591b2a5847 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/exception/MessageIgnoredException.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api.exception; + +import java.io.Serial; +import org.neo4j.driver.exceptions.Neo4jException; + +public class MessageIgnoredException extends Neo4jException { + @Serial + private static final long serialVersionUID = 8087512561960062490L; + + public MessageIgnoredException(String message) { + super(message); + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/logging/Slf4jLoggingTest.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/exception/MinVersionAcquisitionException.java similarity index 51% rename from driver/src/test/java/org/neo4j/driver/internal/logging/Slf4jLoggingTest.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/exception/MinVersionAcquisitionException.java index ae4e436100..82e3497e4e 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/logging/Slf4jLoggingTest.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/exception/MinVersionAcquisitionException.java @@ -14,26 +14,24 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.logging; +package org.neo4j.driver.internal.bolt.api.exception; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.instanceOf; -import static org.junit.jupiter.api.Assertions.assertNull; +import java.io.Serial; +import org.neo4j.driver.exceptions.Neo4jException; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; -import org.junit.jupiter.api.Test; +public class MinVersionAcquisitionException extends Neo4jException { + @Serial + private static final long serialVersionUID = 2620821821322630443L; -class Slf4jLoggingTest { - @Test - void shouldCreateLoggers() { - var logging = new Slf4jLogging(); + private final BoltProtocolVersion version; - var logger = logging.getLog("My Log"); - - assertThat(logger, instanceOf(Slf4jLogger.class)); + public MinVersionAcquisitionException(String message, BoltProtocolVersion version) { + super(message); + this.version = version; } - @Test - void shouldCheckIfAvailable() { - assertNull(Slf4jLogging.checkAvailability()); + public BoltProtocolVersion version() { + return version; } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/BeginSummary.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/BeginSummary.java new file mode 100644 index 0000000000..2d76c7aa2c --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/BeginSummary.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api.summary; + +public interface BeginSummary {} diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelConnector.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/CommitSummary.java similarity index 68% rename from driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelConnector.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/CommitSummary.java index 5a64be241e..e9c04bab41 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelConnector.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/CommitSummary.java @@ -14,12 +14,10 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.api.summary; -import io.netty.bootstrap.Bootstrap; -import io.netty.channel.ChannelFuture; -import org.neo4j.driver.internal.BoltServerAddress; +import java.util.Optional; -public interface ChannelConnector { - ChannelFuture connect(BoltServerAddress address, Bootstrap bootstrap); +public interface CommitSummary { + Optional bookmark(); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursor.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/DiscardSummary.java similarity index 65% rename from driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursor.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/DiscardSummary.java index cd8e3ec398..e5d7bc6e10 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursor.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/DiscardSummary.java @@ -14,12 +14,11 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cursor; +package org.neo4j.driver.internal.bolt.api.summary; -import java.util.concurrent.CompletableFuture; -import org.neo4j.driver.async.ResultCursor; -import org.neo4j.driver.internal.FailableCursor; +import java.util.Map; +import org.neo4j.driver.Value; -public interface AsyncResultCursor extends ResultCursor, FailableCursor { - CompletableFuture mapSuccessfulRunCompletionAsync(); +public interface DiscardSummary { + Map metadata(); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/HelloSummary.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/HelloSummary.java new file mode 100644 index 0000000000..58500221be --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/HelloSummary.java @@ -0,0 +1,21 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api.summary; + +public interface HelloSummary { + String serverAgent(); +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/LogoffSummary.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/LogoffSummary.java new file mode 100644 index 0000000000..d8b788988b --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/LogoffSummary.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api.summary; + +public interface LogoffSummary {} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/LogonSummary.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/LogonSummary.java new file mode 100644 index 0000000000..43a81e8faf --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/LogonSummary.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api.summary; + +public interface LogonSummary {} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/PullSummary.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/PullSummary.java new file mode 100644 index 0000000000..f02679c6e4 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/PullSummary.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api.summary; + +import java.util.Map; +import org.neo4j.driver.Value; + +public interface PullSummary { + boolean hasMore(); + + Map metadata(); +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/ResetSummary.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/ResetSummary.java new file mode 100644 index 0000000000..5f68153bc5 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/ResetSummary.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api.summary; + +public interface ResetSummary {} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/RollbackSummary.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/RollbackSummary.java new file mode 100644 index 0000000000..ea5cb0dcfa --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/RollbackSummary.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api.summary; + +public interface RollbackSummary {} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/RouteSummary.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/RouteSummary.java new file mode 100644 index 0000000000..72e080ec3f --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/RouteSummary.java @@ -0,0 +1,23 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api.summary; + +import org.neo4j.driver.internal.bolt.api.ClusterComposition; + +public interface RouteSummary { + ClusterComposition clusterComposition(); +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/RunSummary.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/RunSummary.java new file mode 100644 index 0000000000..6bb84f4bfa --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/RunSummary.java @@ -0,0 +1,27 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api.summary; + +import java.util.List; + +public interface RunSummary { + long queryId(); + + List keys(); + + long resultAvailableAfter(); +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/TelemetrySummary.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/TelemetrySummary.java new file mode 100644 index 0000000000..9c834e9408 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/api/summary/TelemetrySummary.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.api.summary; + +public interface TelemetrySummary {} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/BoltConnectionImpl.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/BoltConnectionImpl.java new file mode 100644 index 0000000000..bd5baa2a26 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/BoltConnectionImpl.java @@ -0,0 +1,652 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl; + +import io.netty.channel.EventLoop; +import io.netty.handler.codec.CodecException; +import java.io.IOException; +import java.time.Clock; +import java.time.Duration; +import java.util.ArrayDeque; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import java.util.Queue; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Function; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; +import org.neo4j.driver.exceptions.AuthorizationExpiredException; +import org.neo4j.driver.exceptions.Neo4jException; +import org.neo4j.driver.exceptions.ServiceUnavailableException; +import org.neo4j.driver.exceptions.UnsupportedFeatureException; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.AuthData; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltConnectionState; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.ResponseHandler; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; +import org.neo4j.driver.internal.bolt.api.TransactionType; +import org.neo4j.driver.internal.bolt.api.exception.MessageIgnoredException; +import org.neo4j.driver.internal.bolt.api.summary.BeginSummary; +import org.neo4j.driver.internal.bolt.api.summary.CommitSummary; +import org.neo4j.driver.internal.bolt.api.summary.DiscardSummary; +import org.neo4j.driver.internal.bolt.api.summary.LogoffSummary; +import org.neo4j.driver.internal.bolt.api.summary.LogonSummary; +import org.neo4j.driver.internal.bolt.api.summary.PullSummary; +import org.neo4j.driver.internal.bolt.api.summary.ResetSummary; +import org.neo4j.driver.internal.bolt.api.summary.RollbackSummary; +import org.neo4j.driver.internal.bolt.api.summary.RouteSummary; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.api.summary.TelemetrySummary; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.PullMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; +import org.neo4j.driver.internal.bolt.basicimpl.util.FutureUtil; + +public final class BoltConnectionImpl implements BoltConnection { + private final LoggingProvider logging; + private final BoltProtocol protocol; + private final Connection connection; + private final EventLoop eventLoop; + private final String serverAgent; + private final BoltServerAddress serverAddress; + private final BoltProtocolVersion protocolVersion; + private final boolean telemetrySupported; + private final AtomicReference stateRef = new AtomicReference<>(BoltConnectionState.OPEN); + private final AtomicReference> authDataRef; + private final Map routingContext; + private final Queue>> messageWriters; + private final Clock clock; + + public BoltConnectionImpl( + BoltProtocol protocol, + Connection connection, + EventLoop eventLoop, + Map authMap, + CompletableFuture latestAuthMillisFuture, + RoutingContext routingContext, + Clock clock, + LoggingProvider logging) { + this.protocol = Objects.requireNonNull(protocol); + this.connection = Objects.requireNonNull(connection); + this.eventLoop = Objects.requireNonNull(eventLoop); + this.serverAgent = Objects.requireNonNull(connection.serverAgent()); + this.serverAddress = Objects.requireNonNull(connection.serverAddress()); + this.protocolVersion = Objects.requireNonNull(connection.protocol().version()); + this.telemetrySupported = connection.isTelemetryEnabled(); + this.authDataRef = new AtomicReference<>( + CompletableFuture.completedFuture(new AuthDataImpl(authMap, latestAuthMillisFuture.join()))); + var mappedRoutingContext = new HashMap(); + for (var entry : routingContext.toMap().entrySet()) { + mappedRoutingContext.put(entry.getKey(), Values.value(entry.getValue())); + } + this.routingContext = Collections.unmodifiableMap(mappedRoutingContext); + this.messageWriters = new ArrayDeque<>(); + this.clock = Objects.requireNonNull(clock); + this.logging = Objects.requireNonNull(logging); + } + + @Override + public CompletionStage route( + DatabaseName databaseName, String impersonatedUser, Set bookmarks) { + return executeInEventLoop(() -> messageWriters.add(handler -> protocol.route( + this.connection, + this.routingContext, + bookmarks, + databaseName.databaseName().orElse(null), + impersonatedUser, + new MessageHandler<>() { + @Override + public void onError(Throwable throwable) { + updateState(throwable); + handler.onError(throwable); + } + + @Override + public void onSummary(RouteSummary summary) { + handler.onRouteSummary(summary); + } + }, + clock, + logging))) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage beginTransaction( + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, + Set bookmarks, + TransactionType transactionType, + Duration txTimeout, + Map txMetadata, + NotificationConfig notificationConfig) { + return executeInEventLoop(() -> messageWriters.add(handler -> protocol.beginTransaction( + this.connection, + databaseName, + accessMode, + impersonatedUser, + bookmarks, + txTimeout, + txMetadata, + null, + notificationConfig, + new MessageHandler<>() { + @Override + public void onError(Throwable throwable) { + updateState(throwable); + handler.onError(throwable); + } + + @Override + public void onSummary(Void summary) { + handler.onBeginSummary(null); + } + }, + logging))) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage runInAutoCommitTransaction( + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, + Set bookmarks, + String query, + Map parameters, + Duration txTimeout, + Map txMetadata, + NotificationConfig notificationConfig) { + return executeInEventLoop(() -> messageWriters.add(handler -> protocol.runAuto( + connection, + databaseName, + accessMode, + impersonatedUser, + query, + parameters, + bookmarks, + txTimeout, + txMetadata, + notificationConfig, + new MessageHandler<>() { + @Override + public void onError(Throwable throwable) { + updateState(throwable); + handler.onError(throwable); + } + + @Override + public void onSummary(RunSummary summary) { + handler.onRunSummary(summary); + } + }, + logging))) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage run(String query, Map parameters) { + return executeInEventLoop(() -> messageWriters.add( + handler -> protocol.run(connection, query, parameters, new MessageHandler<>() { + @Override + public void onError(Throwable throwable) { + updateState(throwable); + handler.onError(throwable); + } + + @Override + public void onSummary(RunSummary summary) { + handler.onRunSummary(summary); + } + }))) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage pull(long qid, long request) { + return executeInEventLoop(() -> + messageWriters.add(handler -> protocol.pull(connection, qid, request, new PullMessageHandler() { + @Override + public void onRecord(Value[] fields) { + handler.onRecord(fields); + } + + @Override + public void onError(Throwable throwable) { + updateState(throwable); + handler.onError(throwable); + } + + @Override + public void onSummary(PullSummary success) { + handler.onPullSummary(success); + } + }))) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage discard(long qid, long number) { + return executeInEventLoop(() -> messageWriters.add( + handler -> protocol.discard(this.connection, qid, number, new MessageHandler<>() { + @Override + public void onError(Throwable throwable) { + updateState(throwable); + handler.onError(throwable); + } + + @Override + public void onSummary(DiscardSummary summary) { + handler.onDiscardSummary(summary); + } + }))) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage commit() { + return executeInEventLoop(() -> + messageWriters.add(handler -> protocol.commitTransaction(connection, new MessageHandler<>() { + @Override + public void onError(Throwable throwable) { + updateState(throwable); + handler.onError(throwable); + } + + @Override + public void onSummary(String bookmark) { + handler.onCommitSummary(() -> Optional.ofNullable(bookmark)); + } + }))) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage rollback() { + return executeInEventLoop(() -> + messageWriters.add(handler -> protocol.rollbackTransaction(connection, new MessageHandler<>() { + @Override + public void onError(Throwable throwable) { + updateState(throwable); + handler.onError(throwable); + } + + @Override + public void onSummary(Void summary) { + handler.onRollbackSummary(null); + } + }))) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage reset() { + return executeInEventLoop( + () -> messageWriters.add(handler -> protocol.reset(connection, new MessageHandler<>() { + @Override + public void onError(Throwable throwable) { + updateState(throwable); + handler.onError(throwable); + } + + @Override + public void onSummary(Void summary) { + stateRef.set(BoltConnectionState.OPEN); + handler.onResetSummary(null); + } + }))) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage logoff() { + return executeInEventLoop( + () -> messageWriters.add(handler -> protocol.logoff(connection, new MessageHandler<>() { + @Override + public void onError(Throwable throwable) { + updateState(throwable); + handler.onError(throwable); + } + + @Override + public void onSummary(Void summary) { + authDataRef.set(new CompletableFuture<>()); + handler.onLogoffSummary(null); + } + }))) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage logon(Map authMap) { + return executeInEventLoop(() -> messageWriters.add( + handler -> protocol.logon(connection, authMap, clock, new MessageHandler<>() { + @Override + public void onError(Throwable throwable) { + updateState(throwable); + handler.onError(throwable); + } + + @Override + public void onSummary(Void summary) { + authDataRef.get().complete(new AuthDataImpl(authMap, clock.millis())); + handler.onLogonSummary(null); + } + }))) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage telemetry(TelemetryApi telemetryApi) { + return executeInEventLoop(() -> { + if (!telemetrySupported()) { + throw new UnsupportedFeatureException("telemetry not supported"); + } else { + messageWriters.add(handler -> + protocol.telemetry(connection, telemetryApi.getValue(), new MessageHandler<>() { + @Override + public void onError(Throwable throwable) { + updateState(throwable); + handler.onError(throwable); + } + + @Override + public void onSummary(Void summary) { + handler.onTelemetrySummary(null); + } + })); + } + }) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage clear() { + return executeInEventLoop(messageWriters::clear).thenApply(ignored -> this); + } + + @Override + public CompletionStage flush(ResponseHandler handler) { + var flushFuture = new CompletableFuture(); + return executeInEventLoop(() -> { + if (connection.isOpen()) { + var flushStage = CompletableFuture.completedStage(null); + var responseHandler = new ResponseHandleImpl(handler, messageWriters.size()); + var messageWriterIterator = messageWriters.iterator(); + while (messageWriterIterator.hasNext()) { + var messageWriter = messageWriterIterator.next(); + messageWriterIterator.remove(); + flushStage = flushStage.thenCompose(ignored -> messageWriter.apply(responseHandler)); + } + flushStage.thenCompose(ignored -> connection.flush()).whenComplete((ignored, throwable) -> { + if (throwable != null) { + throwable = FutureUtil.completionExceptionCause(throwable); + if (throwable instanceof CodecException + && throwable.getCause() instanceof IOException) { + var serviceError = new ServiceUnavailableException( + "Connection to the database failed", throwable.getCause()); + forceClose("Connection has been closed due to encoding error") + .whenComplete((ignored1, ignored2) -> { + flushFuture.completeExceptionally(serviceError); + }); + } else { + flushFuture.completeExceptionally(throwable); + } + } else { + flushFuture.complete(null); + } + }); + } else { + throw new ServiceUnavailableException("Connection is closed"); + } + }) + .thenCompose(ignored -> flushFuture); + } + + @Override + public CompletionStage forceClose(String reason) { + if (stateRef.getAndSet(BoltConnectionState.CLOSED) != BoltConnectionState.CLOSED) { + try { + return connection.forceClose(reason).exceptionally(ignored -> null); + } catch (Throwable throwable) { + return CompletableFuture.completedStage(null); + } + } else { + return CompletableFuture.completedFuture(null); + } + } + + @Override + public CompletionStage close() { + if (stateRef.getAndSet(BoltConnectionState.CLOSED) != BoltConnectionState.CLOSED) { + try { + return connection.close().exceptionally(ignored -> null); + } catch (Throwable throwable) { + return CompletableFuture.completedStage(null); + } + } else { + return CompletableFuture.completedFuture(null); + } + } + + @Override + public BoltConnectionState state() { + var state = stateRef.get(); + if (state == BoltConnectionState.OPEN) { + if (!connection.isOpen()) { + state = BoltConnectionState.CLOSED; + } + } + return state; + } + + @Override + public CompletionStage authData() { + return authDataRef.get(); + } + + @Override + public String serverAgent() { + return serverAgent; + } + + @Override + public BoltServerAddress serverAddress() { + return serverAddress; + } + + @Override + public BoltProtocolVersion protocolVersion() { + return protocolVersion; + } + + @Override + public boolean telemetrySupported() { + return telemetrySupported; + } + + private CompletionStage executeInEventLoop(Runnable runnable) { + var executeStage = new CompletableFuture(); + Runnable stageCompletingRunnable = () -> { + try { + runnable.run(); + } catch (Throwable throwable) { + executeStage.completeExceptionally(throwable); + } + executeStage.complete(null); + }; + if (eventLoop.inEventLoop()) { + stageCompletingRunnable.run(); + } else { + try { + eventLoop.execute(stageCompletingRunnable); + } catch (Throwable throwable) { + executeStage.completeExceptionally(throwable); + } + } + return executeStage; + } + + private void updateState(Throwable throwable) { + if (throwable instanceof ServiceUnavailableException) { + stateRef.set(BoltConnectionState.CLOSED); + } else if (throwable instanceof Neo4jException) { + if (throwable instanceof AuthorizationExpiredException) { + stateRef.compareAndExchange(BoltConnectionState.OPEN, BoltConnectionState.ERROR); + } else { + stateRef.compareAndExchange(BoltConnectionState.OPEN, BoltConnectionState.FAILURE); + } + } else { + stateRef.updateAndGet(state -> switch (state) { + case OPEN, FAILURE, ERROR -> BoltConnectionState.ERROR; + case CLOSED -> BoltConnectionState.CLOSED; + }); + } + } + + private record AuthDataImpl(Map authMap, long authAckMillis) implements AuthData {} + + private static class ResponseHandleImpl implements ResponseHandler { + private final ResponseHandler delegate; + private final CompletableFuture summariesFuture = new CompletableFuture<>(); + private int expectedSummaries; + + private ResponseHandleImpl(ResponseHandler delegate, int expectedSummaries) { + this.delegate = Objects.requireNonNull(delegate); + this.expectedSummaries = expectedSummaries; + + summariesFuture.whenComplete((ignored1, ignored2) -> onComplete()); + } + + @Override + public void onError(Throwable throwable) { + if (!(throwable instanceof MessageIgnoredException)) { + runIgnoringError(() -> delegate.onError(throwable)); + if (!(throwable instanceof Neo4jException)) { + // assume unrecoverable error, ensure onComplete + expectedSummaries = 1; + } + } + handleSummary(); + } + + @Override + public void onBeginSummary(BeginSummary summary) { + runIgnoringError(() -> delegate.onBeginSummary(summary)); + handleSummary(); + } + + @Override + public void onRunSummary(RunSummary summary) { + runIgnoringError(() -> delegate.onRunSummary(summary)); + handleSummary(); + } + + @Override + public void onRecord(Value[] fields) { + runIgnoringError(() -> delegate.onRecord(fields)); + } + + @Override + public void onPullSummary(PullSummary summary) { + runIgnoringError(() -> delegate.onPullSummary(summary)); + handleSummary(); + } + + @Override + public void onDiscardSummary(DiscardSummary summary) { + runIgnoringError(() -> delegate.onDiscardSummary(summary)); + handleSummary(); + } + + @Override + public void onCommitSummary(CommitSummary summary) { + runIgnoringError(() -> delegate.onCommitSummary(summary)); + handleSummary(); + } + + @Override + public void onRollbackSummary(RollbackSummary summary) { + runIgnoringError(() -> delegate.onRollbackSummary(summary)); + handleSummary(); + } + + @Override + public void onResetSummary(ResetSummary summary) { + runIgnoringError(() -> delegate.onResetSummary(summary)); + handleSummary(); + } + + @Override + public void onRouteSummary(RouteSummary summary) { + runIgnoringError(() -> delegate.onRouteSummary(summary)); + handleSummary(); + } + + @Override + public void onLogoffSummary(LogoffSummary summary) { + runIgnoringError(() -> delegate.onLogoffSummary(summary)); + handleSummary(); + } + + @Override + public void onLogonSummary(LogonSummary summary) { + runIgnoringError(() -> delegate.onLogonSummary(summary)); + handleSummary(); + } + + @Override + public void onTelemetrySummary(TelemetrySummary summary) { + runIgnoringError(() -> delegate.onTelemetrySummary(summary)); + handleSummary(); + } + + @Override + public void onComplete() { + runIgnoringError(delegate::onComplete); + } + + private void handleSummary() { + expectedSummaries--; + if (expectedSummaries == 0) { + summariesFuture.complete(null); + } + } + + private void runIgnoringError(Runnable runnable) { + try { + runnable.run(); + } catch (Throwable ignored) { + } + } + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/ConnectionProvider.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/ConnectionProvider.java new file mode 100644 index 0000000000..683755f6d8 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/ConnectionProvider.java @@ -0,0 +1,48 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl; + +import java.util.Map; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import org.neo4j.driver.Value; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltAgent; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.MetricsListener; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.SecurityPlan; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; + +public interface ConnectionProvider { + + CompletionStage acquireConnection( + BoltServerAddress address, + SecurityPlan securityPlan, + RoutingContext routingContext, + String databaseName, + Map authMap, + BoltAgent boltAgent, + String userAgent, + AccessMode mode, + int connectTimeoutMillis, + String impersonatedUser, + CompletableFuture latestAuthMillisFuture, + NotificationConfig notificationConfig, + MetricsListener metricsListener); +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/FetchSizeUtil.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/ConnectionProviders.java similarity index 55% rename from driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/FetchSizeUtil.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/ConnectionProviders.java index 09e92a26f7..c34bc20954 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/FetchSizeUtil.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/ConnectionProviders.java @@ -14,17 +14,16 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers.pulln; +package org.neo4j.driver.internal.bolt.basicimpl; -public class FetchSizeUtil { - public static final long UNLIMITED_FETCH_SIZE = -1; - public static final long DEFAULT_FETCH_SIZE = 1000; +import io.netty.channel.EventLoopGroup; +import java.time.Clock; +import org.neo4j.driver.internal.bolt.api.DomainNameResolver; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; - public static long assertValidFetchSize(long size) { - if (size <= 0 && size != UNLIMITED_FETCH_SIZE) { - throw new IllegalArgumentException(String.format( - "The record fetch size may not be 0 or negative. Illegal record fetch size: %s.", size)); - } - return size; +public class ConnectionProviders { + static ConnectionProvider netty( + EventLoopGroup group, Clock clock, DomainNameResolver domainNameResolver, LoggingProvider logging) { + return new NettyConnectionProvider(group, clock, domainNameResolver, logging); } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/NettyBoltConnectionProvider.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/NettyBoltConnectionProvider.java new file mode 100644 index 0000000000..1784ca00d1 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/NettyBoltConnectionProvider.java @@ -0,0 +1,293 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl; + +import io.netty.channel.EventLoopGroup; +import io.netty.util.internal.logging.InternalLoggerFactory; +import java.time.Clock; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionException; +import java.util.concurrent.CompletionStage; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Consumer; +import java.util.function.Function; +import java.util.function.IntSupplier; +import java.util.function.Supplier; +import org.neo4j.driver.Value; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltAgent; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.DomainNameResolver; +import org.neo4j.driver.internal.bolt.api.ListenerEvent; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.MetricsListener; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.ResponseHandler; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.SecurityPlan; +import org.neo4j.driver.internal.bolt.api.exception.MinVersionAcquisitionException; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v4.BoltProtocolV4; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v51.BoltProtocolV51; + +public final class NettyBoltConnectionProvider implements BoltConnectionProvider { + private final LoggingProvider logging; + private final System.Logger log; + private final EventLoopGroup eventLoopGroup; + + private final ConnectionProvider connectionProvider; + + private BoltServerAddress address; + private SecurityPlan securityPlan; + + private RoutingContext routingContext; + private BoltAgent boltAgent; + private String userAgent; + private int connectTimeoutMillis; + private CompletableFuture closeFuture; + private MetricsListener metricsListener; + private final Clock clock; + + public NettyBoltConnectionProvider( + EventLoopGroup eventLoopGroup, + Clock clock, + DomainNameResolver domainNameResolver, + LoggingProvider logging) { + Objects.requireNonNull(eventLoopGroup); + this.clock = Objects.requireNonNull(clock); + this.logging = Objects.requireNonNull(logging); + this.log = logging.getLog(getClass()); + this.eventLoopGroup = Objects.requireNonNull(eventLoopGroup); + this.connectionProvider = ConnectionProviders.netty(eventLoopGroup, clock, domainNameResolver, logging); + } + + @Override + public CompletionStage init( + BoltServerAddress address, + SecurityPlan securityPlan, + RoutingContext routingContext, + BoltAgent boltAgent, + String userAgent, + int connectTimeoutMillis, + MetricsListener metricsListener) { + this.address = address; + this.securityPlan = securityPlan; + this.routingContext = routingContext; + this.boltAgent = boltAgent; + this.userAgent = userAgent; + this.connectTimeoutMillis = connectTimeoutMillis; + this.metricsListener = new MetricsListener() { + @Override + public void beforeCreating(String poolId, ListenerEvent creatingEvent) {} + + @Override + public void afterCreated(String poolId, ListenerEvent creatingEvent) {} + + @Override + public void afterFailedToCreate(String poolId) {} + + @Override + public void afterClosed(String poolId) {} + + @Override + public void beforeAcquiringOrCreating(String poolId, ListenerEvent acquireEvent) {} + + @Override + public void afterAcquiringOrCreating(String poolId) {} + + @Override + public void afterAcquiredOrCreated(String poolId, ListenerEvent acquireEvent) {} + + @Override + public void afterTimedOutToAcquireOrCreate(String poolId) {} + + @Override + public void afterConnectionCreated(String poolId, ListenerEvent inUseEvent) {} + + @Override + public void afterConnectionReleased(String poolId, ListenerEvent inUseEvent) {} + + @Override + public ListenerEvent createListenerEvent() { + return new ListenerEvent<>() { + @Override + public void start() {} + + @Override + public Object getSample() { + return null; + } + }; + } + + @Override + public void registerPoolMetrics( + String poolId, + BoltServerAddress serverAddress, + IntSupplier inUseSupplier, + IntSupplier idleSupplier) {} + + @Override + public void removePoolMetrics(String poolId) {} + }; + InternalLoggerFactory.setDefaultFactory(new NettyLogging(logging)); + return CompletableFuture.completedStage(null); + } + + @Override + public CompletionStage connect( + DatabaseName databaseName, + Supplier>> authMapStageSupplier, + AccessMode mode, + Set bookmarks, + String impersonatedUser, + BoltProtocolVersion minVersion, + NotificationConfig notificationConfig, + Consumer databaseNameConsumer) { + synchronized (this) { + if (closeFuture != null) { + return CompletableFuture.failedFuture(new IllegalStateException("Connection provider is closed.")); + } + } + + var latestAuthMillisFuture = new CompletableFuture(); + var authMapRef = new AtomicReference>(); + List>> messagePipeline = new ArrayList<>(); + return authMapStageSupplier + .get() + .thenCompose(authMap -> { + authMapRef.set(authMap); + return this.connectionProvider.acquireConnection( + address, + securityPlan, + routingContext, + databaseName != null ? databaseName.databaseName().orElse(null) : null, + authMap, + boltAgent, + userAgent, + mode, + connectTimeoutMillis, + impersonatedUser, + latestAuthMillisFuture, + notificationConfig, + metricsListener); + }) + .thenCompose(connection -> { + if (minVersion != null + && minVersion.compareTo(connection.protocol().version()) > 0) { + return connection + .close() + .thenCompose( + (ignored) -> CompletableFuture.failedStage(new MinVersionAcquisitionException( + "lower version", + connection.protocol().version()))); + } else { + return CompletableFuture.completedStage(connection); + } + }) + .handle((connection, throwable) -> { + if (throwable != null) { + log.log(System.Logger.Level.DEBUG, "Failed to establish BoltConnection " + address, throwable); + throw new CompletionException(throwable); + } else { + databaseNameConsumer.accept(databaseName); + return new BoltConnectionImpl( + connection.protocol(), + connection, + connection.eventLoop(), + authMapRef.get(), + latestAuthMillisFuture, + routingContext, + clock, + logging); + } + }); + } + + @Override + public CompletionStage verifyConnectivity(Map authMap) { + return connect( + null, + () -> CompletableFuture.completedStage(authMap), + AccessMode.WRITE, + Collections.emptySet(), + null, + null, + null, + (ignored) -> {}) + .thenCompose(BoltConnection::close); + } + + @Override + public CompletionStage supportsMultiDb(Map authMap) { + return connect( + null, + () -> CompletableFuture.completedStage(authMap), + AccessMode.WRITE, + Collections.emptySet(), + null, + null, + null, + (ignored) -> {}) + .thenCompose(boltConnection -> { + var supports = boltConnection.protocolVersion().compareTo(BoltProtocolV4.VERSION) >= 0; + return boltConnection.close().thenApply(ignored -> supports); + }); + } + + @Override + public CompletionStage supportsSessionAuth(Map authMap) { + return connect( + null, + () -> CompletableFuture.completedStage(authMap), + AccessMode.WRITE, + Collections.emptySet(), + null, + null, + null, + (ignored) -> {}) + .thenCompose(boltConnection -> { + var supports = BoltProtocolV51.VERSION.compareTo(boltConnection.protocolVersion()) <= 0; + return boltConnection.close().thenApply(ignored -> supports); + }); + } + + @Override + public CompletionStage close() { + CompletableFuture closeFuture; + synchronized (this) { + if (this.closeFuture == null) { + this.closeFuture = new CompletableFuture<>(); + eventLoopGroup + .shutdownGracefully(200, 15_000, TimeUnit.MILLISECONDS) + .addListener(future -> this.closeFuture.complete(null)); + } + closeFuture = this.closeFuture; + } + return closeFuture; + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/NettyConnectionProvider.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/NettyConnectionProvider.java new file mode 100644 index 0000000000..7fc3202c97 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/NettyConnectionProvider.java @@ -0,0 +1,188 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl; + +import static java.util.Objects.requireNonNull; + +import io.netty.bootstrap.Bootstrap; +import io.netty.channel.ChannelFuture; +import io.netty.channel.ChannelFutureListener; +import io.netty.channel.ChannelOption; +import io.netty.channel.ChannelPromise; +import io.netty.channel.EventLoopGroup; +import io.netty.channel.socket.nio.NioSocketChannel; +import io.netty.resolver.AddressResolverGroup; +import java.net.InetSocketAddress; +import java.net.SocketAddress; +import java.time.Clock; +import java.util.Map; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import org.neo4j.driver.Value; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltAgent; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.DomainNameResolver; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.MetricsListener; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.SecurityPlan; +import org.neo4j.driver.internal.bolt.basicimpl.async.NetworkConnection; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelConnectedListener; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelPipelineBuilderImpl; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.HandshakeCompletedListener; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.NettyChannelInitializer; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.NettyDomainNameResolverGroup; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.ConnectTimeoutHandler; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; + +public final class NettyConnectionProvider implements ConnectionProvider { + private final EventLoopGroup eventLoopGroup; + private final Clock clock; + private final DomainNameResolver domainNameResolver; + private final AddressResolverGroup addressResolverGroup; + + private final LoggingProvider logging; + + public NettyConnectionProvider( + EventLoopGroup eventLoopGroup, + Clock clock, + DomainNameResolver domainNameResolver, + LoggingProvider logging) { + this.eventLoopGroup = eventLoopGroup; + this.clock = clock; + this.domainNameResolver = requireNonNull(domainNameResolver); + this.addressResolverGroup = new NettyDomainNameResolverGroup(this.domainNameResolver); + this.logging = logging; + } + + @Override + public CompletionStage acquireConnection( + BoltServerAddress address, + SecurityPlan securityPlan, + RoutingContext routingContext, + String databaseName, + Map authMap, + BoltAgent boltAgent, + String userAgent, + AccessMode mode, + int connectTimeoutMillis, + String impersonatedUser, + CompletableFuture latestAuthMillisFuture, + NotificationConfig notificationConfig, + MetricsListener metricsListener) { + var bootstrap = new Bootstrap(); + bootstrap + .group(this.eventLoopGroup) + .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, connectTimeoutMillis) + .channel(NioSocketChannel.class) + .resolver(addressResolverGroup) + .handler(new NettyChannelInitializer(address, securityPlan, connectTimeoutMillis, clock, logging)); + + SocketAddress socketAddress; + try { + socketAddress = + new InetSocketAddress(domainNameResolver.resolve(address.connectionHost())[0], address.port()); + } catch (Throwable t) { + socketAddress = InetSocketAddress.createUnresolved(address.connectionHost(), address.port()); + } + + var connectedFuture = bootstrap.connect(socketAddress); + + var channel = connectedFuture.channel(); + var handshakeCompleted = channel.newPromise(); + var connectionInitialized = channel.newPromise(); + + installChannelConnectedListeners(address, connectedFuture, handshakeCompleted, connectTimeoutMillis); + installHandshakeCompletedListeners( + handshakeCompleted, + connectionInitialized, + address, + routingContext, + authMap, + boltAgent, + userAgent, + latestAuthMillisFuture, + notificationConfig); + + var future = new CompletableFuture(); + connectionInitialized.addListener((ChannelFutureListener) f -> { + var throwable = f.cause(); + if (throwable != null) { + future.completeExceptionally(throwable); + } else { + var connection = new NetworkConnection(channel, metricsListener, logging); + future.complete(connection); + } + }); + return future; + } + + private void installChannelConnectedListeners( + BoltServerAddress address, + ChannelFuture channelConnected, + ChannelPromise handshakeCompleted, + int connectTimeoutMillis) { + var pipeline = channelConnected.channel().pipeline(); + + // add timeout handler to the pipeline when channel is connected. it's needed to + // limit amount of time code + // spends in TLS and Bolt handshakes. prevents infinite waiting when database does + // not respond + channelConnected.addListener(future -> pipeline.addFirst(new ConnectTimeoutHandler(connectTimeoutMillis))); + + // add listener that sends Bolt handshake bytes when channel is connected + channelConnected.addListener( + new ChannelConnectedListener(address, new ChannelPipelineBuilderImpl(), handshakeCompleted, logging)); + } + + private void installHandshakeCompletedListeners( + ChannelPromise handshakeCompleted, + ChannelPromise connectionInitialized, + BoltServerAddress address, + RoutingContext routingContext, + Map authMap, + BoltAgent boltAgent, + String userAgent, + CompletableFuture latestAuthMillisFuture, + NotificationConfig notificationConfig) { + var pipeline = handshakeCompleted.channel().pipeline(); + + // remove timeout handler from the pipeline once TLS and Bolt handshakes are + // completed. regular protocol + // messages will flow next and we do not want to have read timeout for them + handshakeCompleted.addListener(future -> { + if (future.isSuccess()) { + pipeline.remove(ConnectTimeoutHandler.class); + } + }); + + // add listener that sends an INIT message. connection is now fully established. + // channel pipeline is fully + // set to send/receive messages for a selected protocol version + handshakeCompleted.addListener(new HandshakeCompletedListener( + authMap, + userAgent, + boltAgent, + routingContext, + connectionInitialized, + notificationConfig, + this.clock, + latestAuthMillisFuture)); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/logging/NettyLogger.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/NettyLogger.java similarity index 65% rename from driver/src/main/java/org/neo4j/driver/internal/logging/NettyLogger.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/NettyLogger.java index 43e27574d6..a55f0c1b39 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/logging/NettyLogger.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/NettyLogger.java @@ -14,85 +14,84 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.logging; +package org.neo4j.driver.internal.bolt.basicimpl; import static java.lang.String.format; import io.netty.util.internal.logging.AbstractInternalLogger; import java.io.Serial; import java.util.regex.Pattern; -import org.neo4j.driver.Logger; public class NettyLogger extends AbstractInternalLogger { @Serial private static final long serialVersionUID = -1466889786216191159L; - private final Logger log; + private final System.Logger log; private static final Pattern PLACE_HOLDER_PATTERN = Pattern.compile("\\{}"); - public NettyLogger(String name, Logger log) { + public NettyLogger(String name, System.Logger log) { super(name); this.log = log; } @Override public boolean isTraceEnabled() { - return log.isTraceEnabled(); + return log.isLoggable(System.Logger.Level.TRACE); } @Override public void trace(String msg) { - log.trace(msg); + log.log(System.Logger.Level.TRACE, msg); } @Override public void trace(String format, Object arg) { - log.trace(toDriverLoggerFormat(format), arg); + log.log(System.Logger.Level.TRACE, toDriverLoggerFormat(format), arg); } @Override public void trace(String format, Object argA, Object argB) { - log.trace(toDriverLoggerFormat(format), argA, argB); + log.log(System.Logger.Level.TRACE, toDriverLoggerFormat(format), argA, argB); } @Override public void trace(String format, Object... arguments) { - log.trace(toDriverLoggerFormat(format), arguments); + log.log(System.Logger.Level.TRACE, toDriverLoggerFormat(format), arguments); } @Override public void trace(String msg, Throwable t) { - log.trace("%s%n%s", msg, t); + log.log(System.Logger.Level.TRACE, "%s%n%s", msg, t); } @Override public boolean isDebugEnabled() { - return log.isDebugEnabled(); + return log.isLoggable(System.Logger.Level.DEBUG); } @Override public void debug(String msg) { - log.debug(msg); + log.log(System.Logger.Level.DEBUG, msg); } @Override public void debug(String format, Object arg) { - log.debug(toDriverLoggerFormat(format), arg); + log.log(System.Logger.Level.DEBUG, toDriverLoggerFormat(format), arg); } @Override public void debug(String format, Object argA, Object argB) { - log.debug(toDriverLoggerFormat(format), argA, argB); + log.log(System.Logger.Level.DEBUG, toDriverLoggerFormat(format), argA, argB); } @Override public void debug(String format, Object... arguments) { - log.debug(toDriverLoggerFormat(format), arguments); + log.log(System.Logger.Level.DEBUG, toDriverLoggerFormat(format), arguments); } @Override public void debug(String msg, Throwable t) { - log.debug("%s%n%s", msg, t); + log.log(System.Logger.Level.DEBUG, "%s%n%s", msg, t); } @Override @@ -102,27 +101,27 @@ public boolean isInfoEnabled() { @Override public void info(String msg) { - log.info(msg); + log.log(System.Logger.Level.INFO, msg); } @Override public void info(String format, Object arg) { - log.info(toDriverLoggerFormat(format), arg); + log.log(System.Logger.Level.INFO, toDriverLoggerFormat(format), arg); } @Override public void info(String format, Object argA, Object argB) { - log.info(toDriverLoggerFormat(format), argA, argB); + log.log(System.Logger.Level.INFO, toDriverLoggerFormat(format), argA, argB); } @Override public void info(String format, Object... arguments) { - log.info(toDriverLoggerFormat(format), arguments); + log.log(System.Logger.Level.INFO, toDriverLoggerFormat(format), arguments); } @Override public void info(String msg, Throwable t) { - log.info("%s%n%s", msg, t); + log.log(System.Logger.Level.INFO, "%s%n%s", msg, t); } @Override @@ -132,27 +131,27 @@ public boolean isWarnEnabled() { @Override public void warn(String msg) { - log.warn(msg); + log.log(System.Logger.Level.WARNING, msg); } @Override public void warn(String format, Object arg) { - log.warn(toDriverLoggerFormat(format), arg); + log.log(System.Logger.Level.WARNING, toDriverLoggerFormat(format), arg); } @Override public void warn(String format, Object... arguments) { - log.warn(toDriverLoggerFormat(format), arguments); + log.log(System.Logger.Level.WARNING, toDriverLoggerFormat(format), arguments); } @Override public void warn(String format, Object argA, Object argB) { - log.warn(toDriverLoggerFormat(format), argA, argB); + log.log(System.Logger.Level.WARNING, toDriverLoggerFormat(format), argA, argB); } @Override public void warn(String msg, Throwable t) { - log.warn("%s%n%s", msg, t); + log.log(System.Logger.Level.WARNING, "%s%n%s", msg, t); } @Override @@ -162,7 +161,7 @@ public boolean isErrorEnabled() { @Override public void error(String msg) { - log.error(msg, null); + log.log(System.Logger.Level.ERROR, msg, (Throwable) null); } @Override @@ -179,7 +178,7 @@ public void error(String format, Object argA, Object argB) { public void error(String format, Object... arguments) { format = toDriverLoggerFormat(format); if (arguments.length == 0) { - log.error(format, null); + log.log(System.Logger.Level.ERROR, format, (Throwable) null); return; } @@ -187,13 +186,13 @@ public void error(String format, Object... arguments) { if (arg instanceof Throwable) { // still give all arguments to string format, // for the worst case, the redundant parameter will be ignored. - log.error(format(format, arguments), (Throwable) arg); + log.log(System.Logger.Level.ERROR, format(format, arguments), (Throwable) arg); } } @Override public void error(String msg, Throwable t) { - log.error(msg, t); + log.log(System.Logger.Level.ERROR, msg, t); } private String toDriverLoggerFormat(String format) { diff --git a/driver/src/main/java/org/neo4j/driver/internal/logging/NettyLogging.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/NettyLogging.java similarity index 84% rename from driver/src/main/java/org/neo4j/driver/internal/logging/NettyLogging.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/NettyLogging.java index 6d6a7ed577..531e23a32a 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/logging/NettyLogging.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/NettyLogging.java @@ -14,19 +14,19 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.logging; +package org.neo4j.driver.internal.bolt.basicimpl; import io.netty.util.internal.logging.InternalLogger; import io.netty.util.internal.logging.InternalLoggerFactory; -import org.neo4j.driver.Logging; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; /** * This is the logging factory to delegate netty's logging to our logging system */ public class NettyLogging extends InternalLoggerFactory { - private final Logging logging; + private final LoggingProvider logging; - public NettyLogging(Logging logging) { + public NettyLogging(LoggingProvider logging) { this.logging = logging; } diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/NetworkConnection.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/NetworkConnection.java new file mode 100644 index 0000000000..5b8b66dd11 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/NetworkConnection.java @@ -0,0 +1,229 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.async; + +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.poolId; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setTerminationReason; +import static org.neo4j.driver.internal.bolt.basicimpl.util.LockUtil.executeWithLock; + +import io.netty.channel.Channel; +import io.netty.channel.ChannelFutureListener; +import io.netty.channel.ChannelHandler; +import io.netty.channel.EventLoop; +import java.util.Collections; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ListenerEvent; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.MetricsListener; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.ConnectionReadTimeoutHandler; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.NoOpResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; + +/** + * This connection represents a simple network connection to a remote server. It wraps a channel obtained from a connection pool. The life cycle of this + * connection start from the moment the channel is borrowed out of the pool and end at the time the connection is released back to the pool. + */ +public class NetworkConnection implements Connection { + private final System.Logger log; + private final Lock lock; + private final Channel channel; + private final InboundMessageDispatcher messageDispatcher; + private final String serverAgent; + private final BoltServerAddress serverAddress; + private final boolean telemetryEnabled; + private final BoltProtocol protocol; + private final ListenerEvent inUseEvent; + + private final Long connectionReadTimeout; + + private ChannelHandler connectionReadTimeoutHandler; + + public NetworkConnection(Channel channel, MetricsListener metricsListener, LoggingProvider logging) { + this.log = logging.getLog(getClass()); + this.lock = new ReentrantLock(); + this.channel = channel; + this.messageDispatcher = ChannelAttributes.messageDispatcher(channel); + this.serverAgent = ChannelAttributes.serverAgent(channel); + this.serverAddress = ChannelAttributes.serverAddress(channel); + this.telemetryEnabled = ChannelAttributes.telemetryEnabled(channel); + this.protocol = BoltProtocol.forChannel(channel); + this.inUseEvent = metricsListener.createListenerEvent(); + this.connectionReadTimeout = + ChannelAttributes.connectionReadTimeout(channel).orElse(null); + metricsListener.afterConnectionCreated(poolId(this.channel), this.inUseEvent); + } + + @Override + public boolean isOpen() { + return executeWithLock(lock, channel::isOpen); + } + + @Override + public void enableAutoRead() { + if (isOpen()) { + setAutoRead(true); + } + } + + @Override + public void disableAutoRead() { + if (isOpen()) { + setAutoRead(false); + } + } + + @Override + public CompletionStage write(Message message, ResponseHandler handler) { + return writeMessageInEventLoop(message, handler); + } + + @Override + public CompletionStage flush() { + var future = new CompletableFuture(); + channel.eventLoop().execute(() -> { + channel.flush(); + future.complete(null); + }); + return future; + } + + @Override + public boolean isTelemetryEnabled() { + return telemetryEnabled; + } + + @Override + public String serverAgent() { + return serverAgent; + } + + @Override + public BoltServerAddress serverAddress() { + return serverAddress; + } + + @Override + public BoltProtocol protocol() { + return protocol; + } + + @Override + public CompletionStage forceClose(String reason) { + var fut = new CompletableFuture(); + eventLoop().execute(() -> { + setTerminationReason(channel, reason); + channel.close().addListener((ChannelFutureListener) future -> { + if (future.isSuccess()) { + fut.complete(null); + } else { + var cause = future.cause(); + if (cause == null) { + cause = new IllegalStateException("Unexpected state"); + } + fut.completeExceptionally(cause); + } + }); + }); + return fut; + } + + @Override + public CompletionStage close() { + var closeFuture = new CompletableFuture(); + writeMessageInEventLoop(GoodbyeMessage.GOODBYE, new NoOpResponseHandler()) + .thenCompose(ignored -> flush()) + .whenComplete((ignored, throwable) -> { + if (throwable == null) { + this.channel.close().addListener((ChannelFutureListener) future -> { + if (future.isSuccess()) { + closeFuture.complete(null); + } else { + closeFuture.completeExceptionally(future.cause()); + } + }); + } else { + closeFuture.completeExceptionally(throwable); + } + }); + return closeFuture; + } + + @Override + public EventLoop eventLoop() { + return channel.eventLoop(); + } + + private CompletionStage writeMessageInEventLoop(Message message, ResponseHandler handler) { + var future = new CompletableFuture(); + Runnable runnable = () -> { + if (messageDispatcher.fatalErrorOccurred() && GoodbyeMessage.GOODBYE.equals(message)) { + future.complete(null); + handler.onSuccess(Collections.emptyMap()); + channel.close(); + return; + } + messageDispatcher.enqueue(handler); + channel.write(message).addListener(writeFuture -> { + if (writeFuture.isSuccess()) { + registerConnectionReadTimeout(channel); + } else { + future.completeExceptionally(writeFuture.cause()); + } + }); + future.complete(null); + }; + if (channel.eventLoop().inEventLoop()) { + runnable.run(); + } else { + channel.eventLoop().execute(runnable); + } + return future; + } + + private void setAutoRead(boolean value) { + channel.config().setAutoRead(value); + } + + private void registerConnectionReadTimeout(Channel channel) { + if (!channel.eventLoop().inEventLoop()) { + throw new IllegalStateException("This method may only be called in the EventLoop"); + } + + if (connectionReadTimeout != null && connectionReadTimeoutHandler == null) { + connectionReadTimeoutHandler = new ConnectionReadTimeoutHandler(connectionReadTimeout, TimeUnit.SECONDS); + channel.pipeline().addFirst(connectionReadTimeoutHandler); + log.log(System.Logger.Level.DEBUG, "Added ConnectionReadTimeoutHandler"); + messageDispatcher.setBeforeLastHandlerHook((messageType) -> { + channel.pipeline().remove(connectionReadTimeoutHandler); + connectionReadTimeoutHandler = null; + messageDispatcher.setBeforeLastHandlerHook(null); + log.log(System.Logger.Level.DEBUG, "Removed ConnectionReadTimeoutHandler"); + }); + } + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/AuthorizationStateListener.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/AuthorizationStateListener.java similarity index 92% rename from driver/src/main/java/org/neo4j/driver/internal/async/connection/AuthorizationStateListener.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/AuthorizationStateListener.java index f83256a335..bf223c9e9a 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/AuthorizationStateListener.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/AuthorizationStateListener.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; /** * Listener for authorization info state maintained on the server side. diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/BoltProtocolUtil.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/BoltProtocolUtil.java similarity index 80% rename from driver/src/main/java/org/neo4j/driver/internal/async/connection/BoltProtocolUtil.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/BoltProtocolUtil.java index 268d913b97..f266d536aa 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/BoltProtocolUtil.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/BoltProtocolUtil.java @@ -14,20 +14,20 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; import static io.netty.buffer.Unpooled.copyInt; import static io.netty.buffer.Unpooled.unreleasableBuffer; import static java.lang.Integer.toHexString; import io.netty.buffer.ByteBuf; -import org.neo4j.driver.internal.messaging.BoltProtocolVersion; -import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3; -import org.neo4j.driver.internal.messaging.v41.BoltProtocolV41; -import org.neo4j.driver.internal.messaging.v42.BoltProtocolV42; -import org.neo4j.driver.internal.messaging.v44.BoltProtocolV44; -import org.neo4j.driver.internal.messaging.v5.BoltProtocolV5; -import org.neo4j.driver.internal.messaging.v54.BoltProtocolV54; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v3.BoltProtocolV3; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v41.BoltProtocolV41; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v42.BoltProtocolV42; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v44.BoltProtocolV44; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v5.BoltProtocolV5; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v54.BoltProtocolV54; public final class BoltProtocolUtil { public static final int BOLT_MAGIC_PREAMBLE = 0x6060B017; diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/BootstrapFactory.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/BootstrapFactory.java similarity index 95% rename from driver/src/main/java/org/neo4j/driver/internal/async/connection/BootstrapFactory.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/BootstrapFactory.java index 4809764be1..aa4271fc13 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/BootstrapFactory.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/BootstrapFactory.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; import io.netty.bootstrap.Bootstrap; import io.netty.channel.ChannelOption; diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelAttributes.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelAttributes.java similarity index 90% rename from driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelAttributes.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelAttributes.java index ac2eaaf988..a2efecedb2 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelAttributes.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelAttributes.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; import static io.netty.util.AttributeKey.newInstance; @@ -25,11 +25,10 @@ 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; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltPatchesListener; public final class ChannelAttributes { private static final AttributeKey CONNECTION_ID = newInstance("connectionId"); @@ -46,7 +45,7 @@ public final class ChannelAttributes { 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"); + // private static final AttributeKey AUTH_CONTEXT = newInstance("authContext"); // configuration hints provided by the server private static final AttributeKey CONNECTION_READ_TIMEOUT = newInstance("connectionReadTimeout"); @@ -166,13 +165,13 @@ public static void setHelloStage(Channel channel, CompletionStage helloSta 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); - } + // public static AuthContext authContext(Channel channel) { + // return get(channel, AUTH_CONTEXT); + // } + // + // public static void setAuthContext(Channel channel, AuthContext authContext) { + // setOnce(channel, AUTH_CONTEXT, authContext); + // } public static void setTelemetryEnabled(Channel channel, Boolean telemetryEnabled) { setOnce(channel, TELEMETRY_ENABLED, telemetryEnabled); diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelConnectedListener.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelConnectedListener.java similarity index 60% rename from driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelConnectedListener.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelConnectedListener.java index fdc602e95f..a74cb070c9 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelConnectedListener.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelConnectedListener.java @@ -14,32 +14,32 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; import static java.lang.String.format; -import static org.neo4j.driver.internal.async.connection.BoltProtocolUtil.handshakeBuf; -import static org.neo4j.driver.internal.async.connection.BoltProtocolUtil.handshakeString; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.BoltProtocolUtil.handshakeString; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelFutureListener; import io.netty.channel.ChannelPromise; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; +import javax.net.ssl.SSLHandshakeException; +import org.neo4j.driver.exceptions.SecurityException; import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.logging.ChannelActivityLogger; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.logging.ChannelActivityLogger; public class ChannelConnectedListener implements ChannelFutureListener { private final BoltServerAddress address; private final ChannelPipelineBuilder pipelineBuilder; private final ChannelPromise handshakeCompletedPromise; - private final Logging logging; + private final LoggingProvider logging; public ChannelConnectedListener( BoltServerAddress address, ChannelPipelineBuilder pipelineBuilder, ChannelPromise handshakeCompletedPromise, - Logging logging) { + LoggingProvider logging) { this.address = address; this.pipelineBuilder = pipelineBuilder; this.handshakeCompletedPromise = handshakeCompletedPromise; @@ -49,15 +49,26 @@ public ChannelConnectedListener( @Override public void operationComplete(ChannelFuture future) { var channel = future.channel(); - Logger log = new ChannelActivityLogger(channel, logging, getClass()); + var log = new ChannelActivityLogger(channel, logging, getClass()); if (future.isSuccess()) { - log.trace("Channel %s connected, initiating bolt handshake", channel); + log.log(System.Logger.Level.TRACE, "Channel %s connected, initiating bolt handshake", channel); var pipeline = channel.pipeline(); pipeline.addLast(new HandshakeHandler(pipelineBuilder, handshakeCompletedPromise, logging)); - log.debug("C: [Bolt Handshake] %s", handshakeString()); - channel.writeAndFlush(handshakeBuf(), channel.voidPromise()); + log.log(System.Logger.Level.DEBUG, "C: [Bolt Handshake] %s", handshakeString()); + channel.writeAndFlush(BoltProtocolUtil.handshakeBuf()).addListener(f -> { + if (!f.isSuccess()) { + var error = f.cause(); + if (error instanceof SSLHandshakeException) { + error = new SecurityException("Failed to establish secured connection with the server", error); + } else { + error = new ServiceUnavailableException( + String.format("Unable to write Bolt handshake to %s.", this.address), error); + } + this.handshakeCompletedPromise.setFailure(error); + } + }); } else { handshakeCompletedPromise.setFailure(databaseUnavailableError(address, future.cause())); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelPipelineBuilder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelPipelineBuilder.java similarity index 77% rename from driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelPipelineBuilder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelPipelineBuilder.java index 6bca77d134..99079b7145 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelPipelineBuilder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelPipelineBuilder.java @@ -14,12 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; import io.netty.channel.ChannelPipeline; -import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; public interface ChannelPipelineBuilder { - void build(MessageFormat messageFormat, ChannelPipeline pipeline, Logging logging); + void build(MessageFormat messageFormat, ChannelPipeline pipeline, LoggingProvider logging); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelPipelineBuilderImpl.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelPipelineBuilderImpl.java similarity index 67% rename from driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelPipelineBuilderImpl.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelPipelineBuilderImpl.java index 7b98303813..1b4f905ea7 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/ChannelPipelineBuilderImpl.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelPipelineBuilderImpl.java @@ -14,22 +14,22 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.addBoltPatchesListener; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.addBoltPatchesListener; import io.netty.channel.ChannelPipeline; -import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.async.inbound.ChannelErrorHandler; -import org.neo4j.driver.internal.async.inbound.ChunkDecoder; -import org.neo4j.driver.internal.async.inbound.InboundMessageHandler; -import org.neo4j.driver.internal.async.inbound.MessageDecoder; -import org.neo4j.driver.internal.async.outbound.OutboundMessageHandler; -import org.neo4j.driver.internal.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.ChannelErrorHandler; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.ChunkDecoder; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.MessageDecoder; +import org.neo4j.driver.internal.bolt.basicimpl.async.outbound.OutboundMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; public class ChannelPipelineBuilderImpl implements ChannelPipelineBuilder { @Override - public void build(MessageFormat messageFormat, ChannelPipeline pipeline, Logging logging) { + public void build(MessageFormat messageFormat, ChannelPipeline pipeline, LoggingProvider logging) { // inbound handlers pipeline.addLast(new ChunkDecoder(logging)); pipeline.addLast(new MessageDecoder()); diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/EventLoopGroupFactory.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/EventLoopGroupFactory.java similarity index 98% rename from driver/src/main/java/org/neo4j/driver/internal/async/connection/EventLoopGroupFactory.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/EventLoopGroupFactory.java index ad440d13a5..fd3bce6765 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/EventLoopGroupFactory.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/EventLoopGroupFactory.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; import io.netty.bootstrap.Bootstrap; import io.netty.channel.Channel; diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/HandshakeCompletedListener.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/HandshakeCompletedListener.java new file mode 100644 index 0000000000..460ae3fd56 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/HandshakeCompletedListener.java @@ -0,0 +1,80 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.async.connection; + +import static java.util.Objects.requireNonNull; + +import io.netty.channel.ChannelFuture; +import io.netty.channel.ChannelFutureListener; +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.internal.bolt.api.BoltAgent; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; + +public class HandshakeCompletedListener implements ChannelFutureListener { + private final Map authMap; + private final String userAgent; + private final BoltAgent boltAgent; + private final RoutingContext routingContext; + private final ChannelPromise connectionInitializedPromise; + private final NotificationConfig notificationConfig; + private final Clock clock; + private final CompletableFuture latestAuthMillisFuture; + + public HandshakeCompletedListener( + Map authMap, + String userAgent, + BoltAgent boltAgent, + RoutingContext routingContext, + ChannelPromise connectionInitializedPromise, + NotificationConfig notificationConfig, + Clock clock, + CompletableFuture latestAuthMillisFuture) { + requireNonNull(clock, "clock must not be null"); + this.authMap = authMap; + this.userAgent = requireNonNull(userAgent); + this.boltAgent = requireNonNull(boltAgent); + this.routingContext = routingContext; + this.connectionInitializedPromise = requireNonNull(connectionInitializedPromise); + this.notificationConfig = notificationConfig; + this.clock = clock; + this.latestAuthMillisFuture = latestAuthMillisFuture; + } + + @Override + public void operationComplete(ChannelFuture future) { + if (future.isSuccess()) { + var protocol = BoltProtocol.forChannel(future.channel()); + protocol.initializeChannel( + userAgent, + boltAgent, + authMap, + routingContext, + connectionInitializedPromise, + notificationConfig, + clock, + latestAuthMillisFuture); + } else { + connectionInitializedPromise.setFailure(future.cause()); + } + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/HandshakeHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/HandshakeHandler.java similarity index 86% rename from driver/src/main/java/org/neo4j/driver/internal/async/connection/HandshakeHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/HandshakeHandler.java index 1b41c73679..15ce047751 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/HandshakeHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/HandshakeHandler.java @@ -14,10 +14,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; -import static org.neo4j.driver.internal.async.connection.BoltProtocolUtil.NO_PROTOCOL_VERSION; -import static org.neo4j.driver.internal.messaging.BoltProtocolVersion.isHttp; +import static org.neo4j.driver.internal.bolt.api.BoltProtocolVersion.isHttp; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; @@ -26,28 +25,28 @@ import io.netty.handler.codec.ReplayingDecoder; import java.util.List; import javax.net.ssl.SSLHandshakeException; -import org.neo4j.driver.Logging; import org.neo4j.driver.exceptions.ClientException; import org.neo4j.driver.exceptions.SecurityException; import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.internal.logging.ChannelActivityLogger; -import org.neo4j.driver.internal.logging.ChannelErrorLogger; -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.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.logging.ChannelActivityLogger; +import org.neo4j.driver.internal.bolt.basicimpl.logging.ChannelErrorLogger; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; import org.neo4j.driver.internal.util.ErrorUtil; public class HandshakeHandler extends ReplayingDecoder { private final ChannelPipelineBuilder pipelineBuilder; private final ChannelPromise handshakeCompletedPromise; - private final Logging logging; + private final LoggingProvider logging; private boolean failed; private ChannelActivityLogger log; private ChannelErrorLogger errorLog; public HandshakeHandler( - ChannelPipelineBuilder pipelineBuilder, ChannelPromise handshakeCompletedPromise, Logging logging) { + ChannelPipelineBuilder pipelineBuilder, ChannelPromise handshakeCompletedPromise, LoggingProvider logging) { this.pipelineBuilder = pipelineBuilder; this.handshakeCompletedPromise = handshakeCompletedPromise; this.logging = logging; @@ -67,7 +66,7 @@ protected void handlerRemoved0(ChannelHandlerContext ctx) { @Override public void channelInactive(ChannelHandlerContext ctx) { - log.debug("Channel is inactive"); + log.log(System.Logger.Level.DEBUG, "Channel is inactive"); if (!failed) { // channel became inactive while doing bolt handshake, not because of some previous error @@ -90,7 +89,7 @@ public void exceptionCaught(ChannelHandlerContext ctx, Throwable error) { @Override protected void decode(ChannelHandlerContext ctx, ByteBuf in, List out) { var serverSuggestedVersion = BoltProtocolVersion.fromRawBytes(in.readInt()); - log.debug("S: [Bolt Handshake] %s", serverSuggestedVersion); + log.log(System.Logger.Level.DEBUG, "S: [Bolt Handshake] %s", serverSuggestedVersion); // this is a one-time handler, remove it when protocol version has been read ctx.pipeline().remove(this); @@ -118,7 +117,7 @@ private void protocolSelected(BoltProtocolVersion version, MessageFormat message } private void handleUnknownSuggestedProtocolVersion(BoltProtocolVersion version, ChannelHandlerContext ctx) { - if (NO_PROTOCOL_VERSION.equals(version)) { + if (BoltProtocolUtil.NO_PROTOCOL_VERSION.equals(version)) { fail(ctx, protocolNoSupportedByServerError()); } else if (isHttp(version)) { fail(ctx, httpEndpointError()); diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/NettyChannelInitializer.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/NettyChannelInitializer.java similarity index 67% rename from driver/src/main/java/org/neo4j/driver/internal/async/connection/NettyChannelInitializer.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/NettyChannelInitializer.java index fa1f4b3c82..fa90a1f22a 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/NettyChannelInitializer.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/NettyChannelInitializer.java @@ -14,44 +14,34 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -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; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; import io.netty.channel.Channel; import io.netty.channel.ChannelInitializer; import io.netty.handler.ssl.SslHandler; import java.time.Clock; import javax.net.ssl.SSLEngine; -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; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.SecurityPlan; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; 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; + private final LoggingProvider logging; public NettyChannelInitializer( BoltServerAddress address, SecurityPlan securityPlan, int connectTimeoutMillis, - AuthTokenManager authTokenManager, Clock clock, - Logging logging) { + LoggingProvider logging) { this.address = address; this.securityPlan = securityPlan; this.connectTimeoutMillis = connectTimeoutMillis; - this.authTokenManager = authTokenManager; this.clock = clock; this.logging = logging; } @@ -86,9 +76,8 @@ private SSLEngine createSslEngine() { } private void updateChannelAttributes(Channel channel) { - setServerAddress(channel, address); - setCreationTimestamp(channel, clock.millis()); - setMessageDispatcher(channel, new InboundMessageDispatcher(channel, logging)); - setAuthContext(channel, new AuthContext(authTokenManager)); + ChannelAttributes.setServerAddress(channel, address); + ChannelAttributes.setCreationTimestamp(channel, clock.millis()); + ChannelAttributes.setMessageDispatcher(channel, new InboundMessageDispatcher(channel, logging)); } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/NettyDomainNameResolver.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/NettyDomainNameResolver.java similarity index 93% rename from driver/src/main/java/org/neo4j/driver/internal/async/connection/NettyDomainNameResolver.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/NettyDomainNameResolver.java index 9efc346124..d4c98d2086 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/NettyDomainNameResolver.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/NettyDomainNameResolver.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; import io.netty.resolver.InetNameResolver; import io.netty.util.concurrent.EventExecutor; @@ -23,7 +23,7 @@ import java.net.UnknownHostException; import java.util.Arrays; import java.util.List; -import org.neo4j.driver.internal.DomainNameResolver; +import org.neo4j.driver.internal.bolt.api.DomainNameResolver; public class NettyDomainNameResolver extends InetNameResolver { private final DomainNameResolver domainNameResolver; diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/connection/NettyDomainNameResolverGroup.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/NettyDomainNameResolverGroup.java similarity index 91% rename from driver/src/main/java/org/neo4j/driver/internal/async/connection/NettyDomainNameResolverGroup.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/NettyDomainNameResolverGroup.java index 3847a6f9a5..818438ee8f 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/connection/NettyDomainNameResolverGroup.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/NettyDomainNameResolverGroup.java @@ -14,13 +14,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; import io.netty.resolver.AddressResolver; import io.netty.resolver.AddressResolverGroup; import io.netty.util.concurrent.EventExecutor; import java.net.InetSocketAddress; -import org.neo4j.driver.internal.DomainNameResolver; +import org.neo4j.driver.internal.bolt.api.DomainNameResolver; public class NettyDomainNameResolverGroup extends AddressResolverGroup { private final DomainNameResolver domainNameResolver; diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ByteBufInput.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ByteBufInput.java similarity index 92% rename from driver/src/main/java/org/neo4j/driver/internal/async/inbound/ByteBufInput.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ByteBufInput.java index 6be0502911..32565ed586 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ByteBufInput.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ByteBufInput.java @@ -14,12 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.inbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.inbound; import static java.util.Objects.requireNonNull; import io.netty.buffer.ByteBuf; -import org.neo4j.driver.internal.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; public class ByteBufInput implements PackInput { private ByteBuf buf; diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ChannelErrorHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ChannelErrorHandler.java similarity index 82% rename from driver/src/main/java/org/neo4j/driver/internal/async/inbound/ChannelErrorHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ChannelErrorHandler.java index ca4313202e..8c8829d9f3 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ChannelErrorHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ChannelErrorHandler.java @@ -14,38 +14,37 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.inbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.inbound; import static java.util.Objects.requireNonNull; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.messageDispatcher; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.terminationReason; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInboundHandlerAdapter; import io.netty.handler.codec.CodecException; import java.io.IOException; -import org.neo4j.driver.Logging; import org.neo4j.driver.exceptions.ConnectionReadTimeoutException; import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.internal.logging.ChannelActivityLogger; -import org.neo4j.driver.internal.logging.ChannelErrorLogger; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.basicimpl.logging.ChannelActivityLogger; +import org.neo4j.driver.internal.bolt.basicimpl.logging.ChannelErrorLogger; import org.neo4j.driver.internal.util.ErrorUtil; public class ChannelErrorHandler extends ChannelInboundHandlerAdapter { - private final Logging logging; + private final LoggingProvider logging; private InboundMessageDispatcher messageDispatcher; private ChannelActivityLogger log; private ChannelErrorLogger errorLog; private boolean failed; - public ChannelErrorHandler(Logging logging) { + public ChannelErrorHandler(LoggingProvider logging) { this.logging = logging; } @Override public void handlerAdded(ChannelHandlerContext ctx) { - messageDispatcher = requireNonNull(messageDispatcher(ctx.channel())); + messageDispatcher = requireNonNull(ChannelAttributes.messageDispatcher(ctx.channel())); log = new ChannelActivityLogger(ctx.channel(), logging, getClass()); errorLog = new ChannelErrorLogger(ctx.channel(), logging); } @@ -59,9 +58,9 @@ public void handlerRemoved(ChannelHandlerContext ctx) { @Override public void channelInactive(ChannelHandlerContext ctx) { - log.debug("Channel is inactive"); + log.log(System.Logger.Level.DEBUG, "Channel is inactive"); - var terminationReason = terminationReason(ctx.channel()); + var terminationReason = ChannelAttributes.terminationReason(ctx.channel()); Throwable error = ErrorUtil.newConnectionTerminatedError(terminationReason); if (!failed) { diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ChunkDecoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ChunkDecoder.java similarity index 83% rename from driver/src/main/java/org/neo4j/driver/internal/async/inbound/ChunkDecoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ChunkDecoder.java index 100f5bbdd1..b25431c924 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ChunkDecoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ChunkDecoder.java @@ -14,15 +14,14 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.inbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.inbound; import io.netty.buffer.ByteBuf; import io.netty.buffer.ByteBufUtil; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.LengthFieldBasedFrameDecoder; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.logging.ChannelActivityLogger; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.logging.ChannelActivityLogger; public class ChunkDecoder extends LengthFieldBasedFrameDecoder { private static final int MAX_FRAME_BODY_LENGTH = 0xFFFF; @@ -32,10 +31,10 @@ public class ChunkDecoder extends LengthFieldBasedFrameDecoder { private static final int INITIAL_BYTES_TO_STRIP = LENGTH_FIELD_LENGTH; private static final int MAX_FRAME_LENGTH = LENGTH_FIELD_LENGTH + MAX_FRAME_BODY_LENGTH; - private final Logging logging; - private Logger log; + private final LoggingProvider logging; + private System.Logger log; - public ChunkDecoder(Logging logging) { + public ChunkDecoder(LoggingProvider logging) { super(MAX_FRAME_LENGTH, LENGTH_FIELD_OFFSET, LENGTH_FIELD_LENGTH, LENGTH_ADJUSTMENT, INITIAL_BYTES_TO_STRIP); this.logging = logging; } @@ -52,12 +51,12 @@ protected void handlerRemoved0(ChannelHandlerContext ctx) { @Override protected ByteBuf extractFrame(ChannelHandlerContext ctx, ByteBuf buffer, int index, int length) { - if (log.isTraceEnabled()) { + if (log.isLoggable(System.Logger.Level.TRACE)) { var originalReaderIndex = buffer.readerIndex(); var readerIndexWithChunkHeader = originalReaderIndex - INITIAL_BYTES_TO_STRIP; var lengthWithChunkHeader = INITIAL_BYTES_TO_STRIP + length; var hexDump = ByteBufUtil.hexDump(buffer, readerIndexWithChunkHeader, lengthWithChunkHeader); - log.trace("S: %s", hexDump); + log.log(System.Logger.Level.TRACE, "S: %s", hexDump); } return super.extractFrame(ctx, buffer, index, length); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ConnectTimeoutHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ConnectTimeoutHandler.java similarity index 96% rename from driver/src/main/java/org/neo4j/driver/internal/async/inbound/ConnectTimeoutHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ConnectTimeoutHandler.java index 87613c369c..b7d6ae66fb 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ConnectTimeoutHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ConnectTimeoutHandler.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.inbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.inbound; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.timeout.ReadTimeoutHandler; diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ConnectionReadTimeoutHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ConnectionReadTimeoutHandler.java similarity index 95% rename from driver/src/main/java/org/neo4j/driver/internal/async/inbound/ConnectionReadTimeoutHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ConnectionReadTimeoutHandler.java index 4246e952d5..e3a85cfd30 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ConnectionReadTimeoutHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ConnectionReadTimeoutHandler.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.inbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.inbound; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.timeout.ReadTimeoutHandler; diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcher.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/InboundMessageDispatcher.java similarity index 59% rename from driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcher.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/InboundMessageDispatcher.java index 6e296c83d2..3902b3af5c 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcher.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/InboundMessageDispatcher.java @@ -14,50 +14,39 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.inbound; +package org.neo4j.driver.internal.bolt.basicimpl.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; import io.netty.channel.Channel; import java.util.Arrays; import java.util.LinkedList; import java.util.Map; -import java.util.Objects; import java.util.Optional; import java.util.Queue; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; import org.neo4j.driver.Value; -import org.neo4j.driver.exceptions.AuthorizationExpiredException; -import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.exceptions.SecurityException; -import org.neo4j.driver.exceptions.SecurityRetryableException; -import org.neo4j.driver.exceptions.TokenExpiredException; -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.spi.ResponseHandler; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.exception.MessageIgnoredException; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.ResetResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.logging.ChannelActivityLogger; +import org.neo4j.driver.internal.bolt.basicimpl.logging.ChannelErrorLogger; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ResponseMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; import org.neo4j.driver.internal.util.ErrorUtil; public class InboundMessageDispatcher implements ResponseMessageHandler { private final Channel channel; private final Queue handlers = new LinkedList<>(); - private final Logger log; + private final System.Logger log; private final ChannelErrorLogger errorLog; private volatile boolean gracefullyClosed; - private Throwable currentError; private boolean fatalErrorOccurred; private HandlerHook beforeLastHandlerHook; private ResponseHandler autoReadManagingHandler; - public InboundMessageDispatcher(Channel channel, Logging logging) { + public InboundMessageDispatcher(Channel channel, LoggingProvider logging) { this.channel = requireNonNull(channel); this.log = new ChannelActivityLogger(channel, logging, getClass()); this.errorLog = new ChannelErrorLogger(channel, logging); @@ -65,7 +54,8 @@ public InboundMessageDispatcher(Channel channel, Logging logging) { public void enqueue(ResponseHandler handler) { if (fatalErrorOccurred) { - handler.onFailure(currentError); + log.log(System.Logger.Level.INFO, String.format("No handlers are accepted %s", handler.toString())); + handler.onFailure(new IllegalStateException("No handlers are accepted after fatal error")); } else { handlers.add(handler); updateAutoReadManagingHandlerIfNeeded(handler); @@ -85,7 +75,9 @@ public int queuedHandlersCount() { @Override public void handleSuccessMessage(Map meta) { - log.debug("S: SUCCESS %s", meta); + if (log.isLoggable(System.Logger.Level.DEBUG)) { + log.log(System.Logger.Level.DEBUG, "S: SUCCESS %s", meta); + } invokeBeforeLastHandlerHook(HandlerHook.MessageType.SUCCESS); var handler = removeHandler(); handler.onSuccess(meta); @@ -93,8 +85,8 @@ public void handleSuccessMessage(Map meta) { @Override public void handleRecordMessage(Value[] fields) { - if (log.isDebugEnabled()) { - log.debug("S: RECORD %s", Arrays.toString(fields)); + if (log.isLoggable(System.Logger.Level.DEBUG)) { + log.log(System.Logger.Level.DEBUG, "S: RECORD %s", Arrays.toString(fields)); } var handler = handlers.peek(); if (handler == null) { @@ -106,62 +98,24 @@ public void handleRecordMessage(Value[] fields) { @Override public void handleFailureMessage(String code, String message) { - log.debug("S: FAILURE %s \"%s\"", code, message); - - currentError = ErrorUtil.newNeo4jError(code, message); - - if (ErrorUtil.isFatal(currentError)) { - // we should not continue using channel after a fatal error - // fire error event back to the pipeline and avoid sending RESET - channel.pipeline().fireExceptionCaught(currentError); - return; - } - - var currentError = this.currentError; - var sendReset = true; - - if (currentError instanceof SecurityException securityException) { - if (securityException instanceof AuthorizationExpiredException) { - authorizationStateListener(channel).onExpired(); - sendReset = false; - } else if (securityException instanceof TokenExpiredException) { - sendReset = false; - } - var authContext = authContext(channel); - var authTokenManager = authContext.getAuthTokenManager(); - var authToken = authContext.getAuthToken(); - if (authToken != null && authContext.isManaged()) { - if (authTokenManager.handleSecurityException(authToken, securityException)) { - currentError = new SecurityRetryableException(securityException); - } - } - } - - if (sendReset) { - // write a RESET to "acknowledge" the failure - enqueue(new ResetResponseHandler(this)); - channel.writeAndFlush(RESET, channel.voidPromise()); + if (log.isLoggable(System.Logger.Level.DEBUG)) { + log.log(System.Logger.Level.DEBUG, "S: FAILURE %s \"%s\"", code, message); } + var error = ErrorUtil.newNeo4jError(code, message); invokeBeforeLastHandlerHook(HandlerHook.MessageType.FAILURE); var handler = removeHandler(); - handler.onFailure(currentError); + handler.onFailure(error); } @Override public void handleIgnoredMessage() { - log.debug("S: IGNORED"); + if (log.isLoggable(System.Logger.Level.DEBUG)) { + log.log(System.Logger.Level.DEBUG, "S: IGNORED"); + } var handler = removeHandler(); - var error = Objects.requireNonNullElseGet(currentError, () -> getPendingResetHandler() - .flatMap(ResetResponseHandler::throwable) - .orElseGet(() -> { - log.warn( - "Received IGNORED message for handler %s but error is missing and RESET is not in progress. Current handlers %s", - handler, handlers); - return new ClientException("Database ignored the request"); - })); - handler.onFailure(error); + handler.onFailure(new MessageIgnoredException("The server has ignored the message")); } public HandlerHook getBeforeLastHandlerHook() { @@ -190,30 +144,15 @@ public void handleChannelInactive(Throwable cause) { } public void handleChannelError(Throwable error) { - if (currentError != null) { - // we already have an error, this new error probably is caused by the existing one, thus we chain the new - // error on this current error - addSuppressed(currentError, error); - } else { - currentError = error; - } - fatalErrorOccurred = true; + this.fatalErrorOccurred = true; - while (!handlers.isEmpty()) { + while (!this.handlers.isEmpty()) { var handler = removeHandler(); - handler.onFailure(currentError); + handler.onFailure(error); } errorLog.traceOrDebug("Closing channel because of a failure", error); - channel.close(); - } - - public void clearCurrentError() { - currentError = null; - } - - public Throwable currentError() { - return currentError; + this.channel.close(); } public boolean fatalErrorOccurred() { @@ -274,12 +213,12 @@ enum MessageType { } // For testing only - Logger getLog() { + System.Logger getLog() { return log; } // For testing only - Logger getErrorLog() { + System.Logger getErrorLog() { return errorLog; } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/InboundMessageHandler.java similarity index 76% rename from driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/InboundMessageHandler.java index c5ebb41ad1..0a224f7f6b 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/InboundMessageHandler.java @@ -14,33 +14,32 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.inbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.inbound; import static io.netty.buffer.ByteBufUtil.hexDump; import static java.util.Objects.requireNonNull; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.messageDispatcher; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.SimpleChannelInboundHandler; import io.netty.handler.codec.DecoderException; import java.util.Set; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.logging.ChannelActivityLogger; -import org.neo4j.driver.internal.messaging.BoltPatchesListener; -import org.neo4j.driver.internal.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.basicimpl.logging.ChannelActivityLogger; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltPatchesListener; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; public class InboundMessageHandler extends SimpleChannelInboundHandler implements BoltPatchesListener { private final ByteBufInput input; private final MessageFormat messageFormat; - private final Logging logging; + private final LoggingProvider logging; private InboundMessageDispatcher messageDispatcher; private MessageFormat.Reader reader; - private Logger log; + private System.Logger log; - public InboundMessageHandler(MessageFormat messageFormat, Logging logging) { + public InboundMessageHandler(MessageFormat messageFormat, LoggingProvider logging) { this.input = new ByteBufInput(); this.messageFormat = messageFormat; this.logging = logging; @@ -50,7 +49,7 @@ public InboundMessageHandler(MessageFormat messageFormat, Logging logging) { @Override public void handlerAdded(ChannelHandlerContext ctx) { var channel = ctx.channel(); - messageDispatcher = requireNonNull(messageDispatcher(channel)); + messageDispatcher = requireNonNull(ChannelAttributes.messageDispatcher(channel)); log = new ChannelActivityLogger(channel, logging, getClass()); } @@ -63,14 +62,15 @@ public void handlerRemoved(ChannelHandlerContext ctx) { @Override protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) { if (messageDispatcher.fatalErrorOccurred()) { - log.warn( + log.log( + System.Logger.Level.WARNING, "Message ignored because of the previous fatal error. Channel will be closed. Message:\n%s", hexDump(msg)); return; } - if (log.isTraceEnabled()) { - log.trace("S: %s", hexDump(msg)); + if (log.isLoggable(System.Logger.Level.TRACE)) { + log.log(System.Logger.Level.TRACE, "S: %s", hexDump(msg)); } input.start(msg); diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/MessageDecoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/MessageDecoder.java similarity index 97% rename from driver/src/main/java/org/neo4j/driver/internal/async/inbound/MessageDecoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/MessageDecoder.java index 1c0a74df33..13dc6c3074 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/MessageDecoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/MessageDecoder.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.inbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.inbound; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/outbound/ChunkAwareByteBufOutput.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/outbound/ChunkAwareByteBufOutput.java similarity index 87% rename from driver/src/main/java/org/neo4j/driver/internal/async/outbound/ChunkAwareByteBufOutput.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/outbound/ChunkAwareByteBufOutput.java index b9027c8215..1c0ef82e81 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/outbound/ChunkAwareByteBufOutput.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/outbound/ChunkAwareByteBufOutput.java @@ -14,15 +14,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.outbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.outbound; import static java.util.Objects.requireNonNull; -import static org.neo4j.driver.internal.async.connection.BoltProtocolUtil.CHUNK_HEADER_SIZE_BYTES; -import static org.neo4j.driver.internal.async.connection.BoltProtocolUtil.DEFAULT_MAX_OUTBOUND_CHUNK_SIZE_BYTES; import io.netty.buffer.ByteBuf; -import org.neo4j.driver.internal.async.connection.BoltProtocolUtil; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.BoltProtocolUtil; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; public class ChunkAwareByteBufOutput implements PackOutput { private final int maxChunkSize; @@ -32,7 +30,7 @@ public class ChunkAwareByteBufOutput implements PackOutput { private int currentChunkSize; public ChunkAwareByteBufOutput() { - this(DEFAULT_MAX_OUTBOUND_CHUNK_SIZE_BYTES); + this(BoltProtocolUtil.DEFAULT_MAX_OUTBOUND_CHUNK_SIZE_BYTES); } ChunkAwareByteBufOutput(int maxChunkSize) { @@ -121,12 +119,12 @@ private void ensureCanFitInCurrentChunk(int numberOfBytes) { private void startNewChunk(int index) { currentChunkStartIndex = index; BoltProtocolUtil.writeEmptyChunkHeader(buf); - currentChunkSize = CHUNK_HEADER_SIZE_BYTES; + currentChunkSize = BoltProtocolUtil.CHUNK_HEADER_SIZE_BYTES; } private void writeChunkSizeHeader() { // go to the beginning of the chunk and write the size header - var chunkBodySize = currentChunkSize - CHUNK_HEADER_SIZE_BYTES; + var chunkBodySize = currentChunkSize - BoltProtocolUtil.CHUNK_HEADER_SIZE_BYTES; BoltProtocolUtil.writeChunkHeader(buf, currentChunkStartIndex, chunkBodySize); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/outbound/OutboundMessageHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/outbound/OutboundMessageHandler.java similarity index 76% rename from driver/src/main/java/org/neo4j/driver/internal/async/outbound/OutboundMessageHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/outbound/OutboundMessageHandler.java index f7d6b2aa4d..e32ee53fdf 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/outbound/OutboundMessageHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/async/outbound/OutboundMessageHandler.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.outbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.outbound; import static io.netty.buffer.ByteBufUtil.hexDump; @@ -23,24 +23,23 @@ import io.netty.handler.codec.MessageToMessageEncoder; import java.util.List; import java.util.Set; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.async.connection.BoltProtocolUtil; -import org.neo4j.driver.internal.logging.ChannelActivityLogger; -import org.neo4j.driver.internal.messaging.BoltPatchesListener; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.BoltProtocolUtil; +import org.neo4j.driver.internal.bolt.basicimpl.logging.ChannelActivityLogger; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltPatchesListener; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; public class OutboundMessageHandler extends MessageToMessageEncoder implements BoltPatchesListener { public static final String NAME = OutboundMessageHandler.class.getSimpleName(); private final ChunkAwareByteBufOutput output; private final MessageFormat messageFormat; - private final Logging logging; + private final LoggingProvider logging; private MessageFormat.Writer writer; - private Logger log; + private System.Logger log; - public OutboundMessageHandler(MessageFormat messageFormat, Logging logging) { + public OutboundMessageHandler(MessageFormat messageFormat, LoggingProvider logging) { this.output = new ChunkAwareByteBufOutput(); this.messageFormat = messageFormat; this.logging = logging; @@ -59,7 +58,7 @@ public void handlerRemoved(ChannelHandlerContext ctx) { @Override protected void encode(ChannelHandlerContext ctx, Message msg, List out) { - log.debug("C: %s", msg); + log.log(System.Logger.Level.DEBUG, "C: %s", msg); var messageBuf = ctx.alloc().ioBuffer(); output.start(messageBuf); @@ -73,8 +72,8 @@ protected void encode(ChannelHandlerContext ctx, Message msg, List out) throw new EncoderException("Failed to write outbound message: " + msg, error); } - if (log.isTraceEnabled()) { - log.trace("C: %s", hexDump(messageBuf)); + if (log.isLoggable(System.Logger.Level.TRACE)) { + log.log(System.Logger.Level.TRACE, "C: %s", hexDump(messageBuf)); } BoltProtocolUtil.writeMessageBoundary(messageBuf); diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/BeginTxResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/BeginTxResponseHandler.java similarity index 92% rename from driver/src/main/java/org/neo4j/driver/internal/handlers/BeginTxResponseHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/BeginTxResponseHandler.java index 9a2c4f3482..cb2e4d66c3 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/BeginTxResponseHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/BeginTxResponseHandler.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers; +package org.neo4j.driver.internal.bolt.basicimpl.handlers; import static java.util.Objects.requireNonNull; @@ -22,7 +22,7 @@ import java.util.Map; import java.util.concurrent.CompletableFuture; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.spi.ResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; public class BeginTxResponseHandler implements ResponseHandler { private final CompletableFuture beginTxFuture; diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/CommitTxResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/CommitTxResponseHandler.java similarity index 65% rename from driver/src/main/java/org/neo4j/driver/internal/handlers/CommitTxResponseHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/CommitTxResponseHandler.java index 24aa771198..ce48a39c13 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/CommitTxResponseHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/CommitTxResponseHandler.java @@ -14,28 +14,35 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers; +package org.neo4j.driver.internal.bolt.basicimpl.handlers; import static java.util.Objects.requireNonNull; +import static org.neo4j.driver.internal.types.InternalTypeSystem.TYPE_SYSTEM; import java.util.Arrays; import java.util.Map; import java.util.concurrent.CompletableFuture; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.spi.ResponseHandler; -import org.neo4j.driver.internal.util.MetadataExtractor; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; public class CommitTxResponseHandler implements ResponseHandler { - private final CompletableFuture commitFuture; + private final CompletableFuture commitFuture; - public CommitTxResponseHandler(CompletableFuture commitFuture) { + public CommitTxResponseHandler(CompletableFuture commitFuture) { this.commitFuture = requireNonNull(commitFuture); } @Override public void onSuccess(Map metadata) { - commitFuture.complete(MetadataExtractor.extractDatabaseBookmark(metadata)); + var bookmarkValue = metadata.get("bookmark"); + String bookmark = null; + if (bookmarkValue != null && !bookmarkValue.isNull() && bookmarkValue.hasType(TYPE_SYSTEM.STRING())) { + bookmark = bookmarkValue.asString(); + if (bookmark.isEmpty()) { + bookmark = null; + } + } + commitFuture.complete(bookmark); } @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/DiscardResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/DiscardResponseHandler.java new file mode 100644 index 0000000000..51c5cfc6dd --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/DiscardResponseHandler.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.handlers; + +import java.util.Map; +import java.util.Objects; +import java.util.concurrent.CompletableFuture; +import org.neo4j.driver.Value; +import org.neo4j.driver.internal.bolt.api.summary.DiscardSummary; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; +import org.neo4j.driver.internal.value.BooleanValue; + +public class DiscardResponseHandler implements ResponseHandler { + private final CompletableFuture future; + + public DiscardResponseHandler(CompletableFuture future) { + this.future = Objects.requireNonNull(future, "future must not be null"); + } + + @Override + public void onSuccess(Map metadata) { + var hasMore = metadata.getOrDefault("has_more", BooleanValue.FALSE).asBoolean(); + this.future.complete(new DiscardSummaryImpl(metadata)); + } + + @Override + public void onFailure(Throwable error) { + this.future.completeExceptionally(error); + } + + @Override + public void onRecord(Value[] fields) {} + + private record DiscardSummaryImpl(Map metadata) implements DiscardSummary { + @Override + public Map metadata() { + return metadata; + } + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/HelloResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/HelloResponseHandler.java similarity index 66% rename from driver/src/main/java/org/neo4j/driver/internal/handlers/HelloResponseHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/HelloResponseHandler.java index eb97b82419..b405df2f19 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/HelloResponseHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/HelloResponseHandler.java @@ -14,43 +14,49 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers; +package org.neo4j.driver.internal.bolt.basicimpl.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; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setConnectionReadTimeout; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setServerAgent; -import static org.neo4j.driver.internal.util.MetadataExtractor.extractBoltPatches; -import static org.neo4j.driver.internal.util.MetadataExtractor.extractServer; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.boltPatchesListeners; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.protocolVersion; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setConnectionId; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setConnectionReadTimeout; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setServerAgent; +import static org.neo4j.driver.internal.bolt.basicimpl.util.MetadataExtractor.extractBoltPatches; +import static org.neo4j.driver.internal.bolt.basicimpl.util.MetadataExtractor.extractServer; import io.netty.channel.Channel; -import io.netty.channel.ChannelPromise; import java.time.Clock; import java.util.Map; +import java.util.Objects; import java.util.Optional; +import java.util.concurrent.CompletableFuture; import java.util.function.Supplier; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.messaging.v43.BoltProtocolV43; -import org.neo4j.driver.internal.messaging.v44.BoltProtocolV44; -import org.neo4j.driver.internal.spi.ResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v43.BoltProtocolV43; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v44.BoltProtocolV44; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; public class HelloResponseHandler implements ResponseHandler { private static final String CONNECTION_ID_METADATA_KEY = "connection_id"; public static final String CONFIGURATION_HINTS_KEY = "hints"; public static final String CONNECTION_RECEIVE_TIMEOUT_SECONDS_KEY = "connection.recv_timeout_seconds"; - private final ChannelPromise connectionInitializedPromise; + private final CompletableFuture future; private final Channel channel; private final Clock clock; + private final CompletableFuture latestAuthMillisFuture; - public HelloResponseHandler(ChannelPromise connectionInitializedPromise, Clock clock) { + public HelloResponseHandler( + CompletableFuture future, + Channel channel, + Clock clock, + CompletableFuture latestAuthMillisFuture) { requireNonNull(clock, "clock must not be null"); - this.connectionInitializedPromise = connectionInitializedPromise; - this.channel = connectionInitializedPromise.channel(); + this.future = future; + this.channel = channel; this.clock = clock; + this.latestAuthMillisFuture = Objects.requireNonNull(latestAuthMillisFuture); } @Override @@ -72,11 +78,8 @@ public void onSuccess(Map metadata) { } } - var authContext = authContext(channel); - if (authContext.getAuthToken() != null) { - authContext.finishAuth(clock.millis()); - } - connectionInitializedPromise.setSuccess(); + latestAuthMillisFuture.complete(clock.millis()); + future.complete(serverAgent); } catch (Throwable error) { onFailure(error); throw error; @@ -85,7 +88,7 @@ public void onSuccess(Map metadata) { @Override public void onFailure(Throwable error) { - channel.close().addListener(future -> connectionInitializedPromise.setFailure(error)); + channel.close().addListener(future -> this.future.completeExceptionally(error)); } @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/HelloV51ResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/HelloV51ResponseHandler.java similarity index 81% rename from driver/src/main/java/org/neo4j/driver/internal/handlers/HelloV51ResponseHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/HelloV51ResponseHandler.java index 5690613501..93d9ba2700 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/HelloV51ResponseHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/HelloV51ResponseHandler.java @@ -14,13 +14,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers; +package org.neo4j.driver.internal.bolt.basicimpl.handlers; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setConnectionId; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setConnectionReadTimeout; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setServerAgent; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setTelemetryEnabled; -import static org.neo4j.driver.internal.util.MetadataExtractor.extractServer; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setConnectionId; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setConnectionReadTimeout; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setServerAgent; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setTelemetryEnabled; +import static org.neo4j.driver.internal.bolt.basicimpl.util.MetadataExtractor.extractServer; import io.netty.channel.Channel; import java.util.Map; @@ -28,7 +28,7 @@ import java.util.concurrent.CompletableFuture; import java.util.function.Supplier; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.spi.ResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; public class HelloV51ResponseHandler implements ResponseHandler { private static final String CONNECTION_ID_METADATA_KEY = "connection_id"; @@ -37,9 +37,9 @@ public class HelloV51ResponseHandler implements ResponseHandler { public static final String TELEMETRY_ENABLED_KEY = "telemetry.enabled"; private final Channel channel; - private final CompletableFuture helloFuture; + private final CompletableFuture helloFuture; - public HelloV51ResponseHandler(Channel channel, CompletableFuture helloFuture) { + public HelloV51ResponseHandler(Channel channel, CompletableFuture helloFuture) { this.channel = channel; this.helloFuture = helloFuture; } @@ -55,7 +55,7 @@ public void onSuccess(Map metadata) { processConfigurationHints(metadata); - helloFuture.complete(null); + helloFuture.complete(serverAgent); } catch (Throwable error) { onFailure(error); throw error; diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/LogoffResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/LogoffResponseHandler.java similarity index 92% rename from driver/src/main/java/org/neo4j/driver/internal/handlers/LogoffResponseHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/LogoffResponseHandler.java index 6996135b8a..efac8d9740 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/LogoffResponseHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/LogoffResponseHandler.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers; +package org.neo4j.driver.internal.bolt.basicimpl.handlers; import static java.util.Objects.requireNonNull; @@ -22,7 +22,7 @@ import java.util.concurrent.CompletableFuture; import org.neo4j.driver.Value; import org.neo4j.driver.exceptions.ProtocolException; -import org.neo4j.driver.internal.spi.ResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; public class LogoffResponseHandler implements ResponseHandler { private final CompletableFuture future; diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/LogonResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/LogonResponseHandler.java similarity index 68% rename from driver/src/main/java/org/neo4j/driver/internal/handlers/LogonResponseHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/LogonResponseHandler.java index 68805554df..eed4abc75d 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/LogonResponseHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/LogonResponseHandler.java @@ -14,10 +14,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers; +package org.neo4j.driver.internal.bolt.basicimpl.handlers; import static java.util.Objects.requireNonNull; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.authContext; import io.netty.channel.Channel; import java.time.Clock; @@ -25,28 +24,35 @@ import java.util.concurrent.CompletableFuture; import org.neo4j.driver.Value; import org.neo4j.driver.exceptions.ProtocolException; -import org.neo4j.driver.internal.spi.ResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; public class LogonResponseHandler implements ResponseHandler { private final CompletableFuture future; private final Channel channel; private final Clock clock; + private final CompletableFuture latestAuthMillisFuture; - public LogonResponseHandler(CompletableFuture future, Channel channel, Clock clock) { + public LogonResponseHandler( + CompletableFuture future, Channel channel, Clock clock, CompletableFuture latestAuthMillisFuture) { this.future = requireNonNull(future, "future must not be null"); - this.channel = requireNonNull(channel, "channel must not be null"); + this.channel = channel; this.clock = requireNonNull(clock, "clock must not be null"); + this.latestAuthMillisFuture = requireNonNull(latestAuthMillisFuture); } @Override public void onSuccess(Map metadata) { - authContext(channel).finishAuth(clock.millis()); + latestAuthMillisFuture.complete(clock.millis()); future.complete(null); } @Override public void onFailure(Throwable error) { - channel.close().addListener(future -> this.future.completeExceptionally(error)); + if (channel != null) { + channel.close().addListener(future -> this.future.completeExceptionally(error)); + } else { + future.completeExceptionally(error); + } } @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/NoOpResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/NoOpResponseHandler.java similarity index 88% rename from driver/src/main/java/org/neo4j/driver/internal/handlers/NoOpResponseHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/NoOpResponseHandler.java index 13adb43d5c..158e2a5850 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/NoOpResponseHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/NoOpResponseHandler.java @@ -14,11 +14,11 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers; +package org.neo4j.driver.internal.bolt.basicimpl.handlers; import java.util.Map; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.spi.ResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; public class NoOpResponseHandler implements ResponseHandler { public static final NoOpResponseHandler INSTANCE = new NoOpResponseHandler(); diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/PullResponseCompletionListener.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/PullResponseCompletionListener.java similarity index 93% rename from driver/src/main/java/org/neo4j/driver/internal/handlers/PullResponseCompletionListener.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/PullResponseCompletionListener.java index d0de20bb17..d5b0b83d19 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/PullResponseCompletionListener.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/PullResponseCompletionListener.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers; +package org.neo4j.driver.internal.bolt.basicimpl.handlers; import java.util.Map; import org.neo4j.driver.Value; diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/PullResponseHandlerImpl.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/PullResponseHandlerImpl.java new file mode 100644 index 0000000000..4563129fd7 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/PullResponseHandlerImpl.java @@ -0,0 +1,51 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.handlers; + +import java.util.Map; +import org.neo4j.driver.Value; +import org.neo4j.driver.internal.bolt.api.summary.PullSummary; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.PullMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; +import org.neo4j.driver.internal.value.BooleanValue; + +public class PullResponseHandlerImpl implements ResponseHandler { + + private final PullMessageHandler handler; + + public PullResponseHandlerImpl(PullMessageHandler handler) { + this.handler = handler; + } + + @Override + public void onSuccess(Map metadata) { + var hasMore = metadata.getOrDefault("has_more", BooleanValue.FALSE).asBoolean(); + handler.onSummary(new PullSummaryImpl(hasMore, metadata)); + } + + @Override + public void onFailure(Throwable throwable) { + handler.onError(throwable); + } + + @Override + public void onRecord(Value[] fields) { + handler.onRecord(fields); + } + + public record PullSummaryImpl(boolean hasMore, Map metadata) implements PullSummary {} +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/ResetResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/ResetResponseHandler.java similarity index 83% rename from driver/src/main/java/org/neo4j/driver/internal/handlers/ResetResponseHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/ResetResponseHandler.java index bd331dfe5d..e4c778993b 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/ResetResponseHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/ResetResponseHandler.java @@ -14,20 +14,23 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers; +package org.neo4j.driver.internal.bolt.basicimpl.handlers; import java.util.Map; import java.util.Optional; import java.util.concurrent.CompletableFuture; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; -import org.neo4j.driver.internal.spi.ResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; public class ResetResponseHandler implements ResponseHandler { - private final InboundMessageDispatcher messageDispatcher; private final CompletableFuture completionFuture; private final Throwable throwable; + public ResetResponseHandler(CompletableFuture completionFuture) { + this(null, completionFuture); + } + public ResetResponseHandler(InboundMessageDispatcher messageDispatcher) { this(messageDispatcher, null); } @@ -38,7 +41,6 @@ public ResetResponseHandler(InboundMessageDispatcher messageDispatcher, Completa public ResetResponseHandler( InboundMessageDispatcher messageDispatcher, CompletableFuture completionFuture, Throwable throwable) { - this.messageDispatcher = messageDispatcher; this.completionFuture = completionFuture; this.throwable = throwable; } @@ -50,7 +52,9 @@ public final void onSuccess(Map metadata) { @Override public final void onFailure(Throwable error) { - resetCompleted(false); + if (completionFuture != null) { + completionFuture.completeExceptionally(error); + } } @Override @@ -63,7 +67,6 @@ public Optional throwable() { } private void resetCompleted(boolean success) { - messageDispatcher.clearCurrentError(); if (completionFuture != null) { resetCompleted(completionFuture, success); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/RollbackTxResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/RollbackTxResponseHandler.java similarity index 92% rename from driver/src/main/java/org/neo4j/driver/internal/handlers/RollbackTxResponseHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/RollbackTxResponseHandler.java index 0e14d76c39..8ad08f3eb8 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/RollbackTxResponseHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/RollbackTxResponseHandler.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers; +package org.neo4j.driver.internal.bolt.basicimpl.handlers; import static java.util.Objects.requireNonNull; @@ -22,7 +22,7 @@ import java.util.Map; import java.util.concurrent.CompletableFuture; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.spi.ResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; public class RollbackTxResponseHandler implements ResponseHandler { private final CompletableFuture rollbackFuture; diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/RouteMessageResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/RouteMessageResponseHandler.java similarity index 94% rename from driver/src/main/java/org/neo4j/driver/internal/handlers/RouteMessageResponseHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/RouteMessageResponseHandler.java index 897884dbd8..5871ee0b53 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/RouteMessageResponseHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/RouteMessageResponseHandler.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers; +package org.neo4j.driver.internal.bolt.basicimpl.handlers; import static java.util.Objects.requireNonNull; @@ -24,7 +24,7 @@ import java.util.concurrent.CompletableFuture; import org.neo4j.driver.Value; import org.neo4j.driver.Values; -import org.neo4j.driver.internal.spi.ResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; /** * Handles the RouteMessage response getting the success response diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/RunResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/RunResponseHandler.java similarity index 52% rename from driver/src/main/java/org/neo4j/driver/internal/handlers/RunResponseHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/RunResponseHandler.java index 88b239191a..d0d9d2043c 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/RunResponseHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/RunResponseHandler.java @@ -14,59 +14,44 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers; +package org.neo4j.driver.internal.bolt.basicimpl.handlers; +import java.util.List; import java.util.Map; import java.util.concurrent.CompletableFuture; import org.neo4j.driver.Value; import org.neo4j.driver.exceptions.AuthorizationExpiredException; import org.neo4j.driver.exceptions.ConnectionReadTimeoutException; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; -import org.neo4j.driver.internal.util.MetadataExtractor; -import org.neo4j.driver.internal.util.QueryKeys; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.util.MetadataExtractor; public class RunResponseHandler implements ResponseHandler { - private final CompletableFuture runFuture; + private final CompletableFuture runFuture; private final MetadataExtractor metadataExtractor; - private long queryId = MetadataExtractor.ABSENT_QUERY_ID; - - private QueryKeys queryKeys = QueryKeys.empty(); private long resultAvailableAfter = -1; - private final Connection connection; - private final UnmanagedTransaction tx; - - public RunResponseHandler( - CompletableFuture runFuture, - MetadataExtractor metadataExtractor, - Connection connection, - UnmanagedTransaction tx) { + public RunResponseHandler(CompletableFuture runFuture, MetadataExtractor metadataExtractor) { this.runFuture = runFuture; this.metadataExtractor = metadataExtractor; - this.connection = connection; - this.tx = tx; } @Override public void onSuccess(Map metadata) { - queryKeys = metadataExtractor.extractQueryKeys(metadata); + var queryKeys = metadataExtractor.extractQueryKeys(metadata); resultAvailableAfter = metadataExtractor.extractResultAvailableAfter(metadata); - queryId = metadataExtractor.extractQueryId(metadata); + var queryId = metadataExtractor.extractQueryId(metadata); - runFuture.complete(null); + runFuture.complete(new RunResponseImpl(queryId, queryKeys, resultAvailableAfter)); } @Override @SuppressWarnings("ThrowableNotThrown") public void onFailure(Throwable error) { - if (tx != null) { - tx.markTerminated(error); - } else if (error instanceof AuthorizationExpiredException) { - connection.terminateAndRelease(AuthorizationExpiredException.DESCRIPTION); + if (error instanceof AuthorizationExpiredException) { + // connection.terminateAndRelease(AuthorizationExpiredException.DESCRIPTION); } else if (error instanceof ConnectionReadTimeoutException) { - connection.terminateAndRelease(error.getMessage()); + // connection.terminateAndRelease(error.getMessage()); } runFuture.completeExceptionally(error); } @@ -76,15 +61,5 @@ public void onRecord(Value[] fields) { throw new UnsupportedOperationException(); } - public QueryKeys queryKeys() { - return queryKeys; - } - - public long resultAvailableAfter() { - return resultAvailableAfter; - } - - public long queryId() { - return queryId; - } + private record RunResponseImpl(long queryId, List keys, long resultAvailableAfter) implements RunSummary {} } diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/TelemetryResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/TelemetryResponseHandler.java similarity index 85% rename from driver/src/main/java/org/neo4j/driver/internal/handlers/TelemetryResponseHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/TelemetryResponseHandler.java index 53ba5f1b4a..4a7633b12e 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/TelemetryResponseHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/TelemetryResponseHandler.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers; +package org.neo4j.driver.internal.bolt.basicimpl.handlers; import static java.util.Objects.requireNonNull; @@ -22,8 +22,8 @@ import java.util.Map; import java.util.concurrent.CompletableFuture; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.messaging.request.TelemetryMessage; -import org.neo4j.driver.internal.spi.ResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.TelemetryMessage; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; /** * Handles {@link TelemetryMessage} responses. @@ -48,7 +48,7 @@ public void onSuccess(Map metadata) { @Override public void onFailure(Throwable error) { - throw new UnsupportedOperationException("Telemetry is not expected to receive failures.", error); + future.completeExceptionally(error); } @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/logging/ChannelActivityLogger.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/logging/ChannelActivityLogger.java similarity index 58% rename from driver/src/main/java/org/neo4j/driver/internal/logging/ChannelActivityLogger.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/logging/ChannelActivityLogger.java index 7ff36dc33a..ee26425e25 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/logging/ChannelActivityLogger.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/logging/ChannelActivityLogger.java @@ -14,35 +14,54 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.logging; +package org.neo4j.driver.internal.bolt.basicimpl.logging; import static java.lang.String.format; -import static org.neo4j.driver.internal.util.Format.valueOrEmpty; import io.netty.channel.Channel; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; +import java.util.ResourceBundle; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; -public class ChannelActivityLogger extends ReformattedLogger { +public class ChannelActivityLogger implements System.Logger { private final Channel channel; private final String localChannelId; + private final System.Logger delegate; private String dbConnectionId; private String serverAddress; - public ChannelActivityLogger(Channel channel, Logging logging, Class owner) { + public ChannelActivityLogger(Channel channel, LoggingProvider logging, Class owner) { this(channel, logging.getLog(owner)); } - private ChannelActivityLogger(Channel channel, Logger delegate) { - super(delegate); + private ChannelActivityLogger(Channel channel, System.Logger delegate) { this.channel = channel; + this.delegate = delegate; this.localChannelId = channel != null ? channel.id().toString() : null; } @Override - protected String reformat(String message) { + public String getName() { + return delegate.getName(); + } + + @Override + public boolean isLoggable(Level level) { + return delegate.isLoggable(level); + } + + @Override + public void log(Level level, ResourceBundle bundle, String msg, Throwable thrown) { + delegate.log(level, bundle, reformat(msg), thrown); + } + + @Override + public void log(Level level, ResourceBundle bundle, String format, Object... params) { + delegate.log(level, bundle, reformat(format), params); + } + + String reformat(String message) { if (channel == null) { return message; } @@ -71,4 +90,11 @@ private String getServerAddress() { return serverAddress; } + + /** + * Returns the submitted value if it is not null or an empty string if it is. + */ + private static String valueOrEmpty(String value) { + return value != null ? value : ""; + } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/logging/ChannelErrorLogger.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/logging/ChannelErrorLogger.java similarity index 74% rename from driver/src/main/java/org/neo4j/driver/internal/logging/ChannelErrorLogger.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/logging/ChannelErrorLogger.java index 1810e7249d..b3cf103bb5 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/logging/ChannelErrorLogger.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/logging/ChannelErrorLogger.java @@ -14,10 +14,10 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.logging; +package org.neo4j.driver.internal.bolt.basicimpl.logging; import io.netty.channel.Channel; -import org.neo4j.driver.Logging; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; /** * Dedicated logger for channel error logging. @@ -27,15 +27,15 @@ public class ChannelErrorLogger extends ChannelActivityLogger { private static final String DEBUG_MESSAGE_FORMAT = "%s (%s)"; - public ChannelErrorLogger(Channel channel, Logging logging) { + public ChannelErrorLogger(Channel channel, LoggingProvider logging) { super(channel, logging, ChannelErrorLogger.class); } public void traceOrDebug(String message, Throwable error) { - if (isTraceEnabled()) { - trace(message, error); + if (isLoggable(Level.TRACE)) { + log(Level.TRACE, message, error); } else { - debug(String.format(DEBUG_MESSAGE_FORMAT, message, error.getClass())); + log(Level.DEBUG, String.format(DEBUG_MESSAGE_FORMAT, message, error.getClass())); } } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/AbstractMessageWriter.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/AbstractMessageWriter.java similarity index 96% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/AbstractMessageWriter.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/AbstractMessageWriter.java index 721539b659..b49e4c2c78 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/AbstractMessageWriter.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/AbstractMessageWriter.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.messaging; import static java.util.Objects.requireNonNull; diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltPatchesListener.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/BoltPatchesListener.java similarity index 92% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/BoltPatchesListener.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/BoltPatchesListener.java index b5ec004c58..fb0977bb33 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltPatchesListener.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/BoltPatchesListener.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.messaging; import java.util.Set; diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/BoltProtocol.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/BoltProtocol.java new file mode 100644 index 0000000000..977ad5d56e --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/BoltProtocol.java @@ -0,0 +1,165 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging; + +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.protocolVersion; + +import io.netty.channel.Channel; +import io.netty.channel.ChannelPromise; +import java.time.Clock; +import java.time.Duration; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import org.neo4j.driver.Value; +import org.neo4j.driver.exceptions.ClientException; +import org.neo4j.driver.exceptions.UnsupportedFeatureException; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltAgent; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.summary.DiscardSummary; +import org.neo4j.driver.internal.bolt.api.summary.RouteSummary; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v3.BoltProtocolV3; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v4.BoltProtocolV4; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v41.BoltProtocolV41; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v42.BoltProtocolV42; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v43.BoltProtocolV43; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v44.BoltProtocolV44; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v5.BoltProtocolV5; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v51.BoltProtocolV51; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v52.BoltProtocolV52; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v53.BoltProtocolV53; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v54.BoltProtocolV54; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; + +public interface BoltProtocol { + MessageFormat createMessageFormat(); + + void initializeChannel( + String userAgent, + BoltAgent boltAgent, + Map authMap, + RoutingContext routingContext, + ChannelPromise channelInitializedPromise, + NotificationConfig notificationConfig, + Clock clock, + CompletableFuture latestAuthMillisFuture); + + CompletionStage route( + Connection connection, + Map routingContext, + Set bookmarks, + String databaseName, + String impersonatedUser, + MessageHandler handler, + Clock clock, + LoggingProvider logging); + + CompletionStage beginTransaction( + Connection connection, + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, + Set bookmarks, + Duration txTimeout, + Map txMetadata, + String txType, + NotificationConfig notificationConfig, + MessageHandler handler, + LoggingProvider logging); + + CompletionStage commitTransaction(Connection connection, MessageHandler handler); + + CompletionStage rollbackTransaction(Connection connection, MessageHandler handler); + + CompletionStage telemetry(Connection connection, Integer api, MessageHandler handler); + + CompletionStage runAuto( + Connection connection, + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, + String query, + Map parameters, + Set bookmarks, + Duration txTimeout, + Map txMetadata, + NotificationConfig notificationConfig, + MessageHandler handler, + LoggingProvider logging); + + CompletionStage run( + Connection connection, String query, Map parameters, MessageHandler handler); + + CompletionStage pull(Connection connection, long qid, long request, PullMessageHandler handler); + + CompletionStage discard(Connection connection, long qid, long number, MessageHandler handler); + + CompletionStage reset(Connection connection, MessageHandler handler); + + default CompletionStage logoff(Connection connection, MessageHandler handler) { + return CompletableFuture.failedStage(new UnsupportedFeatureException("logoff not supported")); + } + + default CompletionStage logon( + Connection connection, Map authMap, Clock clock, MessageHandler handler) { + return CompletableFuture.failedStage(new UnsupportedFeatureException("logon not supported")); + } + + /** + * Returns the protocol version. It can be used for version specific error messages. + * @return the protocol version. + */ + BoltProtocolVersion version(); + + static BoltProtocol forChannel(Channel channel) { + return forVersion(protocolVersion(channel)); + } + + static BoltProtocol forVersion(BoltProtocolVersion version) { + if (BoltProtocolV3.VERSION.equals(version)) { + return BoltProtocolV3.INSTANCE; + } else if (BoltProtocolV4.VERSION.equals(version)) { + return BoltProtocolV4.INSTANCE; + } else if (BoltProtocolV41.VERSION.equals(version)) { + return BoltProtocolV41.INSTANCE; + } else if (BoltProtocolV42.VERSION.equals(version)) { + return BoltProtocolV42.INSTANCE; + } else if (BoltProtocolV43.VERSION.equals(version)) { + return BoltProtocolV43.INSTANCE; + } else if (BoltProtocolV44.VERSION.equals(version)) { + return BoltProtocolV44.INSTANCE; + } else if (BoltProtocolV5.VERSION.equals(version)) { + return BoltProtocolV5.INSTANCE; + } else if (BoltProtocolV51.VERSION.equals(version)) { + return BoltProtocolV51.INSTANCE; + } else if (BoltProtocolV52.VERSION.equals(version)) { + return BoltProtocolV52.INSTANCE; + } else if (BoltProtocolV53.VERSION.equals(version)) { + return BoltProtocolV53.INSTANCE; + } else if (BoltProtocolV54.VERSION.equals(version)) { + return BoltProtocolV54.INSTANCE; + } + throw new ClientException("Unknown protocol version: " + version); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/Message.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/Message.java similarity index 92% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/Message.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/Message.java index 3c5074cdd9..20a05bd7e5 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/Message.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/Message.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.messaging; /** * Base class for all protocol messages. diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/MessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/MessageEncoder.java similarity index 92% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/MessageEncoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/MessageEncoder.java index 0c4ad7820f..1b7b78654b 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/MessageEncoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/MessageEncoder.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.messaging; import java.io.IOException; diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/MessageFormat.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/MessageFormat.java similarity index 86% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/MessageFormat.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/MessageFormat.java index 0ccd2d1b5f..b91dfff4bb 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/MessageFormat.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/MessageFormat.java @@ -14,11 +14,11 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.messaging; import java.io.IOException; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; public interface MessageFormat { interface Writer { diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/MessageHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/MessageHandler.java new file mode 100644 index 0000000000..e8fadc1592 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/MessageHandler.java @@ -0,0 +1,23 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging; + +public interface MessageHandler { + void onError(Throwable throwable); + + void onSummary(T summary); +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/PullMessageHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/PullMessageHandler.java new file mode 100644 index 0000000000..8e3ea17e9a --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/PullMessageHandler.java @@ -0,0 +1,24 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging; + +import org.neo4j.driver.Value; +import org.neo4j.driver.internal.bolt.api.summary.PullSummary; + +public interface PullMessageHandler extends MessageHandler { + void onRecord(Value[] fields); +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/ResponseMessageHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/ResponseMessageHandler.java similarity index 93% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/ResponseMessageHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/ResponseMessageHandler.java index d8e5498d73..3c970e8b36 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/ResponseMessageHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/ResponseMessageHandler.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.messaging; import java.util.Map; import org.neo4j.driver.Value; diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/ValuePacker.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/ValuePacker.java similarity index 94% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/ValuePacker.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/ValuePacker.java index 5decb93165..46d14143b6 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/ValuePacker.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/ValuePacker.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.messaging; import java.io.IOException; import java.util.Map; diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/ValueUnpacker.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/ValueUnpacker.java similarity index 94% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/ValueUnpacker.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/ValueUnpacker.java index c070582a5c..6fc60ed10f 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/ValueUnpacker.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/ValueUnpacker.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.messaging; import java.io.IOException; import java.util.Map; diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/common/CommonMessageReader.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/common/CommonMessageReader.java similarity index 77% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/common/CommonMessageReader.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/common/CommonMessageReader.java index 338b0a5212..8809c81672 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/common/CommonMessageReader.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/common/CommonMessageReader.java @@ -14,17 +14,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.common; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.common; import java.io.IOException; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.ResponseMessageHandler; -import org.neo4j.driver.internal.messaging.ValueUnpacker; -import org.neo4j.driver.internal.messaging.response.FailureMessage; -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.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ResponseMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValueUnpacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.FailureMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.IgnoredMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.RecordMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.SuccessMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; public class CommonMessageReader implements MessageFormat.Reader { private final ValueUnpacker unpacker; diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/common/CommonValuePacker.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/common/CommonValuePacker.java similarity index 97% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/common/CommonValuePacker.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/common/CommonValuePacker.java index 732bbf043b..23ebf701ee 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/common/CommonValuePacker.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/common/CommonValuePacker.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.common; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.common; import static java.time.ZoneOffset.UTC; @@ -29,9 +29,9 @@ import org.neo4j.driver.Value; import org.neo4j.driver.internal.InternalPoint2D; import org.neo4j.driver.internal.InternalPoint3D; -import org.neo4j.driver.internal.messaging.ValuePacker; -import org.neo4j.driver.internal.packstream.PackOutput; -import org.neo4j.driver.internal.packstream.PackStream; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackStream; import org.neo4j.driver.internal.value.InternalValue; import org.neo4j.driver.types.IsoDuration; import org.neo4j.driver.types.Point; diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/common/CommonValueUnpacker.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/common/CommonValueUnpacker.java similarity index 97% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/common/CommonValueUnpacker.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/common/CommonValueUnpacker.java index f17d7e9f05..e57eaaa951 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/common/CommonValueUnpacker.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/common/CommonValueUnpacker.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.common; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.common; import static java.time.ZoneOffset.UTC; import static org.neo4j.driver.Values.isoDuration; @@ -34,6 +34,7 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; +import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.function.Supplier; @@ -43,11 +44,10 @@ import org.neo4j.driver.internal.InternalNode; import org.neo4j.driver.internal.InternalPath; import org.neo4j.driver.internal.InternalRelationship; -import org.neo4j.driver.internal.messaging.ValueUnpacker; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackStream; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValueUnpacker; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackStream; import org.neo4j.driver.internal.types.TypeConstructor; -import org.neo4j.driver.internal.util.Iterables; import org.neo4j.driver.internal.value.ListValue; import org.neo4j.driver.internal.value.MapValue; import org.neo4j.driver.internal.value.NodeValue; @@ -118,7 +118,7 @@ public Map unpackMap() throws IOException { if (size == 0) { return Collections.emptyMap(); } - Map map = Iterables.newHashMapWithSize(size); + Map map = new HashMap<>(size); for (var i = 0; i < size; i++) { var key = unpacker.unpackString(); map.put(key, unpack()); @@ -285,7 +285,7 @@ protected InternalNode unpackNode() throws IOException { labels.add(unpacker.unpackString()); } var numProps = (int) unpacker.unpackMapHeader(); - Map props = Iterables.newHashMapWithSize(numProps); + Map props = new HashMap<>(numProps); for (var j = 0; j < numProps; j++) { var key = unpacker.unpackString(); props.put(key, unpack()); diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/BeginMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/BeginMessageEncoder.java similarity index 69% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/encode/BeginMessageEncoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/BeginMessageEncoder.java index e19b12e8cc..a16a8f5f6c 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/BeginMessageEncoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/BeginMessageEncoder.java @@ -14,15 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; -import static org.neo4j.driver.internal.util.Preconditions.checkArgument; +import static org.neo4j.driver.internal.bolt.basicimpl.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.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; public class BeginMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/CommitMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/CommitMessageEncoder.java similarity index 67% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/encode/CommitMessageEncoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/CommitMessageEncoder.java index 2731e44c66..c3136cff57 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/CommitMessageEncoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/CommitMessageEncoder.java @@ -14,15 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; -import static org.neo4j.driver.internal.util.Preconditions.checkArgument; +import static org.neo4j.driver.internal.bolt.basicimpl.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.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; public class CommitMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/DiscardAllMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/DiscardAllMessageEncoder.java similarity index 67% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/encode/DiscardAllMessageEncoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/DiscardAllMessageEncoder.java index f76e176fe2..17903ac19a 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/DiscardAllMessageEncoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/DiscardAllMessageEncoder.java @@ -14,15 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; -import static org.neo4j.driver.internal.util.Preconditions.checkArgument; +import static org.neo4j.driver.internal.bolt.basicimpl.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.DiscardAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage; public class DiscardAllMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/DiscardMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/DiscardMessageEncoder.java similarity index 69% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/encode/DiscardMessageEncoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/DiscardMessageEncoder.java index 34c6da784c..41e40dfe18 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/DiscardMessageEncoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/DiscardMessageEncoder.java @@ -14,15 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; -import static org.neo4j.driver.internal.util.Preconditions.checkArgument; +import static org.neo4j.driver.internal.bolt.basicimpl.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.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; public class DiscardMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/GoodbyeMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/GoodbyeMessageEncoder.java similarity index 67% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/encode/GoodbyeMessageEncoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/GoodbyeMessageEncoder.java index 131554234e..d8907c517e 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/GoodbyeMessageEncoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/GoodbyeMessageEncoder.java @@ -14,15 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; -import static org.neo4j.driver.internal.util.Preconditions.checkArgument; +import static org.neo4j.driver.internal.bolt.basicimpl.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.GoodbyeMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage; public class GoodbyeMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/HelloMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/HelloMessageEncoder.java similarity index 69% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/encode/HelloMessageEncoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/HelloMessageEncoder.java index 17a6190d50..ae90cdaf41 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/HelloMessageEncoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/HelloMessageEncoder.java @@ -14,15 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; -import static org.neo4j.driver.internal.util.Preconditions.checkArgument; +import static org.neo4j.driver.internal.bolt.basicimpl.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.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; public class HelloMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/LogoffMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/LogoffMessageEncoder.java similarity index 67% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/encode/LogoffMessageEncoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/LogoffMessageEncoder.java index 629f4a070e..3d1e8e59e7 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/LogoffMessageEncoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/LogoffMessageEncoder.java @@ -14,15 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; -import static org.neo4j.driver.internal.util.Preconditions.checkArgument; +import static org.neo4j.driver.internal.bolt.basicimpl.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; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.LogoffMessage; public class LogoffMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/LogonMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/LogonMessageEncoder.java similarity index 69% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/encode/LogonMessageEncoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/LogonMessageEncoder.java index f50e0cc33c..f4f732f630 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/LogonMessageEncoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/LogonMessageEncoder.java @@ -14,15 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; -import static org.neo4j.driver.internal.util.Preconditions.checkArgument; +import static org.neo4j.driver.internal.bolt.basicimpl.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.LogonMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.LogonMessage; public class LogonMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/PullAllMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/PullAllMessageEncoder.java similarity index 67% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/encode/PullAllMessageEncoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/PullAllMessageEncoder.java index 6c38ecc6c7..51b0a05ae7 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/PullAllMessageEncoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/PullAllMessageEncoder.java @@ -14,15 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; -import static org.neo4j.driver.internal.util.Preconditions.checkArgument; +import static org.neo4j.driver.internal.bolt.basicimpl.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.PullAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage; public class PullAllMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/PullMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/PullMessageEncoder.java similarity index 68% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/encode/PullMessageEncoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/PullMessageEncoder.java index 219519dc16..3c2edd5bc7 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/PullMessageEncoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/PullMessageEncoder.java @@ -14,15 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; -import static org.neo4j.driver.internal.util.Preconditions.checkArgument; +import static org.neo4j.driver.internal.bolt.basicimpl.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.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; public class PullMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/ResetMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/ResetMessageEncoder.java similarity index 67% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/encode/ResetMessageEncoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/ResetMessageEncoder.java index 630e4152a0..7fea8b44af 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/ResetMessageEncoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/ResetMessageEncoder.java @@ -14,15 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; -import static org.neo4j.driver.internal.util.Preconditions.checkArgument; +import static org.neo4j.driver.internal.bolt.basicimpl.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.ResetMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage; public class ResetMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RollbackMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RollbackMessageEncoder.java similarity index 67% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RollbackMessageEncoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RollbackMessageEncoder.java index 240761fe79..e0a223264a 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RollbackMessageEncoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RollbackMessageEncoder.java @@ -14,15 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; -import static org.neo4j.driver.internal.util.Preconditions.checkArgument; +import static org.neo4j.driver.internal.bolt.basicimpl.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.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; public class RollbackMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RouteMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RouteMessageEncoder.java similarity index 70% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RouteMessageEncoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RouteMessageEncoder.java index b34f67b2de..80d1d79492 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RouteMessageEncoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RouteMessageEncoder.java @@ -14,17 +14,16 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.util.Preconditions.checkArgument; +import static org.neo4j.driver.internal.bolt.basicimpl.util.Preconditions.checkArgument; import java.io.IOException; -import org.neo4j.driver.Bookmark; -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.RouteMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RouteMessage; /** * Encodes the ROUTE message to the stream @@ -36,7 +35,7 @@ public void encode(Message message, ValuePacker packer) throws IOException { var routeMessage = (RouteMessage) message; packer.packStructHeader(3, message.signature()); packer.pack(routeMessage.routingContext()); - packer.pack(value(routeMessage.bookmarks().stream().map(Bookmark::value))); + packer.pack(value(routeMessage.bookmarks())); packer.pack(routeMessage.databaseName()); } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RouteV44MessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RouteV44MessageEncoder.java similarity index 77% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RouteV44MessageEncoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RouteV44MessageEncoder.java index cc3d072d87..cc396be5b8 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RouteV44MessageEncoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RouteV44MessageEncoder.java @@ -14,20 +14,19 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.util.Preconditions.checkArgument; +import static org.neo4j.driver.internal.bolt.basicimpl.util.Preconditions.checkArgument; import java.io.IOException; import java.util.Collections; import java.util.Map; -import org.neo4j.driver.Bookmark; import org.neo4j.driver.Value; -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.RouteMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RouteMessage; /** * Encodes the ROUTE message to the stream @@ -39,7 +38,7 @@ public void encode(Message message, ValuePacker packer) throws IOException { var routeMessage = (RouteMessage) message; packer.packStructHeader(3, message.signature()); packer.pack(routeMessage.routingContext()); - packer.pack(value(routeMessage.bookmarks().stream().map(Bookmark::value))); + packer.pack(value(routeMessage.bookmarks())); Map params; if (routeMessage.impersonatedUser() != null && routeMessage.databaseName() == null) { diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RunWithMetadataMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RunWithMetadataMessageEncoder.java similarity index 71% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RunWithMetadataMessageEncoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RunWithMetadataMessageEncoder.java index f741875260..226c4b8acd 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/RunWithMetadataMessageEncoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RunWithMetadataMessageEncoder.java @@ -14,15 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; -import static org.neo4j.driver.internal.util.Preconditions.checkArgument; +import static org.neo4j.driver.internal.bolt.basicimpl.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.RunWithMetadataMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage; public class RunWithMetadataMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/TelemetryMessageEncoder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/TelemetryMessageEncoder.java similarity index 70% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/encode/TelemetryMessageEncoder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/TelemetryMessageEncoder.java index a168258ad7..75f96f3e23 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/encode/TelemetryMessageEncoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/TelemetryMessageEncoder.java @@ -14,16 +14,16 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; -import static org.neo4j.driver.internal.util.Preconditions.checkArgument; +import static org.neo4j.driver.internal.bolt.basicimpl.util.Preconditions.checkArgument; import java.io.IOException; import org.neo4j.driver.Values; -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.TelemetryMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.TelemetryMessage; public class TelemetryMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/AbstractStreamingMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/AbstractStreamingMessage.java similarity index 93% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/AbstractStreamingMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/AbstractStreamingMessage.java index 4f30edb9de..0afa65b82c 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/AbstractStreamingMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/AbstractStreamingMessage.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; import static org.neo4j.driver.internal.util.MetadataExtractor.ABSENT_QUERY_ID; @@ -23,7 +23,7 @@ import java.util.Objects; import org.neo4j.driver.Value; import org.neo4j.driver.Values; -import org.neo4j.driver.internal.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; public abstract class AbstractStreamingMessage implements Message { private final Map metadata = new HashMap<>(); diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/BeginMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/BeginMessage.java similarity index 77% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/BeginMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/BeginMessage.java index c66547fc1f..bf20b397cc 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/BeginMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/BeginMessage.java @@ -14,38 +14,37 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; -import static org.neo4j.driver.internal.messaging.request.TransactionMetadataBuilder.buildMetadata; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.TransactionMetadataBuilder.buildMetadata; import java.time.Duration; import java.util.Map; import java.util.Objects; import java.util.Set; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.NotificationConfig; -import org.neo4j.driver.TransactionConfig; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.DatabaseName; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; public class BeginMessage extends MessageWithMetadata { public static final byte SIGNATURE = 0x11; public BeginMessage( - Set bookmarks, - TransactionConfig config, + Set bookmarks, + Duration txTimeout, + Map txMetadata, DatabaseName databaseName, AccessMode mode, String impersonatedUser, String txType, NotificationConfig notificationConfig, - Logging logging) { + LoggingProvider logging) { this( bookmarks, - config.timeout(), - config.metadata(), + txTimeout, + txMetadata, mode, databaseName, impersonatedUser, @@ -55,7 +54,7 @@ public BeginMessage( } public BeginMessage( - Set bookmarks, + Set bookmarks, Duration txTimeout, Map txMetadata, AccessMode mode, @@ -63,7 +62,7 @@ public BeginMessage( String impersonatedUser, String txType, NotificationConfig notificationConfig, - Logging logging) { + LoggingProvider logging) { super(buildMetadata( txTimeout, txMetadata, diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/CommitMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/CommitMessage.java similarity index 87% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/CommitMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/CommitMessage.java index 26b0e0c6e1..f862eafd8b 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/CommitMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/CommitMessage.java @@ -14,9 +14,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; -import org.neo4j.driver.internal.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; public class CommitMessage implements Message { public static final byte SIGNATURE = 0x12; diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/DiscardAllMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/DiscardAllMessage.java similarity index 88% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/DiscardAllMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/DiscardAllMessage.java index afd977c96e..fc8d1026b9 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/DiscardAllMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/DiscardAllMessage.java @@ -14,9 +14,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; -import org.neo4j.driver.internal.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; public class DiscardAllMessage implements Message { public static final byte SIGNATURE = 0x2F; diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/DiscardMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/DiscardMessage.java similarity index 94% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/DiscardMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/DiscardMessage.java index 49dc2f0af0..aef81d260d 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/DiscardMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/DiscardMessage.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; public class DiscardMessage extends AbstractStreamingMessage { public static final byte SIGNATURE = 0x2F; diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/GoodbyeMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/GoodbyeMessage.java similarity index 87% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/GoodbyeMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/GoodbyeMessage.java index 160a2fecb4..e50630731e 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/GoodbyeMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/GoodbyeMessage.java @@ -14,9 +14,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; -import org.neo4j.driver.internal.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; public class GoodbyeMessage implements Message { public static final byte SIGNATURE = 0x02; diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/HelloMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/HelloMessage.java similarity index 87% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/HelloMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/HelloMessage.java index 88b0b28e84..a305799a62 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/HelloMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/HelloMessage.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; import static org.neo4j.driver.Values.value; import static org.neo4j.driver.internal.security.InternalAuthToken.CREDENTIALS_KEY; @@ -23,9 +23,10 @@ import java.util.HashMap; import java.util.Map; import java.util.Objects; -import org.neo4j.driver.NotificationConfig; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.BoltAgent; +import org.neo4j.driver.Values; +import org.neo4j.driver.internal.bolt.api.BoltAgent; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; public class HelloMessage extends MessageWithMetadata { public static final byte SIGNATURE = 0x01; @@ -44,11 +45,11 @@ public class HelloMessage extends MessageWithMetadata { public HelloMessage( String userAgent, BoltAgent boltAgent, - Map authToken, + Map authMap, Map routingContext, boolean includeDateTimeUtc, NotificationConfig notificationConfig) { - super(buildMetadata(userAgent, boltAgent, authToken, routingContext, includeDateTimeUtc, notificationConfig)); + super(buildMetadata(userAgent, boltAgent, authMap, routingContext, includeDateTimeUtc, notificationConfig)); } @Override @@ -83,11 +84,14 @@ public String toString() { private static Map buildMetadata( String userAgent, BoltAgent boltAgent, - Map authToken, + Map authMap, Map routingContext, boolean includeDateTimeUtc, NotificationConfig notificationConfig) { - Map result = new HashMap<>(authToken); + Map result = new HashMap<>(); + for (var entry : authMap.entrySet()) { + result.put(entry.getKey(), Values.value(entry.getValue())); + } if (userAgent != null) { result.put(USER_AGENT_METADATA_KEY, value(userAgent)); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/LogoffMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/LogoffMessage.java similarity index 87% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/LogoffMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/LogoffMessage.java index 1b7926d5a1..ba36290444 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/LogoffMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/LogoffMessage.java @@ -14,9 +14,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; -import org.neo4j.driver.internal.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; public class LogoffMessage implements Message { public static final byte SIGNATURE = 0x6B; diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/LogonMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/LogonMessage.java similarity index 89% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/LogonMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/LogonMessage.java index ccbdfa399e..94ae98dd8b 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/LogonMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/LogonMessage.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; import static org.neo4j.driver.Values.value; import static org.neo4j.driver.internal.security.InternalAuthToken.CREDENTIALS_KEY; @@ -26,8 +26,8 @@ public class LogonMessage extends MessageWithMetadata { public static final byte SIGNATURE = 0x6A; - public LogonMessage(Map authToken) { - super(authToken); + public LogonMessage(Map authMap) { + super(authMap); } @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/MessageWithMetadata.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/MessageWithMetadata.java similarity index 52% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/MessageWithMetadata.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/MessageWithMetadata.java index e16a9d57fd..e5b6cc49d0 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/MessageWithMetadata.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/MessageWithMetadata.java @@ -14,17 +14,14 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; import static org.neo4j.driver.Values.value; import java.util.Map; -import org.neo4j.driver.NotificationConfig; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.InternalNotificationCategory; -import org.neo4j.driver.internal.InternalNotificationConfig; -import org.neo4j.driver.internal.InternalNotificationSeverity; -import org.neo4j.driver.internal.messaging.Message; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; abstract class MessageWithMetadata implements Message { static final String NOTIFICATIONS_MINIMUM_SEVERITY = "notifications_minimum_severity"; @@ -41,21 +38,16 @@ public Map metadata() { static void appendNotificationConfig(Map result, NotificationConfig config) { if (config != null) { - if (config instanceof InternalNotificationConfig internalConfig) { - var severity = (InternalNotificationSeverity) internalConfig.minimumSeverity(); - if (severity != null) { - result.put( - NOTIFICATIONS_MINIMUM_SEVERITY, - value(severity.type().toString())); - } - var disabledCategories = internalConfig.disabledCategories(); - if (disabledCategories != null) { - var list = disabledCategories.stream() - .map(category -> (InternalNotificationCategory) category) - .map(category -> category.type().toString()) - .toList(); - result.put(NOTIFICATIONS_DISABLED_CATEGORIES, value(list)); - } + var severity = config.minimumSeverity(); + if (severity != null) { + result.put(NOTIFICATIONS_MINIMUM_SEVERITY, value(severity.type().toString())); + } + var disabledCategories = config.disabledCategories(); + if (disabledCategories != null) { + var list = disabledCategories.stream() + .map(category -> category.type().toString()) + .toList(); + result.put(NOTIFICATIONS_DISABLED_CATEGORIES, value(list)); } } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/MultiDatabaseUtil.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/MultiDatabaseUtil.java similarity index 63% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/MultiDatabaseUtil.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/MultiDatabaseUtil.java index 69e7ff7781..416519a5cb 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/MultiDatabaseUtil.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/MultiDatabaseUtil.java @@ -14,14 +14,11 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.messaging.BoltProtocolVersion; -import org.neo4j.driver.internal.messaging.v4.BoltProtocolV4; -import org.neo4j.driver.internal.messaging.v43.BoltProtocolV43; -import org.neo4j.driver.internal.spi.Connection; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.DatabaseName; public final class MultiDatabaseUtil { public static void assertEmptyDatabaseName(DatabaseName databaseName, BoltProtocolVersion boltVersion) { @@ -32,12 +29,4 @@ public static void assertEmptyDatabaseName(DatabaseName databaseName, BoltProtoc boltVersion, databaseName.description())); } } - - public static boolean supportsMultiDatabase(Connection connection) { - return connection.protocol().version().compareTo(BoltProtocolV4.VERSION) >= 0; - } - - public static boolean supportsRouteMessage(Connection connection) { - return connection.protocol().version().compareTo(BoltProtocolV43.VERSION) >= 0; - } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/PullAllMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/PullAllMessage.java similarity index 89% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/PullAllMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/PullAllMessage.java index 0a0ff4d90a..6abadd1cde 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/PullAllMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/PullAllMessage.java @@ -14,9 +14,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; -import org.neo4j.driver.internal.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; /** * PULL_ALL request message diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/PullMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/PullMessage.java similarity index 94% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/PullMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/PullMessage.java index 1e27328aea..7c5c4ff2c0 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/PullMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/PullMessage.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; import static org.neo4j.driver.internal.util.MetadataExtractor.ABSENT_QUERY_ID; diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/ResetMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/ResetMessage.java similarity index 92% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/ResetMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/ResetMessage.java index f4ad0a8370..4fc1a61fa5 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/ResetMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/ResetMessage.java @@ -14,9 +14,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; -import org.neo4j.driver.internal.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; /** * RESET request message diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RollbackMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/RollbackMessage.java similarity index 87% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/RollbackMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/RollbackMessage.java index 91b92ea06f..58030e218f 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RollbackMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/RollbackMessage.java @@ -14,9 +14,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; -import org.neo4j.driver.internal.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; public class RollbackMessage implements Message { public static final byte SIGNATURE = 0x13; diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RouteMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/RouteMessage.java similarity index 87% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/RouteMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/RouteMessage.java index a0c273837a..8bcfa1b91c 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RouteMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/RouteMessage.java @@ -14,16 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; import static java.util.Collections.unmodifiableMap; import java.util.Map; import java.util.Objects; import java.util.Set; -import org.neo4j.driver.Bookmark; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; /** * From the application point of view it is not interesting to know about the role a member plays in the cluster. Instead, the application needs to know which @@ -32,7 +31,7 @@ * This message is used to fetch this routing information. */ public record RouteMessage( - Map routingContext, Set bookmarks, String databaseName, String impersonatedUser) + Map routingContext, Set bookmarks, String databaseName, String impersonatedUser) implements Message { public static final byte SIGNATURE = 0x66; @@ -45,7 +44,7 @@ public record RouteMessage( * @param impersonatedUser The name of the impersonated user to get the routing table for, should be {@code null} for non-impersonated requests */ public RouteMessage( - Map routingContext, Set bookmarks, String databaseName, String impersonatedUser) { + Map routingContext, Set bookmarks, String databaseName, String impersonatedUser) { this.routingContext = unmodifiableMap(routingContext); this.bookmarks = bookmarks; this.databaseName = databaseName; diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RunWithMetadataMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/RunWithMetadataMessage.java similarity index 64% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/RunWithMetadataMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/RunWithMetadataMessage.java index c10dc0e28e..6b4f351039 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/RunWithMetadataMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/RunWithMetadataMessage.java @@ -14,24 +14,20 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; import static java.util.Collections.emptyMap; -import static org.neo4j.driver.Values.ofValue; -import static org.neo4j.driver.internal.messaging.request.TransactionMetadataBuilder.buildMetadata; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.TransactionMetadataBuilder.buildMetadata; import java.time.Duration; import java.util.Map; import java.util.Objects; import java.util.Set; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.NotificationConfig; -import org.neo4j.driver.Query; -import org.neo4j.driver.TransactionConfig; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.DatabaseName; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; public class RunWithMetadataMessage extends MessageWithMetadata { public static final byte SIGNATURE = 0x10; @@ -40,36 +36,16 @@ public class RunWithMetadataMessage extends MessageWithMetadata { private final Map parameters; public static RunWithMetadataMessage autoCommitTxRunMessage( - Query query, - TransactionConfig config, - DatabaseName databaseName, - AccessMode mode, - Set bookmarks, - String impersonatedUser, - NotificationConfig notificationConfig, - Logging logging) { - return autoCommitTxRunMessage( - query, - config.timeout(), - config.metadata(), - databaseName, - mode, - bookmarks, - impersonatedUser, - notificationConfig, - logging); - } - - public static RunWithMetadataMessage autoCommitTxRunMessage( - Query query, + String query, + Map parameters, Duration txTimeout, Map txMetadata, DatabaseName databaseName, AccessMode mode, - Set bookmarks, + Set bookmarks, String impersonatedUser, NotificationConfig notificationConfig, - Logging logging) { + LoggingProvider logging) { var metadata = buildMetadata( txTimeout, txMetadata, @@ -80,11 +56,11 @@ public static RunWithMetadataMessage autoCommitTxRunMessage( null, notificationConfig, logging); - return new RunWithMetadataMessage(query.text(), query.parameters().asMap(ofValue()), metadata); + return new RunWithMetadataMessage(query, parameters, metadata); } - public static RunWithMetadataMessage unmanagedTxRunMessage(Query query) { - return new RunWithMetadataMessage(query.text(), query.parameters().asMap(ofValue()), emptyMap()); + public static RunWithMetadataMessage unmanagedTxRunMessage(String query, Map parameters) { + return new RunWithMetadataMessage(query, parameters, emptyMap()); } private RunWithMetadataMessage(String query, Map parameters, Map metadata) { diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/TelemetryMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/TelemetryMessage.java similarity index 88% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/TelemetryMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/TelemetryMessage.java index c577678b01..12109368ee 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/TelemetryMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/TelemetryMessage.java @@ -14,9 +14,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; -import org.neo4j.driver.internal.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; /** * TELEMETRY message diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/TransactionMetadataBuilder.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/TransactionMetadataBuilder.java similarity index 86% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/request/TransactionMetadataBuilder.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/TransactionMetadataBuilder.java index 955d17c44f..5dd42034c1 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/request/TransactionMetadataBuilder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/TransactionMetadataBuilder.java @@ -14,21 +14,20 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; import static java.util.Collections.emptyMap; import static org.neo4j.driver.Values.value; import java.time.Duration; +import java.util.HashMap; import java.util.Map; import java.util.Set; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.NotificationConfig; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.util.Iterables; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; public class TransactionMetadataBuilder { private static final String BOOKMARKS_METADATA_KEY = "bookmarks"; @@ -45,11 +44,11 @@ public static Map buildMetadata( Map txMetadata, DatabaseName databaseName, AccessMode mode, - Set bookmarks, + Set bookmarks, String impersonatedUser, String txType, NotificationConfig notificationConfig, - Logging logging) { + LoggingProvider logging) { var bookmarksPresent = !bookmarks.isEmpty(); var txTimeoutPresent = txTimeout != null; var txMetadataPresent = txMetadata != null && !txMetadata.isEmpty(); @@ -70,17 +69,18 @@ public static Map buildMetadata( return emptyMap(); } - Map result = Iterables.newHashMapWithSize(5); + Map result = new HashMap<>(5); if (bookmarksPresent) { - result.put(BOOKMARKS_METADATA_KEY, value(bookmarks.stream().map(Bookmark::value))); + result.put(BOOKMARKS_METADATA_KEY, value(bookmarks)); } if (txTimeoutPresent) { var millis = txTimeout.toMillis(); if (txTimeout.toNanosPart() % 1_000_000 > 0) { var log = logging.getLog(TransactionMetadataBuilder.class); millis++; - log.info( + log.log( + System.Logger.Level.INFO, "The transaction timeout has been rounded up to next millisecond value since the config had a fractional millisecond value"); } result.put(TX_TIMEOUT_METADATA_KEY, value(millis)); diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/response/FailureMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/response/FailureMessage.java similarity index 91% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/response/FailureMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/response/FailureMessage.java index cfcc20deb1..6e48256cd2 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/response/FailureMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/response/FailureMessage.java @@ -14,12 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.response; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.response; import static java.lang.String.format; import java.util.Objects; -import org.neo4j.driver.internal.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; /** * FAILURE response message diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/response/IgnoredMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/response/IgnoredMessage.java similarity index 90% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/response/IgnoredMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/response/IgnoredMessage.java index a2b3380d4f..e6358a75f3 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/response/IgnoredMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/response/IgnoredMessage.java @@ -14,9 +14,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.response; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.response; -import org.neo4j.driver.internal.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; /** * IGNORED response message diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/response/RecordMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/response/RecordMessage.java similarity index 90% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/response/RecordMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/response/RecordMessage.java index 9a357f1599..a0e061a9b2 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/response/RecordMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/response/RecordMessage.java @@ -14,11 +14,11 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.response; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.response; import java.util.Arrays; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; public record RecordMessage(Value[] fields) implements Message { public static final byte SIGNATURE = 0x71; diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/response/SuccessMessage.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/response/SuccessMessage.java similarity index 90% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/response/SuccessMessage.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/response/SuccessMessage.java index 259da96529..9192e4a12c 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/response/SuccessMessage.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/response/SuccessMessage.java @@ -14,13 +14,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.response; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.response; import static java.lang.String.format; import java.util.Map; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; /** * SUCCESS response message diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/BoltProtocolV3.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/BoltProtocolV3.java new file mode 100644 index 0000000000..1f1699a36c --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/BoltProtocolV3.java @@ -0,0 +1,440 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v3; + +import static org.neo4j.driver.Values.parameters; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.messageDispatcher; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage.COMMIT; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage.ROLLBACK; + +import io.netty.channel.ChannelPromise; +import java.time.Clock; +import java.time.Duration; +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashSet; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionException; +import java.util.concurrent.CompletionStage; +import org.neo4j.driver.Record; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; +import org.neo4j.driver.exceptions.Neo4jException; +import org.neo4j.driver.exceptions.ProtocolException; +import org.neo4j.driver.exceptions.UnsupportedFeatureException; +import org.neo4j.driver.internal.InternalRecord; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltAgent; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ClusterComposition; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.DatabaseNameUtil; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.summary.DiscardSummary; +import org.neo4j.driver.internal.bolt.api.summary.PullSummary; +import org.neo4j.driver.internal.bolt.api.summary.RouteSummary; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.BeginTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.CommitTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.DiscardResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.HelloResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.PullResponseHandlerImpl; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.ResetResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RollbackTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RunResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.PullMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.MultiDatabaseUtil; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; +import org.neo4j.driver.internal.bolt.basicimpl.util.MetadataExtractor; +import org.neo4j.driver.types.MapAccessor; + +public class BoltProtocolV3 implements BoltProtocol { + public static final BoltProtocolVersion VERSION = new BoltProtocolVersion(3, 0); + + public static final BoltProtocol INSTANCE = new BoltProtocolV3(); + + public static final MetadataExtractor METADATA_EXTRACTOR = new MetadataExtractor("t_first"); + + private static final String ROUTING_CONTEXT = "context"; + private static final String GET_ROUTING_TABLE = + "CALL dbms.cluster.routing.getRoutingTable($" + ROUTING_CONTEXT + ")"; + + @Override + public MessageFormat createMessageFormat() { + return new MessageFormatV3(); + } + + @Override + public void initializeChannel( + String userAgent, + BoltAgent boltAgent, + Map authMap, + RoutingContext routingContext, + ChannelPromise channelInitializedPromise, + NotificationConfig notificationConfig, + Clock clock, + CompletableFuture latestAuthMillisFuture) { + var exception = verifyNotificationConfigSupported(notificationConfig); + if (exception != null) { + channelInitializedPromise.setFailure(exception); + return; + } + var channel = channelInitializedPromise.channel(); + HelloMessage message; + + if (routingContext.isServerRoutingEnabled()) { + message = new HelloMessage( + userAgent, + null, + authMap, + routingContext.toMap(), + includeDateTimeUtcPatchInHello(), + notificationConfig); + } else { + message = new HelloMessage( + userAgent, null, authMap, null, includeDateTimeUtcPatchInHello(), notificationConfig); + } + + var future = new CompletableFuture(); + var handler = new HelloResponseHandler(future, channel, clock, latestAuthMillisFuture); + messageDispatcher(channel).enqueue(handler); + channel.writeAndFlush(message, channel.voidPromise()); + future.whenComplete((serverAgent, throwable) -> { + if (throwable != null) { + channelInitializedPromise.setFailure(throwable); + } else { + channelInitializedPromise.setSuccess(); + } + }); + } + + @Override + public CompletionStage route( + Connection connection, + Map routingContext, + Set bookmarks, + String databaseName, + String impersonatedUser, + MessageHandler handler, + Clock clock, + LoggingProvider logging) { + var query = new Query( + GET_ROUTING_TABLE, parameters(ROUTING_CONTEXT, routingContext).asMap(Values::value)); + + var runMessage = RunWithMetadataMessage.autoCommitTxRunMessage( + query.query(), + query.parameters(), + null, + Collections.emptyMap(), + DatabaseNameUtil.defaultDatabase(), + AccessMode.WRITE, + Collections.emptySet(), + null, + NotificationConfig.defaultConfig(), + logging); + var runFuture = new CompletableFuture(); + var runHandler = new RunResponseHandler(runFuture, METADATA_EXTRACTOR); + var pullFuture = new CompletableFuture(); + var records = new ArrayList(); + + runFuture + .thenCompose(ignored -> pullFuture) + .thenApply(ignored -> { + var map = records.get(0); + var ttl = map.get("ttl").asLong(); + var expirationTimestamp = clock.millis() + ttl * 1000; + if (ttl < 0 || ttl >= Long.MAX_VALUE / 1000L || expirationTimestamp < 0) { + expirationTimestamp = Long.MAX_VALUE; + } + + Set readers = new LinkedHashSet<>(); + Set writers = new LinkedHashSet<>(); + Set routers = new LinkedHashSet<>(); + + for (var serversMap : map.get("servers").asList(MapAccessor::asMap)) { + var role = (Values.value(serversMap.get("role")).asString()); + for (var server : + Values.value(serversMap.get("addresses")).asList()) { + var address = + new BoltServerAddress(Values.value(server).asString()); + if (role.equals("WRITE")) { + writers.add(address); + } else if (role.equals("READ")) { + readers.add(address); + } else if (role.equals("ROUTE")) { + routers.add(address); + } + } + } + var db = map.get("db"); + var name = db != null ? db.computeOrDefault(Value::asString, null) : null; + + if (!routers.isEmpty() && !readers.isEmpty()) { + var clusterComposition = + new ClusterComposition(expirationTimestamp, readers, writers, routers, name); + return new RouteSummaryImpl(clusterComposition); + } else { + // todo sync with the original error message + throw new CompletionException( + new ProtocolException( + "Failed to parse result received from server due to no router or reader found in response.")); + } + }) + .whenComplete((summary, throwable) -> { + if (throwable != null) { + handler.onError(throwable); + } else { + handler.onSummary(summary); + } + }); + + return connection.write(runMessage, runHandler).thenCompose(ignored -> { + var pullMessage = PullAllMessage.PULL_ALL; + var pullHandler = new PullResponseHandlerImpl(new PullMessageHandler() { + @Override + public void onRecord(Value[] fields) { + var keys = runFuture.join().keys(); + records.add(new InternalRecord(keys, fields)); + } + + @Override + public void onError(Throwable throwable) { + pullFuture.completeExceptionally(throwable); + } + + @Override + public void onSummary(PullSummary success) { + pullFuture.complete(success); + } + }); + return connection.write(pullMessage, pullHandler); + }); + } + + @Override + public CompletionStage beginTransaction( + Connection connection, + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, + Set bookmarks, + Duration txTimeout, + Map txMetadata, + String txType, + NotificationConfig notificationConfig, + MessageHandler handler, + LoggingProvider logging) { + var exception = verifyNotificationConfigSupported(notificationConfig); + if (exception != null) { + return CompletableFuture.failedStage(exception); + } + try { + verifyDatabaseNameBeforeTransaction(databaseName); + } catch (Exception error) { + return CompletableFuture.failedFuture(error); + } + + var beginTxFuture = new CompletableFuture(); + var beginMessage = new BeginMessage( + bookmarks, + txTimeout, + txMetadata, + databaseName, + accessMode, + impersonatedUser, + txType, + notificationConfig, + logging); + beginTxFuture.whenComplete((ignored, throwable) -> { + if (throwable != null) { + handler.onError(throwable); + } else { + handler.onSummary(null); + } + }); + return connection.write(beginMessage, new BeginTxResponseHandler(beginTxFuture)); + } + + @Override + public CompletionStage commitTransaction(Connection connection, MessageHandler handler) { + var commitFuture = new CompletableFuture(); + commitFuture.whenComplete((bookmark, throwable) -> { + if (throwable != null) { + handler.onError(throwable); + } else { + handler.onSummary(bookmark); + } + }); + return connection.write(COMMIT, new CommitTxResponseHandler(commitFuture)); + } + + @Override + public CompletionStage rollbackTransaction(Connection connection, MessageHandler handler) { + var rollbackFuture = new CompletableFuture(); + rollbackFuture.whenComplete((ignored, throwable) -> { + if (throwable != null) { + handler.onError(throwable); + } else { + handler.onSummary(null); + } + }); + return connection.write(ROLLBACK, new RollbackTxResponseHandler(rollbackFuture)); + } + + @Override + public CompletionStage reset(Connection connection, MessageHandler handler) { + var resetFuture = new CompletableFuture(); + resetFuture.whenComplete((ignored, throwable) -> { + if (throwable != null) { + handler.onError(throwable); + } else { + handler.onSummary(null); + } + }); + var resetHandler = new ResetResponseHandler(resetFuture); + return connection.write(ResetMessage.RESET, resetHandler); + } + + @Override + public CompletionStage telemetry(Connection connection, Integer api, MessageHandler handler) { + return CompletableFuture.failedStage(new UnsupportedFeatureException("telemetry not supported")); + } + + @Override + public CompletionStage runAuto( + Connection connection, + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, + String query, + Map parameters, + Set bookmarks, + Duration txTimeout, + Map txMetadata, + NotificationConfig notificationConfig, + MessageHandler handler, + LoggingProvider logging) { + try { + verifyDatabaseNameBeforeTransaction(databaseName); + } catch (Exception error) { + return CompletableFuture.failedFuture(error); + } + + var runMessage = RunWithMetadataMessage.autoCommitTxRunMessage( + query, + parameters, + txTimeout, + txMetadata, + databaseName, + accessMode, + bookmarks, + impersonatedUser, + notificationConfig, + logging); + var runFuture = new CompletableFuture(); + runFuture.whenComplete((summary, throwable) -> { + if (throwable != null) { + handler.onError(throwable); + } else { + handler.onSummary(summary); + } + }); + var runHandler = new RunResponseHandler(runFuture, METADATA_EXTRACTOR); + return connection.write(runMessage, runHandler); + } + + @Override + public CompletionStage run( + Connection connection, String query, Map parameters, MessageHandler handler) { + var runMessage = RunWithMetadataMessage.unmanagedTxRunMessage(query, parameters); + var runFuture = new CompletableFuture(); + runFuture.whenComplete((summary, throwable) -> { + if (throwable != null) { + handler.onError(throwable); + } else { + handler.onSummary(summary); + } + }); + var runHandler = new RunResponseHandler(runFuture, METADATA_EXTRACTOR); + return connection.write(runMessage, runHandler); + } + + @Override + public CompletionStage pull(Connection connection, long qid, long request, PullMessageHandler handler) { + var pullMessage = PullAllMessage.PULL_ALL; + var pullFuture = new CompletableFuture(); + var pullHandler = new PullResponseHandlerImpl(handler); + return connection.write(pullMessage, pullHandler); + } + + @Override + public CompletionStage discard( + Connection connection, long qid, long number, MessageHandler handler) { + var discardMessage = new DiscardMessage(number, qid); + var discardFuture = new CompletableFuture(); + discardFuture.whenComplete((ignored, throwable) -> { + if (throwable != null) { + handler.onError(throwable); + } else { + handler.onSummary(ignored); + } + }); + var discardHandler = new DiscardResponseHandler(discardFuture); + return connection.write(discardMessage, discardHandler); + } + + protected void verifyDatabaseNameBeforeTransaction(DatabaseName databaseName) { + MultiDatabaseUtil.assertEmptyDatabaseName(databaseName, version()); + } + + @Override + public BoltProtocolVersion version() { + return VERSION; + } + + protected boolean includeDateTimeUtcPatchInHello() { + return false; + } + + protected Neo4jException verifyNotificationConfigSupported(NotificationConfig notificationConfig) { + Neo4jException exception = null; + if (notificationConfig != null && !notificationConfig.equals(NotificationConfig.defaultConfig())) { + exception = new UnsupportedFeatureException(String.format( + "Notification configuration is not supported on Bolt %s", + version().toString())); + } + return exception; + } + + private record RouteSummaryImpl(ClusterComposition clusterComposition) implements RouteSummary {} + + public record Query(String query, Map parameters) {} +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/MessageFormatV3.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/MessageFormatV3.java similarity index 71% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/v3/MessageFormatV3.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/MessageFormatV3.java index 7b2be4e971..510579e1ee 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/MessageFormatV3.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/MessageFormatV3.java @@ -14,12 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v3; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v3; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.common.CommonMessageReader; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonMessageReader; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; public class MessageFormatV3 implements MessageFormat { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/MessageWriterV3.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/MessageWriterV3.java new file mode 100644 index 0000000000..5dfbd182e5 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/MessageWriterV3.java @@ -0,0 +1,60 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v3; + +import java.util.Map; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.AbstractMessageWriter; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.BeginMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.CommitMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.DiscardAllMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.GoodbyeMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.HelloMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.PullAllMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.ResetMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RollbackMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RunWithMetadataMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; + +public class MessageWriterV3 extends AbstractMessageWriter { + public MessageWriterV3(PackOutput output) { + super(new CommonValuePacker(output, false), buildEncoders()); + } + + private static Map buildEncoders() { + return Map.of( + HelloMessage.SIGNATURE, new HelloMessageEncoder(), + GoodbyeMessage.SIGNATURE, new GoodbyeMessageEncoder(), + RunWithMetadataMessage.SIGNATURE, new RunWithMetadataMessageEncoder(), + DiscardAllMessage.SIGNATURE, new DiscardAllMessageEncoder(), + PullAllMessage.SIGNATURE, new PullAllMessageEncoder(), + BeginMessage.SIGNATURE, new BeginMessageEncoder(), + CommitMessage.SIGNATURE, new CommitMessageEncoder(), + RollbackMessage.SIGNATURE, new RollbackMessageEncoder(), + ResetMessage.SIGNATURE, new ResetMessageEncoder()); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/BoltProtocolV4.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/BoltProtocolV4.java new file mode 100644 index 0000000000..9b9a853d10 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/BoltProtocolV4.java @@ -0,0 +1,197 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v4; + +import static org.neo4j.driver.Values.value; + +import java.time.Clock; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.LinkedHashSet; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionException; +import java.util.concurrent.CompletionStage; +import org.neo4j.driver.Record; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; +import org.neo4j.driver.exceptions.ProtocolException; +import org.neo4j.driver.internal.InternalRecord; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ClusterComposition; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.DatabaseNameUtil; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.summary.PullSummary; +import org.neo4j.driver.internal.bolt.api.summary.RouteSummary; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.PullResponseHandlerImpl; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RunResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.PullMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v3.BoltProtocolV3; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; +import org.neo4j.driver.types.MapAccessor; + +public class BoltProtocolV4 extends BoltProtocolV3 { + public static final BoltProtocolVersion VERSION = new BoltProtocolVersion(4, 0); + public static final BoltProtocol INSTANCE = new BoltProtocolV4(); + private static final String ROUTING_CONTEXT = "context"; + private static final String DATABASE_NAME = "database"; + private static final String MULTI_DB_GET_ROUTING_TABLE = + String.format("CALL dbms.routing.getRoutingTable($%s, $%s)", ROUTING_CONTEXT, DATABASE_NAME); + + @Override + public MessageFormat createMessageFormat() { + return new MessageFormatV4(); + } + + @Override + public CompletionStage route( + Connection connection, + Map routingContext, + Set bookmarks, + String databaseName, + String impersonatedUser, + MessageHandler handler, + Clock clock, + LoggingProvider logging) { + var parameters = new HashMap(); + parameters.put(ROUTING_CONTEXT, value(routingContext)); + parameters.put(DATABASE_NAME, value((Object) databaseName)); + var query = new Query(MULTI_DB_GET_ROUTING_TABLE, parameters); + + var runMessage = RunWithMetadataMessage.autoCommitTxRunMessage( + query.query(), + query.parameters(), + null, + Collections.emptyMap(), + DatabaseNameUtil.database("system"), + AccessMode.READ, + bookmarks, + null, + NotificationConfig.defaultConfig(), + logging); + var runFuture = new CompletableFuture(); + var runHandler = new RunResponseHandler(runFuture, METADATA_EXTRACTOR); + + var pullFuture = new CompletableFuture(); + var records = new ArrayList(); + + runFuture + .thenCompose(ignored -> pullFuture) + .thenApply(ignored -> { + var map = records.get(0); + var ttl = map.get("ttl").asLong(); + var expirationTimestamp = clock.millis() + ttl * 1000; + if (ttl < 0 || ttl >= Long.MAX_VALUE / 1000L || expirationTimestamp < 0) { + expirationTimestamp = Long.MAX_VALUE; + } + + Set readers = new LinkedHashSet<>(); + Set writers = new LinkedHashSet<>(); + Set routers = new LinkedHashSet<>(); + + for (var serversMap : map.get("servers").asList(MapAccessor::asMap)) { + var role = (Values.value(serversMap.get("role")).asString()); + for (var server : + Values.value(serversMap.get("addresses")).asList()) { + var address = + new BoltServerAddress(Values.value(server).asString()); + if (role.equals("WRITE")) { + writers.add(address); + } else if (role.equals("READ")) { + readers.add(address); + } else if (role.equals("ROUTE")) { + routers.add(address); + } + } + } + var db = map.get("db"); + var name = db != null ? db.computeOrDefault(Value::asString, null) : null; + + if (!routers.isEmpty() && !readers.isEmpty()) { + var clusterComposition = + new ClusterComposition(expirationTimestamp, readers, writers, routers, name); + return new RouteSummaryImpl(clusterComposition); + } else { + // todo sync with the original error message + throw new CompletionException( + new ProtocolException( + "Failed to parse result received from server due to no router or reader found in response.")); + } + }) + .whenComplete((summary, throwable) -> { + if (throwable != null) { + handler.onError(throwable); + } else { + handler.onSummary(summary); + } + }); + + return connection.write(runMessage, runHandler).thenCompose(ignored -> { + var pullMessage = new PullMessage(-1, -1); + var pullHandler = new PullResponseHandlerImpl(new PullMessageHandler() { + @Override + public void onRecord(Value[] fields) { + var keys = runFuture.join().keys(); + records.add(new InternalRecord(keys, fields)); + } + + @Override + public void onError(Throwable throwable) { + pullFuture.completeExceptionally(throwable); + } + + @Override + public void onSummary(PullSummary success) { + pullFuture.complete(success); + } + }); + return connection.write(pullMessage, pullHandler); + }); + } + + @Override + public CompletionStage pull(Connection connection, long qid, long request, PullMessageHandler handler) { + var pullMessage = new PullMessage(request, qid); + var pullFuture = new CompletableFuture(); + var pullHandler = new PullResponseHandlerImpl(handler); + return connection.write(pullMessage, pullHandler); + } + + @Override + protected void verifyDatabaseNameBeforeTransaction(DatabaseName databaseName) { + // Bolt V4 accepts database name + } + + @Override + public BoltProtocolVersion version() { + return VERSION; + } + + private record RouteSummaryImpl(ClusterComposition clusterComposition) implements RouteSummary {} +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v4/MessageFormatV4.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/MessageFormatV4.java similarity index 71% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/v4/MessageFormatV4.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/MessageFormatV4.java index 8af696eeb7..7b08533586 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v4/MessageFormatV4.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/MessageFormatV4.java @@ -14,12 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v4; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v4; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.common.CommonMessageReader; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonMessageReader; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; public class MessageFormatV4 implements MessageFormat { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/MessageWriterV4.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/MessageWriterV4.java new file mode 100644 index 0000000000..6a642511dc --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/MessageWriterV4.java @@ -0,0 +1,61 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v4; + +import java.util.Map; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.AbstractMessageWriter; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.BeginMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.CommitMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.DiscardMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.GoodbyeMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.HelloMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.PullMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.ResetMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RollbackMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RunWithMetadataMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; + +public class MessageWriterV4 extends AbstractMessageWriter { + public MessageWriterV4(PackOutput output) { + super(new CommonValuePacker(output, false), buildEncoders()); + } + + @SuppressWarnings("DuplicatedCode") + private static Map buildEncoders() { + return Map.of( + HelloMessage.SIGNATURE, new HelloMessageEncoder(), + GoodbyeMessage.SIGNATURE, new GoodbyeMessageEncoder(), + RunWithMetadataMessage.SIGNATURE, new RunWithMetadataMessageEncoder(), + DiscardMessage.SIGNATURE, new DiscardMessageEncoder(), + PullMessage.SIGNATURE, new PullMessageEncoder(), + BeginMessage.SIGNATURE, new BeginMessageEncoder(), + CommitMessage.SIGNATURE, new CommitMessageEncoder(), + RollbackMessage.SIGNATURE, new RollbackMessageEncoder(), + ResetMessage.SIGNATURE, new ResetMessageEncoder()); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v41/BoltProtocolV41.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v41/BoltProtocolV41.java similarity index 77% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/v41/BoltProtocolV41.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v41/BoltProtocolV41.java index 587739a00d..4e58990515 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v41/BoltProtocolV41.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v41/BoltProtocolV41.java @@ -14,11 +14,11 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v41; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v41; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.BoltProtocolVersion; -import org.neo4j.driver.internal.messaging.v4.BoltProtocolV4; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v4.BoltProtocolV4; public class BoltProtocolV41 extends BoltProtocolV4 { public static final BoltProtocolVersion VERSION = new BoltProtocolVersion(4, 1); diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v42/BoltProtocolV42.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v42/BoltProtocolV42.java similarity index 77% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/v42/BoltProtocolV42.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v42/BoltProtocolV42.java index 9cff58ebf3..632eae463e 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v42/BoltProtocolV42.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v42/BoltProtocolV42.java @@ -14,11 +14,11 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v42; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v42; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.BoltProtocolVersion; -import org.neo4j.driver.internal.messaging.v41.BoltProtocolV41; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v41.BoltProtocolV41; /** * Bolt V4.2 is identical to V4.1 diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/BoltProtocolV43.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/BoltProtocolV43.java new file mode 100644 index 0000000000..4a9679abd5 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/BoltProtocolV43.java @@ -0,0 +1,132 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v43; + +import java.time.Clock; +import java.util.LinkedHashSet; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionException; +import java.util.concurrent.CompletionStage; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; +import org.neo4j.driver.exceptions.ProtocolException; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ClusterComposition; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.summary.RouteSummary; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RouteMessageResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RouteMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v42.BoltProtocolV42; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; +import org.neo4j.driver.types.MapAccessor; + +/** + * Definition of the Bolt Protocol 4.3 + *

+ * The version 4.3 use most of the 4.2 behaviours, but it extends it with new messages such as ROUTE + */ +public class BoltProtocolV43 extends BoltProtocolV42 { + public static final BoltProtocolVersion VERSION = new BoltProtocolVersion(4, 3); + public static final BoltProtocol INSTANCE = new BoltProtocolV43(); + + @Override + public MessageFormat createMessageFormat() { + return new MessageFormatV43(); + } + + @Override + public CompletionStage route( + Connection connection, + Map routingContext, + Set bookmarks, + String databaseName, + String impersonatedUser, + MessageHandler handler, + Clock clock, + LoggingProvider logging) { + var routeMessage = new RouteMessage(routingContext, bookmarks, databaseName, impersonatedUser); + var routeFuture = new CompletableFuture>(); + routeFuture + .thenApply(map -> { + var ttl = map.get("ttl").asLong(); + var expirationTimestamp = clock.millis() + ttl * 1000; + if (ttl < 0 || ttl >= Long.MAX_VALUE / 1000L || expirationTimestamp < 0) { + expirationTimestamp = Long.MAX_VALUE; + } + + Set readers = new LinkedHashSet<>(); + Set writers = new LinkedHashSet<>(); + Set routers = new LinkedHashSet<>(); + + for (var serversMap : map.get("servers").asList(MapAccessor::asMap)) { + var role = (Values.value(serversMap.get("role")).asString()); + for (var server : + Values.value(serversMap.get("addresses")).asList()) { + var address = + new BoltServerAddress(Values.value(server).asString()); + if (role.equals("WRITE")) { + writers.add(address); + } else if (role.equals("READ")) { + readers.add(address); + } else if (role.equals("ROUTE")) { + routers.add(address); + } + } + } + var db = map.get("db"); + var name = db != null ? db.computeOrDefault(Value::asString, null) : null; + + if (!routers.isEmpty() && !readers.isEmpty()) { + var clusterComposition = + new ClusterComposition(expirationTimestamp, readers, writers, routers, name); + return new RouteSummaryImpl(clusterComposition); + } else { + // todo sync with the original error message + throw new CompletionException( + new ProtocolException( + "Failed to parse result received from server due to no router or reader found in response.")); + } + }) + .whenComplete((summary, throwable) -> { + if (throwable != null) { + handler.onError(throwable); + } else { + handler.onSummary(summary); + } + }); + var routeHandler = new RouteMessageResponseHandler(routeFuture); + return connection.write(routeMessage, routeHandler); + } + + @Override + public BoltProtocolVersion version() { + return VERSION; + } + + @Override + protected boolean includeDateTimeUtcPatchInHello() { + return true; + } + + private record RouteSummaryImpl(ClusterComposition clusterComposition) implements RouteSummary {} +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v43/MessageFormatV43.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/MessageFormatV43.java similarity index 75% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/v43/MessageFormatV43.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/MessageFormatV43.java index 5ad2da5d96..f56a50d9c7 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v43/MessageFormatV43.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/MessageFormatV43.java @@ -14,12 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v43; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v43; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.common.CommonMessageReader; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonMessageReader; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; /** * Bolt message format v4.3 diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/MessageWriterV43.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/MessageWriterV43.java new file mode 100644 index 0000000000..3bc8a79182 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/MessageWriterV43.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v43; + +import java.util.Map; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.AbstractMessageWriter; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.BeginMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.CommitMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.DiscardMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.GoodbyeMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.HelloMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.PullMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.ResetMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RollbackMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RouteMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RunWithMetadataMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RouteMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; + +/** + * Bolt message writer v4.3 + *

+ * This version is able to encode all the versions existing on v4.2, but it encodes + * new messages such as ROUTE + */ +public class MessageWriterV43 extends AbstractMessageWriter { + public MessageWriterV43(PackOutput output, boolean dateTimeUtcEnabled) { + super(new CommonValuePacker(output, dateTimeUtcEnabled), buildEncoders()); + } + + @SuppressWarnings("DuplicatedCode") + private static Map buildEncoders() { + return Map.of( + HelloMessage.SIGNATURE, new HelloMessageEncoder(), + GoodbyeMessage.SIGNATURE, new GoodbyeMessageEncoder(), + RunWithMetadataMessage.SIGNATURE, new RunWithMetadataMessageEncoder(), + RouteMessage.SIGNATURE, new RouteMessageEncoder(), + DiscardMessage.SIGNATURE, new DiscardMessageEncoder(), + PullMessage.SIGNATURE, new PullMessageEncoder(), + BeginMessage.SIGNATURE, new BeginMessageEncoder(), + CommitMessage.SIGNATURE, new CommitMessageEncoder(), + RollbackMessage.SIGNATURE, new RollbackMessageEncoder(), + ResetMessage.SIGNATURE, new ResetMessageEncoder()); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v44/BoltProtocolV44.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/BoltProtocolV44.java similarity index 75% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/v44/BoltProtocolV44.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/BoltProtocolV44.java index 3c9f3c1339..8a5f442634 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v44/BoltProtocolV44.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/BoltProtocolV44.java @@ -14,12 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v44; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v44; -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.v43.BoltProtocolV43; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v43.BoltProtocolV43; /** * Definition of the Bolt Protocol 4.4 diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v44/MessageFormatV44.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/MessageFormatV44.java similarity index 76% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/v44/MessageFormatV44.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/MessageFormatV44.java index 6805da7cb7..603a6bfd2c 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v44/MessageFormatV44.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/MessageFormatV44.java @@ -14,12 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v44; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v44; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.common.CommonMessageReader; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonMessageReader; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; /** * Bolt message format v4.4 diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/MessageWriterV44.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/MessageWriterV44.java new file mode 100644 index 0000000000..6c0dad82aa --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/MessageWriterV44.java @@ -0,0 +1,67 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v44; + +import java.util.Map; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.AbstractMessageWriter; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.BeginMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.CommitMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.DiscardMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.GoodbyeMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.HelloMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.PullMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.ResetMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RollbackMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RouteV44MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RunWithMetadataMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RouteMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; + +/** + * Bolt message writer v4.4 + */ +public class MessageWriterV44 extends AbstractMessageWriter { + public MessageWriterV44(PackOutput output, boolean dateTimeUtcEnabled) { + super(new CommonValuePacker(output, dateTimeUtcEnabled), buildEncoders()); + } + + @SuppressWarnings("DuplicatedCode") + private static Map buildEncoders() { + return Map.of( + HelloMessage.SIGNATURE, new HelloMessageEncoder(), + GoodbyeMessage.SIGNATURE, new GoodbyeMessageEncoder(), + RunWithMetadataMessage.SIGNATURE, new RunWithMetadataMessageEncoder(), + RouteMessage.SIGNATURE, new RouteV44MessageEncoder(), + DiscardMessage.SIGNATURE, new DiscardMessageEncoder(), + PullMessage.SIGNATURE, new PullMessageEncoder(), + BeginMessage.SIGNATURE, new BeginMessageEncoder(), + CommitMessage.SIGNATURE, new CommitMessageEncoder(), + RollbackMessage.SIGNATURE, new RollbackMessageEncoder(), + ResetMessage.SIGNATURE, new ResetMessageEncoder()); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v5/BoltProtocolV5.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/BoltProtocolV5.java similarity index 76% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/v5/BoltProtocolV5.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/BoltProtocolV5.java index daa3a9385a..736f4895a8 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v5/BoltProtocolV5.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/BoltProtocolV5.java @@ -14,12 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v5; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v5; -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.v44.BoltProtocolV44; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v44.BoltProtocolV44; public class BoltProtocolV5 extends BoltProtocolV44 { public static final BoltProtocolVersion VERSION = new BoltProtocolVersion(5, 0); diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v5/MessageFormatV5.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageFormatV5.java similarity index 76% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/v5/MessageFormatV5.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageFormatV5.java index 064d659f90..6be0cef5f1 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v5/MessageFormatV5.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageFormatV5.java @@ -14,11 +14,11 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v5; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v5; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; public class MessageFormatV5 implements MessageFormat { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v5/MessageReaderV5.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageReaderV5.java similarity index 78% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/v5/MessageReaderV5.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageReaderV5.java index c8beb621e3..473de2ad7d 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v5/MessageReaderV5.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageReaderV5.java @@ -14,10 +14,10 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v5; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v5; -import org.neo4j.driver.internal.messaging.common.CommonMessageReader; -import org.neo4j.driver.internal.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonMessageReader; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; public class MessageReaderV5 extends CommonMessageReader { public MessageReaderV5(PackInput input) { diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageWriterV5.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageWriterV5.java new file mode 100644 index 0000000000..8683cb95e0 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageWriterV5.java @@ -0,0 +1,64 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v5; + +import java.util.Map; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.AbstractMessageWriter; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.BeginMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.CommitMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.DiscardMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.GoodbyeMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.HelloMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.PullMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.ResetMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RollbackMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RouteV44MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RunWithMetadataMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RouteMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; + +public class MessageWriterV5 extends AbstractMessageWriter { + public MessageWriterV5(PackOutput output) { + super(new CommonValuePacker(output, true), buildEncoders()); + } + + @SuppressWarnings("DuplicatedCode") + private static Map buildEncoders() { + return Map.ofEntries( + Map.entry(HelloMessage.SIGNATURE, new HelloMessageEncoder()), + Map.entry(GoodbyeMessage.SIGNATURE, new GoodbyeMessageEncoder()), + Map.entry(RunWithMetadataMessage.SIGNATURE, new RunWithMetadataMessageEncoder()), + Map.entry(RouteMessage.SIGNATURE, new RouteV44MessageEncoder()), + Map.entry(DiscardMessage.SIGNATURE, new DiscardMessageEncoder()), + Map.entry(PullMessage.SIGNATURE, new PullMessageEncoder()), + Map.entry(BeginMessage.SIGNATURE, new BeginMessageEncoder()), + Map.entry(CommitMessage.SIGNATURE, new CommitMessageEncoder()), + Map.entry(RollbackMessage.SIGNATURE, new RollbackMessageEncoder()), + Map.entry(ResetMessage.SIGNATURE, new ResetMessageEncoder())); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v5/ValueUnpackerV5.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/ValueUnpackerV5.java similarity index 95% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/v5/ValueUnpackerV5.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/ValueUnpackerV5.java index 7aba290ff9..8480656715 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v5/ValueUnpackerV5.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/ValueUnpackerV5.java @@ -14,21 +14,21 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v5; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v5; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; +import java.util.HashMap; import java.util.List; import java.util.Map; import org.neo4j.driver.Value; import org.neo4j.driver.internal.InternalNode; import org.neo4j.driver.internal.InternalPath; import org.neo4j.driver.internal.InternalRelationship; -import org.neo4j.driver.internal.messaging.common.CommonValueUnpacker; -import org.neo4j.driver.internal.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonValueUnpacker; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; import org.neo4j.driver.internal.types.TypeConstructor; -import org.neo4j.driver.internal.util.Iterables; import org.neo4j.driver.internal.value.PathValue; import org.neo4j.driver.internal.value.RelationshipValue; import org.neo4j.driver.types.Node; @@ -64,7 +64,7 @@ protected InternalNode unpackNode() throws IOException { labels.add(unpacker.unpackString()); } var numProps = (int) unpacker.unpackMapHeader(); - Map props = Iterables.newHashMapWithSize(numProps); + Map props = new HashMap<>(numProps); for (var j = 0; j < numProps; j++) { var key = unpacker.unpackString(); props.put(key, unpack()); diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/BoltProtocolV51.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/BoltProtocolV51.java new file mode 100644 index 0000000000..768802375f --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/BoltProtocolV51.java @@ -0,0 +1,134 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v51; + +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.messageDispatcher; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setHelloStage; + +import io.netty.channel.ChannelPromise; +import java.time.Clock; +import java.util.Collections; +import java.util.Map; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import org.neo4j.driver.Value; +import org.neo4j.driver.internal.bolt.api.BoltAgent; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.HelloV51ResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.LogoffResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.LogonResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.LogoffMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.LogonMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v5.BoltProtocolV5; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; + +public class BoltProtocolV51 extends BoltProtocolV5 { + public static final BoltProtocolVersion VERSION = new BoltProtocolVersion(5, 1); + public static final BoltProtocol INSTANCE = new BoltProtocolV51(); + + @Override + public void initializeChannel( + String userAgent, + BoltAgent boltAgent, + Map authMap, + RoutingContext routingContext, + ChannelPromise channelInitializedPromise, + NotificationConfig notificationConfig, + Clock clock, + CompletableFuture latestAuthMillisFuture) { + var exception = verifyNotificationConfigSupported(notificationConfig); + if (exception != null) { + channelInitializedPromise.setFailure(exception); + return; + } + var channel = channelInitializedPromise.channel(); + HelloMessage message; + + if (routingContext.isServerRoutingEnabled()) { + message = new HelloMessage( + userAgent, null, Collections.emptyMap(), routingContext.toMap(), false, notificationConfig); + } else { + message = new HelloMessage(userAgent, null, Collections.emptyMap(), null, false, notificationConfig); + } + + var helloFuture = new CompletableFuture(); + setHelloStage(channel, helloFuture.thenApply(ignored -> null)); + messageDispatcher(channel).enqueue(new HelloV51ResponseHandler(channel, helloFuture)); + channel.write(message, channel.voidPromise()); + + var logonFuture = new CompletableFuture(); + var logon = new LogonMessage(authMap); + messageDispatcher(channel) + .enqueue(new LogonResponseHandler(logonFuture, channel, clock, latestAuthMillisFuture)); + channel.writeAndFlush(logon, channel.voidPromise()); + + helloFuture.thenCompose(ignored -> logonFuture).whenComplete((ignored, throwable) -> { + if (throwable != null) { + channelInitializedPromise.setFailure(throwable); + } else { + channelInitializedPromise.setSuccess(); + } + }); + } + + @Override + public CompletionStage logoff(Connection connection, MessageHandler handler) { + var logoffMessage = LogoffMessage.INSTANCE; + var logoffFuture = new CompletableFuture(); + logoffFuture.whenComplete((ignored, throwable) -> { + if (throwable != null) { + handler.onError(throwable); + } else { + handler.onSummary(null); + } + }); + var logoffHandler = new LogoffResponseHandler(logoffFuture); + return connection.write(logoffMessage, logoffHandler); + } + + @Override + public CompletionStage logon( + Connection connection, Map authMap, Clock clock, MessageHandler handler) { + var logonMessage = new LogonMessage(authMap); + var logonFuture = new CompletableFuture(); + logonFuture.whenComplete((ignored, throwable) -> { + if (throwable != null) { + handler.onError(throwable); + } else { + handler.onSummary(null); + } + }); + var logonHandler = new LogonResponseHandler(logonFuture, null, clock, logonFuture); + return connection.write(logonMessage, logonHandler); + } + + @Override + public BoltProtocolVersion version() { + return VERSION; + } + + @Override + public MessageFormat createMessageFormat() { + return new MessageFormatV51(); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v51/MessageFormatV51.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/MessageFormatV51.java similarity index 71% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/v51/MessageFormatV51.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/MessageFormatV51.java index 2125071501..8fac3f34f2 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v51/MessageFormatV51.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/MessageFormatV51.java @@ -14,12 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v51; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v51; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.v5.MessageReaderV5; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v5.MessageReaderV5; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; public class MessageFormatV51 implements MessageFormat { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/MessageWriterV51.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/MessageWriterV51.java new file mode 100644 index 0000000000..7de0dc9bf1 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/MessageWriterV51.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v51; + +import java.util.Map; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.AbstractMessageWriter; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.BeginMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.CommitMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.DiscardMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.GoodbyeMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.HelloMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.LogoffMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.LogonMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.PullMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.ResetMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RollbackMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RouteV44MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RunWithMetadataMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.LogoffMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.LogonMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RouteMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; + +public class MessageWriterV51 extends AbstractMessageWriter { + public MessageWriterV51(PackOutput output) { + super(new CommonValuePacker(output, true), buildEncoders()); + } + + @SuppressWarnings("DuplicatedCode") + private static Map buildEncoders() { + return Map.ofEntries( + Map.entry(HelloMessage.SIGNATURE, new HelloMessageEncoder()), + Map.entry(LogonMessage.SIGNATURE, new LogonMessageEncoder()), + Map.entry(LogoffMessage.SIGNATURE, new LogoffMessageEncoder()), + Map.entry(GoodbyeMessage.SIGNATURE, new GoodbyeMessageEncoder()), + Map.entry(RunWithMetadataMessage.SIGNATURE, new RunWithMetadataMessageEncoder()), + Map.entry(RouteMessage.SIGNATURE, new RouteV44MessageEncoder()), + Map.entry(DiscardMessage.SIGNATURE, new DiscardMessageEncoder()), + Map.entry(PullMessage.SIGNATURE, new PullMessageEncoder()), + Map.entry(BeginMessage.SIGNATURE, new BeginMessageEncoder()), + Map.entry(CommitMessage.SIGNATURE, new CommitMessageEncoder()), + Map.entry(RollbackMessage.SIGNATURE, new RollbackMessageEncoder()), + Map.entry(ResetMessage.SIGNATURE, new ResetMessageEncoder())); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v52/BoltProtocolV52.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v52/BoltProtocolV52.java similarity index 76% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/v52/BoltProtocolV52.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v52/BoltProtocolV52.java index 64ec22681c..abc2e735e3 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v52/BoltProtocolV52.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v52/BoltProtocolV52.java @@ -14,13 +14,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v52; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v52; -import org.neo4j.driver.NotificationConfig; import org.neo4j.driver.exceptions.Neo4jException; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.BoltProtocolVersion; -import org.neo4j.driver.internal.messaging.v51.BoltProtocolV51; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v51.BoltProtocolV51; public class BoltProtocolV52 extends BoltProtocolV51 { public static final BoltProtocolVersion VERSION = new BoltProtocolVersion(5, 2); diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v53/BoltProtocolV53.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v53/BoltProtocolV53.java similarity index 52% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/v53/BoltProtocolV53.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v53/BoltProtocolV53.java index 237d3b1b75..04af13b491 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v53/BoltProtocolV53.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v53/BoltProtocolV53.java @@ -14,24 +14,27 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v53; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v53; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.messageDispatcher; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setHelloStage; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.messageDispatcher; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setHelloStage; import io.netty.channel.ChannelPromise; import java.time.Clock; import java.util.Collections; +import java.util.Map; import java.util.concurrent.CompletableFuture; -import org.neo4j.driver.AuthToken; -import org.neo4j.driver.NotificationConfig; -import org.neo4j.driver.internal.BoltAgent; -import org.neo4j.driver.internal.cluster.RoutingContext; -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.request.HelloMessage; -import org.neo4j.driver.internal.messaging.v52.BoltProtocolV52; +import org.neo4j.driver.Value; +import org.neo4j.driver.internal.bolt.api.BoltAgent; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.HelloV51ResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.LogonResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.LogonMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v52.BoltProtocolV52; public class BoltProtocolV53 extends BoltProtocolV52 { public static final BoltProtocolVersion VERSION = new BoltProtocolVersion(5, 3); @@ -41,11 +44,12 @@ public class BoltProtocolV53 extends BoltProtocolV52 { public void initializeChannel( String userAgent, BoltAgent boltAgent, - AuthToken authToken, + Map authMap, RoutingContext routingContext, ChannelPromise channelInitializedPromise, NotificationConfig notificationConfig, - Clock clock) { + Clock clock, + CompletableFuture latestAuthMillisFuture) { var exception = verifyNotificationConfigSupported(notificationConfig); if (exception != null) { channelInitializedPromise.setFailure(exception); @@ -61,11 +65,24 @@ public void initializeChannel( message = new HelloMessage(userAgent, boltAgent, Collections.emptyMap(), null, false, notificationConfig); } - var helloFuture = new CompletableFuture(); - setHelloStage(channel, helloFuture); + var helloFuture = new CompletableFuture(); + setHelloStage(channel, helloFuture.thenApply(ignored -> null)); messageDispatcher(channel).enqueue(new HelloV51ResponseHandler(channel, helloFuture)); channel.write(message, channel.voidPromise()); - channelInitializedPromise.setSuccess(); + + var logonFuture = new CompletableFuture(); + var logon = new LogonMessage(authMap); + messageDispatcher(channel) + .enqueue(new LogonResponseHandler(logonFuture, channel, clock, latestAuthMillisFuture)); + channel.writeAndFlush(logon, channel.voidPromise()); + + helloFuture.thenCompose(ignored -> logonFuture).whenComplete((ignored, throwable) -> { + if (throwable != null) { + channelInitializedPromise.setFailure(throwable); + } else { + channelInitializedPromise.setSuccess(); + } + }); } @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v54/BoltProtocolV54.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/BoltProtocolV54.java similarity index 56% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/v54/BoltProtocolV54.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/BoltProtocolV54.java index f1d3592d3b..6dcb0a5226 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v54/BoltProtocolV54.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/BoltProtocolV54.java @@ -14,17 +14,18 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v54; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v54; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionStage; -import org.neo4j.driver.internal.handlers.TelemetryResponseHandler; -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.TelemetryMessage; -import org.neo4j.driver.internal.messaging.v53.BoltProtocolV53; -import org.neo4j.driver.internal.spi.Connection; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.TelemetryResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.TelemetryMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v53.BoltProtocolV53; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; public class BoltProtocolV54 extends BoltProtocolV53 { public static final BoltProtocolVersion VERSION = new BoltProtocolVersion(5, 4); @@ -36,11 +37,17 @@ public BoltProtocolVersion version() { } @Override - public CompletionStage telemetry(Connection connection, Integer api) { + public CompletionStage telemetry(Connection connection, Integer api, MessageHandler handler) { var telemetry = new TelemetryMessage(api); var future = new CompletableFuture(); - connection.write(telemetry, new TelemetryResponseHandler(future)); - return future; + future.whenComplete((ignored, throwable) -> { + if (throwable != null) { + handler.onError(throwable); + } else { + handler.onSummary(null); + } + }); + return connection.write(telemetry, new TelemetryResponseHandler(future)); } @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v54/MessageFormatV54.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/MessageFormatV54.java similarity index 71% rename from driver/src/main/java/org/neo4j/driver/internal/messaging/v54/MessageFormatV54.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/MessageFormatV54.java index e1bb154ece..2e11093062 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v54/MessageFormatV54.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/MessageFormatV54.java @@ -14,12 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v54; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v54; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.v5.MessageReaderV5; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v5.MessageReaderV5; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; public class MessageFormatV54 implements MessageFormat { @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/MessageWriterV54.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/MessageWriterV54.java new file mode 100644 index 0000000000..516dd1faa6 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/MessageWriterV54.java @@ -0,0 +1,73 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v54; + +import java.util.Map; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.AbstractMessageWriter; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.BeginMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.CommitMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.DiscardMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.GoodbyeMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.HelloMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.LogoffMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.LogonMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.PullMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.ResetMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RollbackMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RouteV44MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.RunWithMetadataMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.TelemetryMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.LogoffMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.LogonMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RouteMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.TelemetryMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; + +public class MessageWriterV54 extends AbstractMessageWriter { + public MessageWriterV54(PackOutput output) { + super(new CommonValuePacker(output, true), buildEncoders()); + } + + @SuppressWarnings("DuplicatedCode") + private static Map buildEncoders() { + return Map.ofEntries( + Map.entry(HelloMessage.SIGNATURE, new HelloMessageEncoder()), + Map.entry(LogonMessage.SIGNATURE, new LogonMessageEncoder()), + Map.entry(LogoffMessage.SIGNATURE, new LogoffMessageEncoder()), + Map.entry(GoodbyeMessage.SIGNATURE, new GoodbyeMessageEncoder()), + Map.entry(RunWithMetadataMessage.SIGNATURE, new RunWithMetadataMessageEncoder()), + Map.entry(RouteMessage.SIGNATURE, new RouteV44MessageEncoder()), + Map.entry(DiscardMessage.SIGNATURE, new DiscardMessageEncoder()), + Map.entry(PullMessage.SIGNATURE, new PullMessageEncoder()), + Map.entry(BeginMessage.SIGNATURE, new BeginMessageEncoder()), + Map.entry(CommitMessage.SIGNATURE, new CommitMessageEncoder()), + Map.entry(RollbackMessage.SIGNATURE, new RollbackMessageEncoder()), + Map.entry(ResetMessage.SIGNATURE, new ResetMessageEncoder()), + Map.entry(TelemetryMessage.SIGNATURE, new TelemetryMessageEncoder())); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/packstream/PackInput.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/packstream/PackInput.java similarity index 96% rename from driver/src/main/java/org/neo4j/driver/internal/packstream/PackInput.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/packstream/PackInput.java index 6122e20b42..bcbdf2ea8d 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/packstream/PackInput.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/packstream/PackInput.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.packstream; +package org.neo4j.driver.internal.bolt.basicimpl.packstream; import java.io.IOException; diff --git a/driver/src/main/java/org/neo4j/driver/internal/packstream/PackOutput.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/packstream/PackOutput.java similarity index 96% rename from driver/src/main/java/org/neo4j/driver/internal/packstream/PackOutput.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/packstream/PackOutput.java index e79f095462..5dd7c2e974 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/packstream/PackOutput.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/packstream/PackOutput.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.packstream; +package org.neo4j.driver.internal.bolt.basicimpl.packstream; import java.io.IOException; diff --git a/driver/src/main/java/org/neo4j/driver/internal/packstream/PackStream.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/packstream/PackStream.java similarity index 99% rename from driver/src/main/java/org/neo4j/driver/internal/packstream/PackStream.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/packstream/PackStream.java index 69a214bd75..535c7fa7aa 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/packstream/PackStream.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/packstream/PackStream.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.packstream; +package org.neo4j.driver.internal.bolt.basicimpl.packstream; import static java.lang.Integer.toHexString; import static java.lang.String.format; diff --git a/driver/src/main/java/org/neo4j/driver/internal/packstream/PackType.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/packstream/PackType.java similarity index 92% rename from driver/src/main/java/org/neo4j/driver/internal/packstream/PackType.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/packstream/PackType.java index 4805ab7107..2caf7eb75f 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/packstream/PackType.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/packstream/PackType.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.packstream; +package org.neo4j.driver.internal.bolt.basicimpl.packstream; public enum PackType { NULL, diff --git a/driver/src/main/java/org/neo4j/driver/internal/spi/ConnectionPool.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/spi/Connection.java similarity index 50% rename from driver/src/main/java/org/neo4j/driver/internal/spi/ConnectionPool.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/spi/Connection.java index d47c562bab..01843a0d81 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/spi/ConnectionPool.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/spi/Connection.java @@ -14,24 +14,36 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.spi; +package org.neo4j.driver.internal.bolt.basicimpl.spi; -import java.util.Set; +import io.netty.channel.EventLoop; import java.util.concurrent.CompletionStage; -import org.neo4j.driver.AuthToken; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.net.ServerAddress; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; -public interface ConnectionPool { - String CONNECTION_POOL_CLOSED_ERROR_MESSAGE = "Pool closed"; +public interface Connection { + boolean isOpen(); - CompletionStage acquire(BoltServerAddress address, AuthToken overrideAuthToken); + void enableAutoRead(); - void retainAll(Set addressesToRetain); + void disableAutoRead(); - int inUseConnections(ServerAddress address); + CompletionStage write(Message message, ResponseHandler handler); + + CompletionStage flush(); + + boolean isTelemetryEnabled(); + + String serverAgent(); + + BoltServerAddress serverAddress(); + + BoltProtocol protocol(); + + CompletionStage forceClose(String reason); CompletionStage close(); - boolean isOpen(BoltServerAddress address); + EventLoop eventLoop(); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/spi/ResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/spi/ResponseHandler.java similarity index 92% rename from driver/src/main/java/org/neo4j/driver/internal/spi/ResponseHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/spi/ResponseHandler.java index dd72318012..6e9659a8b5 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/spi/ResponseHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/spi/ResponseHandler.java @@ -14,11 +14,11 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.spi; +package org.neo4j.driver.internal.bolt.basicimpl.spi; import java.util.Map; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; public interface ResponseHandler { void onSuccess(Map metadata); diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/util/FutureUtil.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/util/FutureUtil.java new file mode 100644 index 0000000000..74872e1d8c --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/util/FutureUtil.java @@ -0,0 +1,28 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.util; + +import java.util.concurrent.CompletionException; + +public class FutureUtil { + public static Throwable completionExceptionCause(Throwable error) { + if (error instanceof CompletionException) { + return error.getCause(); + } + return error; + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/util/LockUtil.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/util/LockUtil.java new file mode 100644 index 0000000000..b0e121d946 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/util/LockUtil.java @@ -0,0 +1,48 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.util; + +import java.util.concurrent.locks.Lock; +import java.util.function.Supplier; + +public class LockUtil { + public static void executeWithLock(Lock lock, Runnable runnable) { + lock(lock); + try { + runnable.run(); + } finally { + unlock(lock); + } + } + + public static T executeWithLock(Lock lock, Supplier supplier) { + lock(lock); + try { + return supplier.get(); + } finally { + unlock(lock); + } + } + + private static void lock(Lock lock) { + lock.lock(); + } + + private static void unlock(Lock lock) { + lock.unlock(); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/util/MetadataExtractor.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/util/MetadataExtractor.java new file mode 100644 index 0000000000..3e0442dbd1 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/util/MetadataExtractor.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.util; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import org.neo4j.driver.Value; +import org.neo4j.driver.exceptions.UntrustedServerException; + +public class MetadataExtractor { + public static final int ABSENT_QUERY_ID = -1; + private final String resultAvailableAfterMetadataKey; + + public MetadataExtractor(String resultAvailableAfterMetadataKey) { + this.resultAvailableAfterMetadataKey = resultAvailableAfterMetadataKey; + } + + public List extractQueryKeys(Map metadata) { + var keysValue = metadata.get("fields"); + if (keysValue != null) { + if (!keysValue.isEmpty()) { + List keys = new ArrayList<>(keysValue.size()); + for (var value : keysValue.values()) { + keys.add(value.asString()); + } + + return keys; + } + } + return Collections.emptyList(); + } + + public long extractQueryId(Map metadata) { + var queryId = metadata.get("qid"); + if (queryId != null) { + return queryId.asLong(); + } + return ABSENT_QUERY_ID; + } + + public long extractResultAvailableAfter(Map metadata) { + var resultAvailableAfterValue = metadata.get(resultAvailableAfterMetadataKey); + if (resultAvailableAfterValue != null) { + return resultAvailableAfterValue.asLong(); + } + return -1; + } + + public static Value extractServer(Map metadata) { + var versionValue = metadata.get("server"); + if (versionValue == null || versionValue.isNull()) { + throw new UntrustedServerException("Server provides no product identifier"); + } + var serverAgent = versionValue.asString(); + if (!serverAgent.startsWith("Neo4j/")) { + throw new UntrustedServerException( + "Server does not identify as a genuine Neo4j instance: '" + serverAgent + "'"); + } + return versionValue; + } + + public static Set extractBoltPatches(Map metadata) { + var boltPatch = metadata.get("patch_bolt"); + if (boltPatch != null && !boltPatch.isNull()) { + return new HashSet<>(boltPatch.asList(Value::asString)); + } else { + return Collections.emptySet(); + } + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/util/Preconditions.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/util/Preconditions.java new file mode 100644 index 0000000000..4a1ba6d0bc --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/basicimpl/util/Preconditions.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.util; + +public class Preconditions { + public static void checkArgument(Object argument, Class expectedClass) { + if (!expectedClass.isInstance(argument)) { + throw new IllegalArgumentException( + "Argument expected to be of type: " + expectedClass.getName() + " but was: " + argument); + } + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/pooledimpl/PooledBoltConnection.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/pooledimpl/PooledBoltConnection.java new file mode 100644 index 0000000000..1cbd667337 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/pooledimpl/PooledBoltConnection.java @@ -0,0 +1,358 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.pooledimpl; + +import java.time.Duration; +import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import java.util.function.Function; +import org.neo4j.driver.Value; +import org.neo4j.driver.exceptions.AuthorizationExpiredException; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.AuthData; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltConnectionState; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.ResponseHandler; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; +import org.neo4j.driver.internal.bolt.api.TransactionType; +import org.neo4j.driver.internal.bolt.api.summary.BeginSummary; +import org.neo4j.driver.internal.bolt.api.summary.CommitSummary; +import org.neo4j.driver.internal.bolt.api.summary.DiscardSummary; +import org.neo4j.driver.internal.bolt.api.summary.LogoffSummary; +import org.neo4j.driver.internal.bolt.api.summary.LogonSummary; +import org.neo4j.driver.internal.bolt.api.summary.PullSummary; +import org.neo4j.driver.internal.bolt.api.summary.ResetSummary; +import org.neo4j.driver.internal.bolt.api.summary.RollbackSummary; +import org.neo4j.driver.internal.bolt.api.summary.RouteSummary; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.api.summary.TelemetrySummary; + +public class PooledBoltConnection implements BoltConnection { + private final LoggingProvider logging; + private final BoltConnection delegate; + private final PooledBoltConnectionProvider provider; + private final Runnable releaseRunnable; + private final Runnable purgeRunnable; + private CompletableFuture closeFuture; + + public PooledBoltConnection( + BoltConnection delegate, + PooledBoltConnectionProvider provider, + Runnable releaseRunnable, + Runnable purgeRunnable, + LoggingProvider logging) { + this.delegate = Objects.requireNonNull(delegate); + this.provider = Objects.requireNonNull(provider); + this.releaseRunnable = Objects.requireNonNull(releaseRunnable); + this.purgeRunnable = Objects.requireNonNull(purgeRunnable); + this.logging = Objects.requireNonNull(logging); + } + + @Override + public CompletionStage route( + DatabaseName databaseName, String impersonatedUser, Set bookmarks) { + return delegate.route(databaseName, impersonatedUser, bookmarks).thenApply(ignored -> this); + } + + @Override + public CompletionStage beginTransaction( + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, + Set bookmarks, + TransactionType transactionType, + Duration txTimeout, + Map txMetadata, + NotificationConfig notificationConfig) { + return delegate.beginTransaction( + databaseName, + accessMode, + impersonatedUser, + bookmarks, + transactionType, + txTimeout, + txMetadata, + notificationConfig) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage runInAutoCommitTransaction( + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, + Set bookmarks, + String query, + Map parameters, + Duration txTimeout, + Map txMetadata, + NotificationConfig notificationConfig) { + return delegate.runInAutoCommitTransaction( + databaseName, + accessMode, + impersonatedUser, + bookmarks, + query, + parameters, + txTimeout, + txMetadata, + notificationConfig) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage run(String query, Map parameters) { + return delegate.run(query, parameters).thenApply(ignored -> this); + } + + @Override + public CompletionStage pull(long qid, long request) { + return delegate.pull(qid, request).thenApply(ignored -> this); + } + + @Override + public CompletionStage discard(long qid, long number) { + return delegate.discard(qid, number).thenApply(ignored -> this); + } + + @Override + public CompletionStage commit() { + return delegate.commit().thenApply(ignored -> this); + } + + @Override + public CompletionStage rollback() { + return delegate.rollback().thenApply(ignored -> this); + } + + @Override + public CompletionStage reset() { + return delegate.reset().thenApply(ignored -> this); + } + + @Override + public CompletionStage logoff() { + return delegate.logoff().thenApply(ignored -> this); + } + + @Override + public CompletionStage logon(Map authMap) { + return delegate.logon(authMap).thenApply(ignored -> this); + } + + @Override + public CompletionStage telemetry(TelemetryApi telemetryApi) { + return delegate.telemetry(telemetryApi).thenApply(ignored -> this); + } + + @Override + public CompletionStage clear() { + return delegate.clear(); + } + + @Override + public CompletionStage flush(ResponseHandler handler) { + return delegate.flush(new ResponseHandler() { + + @Override + public void onError(Throwable throwable) { + if (throwable instanceof AuthorizationExpiredException) { + provider.onExpired(); + } + handler.onError(throwable); + } + + @Override + public void onBeginSummary(BeginSummary summary) { + handler.onBeginSummary(summary); + } + + @Override + public void onRunSummary(RunSummary summary) { + handler.onRunSummary(summary); + } + + @Override + public void onRecord(Value[] fields) { + handler.onRecord(fields); + } + + @Override + public void onPullSummary(PullSummary summary) { + handler.onPullSummary(summary); + } + + @Override + public void onDiscardSummary(DiscardSummary summary) { + handler.onDiscardSummary(summary); + } + + @Override + public void onCommitSummary(CommitSummary summary) { + handler.onCommitSummary(summary); + } + + @Override + public void onRollbackSummary(RollbackSummary summary) { + handler.onRollbackSummary(summary); + } + + @Override + public void onResetSummary(ResetSummary summary) { + handler.onResetSummary(summary); + } + + @Override + public void onRouteSummary(RouteSummary summary) { + handler.onRouteSummary(summary); + } + + @Override + public void onLogoffSummary(LogoffSummary summary) { + handler.onLogoffSummary(summary); + } + + @Override + public void onLogonSummary(LogonSummary summary) { + handler.onLogonSummary(summary); + } + + @Override + public void onTelemetrySummary(TelemetrySummary summary) { + handler.onTelemetrySummary(summary); + } + + @Override + public void onComplete() { + handler.onComplete(); + } + }) + .whenComplete((ignored, throwable) -> { + if (throwable != null) { + if (delegate.state() == BoltConnectionState.CLOSED) { + purgeRunnable.run(); + } + } + }); + } + + @Override + public CompletionStage forceClose(String reason) { + return delegate.forceClose(reason).whenComplete((closeResult, closeThrowable) -> purgeRunnable.run()); + } + + @Override + public CompletionStage close() { + if (closeFuture == null) { + closeFuture = new CompletableFuture<>(); + + if (delegate.state() == BoltConnectionState.CLOSED) { + purgeRunnable.run(); + closeFuture.complete(null); + return closeFuture; + } else if (delegate.state() == BoltConnectionState.ERROR) { + purgeRunnable.run(); + closeFuture.complete(null); + return closeFuture; + } + + var resetFuture = new CompletableFuture<>(); + delegate.reset() + .thenCompose(boltConnection -> boltConnection.flush(new ResponseHandler() { + @Override + public void onError(Throwable throwable) { + resetFuture.completeExceptionally(throwable); + } + + @Override + public void onResetSummary(ResetSummary summary) { + resetFuture.complete(null); + } + })) + .whenComplete((ignored, throwable) -> { + if (throwable != null) { + resetFuture.completeExceptionally(throwable); + } + }); + + resetFuture + .handle((ignored, throwable) -> { + if (throwable != null) { + return delegate() + .close() + .whenComplete((closeResult, closeThrowable) -> purgeRunnable.run()); + } else { + return CompletableFuture.completedStage(null) + .whenComplete((ignoredResult, nothing) -> releaseRunnable.run()); + } + }) + .thenCompose(Function.identity()) + .whenComplete((ignored, throwable) -> { + if (throwable != null) { + closeFuture.completeExceptionally(throwable); + } else { + closeFuture.complete(null); + } + }); + } + + return closeFuture; + } + + @Override + public BoltConnectionState state() { + return delegate.state(); + } + + @Override + public CompletionStage authData() { + return delegate.authData(); + } + + @Override + public String serverAgent() { + return delegate().serverAgent(); + } + + @Override + public BoltServerAddress serverAddress() { + return delegate.serverAddress(); + } + + @Override + public BoltProtocolVersion protocolVersion() { + return delegate.protocolVersion(); + } + + @Override + public boolean telemetrySupported() { + return delegate.telemetrySupported(); + } + + // internal use only + BoltConnection delegate() { + return delegate; + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/pooledimpl/PooledBoltConnectionProvider.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/pooledimpl/PooledBoltConnectionProvider.java new file mode 100644 index 0000000000..54ee3a23db --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/pooledimpl/PooledBoltConnectionProvider.java @@ -0,0 +1,637 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.pooledimpl; + +import java.time.Clock; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Queue; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.function.Consumer; +import java.util.function.Function; +import java.util.function.Supplier; +import org.neo4j.driver.Value; +import org.neo4j.driver.exceptions.TransientException; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltAgent; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltConnectionState; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.MetricsListener; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.ResponseHandler; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.SecurityPlan; +import org.neo4j.driver.internal.bolt.api.exception.MinVersionAcquisitionException; +import org.neo4j.driver.internal.bolt.api.summary.ResetSummary; +import org.neo4j.driver.internal.bolt.pooledimpl.util.FutureUtil; + +public class PooledBoltConnectionProvider implements BoltConnectionProvider { + private final LoggingProvider logging; + private final System.Logger log; + private final ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor(); + private final BoltConnectionProvider boltConnectionProvider; + private final List pooledConnectionEntries; + private final Queue> pendingAcquisitions; + private final int maxSize; + private final long acquisitionTimeout; + private final long maxLifetime; + private final long idleBeforeTest; + private final Clock clock; + private MetricsListener metricsListener; + private CompletionStage closeStage; + private BoltServerAddress address; + private String poolId; + + private long minAuthTimestamp; + + public PooledBoltConnectionProvider( + BoltConnectionProvider boltConnectionProvider, + int maxSize, + long acquisitionTimeout, + long maxLifetime, + long idleBeforeTest, + Clock clock, + LoggingProvider logging) { + this.boltConnectionProvider = boltConnectionProvider; + this.pooledConnectionEntries = new ArrayList<>(maxSize); + this.pendingAcquisitions = new ArrayDeque<>(100); + this.maxSize = maxSize; + this.acquisitionTimeout = acquisitionTimeout; + this.maxLifetime = maxLifetime; + this.idleBeforeTest = idleBeforeTest; + this.clock = Objects.requireNonNull(clock); + this.logging = Objects.requireNonNull(logging); + this.log = logging.getLog(getClass()); + } + + @Override + public CompletionStage init( + BoltServerAddress address, + SecurityPlan securityPlan, + RoutingContext routingContext, + BoltAgent boltAgent, + String userAgent, + int connectTimeoutMillis, + MetricsListener metricsListener) { + this.address = Objects.requireNonNull(address); + this.poolId = poolId(address); + this.metricsListener = Objects.requireNonNull(metricsListener); + metricsListener.registerPoolMetrics( + poolId, + address, + () -> { + synchronized (this) { + return (int) pooledConnectionEntries.stream() + .filter(entry -> !entry.available) + .count(); + } + }, + () -> { + synchronized (this) { + return (int) pooledConnectionEntries.stream() + .filter(entry -> entry.available) + .count(); + } + }); + return boltConnectionProvider.init( + address, securityPlan, routingContext, boltAgent, userAgent, connectTimeoutMillis, metricsListener); + } + + @SuppressWarnings({"ReassignedVariable", "ConstantValue"}) + @Override + public CompletionStage connect( + DatabaseName databaseName, + Supplier>> authMapStageSupplier, + AccessMode mode, + Set bookmarks, + String impersonatedUser, + BoltProtocolVersion minVersion, + NotificationConfig notificationConfig, + Consumer databaseNameConsumer) { + synchronized (this) { + if (closeStage != null) { + return CompletableFuture.failedFuture(new IllegalStateException("Connection provider is closed.")); + } + } + + var acquisitionFuture = new CompletableFuture(); + + authMapStageSupplier.get().whenComplete((authMap, authThrowable) -> { + if (authThrowable != null) { + acquisitionFuture.completeExceptionally(authThrowable); + return; + } + + var beforeAcquiringOrCreatingEvent = metricsListener.createListenerEvent(); + metricsListener.beforeAcquiringOrCreating(poolId, beforeAcquiringOrCreatingEvent); + acquisitionFuture.whenComplete((connection, throwable) -> { + throwable = FutureUtil.completionExceptionCause(throwable); + if (throwable != null) { + if (throwable instanceof TimeoutException) { + metricsListener.afterTimedOutToAcquireOrCreate(poolId); + } + } else { + metricsListener.afterAcquiredOrCreated(poolId, beforeAcquiringOrCreatingEvent); + } + metricsListener.afterAcquiringOrCreating(poolId); + }); + connect( + acquisitionFuture, + databaseName, + authMap, + authMapStageSupplier, + mode, + bookmarks, + impersonatedUser, + minVersion, + notificationConfig); + }); + + return acquisitionFuture + .whenComplete((ignored, throwable) -> { + if (throwable == null) { + databaseNameConsumer.accept(databaseName); + } + }) + .thenApply(Function.identity()); + } + + public void connect( + CompletableFuture acquisitionFuture, + DatabaseName databaseName, + Map authMap, + Supplier>> authMapStageSupplier, + AccessMode mode, + Set bookmarks, + String impersonatedUser, + BoltProtocolVersion minVersion, + NotificationConfig notificationConfig) { + + ConnectionEntryWithMetadata connectionEntryWithMetadata = null; + Throwable pendingAcquisitionsFull = null; + var empty = new AtomicBoolean(); + synchronized (this) { + try { + empty.set(pooledConnectionEntries.isEmpty()); + try { + // go over existing entries first + connectionEntryWithMetadata = acquireExistingEntry(authMap, mode, impersonatedUser, minVersion); + } catch (MinVersionAcquisitionException e) { + acquisitionFuture.completeExceptionally(e); + return; + } + + if (connectionEntryWithMetadata == null) { + // no entry found + if (pooledConnectionEntries.size() < maxSize) { + // space is available, reserve + var acquiredEntry = new ConnectionEntry(null); + pooledConnectionEntries.add(acquiredEntry); + connectionEntryWithMetadata = new ConnectionEntryWithMetadata(acquiredEntry, false); + } else { + // fallback to queue + if (pendingAcquisitions.size() < 100 && !acquisitionFuture.isDone()) { + if (acquisitionTimeout > 0) { + pendingAcquisitions.add(acquisitionFuture); + } + // schedule timeout + executorService.schedule( + () -> { + synchronized (this) { + pendingAcquisitions.remove(acquisitionFuture); + } + try { + acquisitionFuture.completeExceptionally(new TimeoutException( + "Unable to acquire connection from the pool within configured maximum time of " + + acquisitionTimeout + "ms")); + } catch (Throwable throwable) { + log.log( + System.Logger.Level.WARNING, + "Unexpected error occured.", + throwable); + } + }, + acquisitionTimeout, + TimeUnit.MILLISECONDS); + } else { + pendingAcquisitionsFull = + new TransientException("N/A", "Connection pool pending acquisition queue is full."); + } + } + } + + } catch (Throwable throwable) { + if (connectionEntryWithMetadata != null) { + if (connectionEntryWithMetadata.connectionEntry.connection != null) { + // not new entry, make it available + connectionEntryWithMetadata.connectionEntry.available = true; + } else { + // new empty entry + pooledConnectionEntries.remove(connectionEntryWithMetadata.connectionEntry); + } + } + pendingAcquisitions.remove(acquisitionFuture); + acquisitionFuture.completeExceptionally(throwable); + } + } + + if (pendingAcquisitionsFull != null) { + // no space in queue was available + acquisitionFuture.completeExceptionally(pendingAcquisitionsFull); + } else if (connectionEntryWithMetadata != null) { + if (connectionEntryWithMetadata.connectionEntry.connection != null) { + // entry with connection + var entryWithMetadata = connectionEntryWithMetadata; + var entry = entryWithMetadata.connectionEntry; + + livenessCheckStage(entry).whenComplete((ignored, throwable) -> { + if (throwable != null) { + // liveness check failed + purge(entry); + connect( + acquisitionFuture, + databaseName, + authMap, + authMapStageSupplier, + mode, + bookmarks, + impersonatedUser, + minVersion, + notificationConfig); + } else { + // liveness check green or not needed + var inUseEvent = metricsListener.createListenerEvent(); + var pooledConnection = new PooledBoltConnection( + entry.connection, + this, + () -> { + release(entry); + metricsListener.afterConnectionReleased(poolId, inUseEvent); + }, + () -> { + purge(entry); + metricsListener.afterConnectionReleased(poolId, inUseEvent); + }, + logging); + reauthStage(entryWithMetadata, authMap).whenComplete((ignored2, throwable2) -> { + if (!acquisitionFuture.complete(pooledConnection)) { + // acquisition timed out + CompletableFuture pendingAcquisition; + synchronized (this) { + pendingAcquisition = pendingAcquisitions.poll(); + if (pendingAcquisition == null) { + // nothing pending, just make the entry available + entry.available = true; + } + } + if (pendingAcquisition != null) { + if (pendingAcquisition.complete(pooledConnection)) { + metricsListener.afterConnectionCreated(poolId, inUseEvent); + } + } + } else { + metricsListener.afterConnectionCreated(poolId, inUseEvent); + } + }); + } + }); + } else { + // get reserved entry + var createEvent = metricsListener.createListenerEvent(); + metricsListener.beforeCreating(poolId, createEvent); + var entry = connectionEntryWithMetadata.connectionEntry; + boltConnectionProvider + .connect( + databaseName, + empty.get() ? () -> CompletableFuture.completedStage(authMap) : authMapStageSupplier, + mode, + bookmarks, + impersonatedUser, + minVersion, + notificationConfig, + (ignored) -> {}) + .whenComplete((boltConnection, throwable) -> { + var error = FutureUtil.completionExceptionCause(throwable); + if (error != null) { + // todo decide if retry can be done + synchronized (this) { + pooledConnectionEntries.remove(entry); + } + metricsListener.afterFailedToCreate(poolId); + acquisitionFuture.completeExceptionally(error); + } else { + synchronized (this) { + entry.connection = boltConnection; + } + metricsListener.afterCreated(poolId, createEvent); + var inUseEvent = metricsListener.createListenerEvent(); + var pooledConnection = new PooledBoltConnection( + boltConnection, + this, + () -> { + release(entry); + metricsListener.afterConnectionReleased(poolId, inUseEvent); + }, + () -> { + purge(entry); + metricsListener.afterConnectionReleased(poolId, inUseEvent); + }, + logging); + if (!acquisitionFuture.complete(pooledConnection)) { + // acquisition timed out + CompletableFuture pendingAcquisition; + synchronized (this) { + pendingAcquisition = pendingAcquisitions.poll(); + if (pendingAcquisition == null) { + // nothing pending, just make the entry available + entry.available = true; + } + } + if (pendingAcquisition != null) { + if (pendingAcquisition.complete(pooledConnection)) { + metricsListener.afterConnectionCreated(poolId, inUseEvent); + } + } + } else { + metricsListener.afterConnectionCreated(poolId, inUseEvent); + } + } + }); + } + } + } + + private synchronized ConnectionEntryWithMetadata acquireExistingEntry( + Map authMap, AccessMode mode, String impersonatedUser, BoltProtocolVersion minVersion) { + ConnectionEntryWithMetadata connectionEntryWithMetadata = null; + var iterator = pooledConnectionEntries.iterator(); + while (iterator.hasNext()) { + var connectionEntry = iterator.next(); + + // unavailable + if (!connectionEntry.available) { + continue; + } + + var connection = connectionEntry.connection; + // unusable + if (connection.state() != BoltConnectionState.OPEN) { + iterator.remove(); + continue; + } + + // lower version is present + if (minVersion != null && minVersion.compareTo(connection.protocolVersion()) > 0) { + throw new MinVersionAcquisitionException("lower version", connection.protocolVersion()); + } + + // the pool must not have unauthenticated connections + var authData = connection.authData().toCompletableFuture().getNow(null); + + var expiredByError = minAuthTimestamp > 0 && authData.authAckMillis() <= minAuthTimestamp; + var authMatches = authMap.equals(authData.authMap()); + var reauthNeeded = expiredByError || !authMatches; + + if (reauthNeeded) { + if (new BoltProtocolVersion(5, 1).compareTo(connectionEntry.connection.protocolVersion()) > 0) { + log.log(System.Logger.Level.DEBUG, "reauth is not supported, the connection is voided"); + iterator.remove(); + connectionEntry.connection.close().whenComplete((ignored, throwable) -> { + if (throwable != null) { + log.log( + System.Logger.Level.WARNING, + "Connection close has failed with %s.", + throwable.getClass().getCanonicalName()); + } + }); + continue; + } + } + log.log(System.Logger.Level.DEBUG, "Connection acquired from the pool. " + address); + connectionEntry.available = false; + connectionEntryWithMetadata = new ConnectionEntryWithMetadata(connectionEntry, reauthNeeded); + break; + } + return connectionEntryWithMetadata; + } + + private CompletionStage reauthStage( + ConnectionEntryWithMetadata connectionEntryWithMetadata, Map authMap) { + CompletionStage stage; + if (connectionEntryWithMetadata.reauthNeeded) { + stage = connectionEntryWithMetadata + .connectionEntry + .connection + .logoff() + .thenCompose(conn -> conn.logon(authMap)) + .handle((ignored, throwable) -> { + if (throwable != null) { + connectionEntryWithMetadata.connectionEntry.connection.close(); + synchronized (this) { + pooledConnectionEntries.remove(connectionEntryWithMetadata.connectionEntry); + } + } + return null; + }); + } else { + stage = CompletableFuture.completedStage(null); + } + return stage; + } + + private CompletionStage livenessCheckStage(ConnectionEntry entry) { + CompletionStage stage; + if (idleBeforeTest >= 0 && entry.lastUsedTimestamp + idleBeforeTest < clock.millis()) { + var future = new CompletableFuture(); + entry.connection + .reset() + .thenCompose(conn -> conn.flush(new ResponseHandler() { + @Override + public void onError(Throwable throwable) { + future.completeExceptionally(throwable); + } + + @Override + public void onResetSummary(ResetSummary summary) { + future.complete(null); + } + })); + stage = future; + } else { + stage = CompletableFuture.completedStage(null); + } + return stage; + } + + @Override + public CompletionStage verifyConnectivity(Map authMap) { + return connect( + null, + () -> CompletableFuture.completedStage(authMap), + AccessMode.WRITE, + Collections.emptySet(), + null, + null, + null, + (ignored) -> {}) + .thenCompose(BoltConnection::close); + } + + @Override + public CompletionStage supportsMultiDb(Map authMap) { + return connect( + null, + () -> CompletableFuture.completedStage(authMap), + AccessMode.WRITE, + Collections.emptySet(), + null, + null, + null, + (ignored) -> {}) + .thenCompose(boltConnection -> { + var supports = boltConnection.protocolVersion().compareTo(new BoltProtocolVersion(4, 0)) >= 0; + return boltConnection.close().thenApply(ignored -> supports); + }); + } + + @Override + public CompletionStage supportsSessionAuth(Map authMap) { + return connect( + null, + () -> CompletableFuture.completedStage(authMap), + AccessMode.WRITE, + Collections.emptySet(), + null, + null, + null, + (ignored) -> {}) + .thenCompose(boltConnection -> { + var supports = new BoltProtocolVersion(5, 1).compareTo(boltConnection.protocolVersion()) <= 0; + return boltConnection.close().thenApply(ignored -> supports); + }); + } + + @Override + public CompletionStage close() { + CompletionStage closeStage; + synchronized (this) { + if (this.closeStage == null) { + this.closeStage = CompletableFuture.completedStage(null); + var iterator = pooledConnectionEntries.iterator(); + while (iterator.hasNext()) { + var entry = iterator.next(); + if (entry.connection != null && entry.connection.state() == BoltConnectionState.OPEN) { + this.closeStage = this.closeStage.thenCompose( + ignored -> entry.connection.close().exceptionally(throwable -> null)); + } + iterator.remove(); + } + metricsListener.removePoolMetrics(poolId); + this.closeStage = this.closeStage + .thenCompose(ignored -> boltConnectionProvider.close()) + .exceptionally(throwable -> null) + .whenComplete((ignored, throwable) -> executorService.shutdown()); + } + closeStage = this.closeStage; + } + return closeStage; + } + + private String poolId(BoltServerAddress serverAddress) { + return String.format("%s:%d-%d", serverAddress.host(), serverAddress.port(), this.hashCode()); + } + + private void release(ConnectionEntry entry) { + CompletableFuture pendingAcquisition; + synchronized (this) { + entry.lastUsedTimestamp = clock.millis(); + pendingAcquisition = pendingAcquisitions.poll(); + if (pendingAcquisition == null) { + // nothing pending, just make the entry available + entry.available = true; + } + } + if (pendingAcquisition != null) { + var inUseEvent = metricsListener.createListenerEvent(); + if (pendingAcquisition.complete(new PooledBoltConnection( + entry.connection, + this, + () -> { + release(entry); + metricsListener.afterConnectionReleased(poolId, inUseEvent); + }, + () -> { + purge(entry); + metricsListener.afterConnectionReleased(poolId, inUseEvent); + }, + logging))) { + metricsListener.afterConnectionCreated(poolId, inUseEvent); + } + } + log.log(System.Logger.Level.DEBUG, "Connection released to the pool."); + } + + private void purge(ConnectionEntry entry) { + synchronized (this) { + pooledConnectionEntries.remove(entry); + } + metricsListener.afterClosed(poolId); + entry.connection.close(); + log.log(System.Logger.Level.DEBUG, "Connection purged from the pool."); + } + + synchronized void onExpired() { + var now = clock.millis(); + minAuthTimestamp = Math.max(minAuthTimestamp, now); + } + + private static class ConnectionEntry { + private BoltConnection connection; + private boolean available; + private long lastUsedTimestamp; + + private ConnectionEntry(BoltConnection connection) { + this.connection = connection; + } + } + + private static class ConnectionEntryWithMetadata { + private final ConnectionEntry connectionEntry; + private final boolean reauthNeeded; + + private ConnectionEntryWithMetadata(ConnectionEntry connectionEntry, boolean reauthNeeded) { + this.connectionEntry = connectionEntry; + this.reauthNeeded = reauthNeeded; + } + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/pooledimpl/util/FutureUtil.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/pooledimpl/util/FutureUtil.java new file mode 100644 index 0000000000..e3e063a67c --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/pooledimpl/util/FutureUtil.java @@ -0,0 +1,28 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.pooledimpl.util; + +import java.util.concurrent.CompletionException; + +public class FutureUtil { + public static Throwable completionExceptionCause(Throwable error) { + if (error instanceof CompletionException) { + return error.getCause(); + } + return error; + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/RoutedBoltConnection.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/RoutedBoltConnection.java new file mode 100644 index 0000000000..3583b8770f --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/RoutedBoltConnection.java @@ -0,0 +1,351 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.routedimpl; + +import static java.lang.String.format; + +import java.time.Duration; +import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.concurrent.CompletionStage; +import org.neo4j.driver.Value; +import org.neo4j.driver.exceptions.ClientException; +import org.neo4j.driver.exceptions.ServiceUnavailableException; +import org.neo4j.driver.exceptions.SessionExpiredException; +import org.neo4j.driver.exceptions.TransientException; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.AuthData; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltConnectionState; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.ResponseHandler; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; +import org.neo4j.driver.internal.bolt.api.TransactionType; +import org.neo4j.driver.internal.bolt.api.summary.BeginSummary; +import org.neo4j.driver.internal.bolt.api.summary.CommitSummary; +import org.neo4j.driver.internal.bolt.api.summary.DiscardSummary; +import org.neo4j.driver.internal.bolt.api.summary.LogoffSummary; +import org.neo4j.driver.internal.bolt.api.summary.LogonSummary; +import org.neo4j.driver.internal.bolt.api.summary.PullSummary; +import org.neo4j.driver.internal.bolt.api.summary.ResetSummary; +import org.neo4j.driver.internal.bolt.api.summary.RollbackSummary; +import org.neo4j.driver.internal.bolt.api.summary.RouteSummary; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.api.summary.TelemetrySummary; +import org.neo4j.driver.internal.bolt.routedimpl.cluster.RoutingTableHandler; +import org.neo4j.driver.internal.bolt.routedimpl.util.FutureUtil; + +public class RoutedBoltConnection implements BoltConnection { + private final LoggingProvider logging; + private final BoltConnection delegate; + private final RoutingTableHandler routingTableHandler; + private final AccessMode accessMode; + private final RoutedBoltConnectionProvider provider; + + public RoutedBoltConnection( + BoltConnection delegate, + RoutingTableHandler routingTableHandler, + AccessMode accessMode, + RoutedBoltConnectionProvider provider, + LoggingProvider logging) { + this.delegate = Objects.requireNonNull(delegate); + this.routingTableHandler = Objects.requireNonNull(routingTableHandler); + this.accessMode = Objects.requireNonNull(accessMode); + this.provider = Objects.requireNonNull(provider); + this.logging = Objects.requireNonNull(logging); + } + + @Override + public CompletionStage route( + DatabaseName databaseName, String impersonatedUser, Set bookmarks) { + return delegate.route(databaseName, impersonatedUser, bookmarks).thenApply(ignored -> this); + } + + @Override + public CompletionStage beginTransaction( + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, + Set bookmarks, + TransactionType transactionType, + Duration txTimeout, + Map txMetadata, + NotificationConfig notificationConfig) { + return delegate.beginTransaction( + databaseName, + accessMode, + impersonatedUser, + bookmarks, + transactionType, + txTimeout, + txMetadata, + notificationConfig) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage runInAutoCommitTransaction( + DatabaseName databaseName, + AccessMode accessMode, + String impersonatedUser, + Set bookmarks, + String query, + Map parameters, + Duration txTimeout, + Map txMetadata, + NotificationConfig notificationConfig) { + return delegate.runInAutoCommitTransaction( + databaseName, + accessMode, + impersonatedUser, + bookmarks, + query, + parameters, + txTimeout, + txMetadata, + notificationConfig) + .thenApply(ignored -> this); + } + + @Override + public CompletionStage run(String query, Map parameters) { + return delegate.run(query, parameters).thenApply(ignored -> this); + } + + @Override + public CompletionStage pull(long qid, long request) { + return delegate.pull(qid, request).thenApply(ignored -> this); + } + + @Override + public CompletionStage discard(long qid, long number) { + return delegate.discard(qid, number).thenApply(ignored -> this); + } + + @Override + public CompletionStage commit() { + return delegate.commit().thenApply(ignored -> this); + } + + @Override + public CompletionStage rollback() { + return delegate.rollback().thenApply(ignored -> this); + } + + @Override + public CompletionStage reset() { + return delegate.reset().thenApply(ignored -> this); + } + + @Override + public CompletionStage logoff() { + return delegate.logoff().thenApply(ignored -> this); + } + + @Override + public CompletionStage logon(Map authMap) { + return delegate.logon(authMap).thenApply(ignored -> this); + } + + @Override + public CompletionStage telemetry(TelemetryApi telemetryApi) { + return delegate.telemetry(telemetryApi).thenApply(ignored -> this); + } + + @Override + public CompletionStage clear() { + return delegate.clear(); + } + + @Override + public CompletionStage flush(ResponseHandler handler) { + return delegate.flush(new ResponseHandler() { + private Throwable error; + + @Override + public void onError(Throwable throwable) { + if (error == null) { + error = handledError(throwable); + handler.onError(error); + } + } + + @Override + public void onBeginSummary(BeginSummary summary) { + handler.onBeginSummary(summary); + } + + @Override + public void onRunSummary(RunSummary summary) { + handler.onRunSummary(summary); + } + + @Override + public void onRecord(Value[] fields) { + handler.onRecord(fields); + } + + @Override + public void onPullSummary(PullSummary summary) { + handler.onPullSummary(summary); + } + + @Override + public void onDiscardSummary(DiscardSummary summary) { + handler.onDiscardSummary(summary); + } + + @Override + public void onCommitSummary(CommitSummary summary) { + handler.onCommitSummary(summary); + } + + @Override + public void onRollbackSummary(RollbackSummary summary) { + handler.onRollbackSummary(summary); + } + + @Override + public void onResetSummary(ResetSummary summary) { + handler.onResetSummary(summary); + } + + @Override + public void onRouteSummary(RouteSummary summary) { + handler.onRouteSummary(summary); + } + + @Override + public void onLogoffSummary(LogoffSummary summary) { + handler.onLogoffSummary(summary); + } + + @Override + public void onLogonSummary(LogonSummary summary) { + handler.onLogonSummary(summary); + } + + @Override + public void onTelemetrySummary(TelemetrySummary summary) { + handler.onTelemetrySummary(summary); + } + + @Override + public void onComplete() { + handler.onComplete(); + } + }); + } + + @Override + public CompletionStage forceClose(String reason) { + return delegate.forceClose(reason); + } + + @Override + public CompletionStage close() { + provider.decreaseCount(serverAddress()); + return delegate.close(); + } + + @Override + public BoltConnectionState state() { + return delegate.state(); + } + + @Override + public CompletionStage authData() { + return delegate.authData(); + } + + @Override + public String serverAgent() { + return delegate.serverAgent(); + } + + @Override + public BoltServerAddress serverAddress() { + return delegate.serverAddress(); + } + + @Override + public BoltProtocolVersion protocolVersion() { + return delegate.protocolVersion(); + } + + @Override + public boolean telemetrySupported() { + return delegate.telemetrySupported(); + } + + private Throwable handledError(Throwable receivedError) { + var error = FutureUtil.completionExceptionCause(receivedError); + + if (error instanceof ServiceUnavailableException) { + return handledServiceUnavailableException(((ServiceUnavailableException) error)); + } else if (error instanceof ClientException) { + return handledClientException(((ClientException) error)); + } else if (error instanceof TransientException) { + return handledTransientException(((TransientException) error)); + } else { + return error; + } + } + + private Throwable handledServiceUnavailableException(ServiceUnavailableException e) { + routingTableHandler.onConnectionFailure(serverAddress()); + return new SessionExpiredException(format("Server at %s is no longer available", serverAddress()), e); + } + + private Throwable handledTransientException(TransientException e) { + var errorCode = e.code(); + if (Objects.equals(errorCode, "Neo.TransientError.General.DatabaseUnavailable")) { + routingTableHandler.onConnectionFailure(serverAddress()); + } + return e; + } + + private Throwable handledClientException(ClientException e) { + if (isFailureToWrite(e)) { + // The server is unaware of the session mode, so we have to implement this logic in the driver. + // In the future, we might be able to move this logic to the server. + switch (accessMode) { + case READ -> { + return new ClientException("Write queries cannot be performed in READ access mode."); + } + case WRITE -> { + routingTableHandler.onWriteFailure(serverAddress()); + return new SessionExpiredException( + format("Server at %s no longer accepts writes", serverAddress())); + } + default -> throw new IllegalArgumentException(serverAddress() + " not supported."); + } + } + return e; + } + + private static boolean isFailureToWrite(ClientException e) { + var errorCode = e.code(); + return Objects.equals(errorCode, "Neo.ClientError.Cluster.NotALeader") + || Objects.equals(errorCode, "Neo.ClientError.General.ForbiddenOnReadOnlyDatabase"); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/RoutedBoltConnectionProvider.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/RoutedBoltConnectionProvider.java new file mode 100644 index 0000000000..042b690655 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/RoutedBoltConnectionProvider.java @@ -0,0 +1,434 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.routedimpl; + +import static java.lang.String.format; +import static org.neo4j.driver.internal.bolt.routedimpl.util.LockUtil.executeWithLock; + +import java.time.Clock; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import java.util.concurrent.atomic.AtomicReference; +import java.util.concurrent.locks.ReentrantLock; +import java.util.function.Consumer; +import java.util.function.Function; +import java.util.function.Supplier; +import org.neo4j.driver.Value; +import org.neo4j.driver.exceptions.SecurityException; +import org.neo4j.driver.exceptions.ServiceUnavailableException; +import org.neo4j.driver.exceptions.SessionExpiredException; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltAgent; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.DatabaseNameUtil; +import org.neo4j.driver.internal.bolt.api.DomainNameResolver; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.MetricsListener; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.SecurityPlan; +import org.neo4j.driver.internal.bolt.routedimpl.cluster.Rediscovery; +import org.neo4j.driver.internal.bolt.routedimpl.cluster.RediscoveryImpl; +import org.neo4j.driver.internal.bolt.routedimpl.cluster.RoutingTable; +import org.neo4j.driver.internal.bolt.routedimpl.cluster.RoutingTableHandler; +import org.neo4j.driver.internal.bolt.routedimpl.cluster.RoutingTableRegistry; +import org.neo4j.driver.internal.bolt.routedimpl.cluster.RoutingTableRegistryImpl; +import org.neo4j.driver.internal.bolt.routedimpl.cluster.loadbalancing.LeastConnectedLoadBalancingStrategy; +import org.neo4j.driver.internal.bolt.routedimpl.cluster.loadbalancing.LoadBalancingStrategy; +import org.neo4j.driver.internal.bolt.routedimpl.util.FutureUtil; + +public class RoutedBoltConnectionProvider implements BoltConnectionProvider { + private static final String CONNECTION_ACQUISITION_COMPLETION_FAILURE_MESSAGE = + "Connection acquisition failed for all available addresses."; + private static final String CONNECTION_ACQUISITION_COMPLETION_EXCEPTION_MESSAGE = + "Failed to obtain connection towards %s server. Known routing table is: %s"; + private static final String CONNECTION_ACQUISITION_ATTEMPT_FAILURE_MESSAGE = + "Failed to obtain a connection towards address %s, will try other addresses if available. Complete failure is reported separately from this entry."; + private final LoggingProvider logging; + private final System.Logger log; + private final ReentrantLock lock = new ReentrantLock(); + private final Supplier boltConnectionProviderSupplier; + + private final Map addressToProvider = new HashMap<>(); + private final Function> resolver; + private final DomainNameResolver domainNameResolver; + private final Map addressToInUseCount = new HashMap<>(); + + private final LoadBalancingStrategy loadBalancingStrategy; + + private Rediscovery rediscovery; + private RoutingTableRegistry registry; + + private RoutingTableRegistry routingTableRegistry; + + private BoltServerAddress address; + private SecurityPlan securityPlan; + private Map authMap; + + private RoutingContext routingContext; + private BoltAgent boltAgent; + private String userAgent; + private int connectTimeoutMillis; + private CompletableFuture closeFuture; + private final Clock clock; + private MetricsListener metricsListener; + + public RoutedBoltConnectionProvider( + Supplier boltConnectionProviderSupplier, + Function> resolver, + DomainNameResolver domainNameResolver, + Clock clock, + LoggingProvider logging) { + this.boltConnectionProviderSupplier = Objects.requireNonNull(boltConnectionProviderSupplier); + this.resolver = Objects.requireNonNull(resolver); + this.logging = Objects.requireNonNull(logging); + this.log = logging.getLog(getClass()); + this.loadBalancingStrategy = new LeastConnectedLoadBalancingStrategy( + (addr) -> { + synchronized (this) { + return addressToInUseCount.getOrDefault(address, 0); + } + }, + logging); + this.domainNameResolver = Objects.requireNonNull(domainNameResolver); + this.clock = Objects.requireNonNull(clock); + } + + @Override + public CompletionStage init( + BoltServerAddress address, + SecurityPlan securityPlan, + RoutingContext routingContext, + BoltAgent boltAgent, + String userAgent, + int connectTimeoutMillis, + MetricsListener metricsListener) { + this.address = address; + this.securityPlan = securityPlan; + this.routingContext = routingContext; + this.boltAgent = boltAgent; + this.userAgent = userAgent; + this.connectTimeoutMillis = connectTimeoutMillis; + this.rediscovery = new RediscoveryImpl(address, resolver, logging, domainNameResolver); + this.registry = new RoutingTableRegistryImpl(this::get, rediscovery, clock, logging, 1000); + this.metricsListener = Objects.requireNonNull(metricsListener); + + return CompletableFuture.completedStage(null); + } + + @Override + public CompletionStage connect( + DatabaseName databaseName, + Supplier>> authMapStageSupplier, + AccessMode mode, + Set bookmarks, + String impersonatedUser, + BoltProtocolVersion minVersion, + NotificationConfig notificationConfig, + Consumer databaseNameConsumer) { + synchronized (this) { + if (closeFuture != null) { + return CompletableFuture.failedFuture(new IllegalStateException("Connection provider is closed.")); + } + } + + var handlerRef = new AtomicReference(); + var databaseNameFuture = databaseName == null + ? new CompletableFuture() + : CompletableFuture.completedFuture(databaseName); + databaseNameFuture.whenComplete((name, throwable) -> { + if (name != null) { + databaseNameConsumer.accept(name); + } + }); + return registry.ensureRoutingTable( + databaseNameFuture, mode, bookmarks, impersonatedUser, authMapStageSupplier, minVersion) + .thenApply(routingTableHandler -> { + handlerRef.set(routingTableHandler); + return routingTableHandler; + }) + .thenCompose(routingTableHandler -> acquire( + mode, + routingTableHandler.routingTable(), + authMapStageSupplier, + routingTableHandler.routingTable().database(), + Set.of(), + impersonatedUser, + minVersion, + notificationConfig)) + .thenApply(boltConnection -> + new RoutedBoltConnection(boltConnection, handlerRef.get(), mode, this, logging)); + } + + @Override + public CompletionStage verifyConnectivity(Map authMap) { + return supportsMultiDb(authMap) + .thenCompose(supports -> registry.ensureRoutingTable( + supports + ? CompletableFuture.completedFuture(DatabaseNameUtil.database("system")) + : CompletableFuture.completedFuture(DatabaseNameUtil.defaultDatabase()), + AccessMode.READ, + Collections.emptySet(), + null, + () -> CompletableFuture.completedStage(authMap), + null)) + .handle((ignored, error) -> { + if (error != null) { + var cause = FutureUtil.completionExceptionCause(error); + if (cause instanceof ServiceUnavailableException) { + throw FutureUtil.asCompletionException(new ServiceUnavailableException( + "Unable to connect to database management service, ensure the database is running and that there is a working network connection to it.", + cause)); + } + throw FutureUtil.asCompletionException(cause); + } + return null; + }); + } + + @Override + public CompletionStage supportsMultiDb(Map authMap) { + return detectFeature( + authMap, + "Failed to perform multi-databases feature detection with the following servers: ", + (boltConnection -> boltConnection.protocolVersion().compareTo(new BoltProtocolVersion(4, 0)) >= 0)); + } + + @Override + public CompletionStage supportsSessionAuth(Map authMap) { + return detectFeature( + authMap, + "Failed to perform multi-databases feature detection with the following servers: ", + (boltConnection -> new BoltProtocolVersion(5, 1).compareTo(boltConnection.protocolVersion()) <= 0)); + } + + private CompletionStage detectFeature( + Map authMap, + String baseErrorMessagePrefix, + Function featureDetectionFunction) { + List addresses; + + try { + addresses = rediscovery.resolve(); + } catch (Throwable error) { + return CompletableFuture.failedFuture(error); + } + CompletableFuture result = CompletableFuture.completedFuture(null); + Throwable baseError = new ServiceUnavailableException( + "Failed to perform multi-databases feature detection with the following servers: " + addresses); + + for (var address : addresses) { + result = FutureUtil.onErrorContinue(result, baseError, completionError -> { + // We fail fast on security errors + var error = FutureUtil.completionExceptionCause(completionError); + if (error instanceof SecurityException) { + return CompletableFuture.failedFuture(error); + } + return get(address) + .connect( + null, + () -> CompletableFuture.completedStage(authMap), + AccessMode.WRITE, + Collections.emptySet(), + null, + null, + null, + (ignored) -> {}) + .thenCompose(boltConnection -> { + var featureDetected = featureDetectionFunction.apply(boltConnection); + return boltConnection.close().thenApply(ignored -> featureDetected); + }); + }); + } + return FutureUtil.onErrorContinue(result, baseError, completionError -> { + // If we failed with security errors, then we rethrow the security error out, otherwise we throw the + // chained + // errors. + var error = FutureUtil.completionExceptionCause(completionError); + if (error instanceof SecurityException) { + return CompletableFuture.failedFuture(error); + } + return CompletableFuture.failedFuture(baseError); + }); + } + + private CompletionStage acquire( + AccessMode mode, + RoutingTable routingTable, + Supplier>> authMapStageSupplier, + DatabaseName database, + Set bookmarks, + String impersonatedUser, + BoltProtocolVersion minVersion, + NotificationConfig notificationConfig) { + var result = new CompletableFuture(); + List attemptExceptions = new ArrayList<>(); + acquire( + mode, + routingTable, + result, + authMapStageSupplier, + attemptExceptions, + database, + bookmarks, + impersonatedUser, + minVersion, + notificationConfig); + return result; + } + + private void acquire( + AccessMode mode, + RoutingTable routingTable, + CompletableFuture result, + Supplier>> authMapStageSupplier, + List attemptErrors, + DatabaseName database, + Set bookmarks, + String impersonatedUser, + BoltProtocolVersion minVersion, + NotificationConfig notificationConfig) { + var addresses = getAddressesByMode(mode, routingTable); + log.log(System.Logger.Level.DEBUG, "Addresses: " + addresses); + var address = selectAddress(mode, addresses); + log.log(System.Logger.Level.DEBUG, "Selected address: " + address); + + if (address == null) { + var completionError = new SessionExpiredException( + format(CONNECTION_ACQUISITION_COMPLETION_EXCEPTION_MESSAGE, mode, routingTable)); + attemptErrors.forEach(completionError::addSuppressed); + // log.error(CONNECTION_ACQUISITION_COMPLETION_FAILURE_MESSAGE, completionError); + result.completeExceptionally(completionError); + return; + } + + get(address) + .connect( + database, + authMapStageSupplier, + mode, + bookmarks, + impersonatedUser, + minVersion, + notificationConfig, + (ignored) -> {}) + .whenComplete((connection, completionError) -> { + var error = FutureUtil.completionExceptionCause(completionError); + if (error != null) { + if (error instanceof ServiceUnavailableException) { + var attemptMessage = format(CONNECTION_ACQUISITION_ATTEMPT_FAILURE_MESSAGE, address); + // log.warn(attemptMessage); + // log.debug(attemptMessage, error); + attemptErrors.add(error); + routingTable.forget(address); + CompletableFuture.runAsync(() -> acquire( + mode, + routingTable, + result, + authMapStageSupplier, + attemptErrors, + database, + bookmarks, + impersonatedUser, + minVersion, + notificationConfig)); + } else { + result.completeExceptionally(error); + } + } else { + synchronized (this) { + var inUse = addressToInUseCount.getOrDefault(address, 0); + inUse++; + addressToInUseCount.put(address, inUse); + } + result.complete(connection); + } + }); + } + + private BoltServerAddress selectAddress(AccessMode mode, List addresses) { + return switch (mode) { + case READ -> loadBalancingStrategy.selectReader(addresses); + case WRITE -> loadBalancingStrategy.selectWriter(addresses); + }; + } + + private static List getAddressesByMode(AccessMode mode, RoutingTable routingTable) { + return switch (mode) { + case READ -> routingTable.readers(); + case WRITE -> routingTable.writers(); + }; + } + + synchronized void decreaseCount(BoltServerAddress address) { + var inUse = addressToInUseCount.get(address); + if (inUse != null) { + inUse--; + if (inUse <= 0) { + addressToInUseCount.remove(address); + } else { + addressToInUseCount.put(address, inUse); + } + } + } + + @Override + public CompletionStage close() { + CompletableFuture closeFuture; + synchronized (this) { + if (this.closeFuture == null) { + var futures = executeWithLock(lock, () -> addressToProvider.values().stream() + .map(BoltConnectionProvider::close) + .map(CompletionStage::toCompletableFuture) + .toArray(CompletableFuture[]::new)); + this.closeFuture = CompletableFuture.allOf(futures); + } + closeFuture = this.closeFuture; + } + return closeFuture; + } + + private BoltConnectionProvider get(BoltServerAddress address) { + return executeWithLock(lock, () -> { + var provider = addressToProvider.get(address); + if (provider == null) { + provider = boltConnectionProviderSupplier.get(); + provider.init( + address, + securityPlan, + routingContext, + boltAgent, + userAgent, + connectTimeoutMillis, + metricsListener); + addressToProvider.put(address, provider); + } + return provider; + }); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/ClusterCompositionLookupResult.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/ClusterCompositionLookupResult.java similarity index 88% rename from driver/src/main/java/org/neo4j/driver/internal/cluster/ClusterCompositionLookupResult.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/ClusterCompositionLookupResult.java index b9e35bc3c6..da13d17d5b 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/ClusterCompositionLookupResult.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/ClusterCompositionLookupResult.java @@ -14,11 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal.bolt.routedimpl.cluster; import java.util.Optional; import java.util.Set; -import org.neo4j.driver.internal.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ClusterComposition; public class ClusterCompositionLookupResult { private final ClusterComposition composition; diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/ClusterRoutingTable.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/ClusterRoutingTable.java similarity index 94% rename from driver/src/main/java/org/neo4j/driver/internal/cluster/ClusterRoutingTable.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/ClusterRoutingTable.java index 1907cc64f2..834da43880 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/ClusterRoutingTable.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/ClusterRoutingTable.java @@ -14,11 +14,11 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal.bolt.routedimpl.cluster; import static java.lang.String.format; import static java.util.Arrays.asList; -import static org.neo4j.driver.internal.util.LockUtil.executeWithLock; +import static org.neo4j.driver.internal.bolt.routedimpl.util.LockUtil.executeWithLock; import java.time.Clock; import java.util.ArrayList; @@ -30,9 +30,10 @@ import java.util.concurrent.locks.ReentrantReadWriteLock; import java.util.stream.Collectors; import java.util.stream.Stream; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DatabaseName; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ClusterComposition; +import org.neo4j.driver.internal.bolt.api.DatabaseName; public class ClusterRoutingTable implements RoutingTable { private final ReadWriteLock tableLock = new ReentrantReadWriteLock(); diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/Rediscovery.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/Rediscovery.java similarity index 51% rename from driver/src/main/java/org/neo4j/driver/internal/cluster/Rediscovery.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/Rediscovery.java index 5340a3a0c9..3ae1fae31a 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/Rediscovery.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/Rediscovery.java @@ -14,39 +14,31 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal.bolt.routedimpl.cluster; import java.net.UnknownHostException; import java.util.List; +import java.util.Map; 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; +import java.util.function.Function; +import java.util.function.Supplier; +import org.neo4j.driver.Value; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; /** * Provides cluster composition lookup capabilities and initial router address resolution. */ public interface Rediscovery { - /** - * Fetches cluster composition using the provided routing table. - *

- * Implementation must be thread safe to be called with distinct routing tables concurrently. The routing table instance may be modified. - * - * @param routingTable the routing table for cluster composition lookup - * @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, + Function connectionProviderGetter, + Set bookmarks, String impersonatedUser, - AuthToken overrideAuthToken); + Supplier>> authMapStageSupplier, + BoltProtocolVersion minVersion); 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/bolt/routedimpl/cluster/RediscoveryImpl.java similarity index 58% rename from driver/src/main/java/org/neo4j/driver/internal/cluster/RediscoveryImpl.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RediscoveryImpl.java index dd7cbde2f9..e3546211e5 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RediscoveryImpl.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RediscoveryImpl.java @@ -14,28 +14,27 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal.bolt.routedimpl.cluster; import static java.lang.String.format; import static java.util.Collections.emptySet; import static java.util.Objects.requireNonNull; import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.neo4j.driver.internal.util.Futures.completedWithNull; -import static org.neo4j.driver.internal.util.Futures.failedFuture; import java.net.UnknownHostException; import java.util.Collection; import java.util.HashSet; import java.util.LinkedList; import java.util.List; +import java.util.Map; import java.util.Set; 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 java.util.concurrent.atomic.AtomicReference; +import java.util.function.Function; +import java.util.function.Supplier; +import org.neo4j.driver.Value; import org.neo4j.driver.exceptions.AuthTokenManagerExecutionException; import org.neo4j.driver.exceptions.AuthorizationExpiredException; import org.neo4j.driver.exceptions.ClientException; @@ -44,14 +43,18 @@ import org.neo4j.driver.exceptions.SecurityException; import org.neo4j.driver.exceptions.ServiceUnavailableException; import org.neo4j.driver.exceptions.UnsupportedFeatureException; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DomainNameResolver; -import org.neo4j.driver.internal.ImpersonationUtil; -import org.neo4j.driver.internal.ResolvedBoltServerAddress; -import org.neo4j.driver.internal.spi.ConnectionPool; -import org.neo4j.driver.internal.util.Futures; -import org.neo4j.driver.net.ServerAddress; -import org.neo4j.driver.net.ServerAddressResolver; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ClusterComposition; +import org.neo4j.driver.internal.bolt.api.DomainNameResolver; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.ResponseHandler; +import org.neo4j.driver.internal.bolt.api.exception.MinVersionAcquisitionException; +import org.neo4j.driver.internal.bolt.api.summary.RouteSummary; +import org.neo4j.driver.internal.bolt.routedimpl.util.FutureUtil; public class RediscoveryImpl implements Rediscovery { private static final String NO_ROUTERS_AVAILABLE = @@ -69,59 +72,64 @@ public class RediscoveryImpl implements Rediscovery { private static final String STATEMENT_TYPE_ERROR_CODE = "Neo.ClientError.Statement.TypeError"; private final BoltServerAddress initialRouter; - private final Logger log; - private final ClusterCompositionProvider provider; - private final ServerAddressResolver resolver; + private final System.Logger log; + private final Function> resolver; private final DomainNameResolver domainNameResolver; public RediscoveryImpl( BoltServerAddress initialRouter, - ClusterCompositionProvider provider, - ServerAddressResolver resolver, - Logging logging, + Function> resolver, + LoggingProvider logging, DomainNameResolver domainNameResolver) { this.initialRouter = initialRouter; this.log = logging.getLog(getClass()); - this.provider = provider; this.resolver = resolver; this.domainNameResolver = requireNonNull(domainNameResolver); } - /** - * Given a database and its current routing table, and the global connection pool, use the global cluster composition provider to fetch a new cluster - * composition, which would be used to update the routing table of the given database and global connection pool. - * - * @param routingTable current routing table of the given database. - * @param connectionPool connection pool. - * @return new cluster composition and an optional set of resolved initial router addresses. - */ @Override public CompletionStage lookupClusterComposition( RoutingTable routingTable, - ConnectionPool connectionPool, - Set bookmarks, + Function connectionProviderGetter, + Set bookmarks, String impersonatedUser, - AuthToken overrideAuthToken) { + Supplier>> authMapStageSupplier, + BoltProtocolVersion minVersion) { var result = new CompletableFuture(); // if we failed discovery, we will chain all errors into this one. var baseError = new ServiceUnavailableException( String.format(NO_ROUTERS_AVAILABLE, routingTable.database().description())); lookupClusterComposition( - routingTable, connectionPool, result, bookmarks, impersonatedUser, overrideAuthToken, baseError); + routingTable, + connectionProviderGetter, + result, + bookmarks, + impersonatedUser, + authMapStageSupplier, + minVersion, + baseError); return result; } private void lookupClusterComposition( RoutingTable routingTable, - ConnectionPool pool, + Function connectionProviderGetter, CompletableFuture result, - Set bookmarks, + Set bookmarks, String impersonatedUser, - AuthToken overrideAuthToken, + Supplier>> authMapStageSupplierp, + BoltProtocolVersion minVersion, Throwable baseError) { - lookup(routingTable, pool, bookmarks, impersonatedUser, overrideAuthToken, baseError) + lookup( + routingTable, + connectionProviderGetter, + bookmarks, + impersonatedUser, + authMapStageSupplierp, + minVersion, + baseError) .whenComplete((compositionLookupResult, completionError) -> { - var error = Futures.completionExceptionCause(completionError); + var error = FutureUtil.completionExceptionCause(completionError); if (error != null) { result.completeExceptionally(error); } else if (compositionLookupResult != null) { @@ -134,19 +142,32 @@ private void lookupClusterComposition( private CompletionStage lookup( RoutingTable routingTable, - ConnectionPool connectionPool, - Set bookmarks, + Function connectionProviderGetter, + Set bookmarks, String impersonatedUser, - AuthToken overrideAuthToken, + Supplier>> authMapStageSupplier, + BoltProtocolVersion minVersion, Throwable baseError) { CompletionStage compositionStage; if (routingTable.preferInitialRouter()) { compositionStage = lookupOnInitialRouterThenOnKnownRouters( - routingTable, connectionPool, bookmarks, impersonatedUser, overrideAuthToken, baseError); + routingTable, + connectionProviderGetter, + bookmarks, + impersonatedUser, + authMapStageSupplier, + minVersion, + baseError); } else { compositionStage = lookupOnKnownRoutersThenOnInitialRouter( - routingTable, connectionPool, bookmarks, impersonatedUser, overrideAuthToken, baseError); + routingTable, + connectionProviderGetter, + bookmarks, + impersonatedUser, + authMapStageSupplier, + minVersion, + baseError); } return compositionStage; @@ -154,44 +175,55 @@ private CompletionStage lookup( private CompletionStage lookupOnKnownRoutersThenOnInitialRouter( RoutingTable routingTable, - ConnectionPool connectionPool, - Set bookmarks, + Function connectionProviderGetter, + Set bookmarks, String impersonatedUser, - AuthToken authToken, + Supplier>> authMapStageSupplier, + BoltProtocolVersion minVersion, Throwable baseError) { Set seenServers = new HashSet<>(); return lookupOnKnownRouters( - routingTable, connectionPool, seenServers, bookmarks, impersonatedUser, authToken, baseError) + routingTable, + connectionProviderGetter, + seenServers, + bookmarks, + impersonatedUser, + authMapStageSupplier, + minVersion, + baseError) .thenCompose(compositionLookupResult -> { if (compositionLookupResult != null) { return completedFuture(compositionLookupResult); } return lookupOnInitialRouter( routingTable, - connectionPool, + connectionProviderGetter, seenServers, bookmarks, impersonatedUser, - authToken, + authMapStageSupplier, + minVersion, baseError); }); } private CompletionStage lookupOnInitialRouterThenOnKnownRouters( RoutingTable routingTable, - ConnectionPool connectionPool, - Set bookmarks, + Function connectionProviderGetter, + Set bookmarks, String impersonatedUser, - AuthToken overrideAuthToken, + Supplier>> authMapStageSupplier, + BoltProtocolVersion minVersion, Throwable baseError) { Set seenServers = emptySet(); return lookupOnInitialRouter( routingTable, - connectionPool, + connectionProviderGetter, seenServers, bookmarks, impersonatedUser, - overrideAuthToken, + authMapStageSupplier, + minVersion, baseError) .thenCompose(compositionLookupResult -> { if (compositionLookupResult != null) { @@ -199,24 +231,26 @@ private CompletionStage lookupOnInitialRouterThe } return lookupOnKnownRouters( routingTable, - connectionPool, + connectionProviderGetter, new HashSet<>(), bookmarks, impersonatedUser, - overrideAuthToken, + authMapStageSupplier, + minVersion, baseError); }); } private CompletionStage lookupOnKnownRouters( RoutingTable routingTable, - ConnectionPool connectionPool, + Function connectionProviderGetter, Set seenServers, - Set bookmarks, + Set bookmarks, String impersonatedUser, - AuthToken authToken, + Supplier>> authMapStageSupplier, + BoltProtocolVersion minVersion, Throwable baseError) { - CompletableFuture result = completedWithNull(); + CompletableFuture result = CompletableFuture.completedFuture(null); for (var address : routingTable.routers()) { result = result.thenCompose(composition -> { if (composition != null) { @@ -226,11 +260,12 @@ private CompletionStage lookupOnKnownRouters( address, true, routingTable, - connectionPool, + connectionProviderGetter, seenServers, bookmarks, impersonatedUser, - authToken, + authMapStageSupplier, + minVersion, baseError); } }); @@ -241,22 +276,23 @@ private CompletionStage lookupOnKnownRouters( private CompletionStage lookupOnInitialRouter( RoutingTable routingTable, - ConnectionPool connectionPool, + Function connectionProviderGetter, Set seenServers, - Set bookmarks, + Set bookmarks, String impersonatedUser, - AuthToken overrideAuthToken, + Supplier>> authMapStageSupplier, + BoltProtocolVersion minVersion, Throwable baseError) { List resolvedRouters; try { resolvedRouters = resolve(); } catch (Throwable error) { - return failedFuture(error); + return CompletableFuture.failedFuture(error); } Set resolvedRouterSet = new HashSet<>(resolvedRouters); resolvedRouters.removeAll(seenServers); - CompletableFuture result = completedWithNull(); + CompletableFuture result = CompletableFuture.completedFuture(null); for (var address : resolvedRouters) { result = result.thenCompose(composition -> { if (composition != null) { @@ -266,11 +302,12 @@ private CompletionStage lookupOnInitialRouter( address, false, routingTable, - connectionPool, + connectionProviderGetter, null, bookmarks, impersonatedUser, - overrideAuthToken, + authMapStageSupplier, + minVersion, baseError); }); } @@ -282,30 +319,87 @@ private CompletionStage lookupOnRouter( BoltServerAddress routerAddress, boolean resolveAddress, RoutingTable routingTable, - ConnectionPool connectionPool, + Function connectionProviderGetter, Set seenServers, - Set bookmarks, + Set bookmarks, String impersonatedUser, - AuthToken overrideAuthToken, + Supplier>> authMapStageSupplier, + BoltProtocolVersion minVersion, Throwable baseError) { var addressFuture = CompletableFuture.completedFuture(routerAddress); - return addressFuture + var future = new CompletableFuture(); + var compositionFuture = new CompletableFuture(); + var connectionRef = new AtomicReference(); + + addressFuture .thenApply(address -> resolveAddress ? resolveByDomainNameOrThrowCompletionException(address, routingTable) : address) .thenApply(address -> addAndReturn(seenServers, address)) - .thenCompose(address -> connectionPool.acquire(address, overrideAuthToken)) - .thenApply(connection -> ImpersonationUtil.ensureImpersonationSupport(connection, impersonatedUser)) - .thenCompose(connection -> provider.getClusterComposition( - connection, routingTable.database(), bookmarks, impersonatedUser)) - .handle((response, error) -> { - var cause = Futures.completionExceptionCause(error); + .thenCompose(address -> connectionProviderGetter + .apply(address) + .connect( + null, + authMapStageSupplier, + AccessMode.READ, + bookmarks, + null, + minVersion, + null, + (ignored) -> {})) + .thenApply(connection -> { + connectionRef.set(connection); + return connection; + }) + .thenCompose(connection -> connection.route(routingTable.database(), impersonatedUser, bookmarks)) + .thenCompose(connection -> connection.flush(new ResponseHandler() { + ClusterComposition clusterComposition; + Throwable throwable; + + @Override + public void onError(Throwable throwable) { + this.throwable = throwable; + } + + @Override + public void onRouteSummary(RouteSummary summary) { + clusterComposition = summary.clusterComposition(); + } + + @Override + public void onComplete() { + if (throwable != null) { + compositionFuture.completeExceptionally(throwable); + } else { + compositionFuture.complete(clusterComposition); + } + } + })) + .thenCompose(ignored -> compositionFuture) + .whenComplete((clusterComposition, throwable) -> { + var connection = connectionRef.get(); + var connectionCloseStage = + connection != null ? connection.close() : CompletableFuture.completedStage(null); + var cause = FutureUtil.completionExceptionCause(throwable); if (cause != null) { - return handleRoutingProcedureError(cause, routingTable, routerAddress, baseError); + connectionCloseStage.whenComplete((ignored1, ignored2) -> { + try { + var composition = handleRoutingProcedureError( + FutureUtil.completionExceptionCause(throwable), + routingTable, + routerAddress, + baseError); + future.complete(composition); + } catch (Throwable abortError) { + future.completeExceptionally(abortError); + } + }); } else { - return response; + connectionCloseStage.whenComplete((ignored1, ignored2) -> future.complete(clusterComposition)); } }); + + return future; } @SuppressWarnings({"ThrowableNotThrown", "SameReturnValue"}) @@ -317,9 +411,12 @@ private ClusterComposition handleRoutingProcedureError( // Retryable error happened during discovery. var discoveryError = new DiscoveryException(format(RECOVERABLE_ROUTING_ERROR, routerAddress), error); - Futures.combineErrors(baseError, discoveryError); // we record each failure here - log.warn(RECOVERABLE_DISCOVERY_ERROR_WITH_SERVER, routerAddress); - log.debug(format(RECOVERABLE_DISCOVERY_ERROR_WITH_SERVER, routerAddress), discoveryError); + FutureUtil.combineErrors(baseError, discoveryError); // we record each failure here + log.log(System.Logger.Level.WARNING, RECOVERABLE_DISCOVERY_ERROR_WITH_SERVER, routerAddress); + log.log( + System.Logger.Level.DEBUG, + format(RECOVERABLE_DISCOVERY_ERROR_WITH_SERVER, routerAddress), + discoveryError); routingTable.forget(routerAddress); return null; } @@ -332,7 +429,7 @@ private boolean mustAbortDiscovery(Throwable throwable) { } else if (throwable instanceof FatalDiscoveryException) { abort = true; } else if (throwable instanceof IllegalStateException - && ConnectionPool.CONNECTION_POOL_CLOSED_ERROR_MESSAGE.equals(throwable.getMessage())) { + && "Connection provider is closed.".equals(throwable.getMessage())) { abort = true; } else if (throwable instanceof AuthTokenManagerExecutionException) { abort = true; @@ -347,6 +444,8 @@ private boolean mustAbortDiscovery(Throwable throwable) { REQUEST_INVALID_CODE, STATEMENT_TYPE_ERROR_CODE -> true; default -> false;}; + } else if (throwable instanceof MinVersionAcquisitionException) { + abort = true; } return abort; @@ -356,7 +455,7 @@ private boolean mustAbortDiscovery(Throwable throwable) { public List resolve() throws UnknownHostException { List resolvedAddresses = new LinkedList<>(); UnknownHostException exception = null; - for (var serverAddress : resolver.resolve(initialRouter)) { + for (var serverAddress : resolver.apply(initialRouter)) { try { resolveAllByDomainName(serverAddress).unicastStream().forEach(resolvedAddresses::add); } catch (UnknownHostException e) { @@ -399,7 +498,7 @@ private BoltServerAddress resolveByDomainNameOrThrowCompletionException( } } - private ResolvedBoltServerAddress resolveAllByDomainName(ServerAddress address) throws UnknownHostException { + private ResolvedBoltServerAddress resolveAllByDomainName(BoltServerAddress address) throws UnknownHostException { return new ResolvedBoltServerAddress( address.host(), address.port(), domainNameResolver.resolve(address.host())); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/ResolvedBoltServerAddress.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/ResolvedBoltServerAddress.java similarity index 95% rename from driver/src/main/java/org/neo4j/driver/internal/ResolvedBoltServerAddress.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/ResolvedBoltServerAddress.java index c3f7d4e565..502fb3b8ab 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/ResolvedBoltServerAddress.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/ResolvedBoltServerAddress.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal; +package org.neo4j.driver.internal.bolt.routedimpl.cluster; import static java.util.Objects.requireNonNull; import static java.util.stream.Collectors.joining; @@ -26,11 +26,12 @@ import java.util.Objects; import java.util.Set; import java.util.stream.Stream; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; /** * An explicitly resolved version of {@link BoltServerAddress} that always contains one or more resolved IP addresses. */ -public class ResolvedBoltServerAddress extends BoltServerAddress { +class ResolvedBoltServerAddress extends BoltServerAddress { private static final String HOST_ADDRESSES_FORMAT = "%s%s:%d"; private static final int MAX_HOST_ADDRESSES_IN_STRING_VALUE = 5; private static final String HOST_ADDRESS_DELIMITER = ","; diff --git a/driver/src/main/java/org/neo4j/driver/internal/RoutingErrorHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingErrorHandler.java similarity index 84% rename from driver/src/main/java/org/neo4j/driver/internal/RoutingErrorHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingErrorHandler.java index f24ca14488..4d7022a3e4 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/RoutingErrorHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingErrorHandler.java @@ -14,12 +14,14 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal; +package org.neo4j.driver.internal.bolt.routedimpl.cluster; + +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; /** * Interface used for tracking errors when connected to a cluster. */ -public interface RoutingErrorHandler { +interface RoutingErrorHandler { void onConnectionFailure(BoltServerAddress address); void onWriteFailure(BoltServerAddress address); diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTable.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTable.java similarity index 86% rename from driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTable.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTable.java index dadca7a998..af6b2d3e5b 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTable.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTable.java @@ -14,13 +14,14 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal.bolt.routedimpl.cluster; import java.util.List; import java.util.Set; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DatabaseName; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ClusterComposition; +import org.neo4j.driver.internal.bolt.api.DatabaseName; public interface RoutingTable { boolean isStaleFor(AccessMode mode); diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableHandler.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableHandler.java similarity index 62% rename from driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableHandler.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableHandler.java index dc5eb035a3..4ceca9fa1a 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableHandler.java @@ -14,20 +14,27 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal.bolt.routedimpl.cluster; +import java.util.Map; import java.util.Set; import java.util.concurrent.CompletionStage; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.RoutingErrorHandler; -import org.neo4j.driver.internal.async.ConnectionContext; +import java.util.function.Supplier; +import org.neo4j.driver.Value; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; public interface RoutingTableHandler extends RoutingErrorHandler { Set servers(); boolean isRoutingTableAged(); - CompletionStage ensureRoutingTable(ConnectionContext context); + CompletionStage ensureRoutingTable( + AccessMode mode, + Set rediscoveryBookmarks, + Supplier>> authMapStageSupplier, + BoltProtocolVersion minVersion); CompletionStage updateRoutingTable(ClusterCompositionLookupResult compositionLookupResult); diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableHandlerImpl.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableHandlerImpl.java similarity index 74% rename from driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableHandlerImpl.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableHandlerImpl.java index 7e9772afc6..533feb26a7 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableHandlerImpl.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableHandlerImpl.java @@ -14,45 +14,49 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal.bolt.routedimpl.cluster; import static java.util.concurrent.CompletableFuture.completedFuture; import java.util.HashSet; import java.util.LinkedHashSet; +import java.util.Map; import java.util.Set; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionStage; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.async.ConnectionContext; -import org.neo4j.driver.internal.spi.ConnectionPool; -import org.neo4j.driver.internal.util.Futures; +import java.util.function.Function; +import java.util.function.Supplier; +import org.neo4j.driver.Value; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.routedimpl.util.FutureUtil; public class RoutingTableHandlerImpl implements RoutingTableHandler { private final RoutingTable routingTable; private final DatabaseName databaseName; private final RoutingTableRegistry routingTableRegistry; private volatile CompletableFuture refreshRoutingTableFuture; - private final ConnectionPool connectionPool; + private final Function connectionProviderGetter; private final Rediscovery rediscovery; - private final Logger log; + private final System.Logger log; private final long routingTablePurgeDelayMs; private final Set resolvedInitialRouters = new HashSet<>(); public RoutingTableHandlerImpl( RoutingTable routingTable, Rediscovery rediscovery, - ConnectionPool connectionPool, + Function connectionProviderGetter, RoutingTableRegistry routingTableRegistry, - Logging logging, + LoggingProvider logging, long routingTablePurgeDelayMs) { this.routingTable = routingTable; this.databaseName = routingTable.database(); this.rediscovery = rediscovery; - this.connectionPool = connectionPool; + this.connectionProviderGetter = connectionProviderGetter; this.routingTableRegistry = routingTableRegistry; this.log = logging.getLog(getClass()); this.routingTablePurgeDelayMs = routingTablePurgeDelayMs; @@ -70,13 +74,21 @@ public void onWriteFailure(BoltServerAddress address) { } @Override - public synchronized CompletionStage ensureRoutingTable(ConnectionContext context) { + public synchronized CompletionStage ensureRoutingTable( + AccessMode mode, + Set rediscoveryBookmarks, + Supplier>> authMapStageSupplier, + BoltProtocolVersion minVersion) { if (refreshRoutingTableFuture != null) { // refresh is already happening concurrently, just use it's result return refreshRoutingTableFuture; - } else if (routingTable.isStaleFor(context.mode())) { + } else if (routingTable.isStaleFor(mode)) { // existing routing table is not fresh and should be updated - log.debug("Routing table for database '%s' is stale. %s", databaseName.description(), routingTable); + log.log( + System.Logger.Level.DEBUG, + "Routing table for database '%s' is stale. %s", + databaseName.description(), + routingTable); var resultFuture = new CompletableFuture(); refreshRoutingTableFuture = resultFuture; @@ -84,12 +96,13 @@ public synchronized CompletionStage ensureRoutingTable(ConnectionC rediscovery .lookupClusterComposition( routingTable, - connectionPool, - context.rediscoveryBookmarks(), + connectionProviderGetter, + rediscoveryBookmarks, null, - context.overrideAuthToken()) + authMapStageSupplier, + minVersion) .whenComplete((composition, completionError) -> { - var error = Futures.completionExceptionCause(completionError); + var error = FutureUtil.completionExceptionCause(completionError); if (error != null) { clusterCompositionLookupFailed(error); } else { @@ -124,9 +137,11 @@ public synchronized CompletionStage updateRoutingTable( private synchronized void freshClusterCompositionFetched(ClusterCompositionLookupResult compositionLookupResult) { try { - log.debug( + log.log( + System.Logger.Level.DEBUG, "Fetched cluster composition for database '%s'. %s", - databaseName.description(), compositionLookupResult.getClusterComposition()); + databaseName.description(), + compositionLookupResult.getClusterComposition()); routingTable.update(compositionLookupResult.getClusterComposition()); routingTableRegistry.removeAged(); @@ -139,9 +154,13 @@ private synchronized void freshClusterCompositionFetched(ClusterCompositionLooku resolvedInitialRouters.addAll(addresses); }); addressesToRetain.addAll(resolvedInitialRouters); - connectionPool.retainAll(addressesToRetain); + // connectionPool.retainAll(addressesToRetain); - log.debug("Updated routing table for database '%s'. %s", databaseName.description(), routingTable); + log.log( + System.Logger.Level.DEBUG, + "Updated routing table for database '%s'. %s", + databaseName.description(), + routingTable); var routingTableFuture = refreshRoutingTableFuture; refreshRoutingTableFuture = null; @@ -152,7 +171,8 @@ private synchronized void freshClusterCompositionFetched(ClusterCompositionLooku } private synchronized void clusterCompositionLookupFailed(Throwable error) { - log.error( + log.log( + System.Logger.Level.ERROR, String.format( "Failed to update routing table for database '%s'. Current routing table: %s.", databaseName.description(), routingTable), diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableRegistry.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableRegistry.java similarity index 70% rename from driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableRegistry.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableRegistry.java index 8fe3ec9236..255e08cc7e 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableRegistry.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableRegistry.java @@ -14,14 +14,19 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal.bolt.routedimpl.cluster; +import java.util.Map; import java.util.Optional; import java.util.Set; +import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionStage; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.async.ConnectionContext; +import java.util.function.Supplier; +import org.neo4j.driver.Value; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.DatabaseName; /** * A generic interface to access all routing tables as a whole. @@ -33,7 +38,13 @@ public interface RoutingTableRegistry { * For server version lower than 4.0, the database name will be ignored while refreshing routing table. * @return The future of a new routing table handler. */ - CompletionStage ensureRoutingTable(ConnectionContext context); + CompletionStage ensureRoutingTable( + CompletableFuture databaseNameFuture, + AccessMode mode, + Set rediscoveryBookmarks, + String impersonatedUser, + Supplier>> authMapStageSupplier, + BoltProtocolVersion minVersion); /** * @return all servers in the registry diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableRegistryImpl.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableRegistryImpl.java similarity index 60% rename from driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableRegistryImpl.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableRegistryImpl.java index 013245e364..bb48566356 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingTableRegistryImpl.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableRegistryImpl.java @@ -14,10 +14,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal.bolt.routedimpl.cluster; import static java.util.Objects.requireNonNull; -import static org.neo4j.driver.internal.async.ConnectionContext.PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER; import java.time.Clock; import java.util.HashMap; @@ -30,36 +29,42 @@ import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Function; +import java.util.function.Supplier; import java.util.stream.Collectors; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.DatabaseNameUtil; -import org.neo4j.driver.internal.async.ConnectionContext; -import org.neo4j.driver.internal.spi.ConnectionPool; -import org.neo4j.driver.internal.util.Futures; +import org.neo4j.driver.Value; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.DatabaseNameUtil; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.routedimpl.util.FutureUtil; public class RoutingTableRegistryImpl implements RoutingTableRegistry { + private static final Supplier PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER = + () -> new IllegalStateException("Pending database name encountered."); private final ConcurrentMap routingTableHandlers; private final Map> principalToDatabaseNameStage; private final RoutingTableHandlerFactory factory; - private final Logger log; + private final System.Logger log; private final Clock clock; - private final ConnectionPool connectionPool; + private final Function connectionProviderGetter; private final Rediscovery rediscovery; public RoutingTableRegistryImpl( - ConnectionPool connectionPool, + Function connectionProviderGetter, Rediscovery rediscovery, Clock clock, - Logging logging, + LoggingProvider logging, long routingTablePurgeDelayMs) { this( new ConcurrentHashMap<>(), - new RoutingTableHandlerFactory(connectionPool, rediscovery, clock, logging, routingTablePurgeDelayMs), + new RoutingTableHandlerFactory( + connectionProviderGetter, rediscovery, clock, logging, routingTablePurgeDelayMs), clock, - connectionPool, + connectionProviderGetter, rediscovery, logging); } @@ -68,44 +73,62 @@ public RoutingTableRegistryImpl( ConcurrentMap routingTableHandlers, RoutingTableHandlerFactory factory, Clock clock, - ConnectionPool connectionPool, + Function connectionProviderGetter, Rediscovery rediscovery, - Logging logging) { + LoggingProvider logging) { requireNonNull(rediscovery, "rediscovery must not be null"); this.factory = factory; this.routingTableHandlers = routingTableHandlers; this.principalToDatabaseNameStage = new HashMap<>(); this.clock = clock; - this.connectionPool = connectionPool; + this.connectionProviderGetter = connectionProviderGetter; this.rediscovery = rediscovery; this.log = logging.getLog(getClass()); } @Override - public CompletionStage ensureRoutingTable(ConnectionContext context) { - return ensureDatabaseNameIsCompleted(context).thenCompose(ctxAndHandler -> { - var completedContext = ctxAndHandler.context(); - var handler = ctxAndHandler.handler() != null - ? ctxAndHandler.handler() - : getOrCreate(Futures.joinNowOrElseThrow( - completedContext.databaseNameFuture(), PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER)); - return handler.ensureRoutingTable(completedContext).thenApply(ignored -> handler); - }); + public CompletionStage ensureRoutingTable( + CompletableFuture databaseNameFuture, + AccessMode mode, + Set rediscoveryBookmarks, + String impersonatedUser, + Supplier>> authMapStageSupplier, + BoltProtocolVersion minVersion) { + return ensureDatabaseNameIsCompleted( + databaseNameFuture, + mode, + rediscoveryBookmarks, + impersonatedUser, + authMapStageSupplier, + minVersion) + .thenCompose(ctxAndHandler -> { + var handler = ctxAndHandler.handler() != null + ? ctxAndHandler.handler() + : getOrCreate(FutureUtil.joinNowOrElseThrow( + ctxAndHandler.databaseNameFuture(), PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER)); + return handler.ensureRoutingTable(mode, rediscoveryBookmarks, authMapStageSupplier, minVersion) + .thenApply(ignored -> handler); + }); } - private CompletionStage ensureDatabaseNameIsCompleted(ConnectionContext context) { + private CompletionStage ensureDatabaseNameIsCompleted( + CompletableFuture databaseNameFutureS, + AccessMode mode, + Set rediscoveryBookmarks, + String impersonatedUser, + Supplier>> authMapStageSupplier, + BoltProtocolVersion minVersion) { CompletionStage contextAndHandlerStage; - var contextDatabaseNameFuture = context.databaseNameFuture(); - if (contextDatabaseNameFuture.isDone()) { - contextAndHandlerStage = CompletableFuture.completedFuture(new ConnectionContextAndHandler(context, null)); + if (databaseNameFutureS.isDone()) { + contextAndHandlerStage = CompletableFuture.completedFuture( + new ConnectionContextAndHandler(databaseNameFutureS, mode, rediscoveryBookmarks, null)); } else { synchronized (this) { - if (contextDatabaseNameFuture.isDone()) { - contextAndHandlerStage = - CompletableFuture.completedFuture(new ConnectionContextAndHandler(context, null)); + if (databaseNameFutureS.isDone()) { + contextAndHandlerStage = CompletableFuture.completedFuture( + new ConnectionContextAndHandler(databaseNameFutureS, mode, rediscoveryBookmarks, null)); } else { - var impersonatedUser = context.impersonatedUser(); var principal = new Principal(impersonatedUser); var databaseNameStage = principalToDatabaseNameStage.get(principal); var handlerRef = new AtomicReference(); @@ -119,10 +142,11 @@ private CompletionStage ensureDatabaseNameIsComplet rediscovery .lookupClusterComposition( routingTable, - connectionPool, - context.rediscoveryBookmarks(), + connectionProviderGetter, + rediscoveryBookmarks, impersonatedUser, - context.overrideAuthToken()) + authMapStageSupplier, + minVersion) .thenCompose(compositionLookupResult -> { var databaseName = DatabaseNameUtil.database(compositionLookupResult .getClusterComposition() @@ -148,9 +172,10 @@ private CompletionStage ensureDatabaseNameIsComplet contextAndHandlerStage = databaseNameStage.thenApply(databaseName -> { synchronized (this) { - contextDatabaseNameFuture.complete(databaseName); + databaseNameFutureS.complete(databaseName); } - return new ConnectionContextAndHandler(context, handlerRef.get()); + return new ConnectionContextAndHandler( + databaseNameFutureS, mode, rediscoveryBookmarks, handlerRef.get()); }); } } @@ -171,16 +196,21 @@ public Set allServers() { @Override public void remove(DatabaseName databaseName) { routingTableHandlers.remove(databaseName); - log.debug("Routing table handler for database '%s' is removed.", databaseName.description()); + log.log( + System.Logger.Level.DEBUG, + "Routing table handler for database '%s' is removed.", + databaseName.description()); } @Override public void removeAged() { routingTableHandlers.forEach((databaseName, handler) -> { if (handler.isRoutingTableAged()) { - log.info( + log.log( + System.Logger.Level.INFO, "Routing table handler for database '%s' is removed because it has not been used for a long time. Routing table: %s", - databaseName.description(), handler.routingTable()); + databaseName.description(), + handler.routingTable()); routingTableHandlers.remove(databaseName); } }); @@ -199,25 +229,28 @@ public boolean contains(DatabaseName databaseName) { private RoutingTableHandler getOrCreate(DatabaseName databaseName) { return routingTableHandlers.computeIfAbsent(databaseName, name -> { var handler = factory.newInstance(name, this); - log.debug("Routing table handler for database '%s' is added.", databaseName.description()); + log.log( + System.Logger.Level.DEBUG, + "Routing table handler for database '%s' is added.", + databaseName.description()); return handler; }); } static class RoutingTableHandlerFactory { - private final ConnectionPool connectionPool; + private final Function connectionProviderGetter; private final Rediscovery rediscovery; - private final Logging logging; + private final LoggingProvider logging; private final Clock clock; private final long routingTablePurgeDelayMs; RoutingTableHandlerFactory( - ConnectionPool connectionPool, + Function connectionProviderGetter, Rediscovery rediscovery, Clock clock, - Logging logging, + LoggingProvider logging, long routingTablePurgeDelayMs) { - this.connectionPool = connectionPool; + this.connectionProviderGetter = connectionProviderGetter; this.rediscovery = rediscovery; this.clock = clock; this.logging = logging; @@ -227,7 +260,7 @@ static class RoutingTableHandlerFactory { RoutingTableHandler newInstance(DatabaseName databaseName, RoutingTableRegistry allTables) { var routingTable = new ClusterRoutingTable(databaseName, clock); return new RoutingTableHandlerImpl( - routingTable, rediscovery, connectionPool, allTables, logging, routingTablePurgeDelayMs); + routingTable, rediscovery, connectionProviderGetter, allTables, logging, routingTablePurgeDelayMs); } } @@ -246,5 +279,9 @@ public boolean equals(Object o) { } } - private record ConnectionContextAndHandler(ConnectionContext context, RoutingTableHandler handler) {} + private record ConnectionContextAndHandler( + CompletableFuture databaseNameFuture, + AccessMode mode, + Set rediscoveryBookmarks, + RoutingTableHandler handler) {} } diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/LeastConnectedLoadBalancingStrategy.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/LeastConnectedLoadBalancingStrategy.java similarity index 69% rename from driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/LeastConnectedLoadBalancingStrategy.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/LeastConnectedLoadBalancingStrategy.java index d1ffe0a979..b6a14e583d 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/LeastConnectedLoadBalancingStrategy.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/LeastConnectedLoadBalancingStrategy.java @@ -14,28 +14,23 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster.loadbalancing; +package org.neo4j.driver.internal.bolt.routedimpl.cluster.loadbalancing; import java.util.List; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.spi.ConnectionPool; +import java.util.function.Function; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; -/** - * Load balancing strategy that finds server with the least amount of active (checked out of the pool) connections from given readers or writers. It finds a - * start index for iteration in a round-robin fashion. This is done to prevent choosing same first address over and over when all addresses have the same amount - * of active connections. - */ public class LeastConnectedLoadBalancingStrategy implements LoadBalancingStrategy { private final RoundRobinArrayIndex readersIndex = new RoundRobinArrayIndex(); private final RoundRobinArrayIndex writersIndex = new RoundRobinArrayIndex(); - private final ConnectionPool connectionPool; - private final Logger log; + private final Function inUseFunction; + private final System.Logger log; - public LeastConnectedLoadBalancingStrategy(ConnectionPool connectionPool, Logging logging) { - this.connectionPool = connectionPool; + public LeastConnectedLoadBalancingStrategy( + Function inUseFunction, LoggingProvider logging) { + this.inUseFunction = inUseFunction; this.log = logging.getLog(getClass()); } @@ -53,7 +48,7 @@ private BoltServerAddress select( List addresses, RoundRobinArrayIndex addressesIndex, String addressType) { var size = addresses.size(); if (size == 0) { - log.trace("Unable to select %s, no known addresses given", addressType); + log.log(System.Logger.Level.TRACE, "Unable to select %s, no known addresses given", addressType); return null; } @@ -67,7 +62,7 @@ private BoltServerAddress select( // iterate over the array to find the least connected address do { var address = addresses.get(index); - var activeConnections = connectionPool.inUseConnections(address); + var activeConnections = inUseFunction.apply(address); if (activeConnections < leastActiveConnections) { leastConnectedAddress = address; @@ -82,9 +77,12 @@ private BoltServerAddress select( } } while (index != startIndex); - log.trace( + log.log( + System.Logger.Level.TRACE, "Selected %s with address: '%s' and active connections: %s", - addressType, leastConnectedAddress, leastActiveConnections); + addressType, + leastConnectedAddress, + leastActiveConnections); return leastConnectedAddress; } diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/LoadBalancingStrategy.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/LoadBalancingStrategy.java similarity index 91% rename from driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/LoadBalancingStrategy.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/LoadBalancingStrategy.java index a1a3c95766..a80d2797fe 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/LoadBalancingStrategy.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/LoadBalancingStrategy.java @@ -14,10 +14,10 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster.loadbalancing; +package org.neo4j.driver.internal.bolt.routedimpl.cluster.loadbalancing; import java.util.List; -import org.neo4j.driver.internal.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; /** * A facility to select most appropriate reader or writer among the given addresses for request processing. diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/RoundRobinArrayIndex.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/RoundRobinArrayIndex.java similarity index 94% rename from driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/RoundRobinArrayIndex.java rename to driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/RoundRobinArrayIndex.java index 084ce5d4e3..f6abebcd57 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/RoundRobinArrayIndex.java +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/RoundRobinArrayIndex.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster.loadbalancing; +package org.neo4j.driver.internal.bolt.routedimpl.cluster.loadbalancing; import java.util.concurrent.atomic.AtomicInteger; diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/util/FutureUtil.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/util/FutureUtil.java new file mode 100644 index 0000000000..64c45f295e --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/util/FutureUtil.java @@ -0,0 +1,92 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.routedimpl.util; + +import static java.util.concurrent.CompletableFuture.completedFuture; +import static org.neo4j.driver.internal.util.ErrorUtil.addSuppressed; + +import java.util.Objects; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionException; +import java.util.concurrent.CompletionStage; +import java.util.function.Function; +import java.util.function.Supplier; + +public class FutureUtil { + public static CompletionException asCompletionException(Throwable error) { + if (error instanceof CompletionException) { + return ((CompletionException) error); + } + return new CompletionException(error); + } + + public static Throwable completionExceptionCause(Throwable error) { + if (error instanceof CompletionException) { + return error.getCause(); + } + return error; + } + + @SuppressWarnings("ThrowableNotThrown") + public static CompletableFuture onErrorContinue( + CompletableFuture future, + Throwable errorRecorder, + Function> onErrorAction) { + Objects.requireNonNull(future); + return future.handle((value, error) -> { + if (error != null) { + // record error + combineErrors(errorRecorder, error); + return new CompletionResult(null, error); + } + return new CompletionResult<>(value, null); + }) + .thenCompose(result -> { + if (result.value != null) { + return completedFuture(result.value); + } else { + return onErrorAction.apply(result.error); + } + }); + } + + public static CompletionException combineErrors(Throwable error1, Throwable error2) { + if (error1 != null && error2 != null) { + var cause1 = completionExceptionCause(error1); + var cause2 = completionExceptionCause(error2); + addSuppressed(cause1, cause2); + return asCompletionException(cause1); + } else if (error1 != null) { + return asCompletionException(error1); + } else if (error2 != null) { + return asCompletionException(error2); + } else { + return null; + } + } + + public static T joinNowOrElseThrow( + CompletableFuture future, Supplier exceptionSupplier) { + if (future.isDone()) { + return future.join(); + } else { + throw exceptionSupplier.get(); + } + } + + private record CompletionResult(T value, Throwable error) {} +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/util/LockUtil.java b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/util/LockUtil.java new file mode 100644 index 0000000000..d37c01bbd0 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/bolt/routedimpl/util/LockUtil.java @@ -0,0 +1,48 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.routedimpl.util; + +import java.util.concurrent.locks.Lock; +import java.util.function.Supplier; + +public class LockUtil { + public static void executeWithLock(Lock lock, Runnable runnable) { + lock(lock); + try { + runnable.run(); + } finally { + unlock(lock); + } + } + + public static T executeWithLock(Lock lock, Supplier supplier) { + lock(lock); + try { + return supplier.get(); + } finally { + unlock(lock); + } + } + + private static void lock(Lock lock) { + lock.lock(); + } + + private static void unlock(Lock lock) { + lock.unlock(); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/ClusterCompositionProvider.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/ClusterCompositionProvider.java deleted file mode 100644 index 13500061de..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/ClusterCompositionProvider.java +++ /dev/null @@ -1,28 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cluster; - -import java.util.Set; -import java.util.concurrent.CompletionStage; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.spi.Connection; - -public interface ClusterCompositionProvider { - CompletionStage getClusterComposition( - Connection connection, DatabaseName databaseName, Set bookmarks, String impersonatedUser); -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/MultiDatabasesRoutingProcedureRunner.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/MultiDatabasesRoutingProcedureRunner.java deleted file mode 100644 index befdd39f20..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/MultiDatabasesRoutingProcedureRunner.java +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cluster; - -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.systemDatabase; - -import java.util.HashMap; -import java.util.Set; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.Value; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.async.connection.DirectConnection; -import org.neo4j.driver.internal.messaging.BoltProtocolVersion; -import org.neo4j.driver.internal.spi.Connection; - -/** - * This implementation of the {@link RoutingProcedureRunner} works with multi database versions of Neo4j calling - * the procedure `dbms.routing.getRoutingTable` - */ -public class MultiDatabasesRoutingProcedureRunner extends SingleDatabaseRoutingProcedureRunner { - static final String DATABASE_NAME = "database"; - static final String MULTI_DB_GET_ROUTING_TABLE = - String.format("CALL dbms.routing.getRoutingTable($%s, $%s)", ROUTING_CONTEXT, DATABASE_NAME); - - public MultiDatabasesRoutingProcedureRunner(RoutingContext context, Logging logging) { - super(context, logging); - } - - @Override - Set adaptBookmarks(Set bookmarks) { - return bookmarks; - } - - @Override - Query procedureQuery(BoltProtocolVersion protocolVersion, DatabaseName databaseName) { - var map = new HashMap(); - map.put(ROUTING_CONTEXT, value(context.toMap())); - map.put(DATABASE_NAME, value((Object) databaseName.databaseName().orElse(null))); - return new Query(MULTI_DB_GET_ROUTING_TABLE, value(map)); - } - - @Override - DirectConnection connection(Connection connection) { - return new DirectConnection(connection, systemDatabase(), AccessMode.READ, null); - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RouteMessageRoutingProcedureRunner.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/RouteMessageRoutingProcedureRunner.java deleted file mode 100644 index cef8d329b6..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RouteMessageRoutingProcedureRunner.java +++ /dev/null @@ -1,95 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cluster; - -import static java.util.Collections.singletonList; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionStage; -import java.util.function.Supplier; -import java.util.stream.Collectors; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Query; -import org.neo4j.driver.Record; -import org.neo4j.driver.Value; -import org.neo4j.driver.Values; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.InternalRecord; -import org.neo4j.driver.internal.async.connection.DirectConnection; -import org.neo4j.driver.internal.handlers.RouteMessageResponseHandler; -import org.neo4j.driver.internal.messaging.request.RouteMessage; -import org.neo4j.driver.internal.spi.Connection; - -/** - * This implementation of the {@link RoutingProcedureRunner} access the routing procedure - * through the bolt's ROUTE message. - */ -public class RouteMessageRoutingProcedureRunner implements RoutingProcedureRunner { - private final Map routingContext; - private final Supplier>> createCompletableFuture; - - public RouteMessageRoutingProcedureRunner(RoutingContext routingContext) { - this(routingContext, CompletableFuture::new); - } - - protected RouteMessageRoutingProcedureRunner( - RoutingContext routingContext, Supplier>> createCompletableFuture) { - this.routingContext = routingContext.toMap().entrySet().stream() - .collect(Collectors.toMap(Map.Entry::getKey, entry -> Values.value(entry.getValue()))); - this.createCompletableFuture = createCompletableFuture; - } - - @Override - public CompletionStage run( - Connection connection, DatabaseName databaseName, Set bookmarks, String impersonatedUser) { - var completableFuture = createCompletableFuture.get(); - - var directConnection = toDirectConnection(connection, databaseName, impersonatedUser); - directConnection.writeAndFlush( - new RouteMessage( - routingContext, bookmarks, databaseName.databaseName().orElse(null), impersonatedUser), - new RouteMessageResponseHandler(completableFuture)); - return completableFuture - .thenApply(routingTable -> - new RoutingProcedureResponse(getQuery(databaseName), singletonList(toRecord(routingTable)))) - .exceptionally(throwable -> new RoutingProcedureResponse(getQuery(databaseName), throwable.getCause())) - .thenCompose(routingProcedureResponse -> - directConnection.release().thenApply(ignore -> routingProcedureResponse)); - } - - private Record toRecord(Map routingTable) { - return new InternalRecord( - new ArrayList<>(routingTable.keySet()), routingTable.values().toArray(new Value[0])); - } - - private DirectConnection toDirectConnection( - Connection connection, DatabaseName databaseName, String impersonatedUser) { - return new DirectConnection(connection, databaseName, AccessMode.READ, impersonatedUser); - } - - private Query getQuery(DatabaseName databaseName) { - Map params = new HashMap<>(); - params.put("routingContext", routingContext); - params.put("databaseName", databaseName.databaseName().orElse(null)); - return new Query("ROUTE $routingContext $databaseName", params); - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProvider.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProvider.java deleted file mode 100644 index 3d6d6a0288..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProvider.java +++ /dev/null @@ -1,124 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cluster; - -import static java.lang.String.format; -import static org.neo4j.driver.internal.messaging.request.MultiDatabaseUtil.supportsMultiDatabase; -import static org.neo4j.driver.internal.messaging.request.MultiDatabaseUtil.supportsRouteMessage; - -import java.time.Clock; -import java.util.Set; -import java.util.concurrent.CompletionException; -import java.util.concurrent.CompletionStage; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.exceptions.ProtocolException; -import org.neo4j.driver.exceptions.value.ValueException; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.spi.Connection; - -public class RoutingProcedureClusterCompositionProvider implements ClusterCompositionProvider { - private static final String PROTOCOL_ERROR_MESSAGE = "Failed to parse '%s' result received from server due to "; - - private final Clock clock; - private final RoutingProcedureRunner singleDatabaseRoutingProcedureRunner; - private final RoutingProcedureRunner multiDatabaseRoutingProcedureRunner; - private final RoutingProcedureRunner routeMessageRoutingProcedureRunner; - - public RoutingProcedureClusterCompositionProvider(Clock clock, RoutingContext routingContext, Logging logging) { - this( - clock, - new SingleDatabaseRoutingProcedureRunner(routingContext, logging), - new MultiDatabasesRoutingProcedureRunner(routingContext, logging), - new RouteMessageRoutingProcedureRunner(routingContext)); - } - - RoutingProcedureClusterCompositionProvider( - Clock clock, - SingleDatabaseRoutingProcedureRunner singleDatabaseRoutingProcedureRunner, - MultiDatabasesRoutingProcedureRunner multiDatabaseRoutingProcedureRunner, - RouteMessageRoutingProcedureRunner routeMessageRoutingProcedureRunner) { - this.clock = clock; - this.singleDatabaseRoutingProcedureRunner = singleDatabaseRoutingProcedureRunner; - this.multiDatabaseRoutingProcedureRunner = multiDatabaseRoutingProcedureRunner; - this.routeMessageRoutingProcedureRunner = routeMessageRoutingProcedureRunner; - } - - @Override - public CompletionStage getClusterComposition( - Connection connection, DatabaseName databaseName, Set bookmarks, String impersonatedUser) { - RoutingProcedureRunner runner; - - if (supportsRouteMessage(connection)) { - runner = routeMessageRoutingProcedureRunner; - } else if (supportsMultiDatabase(connection)) { - runner = multiDatabaseRoutingProcedureRunner; - } else { - runner = singleDatabaseRoutingProcedureRunner; - } - - return runner.run(connection, databaseName, bookmarks, impersonatedUser) - .thenApply(this::processRoutingResponse); - } - - private ClusterComposition processRoutingResponse(RoutingProcedureResponse response) { - if (!response.isSuccess()) { - throw new CompletionException( - format( - "Failed to run '%s' on server. Please make sure that there is a Neo4j server or cluster up running.", - invokedProcedureString(response)), - response.error()); - } - - var records = response.records(); - - var now = clock.millis(); - - // the record size is wrong - if (records.size() != 1) { - throw new ProtocolException(format( - PROTOCOL_ERROR_MESSAGE + "records received '%s' is too few or too many.", - invokedProcedureString(response), - records.size())); - } - - // failed to parse the record - ClusterComposition cluster; - try { - cluster = ClusterComposition.parse(records.get(0), now); - } catch (ValueException e) { - throw new ProtocolException( - format(PROTOCOL_ERROR_MESSAGE + "unparsable record received.", invokedProcedureString(response)), - e); - } - - // the cluster result is not a legal reply - if (!cluster.hasRoutersAndReaders()) { - throw new ProtocolException(format( - PROTOCOL_ERROR_MESSAGE + "no router or reader found in response.", - invokedProcedureString(response))); - } - - // all good - return cluster; - } - - private static String invokedProcedureString(RoutingProcedureResponse response) { - var query = response.procedure(); - return query.text() + " " + query.parameters(); - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureResponse.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureResponse.java deleted file mode 100644 index 777d6ed07a..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureResponse.java +++ /dev/null @@ -1,63 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cluster; - -import java.util.List; -import org.neo4j.driver.Query; -import org.neo4j.driver.Record; - -public class RoutingProcedureResponse { - private final Query procedure; - private final List records; - private final Throwable error; - - public RoutingProcedureResponse(Query procedure, List records) { - this(procedure, records, null); - } - - public RoutingProcedureResponse(Query procedure, Throwable error) { - this(procedure, null, error); - } - - private RoutingProcedureResponse(Query procedure, List records, Throwable error) { - this.procedure = procedure; - this.records = records; - this.error = error; - } - - public boolean isSuccess() { - return records != null; - } - - public Query procedure() { - return procedure; - } - - public List records() { - if (!isSuccess()) { - throw new IllegalStateException("Can't access records of a failed result", error); - } - return records; - } - - public Throwable error() { - if (isSuccess()) { - throw new IllegalStateException("Can't access error of a succeeded result " + records); - } - return error; - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureRunner.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureRunner.java deleted file mode 100644 index 20429aa2aa..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureRunner.java +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cluster; - -import java.util.Set; -import java.util.concurrent.CompletionStage; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.spi.Connection; - -/** - * Interface which defines the standard way to get the routing table - */ -public interface RoutingProcedureRunner { - /** - * Run the calls to the server - * - * @param connection The connection which will be used to call the server - * @param databaseName The database name - * @param bookmarks The bookmarks used to query the routing information - * @param impersonatedUser The impersonated user, should be {@code null} for non-impersonated requests - * @return The routing table - */ - CompletionStage run( - Connection connection, DatabaseName databaseName, Set bookmarks, String impersonatedUser); -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/SingleDatabaseRoutingProcedureRunner.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/SingleDatabaseRoutingProcedureRunner.java deleted file mode 100644 index 2b4c3088e0..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/SingleDatabaseRoutingProcedureRunner.java +++ /dev/null @@ -1,129 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cluster; - -import static org.neo4j.driver.Values.parameters; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE; - -import java.util.Collections; -import java.util.List; -import java.util.Set; -import java.util.concurrent.CompletionException; -import java.util.concurrent.CompletionStage; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.Record; -import org.neo4j.driver.TransactionConfig; -import org.neo4j.driver.async.ResultCursor; -import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.exceptions.FatalDiscoveryException; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.async.connection.DirectConnection; -import org.neo4j.driver.internal.messaging.BoltProtocolVersion; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.util.Futures; - -/** - * This implementation of the {@link RoutingProcedureRunner} works with single database versions of Neo4j calling - * the procedure `dbms.cluster.routing.getRoutingTable` - */ -public class SingleDatabaseRoutingProcedureRunner implements RoutingProcedureRunner { - static final String ROUTING_CONTEXT = "context"; - static final String GET_ROUTING_TABLE = "CALL dbms.cluster.routing.getRoutingTable($" + ROUTING_CONTEXT + ")"; - - final RoutingContext context; - private final Logging logging; - - public SingleDatabaseRoutingProcedureRunner(RoutingContext context, Logging logging) { - this.context = context; - this.logging = logging; - } - - @Override - public CompletionStage run( - Connection connection, DatabaseName databaseName, Set bookmarks, String impersonatedUser) { - var delegate = connection(connection); - var procedure = procedureQuery(connection.protocol().version(), databaseName); - return runProcedure(delegate, procedure, adaptBookmarks(bookmarks)) - .thenCompose(records -> releaseConnection(delegate, records)) - .handle((records, error) -> processProcedureResponse(procedure, records, error)); - } - - DirectConnection connection(Connection connection) { - return new DirectConnection(connection, defaultDatabase(), AccessMode.WRITE, null); - } - - Query procedureQuery(BoltProtocolVersion protocolVersion, DatabaseName databaseName) { - if (databaseName.databaseName().isPresent()) { - throw new FatalDiscoveryException(String.format( - "Refreshing routing table for multi-databases is not supported over Bolt protocol lower than 4.0. " - + "Current protocol version: %s. Database name: '%s'", - protocolVersion, databaseName.description())); - } - return new Query(GET_ROUTING_TABLE, parameters(ROUTING_CONTEXT, context.toMap())); - } - - Set adaptBookmarks(Set bookmarks) { - return Collections.emptySet(); - } - - CompletionStage> runProcedure(Connection connection, Query procedure, Set bookmarks) { - return connection - .protocol() - .runInAutoCommitTransaction( - connection, - procedure, - bookmarks, - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - logging) - .asyncResult() - .thenCompose(ResultCursor::listAsync); - } - - private CompletionStage> releaseConnection(Connection connection, List records) { - // It is not strictly required to release connection after routing procedure invocation because it'll - // be released by the PULL_ALL response handler after result is fully fetched. Such release will happen - // in background. However, releasing it early as part of whole chain makes it easier to reason about - // rediscovery in stub server tests. Some of them assume connections to instances not present in new - // routing table will be closed immediately. - return connection.release().thenApply(ignore -> records); - } - - private static RoutingProcedureResponse processProcedureResponse( - Query procedure, List records, Throwable error) { - var cause = Futures.completionExceptionCause(error); - if (cause != null) { - return handleError(procedure, cause); - } else { - return new RoutingProcedureResponse(procedure, records); - } - } - - private static RoutingProcedureResponse handleError(Query procedure, Throwable error) { - if (error instanceof ClientException) { - return new RoutingProcedureResponse(procedure, error); - } else { - throw new CompletionException(error); - } - } -} 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 deleted file mode 100644 index b0c425c0fc..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/LoadBalancer.java +++ /dev/null @@ -1,271 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cluster.loadbalancing; - -import static java.lang.String.format; -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.util.Futures.completedWithNull; -import static org.neo4j.driver.internal.util.Futures.completionExceptionCause; -import static org.neo4j.driver.internal.util.Futures.failedFuture; -import static org.neo4j.driver.internal.util.Futures.onErrorContinue; - -import io.netty.util.concurrent.EventExecutorGroup; -import java.time.Clock; -import java.util.ArrayList; -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; -import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.exceptions.SessionExpiredException; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.async.ConnectionContext; -import org.neo4j.driver.internal.async.connection.RoutingConnection; -import org.neo4j.driver.internal.cluster.Rediscovery; -import org.neo4j.driver.internal.cluster.RoutingSettings; -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 = - "Connection acquisition failed for all available addresses."; - private static final String CONNECTION_ACQUISITION_COMPLETION_EXCEPTION_MESSAGE = - "Failed to obtain connection towards %s server. Known routing table is: %s"; - private static final String CONNECTION_ACQUISITION_ATTEMPT_FAILURE_MESSAGE = - "Failed to obtain a connection towards address %s, will try other addresses if available. Complete failure is reported separately from this entry."; - private final ConnectionPool connectionPool; - private final RoutingTableRegistry routingTables; - private final LoadBalancingStrategy loadBalancingStrategy; - private final EventExecutorGroup eventExecutorGroup; - private final Logger log; - private final Rediscovery rediscovery; - - public LoadBalancer( - ConnectionPool connectionPool, - Rediscovery rediscovery, - RoutingSettings settings, - LoadBalancingStrategy loadBalancingStrategy, - EventExecutorGroup eventExecutorGroup, - Clock clock, - Logging logging) { - this( - connectionPool, - createRoutingTables(connectionPool, rediscovery, settings, clock, logging), - rediscovery, - loadBalancingStrategy, - eventExecutorGroup, - logging); - } - - LoadBalancer( - ConnectionPool connectionPool, - RoutingTableRegistry routingTables, - Rediscovery rediscovery, - LoadBalancingStrategy loadBalancingStrategy, - EventExecutorGroup eventExecutorGroup, - Logging logging) { - requireNonNull(rediscovery, "rediscovery must not be null"); - this.connectionPool = connectionPool; - this.routingTables = routingTables; - this.rediscovery = rediscovery; - this.loadBalancingStrategy = loadBalancingStrategy; - this.eventExecutorGroup = eventExecutorGroup; - this.log = logging.getLog(getClass()); - } - - @Override - public CompletionStage acquireConnection(ConnectionContext context) { - return routingTables.ensureRoutingTable(context).thenCompose(handler -> acquire( - context.mode(), handler.routingTable(), context.overrideAuthToken()) - .thenApply(connection -> new RoutingConnection( - connection, - Futures.joinNowOrElseThrow( - context.databaseNameFuture(), PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER), - context.mode(), - context.impersonatedUser(), - handler))); - } - - @Override - public CompletionStage verifyConnectivity() { - return this.supportsMultiDb() - .thenCompose(supports -> routingTables.ensureRoutingTable(simple(supports))) - .handle((ignored, error) -> { - if (error != null) { - var cause = completionExceptionCause(error); - if (cause instanceof ServiceUnavailableException) { - throw Futures.asCompletionException(new ServiceUnavailableException( - "Unable to connect to database management service, ensure the database is running and that there is a working network connection to it.", - cause)); - } - throw Futures.asCompletionException(cause); - } - return null; - }); - } - - @Override - public CompletionStage close() { - return connectionPool.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 { - addresses = rediscovery.resolve(); - } catch (Throwable error) { - return failedFuture(error); - } - CompletableFuture result = completedWithNull(); - Throwable baseError = new ServiceUnavailableException(baseErrorMessagePrefix + addresses); - - for (var address : addresses) { - result = onErrorContinue(result, baseError, completionError -> { - // We fail fast on security errors - var error = completionExceptionCause(completionError); - if (error instanceof SecurityException) { - return failedFuture(error); - } - return connectionPool.acquire(address, null).thenCompose(conn -> { - boolean featureDetected = featureDetectionFunction.apply(conn); - return conn.release().thenApply(ignored -> featureDetected); - }); - }); - } - return onErrorContinue(result, baseError, completionError -> { - // If we failed with security errors, then we rethrow the security error out, otherwise we throw the chained - // errors. - var error = completionExceptionCause(completionError); - if (error instanceof SecurityException) { - return failedFuture(error); - } - return failedFuture(baseError); - }); - } - - public RoutingTableRegistry getRoutingTableRegistry() { - return routingTables; - } - - private CompletionStage acquire( - AccessMode mode, RoutingTable routingTable, AuthToken overrideAuthToken) { - var result = new CompletableFuture(); - List attemptExceptions = new ArrayList<>(); - acquire(mode, routingTable, result, overrideAuthToken, attemptExceptions); - return result; - } - - private void acquire( - AccessMode mode, - RoutingTable routingTable, - CompletableFuture result, - AuthToken overrideAuthToken, - List attemptErrors) { - var addresses = getAddressesByMode(mode, routingTable); - var address = selectAddress(mode, addresses); - - if (address == null) { - var completionError = new SessionExpiredException( - format(CONNECTION_ACQUISITION_COMPLETION_EXCEPTION_MESSAGE, mode, routingTable)); - attemptErrors.forEach(completionError::addSuppressed); - log.error(CONNECTION_ACQUISITION_COMPLETION_FAILURE_MESSAGE, completionError); - result.completeExceptionally(completionError); - return; - } - - connectionPool.acquire(address, overrideAuthToken).whenComplete((connection, completionError) -> { - var error = completionExceptionCause(completionError); - if (error != null) { - if (error instanceof ServiceUnavailableException) { - var attemptMessage = format(CONNECTION_ACQUISITION_ATTEMPT_FAILURE_MESSAGE, address); - log.warn(attemptMessage); - log.debug(attemptMessage, error); - attemptErrors.add(error); - routingTable.forget(address); - eventExecutorGroup - .next() - .execute(() -> acquire(mode, routingTable, result, overrideAuthToken, attemptErrors)); - } else { - result.completeExceptionally(error); - } - } else { - result.complete(connection); - } - }); - } - - private static List getAddressesByMode(AccessMode mode, RoutingTable routingTable) { - return switch (mode) { - case READ -> routingTable.readers(); - case WRITE -> routingTable.writers(); - }; - } - - private BoltServerAddress selectAddress(AccessMode mode, List addresses) { - return switch (mode) { - case READ -> loadBalancingStrategy.selectReader(addresses); - case WRITE -> loadBalancingStrategy.selectWriter(addresses); - }; - } - - private static RoutingTableRegistry createRoutingTables( - ConnectionPool connectionPool, - Rediscovery rediscovery, - RoutingSettings settings, - Clock clock, - Logging logging) { - return new RoutingTableRegistryImpl( - connectionPool, rediscovery, clock, logging, settings.routingTablePurgeDelayMs()); - } - - /** - * This method is only for testing - */ - public Rediscovery getRediscovery() { - return rediscovery; - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursorImpl.java b/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursorImpl.java deleted file mode 100644 index cdf0d59e81..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursorImpl.java +++ /dev/null @@ -1,141 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cursor; - -import java.util.List; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionStage; -import java.util.function.Consumer; -import java.util.function.Function; -import org.neo4j.driver.Record; -import org.neo4j.driver.exceptions.NoSuchRecordException; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.util.Futures; -import org.neo4j.driver.summary.ResultSummary; - -public class AsyncResultCursorImpl implements AsyncResultCursor { - private final Throwable runError; - private final RunResponseHandler runHandler; - private final PullAllResponseHandler pullAllHandler; - - public AsyncResultCursorImpl( - Throwable runError, RunResponseHandler runHandler, PullAllResponseHandler pullAllHandler) { - this.runError = runError; - this.runHandler = runHandler; - this.pullAllHandler = pullAllHandler; - } - - @Override - public List keys() { - return runHandler.queryKeys().keys(); - } - - @Override - public CompletionStage consumeAsync() { - return pullAllHandler.consumeAsync(); - } - - @Override - public CompletionStage nextAsync() { - return pullAllHandler.nextAsync(); - } - - @Override - public CompletionStage peekAsync() { - return pullAllHandler.peekAsync(); - } - - @Override - public CompletionStage singleAsync() { - return nextAsync().thenCompose(firstRecord -> { - if (firstRecord == null) { - throw new NoSuchRecordException("Cannot retrieve a single record, because this result is empty."); - } - return nextAsync().thenApply(secondRecord -> { - if (secondRecord != null) { - throw new NoSuchRecordException("Expected a result with a single record, but this result " - + "contains at least one more. Ensure your query returns only " - + "one record."); - } - return firstRecord; - }); - }); - } - - @Override - public CompletionStage forEachAsync(Consumer action) { - var resultFuture = new CompletableFuture(); - internalForEachAsync(action, resultFuture); - return resultFuture.thenCompose(ignore -> consumeAsync()); - } - - @Override - public CompletionStage> listAsync() { - return listAsync(Function.identity()); - } - - @Override - public CompletionStage> listAsync(Function mapFunction) { - return pullAllHandler.listAsync(mapFunction); - } - - @Override - public CompletionStage isOpenAsync() { - throw new UnsupportedOperationException(); - } - - @Override - public CompletionStage discardAllFailureAsync() { - // runError has priority over other errors and is expected to have been reported to user by now - return consumeAsync().handle((summary, error) -> runError != null ? null : error); - } - - @Override - public CompletionStage pullAllFailureAsync() { - // runError has priority over other errors and is expected to have been reported to user by now - return pullAllHandler.pullAllFailureAsync().thenApply(error -> runError != null ? null : error); - } - - private void internalForEachAsync(Consumer action, CompletableFuture resultFuture) { - var recordFuture = nextAsync(); - - // use async completion listener because of recursion, otherwise it is possible for - // the caller thread to get StackOverflowError when result is large and buffered - recordFuture.whenCompleteAsync((record, completionError) -> { - var error = Futures.completionExceptionCause(completionError); - if (error != null) { - resultFuture.completeExceptionally(error); - } else if (record != null) { - try { - action.accept(record); - } catch (Throwable actionError) { - resultFuture.completeExceptionally(actionError); - return; - } - internalForEachAsync(action, resultFuture); - } else { - resultFuture.complete(null); - } - }); - } - - @Override - public CompletableFuture mapSuccessfulRunCompletionAsync() { - return runError != null ? Futures.failedFuture(runError) : CompletableFuture.completedFuture(this); - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursorOnlyFactory.java b/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursorOnlyFactory.java deleted file mode 100644 index b37560f32d..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/cursor/AsyncResultCursorOnlyFactory.java +++ /dev/null @@ -1,74 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cursor; - -import static java.util.Objects.requireNonNull; - -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionStage; -import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.util.Futures; - -/** - * Used by Bolt V1, V2, V3 - */ -public class AsyncResultCursorOnlyFactory implements ResultCursorFactory { - protected final Connection connection; - protected final Message runMessage; - protected final RunResponseHandler runHandler; - private final CompletableFuture runFuture; - protected final PullAllResponseHandler pullAllHandler; - - public AsyncResultCursorOnlyFactory( - Connection connection, - Message runMessage, - RunResponseHandler runHandler, - CompletableFuture runFuture, - PullAllResponseHandler pullHandler) { - requireNonNull(connection); - requireNonNull(runMessage); - requireNonNull(runHandler); - requireNonNull(runFuture); - requireNonNull(pullHandler); - - this.connection = connection; - this.runMessage = runMessage; - this.runHandler = runHandler; - this.runFuture = runFuture; - - this.pullAllHandler = pullHandler; - } - - public CompletionStage asyncResult() { - // only write and flush messages when async result is wanted. - connection.write(runMessage, runHandler); // queues the run message, will be flushed with pull message together - pullAllHandler.prePopulateRecords(); - - return runFuture.handle((ignored, error) -> - new DisposableAsyncResultCursor(new AsyncResultCursorImpl(error, runHandler, pullAllHandler))); - } - - public CompletionStage rxResult() { - return Futures.failedFuture( - new ClientException("Driver is connected to the database that does not support driver reactive API. " - + "In order to use the driver reactive API, please upgrade to neo4j 4.0.0 or later.")); - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/DisposableAsyncResultCursor.java b/driver/src/main/java/org/neo4j/driver/internal/cursor/DisposableResultCursorImpl.java similarity index 79% rename from driver/src/main/java/org/neo4j/driver/internal/cursor/DisposableAsyncResultCursor.java rename to driver/src/main/java/org/neo4j/driver/internal/cursor/DisposableResultCursorImpl.java index 610582e452..6c053ef7a5 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cursor/DisposableAsyncResultCursor.java +++ b/driver/src/main/java/org/neo4j/driver/internal/cursor/DisposableResultCursorImpl.java @@ -18,22 +18,24 @@ import static org.neo4j.driver.internal.util.ErrorUtil.newResultConsumedError; import static org.neo4j.driver.internal.util.Futures.completedWithNull; -import static org.neo4j.driver.internal.util.Futures.failedFuture; import java.util.List; +import java.util.Objects; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionStage; import java.util.function.Consumer; import java.util.function.Function; import org.neo4j.driver.Record; +import org.neo4j.driver.async.ResultCursor; +import org.neo4j.driver.internal.FailableCursor; import org.neo4j.driver.summary.ResultSummary; -public class DisposableAsyncResultCursor implements AsyncResultCursor { - private final AsyncResultCursor delegate; +public class DisposableResultCursorImpl implements ResultCursor, FailableCursor { + private final ResultCursorImpl delegate; private boolean isDisposed; - public DisposableAsyncResultCursor(AsyncResultCursor delegate) { - this.delegate = delegate; + public DisposableResultCursorImpl(ResultCursorImpl delegate) { + this.delegate = Objects.requireNonNull(delegate); } @Override @@ -82,23 +84,9 @@ public CompletionStage isOpenAsync() { return CompletableFuture.completedFuture(!isDisposed()); } - @Override - public CompletionStage discardAllFailureAsync() { - isDisposed = true; - return delegate.discardAllFailureAsync(); - } - - @Override - public CompletionStage pullAllFailureAsync() { - // This one does not dispose the result so that a user could still visit the buffered result after this method - // call. - // This also does not assert not disposed so that this method can be called after summary. - return delegate.pullAllFailureAsync(); - } - private CompletableFuture assertNotDisposed() { if (isDisposed) { - return failedFuture(newResultConsumedError()); + return CompletableFuture.failedFuture(newResultConsumedError()); } return completedWithNull(); } @@ -108,7 +96,17 @@ boolean isDisposed() { } @Override - public CompletableFuture mapSuccessfulRunCompletionAsync() { - return this.delegate.mapSuccessfulRunCompletionAsync().thenApply(ignored -> this); + public CompletionStage discardAllFailureAsync() { + isDisposed = true; + return delegate.discardAllFailureAsync(); + } + + @Override + public CompletionStage pullAllFailureAsync() { + return delegate.pullAllFailureAsync(); + } + + public ResultCursorImpl delegate() { + return delegate; } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/ResultCursorFactoryImpl.java b/driver/src/main/java/org/neo4j/driver/internal/cursor/ResultCursorFactoryImpl.java deleted file mode 100644 index 5a7015f1e7..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/cursor/ResultCursorFactoryImpl.java +++ /dev/null @@ -1,78 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cursor; - -import static java.util.Objects.requireNonNull; - -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionStage; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.handlers.pulln.PullResponseHandler; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.spi.Connection; - -/** - * Bolt V4 - */ -public class ResultCursorFactoryImpl implements ResultCursorFactory { - private final RunResponseHandler runHandler; - private final Connection connection; - - private final PullResponseHandler pullHandler; - private final PullAllResponseHandler pullAllHandler; - private final Message runMessage; - private final CompletableFuture runFuture; - - public ResultCursorFactoryImpl( - Connection connection, - Message runMessage, - RunResponseHandler runHandler, - CompletableFuture runFuture, - PullResponseHandler pullHandler, - PullAllResponseHandler pullAllHandler) { - requireNonNull(connection); - requireNonNull(runMessage); - requireNonNull(runHandler); - requireNonNull(runFuture); - requireNonNull(pullHandler); - requireNonNull(pullAllHandler); - - this.connection = connection; - this.runMessage = runMessage; - this.runHandler = runHandler; - this.runFuture = runFuture; - this.pullHandler = pullHandler; - this.pullAllHandler = pullAllHandler; - } - - @Override - public CompletionStage asyncResult() { - // only write and flush messages when async result is wanted. - connection.write(runMessage, runHandler); // queues the run message, will be flushed with pull message together - pullAllHandler.prePopulateRecords(); - return runFuture.handle((ignored, error) -> - new DisposableAsyncResultCursor(new AsyncResultCursorImpl(error, runHandler, pullAllHandler))); - } - - @Override - public CompletionStage rxResult() { - connection.writeAndFlush(runMessage, runHandler); - return runFuture.handle( - (ignored, error) -> new RxResultCursorImpl(error, runHandler, pullHandler, connection::release)); - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/ResultCursorImpl.java b/driver/src/main/java/org/neo4j/driver/internal/cursor/ResultCursorImpl.java new file mode 100644 index 0000000000..015afe122a --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/cursor/ResultCursorImpl.java @@ -0,0 +1,1061 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.cursor; + +import static java.util.concurrent.CompletableFuture.completedFuture; +import static org.neo4j.driver.internal.types.InternalTypeSystem.TYPE_SYSTEM; + +import java.util.ArrayDeque; +import java.util.Collections; +import java.util.List; +import java.util.Objects; +import java.util.Queue; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import java.util.function.Consumer; +import java.util.function.Function; +import java.util.function.Supplier; +import org.neo4j.driver.Bookmark; +import org.neo4j.driver.Query; +import org.neo4j.driver.Record; +import org.neo4j.driver.Value; +import org.neo4j.driver.async.ResultCursor; +import org.neo4j.driver.exceptions.ClientException; +import org.neo4j.driver.exceptions.NoSuchRecordException; +import org.neo4j.driver.internal.DatabaseBookmark; +import org.neo4j.driver.internal.FailableCursor; +import org.neo4j.driver.internal.InternalRecord; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.ResponseHandler; +import org.neo4j.driver.internal.bolt.api.summary.DiscardSummary; +import org.neo4j.driver.internal.bolt.api.summary.PullSummary; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.util.Futures; +import org.neo4j.driver.internal.util.MetadataExtractor; +import org.neo4j.driver.summary.ResultSummary; + +public class ResultCursorImpl implements ResultCursor, FailableCursor, ResponseHandler { + public static final MetadataExtractor METADATA_EXTRACTOR = new MetadataExtractor("t_last"); + private final BoltConnection boltConnection; + private final Queue records; + private final Query query; + private final long fetchSize; + private final Consumer throwableConsumer; + private final Consumer bookmarkConsumer; + private final Supplier termSupplier; + private final boolean closeOnSummary; + private RunSummary runSummary; + private State state; + + private boolean apiCallInProgress; + private CompletableFuture peekFuture; + private CompletableFuture recordFuture; + private CompletableFuture secondRecordFuture; + private CompletableFuture> recordsFuture; + private CompletableFuture summaryFuture; + private ResultSummary summary; + private Throwable error; + private boolean errorExposed; + + private enum State { + READY, + STREAMING, + DISCARDING, + FAILED, + SUCCEDED + } + + public ResultCursorImpl( + BoltConnection boltConnection, + Query query, + long fetchSize, + Consumer throwableConsumer, + Consumer bookmarkConsumer, + boolean closeOnSummary, + RunSummary runSummary, + Supplier termSupplier, + List records, + PullSummary pullSummary, + DiscardSummary discardSummary, + Throwable error) { + this.boltConnection = Objects.requireNonNull(boltConnection); + this.records = new ArrayDeque<>(records); + this.query = Objects.requireNonNull(query); + this.fetchSize = fetchSize; + this.throwableConsumer = throwableConsumer; + this.bookmarkConsumer = Objects.requireNonNull(bookmarkConsumer); + this.closeOnSummary = closeOnSummary; + this.runSummary = runSummary; + this.state = State.READY; + this.termSupplier = termSupplier; + + if (error != null) { + state = State.FAILED; + this.error = error; + } else if (pullSummary != null) { + try { + this.summary = METADATA_EXTRACTOR.extractSummary( + query, boltConnection, runSummary.resultAvailableAfter(), pullSummary.metadata()); + if (pullSummary.hasMore()) { + state = State.READY; + } else { + var metadata = pullSummary.metadata(); + var bookmarkValue = metadata.get("bookmark"); + if (bookmarkValue != null + && !bookmarkValue.isNull() + && bookmarkValue.hasType(TYPE_SYSTEM.STRING())) { + var bookmarkStr = bookmarkValue.asString(); + if (!bookmarkStr.isEmpty()) { + var databaseBookmark = new DatabaseBookmark(null, Bookmark.from(bookmarkStr)); + bookmarkConsumer.accept(databaseBookmark); + } + } + state = State.SUCCEDED; + if (closeOnSummary) { + boltConnection.close(); + } + } + } catch (Throwable throwable) { + state = State.FAILED; + this.error = throwable; + } + } else if (discardSummary != null) { + try { + this.summary = METADATA_EXTRACTOR.extractSummary( + query, boltConnection, runSummary.resultAvailableAfter(), discardSummary.metadata()); + state = State.SUCCEDED; + } catch (Throwable throwable) { + state = State.FAILED; + this.error = throwable; + } + } + } + + @Override + public synchronized List keys() { + return runSummary.keys(); + } + + @Override + public synchronized CompletionStage consumeAsync() { + if (apiCallInProgress) { + return CompletableFuture.failedStage(new ClientException("API calls to result cursor must be sequential.")); + } + return switch (state) { + case READY -> { + var term = termSupplier.get(); + if (term == null) { + apiCallInProgress = true; + summaryFuture = new CompletableFuture<>(); + state = State.DISCARDING; + boltConnection + .discard(runSummary.queryId(), -1) + .thenCompose(conn -> conn.flush(this)) + .whenComplete((ignored, throwable) -> { + var error = Futures.completionExceptionCause(throwable); + CompletableFuture summaryFuture; + if (error != null) { + synchronized (this) { + state = State.FAILED; + errorExposed = true; + summaryFuture = this.summaryFuture; + this.summaryFuture = null; + apiCallInProgress = false; + } + summaryFuture.completeExceptionally(error); + } + }); + yield summaryFuture; + } else { + this.error = term; + this.state = State.FAILED; + this.errorExposed = true; + yield CompletableFuture.failedStage(error); + } + } + case STREAMING -> { + apiCallInProgress = true; + summaryFuture = new CompletableFuture<>(); + yield summaryFuture; + } + case DISCARDING -> CompletableFuture.failedStage(new ClientException("Invalid API call.")); + case FAILED -> stageExposingError(METADATA_EXTRACTOR.extractSummary( + query, boltConnection, runSummary.resultAvailableAfter(), Collections.emptyMap())); + case SUCCEDED -> CompletableFuture.completedStage(summary); + }; + } + + @Override + public synchronized CompletionStage nextAsync() { + if (apiCallInProgress) { + return CompletableFuture.failedStage(new ClientException("API calls to result cursor must be sequential.")); + } + var record = records.poll(); + if (record == null) { + // buffer is empty + return switch (state) { + case READY -> { + var term = termSupplier.get(); + if (term == null) { + apiCallInProgress = true; + recordFuture = new CompletableFuture<>(); + state = State.STREAMING; + boltConnection + .pull(runSummary.queryId(), fetchSize) + .thenCompose(conn -> conn.flush(this)) + .whenComplete((ignored, throwable) -> { + var error = Futures.completionExceptionCause(throwable); + CompletableFuture recordFuture; + if (error != null) { + synchronized (this) { + state = State.FAILED; + errorExposed = true; + recordFuture = this.recordFuture; + this.recordFuture = null; + apiCallInProgress = false; + } + recordFuture.completeExceptionally(error); + } + }); + yield recordFuture; + } else { + this.error = term; + this.state = State.FAILED; + this.errorExposed = true; + yield CompletableFuture.failedStage(error); + } + } + case STREAMING -> { + apiCallInProgress = true; + recordFuture = new CompletableFuture<>(); + yield recordFuture; + } + case DISCARDING -> CompletableFuture.failedStage(new ClientException("Invalid API call.")); + case FAILED -> stageExposingError(null); + case SUCCEDED -> CompletableFuture.completedStage(null); + }; + } else { + return completedFuture(record); + } + } + + @Override + public synchronized CompletionStage peekAsync() { + if (apiCallInProgress) { + return CompletableFuture.failedStage(new ClientException("API calls to result cursor must be sequential.")); + } + var record = records.peek(); + if (record == null) { + // buffer is empty + return switch (state) { + case READY -> { + var term = termSupplier.get(); + if (term == null) { + apiCallInProgress = true; + peekFuture = new CompletableFuture<>(); + state = State.STREAMING; + boltConnection + .pull(runSummary.queryId(), fetchSize) + .thenCompose(conn -> conn.flush(this)) + .whenComplete((ignored, throwable) -> { + var error = Futures.completionExceptionCause(throwable); + if (error != null) { + CompletableFuture peekFuture; + synchronized (this) { + state = State.FAILED; + errorExposed = true; + recordFuture = this.peekFuture; + this.peekFuture = null; + apiCallInProgress = false; + } + recordFuture.completeExceptionally(error); + } + }); + yield peekFuture; + } else { + this.error = term; + this.state = State.FAILED; + this.errorExposed = true; + yield CompletableFuture.failedStage(error); + } + } + case STREAMING -> { + apiCallInProgress = true; + peekFuture = new CompletableFuture<>(); + yield peekFuture; + } + case DISCARDING -> CompletableFuture.failedStage(new ClientException("Invalid API call.")); + case FAILED -> stageExposingError(null); + case SUCCEDED -> CompletableFuture.completedStage(null); + }; + } else { + return completedFuture(record); + } + } + + @Override + public synchronized CompletionStage singleAsync() { + if (apiCallInProgress) { + return CompletableFuture.failedStage(new ClientException("API calls to result cursor must be sequential.")); + } + if (records.size() > 1) { + records.clear(); + return CompletableFuture.failedStage( + new NoSuchRecordException( + "Expected a result with a single record, but this result contains at least one more. Ensure your query returns only one record.")); + } else { + return switch (state) { + case READY -> { + if (records.isEmpty()) { + var term = termSupplier.get(); + if (term == null) { + apiCallInProgress = true; + recordFuture = new CompletableFuture<>(); + secondRecordFuture = new CompletableFuture<>(); + var singleFuture = recordFuture.thenCompose(firstRecord -> { + if (firstRecord == null) { + throw new NoSuchRecordException( + "Cannot retrieve a single record, because this result is empty."); + } + return secondRecordFuture.thenApply(secondRecord -> { + if (secondRecord) { + throw new NoSuchRecordException( + "Expected a result with a single record, but this result contains at least one more. Ensure your query returns only one record."); + } + return firstRecord; + }); + }); + state = State.STREAMING; + boltConnection + .pull(runSummary.queryId(), fetchSize) + .thenCompose(conn -> conn.flush(this)) + .whenComplete((ignored, throwable) -> { + var error = Futures.completionExceptionCause(throwable); + if (error != null) { + CompletableFuture recordFuture; + CompletableFuture secondRecordFuture; + synchronized (this) { + state = State.FAILED; + errorExposed = true; + recordFuture = this.recordFuture; + this.recordFuture = null; + secondRecordFuture = this.secondRecordFuture; + this.secondRecordFuture = null; + apiCallInProgress = false; + } + recordFuture.completeExceptionally(error); + secondRecordFuture.completeExceptionally(error); + } + }); + yield singleFuture; + } else { + this.error = term; + this.state = State.FAILED; + this.errorExposed = true; + yield CompletableFuture.failedStage(error); + } + } else { + // records is not empty and the state is READY, meaning the result is not exhausted + yield CompletableFuture.failedStage( + new NoSuchRecordException( + "Expected a result with a single record, but this result contains at least one more. Ensure your query returns only one record.")); + } + } + case STREAMING -> { + apiCallInProgress = true; + if (records.isEmpty()) { + recordFuture = new CompletableFuture<>(); + secondRecordFuture = new CompletableFuture<>(); + yield recordFuture.thenCompose(firstRecord -> { + if (firstRecord == null) { + throw new NoSuchRecordException( + "Cannot retrieve a single record, because this result is empty."); + } + return secondRecordFuture.thenApply(secondRecord -> { + if (secondRecord) { + throw new NoSuchRecordException( + "Expected a result with a single record, but this result contains at least one more. Ensure your query returns only one record."); + } + return firstRecord; + }); + }); + } else { + var firstRecord = records.poll(); + secondRecordFuture = new CompletableFuture<>(); + yield secondRecordFuture.thenApply(secondRecord -> { + if (secondRecord) { + throw new NoSuchRecordException( + "Expected a result with a single record, but this result contains at least one more. Ensure your query returns only one record."); + } + return firstRecord; + }); + } + } + case DISCARDING -> CompletableFuture.failedStage(new ClientException("Invalid API call.")); + case FAILED -> stageExposingError(null).thenApply(ignored -> { + throw new NoSuchRecordException("Cannot retrieve a single record, because this result is empty."); + }); + case SUCCEDED -> records.size() == 1 + ? CompletableFuture.completedFuture(records.poll()) + : CompletableFuture.failedStage(new NoSuchRecordException( + "Cannot retrieve a single record, because this result is empty.")); + }; + } + } + + @Override + public synchronized CompletionStage forEachAsync(Consumer action) { + if (apiCallInProgress) { + return CompletableFuture.failedStage(new ClientException("API calls to result cursor must be sequential.")); + } + var summaryFuture = new CompletableFuture(); + return switch (state) { + case READY, STREAMING, DISCARDING -> { + this.summaryFuture = summaryFuture; + yield listAsync().thenCompose(list -> { + list.forEach(action); + return summaryFuture; + }); + } + case FAILED -> listAsync().thenApply(ignored -> null); + case SUCCEDED -> listAsync().thenApply(list -> { + list.forEach(action); + return summary; + }); + }; + } + + @Override + public synchronized CompletionStage> listAsync() { + if (apiCallInProgress) { + return CompletableFuture.failedStage(new ClientException("API calls to result cursor must be sequential.")); + } + return switch (state) { + case READY -> { + var term = termSupplier.get(); + if (term == null) { + apiCallInProgress = true; + recordsFuture = new CompletableFuture<>(); + state = State.STREAMING; + boltConnection + .pull(runSummary.queryId(), -1) + .thenCompose(conn -> conn.flush(this)) + .whenComplete((ignored, throwable) -> { + var error = Futures.completionExceptionCause(throwable); + CompletableFuture> recordsFuture; + if (error != null) { + synchronized (this) { + state = State.FAILED; + errorExposed = true; + recordsFuture = this.recordsFuture; + this.recordsFuture = null; + apiCallInProgress = false; + } + recordsFuture.completeExceptionally(error); + } + }); + yield recordsFuture; + } else { + this.error = term; + this.state = State.FAILED; + this.errorExposed = true; + yield CompletableFuture.failedStage(error); + } + } + case STREAMING -> { + apiCallInProgress = true; + recordsFuture = new CompletableFuture<>(); + yield recordsFuture; + } + case DISCARDING -> CompletableFuture.failedStage(new ClientException("Invalid API call.")); + case FAILED -> stageExposingError(null).thenApply(ignored -> Collections.emptyList()); + case SUCCEDED -> { + var records = this.records.stream().toList(); + this.records.clear(); + yield CompletableFuture.completedStage(records); + } + }; + } + + @Override + public CompletionStage> listAsync(Function mapFunction) { + return listAsync().thenApply(list -> list.stream().map(mapFunction).toList()); + } + + @Override + public CompletionStage isOpenAsync() { + if (apiCallInProgress) { + return CompletableFuture.failedStage(new ClientException("API calls to result cursor must be sequential.")); + } + return switch (state) { + case READY, STREAMING, DISCARDING -> CompletableFuture.completedStage(true); + case FAILED, SUCCEDED -> CompletableFuture.completedStage(false); + }; + } + + @Override + public void onRecord(Value[] fields) { + var record = new InternalRecord(runSummary.keys(), fields); + CompletableFuture peekFuture; + CompletableFuture recordFuture = null; + CompletableFuture secondRecordFuture = null; + synchronized (this) { + peekFuture = this.peekFuture; + this.peekFuture = null; + if (peekFuture != null) { + apiCallInProgress = false; + records.add(record); + } else { + recordFuture = this.recordFuture; + this.recordFuture = null; + + secondRecordFuture = this.secondRecordFuture; + if (recordFuture == null) { + if (secondRecordFuture != null) { + apiCallInProgress = false; + this.secondRecordFuture = null; + } + records.add(record); + } else { + if (secondRecordFuture == null) { + apiCallInProgress = false; + } + } + } + } + if (peekFuture != null) { + peekFuture.complete(record); + } else if (recordFuture != null) { + recordFuture.complete(record); + } else if (secondRecordFuture != null) { + secondRecordFuture.complete(true); + } + } + + @Override + public void onError(Throwable throwable) { + CompletableFuture peekFuture; + CompletableFuture recordFuture = null; + CompletableFuture secondRecordFuture = null; + CompletableFuture> recordsFuture = null; + CompletableFuture summaryFuture = null; + + synchronized (this) { + state = State.FAILED; + this.error = throwable; + + peekFuture = this.peekFuture; + this.peekFuture = null; + if (peekFuture != null) { + errorExposed = true; + apiCallInProgress = false; + } else { + recordFuture = this.recordFuture; + this.recordFuture = null; + if (recordFuture != null) { + secondRecordFuture = this.secondRecordFuture; + this.secondRecordFuture = null; + errorExposed = true; + apiCallInProgress = false; + } else { + secondRecordFuture = this.secondRecordFuture; + this.secondRecordFuture = null; + if (secondRecordFuture != null) { + errorExposed = true; + apiCallInProgress = false; + } else { + recordsFuture = this.recordsFuture; + this.recordsFuture = null; + if (recordsFuture != null) { + errorExposed = true; + apiCallInProgress = false; + } else { + summaryFuture = this.summaryFuture; + this.summaryFuture = null; + if (summaryFuture != null) { + errorExposed = true; + apiCallInProgress = false; + } + } + } + } + } + } + + if (peekFuture != null) { + peekFuture.completeExceptionally(throwable); + } + if (recordFuture != null) { + recordFuture.completeExceptionally(throwable); + } + if (secondRecordFuture != null) { + secondRecordFuture.completeExceptionally(throwable); + } + if (recordsFuture != null) { + recordsFuture.completeExceptionally(throwable); + } + if (summaryFuture != null) { + summaryFuture.completeExceptionally(throwable); + } + + if (throwableConsumer != null) { + throwableConsumer.accept(throwable); + } + if (closeOnSummary) { + boltConnection.close(); + } + } + + @Override + public void onDiscardSummary(DiscardSummary summary) { + synchronized (this) { + CompletableFuture peekFuture; + CompletableFuture recordFuture = null; + CompletableFuture secondRecordFuture = null; + Runnable recordsFutureRunnable = null; + CompletableFuture summaryFuture = null; + Throwable summaryError = null; + synchronized (this) { + try { + this.summary = METADATA_EXTRACTOR.extractSummary(query, boltConnection, -1, summary.metadata()); + state = State.SUCCEDED; + } catch (Throwable throwable) { + summaryError = throwable; + } + peekFuture = this.peekFuture; + this.peekFuture = null; + if (peekFuture != null) { + // peek is pending + apiCallInProgress = false; + } else { + recordFuture = this.recordFuture; + this.recordFuture = null; + if (recordFuture != null) { + // next is pending + apiCallInProgress = false; + } else { + secondRecordFuture = this.secondRecordFuture; + this.secondRecordFuture = null; + + if (secondRecordFuture != null) { + // single is pending + apiCallInProgress = false; + } else { + if (this.recordsFuture != null) { + // list is pending + apiCallInProgress = false; + var recordsFuture = this.recordsFuture; + this.recordsFuture = null; + var records = this.records.stream().toList(); + this.records.clear(); + recordsFutureRunnable = () -> recordsFuture.complete(records); + } else if (this.summaryFuture != null) { + // consume is pending + apiCallInProgress = false; + summaryFuture = this.summaryFuture; + this.summaryFuture = null; + } + } + } + } + } + if (summaryError == null) { + if (peekFuture != null) { + peekFuture.complete(null); + } + if (recordFuture != null) { + recordFuture.complete(null); + } else if (secondRecordFuture != null) { + secondRecordFuture.complete(false); + } else if (recordsFutureRunnable != null) { + recordsFutureRunnable.run(); + } else if (summaryFuture != null) { + summaryFuture.complete(this.summary); + } + if (closeOnSummary) { + boltConnection.close(); + } + } else { + onError(summaryError); + } + } + } + + @Override + public void onPullSummary(PullSummary summary) { + if (summary.hasMore()) { + CompletableFuture secondRecordFuture = null; + synchronized (this) { + if (this.peekFuture != null) { + var term = termSupplier.get(); + if (term == null) { + // peek is pending, keep streaming + state = State.STREAMING; + boltConnection + .pull(runSummary.queryId(), fetchSize) + .thenCompose(conn -> conn.flush(this)) + .whenComplete((ignored, throwable) -> { + var error = Futures.completionExceptionCause(throwable); + if (error != null) { + CompletableFuture peekFuture; + synchronized (this) { + state = State.FAILED; + errorExposed = true; + peekFuture = this.peekFuture; + this.peekFuture = null; + apiCallInProgress = false; + } + peekFuture.completeExceptionally(error); + } + }); + } else { + this.error = term; + this.state = State.FAILED; + this.errorExposed = true; + var peekFuture = this.peekFuture; + this.peekFuture = null; + peekFuture.completeExceptionally(error); + } + } else if (this.recordFuture != null) { + var term = termSupplier.get(); + if (term == null) { + // next is pending, keep streaming + state = State.STREAMING; + boltConnection + .pull(runSummary.queryId(), fetchSize) + .thenCompose(conn -> conn.flush(this)) + .whenComplete((ignored, throwable) -> { + var error = Futures.completionExceptionCause(throwable); + if (error != null) { + CompletableFuture recordFuture; + synchronized (this) { + state = State.FAILED; + errorExposed = true; + recordFuture = this.recordFuture; + this.recordFuture = null; + apiCallInProgress = false; + } + recordFuture.completeExceptionally(error); + } + }); + } else { + this.error = term; + this.state = State.FAILED; + this.errorExposed = true; + var recordFuture = this.recordFuture; + this.recordFuture = null; + recordFuture.completeExceptionally(error); + } + } else { + secondRecordFuture = this.secondRecordFuture; + this.secondRecordFuture = null; + + if (secondRecordFuture != null) { + // single is pending + apiCallInProgress = false; + state = State.READY; + } else { + if (this.recordsFuture != null) { + var term = termSupplier.get(); + if (term == null) { + // list is pending, stream all + state = State.STREAMING; + boltConnection + .pull(runSummary.queryId(), -1) + .thenCompose(conn -> conn.flush(this)) + .whenComplete((ignored, throwable) -> { + var error = Futures.completionExceptionCause(throwable); + if (error != null) { + CompletableFuture> recordsFuture; + synchronized (this) { + state = State.FAILED; + errorExposed = true; + recordsFuture = this.recordsFuture; + this.recordsFuture = null; + apiCallInProgress = false; + } + recordsFuture.completeExceptionally(error); + } + }); + } else { + this.error = term; + this.state = State.FAILED; + this.errorExposed = true; + var recordsFuture = this.recordsFuture; + this.recordsFuture = null; + recordsFuture.completeExceptionally(error); + } + } else if (this.summaryFuture != null) { + var term = termSupplier.get(); + if (term == null) { + // consume is pending, discard all + state = State.DISCARDING; + boltConnection + .discard(runSummary.queryId(), -1) + .thenCompose(conn -> conn.flush(this)) + .whenComplete((ignored, throwable) -> { + var error = Futures.completionExceptionCause(throwable); + CompletableFuture summaryFuture; + if (error != null) { + synchronized (this) { + state = State.FAILED; + errorExposed = true; + summaryFuture = this.summaryFuture; + this.summaryFuture = null; + apiCallInProgress = false; + } + summaryFuture.completeExceptionally(error); + } + }); + } else { + this.error = term; + this.state = State.FAILED; + this.errorExposed = true; + var summaryFuture = this.recordsFuture; + this.summaryFuture = null; + summaryFuture.completeExceptionally(error); + } + } else { + state = State.READY; + } + } + } + } + if (secondRecordFuture != null) { + secondRecordFuture.complete(true); + } + } else { + CompletableFuture peekFuture; + CompletableFuture recordFuture = null; + CompletableFuture secondRecordFuture = null; + Runnable recordsFutureRunnable = null; + CompletableFuture summaryFuture = null; + DatabaseBookmark databaseBookmark = null; + Throwable error = null; + synchronized (this) { + state = State.SUCCEDED; + try { + this.summary = METADATA_EXTRACTOR.extractSummary( + query, boltConnection, runSummary.resultAvailableAfter(), summary.metadata()); + } catch (Throwable throwable) { + error = throwable; + this.error = throwable; + state = State.FAILED; + } + var metadata = summary.metadata(); + var bookmarkValue = metadata.get("bookmark"); + if (bookmarkValue != null && !bookmarkValue.isNull() && bookmarkValue.hasType(TYPE_SYSTEM.STRING())) { + var bookmarkStr = bookmarkValue.asString(); + if (!bookmarkStr.isEmpty()) { + databaseBookmark = new DatabaseBookmark(null, Bookmark.from(bookmarkStr)); + } + } + peekFuture = this.peekFuture; + this.peekFuture = null; + if (peekFuture != null) { + // peek is pending + apiCallInProgress = false; + error = this.error; + errorExposed = true; + } else { + recordFuture = this.recordFuture; + this.recordFuture = null; + if (recordFuture != null) { + // peek is pending + apiCallInProgress = false; + error = this.error; + errorExposed = true; + } else { + secondRecordFuture = this.secondRecordFuture; + this.secondRecordFuture = null; + + if (secondRecordFuture != null) { + // single is pending + apiCallInProgress = false; + error = this.error; + errorExposed = true; + } else { + if (this.recordsFuture != null) { + if (this.summaryFuture == null) { + // list is pending + apiCallInProgress = false; + if (this.error == null) { + var recordsFuture = this.recordsFuture; + this.recordsFuture = null; + var records = this.records.stream().toList(); + this.records.clear(); + recordsFutureRunnable = () -> recordsFuture.complete(records); + } else { + recordsFutureRunnable = () -> recordsFuture.completeExceptionally(this.error); + errorExposed = true; + } + } else { + // for-each is pending + apiCallInProgress = false; + summaryFuture = this.summaryFuture; + this.summaryFuture = null; + if (this.error == null) { + var recordsFuture = this.recordsFuture; + this.recordsFuture = null; + var records = this.records.stream().toList(); + this.records.clear(); + recordsFutureRunnable = () -> recordsFuture.complete(records); + } else { + error = this.error; + errorExposed = true; + } + } + } else if (this.summaryFuture != null) { + // consume is pending + apiCallInProgress = false; + summaryFuture = this.summaryFuture; + this.summaryFuture = null; + error = this.error; + errorExposed = true; + } + } + } + } + } + if (databaseBookmark != null) { + bookmarkConsumer.accept(databaseBookmark); + } + if (peekFuture != null) { + if (error != null) { + peekFuture.completeExceptionally(error); + } + peekFuture.complete(null); + } + if (recordFuture != null) { + if (error != null) { + recordFuture.completeExceptionally(error); + } + recordFuture.complete(null); + } else if (secondRecordFuture != null) { + if (error != null) { + secondRecordFuture.completeExceptionally(error); + } + secondRecordFuture.complete(false); + } else if (recordsFutureRunnable != null) { + recordsFutureRunnable.run(); + if (summaryFuture != null) { + // for-each using list + summaryFuture.complete(this.summary); + } + } else if (summaryFuture != null) { + if (error != null) { + summaryFuture.completeExceptionally(error); + } + summaryFuture.complete(this.summary); + } + if (throwableConsumer != null && error != null) { + throwableConsumer.accept(error); + } + if (closeOnSummary) { + boltConnection.close(); + } + } + } + + @Override + public synchronized CompletionStage discardAllFailureAsync() { + return consumeAsync().handle((summary, error) -> error); + } + + @Override + public CompletionStage pullAllFailureAsync() { + synchronized (this) { + if (apiCallInProgress) { + return CompletableFuture.failedStage( + new ClientException("API calls to result cursor must be sequential.")); + } + return switch (state) { + case READY -> { + var term = termSupplier.get(); + if (term == null) { + apiCallInProgress = true; + summaryFuture = new CompletableFuture<>(); + state = State.STREAMING; + boltConnection + .pull(runSummary.queryId(), -1) + .thenCompose(conn -> conn.flush(this)) + .whenComplete((ignored, throwable) -> { + var error = Futures.completionExceptionCause(throwable); + CompletableFuture summaryFuture; + if (error != null) { + synchronized (this) { + state = State.FAILED; + errorExposed = true; + summaryFuture = this.summaryFuture; + this.summaryFuture = null; + apiCallInProgress = false; + } + summaryFuture.completeExceptionally(error); + } + }); + yield summaryFuture.handle((ignored, throwable) -> throwable); + } else { + this.error = term; + this.state = State.FAILED; + this.errorExposed = true; + yield CompletableFuture.failedStage(error); + } + } + case STREAMING -> { + var term = termSupplier.get(); + if (term == null) { + apiCallInProgress = true; + // no pending request should be in place + recordsFuture = new CompletableFuture<>(); + yield recordsFuture.handle((ignored, throwable) -> throwable); + } else { + this.error = term; + this.state = State.FAILED; + this.errorExposed = true; + yield CompletableFuture.failedStage(error); + } + } + case DISCARDING -> { + var term = termSupplier.get(); + if (term == null) { + apiCallInProgress = true; + // no pending request should be in place + summaryFuture = new CompletableFuture<>(); + yield summaryFuture.handle((ignored, throwable) -> throwable); + } else { + this.error = term; + this.state = State.FAILED; + this.errorExposed = true; + yield CompletableFuture.failedStage(error); + } + } + case FAILED -> stageExposingError(null).handle((ignored, throwable) -> throwable); + case SUCCEDED -> CompletableFuture.completedStage(null); + }; + } + } + + private CompletionStage stageExposingError(T value) { + synchronized (this) { + if (error != null && !errorExposed) { + errorExposed = true; + return CompletableFuture.failedStage(error); + } + } + return CompletableFuture.completedStage(value); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/cursor/RxResultCursorImpl.java b/driver/src/main/java/org/neo4j/driver/internal/cursor/RxResultCursorImpl.java index 63358fa0ce..39db28d5f1 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cursor/RxResultCursorImpl.java +++ b/driver/src/main/java/org/neo4j/driver/internal/cursor/RxResultCursorImpl.java @@ -16,180 +16,484 @@ */ package org.neo4j.driver.internal.cursor; -import static org.neo4j.driver.internal.cursor.RxResultCursorImpl.RecordConsumerStatus.DISCARD_INSTALLED; -import static org.neo4j.driver.internal.cursor.RxResultCursorImpl.RecordConsumerStatus.INSTALLED; -import static org.neo4j.driver.internal.cursor.RxResultCursorImpl.RecordConsumerStatus.NOT_INSTALLED; -import static org.neo4j.driver.internal.util.ErrorUtil.newResultConsumedError; +import static org.neo4j.driver.internal.types.InternalTypeSystem.TYPE_SYSTEM; +import java.util.Collections; import java.util.List; import java.util.Objects; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionStage; +import java.util.concurrent.atomic.AtomicReference; import java.util.function.BiConsumer; +import java.util.function.Consumer; import java.util.function.Supplier; +import org.neo4j.driver.Bookmark; +import org.neo4j.driver.Query; import org.neo4j.driver.Record; +import org.neo4j.driver.Value; import org.neo4j.driver.exceptions.TransactionNestingException; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.handlers.pulln.PullResponseHandler; +import org.neo4j.driver.internal.DatabaseBookmark; +import org.neo4j.driver.internal.InternalRecord; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.ResponseHandler; +import org.neo4j.driver.internal.bolt.api.summary.DiscardSummary; +import org.neo4j.driver.internal.bolt.api.summary.PullSummary; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.util.Futures; +import org.neo4j.driver.internal.util.MetadataExtractor; import org.neo4j.driver.summary.ResultSummary; -public class RxResultCursorImpl implements RxResultCursor { - static final BiConsumer DISCARD_RECORD_CONSUMER = (record, throwable) -> { - /*do nothing*/ - }; - private final RunResponseHandler runHandler; - private final PullResponseHandler pullHandler; - private final Throwable runResponseError; - private final Supplier> connectionReleaseSupplier; - private boolean runErrorSurfaced; +public class RxResultCursorImpl implements RxResultCursor, ResponseHandler { + public static final MetadataExtractor METADATA_EXTRACTOR = new MetadataExtractor("t_last"); + private final BoltConnection boltConnection; + private final Query query; + private final RunSummary runSummary; + private final Throwable runError; + private final Consumer bookmarkConsumer; + private final Consumer throwableConsumer; + private final Supplier termSupplier; + private final boolean closeOnSummary; private final CompletableFuture summaryFuture = new CompletableFuture<>(); - private boolean summaryFutureExposed; - private boolean resultConsumed; - private RecordConsumerStatus consumerStatus = NOT_INSTALLED; - // for testing only - public RxResultCursorImpl(RunResponseHandler runHandler, PullResponseHandler pullHandler) { - this(null, runHandler, pullHandler, () -> CompletableFuture.completedFuture(null)); + private State state; + private long outstandingDemand; + private BiConsumer recordConsumer; + private boolean discardPending; + private boolean runErrorExposed; + private boolean summaryExposed; + + private enum State { + READY, + STREAMING, + DISCARDING, + FAILED, + SUCCEDED } public RxResultCursorImpl( + BoltConnection boltConnection, + Query query, + RunSummary runSummary, Throwable runError, - RunResponseHandler runHandler, - PullResponseHandler pullHandler, - Supplier> connectionReleaseSupplier) { - Objects.requireNonNull(runHandler); - Objects.requireNonNull(pullHandler); + Supplier throwableSupplier, + Consumer bookmarkConsumer, + Consumer throwableConsumer, + boolean closeOnSummary, + Supplier termSupplier) { + this.boltConnection = boltConnection; + this.query = query; + if (runSummary != null) { + this.runSummary = runSummary; + this.state = State.READY; + } else { + this.runSummary = new RunSummary() { + @Override + public long queryId() { + return -1; + } - this.runResponseError = runError; - this.runHandler = runHandler; - this.pullHandler = pullHandler; - this.connectionReleaseSupplier = connectionReleaseSupplier; - installSummaryConsumer(); - } + @Override + public List keys() { + return List.of(); + } - @Override - public List keys() { - return runHandler.queryKeys().keys(); + @Override + public long resultAvailableAfter() { + return -1; + } + }; + this.state = State.FAILED; + this.summaryFuture.completeExceptionally(runError); + } + this.runError = runError; + this.bookmarkConsumer = bookmarkConsumer; + this.closeOnSummary = closeOnSummary; + this.throwableConsumer = throwableConsumer; + this.termSupplier = termSupplier; } @Override - public void installRecordConsumer(BiConsumer recordConsumer) { - if (resultConsumed) { - throw newResultConsumedError(); + public void onError(Throwable throwable) { + Runnable runnable; + + synchronized (this) { + if (state == State.FAILED) { + return; + } + state = State.FAILED; + var summary = METADATA_EXTRACTOR.extractSummary( + query, boltConnection, runSummary.resultAvailableAfter(), Collections.emptyMap()); + + if (recordConsumer != null) { + // records subscriber present + runnable = () -> { + var closeStage = closeOnSummary ? boltConnection.close() : CompletableFuture.completedStage(null); + closeStage.whenComplete((ignored, closeThrowable) -> { + var error = Futures.completionExceptionCause(closeThrowable); + if (error != null) { + throwable.addSuppressed(error); + } + throwableConsumer.accept(throwable); + recordConsumer.accept(null, throwable); + summaryFuture.complete(summary); + dispose(); + }); + }; + } else { + runnable = () -> { + var closeStage = closeOnSummary ? boltConnection.close() : CompletableFuture.completedStage(null); + closeStage.whenComplete((ignored, closeThrowable) -> { + var error = Futures.completionExceptionCause(closeThrowable); + if (error != null) { + throwable.addSuppressed(error); + } + throwableConsumer.accept(throwable); + summaryFuture.completeExceptionally(throwable); + dispose(); + }); + }; + } } - if (consumerStatus.isInstalled()) { - return; + runnable.run(); + } + + @Override + public void onRecord(Value[] fields) { + var record = new InternalRecord(runSummary.keys(), fields); + synchronized (this) { + decrementDemand(); } - consumerStatus = recordConsumer == DISCARD_RECORD_CONSUMER ? DISCARD_INSTALLED : INSTALLED; - pullHandler.installRecordConsumer(recordConsumer); - assertRunCompletedSuccessfully(); + recordConsumer.accept(record, null); } @Override - public void request(long n) { - if (n == Long.MAX_VALUE) { - n = -1; + public void onPullSummary(PullSummary summary) { + var term = termSupplier.get(); + if (term == null) { + if (summary.hasMore()) { + synchronized (this) { + if (discardPending) { + discardPending = false; + state = State.DISCARDING; + boltConnection + .discard(runSummary.queryId(), -1) + .thenCompose(conn -> conn.flush(this)) + .whenComplete((ignored, throwable) -> { + var error = Futures.completionExceptionCause(throwable); + if (error != null) { + onError(error); + } + }); + } else { + var demand = getDemand(); + if (demand > 0) { + state = State.STREAMING; + boltConnection + .pull(runSummary.queryId(), demand) + .thenCompose(conn -> conn.flush(this)) + .whenComplete((ignored, throwable) -> { + var error = Futures.completionExceptionCause(throwable); + if (error != null) { + onError(error); + } + }); + } else { + state = State.READY; + } + } + } + } else { + var resultSummaryRef = new AtomicReference(); + CompletableFuture resultSummaryFuture; + Throwable summaryError = null; + synchronized (this) { + resultSummaryFuture = summaryFuture; + try { + resultSummaryRef.set(METADATA_EXTRACTOR.extractSummary( + query, boltConnection, runSummary.resultAvailableAfter(), summary.metadata())); + state = State.SUCCEDED; + } catch (Throwable throwable) { + summaryError = throwable; + } + } + + if (summaryError == null) { + var metadata = summary.metadata(); + var bookmarkValue = metadata.get("bookmark"); + if (bookmarkValue != null + && !bookmarkValue.isNull() + && bookmarkValue.hasType(TYPE_SYSTEM.STRING())) { + var bookmarkStr = bookmarkValue.asString(); + if (!bookmarkStr.isEmpty()) { + var databaseBookmark = new DatabaseBookmark(null, Bookmark.from(bookmarkStr)); + bookmarkConsumer.accept(databaseBookmark); + } + } + + recordConsumer.accept(null, null); + + var closeStage = closeOnSummary ? boltConnection.close() : CompletableFuture.completedStage(null); + closeStage.whenComplete((ignored, throwable) -> { + var error = Futures.completionExceptionCause(throwable); + if (error != null) { + resultSummaryFuture.completeExceptionally(error); + } else { + resultSummaryFuture.complete(resultSummaryRef.get()); + } + }); + dispose(); + } else { + onError(summaryError); + } + } + } else { + onError(term); } - pullHandler.request(n); } @Override - public void cancel() { - pullHandler.cancel(); + public void onDiscardSummary(DiscardSummary summary) { + var resultSummaryRef = new AtomicReference(); + CompletableFuture resultSummaryFuture; + Throwable summaryError = null; + synchronized (this) { + resultSummaryFuture = summaryFuture; + try { + resultSummaryRef.set(METADATA_EXTRACTOR.extractSummary( + query, boltConnection, runSummary.resultAvailableAfter(), summary.metadata())); + state = State.SUCCEDED; + } catch (Throwable throwable) { + summaryError = throwable; + } + } + + if (summaryError == null) { + var metadata = summary.metadata(); + var bookmarkValue = metadata.get("bookmark"); + if (bookmarkValue != null && !bookmarkValue.isNull() && bookmarkValue.hasType(TYPE_SYSTEM.STRING())) { + var bookmarkStr = bookmarkValue.asString(); + if (!bookmarkStr.isEmpty()) { + var databaseBookmark = new DatabaseBookmark(null, Bookmark.from(bookmarkStr)); + bookmarkConsumer.accept(databaseBookmark); + } + } + + var closeStage = closeOnSummary ? boltConnection.close() : CompletableFuture.completedStage(null); + closeStage.whenComplete((ignored, throwable) -> { + var error = Futures.completionExceptionCause(throwable); + if (error != null) { + resultSummaryFuture.completeExceptionally(error); + } else { + resultSummaryFuture.complete(resultSummaryRef.get()); + } + }); + dispose(); + } else { + onError(summaryError); + } } @Override - public CompletionStage discardAllFailureAsync() { - // calling this method will enforce discarding record stream and finish running cypher query - return summaryStage() - .thenApply(summary -> (Throwable) null) - .exceptionally(throwable -> runErrorSurfaced || summaryFutureExposed ? null : throwable); + public synchronized CompletionStage discardAllFailureAsync() { + var summaryExposed = this.summaryExposed; + return summaryAsync() + .thenApply(ignored -> (Throwable) null) + .exceptionally(throwable -> runErrorExposed || summaryExposed ? null : throwable); } @Override public CompletionStage pullAllFailureAsync() { - if (consumerStatus.isInstalled() && !isDone()) { - return CompletableFuture.completedFuture( - new TransactionNestingException( - "You cannot run another query or begin a new transaction in the same session before you've fully consumed the previous run result.")); + synchronized (this) { + if (recordConsumer != null && !isDone()) { + return CompletableFuture.completedFuture( + new TransactionNestingException( + "You cannot run another query or begin a new transaction in the same session before you've fully consumed the previous run result.")); + } } - // It is safe to discard records as either the streaming has not started at all, or the streaming is fully - // finished. return discardAllFailureAsync(); } + @Override + public List keys() { + return runSummary.keys(); + } + + @Override + public void installRecordConsumer(BiConsumer recordConsumer) { + Objects.requireNonNull(recordConsumer); + Runnable runnable = () -> {}; + synchronized (this) { + if (this.recordConsumer == null) { + this.recordConsumer = recordConsumer; + if (runError != null) { + runErrorExposed = true; + runnable = () -> recordConsumer.accept(null, runError); + } + } + } + runnable.run(); + } + @Override public CompletionStage summaryAsync() { - summaryFutureExposed = true; - return summaryStage(); + synchronized (this) { + if (summaryExposed) { + return summaryFuture; + } + summaryExposed = true; + switch (state) { + case SUCCEDED, FAILED, DISCARDING -> {} + case READY -> { + var term = termSupplier.get(); + if (term == null) { + state = State.DISCARDING; + boltConnection + .discard(runSummary.queryId(), -1) + .thenCompose(conn -> conn.flush(this)) + .whenComplete((ignored, throwable) -> { + var error = Futures.completionExceptionCause(throwable); + if (error != null) { + onError(error); + } + }); + } else { + onError(term); + } + } + case STREAMING -> discardPending = true; + } + } + return summaryFuture; } @Override - public boolean isDone() { - return summaryFuture.isDone(); + public synchronized boolean isDone() { + return switch (state) { + case DISCARDING, STREAMING, READY -> false; + case FAILED -> runError == null || runErrorExposed; + case SUCCEDED -> true; + }; } @Override public Throwable getRunError() { - runErrorSurfaced = true; - return runResponseError; + runErrorExposed = true; + return runError; } @Override public CompletionStage rollback() { + synchronized (this) { + state = State.SUCCEDED; + } summaryFuture.complete(null); - return connectionReleaseSupplier.get(); - } + var future = new CompletableFuture(); + boltConnection + .reset() + .thenCompose(conn -> conn.flush(new ResponseHandler() { + @Override + public void onError(Throwable throwable) { + future.completeExceptionally(throwable); + } - public CompletionStage summaryStage() { - if (!isDone() && !resultConsumed) // the summary is called before record streaming - { - installRecordConsumer(DISCARD_RECORD_CONSUMER); - cancel(); - resultConsumed = true; - } - return this.summaryFuture; + @Override + public void onComplete() { + future.complete(null); + } + })) + .whenComplete((ignored, throwable) -> { + if (throwable != null) { + future.completeExceptionally(throwable); + } + }); + return future.thenCompose(ignored -> boltConnection.close()).exceptionally(throwable -> null); } - private void assertRunCompletedSuccessfully() { - if (runResponseError != null) { - pullHandler.onFailure(runResponseError); - } + private synchronized void dispose() { + recordConsumer = null; } - private void installSummaryConsumer() { - pullHandler.installSummaryConsumer((summary, error) -> { - if (error != null && consumerStatus.isDiscardConsumer()) { - // We will only report the error to summary if there is no user record consumer installed - // When a user record consumer is installed, the error will be reported to record consumer instead. - summaryFuture.completeExceptionally(error); - } else if (summary != null) { - summaryFuture.complete(summary); + private synchronized long appendDemand(long n) { + if (n == Long.MAX_VALUE) { + outstandingDemand = -1; + } else { + try { + outstandingDemand = Math.addExact(outstandingDemand, n); + } catch (ArithmeticException ex) { + outstandingDemand = -1; } - // else (null, null) to indicate a has_more success - }); + } + return outstandingDemand; } - enum RecordConsumerStatus { - NOT_INSTALLED(false, false), - INSTALLED(true, false), - DISCARD_INSTALLED(true, true); - - private final boolean isInstalled; - private final boolean isDiscardConsumer; + private synchronized long getDemand() { + return outstandingDemand; + } - RecordConsumerStatus(boolean isInstalled, boolean isDiscardConsumer) { - this.isInstalled = isInstalled; - this.isDiscardConsumer = isDiscardConsumer; + private synchronized void decrementDemand() { + if (outstandingDemand > 0) { + outstandingDemand--; } + } - boolean isInstalled() { - return isInstalled; + @Override + public void request(long n) { + if (n <= 0) { + throw new IllegalArgumentException("n must not be 0 or negative"); + } + synchronized (this) { + switch (state) { + case READY -> { + var term = termSupplier.get(); + if (term == null) { + var request = appendDemand(n); + state = State.STREAMING; + boltConnection + .pull(runSummary.queryId(), request) + .thenCompose(conn -> conn.flush(this)) + .whenComplete((ignored, throwable) -> { + var error = Futures.completionExceptionCause(throwable); + if (error != null) { + onError(error); + } + }); + } else { + onError(term); + } + } + case STREAMING -> appendDemand(n); + case FAILED -> { + if (recordConsumer != null && !runErrorExposed) { + recordConsumer.accept(null, getRunError()); + } + } + case DISCARDING, SUCCEDED -> {} + } } + } - boolean isDiscardConsumer() { - return isDiscardConsumer; + @Override + public void cancel() { + synchronized (this) { + switch (state) { + case READY -> { + state = State.DISCARDING; + boltConnection + .discard(runSummary.queryId(), -1) + .thenCompose(conn -> conn.flush(this)) + .whenComplete((ignored, throwable) -> { + if (throwable != null) { + var error = Futures.completionExceptionCause(throwable); + if (error != null) { + onError(error); + } + } + }); + } + case STREAMING -> discardPending = true; + case DISCARDING, FAILED, SUCCEDED -> {} + } } } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/ChannelReleasingResetResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/ChannelReleasingResetResponseHandler.java deleted file mode 100644 index ec23cd3d71..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/ChannelReleasingResetResponseHandler.java +++ /dev/null @@ -1,63 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.setLastUsedTimestamp; -import static org.neo4j.driver.internal.util.Futures.asCompletionStage; -import static org.neo4j.driver.internal.util.Futures.completedWithNull; - -import io.netty.channel.Channel; -import java.time.Clock; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionStage; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; -import org.neo4j.driver.internal.async.pool.ExtendedChannelPool; - -public class ChannelReleasingResetResponseHandler extends ResetResponseHandler { - private final Channel channel; - private final ExtendedChannelPool pool; - private final Clock clock; - - public ChannelReleasingResetResponseHandler( - Channel channel, - ExtendedChannelPool pool, - InboundMessageDispatcher messageDispatcher, - Clock clock, - CompletableFuture releaseFuture) { - super(messageDispatcher, releaseFuture); - this.channel = channel; - this.pool = pool; - this.clock = clock; - } - - @Override - protected void resetCompleted(CompletableFuture completionFuture, boolean success) { - CompletionStage closureStage; - if (success) { - // update the last-used timestamp before returning the channel back to the pool - setLastUsedTimestamp(channel, clock.millis()); - closureStage = completedWithNull(); - } else { - // close the channel before returning it back to the pool if RESET failed - closureStage = asCompletionStage(channel.close()); - } - closureStage - .exceptionally(throwable -> null) - .thenCompose(ignored -> pool.release(channel)) - .whenComplete((ignore, error) -> completionFuture.complete(null)); - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/LegacyPullAllResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/LegacyPullAllResponseHandler.java deleted file mode 100644 index 726d2a2da3..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/LegacyPullAllResponseHandler.java +++ /dev/null @@ -1,310 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.Collections.emptyMap; -import static java.util.Objects.requireNonNull; -import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.neo4j.driver.internal.util.Futures.completedWithNull; -import static org.neo4j.driver.internal.util.Futures.failedFuture; - -import java.util.ArrayDeque; -import java.util.ArrayList; -import java.util.List; -import java.util.Map; -import java.util.Queue; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionStage; -import java.util.function.Function; -import org.neo4j.driver.Query; -import org.neo4j.driver.Record; -import org.neo4j.driver.Value; -import org.neo4j.driver.exceptions.Neo4jException; -import org.neo4j.driver.internal.InternalRecord; -import org.neo4j.driver.internal.messaging.request.PullAllMessage; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.util.Futures; -import org.neo4j.driver.internal.util.Iterables; -import org.neo4j.driver.internal.util.MetadataExtractor; -import org.neo4j.driver.summary.ResultSummary; - -/** - * This is the Pull All response handler that handles pull all messages in Bolt v3 and previous protocol versions. - */ -public class LegacyPullAllResponseHandler implements PullAllResponseHandler { - private static final Queue UNINITIALIZED_RECORDS = Iterables.emptyQueue(); - - static final int RECORD_BUFFER_LOW_WATERMARK = Integer.getInteger("recordBufferLowWatermark", 300); - static final int RECORD_BUFFER_HIGH_WATERMARK = Integer.getInteger("recordBufferHighWatermark", 1000); - - private final Query query; - private final RunResponseHandler runResponseHandler; - protected final MetadataExtractor metadataExtractor; - protected final Connection connection; - private final PullResponseCompletionListener completionListener; - - // initialized lazily when first record arrives - private Queue records = UNINITIALIZED_RECORDS; - - private boolean autoReadManagementEnabled = true; - private boolean finished; - private Throwable failure; - private ResultSummary summary; - - private boolean ignoreRecords; - private CompletableFuture recordFuture; - private CompletableFuture failureFuture; - - public LegacyPullAllResponseHandler( - Query query, - RunResponseHandler runResponseHandler, - Connection connection, - MetadataExtractor metadataExtractor, - PullResponseCompletionListener completionListener) { - this.query = requireNonNull(query); - this.runResponseHandler = requireNonNull(runResponseHandler); - this.metadataExtractor = requireNonNull(metadataExtractor); - this.connection = requireNonNull(connection); - this.completionListener = requireNonNull(completionListener); - } - - @Override - public boolean canManageAutoRead() { - return true; - } - - @Override - public synchronized void onSuccess(Map metadata) { - finished = true; - Neo4jException exception = null; - try { - summary = extractResultSummary(metadata); - } catch (Neo4jException e) { - exception = e; - } - - if (exception == null) { - completionListener.afterSuccess(metadata); - - completeRecordFuture(null); - completeFailureFuture(null); - } else { - onFailure(exception); - } - } - - @Override - public synchronized void onFailure(Throwable error) { - finished = true; - summary = extractResultSummary(emptyMap()); - - completionListener.afterFailure(error); - - var failedRecordFuture = failRecordFuture(error); - if (failedRecordFuture) { - // error propagated through the record future - completeFailureFuture(null); - } else { - var completedFailureFuture = completeFailureFuture(error); - if (!completedFailureFuture) { - // error has not been propagated to the user, remember it - failure = error; - } - } - } - - @Override - public synchronized void onRecord(Value[] fields) { - if (ignoreRecords) { - completeRecordFuture(null); - } else { - Record record = new InternalRecord(runResponseHandler.queryKeys(), fields); - enqueueRecord(record); - completeRecordFuture(record); - } - } - - @Override - public synchronized void disableAutoReadManagement() { - autoReadManagementEnabled = false; - } - - public synchronized CompletionStage peekAsync() { - var record = records.peek(); - if (record == null) { - if (failure != null) { - return failedFuture(extractFailure()); - } - - if (ignoreRecords || finished) { - return completedWithNull(); - } - - if (recordFuture == null) { - recordFuture = new CompletableFuture<>(); - } - return recordFuture; - } else { - return completedFuture(record); - } - } - - public synchronized CompletionStage nextAsync() { - return peekAsync().thenApply(ignore -> dequeueRecord()); - } - - public synchronized CompletionStage consumeAsync() { - ignoreRecords = true; - records.clear(); - return pullAllFailureAsync().thenApply(error -> { - if (error != null) { - throw Futures.asCompletionException(error); - } - return summary; - }); - } - - public synchronized CompletionStage> listAsync(Function mapFunction) { - return pullAllFailureAsync().thenApply(error -> { - if (error != null) { - throw Futures.asCompletionException(error); - } - return recordsAsList(mapFunction); - }); - } - - @Override - public void prePopulateRecords() { - connection.writeAndFlush(PullAllMessage.PULL_ALL, this); - } - - public synchronized CompletionStage pullAllFailureAsync() { - if (failure != null) { - return completedFuture(extractFailure()); - } else if (finished) { - return completedWithNull(); - } else { - if (failureFuture == null) { - // neither SUCCESS nor FAILURE message has arrived, register future to be notified when it arrives - // future will be completed with null on SUCCESS and completed with Throwable on FAILURE - // enable auto-read, otherwise we might not read SUCCESS/FAILURE if records are not consumed - enableAutoRead(); - failureFuture = new CompletableFuture<>(); - } - return failureFuture; - } - } - - private void enqueueRecord(Record record) { - if (records == UNINITIALIZED_RECORDS) { - records = new ArrayDeque<>(); - } - - records.add(record); - - var shouldBufferAllRecords = failureFuture != null; - // when failure is requested we have to buffer all remaining records and then return the error - // do not disable auto-read in this case, otherwise records will not be consumed and trailing - // SUCCESS or FAILURE message will not arrive as well, so callers will get stuck waiting for the error - if (!shouldBufferAllRecords && records.size() > RECORD_BUFFER_HIGH_WATERMARK) { - // more than high watermark records are already queued, tell connection to stop auto-reading from network - // this is needed to deal with slow consumers, we do not want to buffer all records in memory if they are - // fetched from network faster than consumed - disableAutoRead(); - } - } - - private Record dequeueRecord() { - var record = records.poll(); - - if (records.size() < RECORD_BUFFER_LOW_WATERMARK) { - // less than low watermark records are now available in the buffer, tell connection to pre-fetch more - // and populate queue with new records from network - enableAutoRead(); - } - - return record; - } - - private List recordsAsList(Function mapFunction) { - if (!finished) { - throw new IllegalStateException("Can't get records as list because SUCCESS or FAILURE did not arrive"); - } - - List result = new ArrayList<>(records.size()); - while (!records.isEmpty()) { - var record = records.poll(); - result.add(mapFunction.apply(record)); - } - return result; - } - - private Throwable extractFailure() { - if (failure == null) { - throw new IllegalStateException("Can't extract failure because it does not exist"); - } - - var error = failure; - failure = null; // propagate failure only once - return error; - } - - private void completeRecordFuture(Record record) { - if (recordFuture != null) { - var future = recordFuture; - recordFuture = null; - future.complete(record); - } - } - - private boolean failRecordFuture(Throwable error) { - if (recordFuture != null) { - var future = recordFuture; - recordFuture = null; - future.completeExceptionally(error); - return true; - } - return false; - } - - private boolean completeFailureFuture(Throwable error) { - if (failureFuture != null) { - var future = failureFuture; - failureFuture = null; - future.complete(error); - return true; - } - return false; - } - - private ResultSummary extractResultSummary(Map metadata) { - var resultAvailableAfter = runResponseHandler.resultAvailableAfter(); - return metadataExtractor.extractSummary(query, connection, resultAvailableAfter, metadata); - } - - private void enableAutoRead() { - if (autoReadManagementEnabled) { - connection.enableAutoRead(); - } - } - - private void disableAutoRead() { - if (autoReadManagementEnabled) { - connection.disableAutoRead(); - } - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/PingResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/PingResponseHandler.java deleted file mode 100644 index ba9fb7ab87..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/PingResponseHandler.java +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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 io.netty.channel.Channel; -import io.netty.util.concurrent.Promise; -import java.util.Map; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Value; -import org.neo4j.driver.internal.spi.ResponseHandler; - -public class PingResponseHandler implements ResponseHandler { - private final Promise result; - private final Channel channel; - private final Logger log; - - public PingResponseHandler(Promise result, Channel channel, Logging logging) { - this.result = result; - this.channel = channel; - this.log = logging.getLog(getClass()); - } - - @Override - public void onSuccess(Map metadata) { - log.trace("Channel %s pinged successfully", channel); - result.setSuccess(true); - } - - @Override - public void onFailure(Throwable error) { - log.trace("Channel %s failed ping %s", channel, error); - result.setSuccess(false); - } - - @Override - public void onRecord(Value[] fields) { - throw new UnsupportedOperationException(); - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/PullAllResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/PullAllResponseHandler.java deleted file mode 100644 index 08c6f52fb3..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/PullAllResponseHandler.java +++ /dev/null @@ -1,38 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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 java.util.List; -import java.util.concurrent.CompletionStage; -import java.util.function.Function; -import org.neo4j.driver.Record; -import org.neo4j.driver.internal.spi.ResponseHandler; -import org.neo4j.driver.summary.ResultSummary; - -public interface PullAllResponseHandler extends ResponseHandler { - CompletionStage consumeAsync(); - - CompletionStage nextAsync(); - - CompletionStage peekAsync(); - - CompletionStage> listAsync(Function mapFunction); - - CompletionStage pullAllFailureAsync(); - - void prePopulateRecords(); -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/PullHandlers.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/PullHandlers.java deleted file mode 100644 index fb40199ef3..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/PullHandlers.java +++ /dev/null @@ -1,74 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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 java.util.function.Consumer; -import org.neo4j.driver.Query; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.handlers.pulln.AutoPullResponseHandler; -import org.neo4j.driver.internal.handlers.pulln.BasicPullResponseHandler; -import org.neo4j.driver.internal.handlers.pulln.PullResponseHandler; -import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3; -import org.neo4j.driver.internal.spi.Connection; - -public class PullHandlers { - - public static PullAllResponseHandler newBoltV3PullAllHandler( - Query query, - RunResponseHandler runHandler, - Connection connection, - Consumer bookmarkConsumer, - UnmanagedTransaction tx) { - var completionListener = createPullResponseCompletionListener(connection, bookmarkConsumer, tx); - - return new LegacyPullAllResponseHandler( - query, runHandler, connection, BoltProtocolV3.METADATA_EXTRACTOR, completionListener); - } - - public static PullAllResponseHandler newBoltV4AutoPullHandler( - Query query, - RunResponseHandler runHandler, - Connection connection, - Consumer bookmarkConsumer, - UnmanagedTransaction tx, - long fetchSize) { - var completionListener = createPullResponseCompletionListener(connection, bookmarkConsumer, tx); - - return new AutoPullResponseHandler( - query, runHandler, connection, BoltProtocolV3.METADATA_EXTRACTOR, completionListener, fetchSize); - } - - public static PullResponseHandler newBoltV4BasicPullHandler( - Query query, - RunResponseHandler runHandler, - Connection connection, - Consumer bookmarkConsumer, - UnmanagedTransaction tx) { - var completionListener = createPullResponseCompletionListener(connection, bookmarkConsumer, tx); - - return new BasicPullResponseHandler( - query, runHandler, connection, BoltProtocolV3.METADATA_EXTRACTOR, completionListener); - } - - private static PullResponseCompletionListener createPullResponseCompletionListener( - Connection connection, Consumer bookmarkConsumer, UnmanagedTransaction tx) { - return tx != null - ? new TransactionPullResponseCompletionListener(tx) - : new SessionPullResponseCompletionListener(connection, bookmarkConsumer); - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/RoutingResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/RoutingResponseHandler.java deleted file mode 100644 index 8dcee4be33..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/RoutingResponseHandler.java +++ /dev/null @@ -1,127 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.lang.String.format; - -import java.util.Map; -import java.util.Objects; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.Value; -import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.exceptions.SessionExpiredException; -import org.neo4j.driver.exceptions.TransientException; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.RoutingErrorHandler; -import org.neo4j.driver.internal.spi.ResponseHandler; -import org.neo4j.driver.internal.util.Futures; - -public class RoutingResponseHandler implements ResponseHandler { - private final ResponseHandler delegate; - private final BoltServerAddress address; - private final AccessMode accessMode; - private final RoutingErrorHandler errorHandler; - - public RoutingResponseHandler( - ResponseHandler delegate, - BoltServerAddress address, - AccessMode accessMode, - RoutingErrorHandler errorHandler) { - this.delegate = delegate; - this.address = address; - this.accessMode = accessMode; - this.errorHandler = errorHandler; - } - - @Override - public void onSuccess(Map metadata) { - delegate.onSuccess(metadata); - } - - @Override - public void onFailure(Throwable error) { - var newError = handledError(error); - delegate.onFailure(newError); - } - - @Override - public void onRecord(Value[] fields) { - delegate.onRecord(fields); - } - - @Override - public boolean canManageAutoRead() { - return delegate.canManageAutoRead(); - } - - @Override - public void disableAutoReadManagement() { - delegate.disableAutoReadManagement(); - } - - private Throwable handledError(Throwable receivedError) { - var error = Futures.completionExceptionCause(receivedError); - - if (error instanceof ServiceUnavailableException) { - return handledServiceUnavailableException(((ServiceUnavailableException) error)); - } else if (error instanceof ClientException) { - return handledClientException(((ClientException) error)); - } else if (error instanceof TransientException) { - return handledTransientException(((TransientException) error)); - } else { - return error; - } - } - - private Throwable handledServiceUnavailableException(ServiceUnavailableException e) { - errorHandler.onConnectionFailure(address); - return new SessionExpiredException(format("Server at %s is no longer available", address), e); - } - - private Throwable handledTransientException(TransientException e) { - var errorCode = e.code(); - if (Objects.equals(errorCode, "Neo.TransientError.General.DatabaseUnavailable")) { - errorHandler.onConnectionFailure(address); - } - return e; - } - - private Throwable handledClientException(ClientException e) { - if (isFailureToWrite(e)) { - // The server is unaware of the session mode, so we have to implement this logic in the driver. - // In the future, we might be able to move this logic to the server. - switch (accessMode) { - case READ -> { - return new ClientException("Write queries cannot be performed in READ access mode."); - } - case WRITE -> { - errorHandler.onWriteFailure(address); - return new SessionExpiredException(format("Server at %s no longer accepts writes", address)); - } - default -> throw new IllegalArgumentException(accessMode + " not supported."); - } - } - return e; - } - - private static boolean isFailureToWrite(ClientException e) { - var errorCode = e.code(); - return Objects.equals(errorCode, "Neo.ClientError.Cluster.NotALeader") - || Objects.equals(errorCode, "Neo.ClientError.General.ForbiddenOnReadOnlyDatabase"); - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/SessionPullResponseCompletionListener.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/SessionPullResponseCompletionListener.java deleted file mode 100644 index bef1565286..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/SessionPullResponseCompletionListener.java +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.function.Consumer; -import org.neo4j.driver.Value; -import org.neo4j.driver.exceptions.AuthorizationExpiredException; -import org.neo4j.driver.exceptions.ConnectionReadTimeoutException; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.util.MetadataExtractor; - -public class SessionPullResponseCompletionListener implements PullResponseCompletionListener { - private final Consumer bookmarkConsumer; - private final Connection connection; - - public SessionPullResponseCompletionListener(Connection connection, Consumer bookmarkConsumer) { - this.bookmarkConsumer = requireNonNull(bookmarkConsumer); - this.connection = requireNonNull(connection); - } - - @Override - public void afterSuccess(Map metadata) { - releaseConnection(); - bookmarkConsumer.accept(MetadataExtractor.extractDatabaseBookmark(metadata)); - } - - @Override - public void afterFailure(Throwable error) { - if (error instanceof AuthorizationExpiredException) { - connection.terminateAndRelease(AuthorizationExpiredException.DESCRIPTION); - } else if (error instanceof ConnectionReadTimeoutException) { - connection.terminateAndRelease(error.getMessage()); - } else { - releaseConnection(); - } - } - - private void releaseConnection() { - connection.release(); // release in background - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListener.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListener.java deleted file mode 100644 index a7b95ddc1f..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListener.java +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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 org.neo4j.driver.Value; -import org.neo4j.driver.internal.async.UnmanagedTransaction; - -public class TransactionPullResponseCompletionListener implements PullResponseCompletionListener { - private final UnmanagedTransaction tx; - - public TransactionPullResponseCompletionListener(UnmanagedTransaction tx) { - this.tx = requireNonNull(tx); - } - - @Override - public void afterSuccess(Map metadata) {} - - @Override - @SuppressWarnings("ThrowableNotThrown") - public void afterFailure(Throwable error) { - // always mark transaction as terminated because every error is "acknowledged" with a RESET message - // so database forgets about the transaction after the first error - // such transaction should not attempt to commit and can be considered as rolled back - tx.markTerminated(error); - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/AutoPullResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/AutoPullResponseHandler.java deleted file mode 100644 index dc4f366c21..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/AutoPullResponseHandler.java +++ /dev/null @@ -1,281 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.pulln; - -import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE; -import static org.neo4j.driver.internal.util.Futures.completedWithNull; -import static org.neo4j.driver.internal.util.Futures.failedFuture; - -import java.util.ArrayDeque; -import java.util.ArrayList; -import java.util.List; -import java.util.Queue; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionStage; -import java.util.function.Function; -import org.neo4j.driver.Query; -import org.neo4j.driver.Record; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.PullResponseCompletionListener; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.util.Iterables; -import org.neo4j.driver.internal.util.MetadataExtractor; -import org.neo4j.driver.summary.ResultSummary; - -/** - * Built on top of {@link BasicPullResponseHandler} to be able to pull in batches. - * It is exposed as {@link PullAllResponseHandler} as it can automatically pull when running out of records locally. - */ -public class AutoPullResponseHandler extends BasicPullResponseHandler implements PullAllResponseHandler { - private static final Queue UNINITIALIZED_RECORDS = Iterables.emptyQueue(); - private final long fetchSize; - private final long lowRecordWatermark; - private final long highRecordWatermark; - - // initialized lazily when first record arrives - private Queue records = UNINITIALIZED_RECORDS; - - private ResultSummary summary; - private Throwable failure; - private boolean isAutoPullEnabled = true; - - private CompletableFuture recordFuture; - private CompletableFuture summaryFuture; - - public AutoPullResponseHandler( - Query query, - RunResponseHandler runResponseHandler, - Connection connection, - MetadataExtractor metadataExtractor, - PullResponseCompletionListener completionListener, - long fetchSize) { - super(query, runResponseHandler, connection, metadataExtractor, completionListener, true); - this.fetchSize = fetchSize; - - // For pull everything ensure conditions for disabling auto pull are never met - if (fetchSize == UNLIMITED_FETCH_SIZE) { - this.highRecordWatermark = Long.MAX_VALUE; - this.lowRecordWatermark = Long.MAX_VALUE; - } else { - this.highRecordWatermark = (long) (fetchSize * 0.7); - this.lowRecordWatermark = (long) (fetchSize * 0.3); - } - - installRecordAndSummaryConsumers(); - } - - private void installRecordAndSummaryConsumers() { - installRecordConsumer((record, error) -> { - if (record != null) { - enqueueRecord(record); - completeRecordFuture(record); - } - // if ( error != null ) Handled by summary.error already - if (record == null && error == null) { - // complete - completeRecordFuture(null); - } - }); - - installSummaryConsumer((summary, error) -> { - if (error != null) { - handleFailure(error); - } - if (summary != null) { - this.summary = summary; - completeSummaryFuture(summary); - } - - if (error == null && summary == null) // has_more - { - if (isAutoPullEnabled) { - request(fetchSize); - } - } - }); - } - - private void handleFailure(Throwable error) { - // error has not been propagated to the user, remember it - if (!failRecordFuture(error) && !failSummaryFuture(error)) { - failure = error; - } - } - - public synchronized CompletionStage peekAsync() { - var record = records.peek(); - if (record == null) { - if (isDone()) { - return completedWithValueIfNoFailure(null); - } - - if (recordFuture == null) { - recordFuture = new CompletableFuture<>(); - } - return recordFuture; - } else { - return completedFuture(record); - } - } - - public synchronized CompletionStage nextAsync() { - return peekAsync().thenApply(ignore -> dequeueRecord()); - } - - public synchronized CompletionStage consumeAsync() { - records.clear(); - if (isDone()) { - return completedWithValueIfNoFailure(summary); - } else { - var future = summaryFuture; - if (future == null) { - future = new CompletableFuture<>(); - summaryFuture = future; - } - cancel(); - - return future; - } - } - - public synchronized CompletionStage> listAsync(Function mapFunction) { - return pullAllAsync().thenApply(summary -> recordsAsList(mapFunction)); - } - - @Override - public synchronized CompletionStage pullAllFailureAsync() { - return pullAllAsync().handle((ignore, error) -> error); - } - - @Override - public void prePopulateRecords() { - request(fetchSize); - } - - private synchronized CompletionStage pullAllAsync() { - if (isDone()) { - return completedWithValueIfNoFailure(summary); - } else { - var future = summaryFuture; - if (future == null) { - future = new CompletableFuture<>(); - summaryFuture = future; - } - request(UNLIMITED_FETCH_SIZE); - - return future; - } - } - - private void enqueueRecord(Record record) { - if (records == UNINITIALIZED_RECORDS) { - records = new ArrayDeque<>(); - } - - records.add(record); - - // too many records in the queue, pause auto request gathering - if (records.size() > highRecordWatermark) { - isAutoPullEnabled = false; - } - } - - private Record dequeueRecord() { - var record = records.poll(); - - if (records.size() <= lowRecordWatermark) { - // if not in streaming state we need to restart streaming - if (state() != State.STREAMING_STATE) { - request(fetchSize); - } - isAutoPullEnabled = true; - } - - return record; - } - - private List recordsAsList(Function mapFunction) { - if (!isDone()) { - throw new IllegalStateException("Can't get records as list because SUCCESS or FAILURE did not arrive"); - } - - List result = new ArrayList<>(records.size()); - while (!records.isEmpty()) { - var record = records.poll(); - result.add(mapFunction.apply(record)); - } - return result; - } - - private Throwable extractFailure() { - if (failure == null) { - throw new IllegalStateException("Can't extract failure because it does not exist"); - } - - var error = failure; - failure = null; // propagate failure only once - return error; - } - - private void completeRecordFuture(Record record) { - if (recordFuture != null) { - var future = recordFuture; - recordFuture = null; - future.complete(record); - } - } - - private void completeSummaryFuture(ResultSummary summary) { - if (summaryFuture != null) { - var future = summaryFuture; - summaryFuture = null; - future.complete(summary); - } - } - - private boolean failRecordFuture(Throwable error) { - if (recordFuture != null) { - var future = recordFuture; - recordFuture = null; - future.completeExceptionally(error); - return true; - } - return false; - } - - private boolean failSummaryFuture(Throwable error) { - if (summaryFuture != null) { - var future = summaryFuture; - summaryFuture = null; - future.completeExceptionally(error); - return true; - } - return false; - } - - private CompletionStage completedWithValueIfNoFailure(T value) { - if (failure != null) { - return failedFuture(extractFailure()); - } else if (value == null) { - return completedWithNull(); - } else { - return completedFuture(value); - } - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/BasicPullResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/BasicPullResponseHandler.java deleted file mode 100644 index 017319310e..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/BasicPullResponseHandler.java +++ /dev/null @@ -1,449 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.pulln; - -import static java.lang.String.format; -import static java.util.Collections.emptyMap; -import static java.util.Objects.requireNonNull; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE; -import static org.neo4j.driver.internal.messaging.request.DiscardMessage.newDiscardAllMessage; - -import java.util.Map; -import java.util.function.BiConsumer; -import org.neo4j.driver.Query; -import org.neo4j.driver.Record; -import org.neo4j.driver.Value; -import org.neo4j.driver.exceptions.Neo4jException; -import org.neo4j.driver.internal.InternalRecord; -import org.neo4j.driver.internal.handlers.PullResponseCompletionListener; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.util.MetadataExtractor; -import org.neo4j.driver.internal.value.BooleanValue; -import org.neo4j.driver.summary.ResultSummary; - -/** - * Provides basic handling of pull responses from sever. The state is managed by {@link State}. - */ -public class BasicPullResponseHandler implements PullResponseHandler { - private static final Runnable NO_OP_RUNNABLE = () -> {}; - private final Query query; - protected final RunResponseHandler runResponseHandler; - protected final MetadataExtractor metadataExtractor; - protected final Connection connection; - private final PullResponseCompletionListener completionListener; - private final boolean syncSignals; - - private State state; - private long toRequest; - private BiConsumer recordConsumer = null; - private BiConsumer summaryConsumer = null; - - public BasicPullResponseHandler( - Query query, - RunResponseHandler runResponseHandler, - Connection connection, - MetadataExtractor metadataExtractor, - PullResponseCompletionListener completionListener) { - this(query, runResponseHandler, connection, metadataExtractor, completionListener, false); - } - - public BasicPullResponseHandler( - Query query, - RunResponseHandler runResponseHandler, - Connection connection, - MetadataExtractor metadataExtractor, - PullResponseCompletionListener completionListener, - boolean syncSignals) { - this.query = requireNonNull(query); - this.runResponseHandler = requireNonNull(runResponseHandler); - this.metadataExtractor = requireNonNull(metadataExtractor); - this.connection = requireNonNull(connection); - this.completionListener = requireNonNull(completionListener); - this.syncSignals = syncSignals; - - this.state = State.READY_STATE; - } - - @Override - public void onSuccess(Map metadata) { - State newState; - BiConsumer recordConsumer = null; - BiConsumer summaryConsumer = null; - ResultSummary summary = null; - Neo4jException exception = null; - synchronized (this) { - assertRecordAndSummaryConsumerInstalled(); - state.onSuccess(this, metadata); - newState = state; - if (newState == State.SUCCEEDED_STATE) { - completionListener.afterSuccess(metadata); - try { - summary = extractResultSummary(metadata); - } catch (Neo4jException e) { - summary = extractResultSummary(emptyMap()); - exception = e; - } - recordConsumer = this.recordConsumer; - summaryConsumer = this.summaryConsumer; - if (syncSignals) { - complete(summaryConsumer, recordConsumer, summary, exception); - } - dispose(); - } else if (newState == State.READY_STATE) { - if (toRequest > 0 || toRequest == UNLIMITED_FETCH_SIZE) { - request(toRequest); - toRequest = 0; - } - // summary consumer use (null, null) to identify done handling of success with has_more - this.summaryConsumer.accept(null, null); - } - } - if (!syncSignals && newState == State.SUCCEEDED_STATE) { - complete(summaryConsumer, recordConsumer, summary, exception); - } - } - - @Override - public void onFailure(Throwable error) { - BiConsumer recordConsumer; - BiConsumer summaryConsumer; - ResultSummary summary; - synchronized (this) { - assertRecordAndSummaryConsumerInstalled(); - state.onFailure(this); - completionListener.afterFailure(error); - summary = extractResultSummary(emptyMap()); - recordConsumer = this.recordConsumer; - summaryConsumer = this.summaryConsumer; - if (syncSignals) { - complete(summaryConsumer, recordConsumer, summary, error); - } - dispose(); - } - if (!syncSignals) { - complete(summaryConsumer, recordConsumer, summary, error); - } - } - - @Override - public void onRecord(Value[] fields) { - State newState; - Record record = null; - synchronized (this) { - assertRecordAndSummaryConsumerInstalled(); - state.onRecord(this); - newState = state; - if (newState == State.STREAMING_STATE) { - record = new InternalRecord(runResponseHandler.queryKeys(), fields); - if (syncSignals) { - recordConsumer.accept(record, null); - } - } - } - if (!syncSignals && newState == State.STREAMING_STATE) { - recordConsumer.accept(record, null); - } - } - - @Override - public void request(long size) { - Runnable postAction; - synchronized (this) { - assertRecordAndSummaryConsumerInstalled(); - postAction = state.request(this, size); - if (syncSignals) { - postAction.run(); - } - } - if (!syncSignals) { - postAction.run(); - } - } - - @Override - public synchronized void cancel() { - Runnable postAction; - synchronized (this) { - assertRecordAndSummaryConsumerInstalled(); - postAction = state.cancel(this); - if (syncSignals) { - postAction.run(); - } - } - if (!syncSignals) { - postAction.run(); - } - } - - protected void writePull(long n) { - connection.writeAndFlush(new PullMessage(n, runResponseHandler.queryId()), this); - } - - protected void discardAll() { - connection.writeAndFlush(newDiscardAllMessage(runResponseHandler.queryId()), this); - } - - @Override - public synchronized void installSummaryConsumer(BiConsumer summaryConsumer) { - if (this.summaryConsumer != null) { - throw new IllegalStateException("Summary consumer already installed."); - } - this.summaryConsumer = summaryConsumer; - } - - @Override - public synchronized void installRecordConsumer(BiConsumer recordConsumer) { - if (this.recordConsumer != null) { - throw new IllegalStateException("Record consumer already installed."); - } - this.recordConsumer = recordConsumer; - } - - protected boolean isDone() { - return state.equals(State.SUCCEEDED_STATE) || state.equals(State.FAILURE_STATE); - } - - private ResultSummary extractResultSummary(Map metadata) { - var resultAvailableAfter = runResponseHandler.resultAvailableAfter(); - return metadataExtractor.extractSummary(query, connection, resultAvailableAfter, metadata); - } - - private void addToRequest(long toAdd) { - if (toRequest == UNLIMITED_FETCH_SIZE) { - return; - } - if (toAdd == UNLIMITED_FETCH_SIZE) { - // pull all - toRequest = UNLIMITED_FETCH_SIZE; - return; - } - - if (toAdd <= 0) { - throw new IllegalArgumentException( - "Cannot request record amount that is less than or equal to 0. Request amount: " + toAdd); - } - toRequest += toAdd; - if (toRequest <= 0) // toAdd is already at least 1, we hit buffer overflow - { - toRequest = Long.MAX_VALUE; - } - } - - private void assertRecordAndSummaryConsumerInstalled() { - if (isDone()) { - // no need to check if we've finished. - return; - } - if (recordConsumer == null || summaryConsumer == null) { - throw new IllegalStateException(format( - "Access record stream without record consumer and/or summary consumer. " - + "Record consumer=%s, Summary consumer=%s", - recordConsumer, summaryConsumer)); - } - } - - private void complete( - BiConsumer summaryConsumer, - BiConsumer recordConsumer, - ResultSummary summary, - Throwable error) { - // we first inform the summary consumer to ensure when streaming finished, summary is definitely available. - summaryConsumer.accept(summary, error); - // record consumer use (null, null) to identify the end of record stream - recordConsumer.accept(null, error); - } - - private void dispose() { - // release the reference to the consumers who hold the reference to subscribers which shall be released when - // subscription is completed. - this.recordConsumer = null; - this.summaryConsumer = null; - } - - protected State state() { - return state; - } - - protected void state(State state) { - this.state = state; - } - - protected enum State { - READY_STATE { - @Override - void onSuccess(BasicPullResponseHandler context, Map metadata) { - context.state(SUCCEEDED_STATE); - } - - @Override - void onFailure(BasicPullResponseHandler context) { - context.state(FAILURE_STATE); - } - - @Override - void onRecord(BasicPullResponseHandler context) { - context.state(READY_STATE); - } - - @Override - Runnable request(BasicPullResponseHandler context, long n) { - context.state(STREAMING_STATE); - return () -> context.writePull(n); - } - - @Override - Runnable cancel(BasicPullResponseHandler context) { - context.state(CANCELLED_STATE); - return context::discardAll; - } - }, - STREAMING_STATE { - @Override - void onSuccess(BasicPullResponseHandler context, Map metadata) { - if (metadata.getOrDefault("has_more", BooleanValue.FALSE).asBoolean()) { - context.state(READY_STATE); - } else { - context.state(SUCCEEDED_STATE); - } - } - - @Override - void onFailure(BasicPullResponseHandler context) { - context.state(FAILURE_STATE); - } - - @Override - void onRecord(BasicPullResponseHandler context) { - context.state(STREAMING_STATE); - } - - @Override - Runnable request(BasicPullResponseHandler context, long n) { - context.state(STREAMING_STATE); - context.addToRequest(n); - return NO_OP_RUNNABLE; - } - - @Override - Runnable cancel(BasicPullResponseHandler context) { - context.state(CANCELLED_STATE); - return NO_OP_RUNNABLE; - } - }, - CANCELLED_STATE { - @Override - void onSuccess(BasicPullResponseHandler context, Map metadata) { - if (metadata.getOrDefault("has_more", BooleanValue.FALSE).asBoolean()) { - context.state(CANCELLED_STATE); - context.discardAll(); - } else { - context.state(SUCCEEDED_STATE); - } - } - - @Override - void onFailure(BasicPullResponseHandler context) { - context.state(FAILURE_STATE); - } - - @Override - void onRecord(BasicPullResponseHandler context) { - context.state(CANCELLED_STATE); - } - - @Override - Runnable request(BasicPullResponseHandler context, long n) { - context.state(CANCELLED_STATE); - return NO_OP_RUNNABLE; - } - - @Override - Runnable cancel(BasicPullResponseHandler context) { - context.state(CANCELLED_STATE); - return NO_OP_RUNNABLE; - } - }, - SUCCEEDED_STATE { - @Override - void onSuccess(BasicPullResponseHandler context, Map metadata) { - context.state(SUCCEEDED_STATE); - } - - @Override - void onFailure(BasicPullResponseHandler context) { - context.state(FAILURE_STATE); - } - - @Override - void onRecord(BasicPullResponseHandler context) { - context.state(SUCCEEDED_STATE); - } - - @Override - Runnable request(BasicPullResponseHandler context, long n) { - context.state(SUCCEEDED_STATE); - return NO_OP_RUNNABLE; - } - - @Override - Runnable cancel(BasicPullResponseHandler context) { - context.state(SUCCEEDED_STATE); - return NO_OP_RUNNABLE; - } - }, - FAILURE_STATE { - @Override - void onSuccess(BasicPullResponseHandler context, Map metadata) { - context.state(SUCCEEDED_STATE); - } - - @Override - void onFailure(BasicPullResponseHandler context) { - context.state(FAILURE_STATE); - } - - @Override - void onRecord(BasicPullResponseHandler context) { - context.state(FAILURE_STATE); - } - - @Override - Runnable request(BasicPullResponseHandler context, long n) { - context.state(FAILURE_STATE); - return NO_OP_RUNNABLE; - } - - @Override - Runnable cancel(BasicPullResponseHandler context) { - context.state(FAILURE_STATE); - return NO_OP_RUNNABLE; - } - }; - - abstract void onSuccess(BasicPullResponseHandler context, Map metadata); - - abstract void onFailure(BasicPullResponseHandler context); - - abstract void onRecord(BasicPullResponseHandler context); - - abstract Runnable request(BasicPullResponseHandler context, long n); - - abstract Runnable cancel(BasicPullResponseHandler context); - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/PullResponseHandler.java b/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/PullResponseHandler.java deleted file mode 100644 index 128bf0d956..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/handlers/pulln/PullResponseHandler.java +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.pulln; - -import java.util.function.BiConsumer; -import org.neo4j.driver.Record; -import org.neo4j.driver.internal.spi.ResponseHandler; -import org.neo4j.driver.summary.ResultSummary; -import org.reactivestreams.Subscription; - -public interface PullResponseHandler extends ResponseHandler, Subscription { - /** - * Register a record consumer for each record received. - * STREAMING shall not be started before this consumer is registered. - * A null record with no error indicates the end of streaming. - * @param recordConsumer register a record consumer to be notified for each record received. - */ - void installRecordConsumer(BiConsumer recordConsumer); - - /** - * Register a summary consumer to be notified when a summary is received. - * STREAMING shall not be started before this consumer is registered. - * A null summary with no error indicates a SUCCESS message with has_more=true has arrived. - * @param summaryConsumer register a summary consumer - */ - void installSummaryConsumer(BiConsumer summaryConsumer); -} 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 deleted file mode 100644 index bb687acb30..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/BoltProtocol.java +++ /dev/null @@ -1,217 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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; - -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.protocolVersion; - -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; -import org.neo4j.driver.AuthToken; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.NotificationConfig; -import org.neo4j.driver.Query; -import org.neo4j.driver.Session; -import org.neo4j.driver.Transaction; -import org.neo4j.driver.TransactionConfig; -import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.internal.BoltAgent; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.cluster.RoutingContext; -import org.neo4j.driver.internal.cursor.ResultCursorFactory; -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.messaging.v52.BoltProtocolV52; -import org.neo4j.driver.internal.messaging.v53.BoltProtocolV53; -import org.neo4j.driver.internal.messaging.v54.BoltProtocolV54; -import org.neo4j.driver.internal.spi.Connection; - -public interface BoltProtocol { - /** - * Instantiate {@link MessageFormat} used by this Bolt protocol verison. - * - * @return new message format. - */ - MessageFormat createMessageFormat(); - - /** - * Initialize channel after it is connected and handshake selected this protocol version. - * - * @param userAgent the user agent string. - * @param boltAgent the bolt agent - * @param authToken the authentication token. - * @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, - BoltAgent boltAgent, - AuthToken authToken, - RoutingContext routingContext, - ChannelPromise channelInitializedPromise, - NotificationConfig notificationConfig, - Clock clock); - - /** - * Prepare to close channel before it is closed. - * @param channel the channel to close. - */ - void prepareToCloseChannel(Channel channel); - - /** - * Begin an unmanaged transaction. - * - * @param connection the connection to use. - * @param bookmarks the bookmarks. Never null, should be empty when there are no bookmarks. - * @param config the transaction configuration. Never null, should be {@link TransactionConfig#empty()} when absent. - * @param txType the Kernel transaction type - * @param notificationConfig the notification configuration - * @param logging the driver logging - * @param flush defines whether to flush the message to the connection - * @return a completion stage completed when transaction is started or completed exceptionally when there was a failure. - */ - CompletionStage beginTransaction( - Connection connection, - Set bookmarks, - TransactionConfig config, - String txType, - NotificationConfig notificationConfig, - Logging logging, - boolean flush); - - /** - * Commit the unmanaged transaction. - * - * @param connection the connection to use. - * @return a completion stage completed with a bookmark when transaction is committed or completed exceptionally when there was a failure. - */ - CompletionStage commitTransaction(Connection connection); - - /** - * Rollback the unmanaged transaction. - * - * @param connection the connection to use. - * @return a completion stage completed when transaction is rolled back or completed exceptionally when there was a failure. - */ - CompletionStage rollbackTransaction(Connection connection); - - /** - * Sends telemetry message to the server. - * - * @param api The api number. - * @return Promise of message be delivered - */ - CompletionStage telemetry(Connection connection, Integer api); - - /** - * Execute the given query in an auto-commit transaction, i.e. {@link Session#run(Query)}. - * - * @param connection the network connection to use. - * @param query the cypher to execute. - * @param bookmarkConsumer the database bookmark consumer. - * @param config the transaction config for the implicitly started auto-commit transaction. - * @param fetchSize the record fetch size for PULL message. - * @param notificationConfig the notification configuration - * @param logging the driver logging - * @return stage with cursor. - */ - ResultCursorFactory runInAutoCommitTransaction( - Connection connection, - Query query, - Set bookmarks, - Consumer bookmarkConsumer, - TransactionConfig config, - long fetchSize, - NotificationConfig notificationConfig, - Logging logging); - - /** - * Execute the given query in a running unmanaged transaction, i.e. {@link Transaction#run(Query)}. - * - * @param connection the network connection to use. - * @param query the cypher to execute. - * @param tx the transaction which executes the query. - * @param fetchSize the record fetch size for PULL message. - * @return stage with cursor. - */ - ResultCursorFactory runInUnmanagedTransaction( - Connection connection, Query query, UnmanagedTransaction tx, long fetchSize); - - /** - * Returns the protocol version. It can be used for version specific error messages. - * @return the protocol version. - */ - BoltProtocolVersion version(); - - /** - * Obtain an instance of the protocol for the given channel. - * - * @param channel the channel to get protocol for. - * @return the protocol. - * @throws ClientException when unable to find protocol version for the given channel. - */ - static BoltProtocol forChannel(Channel channel) { - return forVersion(protocolVersion(channel)); - } - - /** - * Obtain an instance of the protocol for the given channel. - * - * @param version the version of the protocol. - * @return the protocol. - * @throws ClientException when unable to find protocol with the given version. - */ - static BoltProtocol forVersion(BoltProtocolVersion version) { - if (BoltProtocolV3.VERSION.equals(version)) { - return BoltProtocolV3.INSTANCE; - } else if (BoltProtocolV4.VERSION.equals(version)) { - return BoltProtocolV4.INSTANCE; - } else if (BoltProtocolV41.VERSION.equals(version)) { - return BoltProtocolV41.INSTANCE; - } else if (BoltProtocolV42.VERSION.equals(version)) { - return BoltProtocolV42.INSTANCE; - } else if (BoltProtocolV43.VERSION.equals(version)) { - return BoltProtocolV43.INSTANCE; - } else if (BoltProtocolV44.VERSION.equals(version)) { - return BoltProtocolV44.INSTANCE; - } else if (BoltProtocolV5.VERSION.equals(version)) { - return BoltProtocolV5.INSTANCE; - } else if (BoltProtocolV51.VERSION.equals(version)) { - return BoltProtocolV51.INSTANCE; - } else if (BoltProtocolV52.VERSION.equals(version)) { - return BoltProtocolV52.INSTANCE; - } else if (BoltProtocolV53.VERSION.equals(version)) { - return BoltProtocolV53.INSTANCE; - } else if (BoltProtocolV54.VERSION.equals(version)) { - return BoltProtocolV54.INSTANCE; - } - throw new ClientException("Unknown protocol version: " + version); - } -} 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 deleted file mode 100644 index d0a16cb28f..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3.java +++ /dev/null @@ -1,258 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v3; - -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.messageDispatcher; -import static org.neo4j.driver.internal.handlers.PullHandlers.newBoltV3PullAllHandler; -import static org.neo4j.driver.internal.messaging.request.CommitMessage.COMMIT; -import static org.neo4j.driver.internal.messaging.request.MultiDatabaseUtil.assertEmptyDatabaseName; -import static org.neo4j.driver.internal.messaging.request.RollbackMessage.ROLLBACK; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; - -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; -import java.util.function.Consumer; -import org.neo4j.driver.AuthToken; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.NotificationConfig; -import org.neo4j.driver.Query; -import org.neo4j.driver.TransactionConfig; -import org.neo4j.driver.exceptions.Neo4jException; -import org.neo4j.driver.exceptions.UnsupportedFeatureException; -import org.neo4j.driver.internal.BoltAgent; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.cluster.RoutingContext; -import org.neo4j.driver.internal.cursor.AsyncResultCursorOnlyFactory; -import org.neo4j.driver.internal.cursor.ResultCursorFactory; -import org.neo4j.driver.internal.handlers.BeginTxResponseHandler; -import org.neo4j.driver.internal.handlers.CommitTxResponseHandler; -import org.neo4j.driver.internal.handlers.HelloResponseHandler; -import org.neo4j.driver.internal.handlers.NoOpResponseHandler; -import org.neo4j.driver.internal.handlers.RollbackTxResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -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.BeginMessage; -import org.neo4j.driver.internal.messaging.request.GoodbyeMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.util.Futures; -import org.neo4j.driver.internal.util.MetadataExtractor; - -public class BoltProtocolV3 implements BoltProtocol { - public static final BoltProtocolVersion VERSION = new BoltProtocolVersion(3, 0); - - public static final BoltProtocol INSTANCE = new BoltProtocolV3(); - - public static final MetadataExtractor METADATA_EXTRACTOR = new MetadataExtractor("t_first", "t_last"); - - @Override - public MessageFormat createMessageFormat() { - return new MessageFormatV3(); - } - - @Override - public void initializeChannel( - String userAgent, - BoltAgent boltAgent, - AuthToken authToken, - RoutingContext routingContext, - ChannelPromise channelInitializedPromise, - NotificationConfig notificationConfig, - Clock clock) { - var exception = verifyNotificationConfigSupported(notificationConfig); - if (exception != null) { - channelInitializedPromise.setFailure(exception); - return; - } - var channel = channelInitializedPromise.channel(); - HelloMessage message; - - if (routingContext.isServerRoutingEnabled()) { - message = new HelloMessage( - userAgent, - null, - ((InternalAuthToken) authToken).toMap(), - routingContext.toMap(), - includeDateTimeUtcPatchInHello(), - notificationConfig); - } else { - message = new HelloMessage( - userAgent, - null, - ((InternalAuthToken) authToken).toMap(), - null, - includeDateTimeUtcPatchInHello(), - notificationConfig); - } - - var handler = new HelloResponseHandler(channelInitializedPromise, clock); - - messageDispatcher(channel).enqueue(handler); - channel.writeAndFlush(message, channel.voidPromise()); - } - - @Override - public void prepareToCloseChannel(Channel channel) { - var messageDispatcher = messageDispatcher(channel); - - var message = GoodbyeMessage.GOODBYE; - messageDispatcher.enqueue(NoOpResponseHandler.INSTANCE); - channel.writeAndFlush(message, channel.voidPromise()); - - messageDispatcher.prepareToCloseChannel(); - } - - @Override - public CompletionStage beginTransaction( - Connection connection, - Set bookmarks, - TransactionConfig config, - String txType, - NotificationConfig notificationConfig, - Logging logging, - boolean flush) { - var exception = verifyNotificationConfigSupported(notificationConfig); - if (exception != null) { - return CompletableFuture.failedStage(exception); - } - try { - verifyDatabaseNameBeforeTransaction(connection.databaseName()); - } catch (Exception error) { - return Futures.failedFuture(error); - } - - var beginTxFuture = new CompletableFuture(); - var beginMessage = new BeginMessage( - bookmarks, - config, - connection.databaseName(), - connection.mode(), - connection.impersonatedUser(), - txType, - notificationConfig, - logging); - var handler = new BeginTxResponseHandler(beginTxFuture); - if (flush) { - connection.writeAndFlush(beginMessage, handler); - } else { - connection.write(beginMessage, handler); - } - return beginTxFuture; - } - - @Override - public CompletionStage commitTransaction(Connection connection) { - var commitFuture = new CompletableFuture(); - connection.writeAndFlush(COMMIT, new CommitTxResponseHandler(commitFuture)); - return commitFuture; - } - - @Override - public CompletionStage rollbackTransaction(Connection connection) { - var rollbackFuture = new CompletableFuture(); - connection.writeAndFlush(ROLLBACK, new RollbackTxResponseHandler(rollbackFuture)); - return rollbackFuture; - } - - @Override - public ResultCursorFactory runInAutoCommitTransaction( - Connection connection, - Query query, - Set bookmarks, - Consumer bookmarkConsumer, - TransactionConfig config, - long fetchSize, - NotificationConfig notificationConfig, - Logging logging) { - var exception = verifyNotificationConfigSupported(notificationConfig); - if (exception != null) { - throw exception; - } - verifyDatabaseNameBeforeTransaction(connection.databaseName()); - var runMessage = autoCommitTxRunMessage( - query, - config, - connection.databaseName(), - connection.mode(), - bookmarks, - connection.impersonatedUser(), - notificationConfig, - logging); - return buildResultCursorFactory(connection, query, bookmarkConsumer, null, runMessage, fetchSize); - } - - @Override - public ResultCursorFactory runInUnmanagedTransaction( - Connection connection, Query query, UnmanagedTransaction tx, long fetchSize) { - var runMessage = unmanagedTxRunMessage(query); - return buildResultCursorFactory(connection, query, (ignored) -> {}, tx, runMessage, fetchSize); - } - - @Override - public CompletionStage telemetry(Connection connection, Integer api) { - return CompletableFuture.completedStage(null); - } - - protected ResultCursorFactory buildResultCursorFactory( - Connection connection, - Query query, - Consumer bookmarkConsumer, - UnmanagedTransaction tx, - RunWithMetadataMessage runMessage, - long ignored) { - var runFuture = new CompletableFuture(); - var runHandler = new RunResponseHandler(runFuture, METADATA_EXTRACTOR, connection, tx); - var pullHandler = newBoltV3PullAllHandler(query, runHandler, connection, bookmarkConsumer, tx); - - return new AsyncResultCursorOnlyFactory(connection, runMessage, runHandler, runFuture, pullHandler); - } - - protected void verifyDatabaseNameBeforeTransaction(DatabaseName databaseName) { - assertEmptyDatabaseName(databaseName, version()); - } - - @Override - public BoltProtocolVersion version() { - return VERSION; - } - - protected boolean includeDateTimeUtcPatchInHello() { - return false; - } - - protected Neo4jException verifyNotificationConfigSupported(NotificationConfig notificationConfig) { - Neo4jException exception = null; - if (notificationConfig != null && !notificationConfig.equals(NotificationConfig.defaultConfig())) { - exception = new UnsupportedFeatureException(String.format( - "Notification configuration is not supported on Bolt %s", - version().toString())); - } - return exception; - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/MessageWriterV3.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/MessageWriterV3.java deleted file mode 100644 index ca3a2d2856..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v3/MessageWriterV3.java +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v3; - -import java.util.Map; -import org.neo4j.driver.internal.messaging.AbstractMessageWriter; -import org.neo4j.driver.internal.messaging.MessageEncoder; -import org.neo4j.driver.internal.messaging.common.CommonValuePacker; -import org.neo4j.driver.internal.messaging.encode.BeginMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.CommitMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.DiscardAllMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.GoodbyeMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.HelloMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.PullAllMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.ResetMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.RollbackMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.RunWithMetadataMessageEncoder; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -import org.neo4j.driver.internal.messaging.request.DiscardAllMessage; -import org.neo4j.driver.internal.messaging.request.GoodbyeMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.messaging.request.PullAllMessage; -import org.neo4j.driver.internal.messaging.request.ResetMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.packstream.PackOutput; -import org.neo4j.driver.internal.util.Iterables; - -public class MessageWriterV3 extends AbstractMessageWriter { - public MessageWriterV3(PackOutput output) { - super(new CommonValuePacker(output, false), buildEncoders()); - } - - private static Map buildEncoders() { - Map result = Iterables.newHashMapWithSize(9); - result.put(HelloMessage.SIGNATURE, new HelloMessageEncoder()); - result.put(GoodbyeMessage.SIGNATURE, new GoodbyeMessageEncoder()); - - result.put(RunWithMetadataMessage.SIGNATURE, new RunWithMetadataMessageEncoder()); - result.put(DiscardAllMessage.SIGNATURE, new DiscardAllMessageEncoder()); - result.put(PullAllMessage.SIGNATURE, new PullAllMessageEncoder()); - - result.put(BeginMessage.SIGNATURE, new BeginMessageEncoder()); - result.put(CommitMessage.SIGNATURE, new CommitMessageEncoder()); - result.put(RollbackMessage.SIGNATURE, new RollbackMessageEncoder()); - result.put(ResetMessage.SIGNATURE, new ResetMessageEncoder()); - return result; - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4.java deleted file mode 100644 index 4b92d6e908..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4.java +++ /dev/null @@ -1,73 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v4; - -import static org.neo4j.driver.internal.handlers.PullHandlers.newBoltV4AutoPullHandler; -import static org.neo4j.driver.internal.handlers.PullHandlers.newBoltV4BasicPullHandler; - -import java.util.concurrent.CompletableFuture; -import java.util.function.Consumer; -import org.neo4j.driver.Query; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.cursor.ResultCursorFactory; -import org.neo4j.driver.internal.cursor.ResultCursorFactoryImpl; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -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.RunWithMetadataMessage; -import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3; -import org.neo4j.driver.internal.spi.Connection; - -public class BoltProtocolV4 extends BoltProtocolV3 { - public static final BoltProtocolVersion VERSION = new BoltProtocolVersion(4, 0); - public static final BoltProtocol INSTANCE = new BoltProtocolV4(); - - @Override - public MessageFormat createMessageFormat() { - return new MessageFormatV4(); - } - - @Override - protected ResultCursorFactory buildResultCursorFactory( - Connection connection, - Query query, - Consumer bookmarkConsumer, - UnmanagedTransaction tx, - RunWithMetadataMessage runMessage, - long fetchSize) { - var runFuture = new CompletableFuture(); - var runHandler = new RunResponseHandler(runFuture, METADATA_EXTRACTOR, connection, tx); - - var pullAllHandler = newBoltV4AutoPullHandler(query, runHandler, connection, bookmarkConsumer, tx, fetchSize); - var pullHandler = newBoltV4BasicPullHandler(query, runHandler, connection, bookmarkConsumer, tx); - - return new ResultCursorFactoryImpl(connection, runMessage, runHandler, runFuture, pullHandler, pullAllHandler); - } - - @Override - protected void verifyDatabaseNameBeforeTransaction(DatabaseName databaseName) { - // Bolt V4 accepts database name - } - - @Override - public BoltProtocolVersion version() { - return VERSION; - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v4/MessageWriterV4.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v4/MessageWriterV4.java deleted file mode 100644 index e45d7fe1ae..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v4/MessageWriterV4.java +++ /dev/null @@ -1,66 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v4; - -import java.util.Map; -import org.neo4j.driver.internal.messaging.AbstractMessageWriter; -import org.neo4j.driver.internal.messaging.MessageEncoder; -import org.neo4j.driver.internal.messaging.common.CommonValuePacker; -import org.neo4j.driver.internal.messaging.encode.BeginMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.CommitMessageEncoder; -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.PullMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.ResetMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.RollbackMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.RunWithMetadataMessageEncoder; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -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.PullMessage; -import org.neo4j.driver.internal.messaging.request.ResetMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.packstream.PackOutput; -import org.neo4j.driver.internal.util.Iterables; - -public class MessageWriterV4 extends AbstractMessageWriter { - public MessageWriterV4(PackOutput output) { - super(new CommonValuePacker(output, false), buildEncoders()); - } - - @SuppressWarnings("DuplicatedCode") - private static Map buildEncoders() { - Map result = Iterables.newHashMapWithSize(9); - result.put(HelloMessage.SIGNATURE, new HelloMessageEncoder()); - result.put(GoodbyeMessage.SIGNATURE, new GoodbyeMessageEncoder()); - result.put(RunWithMetadataMessage.SIGNATURE, new RunWithMetadataMessageEncoder()); - - result.put(DiscardMessage.SIGNATURE, new DiscardMessageEncoder()); // new - result.put(PullMessage.SIGNATURE, new PullMessageEncoder()); // new - - result.put(BeginMessage.SIGNATURE, new BeginMessageEncoder()); - result.put(CommitMessage.SIGNATURE, new CommitMessageEncoder()); - result.put(RollbackMessage.SIGNATURE, new RollbackMessageEncoder()); - - result.put(ResetMessage.SIGNATURE, new ResetMessageEncoder()); - return result; - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v43/BoltProtocolV43.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v43/BoltProtocolV43.java deleted file mode 100644 index 31f0974745..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v43/BoltProtocolV43.java +++ /dev/null @@ -1,47 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v43; - -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.v42.BoltProtocolV42; - -/** - * Definition of the Bolt Protocol 4.3 - *

- * The version 4.3 use most of the 4.2 behaviours, but it extends it with new messages such as ROUTE - */ -public class BoltProtocolV43 extends BoltProtocolV42 { - public static final BoltProtocolVersion VERSION = new BoltProtocolVersion(4, 3); - public static final BoltProtocol INSTANCE = new BoltProtocolV43(); - - @Override - public MessageFormat createMessageFormat() { - return new MessageFormatV43(); - } - - @Override - public BoltProtocolVersion version() { - return VERSION; - } - - @Override - protected boolean includeDateTimeUtcPatchInHello() { - return true; - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v43/MessageWriterV43.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v43/MessageWriterV43.java deleted file mode 100644 index 0e7f5733bd..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v43/MessageWriterV43.java +++ /dev/null @@ -1,75 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v43; - -import java.util.Map; -import org.neo4j.driver.internal.messaging.AbstractMessageWriter; -import org.neo4j.driver.internal.messaging.MessageEncoder; -import org.neo4j.driver.internal.messaging.common.CommonValuePacker; -import org.neo4j.driver.internal.messaging.encode.BeginMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.CommitMessageEncoder; -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.PullMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.ResetMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.RollbackMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.RouteMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.RunWithMetadataMessageEncoder; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -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.PullMessage; -import org.neo4j.driver.internal.messaging.request.ResetMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RouteMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.packstream.PackOutput; -import org.neo4j.driver.internal.util.Iterables; - -/** - * Bolt message writer v4.3 - *

- * This version is able to encode all the versions existing on v4.2, but it encodes - * new messages such as ROUTE - */ -public class MessageWriterV43 extends AbstractMessageWriter { - public MessageWriterV43(PackOutput output, boolean dateTimeUtcEnabled) { - super(new CommonValuePacker(output, dateTimeUtcEnabled), buildEncoders()); - } - - @SuppressWarnings("DuplicatedCode") - private static Map buildEncoders() { - Map result = Iterables.newHashMapWithSize(9); - result.put(HelloMessage.SIGNATURE, new HelloMessageEncoder()); - result.put(GoodbyeMessage.SIGNATURE, new GoodbyeMessageEncoder()); - result.put(RunWithMetadataMessage.SIGNATURE, new RunWithMetadataMessageEncoder()); - result.put(RouteMessage.SIGNATURE, new RouteMessageEncoder()); // new - - result.put(DiscardMessage.SIGNATURE, new DiscardMessageEncoder()); - result.put(PullMessage.SIGNATURE, new PullMessageEncoder()); - - result.put(BeginMessage.SIGNATURE, new BeginMessageEncoder()); - result.put(CommitMessage.SIGNATURE, new CommitMessageEncoder()); - result.put(RollbackMessage.SIGNATURE, new RollbackMessageEncoder()); - - result.put(ResetMessage.SIGNATURE, new ResetMessageEncoder()); - return result; - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v44/MessageWriterV44.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v44/MessageWriterV44.java deleted file mode 100644 index e8217b10cd..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v44/MessageWriterV44.java +++ /dev/null @@ -1,72 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v44; - -import java.util.Map; -import org.neo4j.driver.internal.messaging.AbstractMessageWriter; -import org.neo4j.driver.internal.messaging.MessageEncoder; -import org.neo4j.driver.internal.messaging.common.CommonValuePacker; -import org.neo4j.driver.internal.messaging.encode.BeginMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.CommitMessageEncoder; -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.PullMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.ResetMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.RollbackMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.RouteV44MessageEncoder; -import org.neo4j.driver.internal.messaging.encode.RunWithMetadataMessageEncoder; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -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.PullMessage; -import org.neo4j.driver.internal.messaging.request.ResetMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RouteMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.packstream.PackOutput; -import org.neo4j.driver.internal.util.Iterables; - -/** - * Bolt message writer v4.4 - */ -public class MessageWriterV44 extends AbstractMessageWriter { - public MessageWriterV44(PackOutput output, boolean dateTimeUtcEnabled) { - super(new CommonValuePacker(output, dateTimeUtcEnabled), buildEncoders()); - } - - @SuppressWarnings("DuplicatedCode") - private static Map buildEncoders() { - Map result = Iterables.newHashMapWithSize(9); - result.put(HelloMessage.SIGNATURE, new HelloMessageEncoder()); - result.put(GoodbyeMessage.SIGNATURE, new GoodbyeMessageEncoder()); - result.put(RunWithMetadataMessage.SIGNATURE, new RunWithMetadataMessageEncoder()); - result.put(RouteMessage.SIGNATURE, new RouteV44MessageEncoder()); - - result.put(DiscardMessage.SIGNATURE, new DiscardMessageEncoder()); - result.put(PullMessage.SIGNATURE, new PullMessageEncoder()); - - result.put(BeginMessage.SIGNATURE, new BeginMessageEncoder()); - result.put(CommitMessage.SIGNATURE, new CommitMessageEncoder()); - result.put(RollbackMessage.SIGNATURE, new RollbackMessageEncoder()); - - result.put(ResetMessage.SIGNATURE, new ResetMessageEncoder()); - return result; - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v5/MessageWriterV5.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v5/MessageWriterV5.java deleted file mode 100644 index 1fb3b28349..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v5/MessageWriterV5.java +++ /dev/null @@ -1,69 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v5; - -import java.util.Map; -import org.neo4j.driver.internal.messaging.AbstractMessageWriter; -import org.neo4j.driver.internal.messaging.MessageEncoder; -import org.neo4j.driver.internal.messaging.common.CommonValuePacker; -import org.neo4j.driver.internal.messaging.encode.BeginMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.CommitMessageEncoder; -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.PullMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.ResetMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.RollbackMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.RouteV44MessageEncoder; -import org.neo4j.driver.internal.messaging.encode.RunWithMetadataMessageEncoder; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -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.PullMessage; -import org.neo4j.driver.internal.messaging.request.ResetMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RouteMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.packstream.PackOutput; -import org.neo4j.driver.internal.util.Iterables; - -public class MessageWriterV5 extends AbstractMessageWriter { - public MessageWriterV5(PackOutput output) { - super(new CommonValuePacker(output, true), buildEncoders()); - } - - @SuppressWarnings("DuplicatedCode") - private static Map buildEncoders() { - Map result = Iterables.newHashMapWithSize(9); - result.put(HelloMessage.SIGNATURE, new HelloMessageEncoder()); - result.put(GoodbyeMessage.SIGNATURE, new GoodbyeMessageEncoder()); - result.put(RunWithMetadataMessage.SIGNATURE, new RunWithMetadataMessageEncoder()); - result.put(RouteMessage.SIGNATURE, new RouteV44MessageEncoder()); - - result.put(DiscardMessage.SIGNATURE, new DiscardMessageEncoder()); - result.put(PullMessage.SIGNATURE, new PullMessageEncoder()); - - result.put(BeginMessage.SIGNATURE, new BeginMessageEncoder()); - result.put(CommitMessage.SIGNATURE, new CommitMessageEncoder()); - result.put(RollbackMessage.SIGNATURE, new RollbackMessageEncoder()); - - result.put(ResetMessage.SIGNATURE, new ResetMessageEncoder()); - return result; - } -} 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 deleted file mode 100644 index e7fed32fee..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v51/BoltProtocolV51.java +++ /dev/null @@ -1,81 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.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.BoltAgent; -import org.neo4j.driver.internal.cluster.RoutingContext; -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.v5.BoltProtocolV5; - -public class BoltProtocolV51 extends BoltProtocolV5 { - public static final BoltProtocolVersion VERSION = new BoltProtocolVersion(5, 1); - public static final BoltProtocol INSTANCE = new BoltProtocolV51(); - - @Override - public void initializeChannel( - String userAgent, - BoltAgent boltAgent, - AuthToken authToken, - RoutingContext routingContext, - ChannelPromise channelInitializedPromise, - NotificationConfig notificationConfig, - Clock clock) { - var exception = verifyNotificationConfigSupported(notificationConfig); - if (exception != null) { - channelInitializedPromise.setFailure(exception); - return; - } - var channel = channelInitializedPromise.channel(); - HelloMessage message; - - if (routingContext.isServerRoutingEnabled()) { - message = new HelloMessage( - userAgent, null, Collections.emptyMap(), routingContext.toMap(), false, notificationConfig); - } else { - message = new HelloMessage(userAgent, null, Collections.emptyMap(), null, false, notificationConfig); - } - - var helloFuture = new CompletableFuture(); - setHelloStage(channel, helloFuture); - messageDispatcher(channel).enqueue(new HelloV51ResponseHandler(channel, helloFuture)); - channel.write(message, channel.voidPromise()); - channelInitializedPromise.setSuccess(); - } - - @Override - public BoltProtocolVersion version() { - return VERSION; - } - - @Override - public MessageFormat createMessageFormat() { - return new MessageFormatV51(); - } -} 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 deleted file mode 100644 index 4a22eced41..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v51/MessageWriterV51.java +++ /dev/null @@ -1,75 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v51; - -import java.util.Map; -import org.neo4j.driver.internal.messaging.AbstractMessageWriter; -import org.neo4j.driver.internal.messaging.MessageEncoder; -import org.neo4j.driver.internal.messaging.common.CommonValuePacker; -import org.neo4j.driver.internal.messaging.encode.BeginMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.CommitMessageEncoder; -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; -import org.neo4j.driver.internal.messaging.encode.RollbackMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.RouteV44MessageEncoder; -import org.neo4j.driver.internal.messaging.encode.RunWithMetadataMessageEncoder; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -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; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RouteMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.packstream.PackOutput; -import org.neo4j.driver.internal.util.Iterables; - -public class MessageWriterV51 extends AbstractMessageWriter { - public MessageWriterV51(PackOutput output) { - super(new CommonValuePacker(output, true), buildEncoders()); - } - - @SuppressWarnings("DuplicatedCode") - 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()); - - result.put(DiscardMessage.SIGNATURE, new DiscardMessageEncoder()); - result.put(PullMessage.SIGNATURE, new PullMessageEncoder()); - - result.put(BeginMessage.SIGNATURE, new BeginMessageEncoder()); - result.put(CommitMessage.SIGNATURE, new CommitMessageEncoder()); - result.put(RollbackMessage.SIGNATURE, new RollbackMessageEncoder()); - - result.put(ResetMessage.SIGNATURE, new ResetMessageEncoder()); - return result; - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/v54/MessageWriterV54.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/v54/MessageWriterV54.java deleted file mode 100644 index 26d6bc4ff7..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/v54/MessageWriterV54.java +++ /dev/null @@ -1,78 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v54; - -import java.util.Map; -import org.neo4j.driver.internal.messaging.AbstractMessageWriter; -import org.neo4j.driver.internal.messaging.MessageEncoder; -import org.neo4j.driver.internal.messaging.common.CommonValuePacker; -import org.neo4j.driver.internal.messaging.encode.BeginMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.CommitMessageEncoder; -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; -import org.neo4j.driver.internal.messaging.encode.RollbackMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.RouteV44MessageEncoder; -import org.neo4j.driver.internal.messaging.encode.RunWithMetadataMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.TelemetryMessageEncoder; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -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; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RouteMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.messaging.request.TelemetryMessage; -import org.neo4j.driver.internal.packstream.PackOutput; -import org.neo4j.driver.internal.util.Iterables; - -public class MessageWriterV54 extends AbstractMessageWriter { - public MessageWriterV54(PackOutput output) { - super(new CommonValuePacker(output, true), buildEncoders()); - } - - @SuppressWarnings("DuplicatedCode") - 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()); - - result.put(DiscardMessage.SIGNATURE, new DiscardMessageEncoder()); - result.put(PullMessage.SIGNATURE, new PullMessageEncoder()); - - result.put(BeginMessage.SIGNATURE, new BeginMessageEncoder()); - result.put(CommitMessage.SIGNATURE, new CommitMessageEncoder()); - result.put(RollbackMessage.SIGNATURE, new RollbackMessageEncoder()); - - result.put(ResetMessage.SIGNATURE, new ResetMessageEncoder()); - result.put(TelemetryMessage.SIGNATURE, new TelemetryMessageEncoder()); - return result; - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/metrics/ConnectionPoolMetricsListener.java b/driver/src/main/java/org/neo4j/driver/internal/metrics/ConnectionPoolMetricsListener.java index 1452ace739..6933d9e916 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/metrics/ConnectionPoolMetricsListener.java +++ b/driver/src/main/java/org/neo4j/driver/internal/metrics/ConnectionPoolMetricsListener.java @@ -16,6 +16,8 @@ */ package org.neo4j.driver.internal.metrics; +import org.neo4j.driver.internal.bolt.api.ListenerEvent; + interface ConnectionPoolMetricsListener { /** * Invoked before a connection is creating. diff --git a/driver/src/main/java/org/neo4j/driver/internal/metrics/DevNullListenerEvent.java b/driver/src/main/java/org/neo4j/driver/internal/metrics/DevNullListenerEvent.java index 9c38a96d2c..db2e2802fb 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/metrics/DevNullListenerEvent.java +++ b/driver/src/main/java/org/neo4j/driver/internal/metrics/DevNullListenerEvent.java @@ -16,6 +16,8 @@ */ package org.neo4j.driver.internal.metrics; +import org.neo4j.driver.internal.bolt.api.ListenerEvent; + enum DevNullListenerEvent implements ListenerEvent { INSTANCE; diff --git a/driver/src/main/java/org/neo4j/driver/internal/metrics/DevNullMetricsListener.java b/driver/src/main/java/org/neo4j/driver/internal/metrics/DevNullMetricsListener.java index d93766f1fb..e59a592e54 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/metrics/DevNullMetricsListener.java +++ b/driver/src/main/java/org/neo4j/driver/internal/metrics/DevNullMetricsListener.java @@ -17,7 +17,9 @@ package org.neo4j.driver.internal.metrics; import java.util.function.IntSupplier; -import org.neo4j.driver.net.ServerAddress; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ListenerEvent; +import org.neo4j.driver.internal.bolt.api.MetricsListener; public enum DevNullMetricsListener implements MetricsListener { INSTANCE; @@ -59,7 +61,7 @@ public ListenerEvent createListenerEvent() { @Override public void registerPoolMetrics( - String poolId, ServerAddress serverAddress, IntSupplier inUseSupplier, IntSupplier idleSupplier) {} + String poolId, BoltServerAddress serverAddress, IntSupplier inUseSupplier, IntSupplier idleSupplier) {} @Override public void removePoolMetrics(String poolId) {} diff --git a/driver/src/main/java/org/neo4j/driver/internal/metrics/DevNullMetricsProvider.java b/driver/src/main/java/org/neo4j/driver/internal/metrics/DevNullMetricsProvider.java index f972caf269..a4e878316c 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/metrics/DevNullMetricsProvider.java +++ b/driver/src/main/java/org/neo4j/driver/internal/metrics/DevNullMetricsProvider.java @@ -18,6 +18,7 @@ import org.neo4j.driver.Metrics; import org.neo4j.driver.exceptions.ClientException; +import org.neo4j.driver.internal.bolt.api.MetricsListener; public enum DevNullMetricsProvider implements MetricsProvider { INSTANCE; diff --git a/driver/src/main/java/org/neo4j/driver/internal/metrics/DevNullPoolMetricsListener.java b/driver/src/main/java/org/neo4j/driver/internal/metrics/DevNullPoolMetricsListener.java index c63abd4377..f4cb64e851 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/metrics/DevNullPoolMetricsListener.java +++ b/driver/src/main/java/org/neo4j/driver/internal/metrics/DevNullPoolMetricsListener.java @@ -16,6 +16,8 @@ */ package org.neo4j.driver.internal.metrics; +import org.neo4j.driver.internal.bolt.api.ListenerEvent; + enum DevNullPoolMetricsListener implements ConnectionPoolMetricsListener { INSTANCE; diff --git a/driver/src/main/java/org/neo4j/driver/internal/metrics/InternalConnectionPoolMetrics.java b/driver/src/main/java/org/neo4j/driver/internal/metrics/InternalConnectionPoolMetrics.java index 741781970c..8538ceef31 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/metrics/InternalConnectionPoolMetrics.java +++ b/driver/src/main/java/org/neo4j/driver/internal/metrics/InternalConnectionPoolMetrics.java @@ -23,10 +23,11 @@ import java.util.concurrent.atomic.AtomicLong; import java.util.function.IntSupplier; import org.neo4j.driver.ConnectionPoolMetrics; -import org.neo4j.driver.net.ServerAddress; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ListenerEvent; final class InternalConnectionPoolMetrics implements ConnectionPoolMetrics, ConnectionPoolMetricsListener { - private final ServerAddress address; + private final BoltServerAddress address; private final IntSupplier inUseSupplier; private final IntSupplier idleSupplier; @@ -50,7 +51,7 @@ final class InternalConnectionPoolMetrics implements ConnectionPoolMetrics, Conn private final String id; InternalConnectionPoolMetrics( - String poolId, ServerAddress address, IntSupplier inUseSupplier, IntSupplier idleSupplier) { + String poolId, BoltServerAddress address, IntSupplier inUseSupplier, IntSupplier idleSupplier) { Objects.requireNonNull(address); Objects.requireNonNull(inUseSupplier); Objects.requireNonNull(idleSupplier); @@ -218,7 +219,7 @@ public String toString() { // This is used by the Testkit backend @SuppressWarnings("unused") - public ServerAddress getAddress() { + public BoltServerAddress getAddress() { return address; } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/metrics/InternalMetrics.java b/driver/src/main/java/org/neo4j/driver/internal/metrics/InternalMetrics.java index 8ccc34b2ee..c2f57899fe 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/metrics/InternalMetrics.java +++ b/driver/src/main/java/org/neo4j/driver/internal/metrics/InternalMetrics.java @@ -29,7 +29,9 @@ import org.neo4j.driver.Logger; import org.neo4j.driver.Logging; import org.neo4j.driver.Metrics; -import org.neo4j.driver.net.ServerAddress; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ListenerEvent; +import org.neo4j.driver.internal.bolt.api.MetricsListener; final class InternalMetrics implements Metrics, MetricsListener { private final Map connectionPoolMetrics; @@ -45,7 +47,7 @@ final class InternalMetrics implements Metrics, MetricsListener { @Override public void registerPoolMetrics( - String poolId, ServerAddress serverAddress, IntSupplier inUseSupplier, IntSupplier idleSupplier) { + String poolId, BoltServerAddress serverAddress, IntSupplier inUseSupplier, IntSupplier idleSupplier) { this.connectionPoolMetrics.put( poolId, new InternalConnectionPoolMetrics(poolId, serverAddress, inUseSupplier, idleSupplier)); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/metrics/InternalMetricsProvider.java b/driver/src/main/java/org/neo4j/driver/internal/metrics/InternalMetricsProvider.java index 5e50039179..96bb2f39e3 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/metrics/InternalMetricsProvider.java +++ b/driver/src/main/java/org/neo4j/driver/internal/metrics/InternalMetricsProvider.java @@ -19,6 +19,7 @@ import java.time.Clock; import org.neo4j.driver.Logging; import org.neo4j.driver.Metrics; +import org.neo4j.driver.internal.bolt.api.MetricsListener; public final class InternalMetricsProvider implements MetricsProvider { private final InternalMetrics metrics; diff --git a/driver/src/main/java/org/neo4j/driver/internal/metrics/MetricsProvider.java b/driver/src/main/java/org/neo4j/driver/internal/metrics/MetricsProvider.java index dce6473fdd..49f5a6efe6 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/metrics/MetricsProvider.java +++ b/driver/src/main/java/org/neo4j/driver/internal/metrics/MetricsProvider.java @@ -17,6 +17,7 @@ package org.neo4j.driver.internal.metrics; import org.neo4j.driver.Metrics; +import org.neo4j.driver.internal.bolt.api.MetricsListener; /** * An adapter that collects driver metrics via {@link MetricsListener} and publishes them via {@link Metrics} instance. diff --git a/driver/src/main/java/org/neo4j/driver/internal/metrics/MicrometerConnectionPoolMetrics.java b/driver/src/main/java/org/neo4j/driver/internal/metrics/MicrometerConnectionPoolMetrics.java index ba0dad8221..2e3a41d59a 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/metrics/MicrometerConnectionPoolMetrics.java +++ b/driver/src/main/java/org/neo4j/driver/internal/metrics/MicrometerConnectionPoolMetrics.java @@ -29,8 +29,8 @@ import java.util.concurrent.atomic.AtomicInteger; import java.util.function.IntSupplier; import org.neo4j.driver.ConnectionPoolMetrics; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.net.ServerAddress; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ListenerEvent; final class MicrometerConnectionPoolMetrics implements ConnectionPoolMetricsListener, ConnectionPoolMetrics { public static final String PREFIX = "neo4j.driver.connections"; @@ -61,7 +61,7 @@ final class MicrometerConnectionPoolMetrics implements ConnectionPoolMetricsList MicrometerConnectionPoolMetrics( String poolId, - ServerAddress address, + BoltServerAddress address, IntSupplier inUseSupplier, IntSupplier idleSupplier, MeterRegistry registry) { @@ -70,7 +70,7 @@ final class MicrometerConnectionPoolMetrics implements ConnectionPoolMetricsList MicrometerConnectionPoolMetrics( String poolId, - ServerAddress address, + BoltServerAddress address, IntSupplier inUseSupplier, IntSupplier idleSupplier, MeterRegistry registry, @@ -84,9 +84,8 @@ final class MicrometerConnectionPoolMetrics implements ConnectionPoolMetricsList this.id = poolId; this.inUseSupplier = inUseSupplier; this.idleSupplier = idleSupplier; - var host = - address instanceof BoltServerAddress ? ((BoltServerAddress) address).connectionHost() : address.host(); - Iterable tags = Tags.concat(initialTags, "address", String.format("%s:%d", host, address.port())); + Iterable tags = + Tags.concat(initialTags, "address", String.format("%s:%d", address.connectionHost(), address.port())); Gauge.builder(IN_USE, this::inUse).tags(tags).register(registry); Gauge.builder(IDLE, this::idle).tags(tags).register(registry); diff --git a/driver/src/main/java/org/neo4j/driver/internal/metrics/MicrometerMetrics.java b/driver/src/main/java/org/neo4j/driver/internal/metrics/MicrometerMetrics.java index fe32007263..b89e2d38e2 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/metrics/MicrometerMetrics.java +++ b/driver/src/main/java/org/neo4j/driver/internal/metrics/MicrometerMetrics.java @@ -24,7 +24,9 @@ import java.util.function.IntSupplier; import org.neo4j.driver.ConnectionPoolMetrics; import org.neo4j.driver.Metrics; -import org.neo4j.driver.net.ServerAddress; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ListenerEvent; +import org.neo4j.driver.internal.bolt.api.MetricsListener; final class MicrometerMetrics implements Metrics, MetricsListener { private final MeterRegistry meterRegistry; @@ -97,7 +99,7 @@ public ListenerEvent createListenerEvent() { @Override public void registerPoolMetrics( - String poolId, ServerAddress address, IntSupplier inUseSupplier, IntSupplier idleSupplier) { + String poolId, BoltServerAddress address, IntSupplier inUseSupplier, IntSupplier idleSupplier) { this.connectionPoolMetrics.put( poolId, new MicrometerConnectionPoolMetrics(poolId, address, inUseSupplier, idleSupplier, this.meterRegistry)); diff --git a/driver/src/main/java/org/neo4j/driver/internal/metrics/MicrometerMetricsProvider.java b/driver/src/main/java/org/neo4j/driver/internal/metrics/MicrometerMetricsProvider.java index 65b6ed6742..fce75c08aa 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/metrics/MicrometerMetricsProvider.java +++ b/driver/src/main/java/org/neo4j/driver/internal/metrics/MicrometerMetricsProvider.java @@ -18,6 +18,7 @@ import io.micrometer.core.instrument.MeterRegistry; import org.neo4j.driver.Metrics; +import org.neo4j.driver.internal.bolt.api.MetricsListener; /** * An adapter to bridge between driver metrics and Micrometer {@link MeterRegistry meter registry}. diff --git a/driver/src/main/java/org/neo4j/driver/internal/metrics/MicrometerTimerListenerEvent.java b/driver/src/main/java/org/neo4j/driver/internal/metrics/MicrometerTimerListenerEvent.java index 70bfa9be54..cec39a1670 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/metrics/MicrometerTimerListenerEvent.java +++ b/driver/src/main/java/org/neo4j/driver/internal/metrics/MicrometerTimerListenerEvent.java @@ -18,6 +18,7 @@ import io.micrometer.core.instrument.MeterRegistry; import io.micrometer.core.instrument.Timer; +import org.neo4j.driver.internal.bolt.api.ListenerEvent; final class MicrometerTimerListenerEvent implements ListenerEvent { private final MeterRegistry meterRegistry; diff --git a/driver/src/main/java/org/neo4j/driver/internal/metrics/TimeRecorderListenerEvent.java b/driver/src/main/java/org/neo4j/driver/internal/metrics/TimeRecorderListenerEvent.java index 413c883111..20843bcbde 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/metrics/TimeRecorderListenerEvent.java +++ b/driver/src/main/java/org/neo4j/driver/internal/metrics/TimeRecorderListenerEvent.java @@ -17,6 +17,7 @@ package org.neo4j.driver.internal.metrics; import java.time.Clock; +import org.neo4j.driver.internal.bolt.api.ListenerEvent; final class TimeRecorderListenerEvent implements ListenerEvent { private final Clock clock; diff --git a/driver/src/main/java/org/neo4j/driver/internal/reactive/AbstractReactiveSession.java b/driver/src/main/java/org/neo4j/driver/internal/reactive/AbstractReactiveSession.java index b0078e5df8..a66aedfa88 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/reactive/AbstractReactiveSession.java +++ b/driver/src/main/java/org/neo4j/driver/internal/reactive/AbstractReactiveSession.java @@ -33,9 +33,9 @@ import org.neo4j.driver.exceptions.TransactionNestingException; import org.neo4j.driver.internal.async.NetworkSession; import org.neo4j.driver.internal.async.UnmanagedTransaction; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; import org.neo4j.driver.internal.cursor.RxResultCursor; import org.neo4j.driver.internal.telemetry.ApiTelemetryWork; -import org.neo4j.driver.internal.telemetry.TelemetryApi; import org.neo4j.driver.internal.util.Futures; import org.neo4j.driver.reactive.RxResult; import org.neo4j.driver.reactivestreams.ReactiveResult; @@ -192,7 +192,7 @@ private CompletionStage runAsStage( try { cursorStage = session.runRx(query, config, finalStage); } catch (Throwable t) { - cursorStage = Futures.failedFuture(t); + cursorStage = CompletableFuture.failedFuture(t); } return cursorStage diff --git a/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalReactiveSession.java b/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalReactiveSession.java index a2da21810c..ee0985f0a8 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalReactiveSession.java +++ b/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalReactiveSession.java @@ -28,8 +28,8 @@ import org.neo4j.driver.TransactionConfig; import org.neo4j.driver.internal.async.NetworkSession; import org.neo4j.driver.internal.async.UnmanagedTransaction; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; import org.neo4j.driver.internal.telemetry.ApiTelemetryWork; -import org.neo4j.driver.internal.telemetry.TelemetryApi; import org.neo4j.driver.reactive.ReactiveResult; import org.neo4j.driver.reactive.ReactiveSession; import org.neo4j.driver.reactive.ReactiveTransaction; diff --git a/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalReactiveTransaction.java b/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalReactiveTransaction.java index 2bc117bf0d..b8fd3736e9 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalReactiveTransaction.java +++ b/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalReactiveTransaction.java @@ -18,12 +18,12 @@ import static reactor.adapter.JdkFlowAdapter.publisherToFlowPublisher; +import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionStage; import java.util.concurrent.Flow.Publisher; import org.neo4j.driver.Query; import org.neo4j.driver.internal.async.UnmanagedTransaction; import org.neo4j.driver.internal.cursor.RxResultCursor; -import org.neo4j.driver.internal.util.Futures; import org.neo4j.driver.reactive.ReactiveResult; import org.neo4j.driver.reactive.ReactiveTransaction; import reactor.core.publisher.Mono; @@ -41,7 +41,7 @@ public Publisher run(Query query) { try { cursorStage = tx.runRx(query); } catch (Throwable t) { - cursorStage = Futures.failedFuture(t); + cursorStage = CompletableFuture.failedFuture(t); } return publisherToFlowPublisher(Mono.fromCompletionStage(cursorStage) diff --git a/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxSession.java b/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxSession.java index 613dddc6b1..b61e222fbd 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxSession.java +++ b/driver/src/main/java/org/neo4j/driver/internal/reactive/InternalRxSession.java @@ -26,9 +26,9 @@ import org.neo4j.driver.internal.InternalBookmark; import org.neo4j.driver.internal.async.NetworkSession; import org.neo4j.driver.internal.async.UnmanagedTransaction; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; import org.neo4j.driver.internal.cursor.RxResultCursor; import org.neo4j.driver.internal.telemetry.ApiTelemetryWork; -import org.neo4j.driver.internal.telemetry.TelemetryApi; import org.neo4j.driver.internal.util.Futures; import org.neo4j.driver.reactive.RxResult; import org.neo4j.driver.reactive.RxSession; diff --git a/driver/src/main/java/org/neo4j/driver/internal/reactivestreams/InternalReactiveSession.java b/driver/src/main/java/org/neo4j/driver/internal/reactivestreams/InternalReactiveSession.java index 135c1e1497..54863df9ff 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/reactivestreams/InternalReactiveSession.java +++ b/driver/src/main/java/org/neo4j/driver/internal/reactivestreams/InternalReactiveSession.java @@ -24,9 +24,9 @@ import org.neo4j.driver.TransactionConfig; import org.neo4j.driver.internal.async.NetworkSession; import org.neo4j.driver.internal.async.UnmanagedTransaction; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; import org.neo4j.driver.internal.reactive.AbstractReactiveSession; import org.neo4j.driver.internal.telemetry.ApiTelemetryWork; -import org.neo4j.driver.internal.telemetry.TelemetryApi; import org.neo4j.driver.reactivestreams.ReactiveResult; import org.neo4j.driver.reactivestreams.ReactiveSession; import org.neo4j.driver.reactivestreams.ReactiveTransaction; diff --git a/driver/src/main/java/org/neo4j/driver/internal/reactivestreams/InternalReactiveTransaction.java b/driver/src/main/java/org/neo4j/driver/internal/reactivestreams/InternalReactiveTransaction.java index 354489852c..a7e2159b90 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/reactivestreams/InternalReactiveTransaction.java +++ b/driver/src/main/java/org/neo4j/driver/internal/reactivestreams/InternalReactiveTransaction.java @@ -16,12 +16,12 @@ */ package org.neo4j.driver.internal.reactivestreams; +import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionStage; import org.neo4j.driver.Query; import org.neo4j.driver.internal.async.UnmanagedTransaction; import org.neo4j.driver.internal.cursor.RxResultCursor; import org.neo4j.driver.internal.reactive.AbstractReactiveTransaction; -import org.neo4j.driver.internal.util.Futures; import org.neo4j.driver.reactivestreams.ReactiveResult; import org.neo4j.driver.reactivestreams.ReactiveTransaction; import org.reactivestreams.Publisher; @@ -40,7 +40,7 @@ public Publisher run(Query query) { try { cursorStage = tx.runRx(query); } catch (Throwable t) { - cursorStage = Futures.failedFuture(t); + cursorStage = CompletableFuture.failedFuture(t); } return Mono.fromCompletionStage(cursorStage) 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 index b94f9b0185..3f4c52c68d 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/security/ExpirationBasedAuthTokenManager.java +++ b/driver/src/main/java/org/neo4j/driver/internal/security/ExpirationBasedAuthTokenManager.java @@ -17,7 +17,6 @@ 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; @@ -118,7 +117,7 @@ private CompletionStage getFromUpstream() { upstreamStage = freshTokenSupplier.get(); requireNonNull(upstreamStage, "upstream supplied a null value"); } catch (Throwable t) { - upstreamStage = failedFuture(t); + upstreamStage = CompletableFuture.failedFuture(t); } return upstreamStage; } diff --git a/driver/src/main/java/org/neo4j/driver/internal/security/SecurityPlanImpl.java b/driver/src/main/java/org/neo4j/driver/internal/security/SecurityPlanImpl.java deleted file mode 100644 index 7a8e9ba063..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/security/SecurityPlanImpl.java +++ /dev/null @@ -1,198 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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 org.neo4j.driver.RevocationCheckingStrategy.VERIFY_IF_PRESENT; -import static org.neo4j.driver.RevocationCheckingStrategy.requiresRevocationChecking; -import static org.neo4j.driver.internal.util.CertificateTool.loadX509Cert; - -import java.io.File; -import java.io.IOException; -import java.security.GeneralSecurityException; -import java.security.InvalidAlgorithmParameterException; -import java.security.KeyStore; -import java.security.KeyStoreException; -import java.security.Security; -import java.security.cert.CertificateException; -import java.security.cert.PKIXBuilderParameters; -import java.security.cert.X509CertSelector; -import java.security.cert.X509Certificate; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import javax.net.ssl.CertPathTrustManagerParameters; -import javax.net.ssl.KeyManager; -import javax.net.ssl.SSLContext; -import javax.net.ssl.TrustManager; -import javax.net.ssl.TrustManagerFactory; -import javax.net.ssl.X509TrustManager; -import org.neo4j.driver.RevocationCheckingStrategy; - -/** - * A SecurityPlan consists of encryption and trust details. - */ -public class SecurityPlanImpl implements SecurityPlan { - public static SecurityPlan forAllCertificates( - boolean requiresHostnameVerification, RevocationCheckingStrategy revocationCheckingStrategy) - throws GeneralSecurityException { - var sslContext = SSLContext.getInstance("TLS"); - sslContext.init(new KeyManager[0], new TrustManager[] {new TrustAllTrustManager()}, null); - - return new SecurityPlanImpl(true, sslContext, requiresHostnameVerification, revocationCheckingStrategy); - } - - public static SecurityPlan forCustomCASignedCertificates( - List certFiles, - boolean requiresHostnameVerification, - RevocationCheckingStrategy revocationCheckingStrategy) - throws GeneralSecurityException, IOException { - var sslContext = configureSSLContext(certFiles, revocationCheckingStrategy); - return new SecurityPlanImpl(true, sslContext, requiresHostnameVerification, revocationCheckingStrategy); - } - - public static SecurityPlan forSystemCASignedCertificates( - boolean requiresHostnameVerification, RevocationCheckingStrategy revocationCheckingStrategy) - throws GeneralSecurityException, IOException { - var sslContext = configureSSLContext(Collections.emptyList(), revocationCheckingStrategy); - return new SecurityPlanImpl(true, sslContext, requiresHostnameVerification, revocationCheckingStrategy); - } - - private static SSLContext configureSSLContext( - List customCertFiles, RevocationCheckingStrategy revocationCheckingStrategy) - throws GeneralSecurityException, IOException { - var trustedKeyStore = KeyStore.getInstance(KeyStore.getDefaultType()); - trustedKeyStore.load(null, null); - - if (!customCertFiles.isEmpty()) { - // Certificate files are specified, so we will load the certificates in the file - loadX509Cert(customCertFiles, trustedKeyStore); - } else { - loadSystemCertificates(trustedKeyStore); - } - - var pkixBuilderParameters = configurePKIXBuilderParameters(trustedKeyStore, revocationCheckingStrategy); - - var sslContext = SSLContext.getInstance("TLS"); - var trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()); - - if (pkixBuilderParameters == null) { - trustManagerFactory.init(trustedKeyStore); - } else { - trustManagerFactory.init(new CertPathTrustManagerParameters(pkixBuilderParameters)); - } - - sslContext.init(new KeyManager[0], trustManagerFactory.getTrustManagers(), null); - - return sslContext; - } - - private static PKIXBuilderParameters configurePKIXBuilderParameters( - KeyStore trustedKeyStore, RevocationCheckingStrategy revocationCheckingStrategy) - throws InvalidAlgorithmParameterException, KeyStoreException { - PKIXBuilderParameters pkixBuilderParameters = null; - - if (requiresRevocationChecking(revocationCheckingStrategy)) { - // Configure certificate revocation checking (X509CertSelector() selects all certificates) - pkixBuilderParameters = new PKIXBuilderParameters(trustedKeyStore, new X509CertSelector()); - - // sets checking of stapled ocsp response - pkixBuilderParameters.setRevocationEnabled(true); - - // enables status_request extension in client hello - System.setProperty("jdk.tls.client.enableStatusRequestExtension", "true"); - - if (revocationCheckingStrategy.equals(VERIFY_IF_PRESENT)) { - // enables soft-fail behaviour if no stapled response found. - Security.setProperty("ocsp.enable", "true"); - } - } - return pkixBuilderParameters; - } - - private static void loadSystemCertificates(KeyStore trustedKeyStore) throws GeneralSecurityException { - // To customize the PKIXParameters we need to get hold of the default KeyStore, no other elegant way available - var tempFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()); - tempFactory.init((KeyStore) null); - - // Get hold of the default trust manager - var x509TrustManager = (X509TrustManager) Arrays.stream(tempFactory.getTrustManagers()) - .filter(trustManager -> trustManager instanceof X509TrustManager) - .findFirst() - .orElse(null); - - if (x509TrustManager == null) { - throw new CertificateException("No system certificates found"); - } else { - // load system default certificates into KeyStore - loadX509Cert(x509TrustManager.getAcceptedIssuers(), trustedKeyStore); - } - } - - public static SecurityPlan insecure() { - return new SecurityPlanImpl(false, null, false, RevocationCheckingStrategy.NO_CHECKS); - } - - private final boolean requiresEncryption; - private final SSLContext sslContext; - private final boolean requiresHostnameVerification; - private final RevocationCheckingStrategy revocationCheckingStrategy; - - private SecurityPlanImpl( - boolean requiresEncryption, - SSLContext sslContext, - boolean requiresHostnameVerification, - RevocationCheckingStrategy revocationCheckingStrategy) { - this.requiresEncryption = requiresEncryption; - this.sslContext = sslContext; - this.requiresHostnameVerification = requiresHostnameVerification; - this.revocationCheckingStrategy = revocationCheckingStrategy; - } - - @Override - public boolean requiresEncryption() { - return requiresEncryption; - } - - @Override - public SSLContext sslContext() { - return sslContext; - } - - @Override - public boolean requiresHostnameVerification() { - return requiresHostnameVerification; - } - - @Override - public RevocationCheckingStrategy revocationCheckingStrategy() { - return revocationCheckingStrategy; - } - - private static class TrustAllTrustManager implements X509TrustManager { - public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException { - throw new CertificateException("All client connections to this client are forbidden."); - } - - public void checkServerTrusted(X509Certificate[] chain, String authType) { - // all fine, pass through - } - - public X509Certificate[] getAcceptedIssuers() { - return new X509Certificate[0]; - } - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/security/SecurityPlans.java b/driver/src/main/java/org/neo4j/driver/internal/security/SecurityPlans.java index 353b387a22..401564ecdc 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/security/SecurityPlans.java +++ b/driver/src/main/java/org/neo4j/driver/internal/security/SecurityPlans.java @@ -16,17 +16,39 @@ */ package org.neo4j.driver.internal.security; +import static org.neo4j.driver.RevocationCheckingStrategy.VERIFY_IF_PRESENT; +import static org.neo4j.driver.RevocationCheckingStrategy.requiresRevocationChecking; import static org.neo4j.driver.internal.Scheme.isHighTrustScheme; import static org.neo4j.driver.internal.Scheme.isSecurityScheme; -import static org.neo4j.driver.internal.security.SecurityPlanImpl.insecure; +import static org.neo4j.driver.internal.util.CertificateTool.loadX509Cert; +import java.io.File; import java.io.IOException; import java.security.GeneralSecurityException; +import java.security.InvalidAlgorithmParameterException; +import java.security.KeyStore; +import java.security.KeyStoreException; +import java.security.Security; +import java.security.cert.CertificateException; +import java.security.cert.PKIXBuilderParameters; +import java.security.cert.X509CertSelector; +import java.security.cert.X509Certificate; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import javax.net.ssl.CertPathTrustManagerParameters; +import javax.net.ssl.KeyManager; +import javax.net.ssl.SSLContext; +import javax.net.ssl.TrustManager; +import javax.net.ssl.TrustManagerFactory; +import javax.net.ssl.X509TrustManager; import org.neo4j.driver.Config; import org.neo4j.driver.RevocationCheckingStrategy; import org.neo4j.driver.exceptions.ClientException; import org.neo4j.driver.internal.Scheme; import org.neo4j.driver.internal.SecuritySettings; +import org.neo4j.driver.internal.bolt.api.SecurityPlan; +import org.neo4j.driver.internal.bolt.api.SecurityPlanImpl; public class SecurityPlans { public static SecurityPlan createSecurityPlan(SecuritySettings settings, String uriScheme) { @@ -71,9 +93,9 @@ private static boolean hasEqualTrustStrategy(SecuritySettings settings) { private static SecurityPlan createSecurityPlanFromScheme(String scheme) throws GeneralSecurityException, IOException { if (isHighTrustScheme(scheme)) { - return SecurityPlanImpl.forSystemCASignedCertificates(true, RevocationCheckingStrategy.NO_CHECKS); + return forSystemCASignedCertificates(true, RevocationCheckingStrategy.NO_CHECKS); } else { - return SecurityPlanImpl.forAllCertificates(false, RevocationCheckingStrategy.NO_CHECKS); + return forAllCertificates(false, RevocationCheckingStrategy.NO_CHECKS); } } @@ -87,15 +109,129 @@ private static SecurityPlan createSecurityPlanImpl(boolean encrypted, Config.Tru var hostnameVerificationEnabled = trustStrategy.isHostnameVerificationEnabled(); var revocationCheckingStrategy = trustStrategy.revocationCheckingStrategy(); return switch (trustStrategy.strategy()) { - case TRUST_CUSTOM_CA_SIGNED_CERTIFICATES -> SecurityPlanImpl.forCustomCASignedCertificates( + case TRUST_CUSTOM_CA_SIGNED_CERTIFICATES -> forCustomCASignedCertificates( trustStrategy.certFiles(), hostnameVerificationEnabled, revocationCheckingStrategy); - case TRUST_SYSTEM_CA_SIGNED_CERTIFICATES -> SecurityPlanImpl.forSystemCASignedCertificates( + case TRUST_SYSTEM_CA_SIGNED_CERTIFICATES -> forSystemCASignedCertificates( hostnameVerificationEnabled, revocationCheckingStrategy); - case TRUST_ALL_CERTIFICATES -> SecurityPlanImpl.forAllCertificates( + case TRUST_ALL_CERTIFICATES -> forAllCertificates( hostnameVerificationEnabled, revocationCheckingStrategy); }; } else { return insecure(); } } + + public static SecurityPlan forAllCertificates( + boolean requiresHostnameVerification, RevocationCheckingStrategy revocationCheckingStrategy) + throws GeneralSecurityException { + var sslContext = SSLContext.getInstance("TLS"); + sslContext.init(new KeyManager[0], new TrustManager[] {new TrustAllTrustManager()}, null); + + return new SecurityPlanImpl(true, sslContext, requiresHostnameVerification); + } + + private static SecurityPlan forCustomCASignedCertificates( + List certFiles, + boolean requiresHostnameVerification, + RevocationCheckingStrategy revocationCheckingStrategy) + throws GeneralSecurityException, IOException { + var sslContext = configureSSLContext(certFiles, revocationCheckingStrategy); + return new SecurityPlanImpl(true, sslContext, requiresHostnameVerification); + } + + private static SecurityPlan forSystemCASignedCertificates( + boolean requiresHostnameVerification, RevocationCheckingStrategy revocationCheckingStrategy) + throws GeneralSecurityException, IOException { + var sslContext = configureSSLContext(Collections.emptyList(), revocationCheckingStrategy); + return new SecurityPlanImpl(true, sslContext, requiresHostnameVerification); + } + + private static SSLContext configureSSLContext( + List customCertFiles, RevocationCheckingStrategy revocationCheckingStrategy) + throws GeneralSecurityException, IOException { + var trustedKeyStore = KeyStore.getInstance(KeyStore.getDefaultType()); + trustedKeyStore.load(null, null); + + if (!customCertFiles.isEmpty()) { + // Certificate files are specified, so we will load the certificates in the file + loadX509Cert(customCertFiles, trustedKeyStore); + } else { + loadSystemCertificates(trustedKeyStore); + } + + var pkixBuilderParameters = configurePKIXBuilderParameters(trustedKeyStore, revocationCheckingStrategy); + + var sslContext = SSLContext.getInstance("TLS"); + var trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()); + + if (pkixBuilderParameters == null) { + trustManagerFactory.init(trustedKeyStore); + } else { + trustManagerFactory.init(new CertPathTrustManagerParameters(pkixBuilderParameters)); + } + + sslContext.init(new KeyManager[0], trustManagerFactory.getTrustManagers(), null); + + return sslContext; + } + + private static PKIXBuilderParameters configurePKIXBuilderParameters( + KeyStore trustedKeyStore, RevocationCheckingStrategy revocationCheckingStrategy) + throws InvalidAlgorithmParameterException, KeyStoreException { + PKIXBuilderParameters pkixBuilderParameters = null; + + if (requiresRevocationChecking(revocationCheckingStrategy)) { + // Configure certificate revocation checking (X509CertSelector() selects all certificates) + pkixBuilderParameters = new PKIXBuilderParameters(trustedKeyStore, new X509CertSelector()); + + // sets checking of stapled ocsp response + pkixBuilderParameters.setRevocationEnabled(true); + + // enables status_request extension in client hello + System.setProperty("jdk.tls.client.enableStatusRequestExtension", "true"); + + if (revocationCheckingStrategy.equals(VERIFY_IF_PRESENT)) { + // enables soft-fail behaviour if no stapled response found. + Security.setProperty("ocsp.enable", "true"); + } + } + return pkixBuilderParameters; + } + + private static void loadSystemCertificates(KeyStore trustedKeyStore) throws GeneralSecurityException { + // To customize the PKIXParameters we need to get hold of the default KeyStore, no other elegant way available + var tempFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()); + tempFactory.init((KeyStore) null); + + // Get hold of the default trust manager + var x509TrustManager = (X509TrustManager) Arrays.stream(tempFactory.getTrustManagers()) + .filter(trustManager -> trustManager instanceof X509TrustManager) + .findFirst() + .orElse(null); + + if (x509TrustManager == null) { + throw new CertificateException("No system certificates found"); + } else { + // load system default certificates into KeyStore + loadX509Cert(x509TrustManager.getAcceptedIssuers(), trustedKeyStore); + } + } + + public static SecurityPlan insecure() { + return new SecurityPlanImpl(false, null, false); + } + + private static class TrustAllTrustManager implements X509TrustManager { + public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException { + throw new CertificateException("All client connections to this client are forbidden."); + } + + public void checkServerTrusted(X509Certificate[] chain, String authType) { + // all fine, pass through + } + + public X509Certificate[] getAcceptedIssuers() { + return new X509Certificate[0]; + } + } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/spi/Connection.java b/driver/src/main/java/org/neo4j/driver/internal/spi/Connection.java deleted file mode 100644 index 5faa5a60d9..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/spi/Connection.java +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.spi; - -import static java.lang.String.format; - -import java.util.concurrent.CompletionStage; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.async.TerminationAwareStateLockingExecutor; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.Message; - -public interface Connection { - boolean isOpen(); - - void enableAutoRead(); - - void disableAutoRead(); - - void write(Message message, ResponseHandler handler); - - void writeAndFlush(Message message, ResponseHandler handler); - - boolean isTelemetryEnabled(); - - CompletionStage reset(Throwable throwable); - - CompletionStage release(); - - void terminateAndRelease(String reason); - - String serverAgent(); - - BoltServerAddress serverAddress(); - - BoltProtocol protocol(); - - void bindTerminationAwareStateLockingExecutor(TerminationAwareStateLockingExecutor executor); - - default AccessMode mode() { - throw new UnsupportedOperationException(format("%s does not support access mode.", getClass())); - } - - default DatabaseName databaseName() { - throw new UnsupportedOperationException(format("%s does not support database name.", getClass())); - } - - default String impersonatedUser() { - throw new UnsupportedOperationException(format("%s does not support impersonated user.", getClass())); - } -} 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 deleted file mode 100644 index 88d56cd045..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/spi/ConnectionProvider.java +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.spi; - -import java.util.concurrent.CompletionStage; -import org.neo4j.driver.internal.async.ConnectionContext; - -/** - * Interface defines a layer used by the driver to obtain connections. It is meant to be the only component that - * differs between "direct" and "routing" driver. - */ -public interface ConnectionProvider { - CompletionStage acquireConnection(ConnectionContext context); - - /** - * The validation of connectivity will happen with the default database. - */ - CompletionStage verifyConnectivity(); - - CompletionStage close(); - - CompletionStage supportsMultiDb(); - - CompletionStage supportsSessionAuth(); -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/summary/InternalServerInfo.java b/driver/src/main/java/org/neo4j/driver/internal/summary/InternalServerInfo.java index dc7549222d..9b2205993a 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/summary/InternalServerInfo.java +++ b/driver/src/main/java/org/neo4j/driver/internal/summary/InternalServerInfo.java @@ -17,8 +17,8 @@ package org.neo4j.driver.internal.summary; import java.util.Objects; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.messaging.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; import org.neo4j.driver.summary.ServerInfo; public class InternalServerInfo implements ServerInfo { diff --git a/driver/src/main/java/org/neo4j/driver/internal/telemetry/ApiTelemetryWork.java b/driver/src/main/java/org/neo4j/driver/internal/telemetry/ApiTelemetryWork.java index bb13a84b0a..d9ff5ee4f2 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/telemetry/ApiTelemetryWork.java +++ b/driver/src/main/java/org/neo4j/driver/internal/telemetry/ApiTelemetryWork.java @@ -16,67 +16,47 @@ */ package org.neo4j.driver.internal.telemetry; -import static org.neo4j.driver.internal.util.Futures.futureCompletingConsumer; - import java.util.Objects; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionStage; import java.util.concurrent.atomic.AtomicBoolean; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.spi.Connection; - -public class ApiTelemetryWork { - private final TelemetryApi telemetryApi; - private final AtomicBoolean completedWithSuccess; - - private final AtomicBoolean enabled; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; +public record ApiTelemetryWork(TelemetryApi telemetryApi, AtomicBoolean enabled, AtomicBoolean acknowledged) { public ApiTelemetryWork(TelemetryApi telemetryApi) { - this.telemetryApi = telemetryApi; - this.completedWithSuccess = new AtomicBoolean(false); - this.enabled = new AtomicBoolean(true); + this(telemetryApi, new AtomicBoolean(), new AtomicBoolean()); } public void setEnabled(boolean enabled) { this.enabled.set(enabled); } - public CompletionStage execute(Connection connection, BoltProtocol protocol) { - var future = new CompletableFuture(); - if (connection.isTelemetryEnabled() && enabled.get() && !this.completedWithSuccess.get()) { - protocol.telemetry(connection, telemetryApi.getValue()) - .thenAccept((unused) -> completedWithSuccess.set(true)) - .whenComplete(futureCompletingConsumer(future)); - } else { - future.complete(null); - } - return future; + public void acknowledge() { + this.acknowledged.set(true); } - @Override - public boolean equals(Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; + public CompletionStage pipelineTelemetryIfEnabled(BoltConnection connection) { + if (enabled.get() && connection.telemetrySupported() && !(acknowledged.get())) { + return connection.telemetry(telemetryApi); + } else { + return CompletableFuture.completedStage(connection); } - var that = (ApiTelemetryWork) o; - return telemetryApi == that.telemetryApi - && Objects.equals(completedWithSuccess.get(), that.completedWithSuccess.get()) - && Objects.equals(enabled.get(), that.enabled.get()); } + // for testing @Override - public String toString() { - return "ApiTelemetryWork{" + "telemetryApi=" - + telemetryApi + ", completedWithSuccess=" - + completedWithSuccess.get() + ", enabled=" - + enabled.get() + '}'; + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + ApiTelemetryWork that = (ApiTelemetryWork) o; + return Objects.equals(enabled.get(), that.enabled.get()) + && telemetryApi == that.telemetryApi + && Objects.equals(acknowledged.get(), that.acknowledged.get()); } @Override public int hashCode() { - return Objects.hash(telemetryApi, completedWithSuccess, enabled); + return Objects.hash(telemetryApi, enabled.get(), acknowledged.get()); } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/util/DriverInfoUtil.java b/driver/src/main/java/org/neo4j/driver/internal/util/DriverInfoUtil.java index b265db6814..57d85e354b 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/util/DriverInfoUtil.java +++ b/driver/src/main/java/org/neo4j/driver/internal/util/DriverInfoUtil.java @@ -20,7 +20,7 @@ import java.util.Optional; import org.neo4j.driver.Session; -import org.neo4j.driver.internal.BoltAgent; +import org.neo4j.driver.internal.bolt.api.BoltAgent; public class DriverInfoUtil { public static BoltAgent boltAgent() { @@ -45,7 +45,7 @@ public static BoltAgent boltAgent() { productInfo, platformBuilder.isEmpty() ? null : platformBuilder.toString(), language.orElse(null), - languageDetails.isEmpty() ? null : languageDetails.toString()); + languageDetails.map(StringBuilder::toString).orElse(null)); } /** diff --git a/driver/src/main/java/org/neo4j/driver/internal/util/Futures.java b/driver/src/main/java/org/neo4j/driver/internal/util/Futures.java index 69b04b1ba7..844cbe6cbd 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/util/Futures.java +++ b/driver/src/main/java/org/neo4j/driver/internal/util/Futures.java @@ -19,7 +19,6 @@ import static java.util.concurrent.CompletableFuture.completedFuture; import static org.neo4j.driver.internal.util.ErrorUtil.addSuppressed; -import java.util.Objects; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionException; import java.util.concurrent.CompletionStage; @@ -27,9 +26,7 @@ import java.util.concurrent.Future; import java.util.function.BiConsumer; import java.util.function.BiFunction; -import java.util.function.Function; -import java.util.function.Supplier; -import org.neo4j.driver.internal.async.connection.EventLoopGroupFactory; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.EventLoopGroupFactory; public final class Futures { private static final CompletableFuture COMPLETED_WITH_NULL = completedFuture(null); @@ -41,47 +38,6 @@ public static CompletableFuture completedWithNull() { return (CompletableFuture) COMPLETED_WITH_NULL; } - public static void completeWithNullIfNoError(CompletableFuture future, Throwable error) { - if (error != null) { - future.completeExceptionally(error); - } else { - future.complete(null); - } - } - - public static CompletionStage asCompletionStage(io.netty.util.concurrent.Future future) { - var result = new CompletableFuture(); - return asCompletionStage(future, result); - } - - public static CompletionStage asCompletionStage( - io.netty.util.concurrent.Future future, CompletableFuture result) { - if (future.isCancelled()) { - result.cancel(true); - } else if (future.isSuccess()) { - result.complete(future.getNow()); - } else if (future.cause() != null) { - result.completeExceptionally(future.cause()); - } else { - future.addListener(ignore -> { - if (future.isCancelled()) { - result.cancel(true); - } else if (future.isSuccess()) { - result.complete(future.getNow()); - } else { - result.completeExceptionally(future.cause()); - } - }); - } - return result; - } - - public static CompletableFuture failedFuture(Throwable error) { - var result = new CompletableFuture(); - result.completeExceptionally(error); - return result; - } - public static V blockingGet(CompletionStage stage) { return blockingGet(stage, Futures::noOpInterruptHandler); } @@ -119,15 +75,6 @@ public static T getNow(CompletionStage stage) { return stage.toCompletableFuture().getNow(null); } - public static T joinNowOrElseThrow( - CompletableFuture future, Supplier exceptionSupplier) { - if (future.isDone()) { - return future.join(); - } else { - throw exceptionSupplier.get(); - } - } - /** * Helper method to extract cause of a {@link CompletionException}. *

@@ -180,38 +127,6 @@ public static CompletionException combineErrors(Throwable error1, Throwable erro } } - /** - * Given a future, if the future completes successfully then return a new completed future with the completed value. - * Otherwise if the future completes with an error, then this method first saves the error in the error recorder, and then continues with the onErrorAction. - * @param future the future. - * @param errorRecorder saves error if the given future completes with an error. - * @param onErrorAction continues the future with this action if the future completes with an error. - * @param type - * @return a new completed future with the same completed value if the given future completes successfully, otherwise continues with the onErrorAction. - */ - @SuppressWarnings("ThrowableNotThrown") - public static CompletableFuture onErrorContinue( - CompletableFuture future, - Throwable errorRecorder, - Function> onErrorAction) { - Objects.requireNonNull(future); - return future.handle((value, error) -> { - if (error != null) { - // record error - Futures.combineErrors(errorRecorder, error); - return new CompletionResult(null, error); - } - return new CompletionResult<>(value, null); - }) - .thenCompose(result -> { - if (result.value != null) { - return completedFuture(result.value); - } else { - return onErrorAction.apply(result.error); - } - }); - } - public static BiConsumer futureCompletingConsumer(CompletableFuture future) { return (value, throwable) -> { if (throwable != null) { @@ -222,8 +137,6 @@ public static BiConsumer futureCompletingConsumer(CompletableF }; } - private record CompletionResult(T value, Throwable error) {} - private static void safeRun(Runnable runnable) { try { runnable.run(); diff --git a/driver/src/main/java/org/neo4j/driver/internal/util/LockUtil.java b/driver/src/main/java/org/neo4j/driver/internal/util/LockUtil.java index f8e9bda7e1..271d914658 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/util/LockUtil.java +++ b/driver/src/main/java/org/neo4j/driver/internal/util/LockUtil.java @@ -16,8 +16,6 @@ */ package org.neo4j.driver.internal.util; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionStage; import java.util.concurrent.locks.Lock; import java.util.function.Supplier; @@ -40,13 +38,6 @@ public static T executeWithLock(Lock lock, Supplier supplier) { } } - public static void executeWithLockAsync(Lock lock, Supplier> stageSupplier) { - lock(lock); - CompletableFuture.completedFuture(lock) - .thenCompose(ignored -> stageSupplier.get()) - .whenComplete((ignored, throwable) -> unlock(lock)); - } - /** * Invokes {@link Lock#lock()} on the supplied {@link Lock}. *

diff --git a/driver/src/main/java/org/neo4j/driver/internal/util/MetadataExtractor.java b/driver/src/main/java/org/neo4j/driver/internal/util/MetadataExtractor.java index 2efaeff17d..b8eae5d08a 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/util/MetadataExtractor.java +++ b/driver/src/main/java/org/neo4j/driver/internal/util/MetadataExtractor.java @@ -17,22 +17,15 @@ package org.neo4j.driver.internal.util; import static org.neo4j.driver.internal.summary.InternalDatabaseInfo.DEFAULT_DATABASE_INFO; -import static org.neo4j.driver.internal.types.InternalTypeSystem.TYPE_SYSTEM; import java.util.Collections; -import java.util.HashSet; import java.util.List; import java.util.Map; -import java.util.Set; import java.util.function.Function; -import org.neo4j.driver.Bookmark; import org.neo4j.driver.Query; import org.neo4j.driver.Value; import org.neo4j.driver.exceptions.ProtocolException; -import org.neo4j.driver.exceptions.UntrustedServerException; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.spi.Connection; +import org.neo4j.driver.internal.bolt.api.BoltConnection; import org.neo4j.driver.internal.summary.InternalDatabaseInfo; import org.neo4j.driver.internal.summary.InternalNotification; import org.neo4j.driver.internal.summary.InternalPlan; @@ -53,51 +46,16 @@ public class MetadataExtractor { private static final String UNEXPECTED_TYPE_MSG_FMT = "Unexpected query type '%s', consider updating the driver"; private static final Function UNEXPECTED_TYPE_EXCEPTION_SUPPLIER = (type) -> new ProtocolException(String.format(UNEXPECTED_TYPE_MSG_FMT, type)); - private final String resultAvailableAfterMetadataKey; private final String resultConsumedAfterMetadataKey; - public MetadataExtractor(String resultAvailableAfterMetadataKey, String resultConsumedAfterMetadataKey) { - this.resultAvailableAfterMetadataKey = resultAvailableAfterMetadataKey; + public MetadataExtractor(String resultConsumedAfterMetadataKey) { this.resultConsumedAfterMetadataKey = resultConsumedAfterMetadataKey; } - public QueryKeys extractQueryKeys(Map metadata) { - var keysValue = metadata.get("fields"); - if (keysValue != null) { - if (!keysValue.isEmpty()) { - var keys = new QueryKeys(keysValue.size()); - for (var value : keysValue.values()) { - keys.add(value.asString()); - } - - return keys; - } - } - return QueryKeys.empty(); - } - - public long extractQueryId(Map metadata) { - var queryId = metadata.get("qid"); - if (queryId != null) { - return queryId.asLong(); - } - return ABSENT_QUERY_ID; - } - - public long extractResultAvailableAfter(Map metadata) { - var resultAvailableAfterValue = metadata.get(resultAvailableAfterMetadataKey); - if (resultAvailableAfterValue != null) { - return resultAvailableAfterValue.asLong(); - } - return -1; - } - public ResultSummary extractSummary( - Query query, Connection connection, long resultAvailableAfter, Map metadata) { + Query query, BoltConnection connection, long resultAvailableAfter, Map metadata) { ServerInfo serverInfo = new InternalServerInfo( - connection.serverAgent(), - connection.serverAddress(), - connection.protocol().version()); + connection.serverAgent(), connection.serverAddress(), connection.protocolVersion()); var dbInfo = extractDatabaseInfo(metadata); return new InternalResultSummary( query, @@ -112,25 +70,6 @@ public ResultSummary extractSummary( extractResultConsumedAfter(metadata, resultConsumedAfterMetadataKey)); } - public static DatabaseBookmark extractDatabaseBookmark(Map metadata) { - var databaseName = extractDatabaseInfo(metadata).name(); - var bookmark = extractBookmark(metadata); - return new DatabaseBookmark(databaseName, bookmark); - } - - public static Value extractServer(Map metadata) { - var versionValue = metadata.get("server"); - if (versionValue == null || versionValue.isNull()) { - throw new UntrustedServerException("Server provides no product identifier"); - } - var serverAgent = versionValue.asString(); - if (!serverAgent.startsWith("Neo4j/")) { - throw new UntrustedServerException( - "Server does not identify as a genuine Neo4j instance: '" + serverAgent + "'"); - } - return versionValue; - } - static DatabaseInfo extractDatabaseInfo(Map metadata) { var dbValue = metadata.get("db"); if (dbValue == null || dbValue.isNull()) { @@ -140,15 +79,6 @@ static DatabaseInfo extractDatabaseInfo(Map metadata) { } } - static Bookmark extractBookmark(Map metadata) { - var bookmarkValue = metadata.get("bookmark"); - Bookmark bookmark = null; - if (bookmarkValue != null && !bookmarkValue.isNull() && bookmarkValue.hasType(TYPE_SYSTEM.STRING())) { - bookmark = InternalBookmark.parse(bookmarkValue.asString()); - } - return bookmark; - } - private static QueryType extractQueryType(Map metadata) { var typeValue = metadata.get("type"); if (typeValue != null) { @@ -213,13 +143,4 @@ private static long extractResultConsumedAfter(Map metadata, Stri } return -1; } - - public static Set extractBoltPatches(Map metadata) { - var boltPatch = metadata.get("patch_bolt"); - if (boltPatch != null && !boltPatch.isNull()) { - return new HashSet<>(boltPatch.asList(Value::asString)); - } else { - return Collections.emptySet(); - } - } } 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 deleted file mode 100644 index e8ba36db9a..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/util/SessionAuthUtil.java +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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/main/java/org/neo4j/driver/net/ServerAddress.java b/driver/src/main/java/org/neo4j/driver/net/ServerAddress.java index 66ddcfb0d7..9ccf08c2c8 100644 --- a/driver/src/main/java/org/neo4j/driver/net/ServerAddress.java +++ b/driver/src/main/java/org/neo4j/driver/net/ServerAddress.java @@ -16,7 +16,7 @@ */ package org.neo4j.driver.net; -import org.neo4j.driver.internal.BoltServerAddress; +import org.neo4j.driver.internal.InternalServerAddress; /** * Represents a host and port. Host can either be an IP address or a DNS name. @@ -45,6 +45,6 @@ public interface ServerAddress { * @return new server address with the specified host and port. */ static ServerAddress of(String host, int port) { - return new BoltServerAddress(host, port); + return new InternalServerAddress(host, port); } } diff --git a/driver/src/test/java/org/neo4j/driver/ConfigTest.java b/driver/src/test/java/org/neo4j/driver/ConfigTest.java index 64773d17e7..a3eed12826 100644 --- a/driver/src/test/java/org/neo4j/driver/ConfigTest.java +++ b/driver/src/test/java/org/neo4j/driver/ConfigTest.java @@ -26,7 +26,6 @@ import static org.neo4j.driver.RevocationCheckingStrategy.NO_CHECKS; import static org.neo4j.driver.RevocationCheckingStrategy.STRICT; import static org.neo4j.driver.RevocationCheckingStrategy.VERIFY_IF_PRESENT; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.DEFAULT_FETCH_SIZE; import java.io.File; import java.io.IOException; @@ -305,7 +304,7 @@ void shouldNotAllowNullResolver() { @Test void shouldDefaultToDefaultFetchSize() { var config = Config.defaultConfig(); - assertEquals(DEFAULT_FETCH_SIZE, config.fetchSize()); + assertEquals(1000, config.fetchSize()); } @ParameterizedTest diff --git a/driver/src/test/java/org/neo4j/driver/GraphDatabaseTest.java b/driver/src/test/java/org/neo4j/driver/GraphDatabaseTest.java index 83f035d965..f78142567b 100644 --- a/driver/src/test/java/org/neo4j/driver/GraphDatabaseTest.java +++ b/driver/src/test/java/org/neo4j/driver/GraphDatabaseTest.java @@ -17,6 +17,7 @@ package org.neo4j.driver; import static java.util.concurrent.TimeUnit.MILLISECONDS; +import static java.util.concurrent.TimeUnit.SECONDS; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.containsString; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -28,6 +29,7 @@ import java.io.IOException; import java.net.ServerSocket; import java.net.URI; +import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.neo4j.driver.exceptions.ServiceUnavailableException; import org.neo4j.driver.internal.security.StaticAuthTokenManager; @@ -52,7 +54,9 @@ void shouldRespondToInterruptsWhenConnectingToUnresponsiveServer() throws Except TestUtil.interruptWhenInWaitingState(Thread.currentThread()); @SuppressWarnings("resource") - final var driver = GraphDatabase.driver("bolt://localhost:" + serverSocket.getLocalPort()); + final var driver = GraphDatabase.driver( + "bolt://localhost:" + serverSocket.getLocalPort(), + Config.builder().withConnectionTimeout(1, SECONDS).build()); try { assertThrows(ServiceUnavailableException.class, driver::verifyConnectivity); } finally { @@ -92,6 +96,7 @@ void shouldFailToCreateUnencryptedDriverWhenServerDoesNotRespond() throws IOExce } @Test + @Disabled("TLS actually fails, the test setup is not valid") void shouldFailToCreateEncryptedDriverWhenServerDoesNotRespond() throws IOException { testFailureWhenServerDoesNotRespond(true); } diff --git a/driver/src/test/java/org/neo4j/driver/PackageTests.java b/driver/src/test/java/org/neo4j/driver/PackageTests.java new file mode 100644 index 0000000000..96efe29dc6 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/PackageTests.java @@ -0,0 +1,161 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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 static com.tngtech.archunit.core.domain.JavaClass.Predicates.assignableTo; +import static com.tngtech.archunit.core.domain.JavaClass.Predicates.resideInAPackage; +import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes; + +import com.tngtech.archunit.base.DescribedPredicate; +import com.tngtech.archunit.core.domain.JavaClass; +import com.tngtech.archunit.core.domain.JavaClasses; +import com.tngtech.archunit.core.importer.ClassFileImporter; +import com.tngtech.archunit.core.importer.ImportOption; +import com.tngtech.archunit.library.Architectures; +import java.util.stream.Stream; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.neo4j.driver.exceptions.Neo4jException; +import org.neo4j.driver.exceptions.UntrustedServerException; +import org.neo4j.driver.internal.DriverFactory; +import org.neo4j.driver.internal.InternalNode; +import org.neo4j.driver.internal.InternalPath; +import org.neo4j.driver.internal.InternalRelationship; +import org.neo4j.driver.internal.bolt.basicimpl.NettyBoltConnectionProvider; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.BootstrapFactory; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.EventLoopGroupFactory; +import org.neo4j.driver.internal.bolt.basicimpl.logging.ChannelActivityLogger; +import org.neo4j.driver.internal.bolt.pooledimpl.PooledBoltConnectionProvider; +import org.neo4j.driver.internal.bolt.routedimpl.RoutedBoltConnectionProvider; +import org.neo4j.driver.internal.retry.ExponentialBackoffRetryLogic; +import org.neo4j.driver.internal.types.InternalTypeSystem; +import org.neo4j.driver.internal.types.TypeConstructor; +import org.neo4j.driver.internal.util.ErrorUtil; +import org.neo4j.driver.internal.util.Futures; +import org.neo4j.driver.types.IsoDuration; +import org.neo4j.driver.types.MapAccessor; +import org.neo4j.driver.types.Node; +import org.neo4j.driver.types.Point; +import org.neo4j.driver.types.Type; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +class PackageTests { + private JavaClasses allClasses; + + @BeforeAll + void importAllClasses() { + this.allClasses = new ClassFileImporter() + .withImportOption(ImportOption.Predefined.DO_NOT_INCLUDE_TESTS) + .importPackages("org.neo4j.driver.."); + } + + @Test + void nettyShouldOnlyBeAccessedByBasicBoltImpl() { + var rule = classes() + .that() + .resideInAPackage("io.netty..") + .should() + .onlyBeAccessed() + .byClassesThat(resideInAPackage("org.neo4j.driver.internal.bolt.basicimpl..") + .or(resideInAPackage("io.netty..")) + .or(assignableTo(DriverFactory.class)) + .or(assignableTo(ExponentialBackoffRetryLogic.class))); + rule.check(new ClassFileImporter() + .withImportOption(ImportOption.Predefined.DO_NOT_INCLUDE_TESTS) + .importPackages("org.neo4j.driver..", "io.netty..")); + } + + @Test + void boltLayerShouldBeSelfContained() { + // temporarily whitelisted classes + var whitelistedClasses = Stream.of( + // values + Value.class, + Value[].class, + Values.class, + Type.class, + TypeConstructor.class, + Node.class, + Record.class, + Point.class, + MapAccessor.class, + InternalNode.class, + InternalRelationship.class, + InternalPath.class, + InternalPath.SelfContainedSegment.class, + IsoDuration.class, + InternalTypeSystem.class, + // exceptions + Neo4jException.class, + ErrorUtil.class, + UntrustedServerException.class) + .map(JavaClass.Predicates::assignableTo) + .reduce((one, two) -> DescribedPredicate.or(one, two)) + .get(); + + Architectures.layeredArchitecture() + .consideringOnlyDependenciesInAnyPackage("org.neo4j.driver..") + .layer("Bolt") + .definedBy("..internal.bolt..") + .layer("Whitelisted") + .definedBy(whitelistedClasses) + .whereLayer("Bolt") + .mayOnlyAccessLayers("Whitelisted") + .check(allClasses); + } + + @Test + void boltBasicImplLayerShouldNotBeAccessedDirectly() { + Architectures.layeredArchitecture() + .consideringOnlyDependenciesInAnyPackage("org.neo4j.driver..") + .layer("Bolt basic impl") + .definedBy("..internal.bolt.basicimpl..") + .whereLayer("Bolt basic impl") + .mayNotBeAccessedByAnyLayer() + .ignoreDependency(DriverFactory.class, BootstrapFactory.class) + .ignoreDependency(DriverFactory.class, NettyBoltConnectionProvider.class) + .ignoreDependency(ChannelActivityLogger.class, ChannelAttributes.class) + .ignoreDependency(Futures.class, EventLoopGroupFactory.class) + .check(allClasses); + } + + @Test + void boltPooledImplLayerShouldNotBeAccessedDirectly() { + Architectures.layeredArchitecture() + .consideringOnlyDependenciesInAnyPackage("org.neo4j.driver..") + .layer("Bolt pooled impl") + .definedBy("..internal.bolt.pooledimpl..") + .whereLayer("Bolt pooled impl") + .mayNotBeAccessedByAnyLayer() + .ignoreDependency(DriverFactory.class, PooledBoltConnectionProvider.class) + .check(allClasses); + } + + @Test + void boltRoutedImplLayerShouldNotBeAccessedDirectly() { + Architectures.layeredArchitecture() + .consideringOnlyDependenciesInAnyPackage("org.neo4j.driver..") + .layer("Bolt routed impl") + .definedBy("..internal.bolt.routedimpl..") + .whereLayer("Bolt routed impl") + .mayNotBeAccessedByAnyLayer() + .ignoreDependency(DriverFactory.class, RoutedBoltConnectionProvider.class) + .check(allClasses); + } +} diff --git a/driver/src/test/java/org/neo4j/driver/ParametersTest.java b/driver/src/test/java/org/neo4j/driver/ParametersTest.java index db58a95cec..264494d7f7 100644 --- a/driver/src/test/java/org/neo4j/driver/ParametersTest.java +++ b/driver/src/test/java/org/neo4j/driver/ParametersTest.java @@ -25,8 +25,7 @@ import static org.junit.jupiter.api.Assumptions.assumeTrue; import static org.mockito.Mockito.mock; import static org.neo4j.driver.Values.parameters; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; import static org.neo4j.driver.internal.util.ValueFactory.emptyNodeValue; import static org.neo4j.driver.internal.util.ValueFactory.emptyRelationshipValue; @@ -41,8 +40,8 @@ import org.neo4j.driver.internal.InternalRecord; import org.neo4j.driver.internal.InternalSession; import org.neo4j.driver.internal.async.NetworkSession; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; import org.neo4j.driver.internal.retry.RetryLogic; -import org.neo4j.driver.internal.spi.ConnectionProvider; class ParametersTest { static Stream addressesToParse() { @@ -100,7 +99,7 @@ void shouldNotBePossibleToUseInvalidParametersViaRecord(Object obj, String expec } private Session mockedSession() { - var provider = mock(ConnectionProvider.class); + var provider = mock(BoltConnectionProvider.class); var retryLogic = mock(RetryLogic.class); var session = new NetworkSession( provider, @@ -109,12 +108,14 @@ private Session mockedSession() { AccessMode.WRITE, Collections.emptySet(), null, - UNLIMITED_FETCH_SIZE, + -1, DEV_NULL_LOGGING, mock(BookmarkManager.class), + Config.defaultConfig().notificationConfig(), + Config.defaultConfig().notificationConfig(), null, - null, - true); + false, + mock(AuthTokenManager.class)); 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 deleted file mode 100644 index 5294ee1292..0000000000 --- a/driver/src/test/java/org/neo4j/driver/integration/ChannelConnectorImplIT.java +++ /dev/null @@ -1,231 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.runAsync; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.instanceOf; -import static org.hamcrest.Matchers.startsWith; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -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.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; -import io.netty.handler.ssl.SslHandler; -import java.io.IOException; -import java.io.UncheckedIOException; -import java.net.ServerSocket; -import java.security.GeneralSecurityException; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeUnit; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.RegisterExtension; -import org.neo4j.driver.AuthTokenManager; -import org.neo4j.driver.AuthTokens; -import org.neo4j.driver.RevocationCheckingStrategy; -import org.neo4j.driver.exceptions.AuthenticationException; -import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.ConnectionSettings; -import org.neo4j.driver.internal.DefaultDomainNameResolver; -import org.neo4j.driver.internal.async.connection.BootstrapFactory; -import org.neo4j.driver.internal.async.connection.ChannelConnector; -import org.neo4j.driver.internal.async.connection.ChannelConnectorImpl; -import org.neo4j.driver.internal.async.inbound.ConnectTimeoutHandler; -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; - -@ParallelizableIT -class ChannelConnectorImplIT { - @RegisterExtension - static final DatabaseExtension neo4j = new DatabaseExtension(); - - private Bootstrap bootstrap; - - @BeforeEach - void setUp() { - bootstrap = BootstrapFactory.newBootstrap(1); - } - - @AfterEach - void tearDown() { - if (bootstrap != null) { - bootstrap.config().group().shutdownGracefully().syncUninterruptibly(); - } - } - - @Test - void shouldConnect() throws Exception { - ChannelConnector connector = newConnector(neo4j.authTokenManager()); - - var channelFuture = connector.connect(neo4j.address(), bootstrap); - assertTrue(channelFuture.await(10, TimeUnit.SECONDS)); - var channel = channelFuture.channel(); - - assertNull(channelFuture.get()); - assertTrue(channel.isActive()); - } - - @Test - void shouldSetupHandlers() throws Exception { - ChannelConnector connector = newConnector(neo4j.authTokenManager(), trustAllCertificates(), 10_000); - - var channelFuture = connector.connect(neo4j.address(), bootstrap); - assertTrue(channelFuture.await(10, TimeUnit.SECONDS)); - - var channel = channelFuture.channel(); - var pipeline = channel.pipeline(); - assertTrue(channel.isActive()); - - assertNotNull(pipeline.get(SslHandler.class)); - assertNull(pipeline.get(ConnectTimeoutHandler.class)); - } - - @Test - void shouldFailToConnectToWrongAddress() throws Exception { - ChannelConnector connector = newConnector(neo4j.authTokenManager()); - - var channelFuture = connector.connect(new BoltServerAddress("wrong-localhost"), bootstrap); - assertTrue(channelFuture.await(10, TimeUnit.SECONDS)); - var channel = channelFuture.channel(); - - var e = assertThrows(ExecutionException.class, channelFuture::get); - - assertThat(e.getCause(), instanceOf(ServiceUnavailableException.class)); - assertThat(e.getCause().getMessage(), startsWith("Unable to connect")); - assertFalse(channel.isActive()); - } - - // Beginning with Bolt 5.1 auth is not sent on HELLO message. - @DisabledOnNeo4jWith(BOLT_V51) - @Test - void shouldFailToConnectWithWrongCredentials() throws Exception { - var authToken = AuthTokens.basic("neo4j", "wrong-password"); - ChannelConnector connector = newConnector(new StaticAuthTokenManager(authToken)); - - var channelFuture = connector.connect(neo4j.address(), bootstrap); - assertTrue(channelFuture.await(10, TimeUnit.SECONDS)); - var channel = channelFuture.channel(); - - var e = assertThrows(ExecutionException.class, channelFuture::get); - assertThat(e.getCause(), instanceOf(AuthenticationException.class)); - assertFalse(channel.isActive()); - } - - @Test - void shouldEnforceConnectTimeout() throws Exception { - ChannelConnector connector = newConnector(neo4j.authTokenManager(), 1000); - - // try connect to a non-routable ip address 10.0.0.0, it will never respond - var channelFuture = connector.connect(new BoltServerAddress("10.0.0.0"), bootstrap); - - assertThrows(ServiceUnavailableException.class, () -> await(channelFuture)); - } - - @Test - void shouldFailWhenProtocolNegotiationTakesTooLong() throws Exception { - // run without TLS so that Bolt handshake is the very first operation after connection is established - testReadTimeoutOnConnect(SecurityPlanImpl.insecure()); - } - - @Test - void shouldFailWhenTLSHandshakeTakesTooLong() throws Exception { - // run with TLS so that TLS handshake is the very first operation after connection is established - testReadTimeoutOnConnect(trustAllCertificates()); - } - - @Test - @SuppressWarnings("resource") - void shouldThrowServiceUnavailableExceptionOnFailureDuringConnect() throws Exception { - var server = new ServerSocket(0); - var address = new BoltServerAddress("localhost", server.getLocalPort()); - - runAsync(() -> { - try { - // wait for a connection - var socket = server.accept(); - // and terminate it immediately so that client gets a "reset by peer" IOException - socket.close(); - server.close(); - } catch (IOException e) { - throw new UncheckedIOException(e); - } - }); - - ChannelConnector connector = newConnector(neo4j.authTokenManager()); - var channelFuture = connector.connect(address, bootstrap); - - // connect operation should fail with ServiceUnavailableException - assertThrows(ServiceUnavailableException.class, () -> await(channelFuture)); - } - - private void testReadTimeoutOnConnect(SecurityPlan securityPlan) throws IOException { - try (var server = new ServerSocket(0)) // server that accepts connections but does not reply - { - var timeoutMillis = 1_000; - var address = new BoltServerAddress("localhost", server.getLocalPort()); - ChannelConnector connector = newConnector(neo4j.authTokenManager(), securityPlan, timeoutMillis); - - var channelFuture = connector.connect(address, bootstrap); - - var e = assertThrows(ServiceUnavailableException.class, () -> await(channelFuture)); - assertEquals(e.getMessage(), "Unable to establish connection in " + timeoutMillis + "ms"); - } - } - - private ChannelConnectorImpl newConnector(AuthTokenManager authTokenManager) throws Exception { - return newConnector(authTokenManager, Integer.MAX_VALUE); - } - - private ChannelConnectorImpl newConnector(AuthTokenManager authTokenManager, int connectTimeoutMillis) - throws Exception { - return newConnector(authTokenManager, trustAllCertificates(), connectTimeoutMillis); - } - - private ChannelConnectorImpl newConnector( - AuthTokenManager authTokenManager, SecurityPlan securityPlan, int connectTimeoutMillis) { - var settings = new ConnectionSettings(authTokenManager, "test", connectTimeoutMillis); - return new ChannelConnectorImpl( - settings, - securityPlan, - DEV_NULL_LOGGING, - new FakeClock(), - RoutingContext.EMPTY, - DefaultDomainNameResolver.getInstance(), - null, - BoltAgentUtil.VALUE); - } - - private static SecurityPlan trustAllCertificates() throws GeneralSecurityException { - return SecurityPlanImpl.forAllCertificates(false, RevocationCheckingStrategy.NO_CHECKS); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/integration/ConnectionHandlingIT.java b/driver/src/test/java/org/neo4j/driver/integration/ConnectionHandlingIT.java deleted file mode 100644 index 7998ab3730..0000000000 --- a/driver/src/test/java/org/neo4j/driver/integration/ConnectionHandlingIT.java +++ /dev/null @@ -1,505 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.Collections.singletonList; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.mockito.Mockito.atLeastOnce; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.neo4j.driver.Values.parameters; -import static org.neo4j.driver.internal.util.Neo4jFeature.BOLT_V4; -import static org.neo4j.driver.testutil.TestUtil.await; - -import io.netty.bootstrap.Bootstrap; -import java.time.Clock; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionStage; -import java.util.concurrent.atomic.AtomicReference; -import java.util.function.Function; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -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; -import org.neo4j.driver.QueryRunner; -import org.neo4j.driver.Record; -import org.neo4j.driver.Result; -import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.ConnectionSettings; -import org.neo4j.driver.internal.DriverFactory; -import org.neo4j.driver.internal.async.connection.ChannelConnector; -import org.neo4j.driver.internal.async.pool.ConnectionPoolImpl; -import org.neo4j.driver.internal.async.pool.PoolSettings; -import org.neo4j.driver.internal.cluster.RoutingContext; -import org.neo4j.driver.internal.metrics.DevNullMetricsListener; -import org.neo4j.driver.internal.metrics.MetricsProvider; -import org.neo4j.driver.internal.security.SecurityPlan; -import org.neo4j.driver.internal.security.SecurityPlanImpl; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ConnectionPool; -import org.neo4j.driver.internal.util.EnabledOnNeo4jWith; -import org.neo4j.driver.reactive.RxSession; -import org.neo4j.driver.reactive.RxTransaction; -import org.neo4j.driver.testutil.DatabaseExtension; -import org.neo4j.driver.testutil.ParallelizableIT; -import org.reactivestreams.Publisher; -import reactor.core.publisher.Flux; -import reactor.core.publisher.Mono; -import reactor.test.StepVerifier; - -@ParallelizableIT -class ConnectionHandlingIT { - @RegisterExtension - static final DatabaseExtension neo4j = new DatabaseExtension(); - - private Driver driver; - private MemorizingConnectionPool connectionPool; - - @BeforeEach - void createDriver() { - var driverFactory = new DriverFactoryWithConnectionPool(); - var authTokenProvider = neo4j.authTokenManager(); - driver = driverFactory.newInstance( - neo4j.uri(), - authTokenProvider, - Config.builder().withFetchSize(1).build(), - SecurityPlanImpl.insecure(), - null, - null); - connectionPool = driverFactory.connectionPool; - connectionPool.startMemorizing(); // start memorizing connections after driver creation - } - - @AfterEach - void closeDriver() { - driver.close(); - } - - @Test - void connectionUsedForSessionRunReturnedToThePoolWhenResultConsumed() { - var result = createNodesInNewSession(12); - - var connection1 = connectionPool.lastAcquiredConnectionSpy; - verify(connection1, never()).release(); - - result.consume(); - - var connection2 = connectionPool.lastAcquiredConnectionSpy; - assertSame(connection1, connection2); - verify(connection1).release(); - } - - @Test - void connectionUsedForSessionRunReturnedToThePoolWhenResultSummaryObtained() { - var result = createNodesInNewSession(5); - - var connection1 = connectionPool.lastAcquiredConnectionSpy; - verify(connection1, never()).release(); - - var summary = result.consume(); - - assertEquals(5, summary.counters().nodesCreated()); - var connection2 = connectionPool.lastAcquiredConnectionSpy; - assertSame(connection1, connection2); - verify(connection1).release(); - } - - @Test - void connectionUsedForSessionRunReturnedToThePoolWhenResultFetchedInList() { - var result = createNodesInNewSession(2); - - var connection1 = connectionPool.lastAcquiredConnectionSpy; - verify(connection1, never()).release(); - - var records = result.list(); - assertEquals(2, records.size()); - - var connection2 = connectionPool.lastAcquiredConnectionSpy; - assertSame(connection1, connection2); - verify(connection1).release(); - } - - @Test - void connectionUsedForSessionRunReturnedToThePoolWhenSingleRecordFetched() { - var result = createNodesInNewSession(1); - - assertNotNull(result.single()); - - var connection = connectionPool.lastAcquiredConnectionSpy; - verify(connection).release(); - } - - @Test - void connectionUsedForSessionRunReturnedToThePoolWhenResultFetchedAsIterator() { - var result = createNodesInNewSession(6); - - var connection1 = connectionPool.lastAcquiredConnectionSpy; - verify(connection1, never()).release(); - - var seenRecords = 0; - while (result.hasNext()) { - assertNotNull(result.next()); - seenRecords++; - } - assertEquals(6, seenRecords); - - var connection2 = connectionPool.lastAcquiredConnectionSpy; - assertSame(connection1, connection2); - verify(connection1).release(); - } - - @Test - void connectionUsedForSessionRunReturnedToThePoolOnServerFailure() { - try (var session = driver.session()) { - // provoke division by zero - assertThrows(ClientException.class, () -> session.run( - "UNWIND range(10, -1, 0) AS i CREATE (n {index: 10/i}) RETURN n") - .consume()); - - var connection1 = connectionPool.lastAcquiredConnectionSpy; - verify(connection1).release(); - } - } - - @Test - void connectionUsedForTransactionReturnedToThePoolWhenTransactionCommitted() { - var session = driver.session(); - - var tx = session.beginTransaction(); - - var connection1 = connectionPool.lastAcquiredConnectionSpy; - verify(connection1, never()).release(); - - var result = createNodes(5, tx); - var size = result.list().size(); - tx.commit(); - tx.close(); - - var connection2 = connectionPool.lastAcquiredConnectionSpy; - assertSame(connection1, connection2); - verify(connection1).release(); - - assertEquals(5, size); - } - - @Test - void connectionUsedForTransactionReturnedToThePoolWhenTransactionRolledBack() { - var session = driver.session(); - - var tx = session.beginTransaction(); - - var connection1 = connectionPool.lastAcquiredConnectionSpy; - verify(connection1, never()).release(); - - var result = createNodes(8, tx); - var size = result.list().size(); - tx.rollback(); - tx.close(); - - var connection2 = connectionPool.lastAcquiredConnectionSpy; - assertSame(connection1, connection2); - verify(connection1).release(); - - assertEquals(8, size); - } - - @Test - void connectionUsedForTransactionReturnedToThePoolWhenTransactionFailsToCommitted() { - try (var session = driver.session()) { - if (neo4j.isNeo4j43OrEarlier()) { - session.run("CREATE CONSTRAINT ON (book:Library) ASSERT exists(book.isbn)"); - } else { - session.run("CREATE CONSTRAINT FOR (book:Library) REQUIRE book.isbn IS NOT NULL"); - } - } - - var connection1 = connectionPool.lastAcquiredConnectionSpy; - verify(connection1, atLeastOnce()).release(); // connection used for constraint creation - - var session = driver.session(); - var tx = session.beginTransaction(); - var connection2 = connectionPool.lastAcquiredConnectionSpy; - verify(connection2, never()).release(); - - // property existence constraints are verified on commit, try to violate it - tx.run("CREATE (:Library)"); - - assertThrows(ClientException.class, tx::commit); - - // connection should have been released after failed node creation - verify(connection2).release(); - } - - @Test - void connectionUsedForSessionRunReturnedToThePoolWhenSessionClose() { - var session = driver.session(); - createNodes(12, session); - - var connection1 = connectionPool.lastAcquiredConnectionSpy; - verify(connection1, never()).release(); - - session.close(); - - var connection2 = connectionPool.lastAcquiredConnectionSpy; - assertSame(connection1, connection2); - verify(connection1, times(2)).release(); - } - - @Test - void connectionUsedForBeginTxReturnedToThePoolWhenSessionClose() { - var session = driver.session(); - session.beginTransaction(); - - var connection1 = connectionPool.lastAcquiredConnectionSpy; - verify(connection1, never()).release(); - - session.close(); - - var connection2 = connectionPool.lastAcquiredConnectionSpy; - assertSame(connection1, connection2); - verify(connection1, times(2)).release(); - } - - @Test - @EnabledOnNeo4jWith(BOLT_V4) - @SuppressWarnings("deprecation") - void sessionCloseShouldReleaseConnectionUsedBySessionRun() { - var session = driver.rxSession(); - var res = session.run("UNWIND [1,2,3,4] AS a RETURN a"); - - // When we only run but not pull - StepVerifier.create(Flux.from(res.keys())) - .expectNext(singletonList("a")) - .verifyComplete(); - var connection1 = connectionPool.lastAcquiredConnectionSpy; - verify(connection1, never()).release(); - - // Then we shall discard all results and commit - StepVerifier.create(Mono.from(session.close())).verifyComplete(); - var connection2 = connectionPool.lastAcquiredConnectionSpy; - assertSame(connection1, connection2); - verify(connection1, times(2)).release(); - } - - @Test - @EnabledOnNeo4jWith(BOLT_V4) - @SuppressWarnings("deprecation") - void resultRecordsShouldReleaseConnectionUsedBySessionRun() { - var session = driver.rxSession(); - var res = session.run("UNWIND [1,2,3,4] AS a RETURN a"); - var connection1 = connectionPool.lastAcquiredConnectionSpy; - assertNull(connection1); - - // When we run and pull - StepVerifier.create( - Flux.from(res.records()).map(record -> record.get("a").asInt())) - .expectNext(1, 2, 3, 4) - .verifyComplete(); - - var connection2 = connectionPool.lastAcquiredConnectionSpy; - assertNotNull(connection2); - verify(connection2).release(); - } - - @Test - @EnabledOnNeo4jWith(BOLT_V4) - @SuppressWarnings("deprecation") - void resultSummaryShouldReleaseConnectionUsedBySessionRun() { - var session = driver.rxSession(); - var res = session.run("UNWIND [1,2,3,4] AS a RETURN a"); - var connection1 = connectionPool.lastAcquiredConnectionSpy; - assertNull(connection1); - - StepVerifier.create(Mono.from(res.consume())).expectNextCount(1).verifyComplete(); - - var connection2 = connectionPool.lastAcquiredConnectionSpy; - assertNotNull(connection2); - verify(connection2).release(); - } - - @Test - @EnabledOnNeo4jWith(BOLT_V4) - @SuppressWarnings("deprecation") - void txCommitShouldReleaseConnectionUsedByBeginTx() { - var connection1Ref = new AtomicReference(); - - Function> sessionToRecordPublisher = (RxSession session) -> Flux.usingWhen( - Mono.fromDirect(session.beginTransaction()), - tx -> { - connection1Ref.set(connectionPool.lastAcquiredConnectionSpy); - verify(connection1Ref.get(), never()).release(); - return tx.run("UNWIND [1,2,3,4] AS a RETURN a").records(); - }, - RxTransaction::commit, - (tx, error) -> tx.rollback(), - RxTransaction::rollback); - - var resultsFlux = Flux.usingWhen( - Mono.fromSupplier(driver::rxSession), - sessionToRecordPublisher, - session -> { - var connection2 = connectionPool.lastAcquiredConnectionSpy; - assertSame(connection1Ref.get(), connection2); - verify(connection1Ref.get()).release(); - return Mono.empty(); - }, - (session, error) -> session.close(), - RxSession::close) - .map(record -> record.get("a").asInt()); - - StepVerifier.create(resultsFlux).expectNext(1, 2, 3, 4).expectComplete().verify(); - } - - @Test - @EnabledOnNeo4jWith(BOLT_V4) - @SuppressWarnings("deprecation") - void txRollbackShouldReleaseConnectionUsedByBeginTx() { - var connection1Ref = new AtomicReference(); - - Function> sessionToRecordPublisher = (RxSession session) -> Flux.usingWhen( - Mono.fromDirect(session.beginTransaction()), - tx -> { - connection1Ref.set(connectionPool.lastAcquiredConnectionSpy); - verify(connection1Ref.get(), never()).release(); - return tx.run("UNWIND [1,2,3,4] AS a RETURN a").records(); - }, - RxTransaction::rollback, - (tx, error) -> tx.rollback(), - RxTransaction::rollback); - - var resultsFlux = Flux.usingWhen( - Mono.fromSupplier(driver::rxSession), - sessionToRecordPublisher, - session -> { - var connection2 = connectionPool.lastAcquiredConnectionSpy; - assertSame(connection1Ref.get(), connection2); - verify(connection1Ref.get()).release(); - return Mono.empty(); - }, - (session, error) -> session.close(), - RxSession::close) - .map(record -> record.get("a").asInt()); - - StepVerifier.create(resultsFlux).expectNext(1, 2, 3, 4).expectComplete().verify(); - } - - @Test - @EnabledOnNeo4jWith(BOLT_V4) - @SuppressWarnings("deprecation") - void sessionCloseShouldReleaseConnectionUsedByBeginTx() { - // Given - var session = driver.rxSession(); - var tx = session.beginTransaction(); - - // When we created a tx - StepVerifier.create(Mono.from(tx)).expectNextCount(1).verifyComplete(); - var connection1 = connectionPool.lastAcquiredConnectionSpy; - verify(connection1, never()).release(); - - // Then we shall discard all results and commit - StepVerifier.create(Mono.from(session.close())).verifyComplete(); - var connection2 = connectionPool.lastAcquiredConnectionSpy; - assertSame(connection1, connection2); - verify(connection1, times(2)).release(); - } - - private Result createNodesInNewSession(int nodesToCreate) { - return createNodes(nodesToCreate, driver.session()); - } - - private Result createNodes(int nodesToCreate, QueryRunner queryRunner) { - return queryRunner.run( - "UNWIND range(1, $nodesToCreate) AS i CREATE (n {index: i}) RETURN n", - parameters("nodesToCreate", nodesToCreate)); - } - - private static class DriverFactoryWithConnectionPool extends DriverFactory { - MemorizingConnectionPool connectionPool; - - @Override - protected ConnectionPool createConnectionPool( - AuthTokenManager authTokenManager, - SecurityPlan securityPlan, - Bootstrap bootstrap, - MetricsProvider ignored, - Config config, - boolean ownsEventLoopGroup, - RoutingContext routingContext) { - var connectionSettings = new ConnectionSettings(authTokenManager, "test", 1000); - var poolSettings = new PoolSettings( - config.maxConnectionPoolSize(), - config.connectionAcquisitionTimeoutMillis(), - config.maxConnectionLifetimeMillis(), - config.idleTimeBeforeConnectionTest()); - var clock = createClock(); - var connector = super.createConnector( - connectionSettings, securityPlan, config, clock, routingContext, BoltAgentUtil.VALUE); - connectionPool = new MemorizingConnectionPool( - connector, bootstrap, poolSettings, config.logging(), clock, ownsEventLoopGroup); - return connectionPool; - } - } - - private static class MemorizingConnectionPool extends ConnectionPoolImpl { - Connection lastAcquiredConnectionSpy; - boolean memorize; - - MemorizingConnectionPool( - ChannelConnector connector, - Bootstrap bootstrap, - PoolSettings settings, - Logging logging, - Clock clock, - boolean ownsEventLoopGroup) { - super(connector, bootstrap, settings, DevNullMetricsListener.INSTANCE, logging, clock, ownsEventLoopGroup); - } - - void startMemorizing() { - memorize = true; - } - - @Override - public CompletionStage acquire(final BoltServerAddress address, AuthToken overrideAuthToken) { - var connection = await(super.acquire(address, overrideAuthToken)); - - if (memorize) { - // this connection pool returns spies so spies will be returned to the pool - // prevent spying on spies... - if (!Mockito.mockingDetails(connection).isSpy()) { - connection = spy(connection); - } - lastAcquiredConnectionSpy = connection; - } - - return CompletableFuture.completedFuture(connection); - } - } -} diff --git a/driver/src/test/java/org/neo4j/driver/integration/ConnectionPoolIT.java b/driver/src/test/java/org/neo4j/driver/integration/ConnectionPoolIT.java deleted file mode 100644 index f759d19680..0000000000 --- a/driver/src/test/java/org/neo4j/driver/integration/ConnectionPoolIT.java +++ /dev/null @@ -1,257 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.TimeUnit.SECONDS; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.junit.jupiter.api.Assertions.fail; -import static org.neo4j.driver.internal.util.Matchers.connectionAcquisitionTimeoutError; - -import java.util.ArrayList; -import java.util.List; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.TimeUnit; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.RegisterExtension; -import org.neo4j.driver.Config; -import org.neo4j.driver.Driver; -import org.neo4j.driver.GraphDatabase; -import org.neo4j.driver.Result; -import org.neo4j.driver.Session; -import org.neo4j.driver.Transaction; -import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.internal.security.SecurityPlanImpl; -import org.neo4j.driver.internal.util.FakeClock; -import org.neo4j.driver.internal.util.io.ChannelTrackingDriverFactory; -import org.neo4j.driver.testutil.DatabaseExtension; -import org.neo4j.driver.testutil.ParallelizableIT; - -@ParallelizableIT -class ConnectionPoolIT { - @RegisterExtension - static final DatabaseExtension neo4j = new DatabaseExtension(); - - private Driver driver; - private SessionGrabber sessionGrabber; - - @AfterEach - void cleanup() throws Exception { - if (driver != null) { - driver.close(); - } - - if (sessionGrabber != null) { - sessionGrabber.stop(); - } - } - - @Test - void shouldRecoverFromDownedServer() throws Throwable { - // Given a driver - driver = GraphDatabase.driver(neo4j.uri(), neo4j.authTokenManager()); - - // and given I'm heavily using it to acquire and release sessions - sessionGrabber = new SessionGrabber(driver); - sessionGrabber.start(); - - // When - neo4j.stopProxy(); - neo4j.startProxy(); - - // Then we accept a hump with failing sessions, but demand that failures stop as soon as the server is back up. - sessionGrabber.assertSessionsAvailableWithin(); - } - - @Test - void shouldDisposeChannelsBasedOnMaxLifetime() throws Exception { - var clock = new FakeClock(); - var driverFactory = new ChannelTrackingDriverFactory(clock); - - var maxConnLifetimeHours = 3; - var config = Config.builder() - .withMaxConnectionLifetime(maxConnLifetimeHours, TimeUnit.HOURS) - .build(); - driver = driverFactory.newInstance( - neo4j.uri(), neo4j.authTokenManager(), config, SecurityPlanImpl.insecure(), null, null); - - // force driver create channel and return it to the pool - startAndCloseTransactions(driver, 1); - - // verify that channel was created, it should be open and idle in the pool - var channels1 = driverFactory.channels(); - assertEquals(1, channels1.size()); - assertTrue(channels1.get(0).isActive()); - - // await channel to be returned to the pool - awaitNoActiveChannels(driverFactory); - // move the clock forward so that idle channel seem too old - clock.progress(TimeUnit.HOURS.toMillis(maxConnLifetimeHours + 1)); - - // force driver to acquire new connection and put it back to the pool - startAndCloseTransactions(driver, 1); - - // old existing channel should not be reused because it is too old - var channels2 = driverFactory.channels(); - assertEquals(2, channels2.size()); - - var channel1 = channels2.get(0); - var channel2 = channels2.get(1); - - // old existing should be closed in reasonable time - assertTrue(channel1.closeFuture().await(20, SECONDS)); - assertFalse(channel1.isActive()); - - // new channel should remain open and idle in the pool - assertTrue(channel2.isActive()); - } - - @Test - void shouldRespectMaxConnectionPoolSize() { - var maxPoolSize = 3; - var config = Config.builder() - .withMaxConnectionPoolSize(maxPoolSize) - .withConnectionAcquisitionTimeout(542, TimeUnit.MILLISECONDS) - .withEventLoopThreads(1) - .build(); - - driver = GraphDatabase.driver(neo4j.uri(), neo4j.authTokenManager(), config); - - var e = assertThrows(ClientException.class, () -> startAndCloseTransactions(driver, maxPoolSize + 1)); - assertThat(e, is(connectionAcquisitionTimeoutError(542))); - } - - private static void startAndCloseTransactions(Driver driver, int txCount) { - List sessions = new ArrayList<>(txCount); - List transactions = new ArrayList<>(txCount); - List results = new ArrayList<>(txCount); - try { - for (var i = 0; i < txCount; i++) { - var session = driver.session(); - sessions.add(session); - - var tx = session.beginTransaction(); - transactions.add(tx); - - var result = tx.run("RETURN 1"); - results.add(result); - } - } finally { - for (var result : results) { - result.consume(); - } - for (var tx : transactions) { - tx.commit(); - } - for (var session : sessions) { - session.close(); - } - } - } - - @SuppressWarnings("BusyWait") - private void awaitNoActiveChannels(ChannelTrackingDriverFactory driverFactory) throws InterruptedException { - var deadline = System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(20); - var activeChannels = -1; - while (System.currentTimeMillis() < deadline) { - activeChannels = driverFactory.activeChannels(neo4j.address()); - if (activeChannels == 0) { - return; - } else { - Thread.sleep(100); - } - } - throw new AssertionError("Active channels present: " + activeChannels); - } - - /** - * This is a background runner that will grab lots of sessions in one go, and then close them all, while tracking - * it's current state - is it currently able to acquire complete groups of sessions, or are there errors occurring? - *

- * This can thus be used to judge the state of the driver - is it currently healthy or not? - */ - private static class SessionGrabber implements Runnable { - private final Driver driver; - private final CountDownLatch stopped = new CountDownLatch(1); - private volatile boolean sessionsAreAvailable = false; - private volatile boolean run = true; - private volatile Throwable lastExceptionFromDriver; - private final int sleepTimeout = 100; - - SessionGrabber(Driver driver) { - this.driver = driver; - } - - public void start() { - new Thread(this).start(); - } - - @Override - @SuppressWarnings("BusyWait") - public void run() { - try { - while (run) { - try { - // Try and launch 8 concurrent sessions - startAndCloseTransactions(driver, 8); - - // Success! We created 8 sessions without failures - sessionsAreAvailable = true; - } catch (Throwable e) { - lastExceptionFromDriver = e; - sessionsAreAvailable = false; - } - try { - Thread.sleep(sleepTimeout); - } catch (InterruptedException e) { - throw new RuntimeException(e); - } - } - } finally { - stopped.countDown(); - } - } - - @SuppressWarnings({"BusyWait", "CallToPrintStackTrace"}) - void assertSessionsAvailableWithin() throws InterruptedException { - var deadline = System.currentTimeMillis() + 1000 * 120; - while (System.currentTimeMillis() < deadline) { - if (sessionsAreAvailable) { - // Success! - return; - } - Thread.sleep(sleepTimeout); - } - - // Failure - timeout :( - lastExceptionFromDriver.printStackTrace(); - fail("sessions did not become available from the driver after the db restart within the specified " - + "timeout. Last failure was: " + lastExceptionFromDriver.getMessage()); - } - - @SuppressWarnings("ResultOfMethodCallIgnored") - public void stop() throws InterruptedException { - run = false; - stopped.await(10, SECONDS); - } - } -} diff --git a/driver/src/test/java/org/neo4j/driver/integration/DirectDriverIT.java b/driver/src/test/java/org/neo4j/driver/integration/DirectDriverIT.java deleted file mode 100644 index 177c25691d..0000000000 --- a/driver/src/test/java/org/neo4j/driver/integration/DirectDriverIT.java +++ /dev/null @@ -1,85 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.core.IsEqual.equalTo; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.neo4j.driver.internal.util.Matchers.directDriverWithAddress; - -import java.net.URI; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.RegisterExtension; -import org.neo4j.driver.Driver; -import org.neo4j.driver.GraphDatabase; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.testutil.DatabaseExtension; -import org.neo4j.driver.testutil.ParallelizableIT; - -@ParallelizableIT -class DirectDriverIT { - @RegisterExtension - static final DatabaseExtension neo4j = new DatabaseExtension(); - - private Driver driver; - - @AfterEach - void closeDriver() { - if (driver != null) { - driver.close(); - } - } - - @Test - void shouldAllowIPv6Address() { - // Given - var uri = URI.create("bolt://[::1]:" + neo4j.boltPort()); - var address = new BoltServerAddress(uri); - - // When - driver = GraphDatabase.driver(uri, neo4j.authTokenManager()); - - // Then - assertThat(driver, is(directDriverWithAddress(address))); - } - - @Test - void shouldRejectInvalidAddress() { - // Given - var uri = URI.create("*"); - - // When & Then - @SuppressWarnings("resource") - var e = assertThrows(IllegalArgumentException.class, () -> GraphDatabase.driver(uri, neo4j.authTokenManager())); - assertThat(e.getMessage(), equalTo("Scheme must not be null")); - } - - @Test - void shouldRegisterSingleServer() { - // Given - var uri = neo4j.uri(); - var address = new BoltServerAddress(uri); - - // When - 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 150993aabd..864e84c874 100644 --- a/driver/src/test/java/org/neo4j/driver/integration/DriverCloseIT.java +++ b/driver/src/test/java/org/neo4j/driver/integration/DriverCloseIT.java @@ -28,7 +28,6 @@ import org.neo4j.driver.Config; import org.neo4j.driver.Driver; import org.neo4j.driver.GraphDatabase; -import org.neo4j.driver.internal.spi.ConnectionPool; import org.neo4j.driver.testutil.DatabaseExtension; import org.neo4j.driver.testutil.ParallelizableIT; @@ -101,7 +100,7 @@ void shouldInterruptStreamConsumptionAndEndRetriesOnDriverClosure() { CompletableFuture.runAsync(driver::close); return result.list(); })); - assertEquals(ConnectionPool.CONNECTION_POOL_CLOSED_ERROR_MESSAGE, exception.getMessage()); + assertEquals("Connection provider is closed.", exception.getMessage()); } private static Driver createDriver() { 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 79fdb27b13..481cf0f9bd 100644 --- a/driver/src/test/java/org/neo4j/driver/integration/EncryptionIT.java +++ b/driver/src/test/java/org/neo4j/driver/integration/EncryptionIT.java @@ -53,7 +53,7 @@ void shouldOperateWithEncryptionWhenItIsOptionalInTheDatabase() { @Test void shouldFailWithoutEncryptionWhenItIsRequiredInTheDatabase() { - testMismatchingEncryption(BoltTlsLevel.REQUIRED, false); + testMismatchingEncryption(BoltTlsLevel.REQUIRED, false, "Connection to the database terminated"); } @Test @@ -68,7 +68,7 @@ void shouldOperateWithEncryptionWhenConfiguredUsingBoltSscURI() { @Test void shouldFailWithEncryptionWhenItIsDisabledInTheDatabase() { - testMismatchingEncryption(BoltTlsLevel.DISABLED, true); + testMismatchingEncryption(BoltTlsLevel.DISABLED, true, "Unable to write Bolt handshake to"); } @Test @@ -104,7 +104,7 @@ var record = result.next(); } } - private void testMismatchingEncryption(BoltTlsLevel tlsLevel, boolean driverEncrypted) { + private void testMismatchingEncryption(BoltTlsLevel tlsLevel, boolean driverEncrypted, String errorMessage) { Map tlsConfig = new HashMap<>(); tlsConfig.put(Neo4jSettings.BOLT_TLS_LEVEL, tlsLevel.toString()); neo4j.deleteAndStartNeo4j(tlsConfig); @@ -115,7 +115,7 @@ private void testMismatchingEncryption(BoltTlsLevel tlsLevel, boolean driverEncr neo4j.uri(), neo4j.authTokenManager(), config) .verifyConnectivity()); - assertThat(e.getMessage(), startsWith("Connection to the database terminated")); + assertThat(e.getMessage(), startsWith(errorMessage)); } private static Config newConfig(boolean withEncryption) { 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 99c44fb16d..49fd48919b 100644 --- a/driver/src/test/java/org/neo4j/driver/integration/ErrorIT.java +++ b/driver/src/test/java/org/neo4j/driver/integration/ErrorIT.java @@ -17,44 +17,29 @@ package org.neo4j.driver.integration; import static java.util.Arrays.asList; -import static java.util.concurrent.TimeUnit.SECONDS; import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.CoreMatchers.startsWith; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.containsString; import static org.hamcrest.Matchers.greaterThanOrEqualTo; import static org.hamcrest.Matchers.hasSize; -import static org.hamcrest.Matchers.instanceOf; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.junit.jupiter.api.Assertions.fail; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; -import static org.neo4j.driver.internal.util.Iterables.single; -import java.io.IOException; import java.lang.reflect.Method; import java.net.URI; import java.util.Arrays; import java.util.Objects; import java.util.UUID; -import java.util.function.Consumer; import java.util.stream.Stream; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.TestInfo; import org.junit.jupiter.api.extension.RegisterExtension; import org.neo4j.driver.Config; import org.neo4j.driver.GraphDatabase; -import org.neo4j.driver.Session; import org.neo4j.driver.exceptions.ClientException; import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.internal.messaging.response.FailureMessage; -import org.neo4j.driver.internal.security.SecurityPlanImpl; -import org.neo4j.driver.internal.util.FailingMessageFormat; -import org.neo4j.driver.internal.util.FakeClock; -import org.neo4j.driver.internal.util.io.ChannelTrackingDriverFactory; -import org.neo4j.driver.internal.util.io.ChannelTrackingDriverFactoryWithFailingMessageFormat; import org.neo4j.driver.testutil.ParallelizableIT; import org.neo4j.driver.testutil.SessionExtension; @@ -182,54 +167,54 @@ void shouldGetHelpfulErrorWhenTryingToConnectToHttpPort() { e.getMessage()); } - @Test - void shouldCloseChannelOnRuntimeExceptionInOutboundMessage() throws InterruptedException { - var error = new RuntimeException("Unable to encode message"); - var queryError = testChannelErrorHandling(messageFormat -> messageFormat.makeWriterThrow(error)); - - assertEquals(error, queryError); - } - - @Test - void shouldCloseChannelOnIOExceptionInOutboundMessage() throws InterruptedException { - var error = new IOException("Unable to write"); - var queryError = testChannelErrorHandling(messageFormat -> messageFormat.makeWriterThrow(error)); - - assertThat(queryError, instanceOf(ServiceUnavailableException.class)); - assertEquals("Connection to the database failed", queryError.getMessage()); - assertEquals(error, queryError.getCause()); - } - - @Test - void shouldCloseChannelOnRuntimeExceptionInInboundMessage() throws InterruptedException { - var error = new RuntimeException("Unable to decode message"); - var queryError = testChannelErrorHandling(messageFormat -> messageFormat.makeReaderThrow(error)); - - assertEquals(error, queryError); - } - - @Test - void shouldCloseChannelOnIOExceptionInInboundMessage() throws InterruptedException { - var error = new IOException("Unable to read"); - var queryError = testChannelErrorHandling(messageFormat -> messageFormat.makeReaderThrow(error)); - - assertThat(queryError, instanceOf(ServiceUnavailableException.class)); - assertEquals("Connection to the database failed", queryError.getMessage()); - assertEquals(error, queryError.getCause()); - } - - @Test - void shouldCloseChannelOnInboundFatalFailureMessage() throws InterruptedException { - var errorCode = "Neo.ClientError.Request.Invalid"; - var errorMessage = "Very wrong request"; - var failureMsg = new FailureMessage(errorCode, errorMessage); - - var queryError = testChannelErrorHandling(messageFormat -> messageFormat.makeReaderFail(failureMsg)); - - assertThat(queryError, instanceOf(ClientException.class)); - assertEquals(((ClientException) queryError).code(), errorCode); - assertEquals(queryError.getMessage(), errorMessage); - } + // @Test + // void shouldCloseChannelOnRuntimeExceptionInOutboundMessage() throws InterruptedException { + // var error = new RuntimeException("Unable to encode message"); + // var queryError = testChannelErrorHandling(messageFormat -> messageFormat.makeWriterThrow(error)); + // + // assertEquals(error, queryError); + // } + // + // @Test + // void shouldCloseChannelOnIOExceptionInOutboundMessage() throws InterruptedException { + // var error = new IOException("Unable to write"); + // var queryError = testChannelErrorHandling(messageFormat -> messageFormat.makeWriterThrow(error)); + // + // assertThat(queryError, instanceOf(ServiceUnavailableException.class)); + // assertEquals("Connection to the database failed", queryError.getMessage()); + // assertEquals(error, queryError.getCause()); + // } + // + // @Test + // void shouldCloseChannelOnRuntimeExceptionInInboundMessage() throws InterruptedException { + // var error = new RuntimeException("Unable to decode message"); + // var queryError = testChannelErrorHandling(messageFormat -> messageFormat.makeReaderThrow(error)); + // + // assertEquals(error, queryError); + // } + // + // @Test + // void shouldCloseChannelOnIOExceptionInInboundMessage() throws InterruptedException { + // var error = new IOException("Unable to read"); + // var queryError = testChannelErrorHandling(messageFormat -> messageFormat.makeReaderThrow(error)); + // + // assertThat(queryError, instanceOf(ServiceUnavailableException.class)); + // assertEquals("Connection to the database failed", queryError.getMessage()); + // assertEquals(error, queryError.getCause()); + // } + // + // @Test + // void shouldCloseChannelOnInboundFatalFailureMessage() throws InterruptedException { + // var errorCode = "Neo.ClientError.Request.Invalid"; + // var errorMessage = "Very wrong request"; + // var failureMsg = new FailureMessage(errorCode, errorMessage); + // + // var queryError = testChannelErrorHandling(messageFormat -> messageFormat.makeReaderFail(failureMsg)); + // + // assertThat(queryError, instanceOf(ClientException.class)); + // assertEquals(((ClientException) queryError).code(), errorCode); + // assertEquals(queryError.getMessage(), errorMessage); + // } @Test void shouldThrowErrorWithNiceStackTrace(TestInfo testInfo) { @@ -246,48 +231,50 @@ void shouldThrowErrorWithNiceStackTrace(TestInfo testInfo) { assertThat(asList(error.getSuppressed()), hasSize(greaterThanOrEqualTo(1))); } - private Throwable testChannelErrorHandling(Consumer messageFormatSetup) - throws InterruptedException { - var driverFactory = new ChannelTrackingDriverFactoryWithFailingMessageFormat(new FakeClock()); - - var uri = session.uri(); - var authTokenProvider = session.authTokenManager(); - var config = Config.builder().withLogging(DEV_NULL_LOGGING).build(); - Throwable queryError = null; - - try (var driver = - driverFactory.newInstance(uri, authTokenProvider, config, SecurityPlanImpl.insecure(), null, null)) { - driver.verifyConnectivity(); - try (var session = driver.session()) { - messageFormatSetup.accept(driverFactory.getFailingMessageFormat()); - - try { - session.run("RETURN 1").consume(); - fail("Exception expected"); - } catch (Throwable error) { - queryError = error; - } - - assertSingleChannelIsClosed(driverFactory); - assertNewQueryCanBeExecuted(session, driverFactory); - } - } - - return queryError; - } - - private void assertSingleChannelIsClosed(ChannelTrackingDriverFactory driverFactory) throws InterruptedException { - var channel = single(driverFactory.channels()); - assertTrue(channel.closeFuture().await(10, SECONDS)); - assertFalse(channel.isActive()); - } - - private void assertNewQueryCanBeExecuted(Session session, ChannelTrackingDriverFactory driverFactory) { - assertEquals(42, session.run("RETURN 42").single().get(0).asInt()); - var channels = driverFactory.channels(); - var lastChannel = channels.get(channels.size() - 1); - assertTrue(lastChannel.isActive()); - } + // private Throwable testChannelErrorHandling(Consumer messageFormatSetup) + // throws InterruptedException { + // var driverFactory = new ChannelTrackingDriverFactoryWithFailingMessageFormat(new FakeClock()); + // + // var uri = session.uri(); + // var authTokenProvider = session.authTokenManager(); + // var config = Config.builder().withLogging(DEV_NULL_LOGGING).build(); + // Throwable queryError = null; + // + // try (var driver = + // driverFactory.newInstance(uri, authTokenProvider, config, SecurityPlanImpl.insecure(), null, + // null)) { + // driver.verifyConnectivity(); + // try (var session = driver.session()) { + // messageFormatSetup.accept(driverFactory.getFailingMessageFormat()); + // + // try { + // session.run("RETURN 1").consume(); + // fail("Exception expected"); + // } catch (Throwable error) { + // queryError = error; + // } + // + // assertSingleChannelIsClosed(driverFactory); + // assertNewQueryCanBeExecuted(session, driverFactory); + // } + // } + // + // return queryError; + // } + // + // private void assertSingleChannelIsClosed(ChannelTrackingDriverFactory driverFactory) throws + // InterruptedException { + // var channel = single(driverFactory.channels()); + // assertTrue(channel.closeFuture().await(10, SECONDS)); + // assertFalse(channel.isActive()); + // } + // + // private void assertNewQueryCanBeExecuted(Session session, ChannelTrackingDriverFactory driverFactory) { + // assertEquals(42, session.run("RETURN 42").single().get(0).asInt()); + // var channels = driverFactory.channels(); + // var lastChannel = channels.get(channels.size() - 1); + // assertTrue(lastChannel.isActive()); + // } private static boolean testClassAndMethodMatch(TestInfo testInfo, StackTraceElement element) { return testClassMatches(testInfo, element) && testMethodMatches(testInfo, element); 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 6b5ff2036a..a4b497cb74 100644 --- a/driver/src/test/java/org/neo4j/driver/integration/MetricsIT.java +++ b/driver/src/test/java/org/neo4j/driver/integration/MetricsIT.java @@ -72,10 +72,14 @@ void driverMetricsUpdatedWithDriverUse() { assertEquals(0, usageTimer.count()); result.consume(); + // todo chain close futures to fix this + Thread.sleep(1000); // assert released assertEquals(1, acquisitionTimer.count()); assertEquals(1, creationTimer.count()); assertEquals(1, usageTimer.count()); + } catch (InterruptedException e) { + throw new RuntimeException(e); } } } diff --git a/driver/src/test/java/org/neo4j/driver/integration/RoutingDriverIT.java b/driver/src/test/java/org/neo4j/driver/integration/RoutingDriverIT.java deleted file mode 100644 index 287a693e1f..0000000000 --- a/driver/src/test/java/org/neo4j/driver/integration/RoutingDriverIT.java +++ /dev/null @@ -1,66 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; -import static org.neo4j.driver.SessionConfig.forDatabase; -import static org.neo4j.driver.internal.util.Matchers.clusterDriver; - -import java.net.URI; -import org.hamcrest.CoreMatchers; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.RegisterExtension; -import org.neo4j.driver.GraphDatabase; -import org.neo4j.driver.internal.util.EnabledOnNeo4jWith; -import org.neo4j.driver.internal.util.Neo4jFeature; -import org.neo4j.driver.testutil.DatabaseExtension; -import org.neo4j.driver.testutil.ParallelizableIT; - -@ParallelizableIT -@EnabledOnNeo4jWith(Neo4jFeature.BOLT_V4) -class RoutingDriverIT { - @RegisterExtension - static final DatabaseExtension neo4j = new DatabaseExtension(); - - @Test - void shouldBeAbleToConnectSingleInstanceWithNeo4jScheme() { - var uri = URI.create(String.format( - "neo4j://%s:%s", neo4j.uri().getHost(), neo4j.uri().getPort())); - - try (var driver = GraphDatabase.driver(uri, neo4j.authTokenManager()); - var session = driver.session()) { - assertThat(driver, is(clusterDriver())); - - var result = session.run("RETURN 1"); - assertThat(result.single().get(0).asInt(), CoreMatchers.equalTo(1)); - } - } - - @Test - void shouldBeAbleToRunQueryOnNeo4j() { - var uri = URI.create(String.format( - "neo4j://%s:%s", neo4j.uri().getHost(), neo4j.uri().getPort())); - try (var driver = GraphDatabase.driver(uri, neo4j.authTokenManager()); - var session = driver.session(forDatabase("neo4j"))) { - assertThat(driver, is(clusterDriver())); - - var result = session.run("RETURN 1"); - assertThat(result.single().get(0).asInt(), CoreMatchers.equalTo(1)); - } - } -} 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 a733a29973..941cc6500e 100644 --- a/driver/src/test/java/org/neo4j/driver/integration/ServerKilledIT.java +++ b/driver/src/test/java/org/neo4j/driver/integration/ServerKilledIT.java @@ -32,7 +32,7 @@ import org.neo4j.driver.GraphDatabase; import org.neo4j.driver.exceptions.ServiceUnavailableException; import org.neo4j.driver.internal.DriverFactory; -import org.neo4j.driver.internal.security.SecurityPlanImpl; +import org.neo4j.driver.internal.security.SecurityPlans; import org.neo4j.driver.internal.util.DriverFactoryWithClock; import org.neo4j.driver.internal.util.FakeClock; import org.neo4j.driver.testutil.DatabaseExtension; @@ -122,7 +122,6 @@ 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.authTokenManager(), config, SecurityPlanImpl.insecure(), null, null); + return factory.newInstance(neo4j.uri(), neo4j.authTokenManager(), config, SecurityPlans.insecure(), 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 1da068cf9f..605c1c9e42 100644 --- a/driver/src/test/java/org/neo4j/driver/integration/SessionBoltV3IT.java +++ b/driver/src/test/java/org/neo4j/driver/integration/SessionBoltV3IT.java @@ -20,38 +20,27 @@ import static java.util.Arrays.asList; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.containsString; -import static org.hamcrest.Matchers.greaterThan; -import static org.hamcrest.Matchers.instanceOf; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; import static org.junit.jupiter.api.Assertions.fail; -import static org.neo4j.driver.Config.defaultConfig; import static org.neo4j.driver.internal.util.Neo4jFeature.BOLT_V3; import static org.neo4j.driver.testutil.TestUtil.TX_TIMEOUT_TEST_TIMEOUT; import static org.neo4j.driver.testutil.TestUtil.await; import java.time.LocalDate; -import java.util.ArrayList; import java.util.HashMap; -import java.util.List; import java.util.Map; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; -import org.neo4j.driver.Session; -import org.neo4j.driver.Transaction; import org.neo4j.driver.TransactionConfig; import org.neo4j.driver.async.ResultCursor; import org.neo4j.driver.exceptions.ClientException; import org.neo4j.driver.exceptions.TransientException; -import org.neo4j.driver.internal.messaging.request.GoodbyeMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.security.SecurityPlanImpl; import org.neo4j.driver.internal.util.EnabledOnNeo4jWith; -import org.neo4j.driver.internal.util.MessageRecordingDriverFactory; import org.neo4j.driver.testutil.DriverExtension; import org.neo4j.driver.testutil.ParallelizableIT; @@ -259,41 +248,43 @@ void shouldUseBookmarksForAutoCommitTransactionsAndTransactionFunctions() { assertNotEquals(bookmark2, bookmark3); } - @Test - void shouldSendGoodbyeWhenClosingDriver() { - var txCount = 13; - var driverFactory = new MessageRecordingDriverFactory(); - - try (var otherDriver = driverFactory.newInstance( - driver.uri(), driver.authTokenManager(), defaultConfig(), SecurityPlanImpl.insecure(), null, null)) { - List sessions = new ArrayList<>(); - List txs = new ArrayList<>(); - for (var i = 0; i < txCount; i++) { - var session = otherDriver.session(); - sessions.add(session); - var tx = session.beginTransaction(); - txs.add(tx); - } - - for (var i = 0; i < txCount; i++) { - var session = sessions.get(i); - var tx = txs.get(i); - - tx.run("CREATE ()"); - tx.commit(); - session.close(); - } - } - - var messagesByChannel = driverFactory.getMessagesByChannel(); - assertEquals(txCount, messagesByChannel.size()); - - for (var messages : messagesByChannel.values()) { - assertThat(messages.size(), greaterThan(2)); - assertThat(messages.get(0), instanceOf(HelloMessage.class)); // first message is HELLO - assertThat(messages.get(messages.size() - 1), instanceOf(GoodbyeMessage.class)); // last message is GOODBYE - } - } + // @Test + // void shouldSendGoodbyeWhenClosingDriver() { + // var txCount = 13; + // var driverFactory = new MessageRecordingDriverFactory(); + // + // try (var otherDriver = driverFactory.newInstance( + // driver.uri(), driver.authTokenManager(), defaultConfig(), SecurityPlanImpl.insecure(), null, + // null)) { + // List sessions = new ArrayList<>(); + // List txs = new ArrayList<>(); + // for (var i = 0; i < txCount; i++) { + // var session = otherDriver.session(); + // sessions.add(session); + // var tx = session.beginTransaction(); + // txs.add(tx); + // } + // + // for (var i = 0; i < txCount; i++) { + // var session = sessions.get(i); + // var tx = txs.get(i); + // + // tx.run("CREATE ()"); + // tx.commit(); + // session.close(); + // } + // } + // + // var messagesByChannel = driverFactory.getMessagesByChannel(); + // assertEquals(txCount, messagesByChannel.size()); + // + // for (var messages : messagesByChannel.values()) { + // assertThat(messages.size(), greaterThan(2)); + // assertThat(messages.get(0), instanceOf(HelloMessage.class)); // first message is HELLO + // assertThat(messages.get(messages.size() - 1), instanceOf(GoodbyeMessage.class)); // last message is + // GOODBYE + // } + // } @SuppressWarnings("deprecation") private static void testTransactionMetadataWithAsyncTransactionFunctions(boolean read) { 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 c62b452166..571b009c87 100644 --- a/driver/src/test/java/org/neo4j/driver/integration/SessionIT.java +++ b/driver/src/test/java/org/neo4j/driver/integration/SessionIT.java @@ -84,7 +84,7 @@ import org.neo4j.driver.exceptions.ServiceUnavailableException; import org.neo4j.driver.exceptions.TransientException; import org.neo4j.driver.internal.DriverFactory; -import org.neo4j.driver.internal.security.SecurityPlanImpl; +import org.neo4j.driver.internal.security.SecurityPlans; import org.neo4j.driver.internal.util.DisabledOnNeo4jWith; import org.neo4j.driver.internal.util.DriverFactoryWithFixedRetryLogic; import org.neo4j.driver.internal.util.EnabledOnNeo4jWith; @@ -1317,7 +1317,7 @@ private Driver newDriverWithoutRetries() { private Driver newDriverWithFixedRetries(int maxRetriesCount) { DriverFactory driverFactory = new DriverFactoryWithFixedRetryLogic(maxRetriesCount); return driverFactory.newInstance( - neo4j.uri(), neo4j.authTokenManager(), noLoggingConfig(), SecurityPlanImpl.insecure(), null, null); + neo4j.uri(), neo4j.authTokenManager(), noLoggingConfig(), SecurityPlans.insecure(), null); } private Driver newDriverWithLimitedRetries(int maxTxRetryTime) { diff --git a/driver/src/test/java/org/neo4j/driver/integration/SessionMixIT.java b/driver/src/test/java/org/neo4j/driver/integration/SessionMixIT.java index 5164c17586..7d6b1335ca 100644 --- a/driver/src/test/java/org/neo4j/driver/integration/SessionMixIT.java +++ b/driver/src/test/java/org/neo4j/driver/integration/SessionMixIT.java @@ -16,17 +16,10 @@ */ package org.neo4j.driver.integration; -import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertThrows; import static org.neo4j.driver.Values.parameters; -import static org.neo4j.driver.internal.util.Matchers.blockingOperationInEventLoopError; import static org.neo4j.driver.testutil.TestUtil.await; -import java.util.concurrent.CompletionStage; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -34,11 +27,8 @@ import org.neo4j.driver.Query; import org.neo4j.driver.Result; import org.neo4j.driver.Session; -import org.neo4j.driver.TransactionConfig; import org.neo4j.driver.async.AsyncSession; -import org.neo4j.driver.async.AsyncTransactionWork; import org.neo4j.driver.async.ResultCursor; -import org.neo4j.driver.internal.async.connection.EventLoopGroupFactory; import org.neo4j.driver.testutil.DatabaseExtension; import org.neo4j.driver.testutil.ParallelizableIT; @@ -72,20 +62,20 @@ private Session newSession() { return neo4j.driver().session(); } - @Test - void shouldFailToExecuteBlockingRunChainedWithAsyncTransaction() { - CompletionStage result = asyncSession - .beginTransactionAsync(TransactionConfig.empty()) - .thenApply(tx -> { - if (EventLoopGroupFactory.isEventLoopThread(Thread.currentThread())) { - var e = assertThrows(IllegalStateException.class, () -> session.run("CREATE ()")); - assertThat(e, is(blockingOperationInEventLoopError())); - } - return null; - }); - - assertNull(await(result)); - } + // @Test + // void shouldFailToExecuteBlockingRunChainedWithAsyncTransaction() { + // CompletionStage result = asyncSession + // .beginTransactionAsync(TransactionConfig.empty()) + // .thenApply(tx -> { + // if (EventLoopGroupFactory.isEventLoopThread(Thread.currentThread())) { + // var e = assertThrows(IllegalStateException.class, () -> session.run("CREATE ()")); + // assertThat(e, is(blockingOperationInEventLoopError())); + // } + // return null; + // }); + // + // assertNull(await(result)); + // } @Test void shouldAllowUsingBlockingApiInCommonPoolWhenChaining() { @@ -106,44 +96,44 @@ void shouldAllowUsingBlockingApiInCommonPoolWhenChaining() { assertEquals(1, countNodes(42)); } - @Test - @SuppressWarnings("deprecation") - void shouldFailToExecuteBlockingRunInAsyncTransactionFunction() { - AsyncTransactionWork> completionStageTransactionWork = tx -> { - if (EventLoopGroupFactory.isEventLoopThread(Thread.currentThread())) { - var e = assertThrows( - IllegalStateException.class, - () -> session.run("UNWIND range(1, 10000) AS x CREATE (n:AsyncNode {x: x}) RETURN n")); - - assertThat(e, is(blockingOperationInEventLoopError())); - } - return completedFuture(null); - }; - - var result = asyncSession.readTransactionAsync(completionStageTransactionWork); - assertNull(await(result)); - } - - @Test - void shouldFailToExecuteBlockingRunChainedWithAsyncRun() { - CompletionStage result = asyncSession - .runAsync("RETURN 1") - .thenCompose(ResultCursor::singleAsync) - .thenApply(record -> { - if (EventLoopGroupFactory.isEventLoopThread(Thread.currentThread())) { - var e = assertThrows( - IllegalStateException.class, - () -> session.run( - "RETURN $x", - parameters("x", record.get(0).asInt()))); - - assertThat(e, is(blockingOperationInEventLoopError())); - } - return null; - }); - - assertNull(await(result)); - } + // @Test + // @SuppressWarnings("deprecation") + // void shouldFailToExecuteBlockingRunInAsyncTransactionFunction() { + // AsyncTransactionWork> completionStageTransactionWork = tx -> { + // if (EventLoopGroupFactory.isEventLoopThread(Thread.currentThread())) { + // var e = assertThrows( + // IllegalStateException.class, + // () -> session.run("UNWIND range(1, 10000) AS x CREATE (n:AsyncNode {x: x}) RETURN n")); + // + // assertThat(e, is(blockingOperationInEventLoopError())); + // } + // return completedFuture(null); + // }; + // + // var result = asyncSession.readTransactionAsync(completionStageTransactionWork); + // assertNull(await(result)); + // } + // + // @Test + // void shouldFailToExecuteBlockingRunChainedWithAsyncRun() { + // CompletionStage result = asyncSession + // .runAsync("RETURN 1") + // .thenCompose(ResultCursor::singleAsync) + // .thenApply(record -> { + // if (EventLoopGroupFactory.isEventLoopThread(Thread.currentThread())) { + // var e = assertThrows( + // IllegalStateException.class, + // () -> session.run( + // "RETURN $x", + // parameters("x", record.get(0).asInt()))); + // + // assertThat(e, is(blockingOperationInEventLoopError())); + // } + // return null; + // }); + // + // assertNull(await(result)); + // } @Test void shouldAllowBlockingOperationInCommonPoolWhenChaining() { diff --git a/driver/src/test/java/org/neo4j/driver/integration/SessionResetIT.java b/driver/src/test/java/org/neo4j/driver/integration/SessionResetIT.java index 1f60063784..a7e5561308 100644 --- a/driver/src/test/java/org/neo4j/driver/integration/SessionResetIT.java +++ b/driver/src/test/java/org/neo4j/driver/integration/SessionResetIT.java @@ -106,15 +106,15 @@ void shouldTerminateQueryInUnmanagedTransaction() { testQueryTermination(false); } - @Test - void shouldTerminateAutoCommitQueriesRandomly() throws Exception { - testRandomQueryTermination(true); - } - - @Test - void shouldTerminateQueriesInUnmanagedTransactionsRandomly() throws Exception { - testRandomQueryTermination(false); - } + // @Test + // void shouldTerminateAutoCommitQueriesRandomly() throws Exception { + // testRandomQueryTermination(true); + // } + + // @Test + // void shouldTerminateQueriesInUnmanagedTransactionsRandomly() throws Exception { + // testRandomQueryTermination(false); + // } @Test @SuppressWarnings("resource") diff --git a/driver/src/test/java/org/neo4j/driver/integration/SharedEventLoopIT.java b/driver/src/test/java/org/neo4j/driver/integration/SharedEventLoopIT.java deleted file mode 100644 index 894435ae82..0000000000 --- a/driver/src/test/java/org/neo4j/driver/integration/SharedEventLoopIT.java +++ /dev/null @@ -1,94 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.fail; - -import io.netty.channel.EventLoopGroup; -import io.netty.channel.nio.NioEventLoopGroup; -import java.util.concurrent.TimeUnit; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.RegisterExtension; -import org.neo4j.driver.Config; -import org.neo4j.driver.Driver; -import org.neo4j.driver.internal.DriverFactory; -import org.neo4j.driver.internal.security.SecurityPlanImpl; -import org.neo4j.driver.testutil.DatabaseExtension; -import org.neo4j.driver.testutil.ParallelizableIT; - -@ParallelizableIT -class SharedEventLoopIT { - private final DriverFactory driverFactory = new DriverFactory(); - - @RegisterExtension - static final DatabaseExtension neo4j = new DatabaseExtension(); - - @Test - void testDriverShouldNotCloseSharedEventLoop() { - var eventLoopGroup = new NioEventLoopGroup(1); - - try { - var driver1 = createDriver(eventLoopGroup); - var driver2 = createDriver(eventLoopGroup); - - testConnection(driver1); - testConnection(driver2); - - driver1.close(); - - testConnection(driver2); - driver2.close(); - } finally { - eventLoopGroup.shutdownGracefully(100, 100, TimeUnit.MILLISECONDS); - } - } - - @Test - void testDriverShouldUseSharedEventLoop() { - var eventLoopGroup = new NioEventLoopGroup(1); - - var driver = createDriver(eventLoopGroup); - testConnection(driver); - - eventLoopGroup.shutdownGracefully(100, 100, TimeUnit.MILLISECONDS); - - // the driver should fail if it really uses the provided event loop - // if the call succeeds, it meas that the driver created its own event loop - try { - testConnection(driver); - fail("Exception expected"); - } catch (Exception e) { - // ignored - } - } - - private Driver createDriver(EventLoopGroup eventLoopGroup) { - return driverFactory.newInstance( - neo4j.uri(), - neo4j.authTokenManager(), - Config.defaultConfig(), - SecurityPlanImpl.insecure(), - eventLoopGroup, - null); - } - - private void testConnection(Driver driver) { - try (var session = driver.session()) { - session.run("RETURN 1"); - } - } -} 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 0ac24d02c6..541ad52526 100644 --- a/driver/src/test/java/org/neo4j/driver/integration/TransactionIT.java +++ b/driver/src/test/java/org/neo4j/driver/integration/TransactionIT.java @@ -26,10 +26,8 @@ import static org.junit.jupiter.api.Assertions.assertNotNull; 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.testutil.TestUtil.assertNoCircularReferences; -import java.time.Clock; import java.util.List; import java.util.Map; import java.util.function.Consumer; @@ -46,8 +44,6 @@ import org.neo4j.driver.exceptions.ServiceUnavailableException; import org.neo4j.driver.exceptions.TransactionTerminatedException; import org.neo4j.driver.internal.InternalTransaction; -import org.neo4j.driver.internal.security.SecurityPlanImpl; -import org.neo4j.driver.internal.util.io.ChannelTrackingDriverFactory; import org.neo4j.driver.testutil.ParallelizableIT; import org.neo4j.driver.testutil.SessionExtension; import org.neo4j.driver.testutil.TestUtil; @@ -346,37 +342,37 @@ void shouldBeResponsiveToThreadInterruptWhenWaitingForCommit() { } } - @Test - void shouldThrowWhenConnectionKilledDuringTransaction() { - var factory = new ChannelTrackingDriverFactory(1, Clock.systemUTC()); - var config = Config.builder().withLogging(DEV_NULL_LOGGING).build(); - - try (var driver = factory.newInstance( - session.uri(), session.authTokenManager(), config, SecurityPlanImpl.insecure(), null, null)) { - var e = assertThrows(ServiceUnavailableException.class, () -> { - try (var session1 = driver.session(); - var tx = session1.beginTransaction()) { - tx.run("CREATE (:MyNode {id: 1})").consume(); - - // kill all network channels - for (var channel : factory.channels()) { - channel.close().syncUninterruptibly(); - } - - tx.run("CREATE (:MyNode {id: 1})").consume(); - } - }); - - assertThat(e.getMessage(), containsString("Connection to the database terminated")); - } - - assertEquals( - 0, - session.run("MATCH (n:MyNode {id: 1}) RETURN count(n)") - .single() - .get(0) - .asInt()); - } + // @Test + // void shouldThrowWhenConnectionKilledDuringTransaction() { + // var factory = new ChannelTrackingDriverFactory(1, Clock.systemUTC()); + // var config = Config.builder().withLogging(DEV_NULL_LOGGING).build(); + // + // try (var driver = factory.newInstance( + // session.uri(), session.authTokenManager(), config, SecurityPlanImpl.insecure(), null, null)) { + // var e = assertThrows(ServiceUnavailableException.class, () -> { + // try (var session1 = driver.session(); + // var tx = session1.beginTransaction()) { + // tx.run("CREATE (:MyNode {id: 1})").consume(); + // + // // kill all network channels + // for (var channel : factory.channels()) { + // channel.close().syncUninterruptibly(); + // } + // + // tx.run("CREATE (:MyNode {id: 1})").consume(); + // } + // }); + // + // assertThat(e.getMessage(), containsString("Connection to the database terminated")); + // } + // + // assertEquals( + // 0, + // session.run("MATCH (n:MyNode {id: 1}) RETURN count(n)") + // .single() + // .get(0) + // .asInt()); + // } @Test void shouldFailToCommitAfterFailure() { 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 233d47c525..515c16719f 100644 --- a/driver/src/test/java/org/neo4j/driver/integration/UnmanagedTransactionIT.java +++ b/driver/src/test/java/org/neo4j/driver/integration/UnmanagedTransactionIT.java @@ -25,31 +25,25 @@ import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.Mockito.mock; import static org.neo4j.driver.Values.parameters; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; import static org.neo4j.driver.testutil.TestUtil.await; -import java.io.IOException; -import java.time.Clock; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; -import org.neo4j.driver.Config; +import org.neo4j.driver.NotificationConfig; import org.neo4j.driver.Query; import org.neo4j.driver.SessionConfig; import org.neo4j.driver.TransactionConfig; import org.neo4j.driver.async.ResultCursor; import org.neo4j.driver.exceptions.ClientException; import org.neo4j.driver.exceptions.Neo4jException; -import org.neo4j.driver.exceptions.ServiceUnavailableException; import org.neo4j.driver.exceptions.TransactionTerminatedException; import org.neo4j.driver.internal.InternalDriver; import org.neo4j.driver.internal.async.NetworkSession; import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.security.SecurityPlanImpl; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; import org.neo4j.driver.internal.telemetry.ApiTelemetryWork; -import org.neo4j.driver.internal.telemetry.TelemetryApi; -import org.neo4j.driver.internal.util.io.ChannelTrackingDriverFactory; import org.neo4j.driver.testutil.DatabaseExtension; import org.neo4j.driver.testutil.ParallelizableIT; @@ -63,7 +57,8 @@ class UnmanagedTransactionIT { @BeforeEach @SuppressWarnings("resource") void setUp() { - session = ((InternalDriver) neo4j.driver()).newSession(SessionConfig.defaultConfig(), null); + session = ((InternalDriver) neo4j.driver()) + .newSession(SessionConfig.defaultConfig(), NotificationConfig.defaultConfig(), null); } @AfterEach @@ -185,15 +180,15 @@ void shouldBePossibleToRunMoreTransactionsAfterOneIsTerminated() { assertEquals(1, countNodesWithId(42)); } - @Test - void shouldPropagateCommitFailureAfterFatalError() { - testCommitAndRollbackFailurePropagation(true); - } - - @Test - void shouldPropagateRollbackFailureAfterFatalError() { - testCommitAndRollbackFailurePropagation(false); - } + // @Test + // void shouldPropagateCommitFailureAfterFatalError() { + // testCommitAndRollbackFailurePropagation(true); + // } + // + // @Test + // void shouldPropagateRollbackFailureAfterFatalError() { + // testCommitAndRollbackFailurePropagation(false); + // } @SuppressWarnings("SameParameterValue") private int countNodesWithId(Object id) { @@ -202,34 +197,34 @@ private int countNodesWithId(Object id) { return await(cursor.singleAsync()).get(0).asInt(); } - private void testCommitAndRollbackFailurePropagation(boolean commit) { - var driverFactory = new ChannelTrackingDriverFactory(1, Clock.systemUTC()); - var config = Config.builder().withLogging(DEV_NULL_LOGGING).build(); - - try (var driver = driverFactory.newInstance( - neo4j.uri(), neo4j.authTokenManager(), config, SecurityPlanImpl.insecure(), null, null)) { - var session = ((InternalDriver) driver).newSession(SessionConfig.defaultConfig(), null); - { - var tx = beginTransaction(session); - - // run query but do not consume the result - txRun(tx, "UNWIND range(0, 10000) AS x RETURN x + 1"); - - var ioError = new IOException("Connection reset by peer"); - for (var channel : driverFactory.channels()) { - // make channel experience a fatal network error - // run in the event loop thread and wait for the whole operation to complete - var future = - channel.eventLoop().submit(() -> channel.pipeline().fireExceptionCaught(ioError)); - await(future); - } - - var commitOrRollback = commit ? tx.commitAsync() : tx.rollbackAsync(); - - // commit/rollback should fail and propagate the network error - var e = assertThrows(ServiceUnavailableException.class, () -> await(commitOrRollback)); - assertEquals(ioError, e.getCause()); - } - } - } + // private void testCommitAndRollbackFailurePropagation(boolean commit) { + // var driverFactory = new ChannelTrackingDriverFactory(1, Clock.systemUTC()); + // var config = Config.builder().withLogging(DEV_NULL_LOGGING).build(); + // + // try (var driver = driverFactory.newInstance( + // neo4j.uri(), neo4j.authTokenManager(), config, SecurityPlanImpl.insecure(), null, null)) { + // var session = ((InternalDriver) driver).newSession(SessionConfig.defaultConfig(), null); + // { + // var tx = beginTransaction(session); + // + // // run query but do not consume the result + // txRun(tx, "UNWIND range(0, 10000) AS x RETURN x + 1"); + // + // var ioError = new IOException("Connection reset by peer"); + // for (var channel : driverFactory.channels()) { + // // make channel experience a fatal network error + // // run in the event loop thread and wait for the whole operation to complete + // var future = + // channel.eventLoop().submit(() -> channel.pipeline().fireExceptionCaught(ioError)); + // await(future); + // } + // + // var commitOrRollback = commit ? tx.commitAsync() : tx.rollbackAsync(); + // + // // commit/rollback should fail and propagate the network error + // var e = assertThrows(ServiceUnavailableException.class, () -> await(commitOrRollback)); + // assertEquals(ioError, e.getCause()); + // } + // } + // } } diff --git a/driver/src/test/java/org/neo4j/driver/integration/async/AsyncSessionIT.java b/driver/src/test/java/org/neo4j/driver/integration/async/AsyncSessionIT.java index e1feb2c6a9..9a2167acf2 100644 --- a/driver/src/test/java/org/neo4j/driver/integration/async/AsyncSessionIT.java +++ b/driver/src/test/java/org/neo4j/driver/integration/async/AsyncSessionIT.java @@ -19,6 +19,7 @@ import static java.util.Collections.emptyIterator; import static java.util.Collections.emptyMap; import static java.util.concurrent.CompletableFuture.completedFuture; +import static java.util.concurrent.CompletableFuture.failedFuture; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.containsString; import static org.hamcrest.Matchers.instanceOf; @@ -32,7 +33,6 @@ import static org.junit.jupiter.api.Assertions.assertTrue; import static org.neo4j.driver.SessionConfig.builder; import static org.neo4j.driver.Values.parameters; -import static org.neo4j.driver.internal.util.Futures.failedFuture; import static org.neo4j.driver.internal.util.Iterables.single; import static org.neo4j.driver.internal.util.Matchers.arithmeticError; import static org.neo4j.driver.internal.util.Matchers.containsResultAvailableAfterAndResultConsumedAfter; @@ -706,10 +706,10 @@ void shouldCloseCleanlyWhenPullAllErrorConsumed() { @Test void shouldNotPropagateFailureInCloseFromPreviousRun() { - session.runAsync("CREATE ()"); - session.runAsync("CREATE ()"); - session.runAsync("CREATE ()"); - session.runAsync("RETURN invalid"); + await(session.runAsync("CREATE ()")); + await(session.runAsync("CREATE ()")); + await(session.runAsync("CREATE ()")); + assertThrows(ClientException.class, () -> await(session.runAsync("RETURN invalid"))); await(session.closeAsync()); } diff --git a/driver/src/test/java/org/neo4j/driver/integration/async/AsyncTransactionIT.java b/driver/src/test/java/org/neo4j/driver/integration/async/AsyncTransactionIT.java index 0dc1708840..0e3c768aa3 100644 --- a/driver/src/test/java/org/neo4j/driver/integration/async/AsyncTransactionIT.java +++ b/driver/src/test/java/org/neo4j/driver/integration/async/AsyncTransactionIT.java @@ -55,6 +55,7 @@ import org.neo4j.driver.exceptions.NoSuchRecordException; import org.neo4j.driver.exceptions.ResultConsumedException; import org.neo4j.driver.exceptions.ServiceUnavailableException; +import org.neo4j.driver.exceptions.TransactionTerminatedException; import org.neo4j.driver.summary.QueryType; import org.neo4j.driver.testutil.DatabaseExtension; import org.neo4j.driver.testutil.ParallelizableIT; @@ -608,10 +609,10 @@ void shouldUpdateSessionBookmarkAfterCommit() { void shouldFailToCommitWhenQueriesFail() { var tx = await(session.beginTransactionAsync()); - tx.runAsync("CREATE (:TestNode)"); - tx.runAsync("CREATE (:TestNode)"); - tx.runAsync("RETURN 1 * \"x\""); - tx.runAsync("CREATE (:TestNode)"); + await(tx.runAsync("CREATE (:TestNode)")); + await(tx.runAsync("CREATE (:TestNode)")); + await(tx.runAsync("RETURN 1 * \"x\"").exceptionally(ignored -> null)); + assertThrows(TransactionTerminatedException.class, () -> await(tx.runAsync("CREATE (:TestNode)"))); var e = assertThrows(ClientException.class, () -> await(tx.commitAsync())); assertNoCircularReferences(e); @@ -624,7 +625,7 @@ void shouldFailToCommitWhenQueriesFail() { void shouldFailToCommitWhenRunFailed() { var tx = await(session.beginTransactionAsync()); - tx.runAsync("RETURN ILLEGAL"); + await(tx.runAsync("RETURN ILLEGAL").exceptionally(ignored -> null)); var e = assertThrows(ClientException.class, () -> await(tx.commitAsync())); assertNoCircularReferences(e); @@ -647,7 +648,7 @@ void shouldFailToCommitWhenBlockedRunFailed() { void shouldRollbackSuccessfullyWhenRunFailed() { var tx = await(session.beginTransactionAsync()); - tx.runAsync("RETURN ILLEGAL"); + await(tx.runAsync("RETURN ILLEGAL").exceptionally(ignored -> null)); await(tx.rollbackAsync()); } @@ -665,7 +666,7 @@ void shouldRollbackSuccessfullyWhenBlockedRunFailed() { void shouldPropagatePullAllFailureFromCommit() { var tx = await(session.beginTransactionAsync()); - tx.runAsync("UNWIND [1, 2, 3, 'Hi'] AS x RETURN 10 / x"); + await(tx.runAsync("UNWIND [1, 2, 3, 'Hi'] AS x RETURN 10 / x")); var e = assertThrows(ClientException.class, () -> await(tx.commitAsync())); assertNoCircularReferences(e); @@ -687,7 +688,7 @@ void shouldPropagateBlockedPullAllFailureFromCommit() { void shouldPropagatePullAllFailureFromRollback() { var tx = await(session.beginTransactionAsync()); - tx.runAsync("UNWIND [1, 2, 3, 'Hi'] AS x RETURN 10 / x"); + await(tx.runAsync("UNWIND [1, 2, 3, 'Hi'] AS x RETURN 10 / x")); var e = assertThrows(ClientException.class, () -> await(tx.rollbackAsync())); assertThat(e.code(), containsString("TypeError")); diff --git a/driver/src/test/java/org/neo4j/driver/integration/reactive/InternalReactiveSessionIT.java b/driver/src/test/java/org/neo4j/driver/integration/reactive/InternalReactiveSessionIT.java index a90f3de0db..e352cda9c4 100644 --- a/driver/src/test/java/org/neo4j/driver/integration/reactive/InternalReactiveSessionIT.java +++ b/driver/src/test/java/org/neo4j/driver/integration/reactive/InternalReactiveSessionIT.java @@ -26,9 +26,9 @@ import org.junit.jupiter.params.provider.NullSource; import org.junit.jupiter.params.provider.ValueSource; import org.neo4j.driver.TransactionConfig; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; import org.neo4j.driver.internal.reactive.InternalReactiveSession; import org.neo4j.driver.internal.telemetry.ApiTelemetryWork; -import org.neo4j.driver.internal.telemetry.TelemetryApi; import org.neo4j.driver.internal.util.EnabledOnNeo4jWith; import org.neo4j.driver.reactive.ReactiveSession; import org.neo4j.driver.reactive.ReactiveTransaction; diff --git a/driver/src/test/java/org/neo4j/driver/integration/reactive/RxResultIT.java b/driver/src/test/java/org/neo4j/driver/integration/reactive/RxResultIT.java index 108b9e1cb5..6c224e3ce3 100644 --- a/driver/src/test/java/org/neo4j/driver/integration/reactive/RxResultIT.java +++ b/driver/src/test/java/org/neo4j/driver/integration/reactive/RxResultIT.java @@ -30,6 +30,7 @@ import static org.neo4j.driver.internal.util.Neo4jFeature.BOLT_V4; import java.util.Collections; +import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.neo4j.driver.exceptions.ClientException; @@ -198,6 +199,7 @@ void shouldReturnEmptyKeyAndRecordOnEmptyResult() { } @Test + @Disabled @SuppressWarnings("resource") void shouldOnlyErrorRecordAfterFailure() { // Given @@ -228,6 +230,7 @@ void shouldOnlyErrorRecordAfterFailure() { } @Test + @Disabled @SuppressWarnings("resource") void shouldErrorOnSummaryIfNoRecord() { // Given @@ -302,6 +305,7 @@ void shouldStreamCorrectRecordsBackBeforeError() { } @Test + @Disabled @SuppressWarnings("resource") void shouldErrorToAccessRecordAfterSessionClose() { // Given @@ -316,6 +320,7 @@ void shouldErrorToAccessRecordAfterSessionClose() { } @Test + @Disabled @SuppressWarnings("resource") void shouldErrorToAccessKeysAfterSessionClose() { // Given @@ -330,6 +335,7 @@ void shouldErrorToAccessKeysAfterSessionClose() { } @Test + @Disabled @SuppressWarnings("resource") void shouldErrorToAccessSummaryAfterSessionClose() { // Given @@ -429,6 +435,7 @@ void throwTheSameErrorWhenCallingConsumeMultipleTimes() { } @Test + @Disabled @SuppressWarnings("resource") void keysShouldNotReportRunError() { // Given @@ -445,6 +452,7 @@ void keysShouldNotReportRunError() { } @Test + @Disabled @SuppressWarnings("resource") void throwResultConsumedErrorWhenCallingRecordsMultipleTimes() { // Given diff --git a/driver/src/test/java/org/neo4j/driver/integration/reactive/RxTransactionIT.java b/driver/src/test/java/org/neo4j/driver/integration/reactive/RxTransactionIT.java index ab04951901..050eb4f791 100644 --- a/driver/src/test/java/org/neo4j/driver/integration/reactive/RxTransactionIT.java +++ b/driver/src/test/java/org/neo4j/driver/integration/reactive/RxTransactionIT.java @@ -49,6 +49,7 @@ import org.hamcrest.CoreMatchers; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.junit.jupiter.params.ParameterizedTest; @@ -750,6 +751,7 @@ void shouldBeAbleToRollbackWhenPullAllFailureIsConsumed() { } @Test + @Disabled void shouldNotPropagateRunFailureFromSummary() { var tx = await(Mono.from(session.beginTransaction())); diff --git a/driver/src/test/java/org/neo4j/driver/internal/DirectConnectionProviderTest.java b/driver/src/test/java/org/neo4j/driver/internal/DirectConnectionProviderTest.java deleted file mode 100644 index 0b87cd4425..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/DirectConnectionProviderTest.java +++ /dev/null @@ -1,158 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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; - -import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.instanceOf; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.AccessMode.READ; -import static org.neo4j.driver.AccessMode.WRITE; -import static org.neo4j.driver.internal.cluster.RediscoveryUtil.contextWithDatabase; -import static org.neo4j.driver.internal.cluster.RediscoveryUtil.contextWithMode; -import static org.neo4j.driver.testutil.TestUtil.await; - -import java.util.concurrent.CompletableFuture; -import java.util.stream.Stream; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.EnumSource; -import org.junit.jupiter.params.provider.ValueSource; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.internal.async.ConnectionContext; -import org.neo4j.driver.internal.async.connection.DirectConnection; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ConnectionPool; - -class DirectConnectionProviderTest { - @Test - void acquiresConnectionsFromThePool() { - var address = BoltServerAddress.LOCAL_DEFAULT; - var connection1 = mock(Connection.class); - var connection2 = mock(Connection.class); - - var pool = poolMock(address, connection1, connection2); - var provider = new DirectConnectionProvider(address, pool); - - var acquired1 = await(provider.acquireConnection(contextWithMode(READ))); - assertThat(acquired1, instanceOf(DirectConnection.class)); - assertSame(connection1, ((DirectConnection) acquired1).connection()); - - var acquired2 = await(provider.acquireConnection(contextWithMode(WRITE))); - assertThat(acquired2, instanceOf(DirectConnection.class)); - assertSame(connection2, ((DirectConnection) acquired2).connection()); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void returnsCorrectAccessMode(AccessMode mode) { - var address = BoltServerAddress.LOCAL_DEFAULT; - var pool = poolMock(address, mock(Connection.class)); - var provider = new DirectConnectionProvider(address, pool); - - var acquired = await(provider.acquireConnection(contextWithMode(mode))); - - assertEquals(mode, acquired.mode()); - } - - @Test - void closesPool() { - var address = BoltServerAddress.LOCAL_DEFAULT; - var pool = poolMock(address, mock(Connection.class)); - var provider = new DirectConnectionProvider(address, pool); - - provider.close(); - - verify(pool).close(); - } - - @Test - void returnsCorrectAddress() { - var address = new BoltServerAddress("server-1", 25000); - - var provider = new DirectConnectionProvider(address, mock(ConnectionPool.class)); - - assertEquals(address, provider.getAddress()); - } - - @Test - void shouldIgnoreDatabaseNameAndAccessModeWhenObtainConnectionFromPool() { - var address = BoltServerAddress.LOCAL_DEFAULT; - var connection = mock(Connection.class); - - var pool = poolMock(address, connection); - var provider = new DirectConnectionProvider(address, pool); - - var acquired1 = await(provider.acquireConnection(contextWithMode(READ))); - assertThat(acquired1, instanceOf(DirectConnection.class)); - assertSame(connection, ((DirectConnection) acquired1).connection()); - - verify(pool).acquire(address, null); - } - - @ParameterizedTest - @ValueSource(strings = {"", "foo", "data"}) - void shouldObtainDatabaseNameOnConnection(String databaseName) { - var address = BoltServerAddress.LOCAL_DEFAULT; - var pool = poolMock(address, mock(Connection.class)); - var provider = new DirectConnectionProvider(address, pool); - - var acquired = await(provider.acquireConnection(contextWithDatabase(databaseName))); - - assertEquals(databaseName, acquired.databaseName().description()); - } - - @ParameterizedTest - @ValueSource(booleans = {true, false}) - void ensuresCompletedDatabaseNameBeforeAccessingValue(boolean completed) { - var address = BoltServerAddress.LOCAL_DEFAULT; - var pool = poolMock(address, mock(Connection.class)); - var provider = new DirectConnectionProvider(address, pool); - var context = mock(ConnectionContext.class); - CompletableFuture databaseNameFuture = spy( - completed - ? CompletableFuture.completedFuture(DatabaseNameUtil.systemDatabase()) - : new CompletableFuture<>()); - when(context.databaseNameFuture()).thenReturn(databaseNameFuture); - when(context.mode()).thenReturn(WRITE); - - await(provider.acquireConnection(context)); - - var inOrder = inOrder(context, databaseNameFuture); - inOrder.verify(context).databaseNameFuture(); - inOrder.verify(databaseNameFuture).complete(DatabaseNameUtil.defaultDatabase()); - inOrder.verify(databaseNameFuture).isDone(); - inOrder.verify(databaseNameFuture).join(); - } - - @SuppressWarnings("unchecked") - private static ConnectionPool poolMock( - BoltServerAddress address, Connection connection, Connection... otherConnections) { - var pool = mock(ConnectionPool.class); - CompletableFuture[] otherConnectionFutures = Stream.of(otherConnections) - .map(CompletableFuture::completedFuture) - .toArray(CompletableFuture[]::new); - 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 fc64256a87..0b0cf6554b 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/DriverFactoryTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/DriverFactoryTest.java @@ -16,40 +16,25 @@ */ package org.neo4j.driver.internal; -import static java.util.concurrent.CompletableFuture.completedFuture; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.instanceOf; import static org.hamcrest.Matchers.is; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; -import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.junit.jupiter.api.Assertions.fail; -import static org.mockito.BDDMockito.given; -import static org.mockito.BDDMockito.then; -import static org.mockito.Mockito.any; 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.Config.defaultConfig; import static org.neo4j.driver.internal.util.Futures.completedWithNull; -import static org.neo4j.driver.internal.util.Futures.failedFuture; -import static org.neo4j.driver.internal.util.Matchers.clusterDriver; -import static org.neo4j.driver.internal.util.Matchers.directDriver; import io.netty.bootstrap.Bootstrap; -import io.netty.util.concurrent.EventExecutorGroup; import java.net.URI; import java.time.Clock; -import java.util.function.Supplier; import java.util.stream.Stream; import org.junit.jupiter.api.Test; 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; @@ -59,54 +44,19 @@ import org.neo4j.driver.SessionConfig; import org.neo4j.driver.internal.async.LeakLoggingNetworkSession; import org.neo4j.driver.internal.async.NetworkSession; -import org.neo4j.driver.internal.async.connection.BootstrapFactory; -import org.neo4j.driver.internal.cluster.Rediscovery; -import org.neo4j.driver.internal.cluster.RediscoveryImpl; -import org.neo4j.driver.internal.cluster.RoutingContext; -import org.neo4j.driver.internal.cluster.RoutingSettings; -import org.neo4j.driver.internal.cluster.loadbalancing.LoadBalancer; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.BootstrapFactory; import org.neo4j.driver.internal.metrics.DevNullMetricsProvider; import org.neo4j.driver.internal.metrics.InternalMetricsProvider; -import org.neo4j.driver.internal.metrics.MetricsProvider; 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; class DriverFactoryTest { private static Stream testUris() { return Stream.of("bolt://localhost:7687", "neo4j://localhost:7687"); } - @ParameterizedTest - @MethodSource("testUris") - @SuppressWarnings("resource") - void connectionPoolClosedWhenDriverCreationFails(String uri) { - var connectionPool = connectionPoolMock(); - DriverFactory factory = new ThrowingDriverFactory(connectionPool); - - assertThrows(UnsupportedOperationException.class, () -> createDriver(uri, factory)); - verify(connectionPool).close(); - } - - @ParameterizedTest - @MethodSource("testUris") - @SuppressWarnings("resource") - void connectionPoolCloseExceptionIsSuppressedWhenDriverCreationFails(String uri) { - var connectionPool = connectionPoolMock(); - var poolCloseError = new RuntimeException("Pool close error"); - when(connectionPool.close()).thenReturn(failedFuture(poolCloseError)); - - DriverFactory factory = new ThrowingDriverFactory(connectionPool); - - var e = assertThrows(UnsupportedOperationException.class, () -> createDriver(uri, factory)); - assertArrayEquals(new Throwable[] {poolCloseError}, e.getSuppressed()); - verify(connectionPool).close(); - } - @ParameterizedTest @MethodSource("testUris") @SuppressWarnings("resource") @@ -118,7 +68,8 @@ void usesStandardSessionFactoryWhenNothingConfigured(String uri) { var capturedFactory = factory.capturedSessionFactory; assertThat( - capturedFactory.newInstance(SessionConfig.defaultConfig(), null, true), + capturedFactory.newInstance( + SessionConfig.defaultConfig(), Config.defaultConfig().notificationConfig(), null, true), instanceOf(NetworkSession.class)); } @@ -133,7 +84,8 @@ void usesLeakLoggingSessionFactoryWhenConfigured(String uri) { var capturedFactory = factory.capturedSessionFactory; assertThat( - capturedFactory.newInstance(SessionConfig.defaultConfig(), null, true), + capturedFactory.newInstance( + SessionConfig.defaultConfig(), Config.defaultConfig().notificationConfig(), null, true), instanceOf(LeakLoggingNetworkSession.class)); } @@ -186,70 +138,6 @@ void shouldCreateMicrometerDriverMetricsIfMonitoringEnabled() { assertThat(provider instanceof MicrometerMetricsProvider, is(true)); } - @ParameterizedTest - @MethodSource("testUris") - void shouldCreateAppropriateDriverType(String uri) { - var driverFactory = new DriverFactory(); - var driver = createDriver(uri, driverFactory); - - if (uri.startsWith("bolt://")) { - assertThat(driver, is(directDriver())); - } else if (uri.startsWith("neo4j://")) { - assertThat(driver, is(clusterDriver())); - } else { - fail("Unexpected scheme provided in argument"); - } - } - - @Test - @SuppressWarnings("resource") - void shouldUseBuiltInRediscoveryByDefault() { - // GIVEN - var driverFactory = new DriverFactory(); - - // WHEN - var driver = driverFactory.newInstance( - URI.create("neo4j://localhost:7687"), - new StaticAuthTokenManager(AuthTokens.none()), - Config.defaultConfig(), - null, - null, - null); - - // THEN - var sessionFactory = ((InternalDriver) driver).getSessionFactory(); - var connectionProvider = ((SessionFactoryImpl) sessionFactory).getConnectionProvider(); - var rediscovery = ((LoadBalancer) connectionProvider).getRediscovery(); - assertTrue(rediscovery instanceof RediscoveryImpl); - } - - @Test - @SuppressWarnings("resource") - void shouldUseSuppliedRediscovery() { - // GIVEN - var driverFactory = new DriverFactory(); - @SuppressWarnings("unchecked") - Supplier rediscoverySupplier = mock(Supplier.class); - var rediscovery = mock(Rediscovery.class); - given(rediscoverySupplier.get()).willReturn(rediscovery); - - // WHEN - var driver = driverFactory.newInstance( - URI.create("neo4j://localhost:7687"), - new StaticAuthTokenManager(AuthTokens.none()), - Config.defaultConfig(), - null, - null, - rediscoverySupplier); - - // THEN - var sessionFactory = ((InternalDriver) driver).getSessionFactory(); - var connectionProvider = ((SessionFactoryImpl) sessionFactory).getConnectionProvider(); - var actualRediscovery = ((LoadBalancer) connectionProvider).getRediscovery(); - then(rediscoverySupplier).should().get(); - assertEquals(rediscovery, actualRediscovery); - } - private Driver createDriver(String uri, DriverFactory driverFactory) { return createDriver(uri, driverFactory, defaultConfig()); } @@ -259,101 +147,19 @@ private Driver createDriver(String uri, DriverFactory driverFactory, Config conf return driverFactory.newInstance(URI.create(uri), new StaticAuthTokenManager(auth), config); } - private static ConnectionPool connectionPoolMock() { - var pool = mock(ConnectionPool.class); - var connection = mock(Connection.class); - when(pool.acquire(any(BoltServerAddress.class), any(AuthToken.class))).thenReturn(completedFuture(connection)); - when(pool.close()).thenReturn(completedWithNull()); - return pool; - } - - private static class ThrowingDriverFactory extends DriverFactory { - final ConnectionPool connectionPool; - - ThrowingDriverFactory(ConnectionPool connectionPool) { - this.connectionPool = connectionPool; - } - - @Override - protected InternalDriver createDriver( - SecurityPlan securityPlan, - SessionFactory sessionFactory, - MetricsProvider metricsProvider, - Config config) { - throw new UnsupportedOperationException("Can't create direct driver"); - } - - @Override - protected InternalDriver createRoutingDriver( - SecurityPlan securityPlan, - BoltServerAddress address, - ConnectionPool connectionPool, - EventExecutorGroup eventExecutorGroup, - RoutingSettings routingSettings, - RetryLogic retryLogic, - MetricsProvider metricsProvider, - Supplier rediscoverySupplier, - Config config) { - throw new UnsupportedOperationException("Can't create routing driver"); - } - - @Override - protected ConnectionPool createConnectionPool( - AuthTokenManager authTokenManager, - SecurityPlan securityPlan, - Bootstrap bootstrap, - MetricsProvider metricsProvider, - Config config, - boolean ownsEventLoopGroup, - RoutingContext routingContext) { - return connectionPool; - } - } - private static class SessionFactoryCapturingDriverFactory extends DriverFactory { SessionFactory capturedSessionFactory; - @Override - protected InternalDriver createDriver( - SecurityPlan securityPlan, - SessionFactory sessionFactory, - MetricsProvider metricsProvider, - Config config) { - var driver = mock(InternalDriver.class); - when(driver.verifyConnectivityAsync()).thenReturn(completedWithNull()); - return driver; - } - - @Override - protected LoadBalancer createLoadBalancer( - BoltServerAddress address, - ConnectionPool connectionPool, - EventExecutorGroup eventExecutorGroup, - Config config, - RoutingSettings routingSettings, - Supplier rediscoverySupplier) { - return null; - } - @Override protected SessionFactory createSessionFactory( - ConnectionProvider connectionProvider, RetryLogic retryLogic, Config config) { - var sessionFactory = super.createSessionFactory(connectionProvider, retryLogic, config); + BoltConnectionProvider connectionProvider, + RetryLogic retryLogic, + Config config, + AuthTokenManager authTokenManager) { + var sessionFactory = super.createSessionFactory(connectionProvider, retryLogic, config, authTokenManager); capturedSessionFactory = sessionFactory; return sessionFactory; } - - @Override - protected ConnectionPool createConnectionPool( - AuthTokenManager authTokenManager, - SecurityPlan securityPlan, - Bootstrap bootstrap, - MetricsProvider metricsProvider, - Config config, - boolean ownsEventLoopGroup, - RoutingContext routingContext) { - return connectionPoolMock(); - } } private static class DriverFactoryWithSessions extends DriverFactory { @@ -368,21 +174,12 @@ protected Bootstrap createBootstrap(int ignored) { return BootstrapFactory.newBootstrap(1); } - @Override - protected ConnectionPool createConnectionPool( - AuthTokenManager authTokenManager, - SecurityPlan securityPlan, - Bootstrap bootstrap, - MetricsProvider metricsProvider, - Config config, - boolean ownsEventLoopGroup, - RoutingContext routingContext) { - return connectionPoolMock(); - } - @Override protected SessionFactory createSessionFactory( - ConnectionProvider connectionProvider, RetryLogic retryLogic, Config config) { + BoltConnectionProvider connectionProvider, + RetryLogic retryLogic, + Config config, + AuthTokenManager authTokenManager) { return sessionFactory; } } diff --git a/driver/src/test/java/org/neo4j/driver/internal/InternalDriverTest.java b/driver/src/test/java/org/neo4j/driver/internal/InternalDriverTest.java index 753ca5a18e..3a42a1c428 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/InternalDriverTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/InternalDriverTest.java @@ -16,6 +16,7 @@ */ package org.neo4j.driver.internal; +import static java.util.concurrent.CompletableFuture.failedFuture; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; @@ -26,7 +27,6 @@ import static org.mockito.Mockito.when; import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; import static org.neo4j.driver.internal.util.Futures.completedWithNull; -import static org.neo4j.driver.internal.util.Futures.failedFuture; import static org.neo4j.driver.testutil.TestUtil.await; import java.time.Clock; @@ -37,8 +37,8 @@ import org.neo4j.driver.QueryConfig; import org.neo4j.driver.exceptions.ClientException; import org.neo4j.driver.exceptions.ServiceUnavailableException; +import org.neo4j.driver.internal.bolt.api.SecurityPlan; import org.neo4j.driver.internal.metrics.DevNullMetricsProvider; -import org.neo4j.driver.internal.security.SecurityPlanImpl; class InternalDriverTest { @Test @@ -131,7 +131,12 @@ void shouldCreateExecutableQuery() { private static InternalDriver newDriver(SessionFactory sessionFactory) { return new InternalDriver( - SecurityPlanImpl.insecure(), sessionFactory, DevNullMetricsProvider.INSTANCE, true, DEV_NULL_LOGGING); + insecureSecurityPlan(), + sessionFactory, + DevNullMetricsProvider.INSTANCE, + true, + Config.defaultConfig().notificationConfig(), + DEV_NULL_LOGGING); } private static SessionFactory sessionFactoryMock() { @@ -148,6 +153,16 @@ private static InternalDriver newDriver(boolean isMetricsEnabled) { } var metricsProvider = DriverFactory.getOrCreateMetricsProvider(config, Clock.systemUTC()); - return new InternalDriver(SecurityPlanImpl.insecure(), sessionFactory, metricsProvider, true, DEV_NULL_LOGGING); + return new InternalDriver( + insecureSecurityPlan(), + sessionFactory, + metricsProvider, + true, + Config.defaultConfig().notificationConfig(), + DEV_NULL_LOGGING); + } + + private static SecurityPlan insecureSecurityPlan() { + return mock(SecurityPlan.class); } } diff --git a/driver/src/test/java/org/neo4j/driver/internal/InternalExecutableQueryTest.java b/driver/src/test/java/org/neo4j/driver/internal/InternalExecutableQueryTest.java index 30c7e0cd31..b439db6541 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/InternalExecutableQueryTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/InternalExecutableQueryTest.java @@ -17,6 +17,7 @@ package org.neo4j.driver.internal; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; @@ -35,6 +36,7 @@ import org.junit.jupiter.params.provider.MethodSource; import org.mockito.ArgumentCaptor; import org.neo4j.driver.AccessMode; +import org.neo4j.driver.AuthTokens; import org.neo4j.driver.BookmarkManager; import org.neo4j.driver.Driver; import org.neo4j.driver.ExecutableQuery; @@ -43,11 +45,12 @@ import org.neo4j.driver.Record; import org.neo4j.driver.Result; import org.neo4j.driver.RoutingControl; +import org.neo4j.driver.Session; import org.neo4j.driver.SessionConfig; import org.neo4j.driver.TransactionCallback; import org.neo4j.driver.TransactionConfig; import org.neo4j.driver.TransactionContext; -import org.neo4j.driver.internal.telemetry.TelemetryApi; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; import org.neo4j.driver.summary.ResultSummary; class InternalExecutableQueryTest { @@ -55,27 +58,27 @@ class InternalExecutableQueryTest { void shouldNotAcceptNullDriverOnInstantiation() { assertThrows( NullPointerException.class, - () -> new InternalExecutableQuery(null, new Query("string"), QueryConfig.defaultConfig())); + () -> new InternalExecutableQuery(null, new Query("string"), QueryConfig.defaultConfig(), null)); } @Test void shouldNotAcceptNullQueryOnInstantiation() { assertThrows( NullPointerException.class, - () -> new InternalExecutableQuery(mock(Driver.class), null, QueryConfig.defaultConfig())); + () -> new InternalExecutableQuery(mock(Driver.class), null, QueryConfig.defaultConfig(), null)); } @Test void shouldNotAcceptNullConfigOnInstantiation() { assertThrows( NullPointerException.class, - () -> new InternalExecutableQuery(mock(Driver.class), new Query("string"), null)); + () -> new InternalExecutableQuery(mock(Driver.class), new Query("string"), null, null)); } @Test void shouldNotAcceptNullParameters() { var executableQuery = - new InternalExecutableQuery(mock(Driver.class), new Query("string"), QueryConfig.defaultConfig()); + new InternalExecutableQuery(mock(Driver.class), new Query("string"), QueryConfig.defaultConfig(), null); assertThrows(NullPointerException.class, () -> executableQuery.withParameters(null)); } @@ -84,7 +87,7 @@ void shouldUpdateParameters() { // GIVEN var query = new Query("string"); var params = Map.of("$param", "value"); - var executableQuery = new InternalExecutableQuery(mock(Driver.class), query, QueryConfig.defaultConfig()); + var executableQuery = new InternalExecutableQuery(mock(Driver.class), query, QueryConfig.defaultConfig(), null); // WHEN executableQuery = (InternalExecutableQuery) executableQuery.withParameters(params); @@ -96,7 +99,7 @@ void shouldUpdateParameters() { @Test void shouldNotAcceptNullConfig() { var executableQuery = - new InternalExecutableQuery(mock(Driver.class), new Query("string"), QueryConfig.defaultConfig()); + new InternalExecutableQuery(mock(Driver.class), new Query("string"), QueryConfig.defaultConfig(), null); assertThrows(NullPointerException.class, () -> executableQuery.withConfig(null)); } @@ -104,7 +107,7 @@ void shouldNotAcceptNullConfig() { void shouldUpdateConfig() { // GIVEN var query = new Query("string"); - var executableQuery = new InternalExecutableQuery(mock(Driver.class), query, QueryConfig.defaultConfig()); + var executableQuery = new InternalExecutableQuery(mock(Driver.class), query, QueryConfig.defaultConfig(), null); var config = QueryConfig.builder().withDatabase("database").build(); // WHEN @@ -127,7 +130,8 @@ void shouldExecuteAndReturnResult(RoutingControl routingControl) { var bookmarkManager = mock(BookmarkManager.class); given(driver.executableQueryBookmarkManager()).willReturn(bookmarkManager); var session = mock(InternalSession.class); - given(driver.session(any(SessionConfig.class))).willReturn(session); + given(driver.session(eq(Session.class), any(SessionConfig.class), eq(null))) + .willReturn(session); var txContext = mock(TransactionContext.class); var accessMode = routingControl.equals(RoutingControl.WRITE) ? AccessMode.WRITE : AccessMode.READ; given(session.execute( @@ -169,14 +173,14 @@ var record = mock(Record.class); var expectedExecuteResult = "1"; given(finisherWithSummary.finish(any(List.class), any(String.class), any(ResultSummary.class))) .willReturn(expectedExecuteResult); - var executableQuery = new InternalExecutableQuery(driver, query, config).withParameters(params); + var executableQuery = new InternalExecutableQuery(driver, query, config, null).withParameters(params); // WHEN var executeResult = executableQuery.execute(recordCollector, finisherWithSummary); // THEN var sessionConfigCapture = ArgumentCaptor.forClass(SessionConfig.class); - then(driver).should().session(sessionConfigCapture.capture()); + then(driver).should().session(eq(Session.class), sessionConfigCapture.capture(), eq(null)); var sessionConfig = sessionConfigCapture.getValue(); @SuppressWarnings("OptionalGetWithoutIsPresent") var expectedSessionConfig = SessionConfig.builder() @@ -205,4 +209,25 @@ var record = mock(Record.class); then(finisherWithSummary).should().finish(keys, collectorResult, summary); assertEquals(expectedExecuteResult, executeResult); } + + @Test + void shouldAllowNullAuthToken() { + var executableQuery = + new InternalExecutableQuery(mock(Driver.class), new Query("string"), QueryConfig.defaultConfig(), null); + + executableQuery.withAuthToken(null); + + assertNull(executableQuery.authToken()); + } + + @Test + void shouldUpdateAuthToken() { + var executableQuery = + new InternalExecutableQuery(mock(Driver.class), new Query("string"), QueryConfig.defaultConfig(), null); + var authToken = AuthTokens.basic("user", "password"); + + executableQuery = (InternalExecutableQuery) executableQuery.withAuthToken(authToken); + + assertEquals(authToken, executableQuery.authToken()); + } } diff --git a/driver/src/test/java/org/neo4j/driver/internal/InternalResultTest.java b/driver/src/test/java/org/neo4j/driver/internal/InternalResultTest.java index 3dfef0b5ad..ca740f9506 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/InternalResultTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/InternalResultTest.java @@ -17,8 +17,6 @@ package org.neo4j.driver.internal; import static java.util.Arrays.asList; -import static java.util.Collections.emptyMap; -import static java.util.Collections.singletonMap; import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.collection.IsCollectionWithSize.hasSize; @@ -34,11 +32,12 @@ import static org.neo4j.driver.Records.column; import static org.neo4j.driver.Values.ofString; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.BoltServerAddress.LOCAL_DEFAULT; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collections; import java.util.List; +import java.util.Map; import java.util.concurrent.CompletableFuture; import java.util.stream.Collectors; import org.junit.jupiter.api.Test; @@ -48,18 +47,16 @@ import org.neo4j.driver.Record; import org.neo4j.driver.Result; import org.neo4j.driver.Value; +import org.neo4j.driver.async.ResultCursor; import org.neo4j.driver.exceptions.NoSuchRecordException; import org.neo4j.driver.exceptions.ResultConsumedException; -import org.neo4j.driver.internal.cursor.AsyncResultCursor; -import org.neo4j.driver.internal.cursor.AsyncResultCursorImpl; -import org.neo4j.driver.internal.cursor.DisposableAsyncResultCursor; -import org.neo4j.driver.internal.handlers.LegacyPullAllResponseHandler; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.PullResponseCompletionListener; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3; -import org.neo4j.driver.internal.messaging.v43.BoltProtocolV43; -import org.neo4j.driver.internal.spi.Connection; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.summary.PullSummary; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.cursor.DisposableResultCursorImpl; +import org.neo4j.driver.internal.cursor.ResultCursorImpl; import org.neo4j.driver.internal.value.NullValue; import org.neo4j.driver.util.Pair; @@ -331,7 +328,7 @@ void shouldNotPeekIntoTheFutureWhenResultIsEmpty() { @ValueSource(booleans = {true, false}) void shouldDelegateIsOpen(boolean expectedState) { // GIVEN - var cursor = mock(AsyncResultCursor.class); + var cursor = mock(ResultCursor.class); given(cursor.isOpenAsync()).willReturn(CompletableFuture.completedFuture(expectedState)); Result result = new InternalResult(null, cursor); @@ -344,29 +341,55 @@ void shouldDelegateIsOpen(boolean expectedState) { } private Result createResult(int numberOfRecords) { - var runHandler = new RunResponseHandler( - new CompletableFuture<>(), BoltProtocolV3.METADATA_EXTRACTOR, mock(Connection.class), null); - runHandler.onSuccess(singletonMap("fields", value(Arrays.asList("k1", "k2")))); - var query = new Query(""); - var connection = mock(Connection.class); - when(connection.serverAddress()).thenReturn(LOCAL_DEFAULT); - when(connection.protocol()).thenReturn(BoltProtocolV43.INSTANCE); + var connection = mock(BoltConnection.class); + when(connection.serverAddress()).thenReturn(BoltServerAddress.LOCAL_DEFAULT); + when(connection.protocolVersion()).thenReturn(new BoltProtocolVersion(4, 3)); when(connection.serverAgent()).thenReturn("Neo4j/4.2.5"); - PullAllResponseHandler pullAllHandler = new LegacyPullAllResponseHandler( - query, - runHandler, - connection, - BoltProtocolV3.METADATA_EXTRACTOR, - mock(PullResponseCompletionListener.class)); + var resultCursor = new ResultCursorImpl( + connection, + query, + -1, + ignored -> {}, + ignored -> {}, + false, + new RunSummary() { + @Override + public long queryId() { + return 0; + } + + @Override + public List keys() { + return Arrays.asList("k1", "k2"); + } + + @Override + public long resultAvailableAfter() { + return 0; + } + }, + () -> null, + Collections.emptyList(), + null, + null, + null); for (var i = 1; i <= numberOfRecords; i++) { - pullAllHandler.onRecord(new Value[] {value("v1-" + i), value("v2-" + i)}); + resultCursor.onRecord(new Value[] {value("v1-" + i), value("v2-" + i)}); } - pullAllHandler.onSuccess(emptyMap()); - - AsyncResultCursor cursor = new AsyncResultCursorImpl(null, runHandler, pullAllHandler); - return new InternalResult(connection, new DisposableAsyncResultCursor(cursor)); + resultCursor.onPullSummary(new PullSummary() { + @Override + public boolean hasMore() { + return false; + } + + @Override + public Map metadata() { + return Map.of(); + } + }); + return new InternalResult(connection, new DisposableResultCursorImpl(resultCursor)); } private List values(Record record) { diff --git a/driver/src/test/java/org/neo4j/driver/internal/InternalSessionTest.java b/driver/src/test/java/org/neo4j/driver/internal/InternalSessionTest.java index 9079c1a663..170ceefc5a 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/InternalSessionTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/InternalSessionTest.java @@ -19,6 +19,8 @@ import static java.util.concurrent.CompletableFuture.completedFuture; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.BDDMockito.given; import static org.mockito.BDDMockito.then; import static org.mockito.Mockito.mock; @@ -30,15 +32,16 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; +import org.mockito.ArgumentMatcher; import org.neo4j.driver.Session; import org.neo4j.driver.TransactionCallback; import org.neo4j.driver.TransactionConfig; import org.neo4j.driver.TransactionContext; import org.neo4j.driver.internal.async.NetworkSession; import org.neo4j.driver.internal.async.UnmanagedTransaction; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; import org.neo4j.driver.internal.retry.RetryLogic; import org.neo4j.driver.internal.telemetry.ApiTelemetryWork; -import org.neo4j.driver.internal.telemetry.TelemetryApi; public class InternalSessionTest { NetworkSession networkSession; @@ -93,12 +96,14 @@ void shouldDelegateBeginWithType() { var config = TransactionConfig.empty(); var type = "TYPE"; var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); - given(networkSession.beginTransactionAsync(config, type, apiTelemetryWork)) + ArgumentMatcher apiMatcher = + argument -> apiTelemetryWork.telemetryApi().equals(argument.telemetryApi()); + given(networkSession.beginTransactionAsync(eq(config), eq(type), argThat(apiMatcher))) .willReturn(completedFuture(mock(UnmanagedTransaction.class))); internalSession.beginTransaction(config, type); - then(networkSession).should().beginTransactionAsync(config, type, apiTelemetryWork); + then(networkSession).should().beginTransactionAsync(eq(config), eq(type), argThat(apiMatcher)); } static List executeVariations() { diff --git a/driver/src/test/java/org/neo4j/driver/internal/InternalTransactionTest.java b/driver/src/test/java/org/neo4j/driver/internal/InternalTransactionTest.java index a2ee49e531..a885713598 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/InternalTransactionTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/InternalTransactionTest.java @@ -18,13 +18,12 @@ import static java.util.Collections.singletonList; import static java.util.Collections.singletonMap; -import static java.util.concurrent.CompletableFuture.completedFuture; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; import static org.neo4j.driver.Values.parameters; import static org.neo4j.driver.testutil.TestUtil.connectionMock; import static org.neo4j.driver.testutil.TestUtil.newSession; @@ -36,6 +35,9 @@ import static org.neo4j.driver.testutil.TestUtil.verifyRollbackTx; import static org.neo4j.driver.testutil.TestUtil.verifyRunAndPull; +import java.util.Collections; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; import java.util.function.Consumer; import java.util.function.Function; import java.util.stream.Stream; @@ -43,32 +45,45 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; +import org.mockito.stubbing.Answer; import org.neo4j.driver.Query; import org.neo4j.driver.Result; import org.neo4j.driver.Transaction; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.async.ConnectionContext; -import org.neo4j.driver.internal.messaging.v4.BoltProtocolV4; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.ResponseHandler; +import org.neo4j.driver.internal.bolt.api.summary.BeginSummary; +import org.neo4j.driver.internal.bolt.api.summary.CommitSummary; +import org.neo4j.driver.internal.bolt.api.summary.RollbackSummary; import org.neo4j.driver.internal.value.IntegerValue; class InternalTransactionTest { private static final String DATABASE = "neo4j"; - private Connection connection; + private BoltConnection connection; private Transaction tx; @BeforeEach @SuppressWarnings("resource") void setUp() { - connection = connectionMock(BoltProtocolV4.INSTANCE); - var connectionProvider = mock(ConnectionProvider.class); - when(connectionProvider.acquireConnection(any(ConnectionContext.class))).thenAnswer(invocation -> { - var context = (ConnectionContext) invocation.getArgument(0); - context.databaseNameFuture().complete(DatabaseNameUtil.database(DATABASE)); - return completedFuture(connection); + connection = connectionMock(new BoltProtocolVersion(4, 0)); + var connectionProvider = mock(BoltConnectionProvider.class); + given(connectionProvider.connect(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(CompletableFuture.completedFuture(connection)); + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(CompletableFuture.completedStage(connection)); + given(connection.flush(any())).willAnswer((Answer>) invocation -> { + var handler = (ResponseHandler) invocation.getArgument(0); + if (handler == null) { + // for mocking only + return CompletableFuture.completedFuture(null); + } else { + handler.onBeginSummary(mock(BeginSummary.class)); + return CompletableFuture.completedFuture(null); + } }); - var session = new InternalSession(newSession(connectionProvider)); + var session = new InternalSession(newSession(connectionProvider, Collections.emptySet())); tx = session.beginTransaction(); } @@ -94,6 +109,14 @@ void shouldFlushOnRun(Function runReturnOne) { @Test void shouldCommit() { + given(connection.commit()).willReturn(CompletableFuture.completedStage(connection)); + given(connection.flush(any())).willAnswer((Answer>) invocation -> { + var handler = (ResponseHandler) invocation.getArgument(0); + handler.onCommitSummary(mock(CommitSummary.class)); + return CompletableFuture.completedStage(null); + }); + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); + tx.commit(); tx.close(); @@ -103,6 +126,14 @@ void shouldCommit() { @Test void shouldRollbackByDefault() { + given(connection.rollback()).willReturn(CompletableFuture.completedStage(connection)); + given(connection.flush(any())).willAnswer((Answer>) invocation -> { + var handler = (ResponseHandler) invocation.getArgument(0); + handler.onRollbackSummary(mock(RollbackSummary.class)); + return CompletableFuture.completedStage(null); + }); + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); + tx.close(); verifyRollbackTx(connection); @@ -111,6 +142,14 @@ void shouldRollbackByDefault() { @Test void shouldRollback() { + given(connection.rollback()).willReturn(CompletableFuture.completedStage(connection)); + given(connection.flush(any())).willAnswer((Answer>) invocation -> { + var handler = (ResponseHandler) invocation.getArgument(0); + handler.onRollbackSummary(mock(RollbackSummary.class)); + return CompletableFuture.completedStage(null); + }); + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); + tx.rollback(); tx.close(); @@ -120,39 +159,43 @@ void shouldRollback() { @Test void shouldRollbackWhenFailedRun() { + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); setupFailingRun(connection, new RuntimeException("Bang!")); + assertThrows(RuntimeException.class, () -> tx.run("RETURN 1")); tx.close(); - verify(connection).release(); + verify(connection).close(); assertFalse(tx.isOpen()); } @Test - void shouldReleaseConnectionWhenFailedToCommit() { + void shouldCloseConnectionWhenFailedToCommit() { + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); setupFailingCommit(connection); + assertThrows(Exception.class, () -> tx.commit()); - verify(connection).release(); + verify(connection).close(); assertFalse(tx.isOpen()); } @Test - void shouldReleaseConnectionWhenFailedToRollback() { - shouldReleaseConnectionWhenFailedToAction(Transaction::rollback); + void shouldCloseConnectionWhenFailedToRollback() { + shouldCloseConnectionWhenFailedToAction(Transaction::rollback); } @Test - void shouldReleaseConnectionWhenFailedToClose() { - shouldReleaseConnectionWhenFailedToAction(Transaction::close); + void shouldCloseConnectionWhenFailedToClose() { + shouldCloseConnectionWhenFailedToAction(Transaction::close); } - private void shouldReleaseConnectionWhenFailedToAction(Consumer txAction) { + private void shouldCloseConnectionWhenFailedToAction(Consumer txAction) { setupFailingRollback(connection); assertThrows(Exception.class, () -> txAction.accept(tx)); - verify(connection).release(); + verify(connection).close(); assertFalse(tx.isOpen()); } } 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 a46c0a4b03..3ffea1f09f 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/SessionFactoryImplTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/SessionFactoryImplTest.java @@ -24,10 +24,11 @@ import org.junit.jupiter.api.Test; import org.neo4j.driver.AccessMode; +import org.neo4j.driver.AuthTokenManager; import org.neo4j.driver.Config; import org.neo4j.driver.internal.async.LeakLoggingNetworkSession; import org.neo4j.driver.internal.async.NetworkSession; -import org.neo4j.driver.internal.spi.ConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; import org.neo4j.driver.internal.util.FixedRetryLogic; class SessionFactoryImplTest { @@ -37,11 +38,17 @@ void createsNetworkSessions() { var factory = newSessionFactory(config); var readSession = factory.newInstance( - builder().withDefaultAccessMode(AccessMode.READ).build(), null, true); + builder().withDefaultAccessMode(AccessMode.READ).build(), + Config.defaultConfig().notificationConfig(), + null, + true); assertThat(readSession, instanceOf(NetworkSession.class)); var writeSession = factory.newInstance( - builder().withDefaultAccessMode(AccessMode.WRITE).build(), null, true); + builder().withDefaultAccessMode(AccessMode.WRITE).build(), + Config.defaultConfig().notificationConfig(), + null, + true); assertThat(writeSession, instanceOf(NetworkSession.class)); } @@ -54,15 +61,22 @@ void createsLeakLoggingNetworkSessions() { var factory = newSessionFactory(config); var readSession = factory.newInstance( - builder().withDefaultAccessMode(AccessMode.READ).build(), null, true); + builder().withDefaultAccessMode(AccessMode.READ).build(), + Config.defaultConfig().notificationConfig(), + null, + true); assertThat(readSession, instanceOf(LeakLoggingNetworkSession.class)); var writeSession = factory.newInstance( - builder().withDefaultAccessMode(AccessMode.WRITE).build(), null, true); + builder().withDefaultAccessMode(AccessMode.WRITE).build(), + Config.defaultConfig().notificationConfig(), + null, + true); assertThat(writeSession, instanceOf(LeakLoggingNetworkSession.class)); } private static SessionFactory newSessionFactory(Config config) { - return new SessionFactoryImpl(mock(ConnectionProvider.class), new FixedRetryLogic(0), config); + return new SessionFactoryImpl( + mock(BoltConnectionProvider.class), new FixedRetryLogic(0), config, mock(AuthTokenManager.class)); } } diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/AsyncResultCursorImplTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/AsyncResultCursorImplTest.java index 300199fc88..950eaac516 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/AsyncResultCursorImplTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/async/AsyncResultCursorImplTest.java @@ -14,387 +14,387 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async; - -import static java.util.Arrays.asList; -import static java.util.Collections.emptyList; -import static java.util.Collections.singletonList; -import static java.util.Collections.singletonMap; -import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsString; -import static org.junit.jupiter.api.Assertions.assertEquals; -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.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.Values.values; -import static org.neo4j.driver.internal.summary.InternalDatabaseInfo.DEFAULT_DATABASE_INFO; -import static org.neo4j.driver.internal.util.Futures.completedWithNull; -import static org.neo4j.driver.internal.util.Futures.failedFuture; -import static org.neo4j.driver.testutil.TestUtil.await; - -import java.util.List; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CopyOnWriteArrayList; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.function.Function; -import org.junit.jupiter.api.Test; -import org.neo4j.driver.Query; -import org.neo4j.driver.Record; -import org.neo4j.driver.exceptions.NoSuchRecordException; -import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.InternalRecord; -import org.neo4j.driver.internal.cursor.AsyncResultCursorImpl; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3; -import org.neo4j.driver.internal.messaging.v43.BoltProtocolV43; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.summary.InternalResultSummary; -import org.neo4j.driver.internal.summary.InternalServerInfo; -import org.neo4j.driver.internal.summary.InternalSummaryCounters; -import org.neo4j.driver.summary.QueryType; -import org.neo4j.driver.summary.ResultSummary; - -class AsyncResultCursorImplTest { - @Test - void shouldReturnQueryKeys() { - var runHandler = newRunResponseHandler(); - var pullAllHandler = mock(PullAllResponseHandler.class); - - var keys = asList("key1", "key2", "key3"); - runHandler.onSuccess(singletonMap("fields", value(keys))); - - var cursor = newCursor(runHandler, pullAllHandler); - - assertEquals(keys, cursor.keys()); - } - - @Test - void shouldReturnSummary() { - var pullAllHandler = mock(PullAllResponseHandler.class); - - ResultSummary summary = new InternalResultSummary( - new Query("RETURN 42"), - new InternalServerInfo("Neo4j/4.2.5", BoltServerAddress.LOCAL_DEFAULT, BoltProtocolV43.VERSION), - DEFAULT_DATABASE_INFO, - QueryType.SCHEMA_WRITE, - new InternalSummaryCounters(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0), - null, - null, - emptyList(), - 42, - 42); - when(pullAllHandler.consumeAsync()).thenReturn(completedFuture(summary)); - - var cursor = newCursor(pullAllHandler); - - assertEquals(summary, await(cursor.consumeAsync())); - } - - @Test - void shouldReturnNextExistingRecord() { - var pullAllHandler = mock(PullAllResponseHandler.class); - - Record record = new InternalRecord(asList("key1", "key2"), values(1, 2)); - when(pullAllHandler.nextAsync()).thenReturn(completedFuture(record)); - - var cursor = newCursor(pullAllHandler); - - assertEquals(record, await(cursor.nextAsync())); - } - - @Test - void shouldReturnNextNonExistingRecord() { - var pullAllHandler = mock(PullAllResponseHandler.class); - when(pullAllHandler.nextAsync()).thenReturn(completedWithNull()); - - var cursor = newCursor(pullAllHandler); - - assertNull(await(cursor.nextAsync())); - } - - @Test - void shouldPeekExistingRecord() { - var pullAllHandler = mock(PullAllResponseHandler.class); - - Record record = new InternalRecord(asList("key1", "key2", "key3"), values(3, 2, 1)); - when(pullAllHandler.peekAsync()).thenReturn(completedFuture(record)); - - var cursor = newCursor(pullAllHandler); - - assertEquals(record, await(cursor.peekAsync())); - } - - @Test - void shouldPeekNonExistingRecord() { - var pullAllHandler = mock(PullAllResponseHandler.class); - when(pullAllHandler.peekAsync()).thenReturn(completedWithNull()); - - var cursor = newCursor(pullAllHandler); - - assertNull(await(cursor.peekAsync())); - } - - @Test - void shouldReturnSingleRecord() { - var pullAllHandler = mock(PullAllResponseHandler.class); - - Record record = new InternalRecord(asList("key1", "key2"), values(42, 42)); - when(pullAllHandler.nextAsync()).thenReturn(completedFuture(record)).thenReturn(completedWithNull()); - - var cursor = newCursor(pullAllHandler); - - assertEquals(record, await(cursor.singleAsync())); - } - - @Test - void shouldFailWhenAskedForSingleRecordButResultIsEmpty() { - var pullAllHandler = mock(PullAllResponseHandler.class); - when(pullAllHandler.nextAsync()).thenReturn(completedWithNull()); - - var cursor = newCursor(pullAllHandler); - - var e = assertThrows(NoSuchRecordException.class, () -> await(cursor.singleAsync())); - assertThat(e.getMessage(), containsString("result is empty")); - } - - @Test - void shouldFailWhenAskedForSingleRecordButResultContainsMore() { - var pullAllHandler = mock(PullAllResponseHandler.class); - - Record record1 = new InternalRecord(asList("key1", "key2"), values(1, 1)); - Record record2 = new InternalRecord(asList("key1", "key2"), values(2, 2)); - when(pullAllHandler.nextAsync()).thenReturn(completedFuture(record1)).thenReturn(completedFuture(record2)); - - var cursor = newCursor(pullAllHandler); - - var e = assertThrows(NoSuchRecordException.class, () -> await(cursor.singleAsync())); - assertThat(e.getMessage(), containsString("Ensure your query returns only one record")); - } - - @Test - void shouldForEachAsyncWhenResultContainsMultipleRecords() { - var pullAllHandler = mock(PullAllResponseHandler.class); - - Record record1 = new InternalRecord(asList("key1", "key2", "key3"), values(1, 1, 1)); - Record record2 = new InternalRecord(asList("key1", "key2", "key3"), values(2, 2, 2)); - Record record3 = new InternalRecord(asList("key1", "key2", "key3"), values(3, 3, 3)); - when(pullAllHandler.nextAsync()) - .thenReturn(completedFuture(record1)) - .thenReturn(completedFuture(record2)) - .thenReturn(completedFuture(record3)) - .thenReturn(completedWithNull()); - - var summary = mock(ResultSummary.class); - when(pullAllHandler.consumeAsync()).thenReturn(completedFuture(summary)); - - var cursor = newCursor(pullAllHandler); - - List records = new CopyOnWriteArrayList<>(); - var summaryStage = cursor.forEachAsync(records::add); - - assertEquals(summary, await(summaryStage)); - assertEquals(asList(record1, record2, record3), records); - } - - @Test - void shouldForEachAsyncWhenResultContainsOneRecords() { - var pullAllHandler = mock(PullAllResponseHandler.class); - - Record record = new InternalRecord(asList("key1", "key2", "key3"), values(1, 1, 1)); - when(pullAllHandler.nextAsync()).thenReturn(completedFuture(record)).thenReturn(completedWithNull()); - - var summary = mock(ResultSummary.class); - when(pullAllHandler.consumeAsync()).thenReturn(completedFuture(summary)); - - var cursor = newCursor(pullAllHandler); - - List records = new CopyOnWriteArrayList<>(); - var summaryStage = cursor.forEachAsync(records::add); - - assertEquals(summary, await(summaryStage)); - assertEquals(singletonList(record), records); - } - - @Test - void shouldForEachAsyncWhenResultContainsNoRecords() { - var pullAllHandler = mock(PullAllResponseHandler.class); - when(pullAllHandler.nextAsync()).thenReturn(completedWithNull()); - - var summary = mock(ResultSummary.class); - when(pullAllHandler.consumeAsync()).thenReturn(completedFuture(summary)); - - var cursor = newCursor(pullAllHandler); - - List records = new CopyOnWriteArrayList<>(); - var summaryStage = cursor.forEachAsync(records::add); - - assertEquals(summary, await(summaryStage)); - assertEquals(0, records.size()); - } - - @Test - void shouldFailForEachWhenGivenActionThrows() { - var pullAllHandler = mock(PullAllResponseHandler.class); - - Record record1 = new InternalRecord(asList("key1", "key2"), values(1, 1)); - Record record2 = new InternalRecord(asList("key1", "key2"), values(2, 2)); - Record record3 = new InternalRecord(asList("key1", "key2"), values(3, 3)); - when(pullAllHandler.nextAsync()) - .thenReturn(completedFuture(record1)) - .thenReturn(completedFuture(record2)) - .thenReturn(completedFuture(record3)) - .thenReturn(completedWithNull()); - - var cursor = newCursor(pullAllHandler); - - var recordsProcessed = new AtomicInteger(); - var error = new RuntimeException("Hello"); - - var stage = cursor.forEachAsync(record -> { - if (record.get("key2").asInt() == 2) { - throw error; - } else { - recordsProcessed.incrementAndGet(); - } - }); - - var e = assertThrows(RuntimeException.class, () -> await(stage)); - assertEquals(error, e); - - assertEquals(1, recordsProcessed.get()); - verify(pullAllHandler, times(2)).nextAsync(); - } - - @Test - void shouldReturnFailureWhenExists() { - var pullAllHandler = mock(PullAllResponseHandler.class); - - var error = new ServiceUnavailableException("Hi"); - when(pullAllHandler.pullAllFailureAsync()).thenReturn(completedFuture(error)); - - var cursor = newCursor(pullAllHandler); - - assertEquals(error, await(cursor.pullAllFailureAsync())); - } - - @Test - void shouldReturnNullFailureWhenDoesNotExist() { - var pullAllHandler = mock(PullAllResponseHandler.class); - when(pullAllHandler.pullAllFailureAsync()).thenReturn(completedWithNull()); - - var cursor = newCursor(pullAllHandler); - - assertNull(await(cursor.pullAllFailureAsync())); - } - - @Test - void shouldListAsyncWithoutMapFunction() { - var pullAllHandler = mock(PullAllResponseHandler.class); - - Record record1 = new InternalRecord(asList("key1", "key2"), values(1, 1)); - Record record2 = new InternalRecord(asList("key1", "key2"), values(2, 2)); - var records = asList(record1, record2); - - when(pullAllHandler.listAsync(Function.identity())).thenReturn(completedFuture(records)); - - var cursor = newCursor(pullAllHandler); - - assertEquals(records, await(cursor.listAsync())); - verify(pullAllHandler).listAsync(Function.identity()); - } - - @Test - void shouldListAsyncWithMapFunction() { - Function mapFunction = record -> record.get(0).asString(); - var pullAllHandler = mock(PullAllResponseHandler.class); - - var values = asList("a", "b", "c", "d", "e"); - when(pullAllHandler.listAsync(mapFunction)).thenReturn(completedFuture(values)); - - var cursor = newCursor(pullAllHandler); - - assertEquals(values, await(cursor.listAsync(mapFunction))); - verify(pullAllHandler).listAsync(mapFunction); - } - - @Test - void shouldPropagateFailureFromListAsyncWithoutMapFunction() { - var pullAllHandler = mock(PullAllResponseHandler.class); - var error = new RuntimeException("Hi"); - when(pullAllHandler.listAsync(Function.identity())).thenReturn(failedFuture(error)); - - var cursor = newCursor(pullAllHandler); - - var e = assertThrows(RuntimeException.class, () -> await(cursor.listAsync())); - assertEquals(error, e); - verify(pullAllHandler).listAsync(Function.identity()); - } - - @Test - void shouldPropagateFailureFromListAsyncWithMapFunction() { - Function mapFunction = record -> record.get(0).asString(); - var pullAllHandler = mock(PullAllResponseHandler.class); - var error = new RuntimeException("Hi"); - when(pullAllHandler.listAsync(mapFunction)).thenReturn(failedFuture(error)); - - var cursor = newCursor(pullAllHandler); - - var e = assertThrows(RuntimeException.class, () -> await(cursor.listAsync(mapFunction))); - assertEquals(error, e); - - verify(pullAllHandler).listAsync(mapFunction); - } - - @Test - void shouldConsumeAsync() { - var pullAllHandler = mock(PullAllResponseHandler.class); - var summary = mock(ResultSummary.class); - when(pullAllHandler.consumeAsync()).thenReturn(completedFuture(summary)); - - var cursor = newCursor(pullAllHandler); - - assertEquals(summary, await(cursor.consumeAsync())); - } - - @Test - void shouldPropagateFailureInConsumeAsync() { - var pullAllHandler = mock(PullAllResponseHandler.class); - var error = new RuntimeException("Hi"); - when(pullAllHandler.consumeAsync()).thenReturn(failedFuture(error)); - - var cursor = newCursor(pullAllHandler); - - var e = assertThrows(RuntimeException.class, () -> await(cursor.consumeAsync())); - assertEquals(error, e); - } - - @Test - void shouldThrowOnIsOpenAsync() { - // GIVEN - var cursor = new AsyncResultCursorImpl(null, null, null); - - // WHEN & THEN - assertThrows(UnsupportedOperationException.class, cursor::isOpenAsync); - } - - private static AsyncResultCursorImpl newCursor(PullAllResponseHandler pullAllHandler) { - return new AsyncResultCursorImpl(null, newRunResponseHandler(), pullAllHandler); - } - - private static AsyncResultCursorImpl newCursor( - RunResponseHandler runHandler, PullAllResponseHandler pullAllHandler) { - return new AsyncResultCursorImpl(null, runHandler, pullAllHandler); - } - - private static RunResponseHandler newRunResponseHandler() { - return new RunResponseHandler( - new CompletableFuture<>(), BoltProtocolV3.METADATA_EXTRACTOR, mock(Connection.class), null); - } -} +// package org.neo4j.driver.internal.async; +// +// import static java.util.Arrays.asList; +// import static java.util.Collections.emptyList; +// import static java.util.Collections.singletonList; +// import static java.util.Collections.singletonMap; +// import static java.util.concurrent.CompletableFuture.completedFuture; +// import static org.hamcrest.MatcherAssert.assertThat; +// import static org.hamcrest.Matchers.containsString; +// import static org.junit.jupiter.api.Assertions.assertEquals; +// 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.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.Values.values; +// import static org.neo4j.driver.internal.summary.InternalDatabaseInfo.DEFAULT_DATABASE_INFO; +// import static org.neo4j.driver.internal.util.Futures.completedWithNull; +// import static org.neo4j.driver.internal.util.Futures.failedFuture; +// import static org.neo4j.driver.testutil.TestUtil.await; +// +// import java.util.List; +// import java.util.concurrent.CompletableFuture; +// import java.util.concurrent.CopyOnWriteArrayList; +// import java.util.concurrent.atomic.AtomicInteger; +// import java.util.function.Function; +// import org.junit.jupiter.api.Test; +// import org.neo4j.driver.Query; +// import org.neo4j.driver.Record; +// import org.neo4j.driver.exceptions.NoSuchRecordException; +// import org.neo4j.driver.exceptions.ServiceUnavailableException; +// import org.neo4j.driver.internal.BoltServerAddress; +// import org.neo4j.driver.internal.InternalRecord; +// import org.neo4j.driver.internal.cursor.AsyncResultCursorImpl; +// import org.neo4j.driver.internal.handlers.PullAllResponseHandler; +// import org.neo4j.driver.internal.handlers.RunResponseHandler; +// import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3; +// import org.neo4j.driver.internal.messaging.v43.BoltProtocolV43; +// import org.neo4j.driver.internal.spi.Connection; +// import org.neo4j.driver.internal.summary.InternalResultSummary; +// import org.neo4j.driver.internal.summary.InternalServerInfo; +// import org.neo4j.driver.internal.summary.InternalSummaryCounters; +// import org.neo4j.driver.summary.QueryType; +// import org.neo4j.driver.summary.ResultSummary; +// +// class AsyncResultCursorImplTest { +// @Test +// void shouldReturnQueryKeys() { +// var runHandler = newRunResponseHandler(); +// var pullAllHandler = mock(PullAllResponseHandler.class); +// +// var keys = asList("key1", "key2", "key3"); +// runHandler.onSuccess(singletonMap("fields", value(keys))); +// +// var cursor = newCursor(runHandler, pullAllHandler); +// +// assertEquals(keys, cursor.keys()); +// } +// +// @Test +// void shouldReturnSummary() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// +// ResultSummary summary = new InternalResultSummary( +// new Query("RETURN 42"), +// new InternalServerInfo("Neo4j/4.2.5", BoltServerAddress.LOCAL_DEFAULT, BoltProtocolV43.VERSION), +// DEFAULT_DATABASE_INFO, +// QueryType.SCHEMA_WRITE, +// new InternalSummaryCounters(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0), +// null, +// null, +// emptyList(), +// 42, +// 42); +// when(pullAllHandler.consumeAsync()).thenReturn(completedFuture(summary)); +// +// var cursor = newCursor(pullAllHandler); +// +// assertEquals(summary, await(cursor.consumeAsync())); +// } +// +// @Test +// void shouldReturnNextExistingRecord() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// +// Record record = new InternalRecord(asList("key1", "key2"), values(1, 2)); +// when(pullAllHandler.nextAsync()).thenReturn(completedFuture(record)); +// +// var cursor = newCursor(pullAllHandler); +// +// assertEquals(record, await(cursor.nextAsync())); +// } +// +// @Test +// void shouldReturnNextNonExistingRecord() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// when(pullAllHandler.nextAsync()).thenReturn(completedWithNull()); +// +// var cursor = newCursor(pullAllHandler); +// +// assertNull(await(cursor.nextAsync())); +// } +// +// @Test +// void shouldPeekExistingRecord() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// +// Record record = new InternalRecord(asList("key1", "key2", "key3"), values(3, 2, 1)); +// when(pullAllHandler.peekAsync()).thenReturn(completedFuture(record)); +// +// var cursor = newCursor(pullAllHandler); +// +// assertEquals(record, await(cursor.peekAsync())); +// } +// +// @Test +// void shouldPeekNonExistingRecord() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// when(pullAllHandler.peekAsync()).thenReturn(completedWithNull()); +// +// var cursor = newCursor(pullAllHandler); +// +// assertNull(await(cursor.peekAsync())); +// } +// +// @Test +// void shouldReturnSingleRecord() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// +// Record record = new InternalRecord(asList("key1", "key2"), values(42, 42)); +// when(pullAllHandler.nextAsync()).thenReturn(completedFuture(record)).thenReturn(completedWithNull()); +// +// var cursor = newCursor(pullAllHandler); +// +// assertEquals(record, await(cursor.singleAsync())); +// } +// +// @Test +// void shouldFailWhenAskedForSingleRecordButResultIsEmpty() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// when(pullAllHandler.nextAsync()).thenReturn(completedWithNull()); +// +// var cursor = newCursor(pullAllHandler); +// +// var e = assertThrows(NoSuchRecordException.class, () -> await(cursor.singleAsync())); +// assertThat(e.getMessage(), containsString("result is empty")); +// } +// +// @Test +// void shouldFailWhenAskedForSingleRecordButResultContainsMore() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// +// Record record1 = new InternalRecord(asList("key1", "key2"), values(1, 1)); +// Record record2 = new InternalRecord(asList("key1", "key2"), values(2, 2)); +// when(pullAllHandler.nextAsync()).thenReturn(completedFuture(record1)).thenReturn(completedFuture(record2)); +// +// var cursor = newCursor(pullAllHandler); +// +// var e = assertThrows(NoSuchRecordException.class, () -> await(cursor.singleAsync())); +// assertThat(e.getMessage(), containsString("Ensure your query returns only one record")); +// } +// +// @Test +// void shouldForEachAsyncWhenResultContainsMultipleRecords() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// +// Record record1 = new InternalRecord(asList("key1", "key2", "key3"), values(1, 1, 1)); +// Record record2 = new InternalRecord(asList("key1", "key2", "key3"), values(2, 2, 2)); +// Record record3 = new InternalRecord(asList("key1", "key2", "key3"), values(3, 3, 3)); +// when(pullAllHandler.nextAsync()) +// .thenReturn(completedFuture(record1)) +// .thenReturn(completedFuture(record2)) +// .thenReturn(completedFuture(record3)) +// .thenReturn(completedWithNull()); +// +// var summary = mock(ResultSummary.class); +// when(pullAllHandler.consumeAsync()).thenReturn(completedFuture(summary)); +// +// var cursor = newCursor(pullAllHandler); +// +// List records = new CopyOnWriteArrayList<>(); +// var summaryStage = cursor.forEachAsync(records::add); +// +// assertEquals(summary, await(summaryStage)); +// assertEquals(asList(record1, record2, record3), records); +// } +// +// @Test +// void shouldForEachAsyncWhenResultContainsOneRecords() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// +// Record record = new InternalRecord(asList("key1", "key2", "key3"), values(1, 1, 1)); +// when(pullAllHandler.nextAsync()).thenReturn(completedFuture(record)).thenReturn(completedWithNull()); +// +// var summary = mock(ResultSummary.class); +// when(pullAllHandler.consumeAsync()).thenReturn(completedFuture(summary)); +// +// var cursor = newCursor(pullAllHandler); +// +// List records = new CopyOnWriteArrayList<>(); +// var summaryStage = cursor.forEachAsync(records::add); +// +// assertEquals(summary, await(summaryStage)); +// assertEquals(singletonList(record), records); +// } +// +// @Test +// void shouldForEachAsyncWhenResultContainsNoRecords() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// when(pullAllHandler.nextAsync()).thenReturn(completedWithNull()); +// +// var summary = mock(ResultSummary.class); +// when(pullAllHandler.consumeAsync()).thenReturn(completedFuture(summary)); +// +// var cursor = newCursor(pullAllHandler); +// +// List records = new CopyOnWriteArrayList<>(); +// var summaryStage = cursor.forEachAsync(records::add); +// +// assertEquals(summary, await(summaryStage)); +// assertEquals(0, records.size()); +// } +// +// @Test +// void shouldFailForEachWhenGivenActionThrows() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// +// Record record1 = new InternalRecord(asList("key1", "key2"), values(1, 1)); +// Record record2 = new InternalRecord(asList("key1", "key2"), values(2, 2)); +// Record record3 = new InternalRecord(asList("key1", "key2"), values(3, 3)); +// when(pullAllHandler.nextAsync()) +// .thenReturn(completedFuture(record1)) +// .thenReturn(completedFuture(record2)) +// .thenReturn(completedFuture(record3)) +// .thenReturn(completedWithNull()); +// +// var cursor = newCursor(pullAllHandler); +// +// var recordsProcessed = new AtomicInteger(); +// var error = new RuntimeException("Hello"); +// +// var stage = cursor.forEachAsync(record -> { +// if (record.get("key2").asInt() == 2) { +// throw error; +// } else { +// recordsProcessed.incrementAndGet(); +// } +// }); +// +// var e = assertThrows(RuntimeException.class, () -> await(stage)); +// assertEquals(error, e); +// +// assertEquals(1, recordsProcessed.get()); +// verify(pullAllHandler, times(2)).nextAsync(); +// } +// +// @Test +// void shouldReturnFailureWhenExists() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// +// var error = new ServiceUnavailableException("Hi"); +// when(pullAllHandler.pullAllFailureAsync()).thenReturn(completedFuture(error)); +// +// var cursor = newCursor(pullAllHandler); +// +// assertEquals(error, await(cursor.pullAllFailureAsync())); +// } +// +// @Test +// void shouldReturnNullFailureWhenDoesNotExist() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// when(pullAllHandler.pullAllFailureAsync()).thenReturn(completedWithNull()); +// +// var cursor = newCursor(pullAllHandler); +// +// assertNull(await(cursor.pullAllFailureAsync())); +// } +// +// @Test +// void shouldListAsyncWithoutMapFunction() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// +// Record record1 = new InternalRecord(asList("key1", "key2"), values(1, 1)); +// Record record2 = new InternalRecord(asList("key1", "key2"), values(2, 2)); +// var records = asList(record1, record2); +// +// when(pullAllHandler.listAsync(Function.identity())).thenReturn(completedFuture(records)); +// +// var cursor = newCursor(pullAllHandler); +// +// assertEquals(records, await(cursor.listAsync())); +// verify(pullAllHandler).listAsync(Function.identity()); +// } +// +// @Test +// void shouldListAsyncWithMapFunction() { +// Function mapFunction = record -> record.get(0).asString(); +// var pullAllHandler = mock(PullAllResponseHandler.class); +// +// var values = asList("a", "b", "c", "d", "e"); +// when(pullAllHandler.listAsync(mapFunction)).thenReturn(completedFuture(values)); +// +// var cursor = newCursor(pullAllHandler); +// +// assertEquals(values, await(cursor.listAsync(mapFunction))); +// verify(pullAllHandler).listAsync(mapFunction); +// } +// +// @Test +// void shouldPropagateFailureFromListAsyncWithoutMapFunction() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// var error = new RuntimeException("Hi"); +// when(pullAllHandler.listAsync(Function.identity())).thenReturn(failedFuture(error)); +// +// var cursor = newCursor(pullAllHandler); +// +// var e = assertThrows(RuntimeException.class, () -> await(cursor.listAsync())); +// assertEquals(error, e); +// verify(pullAllHandler).listAsync(Function.identity()); +// } +// +// @Test +// void shouldPropagateFailureFromListAsyncWithMapFunction() { +// Function mapFunction = record -> record.get(0).asString(); +// var pullAllHandler = mock(PullAllResponseHandler.class); +// var error = new RuntimeException("Hi"); +// when(pullAllHandler.listAsync(mapFunction)).thenReturn(failedFuture(error)); +// +// var cursor = newCursor(pullAllHandler); +// +// var e = assertThrows(RuntimeException.class, () -> await(cursor.listAsync(mapFunction))); +// assertEquals(error, e); +// +// verify(pullAllHandler).listAsync(mapFunction); +// } +// +// @Test +// void shouldConsumeAsync() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// var summary = mock(ResultSummary.class); +// when(pullAllHandler.consumeAsync()).thenReturn(completedFuture(summary)); +// +// var cursor = newCursor(pullAllHandler); +// +// assertEquals(summary, await(cursor.consumeAsync())); +// } +// +// @Test +// void shouldPropagateFailureInConsumeAsync() { +// var pullAllHandler = mock(PullAllResponseHandler.class); +// var error = new RuntimeException("Hi"); +// when(pullAllHandler.consumeAsync()).thenReturn(failedFuture(error)); +// +// var cursor = newCursor(pullAllHandler); +// +// var e = assertThrows(RuntimeException.class, () -> await(cursor.consumeAsync())); +// assertEquals(error, e); +// } +// +// @Test +// void shouldThrowOnIsOpenAsync() { +// // GIVEN +// var cursor = new AsyncResultCursorImpl(null, null, null); +// +// // WHEN & THEN +// assertThrows(UnsupportedOperationException.class, cursor::isOpenAsync); +// } +// +// private static AsyncResultCursorImpl newCursor(PullAllResponseHandler pullAllHandler) { +// return new AsyncResultCursorImpl(null, newRunResponseHandler(), pullAllHandler); +// } +// +// private static AsyncResultCursorImpl newCursor( +// RunResponseHandler runHandler, PullAllResponseHandler pullAllHandler) { +// return new AsyncResultCursorImpl(null, runHandler, pullAllHandler); +// } +// +// private static RunResponseHandler newRunResponseHandler() { +// return new RunResponseHandler( +// new CompletableFuture<>(), BoltProtocolV3.METADATA_EXTRACTOR, mock(Connection.class), null); +// } +// } diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncSessionTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncSessionTest.java index b17304fef2..af825f49ea 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncSessionTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncSessionTest.java @@ -14,389 +14,390 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async; - -import static java.util.Collections.singletonList; -import static java.util.Collections.singletonMap; -import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.CoreMatchers.instanceOf; -import static org.hamcrest.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.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertThrows; -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.never; -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.AccessMode.READ; -import static org.neo4j.driver.AccessMode.WRITE; -import static org.neo4j.driver.TransactionConfig.empty; -import static org.neo4j.driver.Values.parameters; -import static org.neo4j.driver.testutil.TestUtil.await; -import static org.neo4j.driver.testutil.TestUtil.connectionMock; -import static org.neo4j.driver.testutil.TestUtil.newSession; -import static org.neo4j.driver.testutil.TestUtil.setupFailingCommit; -import static org.neo4j.driver.testutil.TestUtil.setupSuccessfulRunAndPull; -import static org.neo4j.driver.testutil.TestUtil.verifyBeginTx; -import static org.neo4j.driver.testutil.TestUtil.verifyCommitTx; -import static org.neo4j.driver.testutil.TestUtil.verifyRollbackTx; -import static org.neo4j.driver.testutil.TestUtil.verifyRunAndPull; - -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionStage; -import java.util.concurrent.ExecutionException; -import java.util.function.Function; -import java.util.function.Supplier; -import java.util.stream.Stream; -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.AccessMode; -import org.neo4j.driver.Query; -import org.neo4j.driver.TransactionConfig; -import org.neo4j.driver.Value; -import org.neo4j.driver.async.AsyncSession; -import org.neo4j.driver.async.AsyncTransaction; -import org.neo4j.driver.async.AsyncTransactionCallback; -import org.neo4j.driver.async.AsyncTransactionWork; -import org.neo4j.driver.async.ResultCursor; -import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.exceptions.SessionExpiredException; -import org.neo4j.driver.internal.DatabaseNameUtil; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.InternalRecord; -import org.neo4j.driver.internal.messaging.v4.BoltProtocolV4; -import org.neo4j.driver.internal.retry.RetryLogic; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ConnectionProvider; -import org.neo4j.driver.internal.util.FixedRetryLogic; -import org.neo4j.driver.internal.value.IntegerValue; - -class InternalAsyncSessionTest { - private static final String DATABASE = "neo4j"; - private Connection connection; - private ConnectionProvider connectionProvider; - private AsyncSession asyncSession; - private NetworkSession session; - - @BeforeEach - void setUp() { - connection = connectionMock(BoltProtocolV4.INSTANCE); - connectionProvider = mock(ConnectionProvider.class); - when(connectionProvider.acquireConnection(any(ConnectionContext.class))).thenAnswer(invocation -> { - var context = (ConnectionContext) invocation.getArgument(0); - context.databaseNameFuture().complete(DatabaseNameUtil.database(DATABASE)); - return completedFuture(connection); - }); - session = newSession(connectionProvider); - asyncSession = new InternalAsyncSession(session); - } - - private static Stream>> allSessionRunMethods() { - return Stream.of( - session -> session.runAsync("RETURN 1"), - session -> session.runAsync("RETURN $x", parameters("x", 1)), - session -> session.runAsync("RETURN $x", singletonMap("x", 1)), - session -> session.runAsync( - "RETURN $x", new InternalRecord(singletonList("x"), new Value[] {new IntegerValue(1)})), - session -> session.runAsync(new Query("RETURN $x", parameters("x", 1))), - session -> session.runAsync(new Query("RETURN $x", parameters("x", 1)), empty()), - session -> session.runAsync("RETURN $x", singletonMap("x", 1), empty()), - session -> session.runAsync("RETURN 1", empty())); - } - - private static Stream>> allBeginTxMethods() { - return Stream.of( - AsyncSession::beginTransactionAsync, - session -> session.beginTransactionAsync(TransactionConfig.empty())); - } - - @SuppressWarnings("deprecation") - private static Stream>> allRunTxMethods() { - return Stream.of( - session -> session.readTransactionAsync(tx -> completedFuture("a")), - session -> session.writeTransactionAsync(tx -> completedFuture("a")), - session -> session.readTransactionAsync(tx -> completedFuture("a"), empty()), - session -> session.writeTransactionAsync(tx -> completedFuture("a"), empty())); - } - - @ParameterizedTest - @MethodSource("allSessionRunMethods") - void shouldFlushOnRun(Function> runReturnOne) { - setupSuccessfulRunAndPull(connection); - - var cursor = await(runReturnOne.apply(asyncSession)); - - verifyRunAndPull(connection, await(cursor.consumeAsync()).query().text()); - } - - @ParameterizedTest - @MethodSource("allBeginTxMethods") - void shouldDelegateBeginTx(Function> beginTx) { - var tx = await(beginTx.apply(asyncSession)); - - verifyBeginTx(connection); - assertNotNull(tx); - } - - @ParameterizedTest - @MethodSource("allRunTxMethods") - void txRunShouldBeginAndCommitTx(Function> runTx) { - var string = await(runTx.apply(asyncSession)); - - verifyBeginTx(connection); - verifyCommitTx(connection); - verify(connection).release(); - assertThat(string, equalTo("a")); - } - - @Test - void rollsBackReadTxWhenFunctionThrows() { - testTxRollbackWhenThrows(READ); - } - - @Test - void rollsBackWriteTxWhenFunctionThrows() { - testTxRollbackWhenThrows(WRITE); - } - - @Test - void readTxRetriedUntilSuccessWhenFunctionThrows() { - testTxIsRetriedUntilSuccessWhenFunctionThrows(READ); - } - - @Test - void writeTxRetriedUntilSuccessWhenFunctionThrows() { - testTxIsRetriedUntilSuccessWhenFunctionThrows(WRITE); - } - - @Test - void readTxRetriedUntilSuccessWhenTxCloseThrows() { - testTxIsRetriedUntilSuccessWhenCommitThrows(READ); - } - - @Test - void writeTxRetriedUntilSuccessWhenTxCloseThrows() { - testTxIsRetriedUntilSuccessWhenCommitThrows(WRITE); - } - - @Test - void readTxRetriedUntilFailureWhenFunctionThrows() { - testTxIsRetriedUntilFailureWhenFunctionThrows(READ); - } - - @Test - void writeTxRetriedUntilFailureWhenFunctionThrows() { - testTxIsRetriedUntilFailureWhenFunctionThrows(WRITE); - } - - @Test - void readTxRetriedUntilFailureWhenTxCloseThrows() { - testTxIsRetriedUntilFailureWhenCommitFails(READ); - } - - @Test - void writeTxRetriedUntilFailureWhenTxCloseThrows() { - testTxIsRetriedUntilFailureWhenCommitFails(WRITE); - } - - @Test - void shouldCloseSession() { - await(asyncSession.closeAsync()); - assertFalse(this.session.isOpen()); - } - - @Test - void shouldReturnBookmark() { - session = newSession(connectionProvider, Collections.singleton(InternalBookmark.parse("Bookmark1"))); - asyncSession = new InternalAsyncSession(session); - - assertThat(asyncSession.lastBookmarks(), equalTo(session.lastBookmarks())); - } - - @ParameterizedTest - @MethodSource("executeVariations") - void shouldDelegateExecuteReadToRetryLogic(ExecuteVariation executeVariation) - throws ExecutionException, InterruptedException { - // GIVEN - var networkSession = mock(NetworkSession.class); - AsyncSession session = new InternalAsyncSession(networkSession); - var logic = mock(RetryLogic.class); - var expected = ""; - given(networkSession.retryLogic()).willReturn(logic); - AsyncTransactionCallback> tc = (ignored) -> CompletableFuture.completedFuture(expected); - given(logic.retryAsync(any())).willReturn(tc.execute(null)); - var config = TransactionConfig.builder().build(); - - // WHEN - var actual = executeVariation.readOnly - ? (executeVariation.explicitTxConfig - ? session.executeReadAsync(tc, config) - : session.executeReadAsync(tc)) - : (executeVariation.explicitTxConfig - ? session.executeWriteAsync(tc, config) - : session.executeWriteAsync(tc)); - - // THEN - assertEquals(expected, actual.toCompletableFuture().get()); - then(networkSession).should().retryLogic(); - then(logic).should().retryAsync(any()); - } - - @SuppressWarnings("deprecation") - private void testTxRollbackWhenThrows(AccessMode transactionMode) { - final RuntimeException error = new IllegalStateException("Oh!"); - AsyncTransactionWork> work = tx -> { - throw error; - }; - - var e = assertThrows(Exception.class, () -> executeTransaction(asyncSession, transactionMode, work)); - assertEquals(error, e); - - verify(connectionProvider).acquireConnection(any(ConnectionContext.class)); - verifyBeginTx(connection); - verifyRollbackTx(connection); - } - - private void testTxIsRetriedUntilSuccessWhenFunctionThrows(AccessMode mode) { - var failures = 12; - var retries = failures + 1; - - RetryLogic retryLogic = new FixedRetryLogic(retries); - session = newSession(connectionProvider, retryLogic); - asyncSession = new InternalAsyncSession(session); - - var work = spy(new TxWork(failures, new SessionExpiredException(""))); - int answer = executeTransaction(asyncSession, mode, work); - - assertEquals(42, answer); - verifyInvocationCount(work, failures + 1); - verifyCommitTx(connection); - verifyRollbackTx(connection, times(failures)); - } - - private void testTxIsRetriedUntilSuccessWhenCommitThrows(AccessMode mode) { - var failures = 13; - var retries = failures + 1; - - RetryLogic retryLogic = new FixedRetryLogic(retries); - setupFailingCommit(connection, failures); - session = newSession(connectionProvider, retryLogic); - asyncSession = new InternalAsyncSession(session); - - var work = spy(new TxWork(43)); - int answer = executeTransaction(asyncSession, mode, work); - - assertEquals(43, answer); - verifyInvocationCount(work, failures + 1); - verifyCommitTx(connection, times(retries)); - } - - private void testTxIsRetriedUntilFailureWhenFunctionThrows(AccessMode mode) { - var failures = 14; - var retries = failures - 1; - - RetryLogic retryLogic = new FixedRetryLogic(retries); - session = newSession(connectionProvider, retryLogic); - asyncSession = new InternalAsyncSession(session); - - var work = spy(new TxWork(failures, new SessionExpiredException("Oh!"))); - - var e = assertThrows(Exception.class, () -> executeTransaction(asyncSession, mode, work)); - - assertThat(e, instanceOf(SessionExpiredException.class)); - assertEquals("Oh!", e.getMessage()); - verifyInvocationCount(work, failures); - verifyCommitTx(connection, never()); - verifyRollbackTx(connection, times(failures)); - } - - private void testTxIsRetriedUntilFailureWhenCommitFails(AccessMode mode) { - var failures = 17; - var retries = failures - 1; - - RetryLogic retryLogic = new FixedRetryLogic(retries); - setupFailingCommit(connection, failures); - session = newSession(connectionProvider, retryLogic); - asyncSession = new InternalAsyncSession(session); - - var work = spy(new TxWork(42)); - - var e = assertThrows(Exception.class, () -> executeTransaction(asyncSession, mode, work)); - - assertThat(e, instanceOf(ServiceUnavailableException.class)); - verifyInvocationCount(work, failures); - verifyCommitTx(connection, times(failures)); - } - - @SuppressWarnings("deprecation") - private static T executeTransaction( - AsyncSession session, AccessMode mode, AsyncTransactionWork> work) { - if (mode == READ) { - return await(session.readTransactionAsync(work)); - } else if (mode == WRITE) { - return await(session.writeTransactionAsync(work)); - } else { - throw new IllegalArgumentException("Unknown mode " + mode); - } - } - - @SuppressWarnings("deprecation") - private static void verifyInvocationCount(AsyncTransactionWork workSpy, int expectedInvocationCount) { - verify(workSpy, times(expectedInvocationCount)).execute(any(AsyncTransaction.class)); - } - - @SuppressWarnings("deprecation") - private static class TxWork implements AsyncTransactionWork> { - final int result; - final int timesToThrow; - final Supplier errorSupplier; - - int invoked; - - TxWork(int result) { - this(result, (Supplier) null); - } - - TxWork(int timesToThrow, final RuntimeException error) { - this.result = 42; - this.timesToThrow = timesToThrow; - this.errorSupplier = () -> error; - } - - TxWork(int result, Supplier errorSupplier) { - this.result = result; - this.timesToThrow = 0; - this.errorSupplier = errorSupplier; - } - - @Override - public CompletionStage execute(AsyncTransaction tx) { - if (timesToThrow > 0 && invoked++ < timesToThrow) { - throw errorSupplier.get(); - } - return completedFuture(result); - } - } - - static List executeVariations() { - return Arrays.asList( - new ExecuteVariation(false, false), - new ExecuteVariation(false, true), - new ExecuteVariation(true, false), - new ExecuteVariation(true, true)); - } - - private record ExecuteVariation(boolean readOnly, boolean explicitTxConfig) {} -} +// package org.neo4j.driver.internal.async; +// +// import static java.util.Collections.singletonList; +// import static java.util.Collections.singletonMap; +// import static java.util.concurrent.CompletableFuture.completedFuture; +// import static org.hamcrest.CoreMatchers.equalTo; +// import static org.hamcrest.CoreMatchers.instanceOf; +// import static org.hamcrest.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.assertNotNull; +// import static org.junit.jupiter.api.Assertions.assertThrows; +// 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.never; +// 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.AccessMode.READ; +// import static org.neo4j.driver.AccessMode.WRITE; +// import static org.neo4j.driver.TransactionConfig.empty; +// import static org.neo4j.driver.Values.parameters; +// import static org.neo4j.driver.testutil.TestUtil.await; +// import static org.neo4j.driver.testutil.TestUtil.connectionMock; +// import static org.neo4j.driver.testutil.TestUtil.newSession; +// import static org.neo4j.driver.testutil.TestUtil.setupFailingCommit; +// import static org.neo4j.driver.testutil.TestUtil.setupSuccessfulRunAndPull; +// import static org.neo4j.driver.testutil.TestUtil.verifyBeginTx; +// import static org.neo4j.driver.testutil.TestUtil.verifyCommitTx; +// import static org.neo4j.driver.testutil.TestUtil.verifyRollbackTx; +// import static org.neo4j.driver.testutil.TestUtil.verifyRunAndPull; +// +// import java.util.Arrays; +// import java.util.Collections; +// import java.util.List; +// import java.util.concurrent.CompletableFuture; +// import java.util.concurrent.CompletionStage; +// import java.util.concurrent.ExecutionException; +// import java.util.function.Function; +// import java.util.function.Supplier; +// import java.util.stream.Stream; +// 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.AccessMode; +// import org.neo4j.driver.Query; +// import org.neo4j.driver.TransactionConfig; +// import org.neo4j.driver.Value; +// import org.neo4j.driver.async.AsyncSession; +// import org.neo4j.driver.async.AsyncTransaction; +// import org.neo4j.driver.async.AsyncTransactionCallback; +// import org.neo4j.driver.async.AsyncTransactionWork; +// import org.neo4j.driver.async.ResultCursor; +// import org.neo4j.driver.exceptions.ServiceUnavailableException; +// import org.neo4j.driver.exceptions.SessionExpiredException; +// import org.neo4j.driver.internal.DatabaseNameUtil; +// import org.neo4j.driver.internal.InternalBookmark; +// import org.neo4j.driver.internal.InternalRecord; +// import org.neo4j.driver.internal.messaging.v4.BoltProtocolV4; +// import org.neo4j.driver.internal.retry.RetryLogic; +// import org.neo4j.driver.internal.spi.Connection; +// import org.neo4j.driver.internal.spi.ConnectionProvider; +// import org.neo4j.driver.internal.util.FixedRetryLogic; +// import org.neo4j.driver.internal.value.IntegerValue; +// +// class InternalAsyncSessionTest { +// private static final String DATABASE = "neo4j"; +// private Connection connection; +// private ConnectionProvider connectionProvider; +// private AsyncSession asyncSession; +// private NetworkSession session; +// +// @BeforeEach +// void setUp() { +// connection = connectionMock(BoltProtocolV4.INSTANCE); +// connectionProvider = mock(ConnectionProvider.class); +// when(connectionProvider.acquireConnection(any(ConnectionContext.class))).thenAnswer(invocation -> { +// var context = (ConnectionContext) invocation.getArgument(0); +// context.databaseNameFuture().complete(DatabaseNameUtil.database(DATABASE)); +// return completedFuture(connection); +// }); +// session = newSession(connectionProvider); +// asyncSession = new InternalAsyncSession(session); +// } +// +// private static Stream>> allSessionRunMethods() { +// return Stream.of( +// session -> session.runAsync("RETURN 1"), +// session -> session.runAsync("RETURN $x", parameters("x", 1)), +// session -> session.runAsync("RETURN $x", singletonMap("x", 1)), +// session -> session.runAsync( +// "RETURN $x", new InternalRecord(singletonList("x"), new Value[] {new IntegerValue(1)})), +// session -> session.runAsync(new Query("RETURN $x", parameters("x", 1))), +// session -> session.runAsync(new Query("RETURN $x", parameters("x", 1)), empty()), +// session -> session.runAsync("RETURN $x", singletonMap("x", 1), empty()), +// session -> session.runAsync("RETURN 1", empty())); +// } +// +// private static Stream>> allBeginTxMethods() { +// return Stream.of( +// AsyncSession::beginTransactionAsync, +// session -> session.beginTransactionAsync(TransactionConfig.empty())); +// } +// +// @SuppressWarnings("deprecation") +// private static Stream>> allRunTxMethods() { +// return Stream.of( +// session -> session.readTransactionAsync(tx -> completedFuture("a")), +// session -> session.writeTransactionAsync(tx -> completedFuture("a")), +// session -> session.readTransactionAsync(tx -> completedFuture("a"), empty()), +// session -> session.writeTransactionAsync(tx -> completedFuture("a"), empty())); +// } +// +// @ParameterizedTest +// @MethodSource("allSessionRunMethods") +// void shouldFlushOnRun(Function> runReturnOne) { +// setupSuccessfulRunAndPull(connection); +// +// var cursor = await(runReturnOne.apply(asyncSession)); +// +// verifyRunAndPull(connection, await(cursor.consumeAsync()).query().text()); +// } +// +// @ParameterizedTest +// @MethodSource("allBeginTxMethods") +// void shouldDelegateBeginTx(Function> beginTx) { +// var tx = await(beginTx.apply(asyncSession)); +// +// verifyBeginTx(connection); +// assertNotNull(tx); +// } +// +// @ParameterizedTest +// @MethodSource("allRunTxMethods") +// void txRunShouldBeginAndCommitTx(Function> runTx) { +// var string = await(runTx.apply(asyncSession)); +// +// verifyBeginTx(connection); +// verifyCommitTx(connection); +// verify(connection).release(); +// assertThat(string, equalTo("a")); +// } +// +// @Test +// void rollsBackReadTxWhenFunctionThrows() { +// testTxRollbackWhenThrows(READ); +// } +// +// @Test +// void rollsBackWriteTxWhenFunctionThrows() { +// testTxRollbackWhenThrows(WRITE); +// } +// +// @Test +// void readTxRetriedUntilSuccessWhenFunctionThrows() { +// testTxIsRetriedUntilSuccessWhenFunctionThrows(READ); +// } +// +// @Test +// void writeTxRetriedUntilSuccessWhenFunctionThrows() { +// testTxIsRetriedUntilSuccessWhenFunctionThrows(WRITE); +// } +// +// @Test +// void readTxRetriedUntilSuccessWhenTxCloseThrows() { +// testTxIsRetriedUntilSuccessWhenCommitThrows(READ); +// } +// +// @Test +// void writeTxRetriedUntilSuccessWhenTxCloseThrows() { +// testTxIsRetriedUntilSuccessWhenCommitThrows(WRITE); +// } +// +// @Test +// void readTxRetriedUntilFailureWhenFunctionThrows() { +// testTxIsRetriedUntilFailureWhenFunctionThrows(READ); +// } +// +// @Test +// void writeTxRetriedUntilFailureWhenFunctionThrows() { +// testTxIsRetriedUntilFailureWhenFunctionThrows(WRITE); +// } +// +// @Test +// void readTxRetriedUntilFailureWhenTxCloseThrows() { +// testTxIsRetriedUntilFailureWhenCommitFails(READ); +// } +// +// @Test +// void writeTxRetriedUntilFailureWhenTxCloseThrows() { +// testTxIsRetriedUntilFailureWhenCommitFails(WRITE); +// } +// +// @Test +// void shouldCloseSession() { +// await(asyncSession.closeAsync()); +// assertFalse(this.session.isOpen()); +// } +// +// @Test +// void shouldReturnBookmark() { +// session = newSession(connectionProvider, Collections.singleton(InternalBookmark.parse("Bookmark1"))); +// asyncSession = new InternalAsyncSession(session); +// +// assertThat(asyncSession.lastBookmarks(), equalTo(session.lastBookmarks())); +// } +// +// @ParameterizedTest +// @MethodSource("executeVariations") +// void shouldDelegateExecuteReadToRetryLogic(ExecuteVariation executeVariation) +// throws ExecutionException, InterruptedException { +// // GIVEN +// var networkSession = mock(NetworkSession.class); +// AsyncSession session = new InternalAsyncSession(networkSession); +// var logic = mock(RetryLogic.class); +// var expected = ""; +// given(networkSession.retryLogic()).willReturn(logic); +// AsyncTransactionCallback> tc = (ignored) -> +// CompletableFuture.completedFuture(expected); +// given(logic.retryAsync(any())).willReturn(tc.execute(null)); +// var config = TransactionConfig.builder().build(); +// +// // WHEN +// var actual = executeVariation.readOnly +// ? (executeVariation.explicitTxConfig +// ? session.executeReadAsync(tc, config) +// : session.executeReadAsync(tc)) +// : (executeVariation.explicitTxConfig +// ? session.executeWriteAsync(tc, config) +// : session.executeWriteAsync(tc)); +// +// // THEN +// assertEquals(expected, actual.toCompletableFuture().get()); +// then(networkSession).should().retryLogic(); +// then(logic).should().retryAsync(any()); +// } +// +// @SuppressWarnings("deprecation") +// private void testTxRollbackWhenThrows(AccessMode transactionMode) { +// final RuntimeException error = new IllegalStateException("Oh!"); +// AsyncTransactionWork> work = tx -> { +// throw error; +// }; +// +// var e = assertThrows(Exception.class, () -> executeTransaction(asyncSession, transactionMode, work)); +// assertEquals(error, e); +// +// verify(connectionProvider).acquireConnection(any(ConnectionContext.class)); +// verifyBeginTx(connection); +// verifyRollbackTx(connection); +// } +// +// private void testTxIsRetriedUntilSuccessWhenFunctionThrows(AccessMode mode) { +// var failures = 12; +// var retries = failures + 1; +// +// RetryLogic retryLogic = new FixedRetryLogic(retries); +// session = newSession(connectionProvider, retryLogic); +// asyncSession = new InternalAsyncSession(session); +// +// var work = spy(new TxWork(failures, new SessionExpiredException(""))); +// int answer = executeTransaction(asyncSession, mode, work); +// +// assertEquals(42, answer); +// verifyInvocationCount(work, failures + 1); +// verifyCommitTx(connection); +// verifyRollbackTx(connection, times(failures)); +// } +// +// private void testTxIsRetriedUntilSuccessWhenCommitThrows(AccessMode mode) { +// var failures = 13; +// var retries = failures + 1; +// +// RetryLogic retryLogic = new FixedRetryLogic(retries); +// setupFailingCommit(connection, failures); +// session = newSession(connectionProvider, retryLogic); +// asyncSession = new InternalAsyncSession(session); +// +// var work = spy(new TxWork(43)); +// int answer = executeTransaction(asyncSession, mode, work); +// +// assertEquals(43, answer); +// verifyInvocationCount(work, failures + 1); +// verifyCommitTx(connection, times(retries)); +// } +// +// private void testTxIsRetriedUntilFailureWhenFunctionThrows(AccessMode mode) { +// var failures = 14; +// var retries = failures - 1; +// +// RetryLogic retryLogic = new FixedRetryLogic(retries); +// session = newSession(connectionProvider, retryLogic); +// asyncSession = new InternalAsyncSession(session); +// +// var work = spy(new TxWork(failures, new SessionExpiredException("Oh!"))); +// +// var e = assertThrows(Exception.class, () -> executeTransaction(asyncSession, mode, work)); +// +// assertThat(e, instanceOf(SessionExpiredException.class)); +// assertEquals("Oh!", e.getMessage()); +// verifyInvocationCount(work, failures); +// verifyCommitTx(connection, never()); +// verifyRollbackTx(connection, times(failures)); +// } +// +// private void testTxIsRetriedUntilFailureWhenCommitFails(AccessMode mode) { +// var failures = 17; +// var retries = failures - 1; +// +// RetryLogic retryLogic = new FixedRetryLogic(retries); +// setupFailingCommit(connection, failures); +// session = newSession(connectionProvider, retryLogic); +// asyncSession = new InternalAsyncSession(session); +// +// var work = spy(new TxWork(42)); +// +// var e = assertThrows(Exception.class, () -> executeTransaction(asyncSession, mode, work)); +// +// assertThat(e, instanceOf(ServiceUnavailableException.class)); +// verifyInvocationCount(work, failures); +// verifyCommitTx(connection, times(failures)); +// } +// +// @SuppressWarnings("deprecation") +// private static T executeTransaction( +// AsyncSession session, AccessMode mode, AsyncTransactionWork> work) { +// if (mode == READ) { +// return await(session.readTransactionAsync(work)); +// } else if (mode == WRITE) { +// return await(session.writeTransactionAsync(work)); +// } else { +// throw new IllegalArgumentException("Unknown mode " + mode); +// } +// } +// +// @SuppressWarnings("deprecation") +// private static void verifyInvocationCount(AsyncTransactionWork workSpy, int expectedInvocationCount) { +// verify(workSpy, times(expectedInvocationCount)).execute(any(AsyncTransaction.class)); +// } +// +// @SuppressWarnings("deprecation") +// private static class TxWork implements AsyncTransactionWork> { +// final int result; +// final int timesToThrow; +// final Supplier errorSupplier; +// +// int invoked; +// +// TxWork(int result) { +// this(result, (Supplier) null); +// } +// +// TxWork(int timesToThrow, final RuntimeException error) { +// this.result = 42; +// this.timesToThrow = timesToThrow; +// this.errorSupplier = () -> error; +// } +// +// TxWork(int result, Supplier errorSupplier) { +// this.result = result; +// this.timesToThrow = 0; +// this.errorSupplier = errorSupplier; +// } +// +// @Override +// public CompletionStage execute(AsyncTransaction tx) { +// if (timesToThrow > 0 && invoked++ < timesToThrow) { +// throw errorSupplier.get(); +// } +// return completedFuture(result); +// } +// } +// +// static List executeVariations() { +// return Arrays.asList( +// new ExecuteVariation(false, false), +// new ExecuteVariation(false, true), +// new ExecuteVariation(true, false), +// new ExecuteVariation(true, true)); +// } +// +// private record ExecuteVariation(boolean readOnly, boolean explicitTxConfig) {} +// } diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncTransactionTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncTransactionTest.java index 3ff7a5f64d..ad5bb0801f 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncTransactionTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/async/InternalAsyncTransactionTest.java @@ -14,139 +14,139 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async; - -import static java.util.Collections.singletonList; -import static java.util.Collections.singletonMap; -import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertThrows; -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.mockito.Mockito.when; -import static org.neo4j.driver.Values.parameters; -import static org.neo4j.driver.testutil.TestUtil.await; -import static org.neo4j.driver.testutil.TestUtil.connectionMock; -import static org.neo4j.driver.testutil.TestUtil.newSession; -import static org.neo4j.driver.testutil.TestUtil.setupFailingCommit; -import static org.neo4j.driver.testutil.TestUtil.setupFailingRollback; -import static org.neo4j.driver.testutil.TestUtil.setupSuccessfulRunAndPull; -import static org.neo4j.driver.testutil.TestUtil.verifyCommitTx; -import static org.neo4j.driver.testutil.TestUtil.verifyRollbackTx; -import static org.neo4j.driver.testutil.TestUtil.verifyRunAndPull; - -import java.util.concurrent.CompletionStage; -import java.util.concurrent.ExecutionException; -import java.util.function.Function; -import java.util.stream.Stream; -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.Query; -import org.neo4j.driver.Value; -import org.neo4j.driver.async.AsyncTransaction; -import org.neo4j.driver.async.ResultCursor; -import org.neo4j.driver.internal.DatabaseNameUtil; -import org.neo4j.driver.internal.InternalRecord; -import org.neo4j.driver.internal.messaging.v4.BoltProtocolV4; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ConnectionProvider; -import org.neo4j.driver.internal.value.IntegerValue; - -class InternalAsyncTransactionTest { - private static final String DATABASE = "neo4j"; - private Connection connection; - private InternalAsyncTransaction tx; - - @BeforeEach - void setUp() { - connection = connectionMock(BoltProtocolV4.INSTANCE); - var connectionProvider = mock(ConnectionProvider.class); - when(connectionProvider.acquireConnection(any(ConnectionContext.class))).thenAnswer(invocation -> { - var context = (ConnectionContext) invocation.getArgument(0); - context.databaseNameFuture().complete(DatabaseNameUtil.database(DATABASE)); - return completedFuture(connection); - }); - var networkSession = newSession(connectionProvider); - var session = new InternalAsyncSession(networkSession); - tx = (InternalAsyncTransaction) await(session.beginTransactionAsync()); - } - - private static Stream>> allSessionRunMethods() { - return Stream.of( - tx -> tx.runAsync("RETURN 1"), - tx -> tx.runAsync("RETURN $x", parameters("x", 1)), - tx -> tx.runAsync("RETURN $x", singletonMap("x", 1)), - tx -> tx.runAsync( - "RETURN $x", new InternalRecord(singletonList("x"), new Value[] {new IntegerValue(1)})), - tx -> tx.runAsync(new Query("RETURN $x", parameters("x", 1)))); - } - - @ParameterizedTest - @MethodSource("allSessionRunMethods") - void shouldFlushOnRun(Function> runReturnOne) { - setupSuccessfulRunAndPull(connection); - - var result = await(runReturnOne.apply(tx)); - var summary = await(result.consumeAsync()); - - verifyRunAndPull(connection, summary.query().text()); - } - - @Test - void shouldCommit() { - await(tx.commitAsync()); - - verifyCommitTx(connection); - verify(connection).release(); - assertFalse(tx.isOpen()); - } - - @Test - void shouldRollback() { - await(tx.rollbackAsync()); - - verifyRollbackTx(connection); - verify(connection).release(); - assertFalse(tx.isOpen()); - } - - @Test - void shouldReleaseConnectionWhenFailedToCommit() { - setupFailingCommit(connection); - assertThrows(Exception.class, () -> await(tx.commitAsync())); - - verify(connection).release(); - assertFalse(tx.isOpen()); - } - - @Test - void shouldReleaseConnectionWhenFailedToRollback() { - setupFailingRollback(connection); - assertThrows(Exception.class, () -> await(tx.rollbackAsync())); - - verify(connection).release(); - assertFalse(tx.isOpen()); - } - - @Test - void shouldDelegateIsOpenAsync() throws ExecutionException, InterruptedException { - // GIVEN - var utx = mock(UnmanagedTransaction.class); - var expected = false; - given(utx.isOpen()).willReturn(expected); - tx = new InternalAsyncTransaction(utx); - - // WHEN - boolean actual = tx.isOpenAsync().toCompletableFuture().get(); - - // THEN - assertEquals(expected, actual); - then(utx).should().isOpen(); - } -} +// package org.neo4j.driver.internal.async; +// +// import static java.util.Collections.singletonList; +// import static java.util.Collections.singletonMap; +// import static java.util.concurrent.CompletableFuture.completedFuture; +// import static org.junit.jupiter.api.Assertions.assertEquals; +// import static org.junit.jupiter.api.Assertions.assertFalse; +// import static org.junit.jupiter.api.Assertions.assertThrows; +// 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.mockito.Mockito.when; +// import static org.neo4j.driver.Values.parameters; +// import static org.neo4j.driver.testutil.TestUtil.await; +// import static org.neo4j.driver.testutil.TestUtil.connectionMock; +// import static org.neo4j.driver.testutil.TestUtil.newSession; +// import static org.neo4j.driver.testutil.TestUtil.setupFailingCommit; +// import static org.neo4j.driver.testutil.TestUtil.setupFailingRollback; +// import static org.neo4j.driver.testutil.TestUtil.setupSuccessfulRunAndPull; +// import static org.neo4j.driver.testutil.TestUtil.verifyCommitTx; +// import static org.neo4j.driver.testutil.TestUtil.verifyRollbackTx; +// import static org.neo4j.driver.testutil.TestUtil.verifyRunAndPull; +// +// import java.util.concurrent.CompletionStage; +// import java.util.concurrent.ExecutionException; +// import java.util.function.Function; +// import java.util.stream.Stream; +// 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.Query; +// import org.neo4j.driver.Value; +// import org.neo4j.driver.async.AsyncTransaction; +// import org.neo4j.driver.async.ResultCursor; +// import org.neo4j.driver.internal.DatabaseNameUtil; +// import org.neo4j.driver.internal.InternalRecord; +// import org.neo4j.driver.internal.messaging.v4.BoltProtocolV4; +// import org.neo4j.driver.internal.spi.Connection; +// import org.neo4j.driver.internal.spi.ConnectionProvider; +// import org.neo4j.driver.internal.value.IntegerValue; +// +// class InternalAsyncTransactionTest { +// private static final String DATABASE = "neo4j"; +// private Connection connection; +// private InternalAsyncTransaction tx; +// +// @BeforeEach +// void setUp() { +// connection = connectionMock(BoltProtocolV4.INSTANCE); +// var connectionProvider = mock(ConnectionProvider.class); +// when(connectionProvider.acquireConnection(any(ConnectionContext.class))).thenAnswer(invocation -> { +// var context = (ConnectionContext) invocation.getArgument(0); +// context.databaseNameFuture().complete(DatabaseNameUtil.database(DATABASE)); +// return completedFuture(connection); +// }); +// var networkSession = newSession(connectionProvider); +// var session = new InternalAsyncSession(networkSession); +// tx = (InternalAsyncTransaction) await(session.beginTransactionAsync()); +// } +// +// private static Stream>> allSessionRunMethods() { +// return Stream.of( +// tx -> tx.runAsync("RETURN 1"), +// tx -> tx.runAsync("RETURN $x", parameters("x", 1)), +// tx -> tx.runAsync("RETURN $x", singletonMap("x", 1)), +// tx -> tx.runAsync( +// "RETURN $x", new InternalRecord(singletonList("x"), new Value[] {new IntegerValue(1)})), +// tx -> tx.runAsync(new Query("RETURN $x", parameters("x", 1)))); +// } +// +// @ParameterizedTest +// @MethodSource("allSessionRunMethods") +// void shouldFlushOnRun(Function> runReturnOne) { +// setupSuccessfulRunAndPull(connection); +// +// var result = await(runReturnOne.apply(tx)); +// var summary = await(result.consumeAsync()); +// +// verifyRunAndPull(connection, summary.query().text()); +// } +// +// @Test +// void shouldCommit() { +// await(tx.commitAsync()); +// +// verifyCommitTx(connection); +// verify(connection).release(); +// assertFalse(tx.isOpen()); +// } +// +// @Test +// void shouldRollback() { +// await(tx.rollbackAsync()); +// +// verifyRollbackTx(connection); +// verify(connection).release(); +// assertFalse(tx.isOpen()); +// } +// +// @Test +// void shouldReleaseConnectionWhenFailedToCommit() { +// setupFailingCommit(connection); +// assertThrows(Exception.class, () -> await(tx.commitAsync())); +// +// verify(connection).release(); +// assertFalse(tx.isOpen()); +// } +// +// @Test +// void shouldReleaseConnectionWhenFailedToRollback() { +// setupFailingRollback(connection); +// assertThrows(Exception.class, () -> await(tx.rollbackAsync())); +// +// verify(connection).release(); +// assertFalse(tx.isOpen()); +// } +// +// @Test +// void shouldDelegateIsOpenAsync() throws ExecutionException, InterruptedException { +// // GIVEN +// var utx = mock(UnmanagedTransaction.class); +// var expected = false; +// given(utx.isOpen()).willReturn(expected); +// tx = new InternalAsyncTransaction(utx); +// +// // WHEN +// boolean actual = tx.isOpenAsync().toCompletableFuture().get(); +// +// // THEN +// assertEquals(expected, actual); +// then(utx).should().isOpen(); +// } +// } 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 ddd2330817..7a86f233a9 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 @@ -14,110 +14,110 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async; - -import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsString; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyString; -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.AccessMode.READ; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.testutil.TestUtil.DEFAULT_TEST_PROTOCOL; - -import java.util.Collections; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.TestInfo; -import org.mockito.ArgumentCaptor; -import org.neo4j.driver.BookmarkManager; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; -import org.neo4j.driver.TransactionConfig; -import org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ConnectionProvider; -import org.neo4j.driver.internal.telemetry.ApiTelemetryWork; -import org.neo4j.driver.internal.telemetry.TelemetryApi; -import org.neo4j.driver.internal.util.FixedRetryLogic; -import org.neo4j.driver.testutil.TestUtil; - -class LeakLoggingNetworkSessionTest { - @Test - void logsNothingDuringFinalizationIfClosed() throws Exception { - var logging = mock(Logging.class); - var log = mock(Logger.class); - when(logging.getLog(any(Class.class))).thenReturn(log); - var session = newSession(logging, false); - - finalize(session); - - verify(log, never()).error(anyString(), any(Throwable.class)); - } - - @Test - @SuppressWarnings("OptionalGetWithoutIsPresent") - void logsMessageWithStacktraceDuringFinalizationIfLeaked(TestInfo testInfo) throws Exception { - var logging = mock(Logging.class); - var log = mock(Logger.class); - when(logging.getLog(any(Class.class))).thenReturn(log); - var session = newSession(logging, true); - // begin transaction to make session obtain a connection - var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); - session.beginTransactionAsync(TransactionConfig.empty(), apiTelemetryWork); - - finalize(session); - - var messageCaptor = ArgumentCaptor.forClass(String.class); - verify(log).error(messageCaptor.capture(), any()); - - assertEquals(1, messageCaptor.getAllValues().size()); - - var loggedMessage = messageCaptor.getValue(); - assertThat(loggedMessage, containsString("Neo4j Session object leaked")); - assertThat(loggedMessage, containsString("Session was create at")); - assertThat( - loggedMessage, - containsString(getClass().getSimpleName() + "." - + testInfo.getTestMethod().get().getName())); - } - - private static void finalize(NetworkSession session) throws Exception { - var finalizeMethod = session.getClass().getDeclaredMethod("finalize"); - finalizeMethod.setAccessible(true); - finalizeMethod.invoke(session); - } - - private static LeakLoggingNetworkSession newSession(Logging logging, boolean openConnection) { - return new LeakLoggingNetworkSession( - connectionProviderMock(openConnection), - new FixedRetryLogic(0), - defaultDatabase(), - READ, - Collections.emptySet(), - null, - FetchSizeUtil.UNLIMITED_FETCH_SIZE, - logging, - mock(BookmarkManager.class), - null, - null, - true); - } - - private static ConnectionProvider connectionProviderMock(boolean openConnection) { - var provider = mock(ConnectionProvider.class); - var connection = connectionMock(openConnection); - when(provider.acquireConnection(any(ConnectionContext.class))).thenReturn(completedFuture(connection)); - return provider; - } - - private static Connection connectionMock(boolean open) { - var connection = TestUtil.connectionMock(DEFAULT_TEST_PROTOCOL); - when(connection.isOpen()).thenReturn(open); - return connection; - } -} +// package org.neo4j.driver.internal.async; +// +// import static java.util.concurrent.CompletableFuture.completedFuture; +// import static org.hamcrest.MatcherAssert.assertThat; +// import static org.hamcrest.Matchers.containsString; +// import static org.junit.jupiter.api.Assertions.assertEquals; +// import static org.mockito.ArgumentMatchers.any; +// import static org.mockito.ArgumentMatchers.anyString; +// 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.AccessMode.READ; +// import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; +// import static org.neo4j.driver.testutil.TestUtil.DEFAULT_TEST_PROTOCOL; +// +// import java.util.Collections; +// import org.junit.jupiter.api.Test; +// import org.junit.jupiter.api.TestInfo; +// import org.mockito.ArgumentCaptor; +// import org.neo4j.driver.BookmarkManager; +// import org.neo4j.driver.Logger; +// import org.neo4j.driver.Logging; +// import org.neo4j.driver.TransactionConfig; +// import org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil; +// import org.neo4j.driver.internal.spi.Connection; +// import org.neo4j.driver.internal.spi.ConnectionProvider; +// import org.neo4j.driver.internal.telemetry.ApiTelemetryWork; +// import org.neo4j.driver.internal.telemetry.TelemetryApi; +// import org.neo4j.driver.internal.util.FixedRetryLogic; +// import org.neo4j.driver.testutil.TestUtil; +// +// class LeakLoggingNetworkSessionTest { +// @Test +// void logsNothingDuringFinalizationIfClosed() throws Exception { +// var logging = mock(Logging.class); +// var log = mock(Logger.class); +// when(logging.getLog(any(Class.class))).thenReturn(log); +// var session = newSession(logging, false); +// +// finalize(session); +// +// verify(log, never()).error(anyString(), any(Throwable.class)); +// } +// +// @Test +// @SuppressWarnings("OptionalGetWithoutIsPresent") +// void logsMessageWithStacktraceDuringFinalizationIfLeaked(TestInfo testInfo) throws Exception { +// var logging = mock(Logging.class); +// var log = mock(Logger.class); +// when(logging.getLog(any(Class.class))).thenReturn(log); +// var session = newSession(logging, true); +// // begin transaction to make session obtain a connection +// var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); +// session.beginTransactionAsync(TransactionConfig.empty(), apiTelemetryWork); +// +// finalize(session); +// +// var messageCaptor = ArgumentCaptor.forClass(String.class); +// verify(log).error(messageCaptor.capture(), any()); +// +// assertEquals(1, messageCaptor.getAllValues().size()); +// +// var loggedMessage = messageCaptor.getValue(); +// assertThat(loggedMessage, containsString("Neo4j Session object leaked")); +// assertThat(loggedMessage, containsString("Session was create at")); +// assertThat( +// loggedMessage, +// containsString(getClass().getSimpleName() + "." +// + testInfo.getTestMethod().get().getName())); +// } +// +// private static void finalize(NetworkSession session) throws Exception { +// var finalizeMethod = session.getClass().getDeclaredMethod("finalize"); +// finalizeMethod.setAccessible(true); +// finalizeMethod.invoke(session); +// } +// +// private static LeakLoggingNetworkSession newSession(Logging logging, boolean openConnection) { +// return new LeakLoggingNetworkSession( +// connectionProviderMock(openConnection), +// new FixedRetryLogic(0), +// defaultDatabase(), +// READ, +// Collections.emptySet(), +// null, +// FetchSizeUtil.UNLIMITED_FETCH_SIZE, +// logging, +// mock(BookmarkManager.class), +// null, +// null, +// true); +// } +// +// private static ConnectionProvider connectionProviderMock(boolean openConnection) { +// var provider = mock(ConnectionProvider.class); +// var connection = connectionMock(openConnection); +// when(provider.acquireConnection(any(ConnectionContext.class))).thenReturn(completedFuture(connection)); +// return provider; +// } +// +// private static Connection connectionMock(boolean open) { +// var connection = TestUtil.connectionMock(DEFAULT_TEST_PROTOCOL); +// when(connection.isOpen()).thenReturn(open); +// return connection; +// } +// } diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/NetworkConnectionTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/NetworkConnectionTest.java index 28c5ecf370..6c3aa3dbba 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/NetworkConnectionTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/async/NetworkConnectionTest.java @@ -14,645 +14,646 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async; - -import static java.util.Collections.emptyMap; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.startsWith; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -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.then; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.messageDispatcher; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.terminationReason; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; -import static org.neo4j.driver.internal.messaging.request.PullAllMessage.PULL_ALL; -import static org.neo4j.driver.internal.messaging.request.ResetMessage.RESET; -import static org.neo4j.driver.internal.util.Iterables.single; -import static org.neo4j.driver.testutil.DaemonThreadFactory.daemon; -import static org.neo4j.driver.testutil.TestUtil.DEFAULT_TEST_PROTOCOL_VERSION; - -import io.netty.channel.Channel; -import io.netty.channel.DefaultEventLoop; -import io.netty.channel.EventLoop; -import io.netty.channel.embedded.EmbeddedChannel; -import java.util.List; -import java.util.Set; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.TimeUnit; -import java.util.function.Consumer; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.MethodSource; -import org.junit.jupiter.params.provider.ValueSource; -import org.mockito.ArgumentCaptor; -import org.neo4j.driver.Query; -import org.neo4j.driver.exceptions.Neo4jException; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; -import org.neo4j.driver.internal.async.pool.ExtendedChannelPool; -import org.neo4j.driver.internal.handlers.NoOpResponseHandler; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -import org.neo4j.driver.internal.messaging.request.DiscardAllMessage; -import org.neo4j.driver.internal.messaging.request.DiscardMessage; -import org.neo4j.driver.internal.messaging.request.PullAllMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.metrics.DevNullMetricsListener; -import org.neo4j.driver.internal.spi.ResponseHandler; -import org.neo4j.driver.internal.util.FakeClock; - -class NetworkConnectionTest { - private static final NoOpResponseHandler NO_OP_HANDLER = NoOpResponseHandler.INSTANCE; - - private ExecutorService executor; - private EventLoop eventLoop; - - @AfterEach - void tearDown() throws Exception { - shutdownEventLoop(); - } - - @Test - void shouldBeOpenAfterCreated() { - var connection = newConnection(newChannel()); - assertTrue(connection.isOpen()); - } - - @Test - void shouldNotBeOpenAfterRelease() { - var connection = newConnection(newChannel()); - connection.release(); - assertFalse(connection.isOpen()); - } - - @Test - void shouldSendResetOnRelease() { - var channel = newChannel(); - var connection = newConnection(channel); - - connection.release(); - channel.runPendingTasks(); - - assertEquals(1, channel.outboundMessages().size()); - assertEquals(RESET, channel.readOutbound()); - } - - @Test - void shouldWriteInEventLoopThread() throws Exception { - testWriteInEventLoop( - "WriteSingleMessage", - connection -> connection.write( - RunWithMetadataMessage.unmanagedTxRunMessage(new Query("RETURN 1")), NO_OP_HANDLER)); - } - - @Test - void shouldWriteAndFlushInEventLoopThread() throws Exception { - testWriteInEventLoop( - "WriteAndFlushSingleMessage", - connection -> connection.writeAndFlush( - RunWithMetadataMessage.unmanagedTxRunMessage(new Query("RETURN 1")), NO_OP_HANDLER)); - } - - @Test - void shouldWriteForceReleaseInEventLoopThread() throws Exception { - testWriteInEventLoop("ReleaseTestEventLoop", NetworkConnection::release); - } - - @Test - void shouldEnableAutoReadWhenReleased() { - var channel = newChannel(); - channel.config().setAutoRead(false); - - var connection = newConnection(channel); - - connection.release(); - channel.runPendingTasks(); - - assertTrue(channel.config().isAutoRead()); - } - - @Test - void shouldNotDisableAutoReadWhenReleased() { - var channel = newChannel(); - channel.config().setAutoRead(true); - - var connection = newConnection(channel); - - connection.release(); - connection.disableAutoRead(); // does nothing on released connection - assertTrue(channel.config().isAutoRead()); - } - - @Test - void shouldWriteSingleMessage() { - var channel = newChannel(); - var connection = newConnection(channel); - - connection.write(PULL_ALL, NO_OP_HANDLER); - - assertEquals(0, channel.outboundMessages().size()); - channel.flushOutbound(); - assertEquals(1, channel.outboundMessages().size()); - assertEquals(PULL_ALL, single(channel.outboundMessages())); - } - - @Test - void shouldWriteAndFlushSingleMessage() { - var channel = newChannel(); - var connection = newConnection(channel); - - connection.writeAndFlush(PULL_ALL, NO_OP_HANDLER); - channel.runPendingTasks(); // writeAndFlush is scheduled to execute in the event loop thread, trigger its - // execution - - assertEquals(1, channel.outboundMessages().size()); - assertEquals(PULL_ALL, single(channel.outboundMessages())); - } - - @Test - void shouldNotWriteSingleMessageWhenReleased() { - var handler = mock(ResponseHandler.class); - var connection = newConnection(newChannel()); - - connection.release(); - connection.write(RunWithMetadataMessage.unmanagedTxRunMessage(new Query("RETURN 1")), handler); - - var failureCaptor = ArgumentCaptor.forClass(IllegalStateException.class); - verify(handler).onFailure(failureCaptor.capture()); - assertConnectionReleasedError(failureCaptor.getValue()); - } - - @Test - void shouldNotWriteAndFlushSingleMessageWhenReleased() { - var handler = mock(ResponseHandler.class); - var connection = newConnection(newChannel()); - - connection.release(); - connection.writeAndFlush(RunWithMetadataMessage.unmanagedTxRunMessage(new Query("RETURN 1")), handler); - - var failureCaptor = ArgumentCaptor.forClass(IllegalStateException.class); - verify(handler).onFailure(failureCaptor.capture()); - assertConnectionReleasedError(failureCaptor.getValue()); - } - - @Test - void shouldNotWriteSingleMessageWhenTerminated() { - var handler = mock(ResponseHandler.class); - var connection = newConnection(newChannel()); - - connection.terminateAndRelease("42"); - connection.write(RunWithMetadataMessage.unmanagedTxRunMessage(new Query("RETURN 1")), handler); - - var failureCaptor = ArgumentCaptor.forClass(IllegalStateException.class); - verify(handler).onFailure(failureCaptor.capture()); - assertConnectionTerminatedError(failureCaptor.getValue()); - } - - @Test - void shouldNotWriteAndFlushSingleMessageWhenTerminated() { - var handler = mock(ResponseHandler.class); - var connection = newConnection(newChannel()); - - connection.terminateAndRelease("42"); - connection.writeAndFlush(RunWithMetadataMessage.unmanagedTxRunMessage(new Query("RETURN 1")), handler); - - var failureCaptor = ArgumentCaptor.forClass(IllegalStateException.class); - verify(handler).onFailure(failureCaptor.capture()); - assertConnectionTerminatedError(failureCaptor.getValue()); - } - - @Test - void shouldReturnServerAgentWhenCreated() { - var channel = newChannel(); - var agent = "Neo4j/4.2.5"; - ChannelAttributes.setServerAgent(channel, agent); - - var connection = newConnection(channel); - - assertEquals(agent, connection.serverAgent()); - } - - @Test - void shouldReturnServerAgentWhenReleased() { - var channel = newChannel(); - var agent = "Neo4j/4.2.5"; - ChannelAttributes.setServerAgent(channel, agent); - - var connection = newConnection(channel); - connection.release(); - - assertEquals(agent, connection.serverAgent()); - } - - @Test - void shouldReturnServerAddressWhenReleased() { - var channel = newChannel(); - var address = new BoltServerAddress("host", 4242); - ChannelAttributes.setServerAddress(channel, address); - - var connection = newConnection(channel); - connection.release(); - - assertEquals(address, connection.serverAddress()); - } - - @Test - void shouldReturnSameCompletionStageFromRelease() { - var channel = newChannel(); - var connection = newConnection(channel); - - var releaseStage1 = connection.release(); - var releaseStage2 = connection.release(); - var releaseStage3 = connection.release(); - - channel.runPendingTasks(); - - // RESET should be send only once - assertEquals(1, channel.outboundMessages().size()); - assertEquals(RESET, channel.outboundMessages().poll()); - - // all returned stages should be the same - assertEquals(releaseStage1, releaseStage2); - assertEquals(releaseStage2, releaseStage3); - } - - @Test - void shouldEnableAutoRead() { - var channel = newChannel(); - channel.config().setAutoRead(false); - var connection = newConnection(channel); - - connection.enableAutoRead(); - - assertTrue(channel.config().isAutoRead()); - } - - @Test - void shouldDisableAutoRead() { - var channel = newChannel(); - channel.config().setAutoRead(true); - var connection = newConnection(channel); - - connection.disableAutoRead(); - - assertFalse(channel.config().isAutoRead()); - } - - @Test - void shouldSetTerminationReasonOnChannelWhenTerminated() { - var channel = newChannel(); - var connection = newConnection(channel); - - var reason = "Something really bad has happened"; - connection.terminateAndRelease(reason); - - assertEquals(reason, terminationReason(channel)); - } - - @Test - void shouldCloseChannelWhenTerminated() { - var channel = newChannel(); - var connection = newConnection(channel); - assertTrue(channel.isActive()); - - connection.terminateAndRelease("test"); - - assertFalse(channel.isActive()); - } - - @Test - void shouldReleaseChannelWhenTerminated() { - var channel = newChannel(); - var pool = mock(ExtendedChannelPool.class); - var connection = newConnection(channel, pool); - verify(pool, never()).release(any()); - - connection.terminateAndRelease("test"); - - verify(pool).release(channel); - } - - @Test - void shouldNotReleaseChannelMultipleTimesWhenTerminatedMultipleTimes() { - var channel = newChannel(); - var pool = mock(ExtendedChannelPool.class); - var connection = newConnection(channel, pool); - verify(pool, never()).release(any()); - - connection.terminateAndRelease("reason 1"); - connection.terminateAndRelease("reason 2"); - connection.terminateAndRelease("reason 3"); - - // channel is terminated with the first termination reason - assertEquals("reason 1", terminationReason(channel)); - // channel is released to the pool only once - verify(pool).release(channel); - } - - @Test - void shouldNotReleaseAfterTermination() { - var channel = newChannel(); - var pool = mock(ExtendedChannelPool.class); - var connection = newConnection(channel, pool); - verify(pool, never()).release(any()); - - connection.terminateAndRelease("test"); - var releaseStage = connection.release(); - - // release stage should be completed immediately - assertTrue(releaseStage.toCompletableFuture().isDone()); - // channel is released to the pool only once - verify(pool).release(channel); - } - - @Test - void shouldSendResetMessageWhenReset() { - var channel = newChannel(); - var connection = newConnection(channel); - - connection.reset(null); - channel.runPendingTasks(); - - assertEquals(1, channel.outboundMessages().size()); - assertEquals(RESET, channel.readOutbound()); - } - - @Test - void shouldCompleteResetFutureWhenSuccessResponseArrives() { - var channel = newChannel(); - var connection = newConnection(channel); - - var resetFuture = connection.reset(null).toCompletableFuture(); - channel.runPendingTasks(); - assertFalse(resetFuture.isDone()); - - messageDispatcher(channel).handleSuccessMessage(emptyMap()); - assertTrue(resetFuture.isDone()); - assertFalse(resetFuture.isCompletedExceptionally()); - } - - @Test - void shouldCompleteResetFutureWhenFailureResponseArrives() { - var channel = newChannel(); - var connection = newConnection(channel); - - var resetFuture = connection.reset(null).toCompletableFuture(); - channel.runPendingTasks(); - assertFalse(resetFuture.isDone()); - - messageDispatcher(channel).handleFailureMessage("Neo.TransientError.Transaction.Terminated", "Message"); - assertTrue(resetFuture.isDone()); - assertFalse(resetFuture.isCompletedExceptionally()); - } - - @Test - void shouldDoNothingInResetWhenClosed() { - var channel = newChannel(); - var connection = newConnection(channel); - - connection.release(); - channel.runPendingTasks(); - - var resetFuture = connection.reset(null).toCompletableFuture(); - channel.runPendingTasks(); - - assertEquals(1, channel.outboundMessages().size()); - assertEquals(RESET, channel.readOutbound()); - assertTrue(resetFuture.isDone()); - assertFalse(resetFuture.isCompletedExceptionally()); - } - - @Test - void shouldEnableAutoReadWhenDoingReset() { - var channel = newChannel(); - channel.config().setAutoRead(false); - var connection = newConnection(channel); - - connection.reset(null); - channel.runPendingTasks(); - - assertTrue(channel.config().isAutoRead()); - } - - @Test - void shouldRejectBindingTerminationAwareStateLockingExecutorTwice() { - var channel = newChannel(); - var connection = newConnection(channel); - var lockingExecutor = mock(TerminationAwareStateLockingExecutor.class); - connection.bindTerminationAwareStateLockingExecutor(lockingExecutor); - - assertThrows( - IllegalStateException.class, - () -> connection.bindTerminationAwareStateLockingExecutor(lockingExecutor)); - } - - @ParameterizedTest - @MethodSource("queryMessages") - void shouldPreventDispatchingQueryMessagesOnTermination(QueryMessage queryMessage) { - // Given - var channel = newChannel(); - var connection = newConnection(channel); - var lockingExecutor = mock(TerminationAwareStateLockingExecutor.class); - var error = mock(Neo4jException.class); - doAnswer(invocationOnMock -> { - @SuppressWarnings("unchecked") - var consumer = (Consumer) invocationOnMock.getArguments()[0]; - consumer.accept(error); - return null; - }) - .when(lockingExecutor) - .execute(any()); - connection.bindTerminationAwareStateLockingExecutor(lockingExecutor); - var handler = mock(ResponseHandler.class); - - // When - if (queryMessage.flush()) { - connection.writeAndFlush(queryMessage.message(), handler); - } else { - connection.write(queryMessage.message(), handler); - } - channel.runPendingTasks(); - - // Then - assertTrue(channel.outboundMessages().isEmpty()); - then(lockingExecutor).should().execute(any()); - then(handler).should().onFailure(error); - } - - @ParameterizedTest - @MethodSource("queryMessages") - void shouldDispatchingQueryMessagesWhenNotTerminated(QueryMessage queryMessage) { - // Given - var channel = newChannel(); - var connection = newConnection(channel); - var lockingExecutor = mock(TerminationAwareStateLockingExecutor.class); - doAnswer(invocationOnMock -> { - @SuppressWarnings("unchecked") - var consumer = (Consumer) invocationOnMock.getArguments()[0]; - consumer.accept(null); - return null; - }) - .when(lockingExecutor) - .execute(any()); - connection.bindTerminationAwareStateLockingExecutor(lockingExecutor); - var handler = mock(ResponseHandler.class); - - // When - if (queryMessage.flush()) { - connection.writeAndFlush(queryMessage.message(), handler); - } else { - connection.write(queryMessage.message(), handler); - channel.flushOutbound(); - } - channel.runPendingTasks(); - - // Then - assertEquals(1, channel.outboundMessages().size()); - then(lockingExecutor).should().execute(any()); - } - - @ParameterizedTest - @MethodSource("queryMessages") - void shouldDispatchingQueryMessagesWhenExecutorAbsent(QueryMessage queryMessage) { - // Given - var channel = newChannel(); - var connection = newConnection(channel); - var handler = mock(ResponseHandler.class); - - // When - if (queryMessage.flush()) { - connection.writeAndFlush(queryMessage.message(), handler); - } else { - connection.write(queryMessage.message(), handler); - channel.flushOutbound(); - } - channel.runPendingTasks(); - - // Then - assertEquals(1, channel.outboundMessages().size()); - } - - @ParameterizedTest - @ValueSource(booleans = {true, false}) - void shouldReturnTelemetryEnabledWhenSet(Boolean telemetryEnabled) { - var channel = newChannel(); - ChannelAttributes.setTelemetryEnabled(channel, telemetryEnabled); - - var connection = newConnection(channel); - - assertEquals(telemetryEnabled, connection.isTelemetryEnabled()); - } - - @Test - void shouldReturnTelemetryEnabledEqualsFalseWhenNotSet() { - var channel = newChannel(); - - var connection = newConnection(channel); - - assertFalse(connection.isTelemetryEnabled()); - } - - static List queryMessages() { - return List.of( - new QueryMessage(false, mock(RunWithMetadataMessage.class)), - new QueryMessage(true, mock(RunWithMetadataMessage.class)), - new QueryMessage(false, mock(PullMessage.class)), - new QueryMessage(true, mock(PullMessage.class)), - new QueryMessage(false, mock(PullAllMessage.class)), - new QueryMessage(true, mock(PullAllMessage.class)), - new QueryMessage(false, mock(DiscardMessage.class)), - new QueryMessage(true, mock(DiscardMessage.class)), - new QueryMessage(false, mock(DiscardAllMessage.class)), - new QueryMessage(true, mock(DiscardAllMessage.class)), - new QueryMessage(false, mock(CommitMessage.class)), - new QueryMessage(true, mock(CommitMessage.class)), - new QueryMessage(false, mock(RollbackMessage.class)), - new QueryMessage(true, mock(RollbackMessage.class))); - } - - private record QueryMessage(boolean flush, Message message) {} - - private void testWriteInEventLoop(String threadName, Consumer action) throws Exception { - var channel = spy(new EmbeddedChannel()); - initializeEventLoop(channel, threadName); - var dispatcher = new ThreadTrackingInboundMessageDispatcher(channel); - ChannelAttributes.setProtocolVersion(channel, DEFAULT_TEST_PROTOCOL_VERSION); - ChannelAttributes.setMessageDispatcher(channel, dispatcher); - - var connection = newConnection(channel); - action.accept(connection); - - shutdownEventLoop(); - assertThat(single(dispatcher.queueThreadNames), startsWith(threadName)); - } - - private void initializeEventLoop(Channel channel, String namePrefix) { - executor = Executors.newSingleThreadExecutor(daemon(namePrefix)); - eventLoop = new DefaultEventLoop(executor); - when(channel.eventLoop()).thenReturn(eventLoop); - } - - private void shutdownEventLoop() throws Exception { - if (eventLoop != null) { - eventLoop.shutdownGracefully(); - } - if (executor != null) { - executor.shutdown(); - assertTrue(executor.awaitTermination(30, TimeUnit.SECONDS)); - } - } - - private static EmbeddedChannel newChannel() { - var channel = new EmbeddedChannel(); - var messageDispatcher = new InboundMessageDispatcher(channel, DEV_NULL_LOGGING); - ChannelAttributes.setProtocolVersion(channel, DEFAULT_TEST_PROTOCOL_VERSION); - ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); - return channel; - } - - private static NetworkConnection newConnection(Channel channel) { - return newConnection(channel, mock(ExtendedChannelPool.class)); - } - - private static NetworkConnection newConnection(Channel channel, ExtendedChannelPool pool) { - return new NetworkConnection(channel, pool, new FakeClock(), DevNullMetricsListener.INSTANCE, DEV_NULL_LOGGING); - } - - private static void assertConnectionReleasedError(IllegalStateException e) { - assertThat(e.getMessage(), startsWith("Connection has been released")); - } - - private static void assertConnectionTerminatedError(IllegalStateException e) { - assertThat(e.getMessage(), startsWith("Connection has been terminated")); - } - - private static class ThreadTrackingInboundMessageDispatcher extends InboundMessageDispatcher { - - final Set queueThreadNames = ConcurrentHashMap.newKeySet(); - - ThreadTrackingInboundMessageDispatcher(Channel channel) { - super(channel, DEV_NULL_LOGGING); - } - - @Override - public void enqueue(ResponseHandler handler) { - queueThreadNames.add(Thread.currentThread().getName()); - super.enqueue(handler); - } - } -} +// package org.neo4j.driver.internal.async; +// +// import static java.util.Collections.emptyMap; +// import static org.hamcrest.MatcherAssert.assertThat; +// import static org.hamcrest.Matchers.startsWith; +// import static org.junit.jupiter.api.Assertions.assertEquals; +// import static org.junit.jupiter.api.Assertions.assertFalse; +// 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.then; +// import static org.mockito.Mockito.doAnswer; +// import static org.mockito.Mockito.mock; +// import static org.mockito.Mockito.never; +// import static org.mockito.Mockito.spy; +// import static org.mockito.Mockito.verify; +// import static org.mockito.Mockito.when; +// import static org.neo4j.driver.internal.async.connection.ChannelAttributes.messageDispatcher; +// import static org.neo4j.driver.internal.async.connection.ChannelAttributes.terminationReason; +// import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; +// import static org.neo4j.driver.internal.messaging.request.PullAllMessage.PULL_ALL; +// import static org.neo4j.driver.internal.messaging.request.ResetMessage.RESET; +// import static org.neo4j.driver.internal.util.Iterables.single; +// import static org.neo4j.driver.testutil.DaemonThreadFactory.daemon; +// import static org.neo4j.driver.testutil.TestUtil.DEFAULT_TEST_PROTOCOL_VERSION; +// +// import io.netty.channel.Channel; +// import io.netty.channel.DefaultEventLoop; +// import io.netty.channel.EventLoop; +// import io.netty.channel.embedded.EmbeddedChannel; +// import java.util.List; +// import java.util.Set; +// import java.util.concurrent.ConcurrentHashMap; +// import java.util.concurrent.ExecutorService; +// import java.util.concurrent.Executors; +// import java.util.concurrent.TimeUnit; +// import java.util.function.Consumer; +// import org.junit.jupiter.api.AfterEach; +// import org.junit.jupiter.api.Test; +// import org.junit.jupiter.params.ParameterizedTest; +// import org.junit.jupiter.params.provider.MethodSource; +// import org.junit.jupiter.params.provider.ValueSource; +// import org.mockito.ArgumentCaptor; +// import org.neo4j.driver.Query; +// import org.neo4j.driver.exceptions.Neo4jException; +// import org.neo4j.driver.internal.BoltServerAddress; +// import org.neo4j.driver.internal.async.connection.ChannelAttributes; +// import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; +// import org.neo4j.driver.internal.async.pool.ExtendedChannelPool; +// import org.neo4j.driver.internal.handlers.NoOpResponseHandler; +// import org.neo4j.driver.internal.messaging.Message; +// import org.neo4j.driver.internal.messaging.request.CommitMessage; +// import org.neo4j.driver.internal.messaging.request.DiscardAllMessage; +// import org.neo4j.driver.internal.messaging.request.DiscardMessage; +// import org.neo4j.driver.internal.messaging.request.PullAllMessage; +// import org.neo4j.driver.internal.messaging.request.PullMessage; +// import org.neo4j.driver.internal.messaging.request.RollbackMessage; +// import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; +// import org.neo4j.driver.internal.metrics.DevNullMetricsListener; +// import org.neo4j.driver.internal.spi.ResponseHandler; +// import org.neo4j.driver.internal.util.FakeClock; +// +// class NetworkConnectionTest { +// private static final NoOpResponseHandler NO_OP_HANDLER = NoOpResponseHandler.INSTANCE; +// +// private ExecutorService executor; +// private EventLoop eventLoop; +// +// @AfterEach +// void tearDown() throws Exception { +// shutdownEventLoop(); +// } +// +// @Test +// void shouldBeOpenAfterCreated() { +// var connection = newConnection(newChannel()); +// assertTrue(connection.isOpen()); +// } +// +// @Test +// void shouldNotBeOpenAfterRelease() { +// var connection = newConnection(newChannel()); +// connection.release(); +// assertFalse(connection.isOpen()); +// } +// +// @Test +// void shouldSendResetOnRelease() { +// var channel = newChannel(); +// var connection = newConnection(channel); +// +// connection.release(); +// channel.runPendingTasks(); +// +// assertEquals(1, channel.outboundMessages().size()); +// assertEquals(RESET, channel.readOutbound()); +// } +// +// @Test +// void shouldWriteInEventLoopThread() throws Exception { +// testWriteInEventLoop( +// "WriteSingleMessage", +// connection -> connection.write( +// RunWithMetadataMessage.unmanagedTxRunMessage(new Query("RETURN 1")), NO_OP_HANDLER)); +// } +// +// @Test +// void shouldWriteAndFlushInEventLoopThread() throws Exception { +// testWriteInEventLoop( +// "WriteAndFlushSingleMessage", +// connection -> connection.writeAndFlush( +// RunWithMetadataMessage.unmanagedTxRunMessage(new Query("RETURN 1")), NO_OP_HANDLER)); +// } +// +// @Test +// void shouldWriteForceReleaseInEventLoopThread() throws Exception { +// testWriteInEventLoop("ReleaseTestEventLoop", NetworkConnection::release); +// } +// +// @Test +// void shouldEnableAutoReadWhenReleased() { +// var channel = newChannel(); +// channel.config().setAutoRead(false); +// +// var connection = newConnection(channel); +// +// connection.release(); +// channel.runPendingTasks(); +// +// assertTrue(channel.config().isAutoRead()); +// } +// +// @Test +// void shouldNotDisableAutoReadWhenReleased() { +// var channel = newChannel(); +// channel.config().setAutoRead(true); +// +// var connection = newConnection(channel); +// +// connection.release(); +// connection.disableAutoRead(); // does nothing on released connection +// assertTrue(channel.config().isAutoRead()); +// } +// +// @Test +// void shouldWriteSingleMessage() { +// var channel = newChannel(); +// var connection = newConnection(channel); +// +// connection.write(PULL_ALL, NO_OP_HANDLER); +// +// assertEquals(0, channel.outboundMessages().size()); +// channel.flushOutbound(); +// assertEquals(1, channel.outboundMessages().size()); +// assertEquals(PULL_ALL, single(channel.outboundMessages())); +// } +// +// @Test +// void shouldWriteAndFlushSingleMessage() { +// var channel = newChannel(); +// var connection = newConnection(channel); +// +// connection.writeAndFlush(PULL_ALL, NO_OP_HANDLER); +// channel.runPendingTasks(); // writeAndFlush is scheduled to execute in the event loop thread, trigger its +// // execution +// +// assertEquals(1, channel.outboundMessages().size()); +// assertEquals(PULL_ALL, single(channel.outboundMessages())); +// } +// +// @Test +// void shouldNotWriteSingleMessageWhenReleased() { +// var handler = mock(ResponseHandler.class); +// var connection = newConnection(newChannel()); +// +// connection.release(); +// connection.write(RunWithMetadataMessage.unmanagedTxRunMessage(new Query("RETURN 1")), handler); +// +// var failureCaptor = ArgumentCaptor.forClass(IllegalStateException.class); +// verify(handler).onFailure(failureCaptor.capture()); +// assertConnectionReleasedError(failureCaptor.getValue()); +// } +// +// @Test +// void shouldNotWriteAndFlushSingleMessageWhenReleased() { +// var handler = mock(ResponseHandler.class); +// var connection = newConnection(newChannel()); +// +// connection.release(); +// connection.writeAndFlush(RunWithMetadataMessage.unmanagedTxRunMessage(new Query("RETURN 1")), handler); +// +// var failureCaptor = ArgumentCaptor.forClass(IllegalStateException.class); +// verify(handler).onFailure(failureCaptor.capture()); +// assertConnectionReleasedError(failureCaptor.getValue()); +// } +// +// @Test +// void shouldNotWriteSingleMessageWhenTerminated() { +// var handler = mock(ResponseHandler.class); +// var connection = newConnection(newChannel()); +// +// connection.terminateAndRelease("42"); +// connection.write(RunWithMetadataMessage.unmanagedTxRunMessage(new Query("RETURN 1")), handler); +// +// var failureCaptor = ArgumentCaptor.forClass(IllegalStateException.class); +// verify(handler).onFailure(failureCaptor.capture()); +// assertConnectionTerminatedError(failureCaptor.getValue()); +// } +// +// @Test +// void shouldNotWriteAndFlushSingleMessageWhenTerminated() { +// var handler = mock(ResponseHandler.class); +// var connection = newConnection(newChannel()); +// +// connection.terminateAndRelease("42"); +// connection.writeAndFlush(RunWithMetadataMessage.unmanagedTxRunMessage(new Query("RETURN 1")), handler); +// +// var failureCaptor = ArgumentCaptor.forClass(IllegalStateException.class); +// verify(handler).onFailure(failureCaptor.capture()); +// assertConnectionTerminatedError(failureCaptor.getValue()); +// } +// +// @Test +// void shouldReturnServerAgentWhenCreated() { +// var channel = newChannel(); +// var agent = "Neo4j/4.2.5"; +// ChannelAttributes.setServerAgent(channel, agent); +// +// var connection = newConnection(channel); +// +// assertEquals(agent, connection.serverAgent()); +// } +// +// @Test +// void shouldReturnServerAgentWhenReleased() { +// var channel = newChannel(); +// var agent = "Neo4j/4.2.5"; +// ChannelAttributes.setServerAgent(channel, agent); +// +// var connection = newConnection(channel); +// connection.release(); +// +// assertEquals(agent, connection.serverAgent()); +// } +// +// @Test +// void shouldReturnServerAddressWhenReleased() { +// var channel = newChannel(); +// var address = new BoltServerAddress("host", 4242); +// ChannelAttributes.setServerAddress(channel, address); +// +// var connection = newConnection(channel); +// connection.release(); +// +// assertEquals(address, connection.serverAddress()); +// } +// +// @Test +// void shouldReturnSameCompletionStageFromRelease() { +// var channel = newChannel(); +// var connection = newConnection(channel); +// +// var releaseStage1 = connection.release(); +// var releaseStage2 = connection.release(); +// var releaseStage3 = connection.release(); +// +// channel.runPendingTasks(); +// +// // RESET should be send only once +// assertEquals(1, channel.outboundMessages().size()); +// assertEquals(RESET, channel.outboundMessages().poll()); +// +// // all returned stages should be the same +// assertEquals(releaseStage1, releaseStage2); +// assertEquals(releaseStage2, releaseStage3); +// } +// +// @Test +// void shouldEnableAutoRead() { +// var channel = newChannel(); +// channel.config().setAutoRead(false); +// var connection = newConnection(channel); +// +// connection.enableAutoRead(); +// +// assertTrue(channel.config().isAutoRead()); +// } +// +// @Test +// void shouldDisableAutoRead() { +// var channel = newChannel(); +// channel.config().setAutoRead(true); +// var connection = newConnection(channel); +// +// connection.disableAutoRead(); +// +// assertFalse(channel.config().isAutoRead()); +// } +// +// @Test +// void shouldSetTerminationReasonOnChannelWhenTerminated() { +// var channel = newChannel(); +// var connection = newConnection(channel); +// +// var reason = "Something really bad has happened"; +// connection.terminateAndRelease(reason); +// +// assertEquals(reason, terminationReason(channel)); +// } +// +// @Test +// void shouldCloseChannelWhenTerminated() { +// var channel = newChannel(); +// var connection = newConnection(channel); +// assertTrue(channel.isActive()); +// +// connection.terminateAndRelease("test"); +// +// assertFalse(channel.isActive()); +// } +// +// @Test +// void shouldReleaseChannelWhenTerminated() { +// var channel = newChannel(); +// var pool = mock(ExtendedChannelPool.class); +// var connection = newConnection(channel, pool); +// verify(pool, never()).release(any()); +// +// connection.terminateAndRelease("test"); +// +// verify(pool).release(channel); +// } +// +// @Test +// void shouldNotReleaseChannelMultipleTimesWhenTerminatedMultipleTimes() { +// var channel = newChannel(); +// var pool = mock(ExtendedChannelPool.class); +// var connection = newConnection(channel, pool); +// verify(pool, never()).release(any()); +// +// connection.terminateAndRelease("reason 1"); +// connection.terminateAndRelease("reason 2"); +// connection.terminateAndRelease("reason 3"); +// +// // channel is terminated with the first termination reason +// assertEquals("reason 1", terminationReason(channel)); +// // channel is released to the pool only once +// verify(pool).release(channel); +// } +// +// @Test +// void shouldNotReleaseAfterTermination() { +// var channel = newChannel(); +// var pool = mock(ExtendedChannelPool.class); +// var connection = newConnection(channel, pool); +// verify(pool, never()).release(any()); +// +// connection.terminateAndRelease("test"); +// var releaseStage = connection.release(); +// +// // release stage should be completed immediately +// assertTrue(releaseStage.toCompletableFuture().isDone()); +// // channel is released to the pool only once +// verify(pool).release(channel); +// } +// +// @Test +// void shouldSendResetMessageWhenReset() { +// var channel = newChannel(); +// var connection = newConnection(channel); +// +// connection.reset(null); +// channel.runPendingTasks(); +// +// assertEquals(1, channel.outboundMessages().size()); +// assertEquals(RESET, channel.readOutbound()); +// } +// +// @Test +// void shouldCompleteResetFutureWhenSuccessResponseArrives() { +// var channel = newChannel(); +// var connection = newConnection(channel); +// +// var resetFuture = connection.reset(null).toCompletableFuture(); +// channel.runPendingTasks(); +// assertFalse(resetFuture.isDone()); +// +// messageDispatcher(channel).handleSuccessMessage(emptyMap()); +// assertTrue(resetFuture.isDone()); +// assertFalse(resetFuture.isCompletedExceptionally()); +// } +// +// @Test +// void shouldCompleteResetFutureWhenFailureResponseArrives() { +// var channel = newChannel(); +// var connection = newConnection(channel); +// +// var resetFuture = connection.reset(null).toCompletableFuture(); +// channel.runPendingTasks(); +// assertFalse(resetFuture.isDone()); +// +// messageDispatcher(channel).handleFailureMessage("Neo.TransientError.Transaction.Terminated", "Message"); +// assertTrue(resetFuture.isDone()); +// assertFalse(resetFuture.isCompletedExceptionally()); +// } +// +// @Test +// void shouldDoNothingInResetWhenClosed() { +// var channel = newChannel(); +// var connection = newConnection(channel); +// +// connection.release(); +// channel.runPendingTasks(); +// +// var resetFuture = connection.reset(null).toCompletableFuture(); +// channel.runPendingTasks(); +// +// assertEquals(1, channel.outboundMessages().size()); +// assertEquals(RESET, channel.readOutbound()); +// assertTrue(resetFuture.isDone()); +// assertFalse(resetFuture.isCompletedExceptionally()); +// } +// +// @Test +// void shouldEnableAutoReadWhenDoingReset() { +// var channel = newChannel(); +// channel.config().setAutoRead(false); +// var connection = newConnection(channel); +// +// connection.reset(null); +// channel.runPendingTasks(); +// +// assertTrue(channel.config().isAutoRead()); +// } +// +// @Test +// void shouldRejectBindingTerminationAwareStateLockingExecutorTwice() { +// var channel = newChannel(); +// var connection = newConnection(channel); +// var lockingExecutor = mock(TerminationAwareStateLockingExecutor.class); +// connection.bindTerminationAwareStateLockingExecutor(lockingExecutor); +// +// assertThrows( +// IllegalStateException.class, +// () -> connection.bindTerminationAwareStateLockingExecutor(lockingExecutor)); +// } +// +// @ParameterizedTest +// @MethodSource("queryMessages") +// void shouldPreventDispatchingQueryMessagesOnTermination(QueryMessage queryMessage) { +// // Given +// var channel = newChannel(); +// var connection = newConnection(channel); +// var lockingExecutor = mock(TerminationAwareStateLockingExecutor.class); +// var error = mock(Neo4jException.class); +// doAnswer(invocationOnMock -> { +// @SuppressWarnings("unchecked") +// var consumer = (Consumer) invocationOnMock.getArguments()[0]; +// consumer.accept(error); +// return null; +// }) +// .when(lockingExecutor) +// .execute(any()); +// connection.bindTerminationAwareStateLockingExecutor(lockingExecutor); +// var handler = mock(ResponseHandler.class); +// +// // When +// if (queryMessage.flush()) { +// connection.writeAndFlush(queryMessage.message(), handler); +// } else { +// connection.write(queryMessage.message(), handler); +// } +// channel.runPendingTasks(); +// +// // Then +// assertTrue(channel.outboundMessages().isEmpty()); +// then(lockingExecutor).should().execute(any()); +// then(handler).should().onFailure(error); +// } +// +// @ParameterizedTest +// @MethodSource("queryMessages") +// void shouldDispatchingQueryMessagesWhenNotTerminated(QueryMessage queryMessage) { +// // Given +// var channel = newChannel(); +// var connection = newConnection(channel); +// var lockingExecutor = mock(TerminationAwareStateLockingExecutor.class); +// doAnswer(invocationOnMock -> { +// @SuppressWarnings("unchecked") +// var consumer = (Consumer) invocationOnMock.getArguments()[0]; +// consumer.accept(null); +// return null; +// }) +// .when(lockingExecutor) +// .execute(any()); +// connection.bindTerminationAwareStateLockingExecutor(lockingExecutor); +// var handler = mock(ResponseHandler.class); +// +// // When +// if (queryMessage.flush()) { +// connection.writeAndFlush(queryMessage.message(), handler); +// } else { +// connection.write(queryMessage.message(), handler); +// channel.flushOutbound(); +// } +// channel.runPendingTasks(); +// +// // Then +// assertEquals(1, channel.outboundMessages().size()); +// then(lockingExecutor).should().execute(any()); +// } +// +// @ParameterizedTest +// @MethodSource("queryMessages") +// void shouldDispatchingQueryMessagesWhenExecutorAbsent(QueryMessage queryMessage) { +// // Given +// var channel = newChannel(); +// var connection = newConnection(channel); +// var handler = mock(ResponseHandler.class); +// +// // When +// if (queryMessage.flush()) { +// connection.writeAndFlush(queryMessage.message(), handler); +// } else { +// connection.write(queryMessage.message(), handler); +// channel.flushOutbound(); +// } +// channel.runPendingTasks(); +// +// // Then +// assertEquals(1, channel.outboundMessages().size()); +// } +// +// @ParameterizedTest +// @ValueSource(booleans = {true, false}) +// void shouldReturnTelemetryEnabledWhenSet(Boolean telemetryEnabled) { +// var channel = newChannel(); +// ChannelAttributes.setTelemetryEnabled(channel, telemetryEnabled); +// +// var connection = newConnection(channel); +// +// assertEquals(telemetryEnabled, connection.isTelemetryEnabled()); +// } +// +// @Test +// void shouldReturnTelemetryEnabledEqualsFalseWhenNotSet() { +// var channel = newChannel(); +// +// var connection = newConnection(channel); +// +// assertFalse(connection.isTelemetryEnabled()); +// } +// +// static List queryMessages() { +// return List.of( +// new QueryMessage(false, mock(RunWithMetadataMessage.class)), +// new QueryMessage(true, mock(RunWithMetadataMessage.class)), +// new QueryMessage(false, mock(PullMessage.class)), +// new QueryMessage(true, mock(PullMessage.class)), +// new QueryMessage(false, mock(PullAllMessage.class)), +// new QueryMessage(true, mock(PullAllMessage.class)), +// new QueryMessage(false, mock(DiscardMessage.class)), +// new QueryMessage(true, mock(DiscardMessage.class)), +// new QueryMessage(false, mock(DiscardAllMessage.class)), +// new QueryMessage(true, mock(DiscardAllMessage.class)), +// new QueryMessage(false, mock(CommitMessage.class)), +// new QueryMessage(true, mock(CommitMessage.class)), +// new QueryMessage(false, mock(RollbackMessage.class)), +// new QueryMessage(true, mock(RollbackMessage.class))); +// } +// +// private record QueryMessage(boolean flush, Message message) {} +// +// private void testWriteInEventLoop(String threadName, Consumer action) throws Exception { +// var channel = spy(new EmbeddedChannel()); +// initializeEventLoop(channel, threadName); +// var dispatcher = new ThreadTrackingInboundMessageDispatcher(channel); +// ChannelAttributes.setProtocolVersion(channel, DEFAULT_TEST_PROTOCOL_VERSION); +// ChannelAttributes.setMessageDispatcher(channel, dispatcher); +// +// var connection = newConnection(channel); +// action.accept(connection); +// +// shutdownEventLoop(); +// assertThat(single(dispatcher.queueThreadNames), startsWith(threadName)); +// } +// +// private void initializeEventLoop(Channel channel, String namePrefix) { +// executor = Executors.newSingleThreadExecutor(daemon(namePrefix)); +// eventLoop = new DefaultEventLoop(executor); +// when(channel.eventLoop()).thenReturn(eventLoop); +// } +// +// private void shutdownEventLoop() throws Exception { +// if (eventLoop != null) { +// eventLoop.shutdownGracefully(); +// } +// if (executor != null) { +// executor.shutdown(); +// assertTrue(executor.awaitTermination(30, TimeUnit.SECONDS)); +// } +// } +// +// private static EmbeddedChannel newChannel() { +// var channel = new EmbeddedChannel(); +// var messageDispatcher = new InboundMessageDispatcher(channel, DEV_NULL_LOGGING); +// ChannelAttributes.setProtocolVersion(channel, DEFAULT_TEST_PROTOCOL_VERSION); +// ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); +// return channel; +// } +// +// private static NetworkConnection newConnection(Channel channel) { +// return newConnection(channel, mock(ExtendedChannelPool.class)); +// } +// +// private static NetworkConnection newConnection(Channel channel, ExtendedChannelPool pool) { +// return new NetworkConnection(channel, pool, new FakeClock(), DevNullMetricsListener.INSTANCE, +// DEV_NULL_LOGGING); +// } +// +// private static void assertConnectionReleasedError(IllegalStateException e) { +// assertThat(e.getMessage(), startsWith("Connection has been released")); +// } +// +// private static void assertConnectionTerminatedError(IllegalStateException e) { +// assertThat(e.getMessage(), startsWith("Connection has been terminated")); +// } +// +// private static class ThreadTrackingInboundMessageDispatcher extends InboundMessageDispatcher { +// +// final Set queueThreadNames = ConcurrentHashMap.newKeySet(); +// +// ThreadTrackingInboundMessageDispatcher(Channel channel) { +// super(channel, DEV_NULL_LOGGING); +// } +// +// @Override +// public void enqueue(ResponseHandler handler) { +// queueThreadNames.add(Thread.currentThread().getName()); +// super.enqueue(handler); +// } +// } +// } diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/NetworkSessionTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/NetworkSessionTest.java index 6fdcf3f5cc..08b3608346 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/NetworkSessionTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/async/NetworkSessionTest.java @@ -17,7 +17,7 @@ package org.neo4j.driver.internal.async; import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.hamcrest.CoreMatchers.containsString; +import static java.util.concurrent.CompletableFuture.failedFuture; import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.CoreMatchers.instanceOf; import static org.hamcrest.MatcherAssert.assertThat; @@ -26,94 +26,99 @@ 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.ArgumentMatchers.anyLong; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.BDDMockito.given; import static org.mockito.BDDMockito.then; import static org.mockito.Mockito.atLeastOnce; -import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; -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.AccessMode.READ; import static org.neo4j.driver.AccessMode.WRITE; -import static org.neo4j.driver.internal.util.Futures.failedFuture; import static org.neo4j.driver.testutil.TestUtil.await; import static org.neo4j.driver.testutil.TestUtil.connectionMock; import static org.neo4j.driver.testutil.TestUtil.newSession; -import static org.neo4j.driver.testutil.TestUtil.setupFailingBegin; -import static org.neo4j.driver.testutil.TestUtil.setupSuccessfulRunAndPull; -import static org.neo4j.driver.testutil.TestUtil.setupSuccessfulRunRx; -import static org.neo4j.driver.testutil.TestUtil.verifyBeginTx; +import static org.neo4j.driver.testutil.TestUtil.setupConnectionAnswers; +import static org.neo4j.driver.testutil.TestUtil.setupSuccessfulAutocommitRunAndPull; +import static org.neo4j.driver.testutil.TestUtil.verifyAutocommitRunAndPull; +import static org.neo4j.driver.testutil.TestUtil.verifyAutocommitRunRx; import static org.neo4j.driver.testutil.TestUtil.verifyRollbackTx; -import static org.neo4j.driver.testutil.TestUtil.verifyRunAndPull; -import static org.neo4j.driver.testutil.TestUtil.verifyRunRx; import java.util.Collections; +import java.util.List; +import java.util.Optional; import java.util.Set; import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import java.util.function.Consumer; import org.junit.jupiter.api.BeforeEach; 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.mockito.Mockito; +import org.mockito.stubbing.Answer; import org.neo4j.driver.AccessMode; import org.neo4j.driver.Query; import org.neo4j.driver.TransactionConfig; import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.DatabaseNameUtil; import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.messaging.v4.BoltProtocolV4; -import org.neo4j.driver.internal.messaging.v54.BoltProtocolV54; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.DatabaseName; +import org.neo4j.driver.internal.bolt.api.ResponseHandler; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; +import org.neo4j.driver.internal.bolt.api.summary.BeginSummary; +import org.neo4j.driver.internal.bolt.api.summary.PullSummary; +import org.neo4j.driver.internal.bolt.api.summary.RollbackSummary; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; import org.neo4j.driver.internal.telemetry.ApiTelemetryWork; -import org.neo4j.driver.internal.telemetry.TelemetryApi; import org.neo4j.driver.internal.util.FixedRetryLogic; class NetworkSessionTest { - private static final String DATABASE = "neo4j"; - private Connection connection; - private ConnectionProvider connectionProvider; + private BoltConnection connection; + private BoltConnectionProvider connectionProvider; private NetworkSession session; @BeforeEach void setUp() { - connection = connectionMock(BoltProtocolV4.INSTANCE); - connectionProvider = mock(ConnectionProvider.class); - when(connectionProvider.acquireConnection(any(ConnectionContext.class))).thenAnswer(invocation -> { - var context = (ConnectionContext) invocation.getArgument(0); - context.databaseNameFuture().complete(DatabaseNameUtil.database(DATABASE)); - return completedFuture(connection); - }); + connection = connectionMock(new BoltProtocolVersion(5, 4)); + given(connection.close()).willReturn(completedFuture(null)); + connectionProvider = mock(BoltConnectionProvider.class); + given(connectionProvider.connect(any(), any(), any(), any(), any(), any(), any(), any())) + .willAnswer((Answer>) invocation -> { + var database = (DatabaseName) invocation.getArguments()[0]; + @SuppressWarnings("unchecked") + var databaseConsumer = (Consumer) invocation.getArguments()[7]; + databaseConsumer.accept(database); + return completedFuture(connection); + }); session = newSession(connectionProvider); } @Test void shouldFlushOnRunAsync() { - setupSuccessfulRunAndPull(connection); + setupSuccessfulAutocommitRunAndPull(connection); await(session.runAsync(new Query("RETURN 1"), TransactionConfig.empty())); - verifyRunAndPull(connection, "RETURN 1"); + verifyAutocommitRunAndPull(connection, "RETURN 1"); } @Test void shouldFlushOnRunRx() { - setupSuccessfulRunRx(connection); + setupSuccessfulAutocommitRunAndPull(connection); await(session.runRx(new Query("RETURN 1"), TransactionConfig.empty(), CompletableFuture.completedStage(null))); - verifyRunRx(connection, "RETURN 1"); + verifyAutocommitRunRx(connection, "RETURN 1"); } @Test void shouldNotAllowNewTxWhileOneIsRunning() { // Given + setupSuccessfulBegin(connection); beginTransaction(session); // Expect @@ -123,6 +128,24 @@ void shouldNotAllowNewTxWhileOneIsRunning() { @Test void shouldBeAbleToOpenTxAfterPreviousIsClosed() { // Given + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(connection)); + given(connection.rollback()).willReturn(CompletableFuture.completedStage(connection)); + setupConnectionAnswers( + connection, + List.of( + handler -> { + handler.onBeginSummary(mock(BeginSummary.class)); + handler.onComplete(); + }, + handler -> { + handler.onRollbackSummary(mock(RollbackSummary.class)); + handler.onComplete(); + }, + handler -> { + handler.onBeginSummary(mock(BeginSummary.class)); + handler.onComplete(); + })); await(beginTransaction(session).closeAsync()); // When @@ -136,6 +159,7 @@ void shouldBeAbleToOpenTxAfterPreviousIsClosed() { @Test void shouldNotBeAbleToUseSessionWhileOngoingTransaction() { // Given + setupSuccessfulBegin(connection); beginTransaction(session); // Expect @@ -145,19 +169,48 @@ void shouldNotBeAbleToUseSessionWhileOngoingTransaction() { @Test void shouldBeAbleToUseSessionAgainWhenTransactionIsClosed() { // Given + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(connection)); + given(connection.rollback()).willReturn(CompletableFuture.completedFuture(connection)); + setupConnectionAnswers( + connection, + List.of( + handler -> { + handler.onBeginSummary(mock(BeginSummary.class)); + handler.onComplete(); + }, + handler -> { + handler.onRollbackSummary(mock(RollbackSummary.class)); + handler.onComplete(); + })); await(beginTransaction(session).closeAsync()); + Mockito.reset(connection); + setupSuccessfulAutocommitRunAndPull(connection); var query = "RETURN 1"; - setupSuccessfulRunAndPull(connection, query); // When run(session, query); // Then - verifyRunAndPull(connection, query); + verifyAutocommitRunAndPull(connection, query); } @Test void shouldNotCloseAlreadyClosedSession() { + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(connection)); + given(connection.rollback()).willReturn(CompletableFuture.completedFuture(connection)); + setupConnectionAnswers( + connection, + List.of( + handler -> { + handler.onBeginSummary(mock(BeginSummary.class)); + handler.onComplete(); + }, + handler -> { + handler.onRollbackSummary(mock(RollbackSummary.class)); + handler.onComplete(); + })); beginTransaction(session); close(session); @@ -167,45 +220,42 @@ void shouldNotCloseAlreadyClosedSession() { verifyRollbackTx(connection); } - @Test - void runThrowsWhenSessionIsClosed() { - close(session); - - var e = assertThrows(Exception.class, () -> run(session, "CREATE ()")); - assertThat(e, instanceOf(ClientException.class)); - assertThat(e.getMessage(), containsString("session is already closed")); - } + // TODO investigate + // @Test + // void runThrowsWhenSessionIsClosed() { + // close(session); + // + // var e = assertThrows(Exception.class, () -> run(session, "CREATE ()")); + // assertThat(e, instanceOf(ClientException.class)); + // assertThat(e.getMessage(), containsString("session is already closed")); + // } @Test void acquiresNewConnectionForRun() { var query = "RETURN 1"; - setupSuccessfulRunAndPull(connection, query); + setupSuccessfulAutocommitRunAndPull(connection); run(session, query); - verify(connectionProvider).acquireConnection(any(ConnectionContext.class)); + verify(connectionProvider).connect(any(), any(), any(), any(), any(), any(), any(), any()); } @Test void releasesOpenConnectionUsedForRunWhenSessionIsClosed() { var query = "RETURN 1"; - setupSuccessfulRunAndPull(connection, query); + setupSuccessfulAutocommitRunAndPull(connection); run(session, query); close(session); - - var inOrder = inOrder(connection); - inOrder.verify(connection).write(any(RunWithMetadataMessage.class), any()); - inOrder.verify(connection).writeAndFlush(any(PullMessage.class), any()); - inOrder.verify(connection, atLeastOnce()).release(); + then(connection).should(atLeastOnce()).close(); } @Test void resetDoesNothingWhenNoTransactionAndNoConnection() { await(session.resetAsync()); - verify(connectionProvider, never()).acquireConnection(any(ConnectionContext.class)); + verify(connectionProvider, never()).connect(any(), any(), any(), any(), any(), any(), any(), any()); } @Test @@ -214,27 +264,35 @@ void closeWithoutConnection() { close(session); - verify(connectionProvider, never()).acquireConnection(any(ConnectionContext.class)); + verify(connectionProvider, never()).connect(any(), any(), any(), any(), any(), any(), any(), any()); } @Test void acquiresNewConnectionForBeginTx() { + setupSuccessfulBegin(connection); var tx = beginTransaction(session); assertNotNull(tx); - verify(connectionProvider).acquireConnection(any(ConnectionContext.class)); + verify(connectionProvider).connect(any(), any(), any(), any(), any(), any(), any(), any()); } @Test void updatesBookmarkWhenTxIsClosed() { var bookmarkAfterCommit = InternalBookmark.parse("TheBookmark"); - - var protocol = spy(BoltProtocolV4.INSTANCE); - doReturn(completedFuture(new DatabaseBookmark(DATABASE, bookmarkAfterCommit))) - .when(protocol) - .commitTransaction(any(Connection.class)); - - when(connection.protocol()).thenReturn(protocol); + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(connection)); + given(connection.commit()).willReturn(CompletableFuture.completedFuture(connection)); + setupConnectionAnswers( + connection, + List.of( + handler -> { + handler.onBeginSummary(mock(BeginSummary.class)); + handler.onComplete(); + }, + handler -> { + handler.onCommitSummary(() -> Optional.of(bookmarkAfterCommit.value())); + handler.onComplete(); + })); var tx = beginTransaction(session); assertThat(session.lastBookmarks(), instanceOf(Set.class)); @@ -247,27 +305,53 @@ void updatesBookmarkWhenTxIsClosed() { @Test void releasesConnectionWhenTxIsClosed() { - var query = "RETURN 42"; - setupSuccessfulRunAndPull(connection, query); - + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(connection)); + given(connection.run(any(), any())).willAnswer((Answer>) + invocation -> CompletableFuture.completedStage(connection)); + given(connection.pull(anyLong(), anyLong())).willAnswer((Answer>) + invocation -> CompletableFuture.completedStage(connection)); + given(connection.rollback()).willReturn(CompletableFuture.completedFuture(connection)); + setupConnectionAnswers( + connection, + List.of( + handler -> { + handler.onBeginSummary(mock(BeginSummary.class)); + handler.onComplete(); + }, + handler -> { + handler.onRunSummary(mock(RunSummary.class)); + handler.onPullSummary(mock(PullSummary.class)); + handler.onComplete(); + }, + handler -> { + handler.onRollbackSummary(mock(RollbackSummary.class)); + handler.onComplete(); + })); var tx = beginTransaction(session); + verify(connectionProvider).connect(any(), any(), any(), any(), any(), any(), any(), any()); + then(connection).should().flush(any()); + var query = "RETURN 42"; await(tx.runAsync(new Query(query))); - verify(connectionProvider).acquireConnection(any(ConnectionContext.class)); - verifyRunAndPull(connection, query); + then(connection).should().run(eq(query), any()); + then(connection).should().pull(anyLong(), anyLong()); + then(connection).should(times(2)).flush(any()); await(tx.closeAsync()); - verify(connection).release(); + verify(connection).close(); } @Test void bookmarkIsPropagatedFromSession() { var bookmarks = Collections.singleton(InternalBookmark.parse("Bookmarks")); var session = newSession(connectionProvider, bookmarks); + setupSuccessfulBegin(connection); var tx = beginTransaction(session); assertNotNull(tx); - verifyBeginTx(connection); + then(connection).should().beginTransaction(any(), any(), any(), any(), any(), any(), any(), any()); + then(connection).should().flush(any()); } @Test @@ -277,21 +361,36 @@ void bookmarkIsPropagatedBetweenTransactions() { var session = newSession(connectionProvider); - var protocol = spy(BoltProtocolV4.INSTANCE); - doReturn( - completedFuture(new DatabaseBookmark(DATABASE, bookmark1)), - completedFuture(new DatabaseBookmark(DATABASE, bookmark2))) - .when(protocol) - .commitTransaction(any(Connection.class)); - - when(connection.protocol()).thenReturn(protocol); + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(connection)); + given(connection.commit()).willReturn(CompletableFuture.completedFuture(connection)); + setupConnectionAnswers( + connection, + List.of( + handler -> { + handler.onBeginSummary(mock(BeginSummary.class)); + handler.onComplete(); + }, + handler -> { + handler.onCommitSummary(() -> Optional.of(bookmark1.value())); + handler.onComplete(); + }, + handler -> { + handler.onBeginSummary(mock(BeginSummary.class)); + handler.onComplete(); + }, + handler -> { + handler.onCommitSummary(() -> Optional.of(bookmark2.value())); + handler.onComplete(); + })); var tx1 = beginTransaction(session); await(tx1.commitAsync()); assertEquals(Collections.singleton(bookmark1), session.lastBookmarks()); var tx2 = beginTransaction(session); - verifyBeginTx(connection, 2); + then(connection).should(times(2)).beginTransaction(any(), any(), any(), any(), any(), any(), any(), any()); + then(connection).should(times(3)).flush(any()); await(tx2.commitAsync()); assertEquals(Collections.singleton(bookmark2), session.lastBookmarks()); @@ -299,45 +398,54 @@ void bookmarkIsPropagatedBetweenTransactions() { @Test void accessModeUsedToAcquireReadConnections() { + setupSuccessfulBegin(connection); accessModeUsedToAcquireConnections(READ); } @Test void accessModeUsedToAcquireWriteConnections() { + setupSuccessfulBegin(connection); accessModeUsedToAcquireConnections(WRITE); } private void accessModeUsedToAcquireConnections(AccessMode mode) { var session2 = newSession(connectionProvider, mode); beginTransaction(session2); - var argument = ArgumentCaptor.forClass(ConnectionContext.class); - verify(connectionProvider).acquireConnection(argument.capture()); - assertEquals(mode, argument.getValue().mode()); + var argument = ArgumentCaptor.forClass(org.neo4j.driver.internal.bolt.api.AccessMode.class); + verify(connectionProvider).connect(any(), any(), argument.capture(), any(), any(), any(), any(), any()); + assertEquals( + switch (mode) { + case READ -> org.neo4j.driver.internal.bolt.api.AccessMode.READ; + case WRITE -> org.neo4j.driver.internal.bolt.api.AccessMode.WRITE; + }, + argument.getValue()); } @Test void testPassingNoBookmarkShouldRetainBookmark() { var bookmarks = Collections.singleton(InternalBookmark.parse("X")); var session = newSession(connectionProvider, bookmarks); + setupSuccessfulBegin(connection); beginTransaction(session); assertThat(session.lastBookmarks(), equalTo(bookmarks)); } - @Test - void connectionShouldBeResetAfterSessionReset() { - var query = "RETURN 1"; - setupSuccessfulRunAndPull(connection, query); - - run(session, query); - - var connectionInOrder = inOrder(connection); - connectionInOrder.verify(connection, never()).reset(null); - connectionInOrder.verify(connection).release(); - - await(session.resetAsync()); - connectionInOrder.verify(connection).reset(null); - connectionInOrder.verify(connection, never()).release(); - } + // TODO investigate + // @Test + // void connectionShouldBeResetAfterSessionReset() { + // var query = "RETURN 1"; + // setupSuccessfulRunAndPull(connection, query); + // + // run(session, query); + // + // var connectionInOrder = inOrder(connection); + // connectionInOrder.verify(connection, never()).reset(null); + // connectionInOrder.verify(connection).release(); + // + // await(session.resetAsync()); + // connectionInOrder.verify(connection).reset(null); + // connectionInOrder.verify(connection, never()).release(); + // } @Test void shouldHaveEmptyLastBookmarksInitially() { @@ -347,7 +455,9 @@ void shouldHaveEmptyLastBookmarksInitially() { @Test void shouldDoNothingWhenClosingWithoutAcquiredConnection() { var error = new RuntimeException("Hi"); - when(connectionProvider.acquireConnection(any(ConnectionContext.class))).thenReturn(failedFuture(error)); + Mockito.reset(connectionProvider); + given(connectionProvider.connect(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(failedFuture(error)); var e = assertThrows(Exception.class, () -> run(session, "RETURN 1")); assertEquals(error, e); @@ -358,11 +468,15 @@ void shouldDoNothingWhenClosingWithoutAcquiredConnection() { @Test void shouldRunAfterRunFailure() { var error = new RuntimeException("Hi"); - when(connectionProvider.acquireConnection(any(ConnectionContext.class))) - .thenReturn(failedFuture(error)) - .thenAnswer(invocation -> { - var context = (ConnectionContext) invocation.getArgument(0); - context.databaseNameFuture().complete(DatabaseNameUtil.database(DATABASE)); + Mockito.reset(connectionProvider); + given(connectionProvider.connect(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(failedFuture(error)) + .willAnswer((Answer>) invocation -> { + var databaseName = (DatabaseName) invocation.getArguments()[0]; + @SuppressWarnings("unchecked") + var databaseNameConsumer = + (Consumer) invocation.getArguments()[7]; + databaseNameConsumer.accept(databaseName); return completedFuture(connection); }); @@ -371,30 +485,38 @@ void shouldRunAfterRunFailure() { assertEquals(error, e); var query = "RETURN 2"; - setupSuccessfulRunAndPull(connection, query); + setupSuccessfulAutocommitRunAndPull(connection); run(session, query); - verify(connectionProvider, times(2)).acquireConnection(any(ConnectionContext.class)); - verifyRunAndPull(connection, query); + verify(connectionProvider, times(2)).connect(any(), any(), any(), any(), any(), any(), any(), any()); + verifyAutocommitRunAndPull(connection, query); } @Test void shouldRunAfterBeginTxFailureOnBookmark() { var error = new RuntimeException("Hi"); - var connection1 = connectionMock(BoltProtocolV4.INSTANCE); - setupFailingBegin(connection1, error); - var connection2 = connectionMock(BoltProtocolV4.INSTANCE); - - when(connectionProvider.acquireConnection(any(ConnectionContext.class))) - .thenAnswer(invocation -> { - var context = (ConnectionContext) invocation.getArgument(0); - context.databaseNameFuture().complete(DatabaseNameUtil.database(DATABASE)); + var connection1 = connectionMock(new BoltProtocolVersion(5, 0)); + given(connection1.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(CompletableFuture.failedStage(error)); + var connection2 = connectionMock(new BoltProtocolVersion(5, 0)); + + Mockito.reset(connectionProvider); + given(connectionProvider.connect(any(), any(), any(), any(), any(), any(), any(), any())) + .willAnswer((Answer>) invocation -> { + var databaseName = (DatabaseName) invocation.getArguments()[0]; + @SuppressWarnings("unchecked") + var databaseNameConsumer = + (Consumer) invocation.getArguments()[7]; + databaseNameConsumer.accept(databaseName); return completedFuture(connection1); }) - .thenAnswer(invocation -> { - var context = (ConnectionContext) invocation.getArgument(0); - context.databaseNameFuture().complete(DatabaseNameUtil.database(DATABASE)); + .willAnswer((Answer>) invocation -> { + var databaseName = (DatabaseName) invocation.getArguments()[0]; + @SuppressWarnings("unchecked") + var databaseNameConsumer = + (Consumer) invocation.getArguments()[7]; + databaseNameConsumer.accept(databaseName); return completedFuture(connection2); }); @@ -404,31 +526,42 @@ void shouldRunAfterBeginTxFailureOnBookmark() { var e = assertThrows(Exception.class, () -> beginTransaction(session)); assertEquals(error, e); var query = "RETURN 2"; - setupSuccessfulRunAndPull(connection2, query); + setupSuccessfulAutocommitRunAndPull(connection2); run(session, query); - verify(connectionProvider, times(2)).acquireConnection(any(ConnectionContext.class)); - verifyBeginTx(connection1); - verifyRunAndPull(connection2, "RETURN 2"); + verify(connectionProvider, times(2)).connect(any(), any(), any(), any(), any(), any(), any(), any()); + then(connection1).should().beginTransaction(any(), any(), any(), any(), any(), any(), any(), any()); + verifyAutocommitRunAndPull(connection2, "RETURN 2"); } @Test void shouldBeginTxAfterBeginTxFailureOnBookmark() { var error = new RuntimeException("Hi"); - var connection1 = connectionMock(BoltProtocolV4.INSTANCE); - setupFailingBegin(connection1, error); - var connection2 = connectionMock(BoltProtocolV4.INSTANCE); - - when(connectionProvider.acquireConnection(any(ConnectionContext.class))) - .thenAnswer(invocation -> { - var context = (ConnectionContext) invocation.getArgument(0); - context.databaseNameFuture().complete(DatabaseNameUtil.database(DATABASE)); + var connection1 = connectionMock(new BoltProtocolVersion(5, 0)); + given(connection1.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(CompletableFuture.failedStage(error)); + var connection2 = connectionMock(new BoltProtocolVersion(5, 0)); + given(connection2.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(CompletableFuture.completedStage(connection2)); + setupConnectionAnswers(connection2, List.of(handler -> handler.onBeginSummary(mock(BeginSummary.class)))); + + Mockito.reset(connectionProvider); + given(connectionProvider.connect(any(), any(), any(), any(), any(), any(), any(), any())) + .willAnswer((Answer>) invocation -> { + var databaseName = (DatabaseName) invocation.getArguments()[0]; + @SuppressWarnings("unchecked") + var databaseNameConsumer = + (Consumer) invocation.getArguments()[7]; + databaseNameConsumer.accept(databaseName); return completedFuture(connection1); }) - .thenAnswer(invocation -> { - var context = (ConnectionContext) invocation.getArgument(0); - context.databaseNameFuture().complete(DatabaseNameUtil.database(DATABASE)); + .willAnswer((Answer>) invocation -> { + var databaseName = (DatabaseName) invocation.getArguments()[0]; + @SuppressWarnings("unchecked") + var databaseNameConsumer = + (Consumer) invocation.getArguments()[7]; + databaseNameConsumer.accept(databaseName); return completedFuture(connection2); }); @@ -440,62 +573,66 @@ void shouldBeginTxAfterBeginTxFailureOnBookmark() { beginTransaction(session); - verify(connectionProvider, times(2)).acquireConnection(any(ConnectionContext.class)); - verifyBeginTx(connection1); - verifyBeginTx(connection2); + verify(connectionProvider, times(2)).connect(any(), any(), any(), any(), any(), any(), any(), any()); + then(connection1).should().beginTransaction(any(), any(), any(), any(), any(), any(), any(), any()); + then(connection2).should().beginTransaction(any(), any(), any(), any(), any(), any(), any(), any()); } @Test void shouldBeginTxAfterRunFailureToAcquireConnection() { var error = new RuntimeException("Hi"); - when(connectionProvider.acquireConnection(any(ConnectionContext.class))) - .thenReturn(failedFuture(error)) - .thenAnswer(invocation -> { - var context = (ConnectionContext) invocation.getArgument(0); - context.databaseNameFuture().complete(DatabaseNameUtil.database(DATABASE)); + Mockito.reset(connectionProvider); + given(connectionProvider.connect(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(failedFuture(error)) + .willAnswer((Answer>) invocation -> { + var databaseName = (DatabaseName) invocation.getArguments()[0]; + @SuppressWarnings("unchecked") + var databaseNameConsumer = + (Consumer) invocation.getArguments()[7]; + databaseNameConsumer.accept(databaseName); return completedFuture(connection); }); + setupSuccessfulBegin(connection); var e = assertThrows(Exception.class, () -> run(session, "RETURN 1")); assertEquals(error, e); beginTransaction(session); - verify(connectionProvider, times(2)).acquireConnection(any(ConnectionContext.class)); - verifyBeginTx(connection); + verify(connectionProvider, times(2)).connect(any(), any(), any(), any(), any(), any(), any(), any()); + then(connection).should().beginTransaction(any(), any(), any(), any(), any(), any(), any(), any()); } - @Test - void shouldMarkTransactionAsTerminatedAndThenResetConnectionOnReset() { - var tx = beginTransaction(session); - - assertTrue(tx.isOpen()); - verify(connection, never()).reset(null); - - await(session.resetAsync()); - - verify(connection).reset(any()); - } + // TODO investigate + // @Test + // void shouldMarkTransactionAsTerminatedAndThenResetConnectionOnReset() { + // var tx = beginTransaction(session); + // + // assertTrue(tx.isOpen()); + // verify(connection, never()).reset(null); + // + // await(session.resetAsync()); + // + // verify(connection).reset(any()); + // } @ParameterizedTest @ValueSource(booleans = {true, false}) void shouldSendTelemetryIfEnabledOnBegin(boolean telemetryDisabled) { // given var session = newSession(connectionProvider, WRITE, new FixedRetryLogic(0), Set.of(), telemetryDisabled); - given(connection.isTelemetryEnabled()).willReturn(true); - var protocol = spy(BoltProtocolV54.INSTANCE); - when(connection.protocol()).thenReturn(protocol); + given(connection.telemetrySupported()).willReturn(true); + given(connection.telemetry(any())).willReturn(CompletableFuture.completedStage(connection)); + setupSuccessfulBegin(connection); // when beginTransaction(session); // then if (telemetryDisabled) { - then(protocol).should(never()).telemetry(any(), any()); + then(connection).should(never()).telemetry(any()); } else { - then(protocol) - .should(times(1)) - .telemetry(eq(connection), eq(TelemetryApi.UNMANAGED_TRANSACTION.getValue())); + then(connection).should().telemetry(eq(TelemetryApi.UNMANAGED_TRANSACTION)); } } @@ -504,26 +641,33 @@ void shouldSendTelemetryIfEnabledOnBegin(boolean telemetryDisabled) { void shouldSendTelemetryIfEnabledOnRun(boolean telemetryDisabled) { // given var query = "RETURN 1"; - setupSuccessfulRunAndPull(connection, query); - var apiTxWork = mock(ApiTelemetryWork.class); + setupSuccessfulAutocommitRunAndPull(connection); var session = newSession(connectionProvider, WRITE, new FixedRetryLogic(0), Set.of(), telemetryDisabled); - given(connection.isTelemetryEnabled()).willReturn(true); - var protocol = spy(BoltProtocolV54.INSTANCE); - when(connection.protocol()).thenReturn(protocol); + given(connection.telemetrySupported()).willReturn(true); + given(connection.telemetry(any())).willReturn(CompletableFuture.completedStage(connection)); // when run(session, query); // then if (telemetryDisabled) { - then(protocol).should(never()).telemetry(any(), any()); + then(connection).should(never()).telemetry(any()); } else { - then(protocol) - .should(times(1)) - .telemetry(eq(connection), eq(TelemetryApi.AUTO_COMMIT_TRANSACTION.getValue())); + then(connection).should().telemetry(eq(TelemetryApi.AUTO_COMMIT_TRANSACTION)); } } + private void setupSuccessfulBegin(BoltConnection connection) { + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(connection)); + given(connection.flush(any())).willAnswer((Answer>) invocation -> { + var handler = (ResponseHandler) invocation.getArguments()[0]; + handler.onBeginSummary(mock(BeginSummary.class)); + handler.onComplete(); + return completedFuture(null); + }); + } + private static void run(NetworkSession session, String query) { await(session.runAsync(new Query(query), TransactionConfig.empty())); } diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/ResultCursorsHolderTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/ResultCursorsHolderTest.java index 571c3ecf14..fb99f8996e 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/ResultCursorsHolderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/async/ResultCursorsHolderTest.java @@ -14,127 +14,128 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async; - -import static java.util.concurrent.CompletableFuture.completedFuture; -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 static org.mockito.Mockito.when; -import static org.neo4j.driver.testutil.TestUtil.await; - -import java.io.IOException; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionStage; -import java.util.concurrent.TimeoutException; -import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.cursor.AsyncResultCursorImpl; -import org.neo4j.driver.internal.util.Futures; - -class ResultCursorsHolderTest { - @Test - void shouldReturnNoErrorWhenNoCursorStages() { - var holder = new ResultCursorsHolder(); - - var error = await(holder.retrieveNotConsumedError()); - assertNull(error); - } - - @Test - void shouldFailToAddNullCursorStage() { - var holder = new ResultCursorsHolder(); - - assertThrows(NullPointerException.class, () -> holder.add(null)); - } - - @Test - void shouldReturnNoErrorWhenCursorStagesHaveNoErrors() { - var holder = new ResultCursorsHolder(); - - holder.add(cursorWithoutError()); - holder.add(cursorWithoutError()); - holder.add(cursorWithoutError()); - holder.add(cursorWithoutError()); - - var error = await(holder.retrieveNotConsumedError()); - assertNull(error); - } - - @Test - void shouldNotReturnStageErrors() { - var holder = new ResultCursorsHolder(); - - holder.add(Futures.failedFuture(new RuntimeException("Failed to acquire a connection"))); - holder.add(cursorWithoutError()); - holder.add(cursorWithoutError()); - holder.add(Futures.failedFuture(new IOException("Failed to do IO"))); - - var error = await(holder.retrieveNotConsumedError()); - assertNull(error); - } - - @Test - void shouldReturnErrorWhenOneCursorFailed() { - var error = new IOException("IO failed"); - var holder = new ResultCursorsHolder(); - - holder.add(cursorWithoutError()); - holder.add(cursorWithoutError()); - holder.add(cursorWithError(error)); - holder.add(cursorWithoutError()); - - var retrievedError = await(holder.retrieveNotConsumedError()); - assertEquals(error, retrievedError); - } - - @Test - void shouldReturnFirstError() { - var error1 = new RuntimeException("Error 1"); - var error2 = new IOException("Error 2"); - var error3 = new TimeoutException("Error 3"); - var holder = new ResultCursorsHolder(); - - holder.add(cursorWithoutError()); - holder.add(cursorWithError(error1)); - holder.add(cursorWithError(error2)); - holder.add(cursorWithError(error3)); - - assertEquals(error1, await(holder.retrieveNotConsumedError())); - } - - @Test - void shouldWaitForAllFailuresToArrive() { - var error1 = new RuntimeException("Error 1"); - var error2Future = new CompletableFuture(); - var holder = new ResultCursorsHolder(); - - holder.add(cursorWithoutError()); - holder.add(cursorWithError(error1)); - holder.add(cursorWithFailureFuture(error2Future)); - - var failureFuture = holder.retrieveNotConsumedError().toCompletableFuture(); - assertFalse(failureFuture.isDone()); - - error2Future.complete(null); - assertTrue(failureFuture.isDone()); - - assertEquals(error1, await(failureFuture)); - } - - private static CompletionStage cursorWithoutError() { - return cursorWithError(null); - } - - private static CompletionStage cursorWithError(Throwable error) { - return cursorWithFailureFuture(completedFuture(error)); - } - - private static CompletionStage cursorWithFailureFuture(CompletableFuture future) { - var cursor = mock(AsyncResultCursorImpl.class); - when(cursor.discardAllFailureAsync()).thenReturn(future); - return completedFuture(cursor); - } -} +// package org.neo4j.driver.internal.async; +// +// import static java.util.concurrent.CompletableFuture.completedFuture; +// 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 static org.mockito.Mockito.when; +// import static org.neo4j.driver.testutil.TestUtil.await; +// +// import java.io.IOException; +// import java.util.concurrent.CompletableFuture; +// import java.util.concurrent.CompletionStage; +// import java.util.concurrent.TimeoutException; +// import org.junit.jupiter.api.Test; +// import org.neo4j.driver.internal.cursor.AsyncResultCursorImpl; +// import org.neo4j.driver.internal.util.Futures; +// +// class ResultCursorsHolderTest { +// @Test +// void shouldReturnNoErrorWhenNoCursorStages() { +// var holder = new ResultCursorsHolder(); +// +// var error = await(holder.retrieveNotConsumedError()); +// assertNull(error); +// } +// +// @Test +// void shouldFailToAddNullCursorStage() { +// var holder = new ResultCursorsHolder(); +// +// assertThrows(NullPointerException.class, () -> holder.add(null)); +// } +// +// @Test +// void shouldReturnNoErrorWhenCursorStagesHaveNoErrors() { +// var holder = new ResultCursorsHolder(); +// +// holder.add(cursorWithoutError()); +// holder.add(cursorWithoutError()); +// holder.add(cursorWithoutError()); +// holder.add(cursorWithoutError()); +// +// var error = await(holder.retrieveNotConsumedError()); +// assertNull(error); +// } +// +// @Test +// void shouldNotReturnStageErrors() { +// var holder = new ResultCursorsHolder(); +// +// holder.add(Futures.failedFuture(new RuntimeException("Failed to acquire a connection"))); +// holder.add(cursorWithoutError()); +// holder.add(cursorWithoutError()); +// holder.add(Futures.failedFuture(new IOException("Failed to do IO"))); +// +// var error = await(holder.retrieveNotConsumedError()); +// assertNull(error); +// } +// +// @Test +// void shouldReturnErrorWhenOneCursorFailed() { +// var error = new IOException("IO failed"); +// var holder = new ResultCursorsHolder(); +// +// holder.add(cursorWithoutError()); +// holder.add(cursorWithoutError()); +// holder.add(cursorWithError(error)); +// holder.add(cursorWithoutError()); +// +// var retrievedError = await(holder.retrieveNotConsumedError()); +// assertEquals(error, retrievedError); +// } +// +// @Test +// void shouldReturnFirstError() { +// var error1 = new RuntimeException("Error 1"); +// var error2 = new IOException("Error 2"); +// var error3 = new TimeoutException("Error 3"); +// var holder = new ResultCursorsHolder(); +// +// holder.add(cursorWithoutError()); +// holder.add(cursorWithError(error1)); +// holder.add(cursorWithError(error2)); +// holder.add(cursorWithError(error3)); +// +// assertEquals(error1, await(holder.retrieveNotConsumedError())); +// } +// +// @Test +// void shouldWaitForAllFailuresToArrive() { +// var error1 = new RuntimeException("Error 1"); +// var error2Future = new CompletableFuture(); +// var holder = new ResultCursorsHolder(); +// +// holder.add(cursorWithoutError()); +// holder.add(cursorWithError(error1)); +// holder.add(cursorWithFailureFuture(error2Future)); +// +// var failureFuture = holder.retrieveNotConsumedError().toCompletableFuture(); +// assertFalse(failureFuture.isDone()); +// +// error2Future.complete(null); +// assertTrue(failureFuture.isDone()); +// +// assertEquals(error1, await(failureFuture)); +// } +// +// private static CompletionStage cursorWithoutError() { +// return cursorWithError(null); +// } +// +// private static CompletionStage cursorWithError(Throwable error) { +// return cursorWithFailureFuture(completedFuture(error)); +// } +// +// private static CompletionStage cursorWithFailureFuture(CompletableFuture future) +// { +// var cursor = mock(AsyncResultCursorImpl.class); +// when(cursor.discardAllFailureAsync()).thenReturn(future); +// return completedFuture(cursor); +// } +// } diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/UnmanagedTransactionTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/UnmanagedTransactionTest.java index 99dfeb1633..2261d96d9a 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/UnmanagedTransactionTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/async/UnmanagedTransactionTest.java @@ -16,9 +16,7 @@ */ package org.neo4j.driver.internal.async; -import static java.util.Collections.emptyMap; import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -27,32 +25,19 @@ 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.ArgumentMatchers.anyBoolean; -import static org.mockito.ArgumentMatchers.anySet; -import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.ArgumentMatchers.argThat; -import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.ArgumentMatchers.anyLong; import static org.mockito.BDDMockito.given; import static org.mockito.BDDMockito.then; -import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE; import static org.neo4j.driver.testutil.TestUtil.assertNoCircularReferences; import static org.neo4j.driver.testutil.TestUtil.await; -import static org.neo4j.driver.testutil.TestUtil.beginMessage; import static org.neo4j.driver.testutil.TestUtil.connectionMock; -import static org.neo4j.driver.testutil.TestUtil.setupFailingRun; -import static org.neo4j.driver.testutil.TestUtil.setupSuccessfulRunAndPull; -import static org.neo4j.driver.testutil.TestUtil.setupSuccessfulRunRx; -import static org.neo4j.driver.testutil.TestUtil.verifyBeginTx; -import static org.neo4j.driver.testutil.TestUtil.verifyRollbackTx; +import static org.neo4j.driver.testutil.TestUtil.setupConnectionAnswers; import static org.neo4j.driver.testutil.TestUtil.verifyRunAndPull; -import static org.neo4j.driver.testutil.TestUtil.verifyRunRx; import java.util.Collections; import java.util.List; @@ -60,7 +45,6 @@ import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionStage; import java.util.concurrent.ExecutionException; -import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Supplier; import java.util.stream.Stream; @@ -76,27 +60,43 @@ import org.neo4j.driver.exceptions.AuthorizationExpiredException; import org.neo4j.driver.exceptions.ClientException; import org.neo4j.driver.exceptions.ConnectionReadTimeoutException; -import org.neo4j.driver.exceptions.Neo4jException; import org.neo4j.driver.exceptions.TransactionTerminatedException; -import org.neo4j.driver.internal.DatabaseBookmark; import org.neo4j.driver.internal.FailableCursor; import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.v4.BoltProtocolV4; -import org.neo4j.driver.internal.messaging.v53.BoltProtocolV53; -import org.neo4j.driver.internal.messaging.v54.BoltProtocolV54; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.DatabaseNameUtil; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; +import org.neo4j.driver.internal.bolt.api.summary.BeginSummary; +import org.neo4j.driver.internal.bolt.api.summary.CommitSummary; +import org.neo4j.driver.internal.bolt.api.summary.PullSummary; +import org.neo4j.driver.internal.bolt.api.summary.RollbackSummary; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; import org.neo4j.driver.internal.telemetry.ApiTelemetryWork; -import org.neo4j.driver.internal.telemetry.TelemetryApi; class UnmanagedTransactionTest { @Test void shouldFlushOnRunAsync() { // Given - var connection = connectionMock(BoltProtocolV4.INSTANCE); + var connection = connectionMock(new BoltProtocolVersion(5, 0)); + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(connection)); + given(connection.run(any(), any())).willReturn(CompletableFuture.completedStage(connection)); + given(connection.pull(anyLong(), anyLong())).willReturn(CompletableFuture.completedStage(connection)); + setupConnectionAnswers( + connection, + List.of( + handler -> { + handler.onBeginSummary(mock(BeginSummary.class)); + handler.onComplete(); + }, + handler -> { + handler.onRunSummary(mock(RunSummary.class)); + handler.onPullSummary(mock(PullSummary.class)); + handler.onComplete(); + })); var tx = beginTx(connection); - setupSuccessfulRunAndPull(connection); // When await(tx.runAsync(new Query("RETURN 1"))); @@ -108,55 +108,89 @@ void shouldFlushOnRunAsync() { @Test void shouldFlushOnRunRx() { // Given - var connection = connectionMock(BoltProtocolV4.INSTANCE); + var connection = connectionMock(new BoltProtocolVersion(5, 0)); + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(connection)); + given(connection.run(any(), any())).willReturn(CompletableFuture.completedStage(connection)); + setupConnectionAnswers( + connection, + List.of( + handler -> { + handler.onBeginSummary(mock(BeginSummary.class)); + handler.onComplete(); + }, + handler -> { + handler.onRunSummary(mock(RunSummary.class)); + handler.onComplete(); + })); var tx = beginTx(connection); - setupSuccessfulRunRx(connection); // When await(tx.runRx(new Query("RETURN 1"))); // Then - verifyRunRx(connection, "RETURN 1"); + then(connection).should().run("RETURN 1", Collections.emptyMap()); + then(connection).should(times(2)).flush(any()); } @Test void shouldRollbackOnImplicitFailure() { // Given var connection = connectionMock(); + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(connection)); + given(connection.rollback()).willReturn(CompletableFuture.completedStage(connection)); + setupConnectionAnswers( + connection, + List.of( + handler -> { + handler.onBeginSummary(mock(BeginSummary.class)); + handler.onComplete(); + }, + handler -> { + handler.onRollbackSummary(mock(RollbackSummary.class)); + handler.onComplete(); + })); + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); var tx = beginTx(connection); // When await(tx.closeAsync()); // Then - var order = inOrder(connection); - verifyBeginTx(connection); - verifyRollbackTx(connection); - order.verify(connection).release(); + then(connection).should().beginTransaction(any(), any(), any(), any(), any(), any(), any(), any()); + then(connection).should().rollback(); + then(connection).should(times(2)).flush(any()); + then(connection).should().close(); } @Test - void shouldOnlyQueueMessagesWhenNoBookmarkGiven() { + void shouldBeginTransaction() { var connection = connectionMock(); + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(connection)); + setupConnectionAnswers(connection, List.of(handler -> { + handler.onBeginSummary(mock(BeginSummary.class)); + handler.onComplete(); + })); beginTx(connection, Collections.emptySet()); - verifyBeginTx(connection); + then(connection).should().beginTransaction(any(), any(), any(), any(), any(), any(), any(), any()); + then(connection).should().flush(any()); } @Test - void shouldFlushWhenBookmarkGiven() { - var bookmarks = Collections.singleton(InternalBookmark.parse("hi, I'm bookmark")); + void shouldBeOpenAfterConstruction() { var connection = connectionMock(); + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(connection)); + setupConnectionAnswers(connection, List.of(handler -> { + handler.onBeginSummary(mock(BeginSummary.class)); + handler.onComplete(); + })); - beginTx(connection, bookmarks); - - verifyBeginTx(connection); - } - - @Test - void shouldBeOpenAfterConstruction() { - var tx = beginTx(connectionMock()); + var tx = beginTx(connection); assertTrue(tx.isOpen()); } @@ -164,7 +198,14 @@ void shouldBeOpenAfterConstruction() { @Test @SuppressWarnings("ThrowableNotThrown") void shouldBeClosedWhenMarkedAsTerminated() { - var tx = beginTx(connectionMock()); + var connection = connectionMock(); + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(connection)); + setupConnectionAnswers(connection, List.of(handler -> { + handler.onBeginSummary(mock(BeginSummary.class)); + handler.onComplete(); + })); + var tx = beginTx(connection); tx.markTerminated(null); @@ -174,7 +215,15 @@ void shouldBeClosedWhenMarkedAsTerminated() { @Test @SuppressWarnings("ThrowableNotThrown") void shouldBeClosedWhenMarkedTerminatedAndClosed() { - var tx = beginTx(connectionMock()); + var connection = connectionMock(); + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(connection)); + setupConnectionAnswers(connection, List.of(handler -> { + handler.onBeginSummary(mock(BeginSummary.class)); + handler.onComplete(); + })); + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); + var tx = beginTx(connection); tx.markTerminated(null); await(tx.closeAsync()); @@ -185,10 +234,22 @@ void shouldBeClosedWhenMarkedTerminatedAndClosed() { @Test void shouldReleaseConnectionWhenBeginFails() { var error = new RuntimeException("Wrong bookmark!"); - var connection = connectionWithBegin(handler -> handler.onFailure(error)); + var connection = connectionMock(); + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(CompletableFuture.completedStage(connection)); + setupConnectionAnswers(connection, List.of(handler -> handler.onError(error))); + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); var tx = new UnmanagedTransaction( - connection, (ignored) -> {}, UNLIMITED_FETCH_SIZE, null, apiTelemetryWork, Logging.none()); + connection, + DatabaseNameUtil.defaultDatabase(), + AccessMode.WRITE, + null, + (ignored) -> {}, + -1, + null, + apiTelemetryWork, + Logging.none()); var bookmarks = Collections.singleton(InternalBookmark.parse("SomeBookmark")); var txConfig = TransactionConfig.empty(); @@ -196,52 +257,77 @@ void shouldReleaseConnectionWhenBeginFails() { var e = assertThrows(RuntimeException.class, () -> await(tx.beginAsync(bookmarks, txConfig, null, true))); assertEquals(error, e); - verify(connection).release(); + verify(connection).close(); } @Test void shouldNotReleaseConnectionWhenBeginSucceeds() { - var connection = connectionWithBegin(handler -> handler.onSuccess(emptyMap())); + var connection = connectionMock(); + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(CompletableFuture.completedStage(connection)); + setupConnectionAnswers(connection, List.of(handler -> handler.onBeginSummary(mock(BeginSummary.class)))); + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); var tx = new UnmanagedTransaction( - connection, (ignored) -> {}, UNLIMITED_FETCH_SIZE, null, apiTelemetryWork, Logging.none()); + connection, + DatabaseNameUtil.defaultDatabase(), + AccessMode.WRITE, + null, + (ignored) -> {}, + -1, + null, + apiTelemetryWork, + Logging.none()); var bookmarks = Collections.singleton(InternalBookmark.parse("SomeBookmark")); var txConfig = TransactionConfig.empty(); await(tx.beginAsync(bookmarks, txConfig, null, true)); - verify(connection, never()).release(); + verify(connection, never()).close(); } @Test @SuppressWarnings("ThrowableNotThrown") void shouldReleaseConnectionWhenTerminatedAndCommitted() { var connection = connectionMock(); + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); var tx = new UnmanagedTransaction( - connection, (ignored) -> {}, UNLIMITED_FETCH_SIZE, null, apiTelemetryWork, Logging.none()); + connection, + DatabaseNameUtil.defaultDatabase(), + AccessMode.WRITE, + null, + (ignored) -> {}, + -1, + null, + apiTelemetryWork, + Logging.none()); tx.markTerminated(null); assertThrows(TransactionTerminatedException.class, () -> await(tx.commitAsync())); assertFalse(tx.isOpen()); - verify(connection).release(); + verify(connection).close(); } @Test @SuppressWarnings("ThrowableNotThrown") void shouldNotCreateCircularExceptionWhenTerminationCauseEqualsToCursorFailure() { var connection = connectionMock(); + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); var terminationCause = new ClientException("Custom exception"); var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); var resultCursorsHolder = mockResultCursorWith(terminationCause); var tx = new UnmanagedTransaction( connection, + DatabaseNameUtil.defaultDatabase(), + AccessMode.WRITE, + null, (ignored) -> {}, - UNLIMITED_FETCH_SIZE, + -1, resultCursorsHolder, null, apiTelemetryWork, @@ -258,13 +344,17 @@ void shouldNotCreateCircularExceptionWhenTerminationCauseEqualsToCursorFailure() @SuppressWarnings("ThrowableNotThrown") void shouldNotCreateCircularExceptionWhenTerminationCauseDifferentFromCursorFailure() { var connection = connectionMock(); + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); var terminationCause = new ClientException("Custom exception"); var resultCursorsHolder = mockResultCursorWith(new ClientException("Cursor error")); var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); var tx = new UnmanagedTransaction( connection, + DatabaseNameUtil.defaultDatabase(), + AccessMode.WRITE, + null, (ignored) -> {}, - UNLIMITED_FETCH_SIZE, + -1, resultCursorsHolder, null, apiTelemetryWork, @@ -284,10 +374,19 @@ void shouldNotCreateCircularExceptionWhenTerminationCauseDifferentFromCursorFail @SuppressWarnings("ThrowableNotThrown") void shouldNotCreateCircularExceptionWhenTerminatedWithoutFailure() { var connection = connectionMock(); + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); var terminationCause = new ClientException("Custom exception"); var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); var tx = new UnmanagedTransaction( - connection, (ignored) -> {}, UNLIMITED_FETCH_SIZE, null, apiTelemetryWork, Logging.none()); + connection, + DatabaseNameUtil.defaultDatabase(), + AccessMode.WRITE, + null, + (ignored) -> {}, + -1, + null, + apiTelemetryWork, + Logging.none()); tx.markTerminated(terminationCause); @@ -301,35 +400,67 @@ void shouldNotCreateCircularExceptionWhenTerminatedWithoutFailure() { @SuppressWarnings("ThrowableNotThrown") void shouldReleaseConnectionWhenTerminatedAndRolledBack() { var connection = connectionMock(); + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); var tx = new UnmanagedTransaction( - connection, (ignored) -> {}, UNLIMITED_FETCH_SIZE, null, apiTelemetryWork, Logging.none()); + connection, + DatabaseNameUtil.defaultDatabase(), + AccessMode.WRITE, + null, + (ignored) -> {}, + -1, + null, + apiTelemetryWork, + Logging.none()); tx.markTerminated(null); await(tx.rollbackAsync()); - verify(connection).release(); + verify(connection).close(); } @Test void shouldReleaseConnectionWhenClose() { var connection = connectionMock(); + given(connection.rollback()).willReturn(CompletableFuture.completedStage(connection)); + setupConnectionAnswers(connection, List.of(handler -> handler.onRollbackSummary(mock(RollbackSummary.class)))); + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); var tx = new UnmanagedTransaction( - connection, (ignored) -> {}, UNLIMITED_FETCH_SIZE, null, apiTelemetryWork, Logging.none()); + connection, + DatabaseNameUtil.defaultDatabase(), + AccessMode.WRITE, + null, + (ignored) -> {}, + -1, + null, + apiTelemetryWork, + Logging.none()); await(tx.closeAsync()); - verify(connection).release(); + verify(connection).close(); } @Test void shouldReleaseConnectionOnConnectionAuthorizationExpiredExceptionFailure() { var exception = new AuthorizationExpiredException("code", "message"); - var connection = connectionWithBegin(handler -> handler.onFailure(exception)); + var connection = connectionMock(); + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(CompletableFuture.completedStage(connection)); + setupConnectionAnswers(connection, List.of(handler -> handler.onError(exception))); + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); var tx = new UnmanagedTransaction( - connection, (ignored) -> {}, UNLIMITED_FETCH_SIZE, null, apiTelemetryWork, Logging.none()); + connection, + DatabaseNameUtil.defaultDatabase(), + AccessMode.WRITE, + null, + (ignored) -> {}, + -1, + null, + apiTelemetryWork, + Logging.none()); var bookmarks = Collections.singleton(InternalBookmark.parse("SomeBookmark")); var txConfig = TransactionConfig.empty(); @@ -337,16 +468,28 @@ void shouldReleaseConnectionOnConnectionAuthorizationExpiredExceptionFailure() { AuthorizationExpiredException.class, () -> await(tx.beginAsync(bookmarks, txConfig, null, true))); assertSame(exception, actualException); - verify(connection).terminateAndRelease(AuthorizationExpiredException.DESCRIPTION); - verify(connection, never()).release(); + verify(connection).close(); } @Test void shouldReleaseConnectionOnConnectionReadTimeoutExceptionFailure() { - var connection = connectionWithBegin(handler -> handler.onFailure(ConnectionReadTimeoutException.INSTANCE)); + var connection = connectionMock(); + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(CompletableFuture.completedStage(connection)); + setupConnectionAnswers( + connection, List.of(handler -> handler.onError(ConnectionReadTimeoutException.INSTANCE))); + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); var tx = new UnmanagedTransaction( - connection, (ignored) -> {}, UNLIMITED_FETCH_SIZE, null, apiTelemetryWork, Logging.none()); + connection, + DatabaseNameUtil.defaultDatabase(), + AccessMode.WRITE, + null, + (ignored) -> {}, + -1, + null, + apiTelemetryWork, + Logging.none()); var bookmarks = Collections.singleton(InternalBookmark.parse("SomeBookmark")); var txConfig = TransactionConfig.empty(); @@ -354,8 +497,7 @@ void shouldReleaseConnectionOnConnectionReadTimeoutExceptionFailure() { ConnectionReadTimeoutException.class, () -> await(tx.beginAsync(bookmarks, txConfig, null, true))); assertSame(ConnectionReadTimeoutException.INSTANCE, actualException); - verify(connection).terminateAndRelease(ConnectionReadTimeoutException.INSTANCE.getMessage()); - verify(connection, never()).release(); + verify(connection).close(); } private static Stream similarTransactionCompletingActionArgs() { @@ -371,23 +513,31 @@ private static Stream similarTransactionCompletingActionArgs() { @MethodSource("similarTransactionCompletingActionArgs") void shouldReturnExistingStageOnSimilarCompletingAction( boolean protocolCommit, String initialAction, String similarAction) { - var connection = mock(Connection.class); - var protocol = mock(BoltProtocol.class); - given(connection.protocol()).willReturn(protocol); - given(protocolCommit ? protocol.commitTransaction(connection) : protocol.rollbackTransaction(connection)) - .willReturn(new CompletableFuture<>()); + var connection = connectionMock(); + given(connection.commit()).willReturn(CompletableFuture.completedStage(connection)); + given(connection.rollback()).willReturn(CompletableFuture.completedStage(connection)); + given(connection.flush(any())).willReturn(CompletableFuture.completedStage(null)); + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); var tx = new UnmanagedTransaction( - connection, (ignored) -> {}, UNLIMITED_FETCH_SIZE, null, apiTelemetryWork, Logging.none()); + connection, + DatabaseNameUtil.defaultDatabase(), + AccessMode.WRITE, + null, + (ignored) -> {}, + -1, + null, + apiTelemetryWork, + Logging.none()); var initialStage = mapTransactionAction(initialAction, tx).get(); var similarStage = mapTransactionAction(similarAction, tx).get(); assertSame(initialStage, similarStage); if (protocolCommit) { - then(protocol).should(times(1)).commitTransaction(connection); + then(connection).should(times(1)).commit(); } else { - then(protocol).should(times(1)).rollbackTransaction(connection); + then(connection).should(times(1)).rollback(); } } @@ -413,24 +563,43 @@ void shouldReturnFailingStageOnConflictingCompletingAction( String initialAction, String conflictingAction, String expectedErrorMsg) { - var connection = mock(Connection.class); - var protocol = mock(BoltProtocol.class); - given(connection.protocol()).willReturn(protocol); - given(protocolCommit ? protocol.commitTransaction(connection) : protocol.rollbackTransaction(connection)) - .willReturn(protocolActionCompleted ? completedFuture(null) : new CompletableFuture<>()); + var connection = connectionMock(); + given(connection.commit()).willReturn(CompletableFuture.completedStage(connection)); + given(connection.rollback()).willReturn(CompletableFuture.completedStage(connection)); + if (protocolActionCompleted) { + setupConnectionAnswers(connection, List.of(handler -> { + if (protocolCommit) { + handler.onCommitSummary(mock(CommitSummary.class)); + } else { + handler.onRollbackSummary(mock(RollbackSummary.class)); + } + })); + } else { + given(connection.flush(any())).willReturn(CompletableFuture.completedStage(null)); + } + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); var tx = new UnmanagedTransaction( - connection, (ignored) -> {}, UNLIMITED_FETCH_SIZE, null, apiTelemetryWork, Logging.none()); + connection, + DatabaseNameUtil.defaultDatabase(), + AccessMode.WRITE, + null, + (ignored) -> {}, + -1, + null, + apiTelemetryWork, + Logging.none()); var originalActionStage = mapTransactionAction(initialAction, tx).get(); var conflictingActionStage = mapTransactionAction(conflictingAction, tx).get(); assertNotNull(originalActionStage); if (protocolCommit) { - then(protocol).should(times(1)).commitTransaction(connection); + then(connection).should().commit(); } else { - then(protocol).should(times(1)).rollbackTransaction(connection); + then(connection).should().rollback(); } + then(connection).should().flush(any()); assertTrue(conflictingActionStage.toCompletableFuture().isCompletedExceptionally()); var throwable = assertThrows( ExecutionException.class, @@ -456,14 +625,28 @@ private static Stream closingNotActionTransactionArgs() { @MethodSource("closingNotActionTransactionArgs") void shouldReturnCompletedWithNullStageOnClosingInactiveTransactionExceptCommittingAborted( boolean protocolCommit, int expectedProtocolInvocations, String originalAction, Boolean commitOnClose) { - var connection = mock(Connection.class); - var protocol = mock(BoltProtocol.class); - given(connection.protocol()).willReturn(protocol); - given(protocolCommit ? protocol.commitTransaction(connection) : protocol.rollbackTransaction(connection)) - .willReturn(completedFuture(null)); + var connection = connectionMock(); + given(connection.commit()).willReturn(CompletableFuture.completedStage(connection)); + given(connection.rollback()).willReturn(CompletableFuture.completedStage(connection)); + setupConnectionAnswers(connection, List.of(handler -> { + if (protocolCommit) { + handler.onCommitSummary(mock(CommitSummary.class)); + } else { + handler.onRollbackSummary(mock(RollbackSummary.class)); + } + })); + given(connection.close()).willReturn(CompletableFuture.completedStage(null)); var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); var tx = new UnmanagedTransaction( - connection, (ignored) -> {}, UNLIMITED_FETCH_SIZE, null, apiTelemetryWork, Logging.none()); + connection, + DatabaseNameUtil.defaultDatabase(), + AccessMode.WRITE, + null, + (ignored) -> {}, + -1, + null, + apiTelemetryWork, + Logging.none()); var originalActionStage = mapTransactionAction(originalAction, tx).get(); var closeStage = commitOnClose != null ? tx.closeAsync(commitOnClose) : tx.closeAsync(); @@ -471,73 +654,79 @@ void shouldReturnCompletedWithNullStageOnClosingInactiveTransactionExceptCommitt assertTrue(originalActionStage.toCompletableFuture().isDone()); assertFalse(originalActionStage.toCompletableFuture().isCompletedExceptionally()); if (protocolCommit) { - then(protocol).should(times(expectedProtocolInvocations)).commitTransaction(connection); + then(connection).should(times(expectedProtocolInvocations)).commit(); } else { - then(protocol).should(times(expectedProtocolInvocations)).rollbackTransaction(connection); + then(connection).should(times(expectedProtocolInvocations)).rollback(); } + then(connection).should(times(expectedProtocolInvocations)).flush(any()); assertNull(closeStage.toCompletableFuture().join()); } - @Test - void shouldTerminateOnTerminateAsync() { - // Given - var connection = connectionMock(BoltProtocolV4.INSTANCE); - var tx = beginTx(connection); - - // When - await(tx.terminateAsync()); - - // Then - then(connection).should().reset(any()); - } - - @Test - void shouldServeTheSameStageOnTerminateAsync() { - // Given - var connection = connectionMock(BoltProtocolV4.INSTANCE); - var tx = beginTx(connection); - - // When - var stage0 = tx.terminateAsync(); - var stage1 = tx.terminateAsync(); - - // Then - assertEquals(stage0, stage1); - } - - @Test - void shouldHandleTerminationWhenAlreadyTerminated() throws ExecutionException, InterruptedException { - // Given - var connection = connectionMock(BoltProtocolV4.INSTANCE); - var exception = new Neo4jException("message"); - setupFailingRun(connection, exception); - var tx = beginTx(connection); - Throwable actualException = null; - - // When - try { - tx.runAsync(new Query("RETURN 1")).toCompletableFuture().get(); - } catch (ExecutionException e) { - actualException = e.getCause(); - } - tx.terminateAsync().toCompletableFuture().get(); - - // Then - assertEquals(exception, actualException); - } + // @Test + // void shouldTerminateOnTerminateAsync() { + // // Given + // var connection = connectionMock(BoltProtocolV4.INSTANCE); + // var tx = beginTx(connection); + // + // // When + // await(tx.terminateAsync()); + // + // // Then + // then(connection).should().reset(any()); + // } + // + // @Test + // void shouldServeTheSameStageOnTerminateAsync() { + // // Given + // var connection = connectionMock(BoltProtocolV4.INSTANCE); + // var tx = beginTx(connection); + // + // // When + // var stage0 = tx.terminateAsync(); + // var stage1 = tx.terminateAsync(); + // + // // Then + // assertEquals(stage0, stage1); + // } + // + // @Test + // void shouldHandleTerminationWhenAlreadyTerminated() throws ExecutionException, InterruptedException { + // // Given + // var connection = connectionMock(BoltProtocolV4.INSTANCE); + // var exception = new Neo4jException("message"); + // setupFailingRun(connection, exception); + // var tx = beginTx(connection); + // Throwable actualException = null; + // + // // When + // try { + // tx.runAsync(new Query("RETURN 1")).toCompletableFuture().get(); + // } catch (ExecutionException e) { + // actualException = e.getCause(); + // } + // tx.terminateAsync().toCompletableFuture().get(); + // + // // Then + // assertEquals(exception, actualException); + // } @ParameterizedTest @MethodSource("transactionClosingTestParams") void shouldThrowOnRunningNewQueriesWhenTransactionIsClosing(TransactionClosingTestParams testParams) { // Given - var boltProtocol = mock(BoltProtocol.class); - given(boltProtocol.version()).willReturn(BoltProtocolV53.VERSION); - var closureStage = new CompletableFuture(); - var connection = connectionMock(boltProtocol); - given(boltProtocol.beginTransaction(eq(connection), any(), any(), any(), any(), any(), eq(true))) - .willReturn(completedFuture(null)); - given(boltProtocol.commitTransaction(connection)).willReturn(closureStage); - given(boltProtocol.rollbackTransaction(connection)).willReturn(closureStage.thenApply(ignored -> null)); + var connection = connectionMock(); + given(connection.beginTransaction(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(CompletableFuture.completedStage(connection)); + given(connection.commit()).willReturn(CompletableFuture.completedStage(connection)); + given(connection.rollback()).willReturn(CompletableFuture.completedStage(connection)); + setupConnectionAnswers( + connection, + List.of( + handler -> { + handler.onBeginSummary(mock(BeginSummary.class)); + handler.onComplete(); + }, + handler -> {})); var tx = beginTx(connection); // When @@ -549,105 +738,110 @@ void shouldThrowOnRunningNewQueriesWhenTransactionIsClosing(TransactionClosingTe assertEquals(testParams.expectedMessage(), exception.getMessage()); } - @Test - void shouldBeginAsyncTelemetryNotCompleteReturnedFuture() { - var protocol = mock(BoltProtocol.class); - given(protocol.version()).willReturn(BoltProtocolV54.VERSION); - var connection = connectionMock(protocol); - var apiTelemetryWork = mock(ApiTelemetryWork.class); - var beginFuture = new CompletableFuture<>(); - doReturn(CompletableFuture.completedFuture(null)).when(apiTelemetryWork).execute(connection, protocol); - doReturn(beginFuture) - .when(protocol) - .beginTransaction(any(), anySet(), any(), anyString(), any(), any(), anyBoolean()); - var unmanagedTransaction = new UnmanagedTransaction(connection, (bm) -> {}, 100, null, apiTelemetryWork, null); - - assertFalse(unmanagedTransaction - .beginAsync(Set.of(), TransactionConfig.empty(), "tx", true) - .toCompletableFuture() - .isDone()); - - beginFuture.complete(null); - - assertTrue(unmanagedTransaction - .beginAsync(Set.of(), TransactionConfig.empty(), "tx", true) - .toCompletableFuture() - .isDone()); - } - - @Test - void shouldBeginAsyncThrowErrorOnTelemetryIfFlushIsTrueAndBeginDontFinish() { - var protocol = mock(BoltProtocol.class); - given(protocol.version()).willReturn(BoltProtocolV54.VERSION); - var connection = connectionMock(protocol); - var apiTelemetryWork = mock(ApiTelemetryWork.class); - doReturn(CompletableFuture.failedFuture(new SecurityException("My Exception"))) - .when(apiTelemetryWork) - .execute(connection, protocol); - doReturn(new CompletableFuture<>()) - .when(protocol) - .beginTransaction(any(), anySet(), any(), anyString(), any(), any(), anyBoolean()); - var unmanagedTransaction = new UnmanagedTransaction(connection, (bm) -> {}, 100, null, apiTelemetryWork, null); - - assertThrows( - SecurityException.class, - () -> await(unmanagedTransaction.beginAsync(Set.of(), TransactionConfig.empty(), "tx", true))); - } - - @Test - void shouldBeginAsyncThrowErrorOnTelemetryIfFlushIsTrueAndBeginFailed() { - var protocol = mock(BoltProtocol.class); - given(protocol.version()).willReturn(BoltProtocolV54.VERSION); - var connection = connectionMock(protocol); - var apiTelemetryWork = mock(ApiTelemetryWork.class); - doReturn(CompletableFuture.failedFuture(new SecurityException("My Exception"))) - .when(apiTelemetryWork) - .execute(connection, protocol); - doReturn(CompletableFuture.failedFuture(new ClientException("other error"))) - .when(protocol) - .beginTransaction(any(), anySet(), any(), anyString(), any(), any(), anyBoolean()); - var unmanagedTransaction = new UnmanagedTransaction(connection, (bm) -> {}, 100, null, apiTelemetryWork, null); - - assertThrows( - SecurityException.class, - () -> await(unmanagedTransaction.beginAsync(Set.of(), TransactionConfig.empty(), "tx", true))); - } - - @Test - void shouldBeginAsyncNotThrowErrorOnTelemetryIfNotFlushIsTrueAndBeginDontFinish() { - var protocol = mock(BoltProtocol.class); - given(protocol.version()).willReturn(BoltProtocolV54.VERSION); - var connection = connectionMock(protocol); - var apiTelemetryWork = mock(ApiTelemetryWork.class); - doReturn(CompletableFuture.failedFuture(new SecurityException("My Exception"))) - .when(apiTelemetryWork) - .execute(connection, protocol); - doReturn(new CompletableFuture<>()) - .when(protocol) - .beginTransaction(any(), anySet(), any(), anyString(), any(), any(), anyBoolean()); - var unmanagedTransaction = new UnmanagedTransaction(connection, (bm) -> {}, 100, null, apiTelemetryWork, null); - - assertDoesNotThrow( - () -> await(unmanagedTransaction.beginAsync(Set.of(), TransactionConfig.empty(), "tx", false))); - } - - @Test - void shouldBeginAsyncNotThrowErrorOnTelemetryIfNotFlushIsTrueAndBeginFailed() { - var protocol = mock(BoltProtocol.class); - given(protocol.version()).willReturn(BoltProtocolV54.VERSION); - var connection = connectionMock(protocol); - var apiTelemetryWork = mock(ApiTelemetryWork.class); - doReturn(CompletableFuture.failedFuture(new SecurityException("My Exception"))) - .when(apiTelemetryWork) - .execute(connection, protocol); - doReturn(CompletableFuture.failedFuture(new ClientException("other error"))) - .when(protocol) - .beginTransaction(any(), anySet(), any(), anyString(), any(), any(), anyBoolean()); - var unmanagedTransaction = new UnmanagedTransaction(connection, (bm) -> {}, 100, null, apiTelemetryWork, null); - - assertDoesNotThrow( - () -> await(unmanagedTransaction.beginAsync(Set.of(), TransactionConfig.empty(), "tx", false))); - } + // @Test + // void shouldBeginAsyncTelemetryNotCompleteReturnedFuture() { + // var protocol = mock(BoltProtocol.class); + // given(protocol.version()).willReturn(BoltProtocolV54.VERSION); + // var connection = connectionMock(protocol); + // var apiTelemetryWork = mock(ApiTelemetryWork.class); + // var beginFuture = new CompletableFuture<>(); + // doReturn(CompletableFuture.completedFuture(null)).when(apiTelemetryWork).execute(connection, protocol); + // doReturn(beginFuture) + // .when(protocol) + // .beginTransaction(any(), anySet(), any(), anyString(), any(), any(), anyBoolean()); + // var unmanagedTransaction = new UnmanagedTransaction(connection, (bm) -> {}, 100, null, apiTelemetryWork, + // null); + // + // assertFalse(unmanagedTransaction + // .beginAsync(Set.of(), TransactionConfig.empty(), "tx", true) + // .toCompletableFuture() + // .isDone()); + // + // beginFuture.complete(null); + // + // assertTrue(unmanagedTransaction + // .beginAsync(Set.of(), TransactionConfig.empty(), "tx", true) + // .toCompletableFuture() + // .isDone()); + // } + // + // @Test + // void shouldBeginAsyncThrowErrorOnTelemetryIfFlushIsTrueAndBeginDontFinish() { + // var protocol = mock(BoltProtocol.class); + // given(protocol.version()).willReturn(BoltProtocolV54.VERSION); + // var connection = connectionMock(protocol); + // var apiTelemetryWork = mock(ApiTelemetryWork.class); + // doReturn(CompletableFuture.failedFuture(new SecurityException("My Exception"))) + // .when(apiTelemetryWork) + // .execute(connection, protocol); + // doReturn(new CompletableFuture<>()) + // .when(protocol) + // .beginTransaction(any(), anySet(), any(), anyString(), any(), any(), anyBoolean()); + // var unmanagedTransaction = new UnmanagedTransaction(connection, (bm) -> {}, 100, null, apiTelemetryWork, + // null); + // + // assertThrows( + // SecurityException.class, + // () -> await(unmanagedTransaction.beginAsync(Set.of(), TransactionConfig.empty(), "tx", true))); + // } + // + // @Test + // void shouldBeginAsyncThrowErrorOnTelemetryIfFlushIsTrueAndBeginFailed() { + // var protocol = mock(BoltProtocol.class); + // given(protocol.version()).willReturn(BoltProtocolV54.VERSION); + // var connection = connectionMock(protocol); + // var apiTelemetryWork = mock(ApiTelemetryWork.class); + // doReturn(CompletableFuture.failedFuture(new SecurityException("My Exception"))) + // .when(apiTelemetryWork) + // .execute(connection, protocol); + // doReturn(CompletableFuture.failedFuture(new ClientException("other error"))) + // .when(protocol) + // .beginTransaction(any(), anySet(), any(), anyString(), any(), any(), anyBoolean()); + // var unmanagedTransaction = new UnmanagedTransaction(connection, (bm) -> {}, 100, null, apiTelemetryWork, + // null); + // + // assertThrows( + // SecurityException.class, + // () -> await(unmanagedTransaction.beginAsync(Set.of(), TransactionConfig.empty(), "tx", true))); + // } + // + // @Test + // void shouldBeginAsyncNotThrowErrorOnTelemetryIfNotFlushIsTrueAndBeginDontFinish() { + // var protocol = mock(BoltProtocol.class); + // given(protocol.version()).willReturn(BoltProtocolV54.VERSION); + // var connection = connectionMock(protocol); + // var apiTelemetryWork = mock(ApiTelemetryWork.class); + // doReturn(CompletableFuture.failedFuture(new SecurityException("My Exception"))) + // .when(apiTelemetryWork) + // .execute(connection, protocol); + // doReturn(new CompletableFuture<>()) + // .when(protocol) + // .beginTransaction(any(), anySet(), any(), anyString(), any(), any(), anyBoolean()); + // var unmanagedTransaction = new UnmanagedTransaction(connection, (bm) -> {}, 100, null, apiTelemetryWork, + // null); + // + // assertDoesNotThrow( + // () -> await(unmanagedTransaction.beginAsync(Set.of(), TransactionConfig.empty(), "tx", false))); + // } + // + // @Test + // void shouldBeginAsyncNotThrowErrorOnTelemetryIfNotFlushIsTrueAndBeginFailed() { + // var protocol = mock(BoltProtocol.class); + // given(protocol.version()).willReturn(BoltProtocolV54.VERSION); + // var connection = connectionMock(protocol); + // var apiTelemetryWork = mock(ApiTelemetryWork.class); + // doReturn(CompletableFuture.failedFuture(new SecurityException("My Exception"))) + // .when(apiTelemetryWork) + // .execute(connection, protocol); + // doReturn(CompletableFuture.failedFuture(new ClientException("other error"))) + // .when(protocol) + // .beginTransaction(any(), anySet(), any(), anyString(), any(), any(), anyBoolean()); + // var unmanagedTransaction = new UnmanagedTransaction(connection, (bm) -> {}, 100, null, apiTelemetryWork, + // null); + // + // assertDoesNotThrow( + // () -> await(unmanagedTransaction.beginAsync(Set.of(), TransactionConfig.empty(), "tx", false))); + // } static List transactionClosingTestParams() { Function> asyncRun = tx -> tx.runAsync(new Query("query")); @@ -696,30 +890,38 @@ private record TransactionClosingTestParams( Function> runAction, String expectedMessage) {} - private static UnmanagedTransaction beginTx(Connection connection) { + private static UnmanagedTransaction beginTx(BoltConnection connection) { return beginTx(connection, Collections.emptySet()); } - private static UnmanagedTransaction beginTx(Connection connection, Set initialBookmarks) { + private static UnmanagedTransaction beginTx(BoltConnection connection, Set initialBookmarks) { var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); var tx = new UnmanagedTransaction( - connection, (ignored) -> {}, UNLIMITED_FETCH_SIZE, null, apiTelemetryWork, Logging.none()); + connection, + DatabaseNameUtil.defaultDatabase(), + AccessMode.WRITE, + null, + (ignored) -> {}, + -1, + null, + apiTelemetryWork, + Logging.none()); return await(tx.beginAsync(initialBookmarks, TransactionConfig.empty(), null, true)); } - private static Connection connectionWithBegin(Consumer beginBehaviour) { - var connection = connectionMock(); - - doAnswer(invocation -> { - ResponseHandler beginHandler = invocation.getArgument(1); - beginBehaviour.accept(beginHandler); - return null; - }) - .when(connection) - .writeAndFlush(argThat(beginMessage()), any()); - - return connection; - } + // private static BoltConnection connectionWithBegin(Consumer beginBehaviour) { + // var connection = connectionMock(); + // + // doAnswer(invocation -> { + // ResponseHandler beginHandler = invocation.getArgument(1); + // beginBehaviour.accept(beginHandler); + // return null; + // }) + // .when(connection) + // .writeAndFlush(argThat(beginMessage()), any()); + // + // return connection; + // } private ResultCursorsHolder mockResultCursorWith(ClientException clientException) { var resultCursorsHolder = new ResultCursorsHolder(); diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/connection/DecoratedConnectionTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/connection/DecoratedConnectionTest.java deleted file mode 100644 index 93eb31daaa..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/async/connection/DecoratedConnectionTest.java +++ /dev/null @@ -1,169 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.connection; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.AccessMode.READ; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; - -import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.EnumSource; -import org.junit.jupiter.params.provider.ValueSource; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; -import org.neo4j.driver.net.ServerAddress; - -class DecoratedConnectionTest { - @ParameterizedTest - @ValueSource(strings = {"true", "false"}) - void shouldDelegateIsOpen(String open) { - var mockConnection = mock(Connection.class); - when(mockConnection.isOpen()).thenReturn(Boolean.valueOf(open)); - - var connection = newConnection(mockConnection); - - assertEquals(Boolean.valueOf(open), connection.isOpen()); - verify(mockConnection).isOpen(); - } - - @Test - void shouldDelegateEnableAutoRead() { - var mockConnection = mock(Connection.class); - var connection = newConnection(mockConnection); - - connection.enableAutoRead(); - - verify(mockConnection).enableAutoRead(); - } - - @Test - void shouldDelegateDisableAutoRead() { - var mockConnection = mock(Connection.class); - var connection = newConnection(mockConnection); - - connection.disableAutoRead(); - - verify(mockConnection).disableAutoRead(); - } - - @Test - void shouldDelegateWrite() { - var mockConnection = mock(Connection.class); - var connection = newConnection(mockConnection); - - var message = mock(Message.class); - var handler = mock(ResponseHandler.class); - - connection.write(message, handler); - - verify(mockConnection).write(message, handler); - } - - @Test - void shouldDelegateWriteAndFlush() { - var mockConnection = mock(Connection.class); - var connection = newConnection(mockConnection); - - var message = mock(Message.class); - var handler = mock(ResponseHandler.class); - - connection.writeAndFlush(message, handler); - - verify(mockConnection).writeAndFlush(message, handler); - } - - @Test - void shouldDelegateReset() { - var mockConnection = mock(Connection.class); - var connection = newConnection(mockConnection); - - connection.reset(null); - - verify(mockConnection).reset(null); - } - - @Test - void shouldDelegateRelease() { - var mockConnection = mock(Connection.class); - var connection = newConnection(mockConnection); - - connection.release(); - - verify(mockConnection).release(); - } - - @Test - void shouldDelegateTerminateAndRelease() { - var mockConnection = mock(Connection.class); - var connection = newConnection(mockConnection); - - connection.terminateAndRelease("a reason"); - - verify(mockConnection).terminateAndRelease("a reason"); - } - - @Test - void shouldDelegateServerAddress() { - var address = BoltServerAddress.from(ServerAddress.of("localhost", 9999)); - var mockConnection = mock(Connection.class); - when(mockConnection.serverAddress()).thenReturn(address); - var connection = newConnection(mockConnection); - - assertSame(address, connection.serverAddress()); - verify(mockConnection).serverAddress(); - } - - @Test - void shouldDelegateProtocol() { - var protocol = mock(BoltProtocol.class); - var mockConnection = mock(Connection.class); - when(mockConnection.protocol()).thenReturn(protocol); - var connection = newConnection(mockConnection); - - assertSame(protocol, connection.protocol()); - verify(mockConnection).protocol(); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldReturnModeFromConstructor(AccessMode mode) { - var connection = new DirectConnection(mock(Connection.class), defaultDatabase(), mode, null); - - assertEquals(mode, connection.mode()); - } - - @Test - void shouldReturnConnection() { - var mockConnection = mock(Connection.class); - var connection = newConnection(mockConnection); - - assertSame(mockConnection, connection.connection()); - } - - private static DirectConnection newConnection(Connection connection) { - return new DirectConnection(connection, defaultDatabase(), READ, null); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/connection/DirectConnectionTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/connection/DirectConnectionTest.java deleted file mode 100644 index ba4c11e18a..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/async/connection/DirectConnectionTest.java +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.connection; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.mockito.BDDMockito.given; -import static org.mockito.BDDMockito.then; -import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.mock; -import static org.neo4j.driver.AccessMode.READ; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; - -import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.ValueSource; -import org.neo4j.driver.internal.spi.Connection; - -public class DirectConnectionTest { - @Test - void shouldReturnServerAgent() { - // given - var connection = mock(Connection.class); - var directConnection = new DirectConnection(connection, defaultDatabase(), READ, null); - var agent = "Neo4j/4.2.5"; - given(connection.serverAgent()).willReturn(agent); - - // when - var actualAgent = directConnection.serverAgent(); - - // then - assertEquals(agent, actualAgent); - then(connection).should().serverAgent(); - } - - @ParameterizedTest - @ValueSource(booleans = {true, false}) - void shouldReturnTelemetryEnabledReturnNetworkValue(Boolean telemetryEnabled) { - var connection = mock(Connection.class); - doReturn(telemetryEnabled).when(connection).isTelemetryEnabled(); - - var directConnection = new DirectConnection(connection, defaultDatabase(), READ, null); - - assertEquals(telemetryEnabled, directConnection.isTelemetryEnabled()); - } -} 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 deleted file mode 100644 index 8d093dd279..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/async/connection/HandshakeCompletedListenerTest.java +++ /dev/null @@ -1,160 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.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; - -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.BoltAgentUtil; -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.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"; - - private final EmbeddedChannel channel = new EmbeddedChannel(); - - @AfterEach - void tearDown() { - channel.finishAndReleaseAll(); - } - - @Test - void shouldFailConnectionInitializedPromiseWhenHandshakeFails() { - var channelInitializedPromise = channel.newPromise(); - var listener = new HandshakeCompletedListener( - USER_AGENT, - BoltAgentUtil.VALUE, - RoutingContext.EMPTY, - channelInitializedPromise, - null, - mock(Clock.class)); - - var handshakeCompletedPromise = channel.newPromise(); - var cause = new IOException("Bad handshake"); - handshakeCompletedPromise.setFailure(cause); - - listener.operationComplete(handshakeCompletedPromise); - - var error = assertThrows(Exception.class, () -> await(channelInitializedPromise)); - assertEquals(cause, error); - } - - @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( - new HelloMessage(USER_AGENT, null, authToken().toMap(), Collections.emptyMap(), false, null)); - then(authContext).should().initiateAuth(authToken); - } - - @Test - void shouldFailPromiseWhenTokenStageCompletesExceptionally() { - // given - var channelInitializedPromise = channel.newPromise(); - var listener = new HandshakeCompletedListener( - USER_AGENT, - BoltAgentUtil.VALUE, - 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(Message expectedMessage) { - var messageDispatcher = mock(InboundMessageDispatcher.class); - setProtocolVersion(channel, BoltProtocolV3.VERSION); - setMessageDispatcher(channel, messageDispatcher); - - var channelInitializedPromise = channel.newPromise(); - var listener = new HandshakeCompletedListener( - USER_AGENT, - BoltAgentUtil.VALUE, - RoutingContext.EMPTY, - channelInitializedPromise, - null, - mock(Clock.class)); - - var handshakeCompletedPromise = channel.newPromise(); - handshakeCompletedPromise.setSuccess(); - - listener.operationComplete(handshakeCompletedPromise); - assertTrue(channel.finish()); - - verify(messageDispatcher).enqueue(any((Class) HelloResponseHandler.class)); - var outboundMessage = channel.readOutbound(); - assertEquals(expectedMessage, outboundMessage); - } - - private static InternalAuthToken authToken() { - return (InternalAuthToken) AuthTokens.basic("neo4j", "secret"); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/connection/RoutingConnectionTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/connection/RoutingConnectionTest.java deleted file mode 100644 index a0f87761a7..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/async/connection/RoutingConnectionTest.java +++ /dev/null @@ -1,102 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.connection; - -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.instanceOf; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.mockito.BDDMockito.given; -import static org.mockito.BDDMockito.then; -import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.eq; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.neo4j.driver.AccessMode.READ; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.messaging.request.PullAllMessage.PULL_ALL; - -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.internal.RoutingErrorHandler; -import org.neo4j.driver.internal.handlers.RoutingResponseHandler; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; - -class RoutingConnectionTest { - @Test - void shouldWrapHandlersWhenWritingSingleMessage() { - testHandlersWrappingWithSingleMessage(false); - } - - @Test - void shouldWrapHandlersWhenWritingAndFlushingSingleMessage() { - testHandlersWrappingWithSingleMessage(true); - } - - @Test - void shouldReturnServerAgent() { - // given - var connection = mock(Connection.class); - var errorHandler = mock(RoutingErrorHandler.class); - var routingConnection = new RoutingConnection(connection, defaultDatabase(), READ, null, errorHandler); - var agent = "Neo4j/4.2.5"; - given(connection.serverAgent()).willReturn(agent); - - // when - var actualAgent = routingConnection.serverAgent(); - - // then - assertEquals(agent, actualAgent); - then(connection).should().serverAgent(); - } - - @ParameterizedTest - @ValueSource(booleans = {true, false}) - void shouldReturnTelemetryEnabledReturnNetworkValue(Boolean telemetryEnabled) { - var connection = mock(Connection.class); - var errorHandler = mock(RoutingErrorHandler.class); - doReturn(telemetryEnabled).when(connection).isTelemetryEnabled(); - - var routingConnection = new RoutingConnection(connection, defaultDatabase(), READ, null, errorHandler); - - assertEquals(telemetryEnabled, routingConnection.isTelemetryEnabled()); - } - - private static void testHandlersWrappingWithSingleMessage(boolean flush) { - var connection = mock(Connection.class); - var errorHandler = mock(RoutingErrorHandler.class); - var routingConnection = new RoutingConnection(connection, defaultDatabase(), READ, null, errorHandler); - - if (flush) { - routingConnection.writeAndFlush(PULL_ALL, mock(ResponseHandler.class)); - } else { - routingConnection.write(PULL_ALL, mock(ResponseHandler.class)); - } - - var handlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - - if (flush) { - verify(connection).writeAndFlush(eq(PULL_ALL), handlerCaptor.capture()); - } else { - verify(connection).write(eq(PULL_ALL), handlerCaptor.capture()); - } - - assertThat(handlerCaptor.getValue(), instanceOf(RoutingResponseHandler.class)); - } -} 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 deleted file mode 100644 index 331a674cf7..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/async/pool/AuthContextTest.java +++ /dev/null @@ -1,135 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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 deleted file mode 100644 index cbab4692cf..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImplIT.java +++ /dev/null @@ -1,153 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsString; -import static org.hamcrest.Matchers.instanceOf; -import static org.hamcrest.Matchers.startsWith; -import static org.junit.jupiter.api.Assertions.assertNotNull; -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.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; -import static org.neo4j.driver.testutil.TestUtil.await; - -import java.util.Collections; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.RegisterExtension; -import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.ConnectionSettings; -import org.neo4j.driver.internal.DefaultDomainNameResolver; -import org.neo4j.driver.internal.async.connection.BootstrapFactory; -import org.neo4j.driver.internal.async.connection.ChannelConnector; -import org.neo4j.driver.internal.async.connection.ChannelConnectorImpl; -import org.neo4j.driver.internal.cluster.RoutingContext; -import org.neo4j.driver.internal.metrics.DevNullMetricsListener; -import org.neo4j.driver.internal.security.SecurityPlanImpl; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.util.FakeClock; -import org.neo4j.driver.testutil.DatabaseExtension; -import org.neo4j.driver.testutil.ParallelizableIT; - -@ParallelizableIT -class ConnectionPoolImplIT { - @RegisterExtension - static final DatabaseExtension neo4j = new DatabaseExtension(); - - private ConnectionPoolImpl pool; - - @BeforeEach - void setUp() { - pool = newPool(); - } - - @AfterEach - void tearDown() { - pool.close(); - } - - @Test - void shouldAcquireConnectionWhenPoolIsEmpty() { - var connection = await(pool.acquire(neo4j.address(), null)); - - assertNotNull(connection); - } - - @Test - void shouldAcquireIdleConnection() { - var connection1 = await(pool.acquire(neo4j.address(), null)); - await(connection1.release()); - - var connection2 = await(pool.acquire(neo4j.address(), null)); - assertNotNull(connection2); - } - - @Test - void shouldBeAbleToClosePoolInIOWorkerThread() { - // In the IO worker thread of a channel obtained from a pool, we shall be able to close the pool. - var future = pool.acquire(neo4j.address(), null) - .thenCompose(Connection::release) - // This shall close all pools - .whenComplete((ignored, error) -> pool.retainAll(Collections.emptySet())); - - // We should be able to come to this line. - await(future); - } - - @Test - void shouldFailToAcquireConnectionToWrongAddress() { - var e = assertThrows( - ServiceUnavailableException.class, - () -> await(pool.acquire(new BoltServerAddress("wrong-localhost"), null))); - - assertThat(e.getMessage(), startsWith("Unable to connect")); - } - - @Test - void shouldFailToAcquireWhenPoolClosed() { - var connection = await(pool.acquire(neo4j.address(), null)); - await(connection.release()); - await(pool.close()); - - var e = assertThrows(IllegalStateException.class, () -> pool.acquire(neo4j.address(), null)); - assertThat(e.getMessage(), startsWith("Pool closed")); - } - - @Test - void shouldNotCloseWhenClosed() { - assertNull(await(pool.close())); - assertTrue(pool.close().toCompletableFuture().isDone()); - } - - @Test - void shouldFailToAcquireConnectionWhenPoolIsClosed() { - await(pool.acquire(neo4j.address(), null)); - var channelPool = this.pool.getPool(neo4j.address()); - await(channelPool.close()); - var error = 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() { - var clock = new FakeClock(); - var connectionSettings = new ConnectionSettings(neo4j.authTokenManager(), "test", 5000); - ChannelConnector connector = new ChannelConnectorImpl( - connectionSettings, - SecurityPlanImpl.insecure(), - DEV_NULL_LOGGING, - clock, - RoutingContext.EMPTY, - DefaultDomainNameResolver.getInstance(), - null, - BoltAgentUtil.VALUE); - var poolSettings = newSettings(); - var bootstrap = BootstrapFactory.newBootstrap(1); - return new ConnectionPoolImpl( - connector, bootstrap, poolSettings, DevNullMetricsListener.INSTANCE, DEV_NULL_LOGGING, clock, true); - } - - private static PoolSettings newSettings() { - return new PoolSettings(10, 5000, -1, -1); - } -} 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 deleted file mode 100644 index a128b2e289..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImplTest.java +++ /dev/null @@ -1,140 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.Arrays.asList; -import static java.util.Collections.singleton; -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.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoInteractions; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.internal.BoltServerAddress.LOCAL_DEFAULT; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.authorizationStateListener; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; - -import io.netty.bootstrap.Bootstrap; -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; -import org.neo4j.driver.internal.metrics.DevNullMetricsListener; -import org.neo4j.driver.internal.util.FakeClock; - -class ConnectionPoolImplTest { - private static final BoltServerAddress ADDRESS_1 = new BoltServerAddress("server:1"); - private static final BoltServerAddress ADDRESS_2 = new BoltServerAddress("server:2"); - private static final BoltServerAddress ADDRESS_3 = new BoltServerAddress("server:3"); - - @Test - void shouldDoNothingWhenRetainOnEmptyPool() { - var nettyChannelTracker = mock(NettyChannelTracker.class); - var pool = newConnectionPool(nettyChannelTracker); - - pool.retainAll(singleton(LOCAL_DEFAULT)); - - verifyNoInteractions(nettyChannelTracker); - } - - @Test - void shouldRetainSpecifiedAddresses() { - var nettyChannelTracker = mock(NettyChannelTracker.class); - var pool = newConnectionPool(nettyChannelTracker); - - 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 (var channelPool : pool.channelPoolsByAddress.values()) { - assertFalse(channelPool.isClosed()); - } - } - - @Test - void shouldClosePoolsWhenRetaining() { - var nettyChannelTracker = mock(NettyChannelTracker.class); - var pool = newConnectionPool(nettyChannelTracker); - - 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); - when(nettyChannelTracker.inUseChannelCount(ADDRESS_3)).thenReturn(3); - - pool.retainAll(new HashSet<>(asList(ADDRESS_1, ADDRESS_3))); - assertFalse(pool.getPool(ADDRESS_1).isClosed()); - assertTrue(pool.getPool(ADDRESS_2).isClosed()); - assertFalse(pool.getPool(ADDRESS_3).isClosed()); - } - - @Test - void shouldNotClosePoolsWithActiveConnectionsWhenRetaining() { - var nettyChannelTracker = mock(NettyChannelTracker.class); - var pool = newConnectionPool(nettyChannelTracker); - - 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); - when(nettyChannelTracker.inUseChannelCount(ADDRESS_3)).thenReturn(0); - - pool.retainAll(singleton(ADDRESS_2)); - assertFalse(pool.getPool(ADDRESS_1).isClosed()); - assertFalse(pool.getPool(ADDRESS_2).isClosed()); - assertTrue(pool.getPool(ADDRESS_3).isClosed()); - } - - @Disabled("to fix") - @Test - void shouldRegisterAuthorizationStateListenerWithChannel() throws ExecutionException, InterruptedException { - var nettyChannelTracker = mock(NettyChannelTracker.class); - var nettyChannelHealthChecker = mock(NettyChannelHealthChecker.class); - var channelArgumentCaptor = ArgumentCaptor.forClass(Channel.class); - var pool = newConnectionPool(nettyChannelTracker); - - pool.acquire(ADDRESS_1, null).toCompletableFuture().get(); - verify(nettyChannelTracker).channelAcquired(channelArgumentCaptor.capture()); - var channel = channelArgumentCaptor.getValue(); - - assertEquals(nettyChannelHealthChecker, authorizationStateListener(channel)); - } - - private static PoolSettings newSettings() { - return new PoolSettings(10, 5000, -1, -1); - } - - private static TestConnectionPool newConnectionPool(NettyChannelTracker nettyChannelTracker) { - return new TestConnectionPool( - mock(Bootstrap.class), - nettyChannelTracker, - newSettings(), - DevNullMetricsListener.INSTANCE, - DEV_NULL_LOGGING, - new FakeClock(), - true); - } -} 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 deleted file mode 100644 index b99d7ff599..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/async/pool/NettyChannelHealthCheckerTest.java +++ /dev/null @@ -1,384 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.concurrent.CompletableFuture.completedFuture; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertInstanceOf; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -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.setConnectionReadTimeout; -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; -import static org.neo4j.driver.internal.async.pool.PoolSettings.NOT_CONFIGURED; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; -import static org.neo4j.driver.internal.util.Iterables.single; -import static org.neo4j.driver.testutil.TestUtil.await; - -import io.netty.channel.embedded.EmbeddedChannel; -import java.time.Clock; -import java.util.Collections; -import java.util.List; -import java.util.Objects; -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.internal.async.inbound.ConnectionReadTimeoutHandler; -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(); - private final InboundMessageDispatcher dispatcher = new InboundMessageDispatcher(channel, DEV_NULL_LOGGING); - - @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 - void tearDown() { - channel.finishAndReleaseAll(); - } - - @Test - void shouldDropTooOldChannelsWhenMaxLifetimeEnabled() { - var maxLifetime = 1000; - var settings = new PoolSettings( - DEFAULT_MAX_CONNECTION_POOL_SIZE, - DEFAULT_CONNECTION_ACQUISITION_TIMEOUT, - maxLifetime, - DEFAULT_IDLE_TIME_BEFORE_CONNECTION_TEST); - var clock = Clock.systemUTC(); - var healthChecker = newHealthChecker(settings, clock); - - setCreationTimestamp(channel, clock.millis() - maxLifetime * 2); - var healthy = healthChecker.isHealthy(channel); - - assertThat(await(healthy), is(false)); - } - - @Test - void shouldAllowVeryOldChannelsWhenMaxLifetimeDisabled() { - var settings = new PoolSettings( - DEFAULT_MAX_CONNECTION_POOL_SIZE, - DEFAULT_CONNECTION_ACQUISITION_TIMEOUT, - NOT_CONFIGURED, - DEFAULT_IDLE_TIME_BEFORE_CONNECTION_TEST); - var healthChecker = newHealthChecker(settings, Clock.systemUTC()); - - setCreationTimestamp(channel, 0); - var healthy = healthChecker.isHealthy(channel); - channel.runPendingTasks(); - - assertThat(await(healthy), is(true)); - } - - 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) { - var settings = new PoolSettings( - DEFAULT_MAX_CONNECTION_POOL_SIZE, - DEFAULT_CONNECTION_ACQUISITION_TIMEOUT, - NOT_CONFIGURED, - DEFAULT_IDLE_TIME_BEFORE_CONNECTION_TEST); - var clock = mock(Clock.class); - var healthChecker = newHealthChecker(settings, clock); - - var authToken = AuthTokens.basic("username", "password"); - var authTokenManager = mock(AuthTokenManager.class); - given(authTokenManager.getToken()).willReturn(completedFuture(authToken)); - var channels = IntStream.range(0, 100) - .mapToObj(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; - }) - .toList(); - - var authorizationExpiredChannelIndex = channels.size() / 2 - 1; - given(clock.millis()).willReturn((long) authorizationExpiredChannelIndex); - healthChecker.onExpired(); - - for (var i = 0; i < channels.size(); i++) { - var channel = channels.get(i); - var future = healthChecker.isHealthy(channel); - channel.runPendingTasks(); - boolean health = Objects.requireNonNull(await(future)); - var expectedHealth = i > authorizationExpiredChannelIndex; - assertEquals(expectedHealth, health, String.format("Channel %d has failed the check", i)); - } - } - - @Test - void shouldMarkForLogoffAllConnectionsCreatedOnOrBeforeExpirationTimestamp() { - var settings = new PoolSettings( - DEFAULT_MAX_CONNECTION_POOL_SIZE, - DEFAULT_CONNECTION_ACQUISITION_TIMEOUT, - NOT_CONFIGURED, - DEFAULT_IDLE_TIME_BEFORE_CONNECTION_TEST); - var clock = mock(Clock.class); - var healthChecker = newHealthChecker(settings, clock); - - var authToken = AuthTokens.basic("username", "password"); - var authTokenManager = mock(AuthTokenManager.class); - given(authTokenManager.getToken()).willReturn(completedFuture(authToken)); - var 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(); - - var authorizationExpiredChannelIndex = channels.size() / 2 - 1; - given(clock.millis()).willReturn((long) authorizationExpiredChannelIndex); - healthChecker.onExpired(); - - for (var 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)); - var pendingLogoff = i <= authorizationExpiredChannelIndex; - then(authContext(channel)) - .should(pendingLogoff ? times(1) : never()) - .markPendingLogoff(); - } - } - - @Test - void shouldUseGreatestExpirationTimestamp() { - var settings = new PoolSettings( - DEFAULT_MAX_CONNECTION_POOL_SIZE, - DEFAULT_CONNECTION_ACQUISITION_TIMEOUT, - NOT_CONFIGURED, - DEFAULT_IDLE_TIME_BEFORE_CONNECTION_TEST); - var clock = mock(Clock.class); - given(clock.millis()).willReturn(0L).willReturn(100L); - var healthChecker = newHealthChecker(settings, clock); - - var channel1 = new EmbeddedChannel(); - var channel2 = new EmbeddedChannel(); - setAuthContext(channel1, new AuthContext(new StaticAuthTokenManager(AuthTokens.none()))); - setAuthContext(channel2, new AuthContext(new StaticAuthTokenManager(AuthTokens.none()))); - - healthChecker.onExpired(); - healthChecker.onExpired(); - - var healthy = healthChecker.isHealthy(channel1); - channel1.runPendingTasks(); - assertFalse(Objects.requireNonNull(await(healthy))); - healthy = healthChecker.isHealthy(channel2); - channel2.runPendingTasks(); - assertFalse(Objects.requireNonNull(await(healthy))); - then(clock).should(times(2)).millis(); - } - - @Test - void shouldKeepIdleConnectionWhenPingSucceeds() { - testPing(true); - } - - @Test - void shouldHandlePingWithConnectionReceiveTimeout() { - var idleTimeBeforeConnectionTest = 1000; - var connectionReadTimeout = 60L; - var settings = new PoolSettings( - DEFAULT_MAX_CONNECTION_POOL_SIZE, - DEFAULT_CONNECTION_ACQUISITION_TIMEOUT, - NOT_CONFIGURED, - idleTimeBeforeConnectionTest); - var clock = Clock.systemUTC(); - var healthChecker = newHealthChecker(settings, clock); - - setCreationTimestamp(channel, clock.millis()); - setConnectionReadTimeout(channel, connectionReadTimeout); - setLastUsedTimestamp(channel, clock.millis() - idleTimeBeforeConnectionTest * 2); - - var healthy = healthChecker.isHealthy(channel); - channel.runPendingTasks(); - - var firstElementOnPipeline = channel.pipeline().first(); - assertInstanceOf(ConnectionReadTimeoutHandler.class, firstElementOnPipeline); - assertNotNull(dispatcher.getBeforeLastHandlerHook()); - var readTimeoutHandler = (ConnectionReadTimeoutHandler) firstElementOnPipeline; - assertEquals(connectionReadTimeout * 1000L, readTimeoutHandler.getReaderIdleTimeInMillis()); - assertEquals(ResetMessage.RESET, single(channel.outboundMessages())); - assertFalse(healthy.isDone()); - - dispatcher.handleSuccessMessage(Collections.emptyMap()); - assertThat(await(healthy), is(true)); - assertNull(channel.pipeline().first()); - assertNull(dispatcher.getBeforeLastHandlerHook()); - } - - @Test - void shouldHandlePingWithoutConnectionReceiveTimeout() { - var idleTimeBeforeConnectionTest = 1000; - var settings = new PoolSettings( - DEFAULT_MAX_CONNECTION_POOL_SIZE, - DEFAULT_CONNECTION_ACQUISITION_TIMEOUT, - NOT_CONFIGURED, - idleTimeBeforeConnectionTest); - var clock = Clock.systemUTC(); - var healthChecker = newHealthChecker(settings, clock); - - setCreationTimestamp(channel, clock.millis()); - setLastUsedTimestamp(channel, clock.millis() - idleTimeBeforeConnectionTest * 2); - - var healthy = healthChecker.isHealthy(channel); - channel.runPendingTasks(); - - assertNull(channel.pipeline().first()); - assertEquals(ResetMessage.RESET, single(channel.outboundMessages())); - assertFalse(healthy.isDone()); - - dispatcher.handleSuccessMessage(Collections.emptyMap()); - assertThat(await(healthy), is(true)); - assertNull(channel.pipeline().first()); - } - - @Test - void shouldDropIdleConnectionWhenPingFails() { - testPing(false); - } - - @Test - void shouldKeepActiveConnections() { - testActiveConnectionCheck(true); - } - - @Test - void shouldDropInactiveConnections() { - testActiveConnectionCheck(false); - } - - private void testPing(boolean resetMessageSuccessful) { - var idleTimeBeforeConnectionTest = 1000; - var settings = new PoolSettings( - DEFAULT_MAX_CONNECTION_POOL_SIZE, - DEFAULT_CONNECTION_ACQUISITION_TIMEOUT, - NOT_CONFIGURED, - idleTimeBeforeConnectionTest); - var clock = Clock.systemUTC(); - var healthChecker = newHealthChecker(settings, clock); - - setCreationTimestamp(channel, clock.millis()); - setLastUsedTimestamp(channel, clock.millis() - idleTimeBeforeConnectionTest * 2); - - var healthy = healthChecker.isHealthy(channel); - channel.runPendingTasks(); - - assertEquals(ResetMessage.RESET, single(channel.outboundMessages())); - assertFalse(healthy.isDone()); - - if (resetMessageSuccessful) { - dispatcher.handleSuccessMessage(Collections.emptyMap()); - assertThat(await(healthy), is(true)); - } else { - dispatcher.handleFailureMessage("Neo.ClientError.General.Unknown", "Error!"); - assertThat(await(healthy), is(false)); - } - } - - private void testActiveConnectionCheck(boolean channelActive) { - var settings = new PoolSettings( - DEFAULT_MAX_CONNECTION_POOL_SIZE, - DEFAULT_CONNECTION_ACQUISITION_TIMEOUT, - NOT_CONFIGURED, - DEFAULT_IDLE_TIME_BEFORE_CONNECTION_TEST); - var clock = Clock.systemUTC(); - var healthChecker = newHealthChecker(settings, clock); - - setCreationTimestamp(channel, clock.millis()); - - if (channelActive) { - var healthy = healthChecker.isHealthy(channel); - channel.runPendingTasks(); - assertThat(await(healthy), is(true)); - } else { - channel.close().syncUninterruptibly(); - var healthy = healthChecker.isHealthy(channel); - channel.runPendingTasks(); - assertThat(await(healthy), is(false)); - } - } - - private NettyChannelHealthChecker newHealthChecker(PoolSettings settings, Clock clock) { - return new NettyChannelHealthChecker(settings, clock, DEV_NULL_LOGGING); - } -} 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 deleted file mode 100644 index e09e33f77c..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/async/pool/NettyChannelPoolIT.java +++ /dev/null @@ -1,222 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.eq; -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; - -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; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.RegisterExtension; -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; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.ConnectionSettings; -import org.neo4j.driver.internal.DefaultDomainNameResolver; -import org.neo4j.driver.internal.async.connection.BootstrapFactory; -import org.neo4j.driver.internal.async.connection.ChannelConnectorImpl; -import org.neo4j.driver.internal.cluster.RoutingContext; -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; - -@ParallelizableIT -class NettyChannelPoolIT { - @RegisterExtension - static final DatabaseExtension neo4j = new DatabaseExtension(); - - private Bootstrap bootstrap; - 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); - poolHandler = mock(NettyChannelTracker.class); - } - - @AfterEach - void tearDown() { - if (pool != null) { - pool.close(); - } - if (bootstrap != null) { - bootstrap.config().group().shutdownGracefully().syncUninterruptibly(); - } - } - - @Test - void shouldAcquireAndReleaseWithCorrectCredentials() { - pool = newPool(neo4j.authTokenManager()); - - var channel = await(pool.acquire(null)); - assertNotNull(channel); - verify(poolHandler).channelCreated(eq(channel), any()); - verify(poolHandler, never()).channelReleased(channel); - - await(pool.release(channel)); - verify(poolHandler).channelReleased(channel); - } - - @DisabledOnNeo4jWith(Neo4jFeature.BOLT_V51) - @Test - void shouldFailToAcquireWithWrongCredentialsBolt50AndBelow() { - pool = newPool(new StaticAuthTokenManager(AuthTokens.basic("wrong", "wrong"))); - - 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() { - var maxConnections = 2; - - Map authTokenMap = new HashMap<>(); - authTokenMap.put("scheme", value("basic")); - authTokenMap.put("principal", value("neo4j")); - authTokenMap.put("credentials", value("wrong")); - var authToken = new InternalAuthToken(authTokenMap); - - pool = newPool(new StaticAuthTokenManager(authToken), maxConnections); - - for (var i = 0; i < maxConnections; i++) { - assertThrows(AuthenticationException.class, () -> acquire(pool)); - } - - authTokenMap.put("credentials", value(neo4j.adminPassword())); - - assertNotNull(acquire(pool)); - } - - @Test - void shouldLimitNumberOfConcurrentConnections() { - var maxConnections = 5; - pool = newPool(neo4j.authTokenManager(), maxConnections); - - for (var i = 0; i < maxConnections; i++) { - assertNotNull(acquire(pool)); - } - - var e = assertThrows(TimeoutException.class, () -> acquire(pool)); - assertEquals(e.getMessage(), "Acquire operation took longer then configured maximum time"); - } - - @Test - void shouldTrackActiveChannels() { - var tracker = new NettyChannelTracker( - DevNullMetricsListener.INSTANCE, new ImmediateSchedulingEventExecutor(), DEV_NULL_LOGGING); - - poolHandler = tracker; - pool = newPool(neo4j.authTokenManager()); - - var channel1 = acquire(pool); - var channel2 = acquire(pool); - var channel3 = acquire(pool); - assertEquals(3, tracker.inUseChannelCount(neo4j.address())); - - release(channel1); - release(channel2); - release(channel3); - assertEquals(0, tracker.inUseChannelCount(neo4j.address())); - - assertNotNull(acquire(pool)); - assertNotNull(acquire(pool)); - assertEquals(2, tracker.inUseChannelCount(neo4j.address())); - } - - private NettyChannelPool newPool(AuthTokenManager authTokenManager) { - return newPool(authTokenManager, 100); - } - - private NettyChannelPool newPool(AuthTokenManager authTokenManager, int maxConnections) { - var settings = new ConnectionSettings(authTokenManager, "test", 5_000); - var connector = new ChannelConnectorImpl( - settings, - SecurityPlanImpl.insecure(), - DEV_NULL_LOGGING, - new FakeClock(), - RoutingContext.EMPTY, - DefaultDomainNameResolver.getInstance(), - null, - BoltAgentUtil.VALUE); - var nettyChannelHealthChecker = mock(NettyChannelHealthChecker.class); - when(nettyChannelHealthChecker.isHealthy(any())).thenAnswer(NettyChannelPoolIT::answer); - return new NettyChannelPool( - neo4j.address(), - connector, - bootstrap, - poolHandler, - nettyChannelHealthChecker, - 1_000, - maxConnections, - Clock.systemUTC()); - } - - private static Channel acquire(NettyChannelPool pool) { - return await(pool.acquire(null)); - } - - private void release(Channel channel) { - await(pool.release(channel)); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/pool/NettyChannelTrackerTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/pool/NettyChannelTrackerTest.java deleted file mode 100644 index 458f4bda4e..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/async/pool/NettyChannelTrackerTest.java +++ /dev/null @@ -1,229 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.equalTo; -import static org.hamcrest.Matchers.hasItem; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -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.connection.ChannelAttributes.setServerAddress; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; - -import io.netty.channel.Channel; -import io.netty.channel.embedded.EmbeddedChannel; -import io.netty.channel.group.ChannelGroup; -import org.bouncycastle.util.Arrays; -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.messaging.request.GoodbyeMessage; -import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3; -import org.neo4j.driver.internal.metrics.DevNullMetricsListener; - -class NettyChannelTrackerTest { - private final BoltServerAddress address = BoltServerAddress.LOCAL_DEFAULT; - private final NettyChannelTracker tracker = - new NettyChannelTracker(DevNullMetricsListener.INSTANCE, mock(ChannelGroup.class), DEV_NULL_LOGGING); - - @Test - void shouldIncrementIdleCountWhenChannelCreated() { - var channel = newChannel(); - assertEquals(0, tracker.inUseChannelCount(address)); - assertEquals(0, tracker.idleChannelCount(address)); - - tracker.channelCreated(channel, null); - assertEquals(0, tracker.inUseChannelCount(address)); - assertEquals(1, tracker.idleChannelCount(address)); - } - - @Test - void shouldIncrementInUseCountWhenChannelAcquired() { - var channel = newChannel(); - assertEquals(0, tracker.inUseChannelCount(address)); - assertEquals(0, tracker.idleChannelCount(address)); - - tracker.channelCreated(channel, null); - assertEquals(0, tracker.inUseChannelCount(address)); - assertEquals(1, tracker.idleChannelCount(address)); - - tracker.channelAcquired(channel); - assertEquals(1, tracker.inUseChannelCount(address)); - assertEquals(0, tracker.idleChannelCount(address)); - } - - @Test - void shouldIncrementIdleCountWhenChannelReleased() { - var channel = newChannel(); - assertEquals(0, tracker.inUseChannelCount(address)); - assertEquals(0, tracker.idleChannelCount(address)); - - channelCreatedAndAcquired(channel); - assertEquals(1, tracker.inUseChannelCount(address)); - assertEquals(0, tracker.idleChannelCount(address)); - - tracker.channelReleased(channel); - assertEquals(0, tracker.inUseChannelCount(address)); - assertEquals(1, tracker.idleChannelCount(address)); - } - - @Test - void shouldIncrementIdleCountForAddress() { - var channel1 = newChannel(); - var channel2 = newChannel(); - var channel3 = newChannel(); - - assertEquals(0, tracker.idleChannelCount(address)); - tracker.channelCreated(channel1, null); - assertEquals(1, tracker.idleChannelCount(address)); - tracker.channelCreated(channel2, null); - assertEquals(2, tracker.idleChannelCount(address)); - tracker.channelCreated(channel3, null); - assertEquals(3, tracker.idleChannelCount(address)); - assertEquals(0, tracker.inUseChannelCount(address)); - } - - @Test - void shouldDecrementCountForAddress() { - var channel1 = newChannel(); - var channel2 = newChannel(); - var channel3 = newChannel(); - - channelCreatedAndAcquired(channel1); - channelCreatedAndAcquired(channel2); - channelCreatedAndAcquired(channel3); - assertEquals(3, tracker.inUseChannelCount(address)); - assertEquals(0, tracker.idleChannelCount(address)); - - tracker.channelReleased(channel1); - assertEquals(2, tracker.inUseChannelCount(address)); - assertEquals(1, tracker.idleChannelCount(address)); - tracker.channelReleased(channel2); - assertEquals(1, tracker.inUseChannelCount(address)); - assertEquals(2, tracker.idleChannelCount(address)); - tracker.channelReleased(channel3); - assertEquals(0, tracker.inUseChannelCount(address)); - assertEquals(3, tracker.idleChannelCount(address)); - } - - @Test - void shouldDecreaseIdleWhenClosedOutsidePool() throws Throwable { - // Given - var channel = newChannel(); - channelCreatedAndAcquired(channel); - assertEquals(1, tracker.inUseChannelCount(address)); - assertEquals(0, tracker.idleChannelCount(address)); - - // When closed before session.close - channel.close().sync(); - - // Then - assertEquals(1, tracker.inUseChannelCount(address)); - assertEquals(0, tracker.idleChannelCount(address)); - - tracker.channelReleased(channel); - assertEquals(0, tracker.inUseChannelCount(address)); - assertEquals(0, tracker.idleChannelCount(address)); - } - - @Test - void shouldDecreaseIdleWhenClosedInsidePool() throws Throwable { - // Given - var channel = newChannel(); - channelCreatedAndAcquired(channel); - assertEquals(1, tracker.inUseChannelCount(address)); - assertEquals(0, tracker.idleChannelCount(address)); - - tracker.channelReleased(channel); - assertEquals(0, tracker.inUseChannelCount(address)); - assertEquals(1, tracker.idleChannelCount(address)); - - // When closed before acquire - channel.close().sync(); - // Then - assertEquals(0, tracker.inUseChannelCount(address)); - assertEquals(0, tracker.idleChannelCount(address)); - } - - @Test - void shouldThrowWhenDecrementingForUnknownAddress() { - var channel = newChannel(); - - assertThrows(IllegalStateException.class, () -> tracker.channelReleased(channel)); - } - - @Test - void shouldReturnZeroActiveCountForUnknownAddress() { - assertEquals(0, tracker.inUseChannelCount(address)); - } - - @Test - void shouldAddChannelToGroupWhenChannelCreated() { - var channel = newChannel(); - var anotherChannel = newChannel(); - var group = mock(ChannelGroup.class); - var tracker = new NettyChannelTracker(DevNullMetricsListener.INSTANCE, group, DEV_NULL_LOGGING); - - tracker.channelCreated(channel, null); - tracker.channelCreated(anotherChannel, null); - - verify(group).add(channel); - verify(group).add(anotherChannel); - } - - @Test - void shouldDelegateToProtocolPrepareToClose() { - var channel = newChannelWithProtocolV3(); - var anotherChannel = newChannelWithProtocolV3(); - var group = mock(ChannelGroup.class); - when(group.iterator()).thenReturn(new Arrays.Iterator<>(new Channel[] {channel, anotherChannel})); - - var tracker = new NettyChannelTracker(DevNullMetricsListener.INSTANCE, group, DEV_NULL_LOGGING); - - tracker.prepareToCloseChannels(); - - assertThat(channel.outboundMessages().size(), equalTo(1)); - assertThat(channel.outboundMessages(), hasItem(GoodbyeMessage.GOODBYE)); - - assertThat(anotherChannel.outboundMessages().size(), equalTo(1)); - assertThat(anotherChannel.outboundMessages(), hasItem(GoodbyeMessage.GOODBYE)); - } - - private Channel newChannel() { - var channel = new EmbeddedChannel(); - setServerAddress(channel, address); - return channel; - } - - private EmbeddedChannel newChannelWithProtocolV3() { - var channel = new EmbeddedChannel(); - setServerAddress(channel, address); - setProtocolVersion(channel, BoltProtocolV3.VERSION); - setMessageDispatcher(channel, mock(InboundMessageDispatcher.class)); - return channel; - } - - private void channelCreatedAndAcquired(Channel channel) { - tracker.channelCreated(channel, null); - tracker.channelAcquired(channel); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/pool/PoolSettingsTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/pool/PoolSettingsTest.java deleted file mode 100644 index 546fc9989c..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/async/pool/PoolSettingsTest.java +++ /dev/null @@ -1,73 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.assertTrue; - -import org.junit.jupiter.api.Test; - -class PoolSettingsTest { - @Test - void idleTimeBeforeConnectionTestWhenConfigured() { - var settings = new PoolSettings(5, -1, 10, 42); - assertTrue(settings.idleTimeBeforeConnectionTestEnabled()); - assertEquals(42, settings.idleTimeBeforeConnectionTest()); - } - - @Test - void idleTimeBeforeConnectionTestWhenSetToZero() { - // Always test idle time during acquisition - var settings = new PoolSettings(5, -1, 10, 0); - assertTrue(settings.idleTimeBeforeConnectionTestEnabled()); - assertEquals(0, settings.idleTimeBeforeConnectionTest()); - } - - @Test - void idleTimeBeforeConnectionTestWhenSetToNegativeValue() { - // Never test idle time during acquisition - testIdleTimeBeforeConnectionTestWithIllegalValue(-1); - testIdleTimeBeforeConnectionTestWithIllegalValue(-42); - testIdleTimeBeforeConnectionTestWithIllegalValue(Integer.MIN_VALUE); - } - - @Test - void maxConnectionLifetimeWhenConfigured() { - var settings = new PoolSettings(5, -1, 42, 10); - assertTrue(settings.maxConnectionLifetimeEnabled()); - assertEquals(42, settings.maxConnectionLifetime()); - } - - @Test - void maxConnectionLifetimeWhenSetToZeroOrNegativeValue() { - testMaxConnectionLifetimeWithIllegalValue(0); - testMaxConnectionLifetimeWithIllegalValue(-1); - testMaxConnectionLifetimeWithIllegalValue(-42); - testMaxConnectionLifetimeWithIllegalValue(Integer.MIN_VALUE); - } - - private static void testIdleTimeBeforeConnectionTestWithIllegalValue(int value) { - var settings = new PoolSettings(5, -1, 10, value); - assertFalse(settings.idleTimeBeforeConnectionTestEnabled()); - } - - private static void testMaxConnectionLifetimeWithIllegalValue(int value) { - var settings = new PoolSettings(5, -1, value, 10); - assertFalse(settings.maxConnectionLifetimeEnabled()); - } -} 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 deleted file mode 100644 index 1ebf59a448..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/async/pool/TestConnectionPool.java +++ /dev/null @@ -1,127 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.concurrent.CompletableFuture.completedFuture; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setPoolId; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setServerAddress; -import static org.neo4j.driver.internal.util.Futures.completedWithNull; - -import io.netty.bootstrap.Bootstrap; -import io.netty.channel.Channel; -import io.netty.channel.embedded.EmbeddedChannel; -import java.time.Clock; -import java.util.HashMap; -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; -import org.neo4j.driver.internal.metrics.MetricsListener; -import org.neo4j.driver.internal.spi.Connection; - -public class TestConnectionPool extends ConnectionPoolImpl { - final Map channelPoolsByAddress = new HashMap<>(); - private final NettyChannelTracker nettyChannelTracker; - - public TestConnectionPool( - Bootstrap bootstrap, - NettyChannelTracker nettyChannelTracker, - PoolSettings settings, - MetricsListener metricsListener, - Logging logging, - Clock clock, - boolean ownsEventLoopGroup) { - super( - mock(ChannelConnector.class), - bootstrap, - nettyChannelTracker, - settings, - metricsListener, - logging, - clock, - ownsEventLoopGroup, - newConnectionFactory()); - this.nettyChannelTracker = nettyChannelTracker; - } - - ExtendedChannelPool getPool(BoltServerAddress address) { - return channelPoolsByAddress.get(address); - } - - @Override - ExtendedChannelPool newPool(BoltServerAddress address) { - var channelPool = new ExtendedChannelPool() { - private final AtomicBoolean isClosed = new AtomicBoolean(false); - - @Override - public CompletionStage acquire(AuthToken overrideAuthToken) { - var channel = new EmbeddedChannel(); - setServerAddress(channel, address); - setPoolId(channel, id()); - - var event = nettyChannelTracker.channelCreating(id()); - nettyChannelTracker.channelCreated(channel, event); - nettyChannelTracker.channelAcquired(channel); - - return completedFuture(channel); - } - - @Override - public CompletionStage release(Channel channel) { - nettyChannelTracker.channelReleased(channel); - nettyChannelTracker.channelClosed(channel); - return completedWithNull(); - } - - @Override - public boolean isClosed() { - return isClosed.get(); - } - - @Override - public String id() { - return "Pool-" + this.hashCode(); - } - - @Override - public CompletionStage close() { - isClosed.set(true); - return completedWithNull(); - } - - @Override - public NettyChannelHealthChecker healthChecker() { - return mock(NettyChannelHealthChecker.class); - } - }; - channelPoolsByAddress.put(address, channelPool); - return channelPool; - } - - private static ConnectionFactory newConnectionFactory() { - return (channel, pool) -> { - var conn = mock(Connection.class); - when(conn.release()).thenAnswer(invocation -> pool.release(channel)); - return conn; - }; - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/NoopLoggingProvider.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/NoopLoggingProvider.java new file mode 100644 index 0000000000..d069bc6353 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/NoopLoggingProvider.java @@ -0,0 +1,37 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt; + +import static org.mockito.Mockito.mock; + +import org.neo4j.driver.internal.bolt.api.LoggingProvider; + +public class NoopLoggingProvider implements LoggingProvider { + public static final NoopLoggingProvider INSTANCE = new NoopLoggingProvider(); + + private NoopLoggingProvider() {} + + @Override + public System.Logger getLog(Class cls) { + return mock(System.Logger.class); + } + + @Override + public System.Logger getLog(String name) { + return mock(System.Logger.class); + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/BoltAgentUtil.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/api/BoltAgentUtil.java similarity index 94% rename from driver/src/test/java/org/neo4j/driver/internal/BoltAgentUtil.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/api/BoltAgentUtil.java index 208853edd4..837fdf6599 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/BoltAgentUtil.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/api/BoltAgentUtil.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal; +package org.neo4j.driver.internal.bolt.api; public interface BoltAgentUtil { BoltAgent VALUE = new BoltAgent("agent", null, null, null); diff --git a/driver/src/test/java/org/neo4j/driver/internal/net/BoltServerAddressParsingTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/api/BoltServerAddressParsingTest.java similarity index 97% rename from driver/src/test/java/org/neo4j/driver/internal/net/BoltServerAddressParsingTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/api/BoltServerAddressParsingTest.java index 8da272fd70..9e3f55be59 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/net/BoltServerAddressParsingTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/api/BoltServerAddressParsingTest.java @@ -14,16 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.net; +package org.neo4j.driver.internal.bolt.api; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.neo4j.driver.internal.BoltServerAddress.DEFAULT_PORT; +import static org.neo4j.driver.internal.bolt.api.BoltServerAddress.DEFAULT_PORT; import java.util.stream.Stream; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; -import org.neo4j.driver.internal.BoltServerAddress; class BoltServerAddressParsingTest { private static Stream addressesToParse() { diff --git a/driver/src/test/java/org/neo4j/driver/internal/net/BoltServerAddressTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/api/BoltServerAddressTest.java similarity index 60% rename from driver/src/test/java/org/neo4j/driver/internal/net/BoltServerAddressTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/api/BoltServerAddressTest.java index b840b26910..56e3e48352 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/net/BoltServerAddressTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/api/BoltServerAddressTest.java @@ -14,21 +14,16 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.net; +package org.neo4j.driver.internal.bolt.api; import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.MatcherAssert.assertThat; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.internal.BoltServerAddress.DEFAULT_PORT; +import static org.neo4j.driver.internal.bolt.api.BoltServerAddress.DEFAULT_PORT; import java.net.URI; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.net.ServerAddress; class BoltServerAddressTest { @Test @@ -60,38 +55,6 @@ void shouldVerifyPort() { assertThrows(IllegalArgumentException.class, () -> new BoltServerAddress("localhost", 99_999)); } - @Test - void shouldCreateBoltServerAddressFromServerAddress() { - var address1 = new BoltServerAddress("my.server.com", 8899); - assertSame(address1, BoltServerAddress.from(address1)); - - var address2 = new BoltServerAddress("db.neo4j.com"); - assertSame(address2, BoltServerAddress.from(address2)); - - var address3 = mock(ServerAddress.class); - when(address3.host()).thenReturn("graph.database.com"); - when(address3.port()).thenReturn(20600); - assertEquals(new BoltServerAddress("graph.database.com", 20600), BoltServerAddress.from(address3)); - } - - @Test - void shouldFailToCreateBoltServerAddressFromInvalidServerAddress() { - var address1 = mock(ServerAddress.class); - when(address1.host()).thenReturn(null); - when(address1.port()).thenReturn(8888); - assertThrows(NullPointerException.class, () -> BoltServerAddress.from(address1)); - - var address2 = mock(ServerAddress.class); - when(address2.host()).thenReturn("neo4j.host.com"); - when(address2.port()).thenReturn(-1); - assertThrows(IllegalArgumentException.class, () -> BoltServerAddress.from(address2)); - - var address3 = mock(ServerAddress.class); - when(address3.host()).thenReturn("my.database.org"); - when(address3.port()).thenReturn(99_000); - assertThrows(IllegalArgumentException.class, () -> BoltServerAddress.from(address3)); - } - @Test void shouldUseUriWithHostButWithoutPort() { var uri = URI.create("bolt://neo4j.com"); diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/ClusterCompositionTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/api/ClusterCompositionTest.java similarity index 57% rename from driver/src/test/java/org/neo4j/driver/internal/cluster/ClusterCompositionTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/api/ClusterCompositionTest.java index b4721a1230..43faa6b83a 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/ClusterCompositionTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/api/ClusterCompositionTest.java @@ -14,21 +14,18 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal.bolt.api; import static java.util.Arrays.asList; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; 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.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.A; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.B; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.C; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.D; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.E; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.F; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.A; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.B; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.C; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.D; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.E; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.F; import java.util.Arrays; import java.util.HashMap; @@ -37,10 +34,6 @@ import java.util.Set; import java.util.stream.Collectors; import org.junit.jupiter.api.Test; -import org.neo4j.driver.Record; -import org.neo4j.driver.Value; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.InternalRecord; class ClusterCompositionTest { @Test @@ -127,68 +120,68 @@ void expirationTimestamp() { assertEquals(42, composition.expirationTimestamp()); } - @Test - void parseCorrectRecord() { - var values = new Value[] { - value(42L), - value(asList(serversEntry("READ", A, B), serversEntry("WRITE", C, D), serversEntry("ROUTE", E, F))) - }; - Record record = new InternalRecord(asList("ttl", "servers"), values); - - var composition = ClusterComposition.parse(record, 0); - - // TTL is received in seconds and is converted to millis - assertEquals(42_000, composition.expirationTimestamp()); - - assertEquals(addresses(A, B), composition.readers()); - assertEquals(addresses(C, D), composition.writers()); - assertEquals(addresses(E, F), composition.routers()); - } - - @Test - void parsePreservesOrderOfReaders() { - var values = new Value[] { - value(42L), - value(asList(serversEntry("READ", A, C, E, B, F, D), serversEntry("WRITE"), serversEntry("ROUTE"))) - }; - Record record = new InternalRecord(asList("ttl", "servers"), values); - - var composition = ClusterComposition.parse(record, 0); - - assertThat(composition.readers(), contains(A, C, E, B, F, D)); - assertEquals(0, composition.writers().size()); - assertEquals(0, composition.routers().size()); - } - - @Test - void parsePreservesOrderOfWriters() { - var values = new Value[] { - value(42L), - value(asList(serversEntry("READ"), serversEntry("WRITE", C, F, D, A, B, E), serversEntry("ROUTE"))) - }; - Record record = new InternalRecord(asList("ttl", "servers"), values); - - var composition = ClusterComposition.parse(record, 0); - - assertEquals(0, composition.readers().size()); - assertThat(composition.writers(), contains(C, F, D, A, B, E)); - assertEquals(0, composition.routers().size()); - } - - @Test - void parsePreservesOrderOfRouters() { - var values = new Value[] { - value(42L), - value(asList(serversEntry("READ"), serversEntry("WRITE"), serversEntry("ROUTE", F, D, A, B, C, E))) - }; - Record record = new InternalRecord(asList("ttl", "servers"), values); - - var composition = ClusterComposition.parse(record, 0); - - assertEquals(0, composition.readers().size()); - assertEquals(0, composition.writers().size()); - assertThat(composition.routers(), contains(F, D, A, B, C, E)); - } + // @Test + // void parseCorrectRecord() { + // var values = new Value[] { + // value(42L), + // value(asList(serversEntry("READ", A, B), serversEntry("WRITE", C, D), serversEntry("ROUTE", E, F))) + // }; + // Record record = new InternalRecord(asList("ttl", "servers"), values); + // + // var composition = ClusterComposition.parse(record, 0); + // + // // TTL is received in seconds and is converted to millis + // assertEquals(42_000, composition.expirationTimestamp()); + // + // assertEquals(addresses(A, B), composition.readers()); + // assertEquals(addresses(C, D), composition.writers()); + // assertEquals(addresses(E, F), composition.routers()); + // } + // + // @Test + // void parsePreservesOrderOfReaders() { + // var values = new Value[] { + // value(42L), + // value(asList(serversEntry("READ", A, C, E, B, F, D), serversEntry("WRITE"), serversEntry("ROUTE"))) + // }; + // Record record = new InternalRecord(asList("ttl", "servers"), values); + // + // var composition = ClusterComposition.parse(record, 0); + // + // assertThat(composition.readers(), contains(A, C, E, B, F, D)); + // assertEquals(0, composition.writers().size()); + // assertEquals(0, composition.routers().size()); + // } + // + // @Test + // void parsePreservesOrderOfWriters() { + // var values = new Value[] { + // value(42L), + // value(asList(serversEntry("READ"), serversEntry("WRITE", C, F, D, A, B, E), serversEntry("ROUTE"))) + // }; + // Record record = new InternalRecord(asList("ttl", "servers"), values); + // + // var composition = ClusterComposition.parse(record, 0); + // + // assertEquals(0, composition.readers().size()); + // assertThat(composition.writers(), contains(C, F, D, A, B, E)); + // assertEquals(0, composition.routers().size()); + // } + // + // @Test + // void parsePreservesOrderOfRouters() { + // var values = new Value[] { + // value(42L), + // value(asList(serversEntry("READ"), serversEntry("WRITE"), serversEntry("ROUTE", F, D, A, B, C, E))) + // }; + // Record record = new InternalRecord(asList("ttl", "servers"), values); + // + // var composition = ClusterComposition.parse(record, 0); + // + // assertEquals(0, composition.readers().size()); + // assertEquals(0, composition.writers().size()); + // assertThat(composition.routers(), contains(F, D, A, B, C, E)); + // } private static ClusterComposition newComposition( long expirationTimestamp, diff --git a/driver/src/test/java/org/neo4j/driver/internal/CustomSecurityPlanTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/api/CustomSecurityPlanTest.java similarity index 66% rename from driver/src/test/java/org/neo4j/driver/internal/CustomSecurityPlanTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/api/CustomSecurityPlanTest.java index 6598ee96b4..3226eeae42 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/CustomSecurityPlanTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/api/CustomSecurityPlanTest.java @@ -14,25 +14,23 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal; +package org.neo4j.driver.internal.bolt.api; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.mockito.Mockito.mock; -import io.netty.bootstrap.Bootstrap; import java.net.URI; import java.util.ArrayList; import java.util.List; import org.junit.jupiter.api.Test; -import org.neo4j.driver.AuthTokenManager; +import org.mockito.Mockito; import org.neo4j.driver.AuthTokens; import org.neo4j.driver.Config; -import org.neo4j.driver.internal.cluster.RoutingContext; +import org.neo4j.driver.internal.DriverFactory; +import org.neo4j.driver.internal.InternalDriver; +import org.neo4j.driver.internal.SessionFactory; 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 { @Test @@ -40,14 +38,13 @@ class CustomSecurityPlanTest { void testCustomSecurityPlanUsed() { var driverFactory = new SecurityPlanCapturingDriverFactory(); - var securityPlan = mock(SecurityPlan.class); + var securityPlan = Mockito.mock(SecurityPlan.class); driverFactory.newInstance( URI.create("neo4j://somewhere:1234"), new StaticAuthTokenManager(AuthTokens.none()), Config.defaultConfig(), securityPlan, - null, null); assertFalse(driverFactory.capturedSecurityPlans.isEmpty()); @@ -66,25 +63,5 @@ protected InternalDriver createDriver( capturedSecurityPlans.add(securityPlan); return super.createDriver(securityPlan, sessionFactory, metricsProvider, config); } - - @Override - protected ConnectionPool createConnectionPool( - AuthTokenManager authTokenManager, - SecurityPlan securityPlan, - Bootstrap bootstrap, - MetricsProvider metricsProvider, - Config config, - boolean ownsEventLoopGroup, - RoutingContext routingContext) { - capturedSecurityPlans.add(securityPlan); - return super.createConnectionPool( - authTokenManager, - securityPlan, - bootstrap, - metricsProvider, - config, - ownsEventLoopGroup, - routingContext); - } } } diff --git a/driver/src/test/java/org/neo4j/driver/internal/DatabaseNameUtilTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/api/DatabaseNameUtilTest.java similarity index 77% rename from driver/src/test/java/org/neo4j/driver/internal/DatabaseNameUtilTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/api/DatabaseNameUtilTest.java index 7771383a0a..e3fcbd2364 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/DatabaseNameUtilTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/api/DatabaseNameUtilTest.java @@ -14,14 +14,14 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal; +package org.neo4j.driver.internal.bolt.api; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.neo4j.driver.internal.DatabaseNameUtil.DEFAULT_DATABASE_NAME; -import static org.neo4j.driver.internal.DatabaseNameUtil.SYSTEM_DATABASE_NAME; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.DatabaseNameUtil.systemDatabase; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.DEFAULT_DATABASE_NAME; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.SYSTEM_DATABASE_NAME; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.systemDatabase; import org.junit.jupiter.api.Test; diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingContextTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/api/RoutingContextTest.java similarity index 99% rename from driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingContextTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/api/RoutingContextTest.java index 8c10912b85..30ad5c17b9 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingContextTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/api/RoutingContextTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal.bolt.api; import static java.util.Collections.singletonMap; import static org.junit.jupiter.api.Assertions.assertEquals; diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/ClusterCompositionUtil.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/api/util/ClusterCompositionUtil.java similarity index 93% rename from driver/src/test/java/org/neo4j/driver/internal/util/ClusterCompositionUtil.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/api/util/ClusterCompositionUtil.java index 0bd21bfa84..336280418f 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/ClusterCompositionUtil.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/api/util/ClusterCompositionUtil.java @@ -14,15 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.util; +package org.neo4j.driver.internal.bolt.api.util; import java.util.ArrayList; import java.util.LinkedHashSet; import java.util.List; import java.util.Set; import java.util.concurrent.TimeUnit; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.cluster.ClusterComposition; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ClusterComposition; public final class ClusterCompositionUtil { private ClusterCompositionUtil() {} diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/connection/BoltProtocolUtilTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/BoltProtocolUtilTest.java similarity index 68% rename from driver/src/test/java/org/neo4j/driver/internal/async/connection/BoltProtocolUtilTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/BoltProtocolUtilTest.java index a7dd582f35..a1eba14c50 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/connection/BoltProtocolUtilTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/BoltProtocolUtilTest.java @@ -14,23 +14,23 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.neo4j.driver.internal.async.connection.BoltProtocolUtil.BOLT_MAGIC_PREAMBLE; -import static org.neo4j.driver.internal.async.connection.BoltProtocolUtil.handshakeBuf; -import static org.neo4j.driver.internal.async.connection.BoltProtocolUtil.handshakeString; -import static org.neo4j.driver.internal.async.connection.BoltProtocolUtil.writeChunkHeader; -import static org.neo4j.driver.internal.async.connection.BoltProtocolUtil.writeEmptyChunkHeader; -import static org.neo4j.driver.internal.async.connection.BoltProtocolUtil.writeMessageBoundary; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.BoltProtocolUtil.BOLT_MAGIC_PREAMBLE; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.BoltProtocolUtil.handshakeBuf; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.BoltProtocolUtil.handshakeString; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.BoltProtocolUtil.writeChunkHeader; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.BoltProtocolUtil.writeEmptyChunkHeader; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.BoltProtocolUtil.writeMessageBoundary; import static org.neo4j.driver.testutil.TestUtil.assertByteBufContains; import io.netty.buffer.Unpooled; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3; -import org.neo4j.driver.internal.messaging.v41.BoltProtocolV41; -import org.neo4j.driver.internal.messaging.v44.BoltProtocolV44; -import org.neo4j.driver.internal.messaging.v54.BoltProtocolV54; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v3.BoltProtocolV3; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v41.BoltProtocolV41; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v44.BoltProtocolV44; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v54.BoltProtocolV54; class BoltProtocolUtilTest { @Test diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/connection/ChannelAttributesTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelAttributesTest.java similarity index 64% rename from driver/src/test/java/org/neo4j/driver/internal/async/connection/ChannelAttributesTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelAttributesTest.java index 249da81fde..ffe139be6f 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/connection/ChannelAttributesTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelAttributesTest.java @@ -14,41 +14,39 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; import static org.junit.jupiter.api.Assertions.assertEquals; 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; -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 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; -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.connection.ChannelAttributes.setServerAddress; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setServerAgent; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setTerminationReason; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.terminationReason; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.authorizationStateListener; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.connectionId; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.connectionReadTimeout; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.creationTimestamp; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.lastUsedTimestamp; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.messageDispatcher; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.protocolVersion; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.serverAddress; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.serverAgent; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setAuthorizationStateListener; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setConnectionId; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setConnectionReadTimeout; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setCreationTimestamp; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setLastUsedTimestamp; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setMessageDispatcher; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setProtocolVersion; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setServerAddress; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setServerAgent; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setTerminationReason; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.terminationReason; import io.netty.channel.embedded.EmbeddedChannel; 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; +import org.mockito.Mockito; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; class ChannelAttributesTest { private final EmbeddedChannel channel = new EmbeddedChannel(); @@ -168,17 +166,17 @@ void shouldFailToSetTerminationReasonTwice() { @Test void shouldSetAndGetAuthorizationStateListener() { - var listener = mock(AuthorizationStateListener.class); + var listener = Mockito.mock(AuthorizationStateListener.class); setAuthorizationStateListener(channel, listener); assertEquals(listener, authorizationStateListener(channel)); } @Test void shouldAllowOverridingAuthorizationStateListener() { - var listener = mock(AuthorizationStateListener.class); + var listener = Mockito.mock(AuthorizationStateListener.class); setAuthorizationStateListener(channel, listener); assertEquals(listener, authorizationStateListener(channel)); - var newListener = mock(AuthorizationStateListener.class); + var newListener = Mockito.mock(AuthorizationStateListener.class); setAuthorizationStateListener(channel, newListener); assertEquals(newListener, authorizationStateListener(channel)); } @@ -196,18 +194,4 @@ 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/ChannelConnectedListenerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelConnectedListenerTest.java similarity index 63% rename from driver/src/test/java/org/neo4j/driver/internal/async/connection/ChannelConnectedListenerTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelConnectedListenerTest.java index 862f5a7503..d23468f95d 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/connection/ChannelConnectedListenerTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelConnectedListenerTest.java @@ -14,23 +14,27 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.neo4j.driver.internal.BoltServerAddress.LOCAL_DEFAULT; -import static org.neo4j.driver.internal.async.connection.BoltProtocolUtil.handshakeBuf; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; +import static org.neo4j.driver.internal.bolt.api.BoltServerAddress.LOCAL_DEFAULT; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.BoltProtocolUtil.handshakeBuf; import static org.neo4j.driver.testutil.TestUtil.await; import io.netty.channel.ChannelPromise; import io.netty.channel.embedded.EmbeddedChannel; +import io.netty.util.concurrent.Future; import java.io.IOException; +import java.util.concurrent.CompletableFuture; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.Test; import org.neo4j.driver.exceptions.ServiceUnavailableException; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; class ChannelConnectedListenerTest { private final EmbeddedChannel channel = new EmbeddedChannel(); @@ -70,8 +74,30 @@ void shouldWriteHandshakeWhenChannelConnected() { assertEquals(handshakeBuf(), channel.readOutbound()); } + @Test + void shouldCompleteHandshakePromiseExceptionallyOnWriteFailure() { + var handshakeCompletedPromise = channel.newPromise(); + var listener = newListener(handshakeCompletedPromise); + var channelConnectedPromise = channel.newPromise(); + channelConnectedPromise.setSuccess(); + channel.close(); + + listener.operationComplete(channelConnectedPromise); + + assertTrue(handshakeCompletedPromise.isDone()); + var future = new CompletableFuture>(); + handshakeCompletedPromise.addListener(future::complete); + var handshakeFuture = future.join(); + assertTrue(handshakeFuture.isDone()); + assertFalse(handshakeFuture.isSuccess()); + assertInstanceOf(ServiceUnavailableException.class, handshakeFuture.cause()); + } + private static ChannelConnectedListener newListener(ChannelPromise handshakeCompletedPromise) { return new ChannelConnectedListener( - LOCAL_DEFAULT, new ChannelPipelineBuilderImpl(), handshakeCompletedPromise, DEV_NULL_LOGGING); + LOCAL_DEFAULT, + new ChannelPipelineBuilderImpl(), + handshakeCompletedPromise, + NoopLoggingProvider.INSTANCE); } } diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/connection/ChannelErrorHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelErrorHandlerTest.java similarity index 54% rename from driver/src/test/java/org/neo4j/driver/internal/async/connection/ChannelErrorHandlerTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelErrorHandlerTest.java index 9174d62f24..d34b7c9cf0 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/connection/ChannelErrorHandlerTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelErrorHandlerTest.java @@ -14,17 +14,18 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.containsString; import static org.hamcrest.Matchers.instanceOf; import static org.hamcrest.Matchers.startsWith; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setMessageDispatcher; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setTerminationReason; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; +import static org.mockito.BDDMockito.then; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setMessageDispatcher; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setTerminationReason; import io.netty.channel.embedded.EmbeddedChannel; import io.netty.handler.codec.CodecException; @@ -32,9 +33,11 @@ import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.internal.async.inbound.ChannelErrorHandler; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.ChannelErrorHandler; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; class ChannelErrorHandlerTest { private EmbeddedChannel channel; @@ -43,9 +46,9 @@ class ChannelErrorHandlerTest { @BeforeEach void setUp() { channel = new EmbeddedChannel(); - messageDispatcher = new InboundMessageDispatcher(channel, DEV_NULL_LOGGING); + messageDispatcher = mock(); setMessageDispatcher(channel, messageDispatcher); - channel.pipeline().addLast(new ChannelErrorHandler(DEV_NULL_LOGGING)); + channel.pipeline().addLast(new ChannelErrorHandler(NoopLoggingProvider.INSTANCE)); } @AfterEach @@ -58,24 +61,33 @@ void tearDown() { @Test void shouldHandleChannelInactive() { channel.pipeline().fireChannelInactive(); + var exceptionCaptor = ArgumentCaptor.forClass(ServiceUnavailableException.class); - var error = messageDispatcher.currentError(); + then(messageDispatcher).should().handleChannelInactive(exceptionCaptor.capture()); + var error = exceptionCaptor.getValue(); assertThat(error, instanceOf(ServiceUnavailableException.class)); assertThat(error.getMessage(), startsWith("Connection to the database terminated")); - assertFalse(channel.isOpen()); + // assertFalse(channel.isOpen()); } @Test void shouldHandleChannelInactiveAfterExceptionCaught() { var originalError = new RuntimeException("Hi!"); + var exception1 = ArgumentCaptor.forClass(RuntimeException.class); channel.pipeline().fireExceptionCaught(originalError); + then(messageDispatcher).should().handleChannelError(exception1.capture()); channel.pipeline().fireChannelInactive(); + var exception2 = ArgumentCaptor.forClass(RuntimeException.class); + then(messageDispatcher).should(times(2)).handleChannelError(exception2.capture()); - var error = messageDispatcher.currentError(); + var error1 = exception1.getValue(); + var error2 = exception2.getValue(); - assertEquals(originalError, error); - assertFalse(channel.isOpen()); + assertEquals(originalError, error1); + assertThat(error2, instanceOf(ServiceUnavailableException.class)); + assertThat(error2.getMessage(), startsWith("Connection to the database terminated")); + // assertFalse(channel.isOpen()); } @Test @@ -85,58 +97,67 @@ void shouldHandleChannelInactiveWhenTerminationReasonSet() { channel.pipeline().fireChannelInactive(); - var error = messageDispatcher.currentError(); - + var exceptionCaptor = ArgumentCaptor.forClass(ServiceUnavailableException.class); + then(messageDispatcher).should().handleChannelInactive(exceptionCaptor.capture()); + var error = exceptionCaptor.getValue(); assertThat(error, instanceOf(ServiceUnavailableException.class)); assertThat(error.getMessage(), startsWith("Connection to the database terminated")); assertThat(error.getMessage(), containsString(terminationReason)); - assertFalse(channel.isOpen()); + // assertFalse(channel.isOpen()); } @Test void shouldHandleCodecException() { var cause = new RuntimeException("Hi!"); var codecException = new CodecException("Unable to encode or decode message", cause); - channel.pipeline().fireExceptionCaught(codecException); - var error = messageDispatcher.currentError(); + channel.pipeline().fireExceptionCaught(codecException); + var exceptionCaptor = ArgumentCaptor.forClass(RuntimeException.class); + then(messageDispatcher).should().handleChannelError(exceptionCaptor.capture()); + var error = exceptionCaptor.getValue(); assertEquals(cause, error); - assertFalse(channel.isOpen()); + // assertFalse(channel.isOpen()); } @Test void shouldHandleCodecExceptionWithoutCause() { var codecException = new CodecException("Unable to encode or decode message"); - channel.pipeline().fireExceptionCaught(codecException); - var error = messageDispatcher.currentError(); + channel.pipeline().fireExceptionCaught(codecException); + var exceptionCaptor = ArgumentCaptor.forClass(RuntimeException.class); + then(messageDispatcher).should().handleChannelError(exceptionCaptor.capture()); + var error = exceptionCaptor.getValue(); assertEquals(codecException, error); - assertFalse(channel.isOpen()); + // assertFalse(channel.isOpen()); } @Test void shouldHandleIOException() { var ioException = new IOException("Write or read failed"); - channel.pipeline().fireExceptionCaught(ioException); - var error = messageDispatcher.currentError(); + channel.pipeline().fireExceptionCaught(ioException); + var exceptionCaptor = ArgumentCaptor.forClass(RuntimeException.class); + then(messageDispatcher).should().handleChannelError(exceptionCaptor.capture()); + var error = exceptionCaptor.getValue(); assertThat(error, instanceOf(ServiceUnavailableException.class)); assertEquals(ioException, error.getCause()); - assertFalse(channel.isOpen()); + // assertFalse(channel.isOpen()); } @Test void shouldHandleException() { var originalError = new RuntimeException("Random failure"); - channel.pipeline().fireExceptionCaught(originalError); - var error = messageDispatcher.currentError(); + channel.pipeline().fireExceptionCaught(originalError); + var exceptionCaptor = ArgumentCaptor.forClass(RuntimeException.class); + then(messageDispatcher).should().handleChannelError(exceptionCaptor.capture()); + var error = exceptionCaptor.getValue(); assertEquals(originalError, error); - assertFalse(channel.isOpen()); + // assertFalse(channel.isOpen()); } @Test @@ -147,9 +168,10 @@ void shouldHandleMultipleExceptions() { channel.pipeline().fireExceptionCaught(error1); channel.pipeline().fireExceptionCaught(error2); - var error = messageDispatcher.currentError(); - + var exceptionCaptor = ArgumentCaptor.forClass(RuntimeException.class); + then(messageDispatcher).should().handleChannelError(exceptionCaptor.capture()); + var error = exceptionCaptor.getValue(); assertEquals(error1, error); - assertFalse(channel.isOpen()); + // assertFalse(channel.isOpen()); } } diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/connection/ChannelPipelineBuilderImplTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelPipelineBuilderImplTest.java similarity index 64% rename from driver/src/test/java/org/neo4j/driver/internal/async/connection/ChannelPipelineBuilderImplTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelPipelineBuilderImplTest.java index 22c64cf00c..a38a9195e8 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/connection/ChannelPipelineBuilderImplTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/ChannelPipelineBuilderImplTest.java @@ -14,30 +14,31 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.instanceOf; import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; import io.netty.channel.embedded.EmbeddedChannel; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.async.inbound.ChannelErrorHandler; -import org.neo4j.driver.internal.async.inbound.ChunkDecoder; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; -import org.neo4j.driver.internal.async.inbound.InboundMessageHandler; -import org.neo4j.driver.internal.async.inbound.MessageDecoder; -import org.neo4j.driver.internal.async.outbound.OutboundMessageHandler; -import org.neo4j.driver.internal.messaging.v3.MessageFormatV3; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.ChannelErrorHandler; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.ChunkDecoder; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.MessageDecoder; +import org.neo4j.driver.internal.bolt.basicimpl.async.outbound.OutboundMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v3.MessageFormatV3; class ChannelPipelineBuilderImplTest { @Test void shouldBuildPipeline() { var channel = new EmbeddedChannel(); - ChannelAttributes.setMessageDispatcher(channel, new InboundMessageDispatcher(channel, DEV_NULL_LOGGING)); + ChannelAttributes.setMessageDispatcher( + channel, new InboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE)); - new ChannelPipelineBuilderImpl().build(new MessageFormatV3(), channel.pipeline(), DEV_NULL_LOGGING); + new ChannelPipelineBuilderImpl().build(new MessageFormatV3(), channel.pipeline(), NoopLoggingProvider.INSTANCE); var iterator = channel.pipeline().iterator(); assertThat(iterator.next().getValue(), instanceOf(ChunkDecoder.class)); diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/connection/EventLoopGroupFactoryTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/EventLoopGroupFactoryTest.java similarity index 98% rename from driver/src/test/java/org/neo4j/driver/internal/async/connection/EventLoopGroupFactoryTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/EventLoopGroupFactoryTest.java index f45f91ab25..431c9b56a6 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/connection/EventLoopGroupFactoryTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/EventLoopGroupFactoryTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; import static java.util.concurrent.TimeUnit.SECONDS; import static org.hamcrest.MatcherAssert.assertThat; diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/HandshakeCompletedListenerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/HandshakeCompletedListenerTest.java new file mode 100644 index 0000000000..4ce0fc7e89 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/HandshakeCompletedListenerTest.java @@ -0,0 +1,115 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.async.connection; + +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.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setMessageDispatcher; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setProtocolVersion; +import static org.neo4j.driver.testutil.TestUtil.await; + +import io.netty.channel.embedded.EmbeddedChannel; +import java.io.IOException; +import java.time.Clock; +import java.util.Collections; +import java.util.Map; +import java.util.concurrent.CompletableFuture; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Test; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; +import org.neo4j.driver.internal.bolt.api.BoltAgentUtil; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.HelloResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v3.BoltProtocolV3; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; + +class HandshakeCompletedListenerTest { + private static final String USER_AGENT = "user-agent"; + + private final EmbeddedChannel channel = new EmbeddedChannel(); + + @AfterEach + void tearDown() { + channel.finishAndReleaseAll(); + } + + @Test + void shouldFailConnectionInitializedPromiseWhenHandshakeFails() { + var channelInitializedPromise = channel.newPromise(); + var listener = new HandshakeCompletedListener( + Collections.emptyMap(), + USER_AGENT, + BoltAgentUtil.VALUE, + RoutingContext.EMPTY, + channelInitializedPromise, + null, + mock(Clock.class), + new CompletableFuture<>()); + + var handshakeCompletedPromise = channel.newPromise(); + var cause = new IOException("Bad handshake"); + handshakeCompletedPromise.setFailure(cause); + + listener.operationComplete(handshakeCompletedPromise); + + var error = assertThrows(Exception.class, () -> await(channelInitializedPromise)); + assertEquals(cause, error); + } + + @Test + void shouldWriteInitializationMessageInBoltV3WhenHandshakeCompleted() { + var expectedMessage = new HelloMessage(USER_AGENT, null, authToken(), Collections.emptyMap(), false, null); + var messageDispatcher = mock(InboundMessageDispatcher.class); + setProtocolVersion(channel, BoltProtocolV3.VERSION); + setMessageDispatcher(channel, messageDispatcher); + + var channelInitializedPromise = channel.newPromise(); + var listener = new HandshakeCompletedListener( + authToken(), + USER_AGENT, + BoltAgentUtil.VALUE, + RoutingContext.EMPTY, + channelInitializedPromise, + null, + mock(Clock.class), + new CompletableFuture<>()); + + var handshakeCompletedPromise = channel.newPromise(); + handshakeCompletedPromise.setSuccess(); + + listener.operationComplete(handshakeCompletedPromise); + assertTrue(channel.finish()); + + verify(messageDispatcher).enqueue(any((Class) HelloResponseHandler.class)); + var outboundMessage = channel.readOutbound(); + assertEquals(expectedMessage, outboundMessage); + } + + private void testWritingOfInitializationMessage(Message expectedMessage) {} + + private static Map authToken() { + return Map.of("neo4j", Values.value("secret")); + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/connection/HandshakeHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/HandshakeHandlerTest.java similarity index 87% rename from driver/src/test/java/org/neo4j/driver/internal/async/connection/HandshakeHandlerTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/HandshakeHandlerTest.java index 214100cd0e..a52edf2b10 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/connection/HandshakeHandlerTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/HandshakeHandlerTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; import static io.netty.buffer.Unpooled.copyInt; import static org.hamcrest.MatcherAssert.assertThat; @@ -25,9 +25,8 @@ import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.params.provider.Arguments.arguments; -import static org.neo4j.driver.internal.async.connection.BoltProtocolUtil.NO_PROTOCOL_VERSION; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setMessageDispatcher; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.BoltProtocolUtil.NO_PROTOCOL_VERSION; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setMessageDispatcher; import static org.neo4j.driver.testutil.TestUtil.await; import io.netty.channel.ChannelPipeline; @@ -43,23 +42,24 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; -import org.neo4j.driver.Logging; import org.neo4j.driver.exceptions.ClientException; import org.neo4j.driver.exceptions.SecurityException; import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.internal.async.inbound.ChunkDecoder; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; -import org.neo4j.driver.internal.async.inbound.InboundMessageHandler; -import org.neo4j.driver.internal.async.inbound.MessageDecoder; -import org.neo4j.driver.internal.async.outbound.OutboundMessageHandler; -import org.neo4j.driver.internal.messaging.BoltProtocolVersion; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3; -import org.neo4j.driver.internal.messaging.v3.MessageFormatV3; -import org.neo4j.driver.internal.messaging.v4.BoltProtocolV4; -import org.neo4j.driver.internal.messaging.v4.MessageFormatV4; -import org.neo4j.driver.internal.messaging.v41.BoltProtocolV41; -import org.neo4j.driver.internal.messaging.v42.BoltProtocolV42; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.ChunkDecoder; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.MessageDecoder; +import org.neo4j.driver.internal.bolt.basicimpl.async.outbound.OutboundMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v3.BoltProtocolV3; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v3.MessageFormatV3; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v4.BoltProtocolV4; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v4.MessageFormatV4; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v41.BoltProtocolV41; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v42.BoltProtocolV42; import org.neo4j.driver.internal.util.ErrorUtil; class HandshakeHandlerTest { @@ -67,7 +67,7 @@ class HandshakeHandlerTest { @BeforeEach void setUp() { - setMessageDispatcher(channel, new InboundMessageDispatcher(channel, DEV_NULL_LOGGING)); + setMessageDispatcher(channel, new InboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE)); } @AfterEach @@ -274,14 +274,14 @@ private static HandshakeHandler newHandler(ChannelPromise handshakeCompletedProm private static HandshakeHandler newHandler( ChannelPipelineBuilder pipelineBuilder, ChannelPromise handshakeCompletedPromise) { - return new HandshakeHandler(pipelineBuilder, handshakeCompletedPromise, DEV_NULL_LOGGING); + return new HandshakeHandler(pipelineBuilder, handshakeCompletedPromise, NoopLoggingProvider.INSTANCE); } private static class MemorizingChannelPipelineBuilder extends ChannelPipelineBuilderImpl { MessageFormat usedMessageFormat; @Override - public void build(MessageFormat messageFormat, ChannelPipeline pipeline, Logging logging) { + public void build(MessageFormat messageFormat, ChannelPipeline pipeline, LoggingProvider logging) { usedMessageFormat = messageFormat; super.build(messageFormat, pipeline, logging); } diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/connection/NettyChannelInitializerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/NettyChannelInitializerTest.java similarity index 75% rename from driver/src/test/java/org/neo4j/driver/internal/async/connection/NettyChannelInitializerTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/NettyChannelInitializerTest.java index 76120cc3eb..a6096eef65 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/connection/NettyChannelInitializerTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/connection/NettyChannelInitializerTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.connection; +package org.neo4j.driver.internal.bolt.basicimpl.async.connection; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.equalTo; @@ -25,12 +25,10 @@ import static org.junit.jupiter.api.Assertions.assertNull; 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; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; +import static org.neo4j.driver.internal.bolt.api.BoltServerAddress.LOCAL_DEFAULT; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.creationTimestamp; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.messageDispatcher; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.serverAddress; import io.netty.channel.embedded.EmbeddedChannel; import io.netty.handler.ssl.SslHandler; @@ -39,12 +37,11 @@ import javax.net.ssl.SNIHostName; 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.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.SecurityPlan; +import org.neo4j.driver.internal.security.SecurityPlans; import org.neo4j.driver.internal.util.FakeClock; class NettyChannelInitializerTest { @@ -67,7 +64,7 @@ void shouldAddSslHandlerWhenRequiresEncryption() throws Exception { @Test void shouldNotAddSslHandlerWhenDoesNotRequireEncryption() { - var security = SecurityPlanImpl.insecure(); + var security = SecurityPlans.insecure(); var initializer = newInitializer(security); initializer.initChannel(channel); @@ -92,7 +89,7 @@ void shouldAddSslHandlerWithHandshakeTimeout() throws Exception { void shouldUpdateChannelAttributes() { var clock = mock(Clock.class); when(clock.millis()).thenReturn(42L); - var security = SecurityPlanImpl.insecure(); + var security = SecurityPlans.insecure(); var initializer = newInitializer(security, Integer.MAX_VALUE, clock); initializer.initChannel(channel); @@ -100,19 +97,13 @@ void shouldUpdateChannelAttributes() { assertEquals(LOCAL_DEFAULT, serverAddress(channel)); assertEquals(42L, creationTimestamp(channel)); assertNotNull(messageDispatcher(channel)); - assertNotNull(authContext(channel)); } @Test void shouldIncludeSniHostName() throws Exception { var address = new BoltServerAddress("database.neo4j.com", 8989); var initializer = new NettyChannelInitializer( - address, - trustAllCertificates(), - 10000, - new StaticAuthTokenManager(AuthTokens.none()), - Clock.systemUTC(), - DEV_NULL_LOGGING); + address, trustAllCertificates(), 10000, Clock.systemUTC(), NoopLoggingProvider.INSTANCE); initializer.initChannel(channel); @@ -137,7 +128,7 @@ void shouldNotEnableHostnameVerificationWhenNotConfigured() throws Exception { private void testHostnameVerificationSetting(boolean enabled, String expectedValue) throws Exception { var initializer = - newInitializer(SecurityPlanImpl.forAllCertificates(enabled, RevocationCheckingStrategy.NO_CHECKS)); + newInitializer(SecurityPlans.forAllCertificates(enabled, RevocationCheckingStrategy.NO_CHECKS)); initializer.initChannel(channel); @@ -158,15 +149,10 @@ private static NettyChannelInitializer newInitializer(SecurityPlan securityPlan, private static NettyChannelInitializer newInitializer( SecurityPlan securityPlan, int connectTimeoutMillis, Clock clock) { return new NettyChannelInitializer( - LOCAL_DEFAULT, - securityPlan, - connectTimeoutMillis, - new StaticAuthTokenManager(AuthTokens.none()), - clock, - DEV_NULL_LOGGING); + LOCAL_DEFAULT, securityPlan, connectTimeoutMillis, clock, NoopLoggingProvider.INSTANCE); } private static SecurityPlan trustAllCertificates() throws GeneralSecurityException { - return SecurityPlanImpl.forAllCertificates(false, RevocationCheckingStrategy.NO_CHECKS); + return SecurityPlans.forAllCertificates(false, RevocationCheckingStrategy.NO_CHECKS); } } diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/ByteBufInputTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ByteBufInputTest.java similarity index 98% rename from driver/src/test/java/org/neo4j/driver/internal/async/inbound/ByteBufInputTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ByteBufInputTest.java index 92650a2203..84887fcf11 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/ByteBufInputTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ByteBufInputTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.inbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.inbound; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/ChunkDecoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ChunkDecoderTest.java similarity index 88% rename from driver/src/test/java/org/neo4j/driver/internal/async/inbound/ChunkDecoderTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ChunkDecoderTest.java index 7bfe62f370..3d8458929a 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/ChunkDecoderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ChunkDecoderTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.inbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.inbound; import static io.netty.buffer.ByteBufUtil.hexDump; import static io.netty.buffer.Unpooled.buffer; @@ -25,19 +25,20 @@ import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; import static org.neo4j.driver.testutil.TestUtil.assertByteBufEquals; import io.netty.buffer.ByteBuf; import io.netty.channel.embedded.EmbeddedChannel; +import java.util.ResourceBundle; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.Test; import org.mockito.ArgumentCaptor; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; class ChunkDecoderTest { private ByteBuf buffer; @@ -139,7 +140,8 @@ void shouldLogEmptyChunkOnTraceLevel() { assertTrue(channel.finish()); var messageCaptor = ArgumentCaptor.forClass(String.class); - verify(logger).trace(anyString(), messageCaptor.capture()); + verify(logger) + .log(eq(System.Logger.Level.TRACE), eq((ResourceBundle) null), anyString(), messageCaptor.capture()); // pretty hex dump should be logged assertEquals(hexDump(buffer), messageCaptor.getValue()); @@ -162,7 +164,8 @@ void shouldLogNonEmptyChunkOnTraceLevel() { assertTrue(channel.finish()); var messageCaptor = ArgumentCaptor.forClass(String.class); - verify(logger).trace(anyString(), messageCaptor.capture()); + verify(logger) + .log(eq(System.Logger.Level.TRACE), eq((ResourceBundle) null), anyString(), messageCaptor.capture()); // pretty hex dump should be logged assertEquals(hexDump(buffer), messageCaptor.getValue()); @@ -187,17 +190,17 @@ public void shouldDecodeMaxSizeChunk() { } private static ChunkDecoder newChunkDecoder() { - return new ChunkDecoder(DEV_NULL_LOGGING); + return new ChunkDecoder(NoopLoggingProvider.INSTANCE); } - private static Logger newTraceLogger() { - var logger = mock(Logger.class); - when(logger.isTraceEnabled()).thenReturn(true); + private static System.Logger newTraceLogger() { + var logger = mock(System.Logger.class); + when(logger.isLoggable(System.Logger.Level.TRACE)).thenReturn(true); return logger; } - private static Logging newLogging(Logger logger) { - var logging = mock(Logging.class); + private static LoggingProvider newLogging(System.Logger logger) { + var logging = mock(LoggingProvider.class); when(logging.getLog(any(Class.class))).thenReturn(logger); return logging; } diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/ConnectTimeoutHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ConnectTimeoutHandlerTest.java similarity index 97% rename from driver/src/test/java/org/neo4j/driver/internal/async/inbound/ConnectTimeoutHandlerTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ConnectTimeoutHandlerTest.java index 5fe10ebd32..c0aaf40bfc 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/ConnectTimeoutHandlerTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ConnectTimeoutHandlerTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.inbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.inbound; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/ConnectionReadTimeoutHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ConnectionReadTimeoutHandlerTest.java similarity index 96% rename from driver/src/test/java/org/neo4j/driver/internal/async/inbound/ConnectionReadTimeoutHandlerTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ConnectionReadTimeoutHandlerTest.java index 25c3599b26..b345a31229 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/ConnectionReadTimeoutHandlerTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/ConnectionReadTimeoutHandlerTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.inbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.inbound; import static org.mockito.BDDMockito.any; import static org.mockito.BDDMockito.then; diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcherTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/InboundMessageDispatcherTest.java similarity index 52% rename from driver/src/test/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcherTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/InboundMessageDispatcherTest.java index 2ee16a715c..3aafd07274 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcherTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/InboundMessageDispatcherTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.inbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.inbound; import static java.util.Collections.emptyMap; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -25,23 +25,14 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyBoolean; import static org.mockito.ArgumentMatchers.anyString; -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; @@ -50,30 +41,25 @@ import io.netty.util.Attribute; import java.util.HashMap; import java.util.Map; +import java.util.ResourceBundle; 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.AuthTokenManager; -import org.neo4j.driver.AuthTokens; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; +import org.mockito.ArgumentMatchers; 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.SecurityException; -import org.neo4j.driver.exceptions.TokenExpiredException; -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; -import org.neo4j.driver.internal.messaging.response.FailureMessage; -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.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.logging.ChannelActivityLogger; +import org.neo4j.driver.internal.bolt.basicimpl.logging.ChannelErrorLogger; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.FailureMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.IgnoredMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.RecordMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.SuccessMessage; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; import org.neo4j.driver.internal.value.IntegerValue; class InboundMessageDispatcherTest { @@ -82,7 +68,8 @@ class InboundMessageDispatcherTest { @Test void shouldFailWhenCreatedWithNullChannel() { - assertThrows(NullPointerException.class, () -> new InboundMessageDispatcher(null, DEV_NULL_LOGGING)); + assertThrows( + NullPointerException.class, () -> new InboundMessageDispatcher(null, NoopLoggingProvider.INSTANCE)); } @Test @@ -110,13 +97,6 @@ void shouldDequeHandlerOnSuccess() { @Test void shouldDequeHandlerOnFailure() { 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); @@ -125,52 +105,8 @@ void shouldDequeHandlerOnFailure() { dispatcher.handleFailureMessage(FAILURE_CODE, FAILURE_MESSAGE); - // "RESET after failure" handler should remain queued - assertEquals(1, dispatcher.queuedHandlersCount()); + assertEquals(0, dispatcher.queuedHandlersCount()); verifyFailure(handler); - assertEquals(FAILURE_CODE, ((Neo4jException) dispatcher.currentError()).code()); - assertEquals(FAILURE_MESSAGE, dispatcher.currentError().getMessage()); - } - - @Test - void shouldSendResetOnFailure() { - var channel = spy(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); - - dispatcher.enqueue(mock(ResponseHandler.class)); - assertEquals(1, dispatcher.queuedHandlersCount()); - - dispatcher.handleFailureMessage(FAILURE_CODE, FAILURE_MESSAGE); - - verify(channel).writeAndFlush(eq(RESET), any()); - } - - @Test - void shouldClearFailureOnSuccessOfResetAfterFailure() { - 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); - - dispatcher.enqueue(mock(ResponseHandler.class)); - assertEquals(1, dispatcher.queuedHandlersCount()); - - dispatcher.handleFailureMessage(FAILURE_CODE, FAILURE_MESSAGE); - dispatcher.handleSuccessMessage(emptyMap()); - - assertNull(dispatcher.currentError()); } @Test @@ -220,31 +156,12 @@ void shouldFailAllHandlersOnChannelError() { void shouldFailNewHandlerAfterChannelError() { var dispatcher = newDispatcher(); - var fatalError = new RuntimeException("Fatal!"); - dispatcher.handleChannelError(fatalError); - - var handler = mock(ResponseHandler.class); - dispatcher.enqueue(handler); - - verify(handler).onFailure(fatalError); - } - - @Test - void shouldAttachChannelErrorOnExistingError() { - var dispatcher = newDispatcher(); + dispatcher.handleChannelError(new RuntimeException("Fatal!")); var handler = mock(ResponseHandler.class); dispatcher.enqueue(handler); - dispatcher.handleFailureMessage("Neo.ClientError", "First error!"); - var fatalError = new RuntimeException("Second Error!"); - dispatcher.handleChannelError(fatalError); - - verify(handler) - .onFailure(argThat(error -> error instanceof ClientException - && error.getMessage().equals("First error!") - && error.getSuppressed().length == 1 - && error.getSuppressed()[0].getMessage().equals("Second Error!"))); + verify(handler).onFailure(ArgumentMatchers.any(IllegalStateException.class)); } @Test @@ -258,67 +175,6 @@ void shouldDequeHandlerOnIgnored() { assertEquals(0, dispatcher.queuedHandlersCount()); } - @Test - void shouldFailHandlerOnIgnoredMessageWithExistingError() { - 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 handler1 = mock(ResponseHandler.class); - var handler2 = mock(ResponseHandler.class); - - dispatcher.enqueue(handler1); - dispatcher.enqueue(handler2); - - dispatcher.handleFailureMessage(FAILURE_CODE, FAILURE_MESSAGE); - verifyFailure(handler1); - verify(handler2, only()).canManageAutoRead(); - - dispatcher.handleIgnoredMessage(); - verifyFailure(handler2); - } - - @Test - void shouldFailHandlerOnIgnoredMessageWhenNoErrorAndNotHandlingReset() { - var dispatcher = newDispatcher(); - var handler = mock(ResponseHandler.class); - dispatcher.enqueue(handler); - - dispatcher.handleIgnoredMessage(); - - verify(handler).onFailure(any(ClientException.class)); - } - - @Test - void shouldDequeAndFailHandlerOnIgnoredWhenErrorHappened() { - 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 handler1 = mock(ResponseHandler.class); - var handler2 = mock(ResponseHandler.class); - - dispatcher.enqueue(handler1); - dispatcher.enqueue(handler2); - dispatcher.handleFailureMessage(FAILURE_CODE, FAILURE_MESSAGE); - dispatcher.handleIgnoredMessage(); - - // "RESET after failure" handler should remain queued - assertEquals(1, dispatcher.queuedHandlersCount()); - verifyFailure(handler1); - verifyFailure(handler2); - } - @Test void shouldThrowWhenNoHandlerToHandleRecordMessage() { var dispatcher = newDispatcher(); @@ -404,16 +260,9 @@ void shouldReEnableAutoReadWhenAutoReadManagingHandlerIsRemoved() { void shouldCreateChannelActivityLoggerAndLogDebugMessageOnMessageHandling(Class message) { // 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 logging = mock(Logging.class); - var logger = mock(Logger.class); - when(logger.isDebugEnabled()).thenReturn(true); + var logging = mock(LoggingProvider.class); + var logger = mock(System.Logger.class); + when(logger.isLoggable(System.Logger.Level.DEBUG)).thenReturn(true); when(logging.getLog(InboundMessageDispatcher.class)).thenReturn(logger); var errorLogger = mock(ChannelErrorLogger.class); when(logging.getLog(ChannelErrorLogger.class)).thenReturn(errorLogger); @@ -426,26 +275,34 @@ void shouldCreateChannelActivityLoggerAndLogDebugMessageOnMessageHandling(Class< if (SuccessMessage.class.isAssignableFrom(message)) { dispatcher.handleSuccessMessage(new HashMap<>()); loggerVerification = () -> { - verify(logger).isDebugEnabled(); - verify(logger).debug(anyString(), any(Map.class)); + verify(logger).isLoggable(System.Logger.Level.DEBUG); + verify(logger) + .log(eq(System.Logger.Level.DEBUG), eq((ResourceBundle) null), anyString(), any(Map.class)); }; } else if (FailureMessage.class.isAssignableFrom(message)) { dispatcher.handleFailureMessage(FAILURE_CODE, FAILURE_MESSAGE); loggerVerification = () -> { - verify(logger).isDebugEnabled(); - verify(logger).debug(anyString(), anyString(), anyString()); + verify(logger).isLoggable(System.Logger.Level.DEBUG); + verify(logger) + .log( + eq(System.Logger.Level.DEBUG), + eq((ResourceBundle) null), + anyString(), + anyString(), + anyString()); }; } else if (RecordMessage.class.isAssignableFrom(message)) { dispatcher.handleRecordMessage(Values.values()); loggerVerification = () -> { - verify(logger, times(2)).isDebugEnabled(); - verify(logger).debug(anyString(), anyString()); + verify(logger).isLoggable(System.Logger.Level.DEBUG); + verify(logger).log(eq(System.Logger.Level.DEBUG), eq((ResourceBundle) null), anyString(), anyString()); }; } else if (IgnoredMessage.class.isAssignableFrom(message)) { dispatcher.handleIgnoredMessage(); loggerVerification = () -> { - verify(logger).isDebugEnabled(); - verify(logger).debug(anyString()); + verify(logger).isLoggable(System.Logger.Level.DEBUG); + verify(logger) + .log(eq(System.Logger.Level.DEBUG), eq((ResourceBundle) null), anyString(), eq((String) null)); }; } else { fail("Unexpected message type parameter provided"); @@ -461,12 +318,12 @@ void shouldCreateChannelActivityLoggerAndLogDebugMessageOnMessageHandling(Class< void shouldCreateChannelErrorLoggerAndLogDebugMessageOnChannelError() { // GIVEN var channel = newChannelMock(); - var logging = mock(Logging.class); - var logger = mock(Logger.class); - when(logger.isDebugEnabled()).thenReturn(true); + var logging = mock(LoggingProvider.class); + var logger = mock(System.Logger.class); + when(logger.isLoggable(System.Logger.Level.DEBUG)).thenReturn(true); when(logging.getLog(InboundMessageDispatcher.class)).thenReturn(logger); var errorLogger = mock(ChannelErrorLogger.class); - when(errorLogger.isDebugEnabled()).thenReturn(true); + when(errorLogger.isLoggable(System.Logger.Level.DEBUG)).thenReturn(true); when(logging.getLog(ChannelErrorLogger.class)).thenReturn(errorLogger); var dispatcher = new InboundMessageDispatcher(channel, logging); var handler = mock(ResponseHandler.class); @@ -479,65 +336,12 @@ void shouldCreateChannelErrorLoggerAndLogDebugMessageOnChannelError() { // THEN assertTrue(dispatcher.getLog() instanceof ChannelActivityLogger); assertTrue(dispatcher.getErrorLog() instanceof ChannelErrorLogger); - 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, TokenExpiredException.class); - assertEquals(code, ((Neo4jException) dispatcher.currentError()).code()); - assertEquals(message, dispatcher.currentError().getMessage()); - then(authTokenManager).should().handleSecurityException(authToken, (SecurityException) - dispatcher.currentError()); - } - - @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().handleSecurityException(authToken, (SecurityException) - dispatcher.currentError()); + verify(errorLogger) + .log( + eq(System.Logger.Level.DEBUG), + eq((ResourceBundle) null), + contains(throwable.getClass().toString()), + eq((String) null)); } private static void verifyFailure(ResponseHandler handler) { @@ -561,7 +365,7 @@ private static InboundMessageDispatcher newDispatcher() { } private static InboundMessageDispatcher newDispatcher(Channel channel) { - return new InboundMessageDispatcher(channel, DEV_NULL_LOGGING); + return new InboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE); } @SuppressWarnings("unchecked") diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/InboundMessageHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/InboundMessageHandlerTest.java similarity index 78% rename from driver/src/test/java/org/neo4j/driver/internal/async/inbound/InboundMessageHandlerTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/InboundMessageHandlerTest.java index 56cae1fe61..c11b0fe8e3 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/InboundMessageHandlerTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/InboundMessageHandlerTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.inbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.inbound; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.startsWith; @@ -26,8 +26,7 @@ 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.internal.messaging.request.ResetMessage.RESET; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage.RESET; import io.netty.channel.embedded.EmbeddedChannel; import io.netty.handler.codec.DecoderException; @@ -40,17 +39,17 @@ import org.mockito.ArgumentCaptor; import org.neo4j.driver.Value; import org.neo4j.driver.exceptions.Neo4jException; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.MessageFormat.Reader; -import org.neo4j.driver.internal.messaging.response.FailureMessage; -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.messaging.v3.MessageFormatV3; -import org.neo4j.driver.internal.spi.ResponseHandler; -import org.neo4j.driver.internal.util.io.MessageToByteBufWriter; -import org.neo4j.driver.internal.util.messaging.KnowledgeableMessageFormat; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.FailureMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.IgnoredMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.RecordMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.SuccessMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v3.MessageFormatV3; +import org.neo4j.driver.internal.bolt.basicimpl.spi.ResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.util.io.MessageToByteBufWriter; +import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.KnowledgeableMessageFormat; class InboundMessageHandlerTest { private EmbeddedChannel channel; @@ -60,11 +59,11 @@ class InboundMessageHandlerTest { @BeforeEach void setUp() { channel = new EmbeddedChannel(); - messageDispatcher = new InboundMessageDispatcher(channel, DEV_NULL_LOGGING); + messageDispatcher = new InboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE); writer = new MessageToByteBufWriter(new KnowledgeableMessageFormat(false)); ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); - var handler = new InboundMessageHandler(new MessageFormatV3(), DEV_NULL_LOGGING); + var handler = new InboundMessageHandler(new MessageFormatV3(), NoopLoggingProvider.INSTANCE); channel.pipeline().addFirst(handler); } @@ -124,12 +123,12 @@ void shouldReadIgnoredMessage() { @Test void shouldRethrowReadErrors() throws IOException { var messageFormat = mock(MessageFormat.class); - var reader = mock(Reader.class); + var reader = mock(MessageFormat.Reader.class); var error = new RuntimeException("Unable to decode!"); doThrow(error).when(reader).read(any()); when(messageFormat.newReader(any())).thenReturn(reader); - var handler = new InboundMessageHandler(messageFormat, DEV_NULL_LOGGING); + var handler = new InboundMessageHandler(messageFormat, NoopLoggingProvider.INSTANCE); channel.pipeline().remove(InboundMessageHandler.class); channel.pipeline().addLast(handler); diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/MessageDecoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/MessageDecoderTest.java similarity index 98% rename from driver/src/test/java/org/neo4j/driver/internal/async/inbound/MessageDecoderTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/MessageDecoderTest.java index 25b338552c..89d2bc48d2 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/MessageDecoderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/inbound/MessageDecoderTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.inbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.inbound; import static io.netty.buffer.Unpooled.wrappedBuffer; import static org.junit.jupiter.api.Assertions.assertEquals; diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/outbound/ChunkAwareByteBufOutputTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/outbound/ChunkAwareByteBufOutputTest.java similarity index 99% rename from driver/src/test/java/org/neo4j/driver/internal/async/outbound/ChunkAwareByteBufOutputTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/outbound/ChunkAwareByteBufOutputTest.java index 6dffd23811..b5b5d566d6 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/outbound/ChunkAwareByteBufOutputTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/outbound/ChunkAwareByteBufOutputTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.outbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.outbound; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.mock; diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/outbound/OutboundMessageHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/outbound/OutboundMessageHandlerTest.java similarity index 77% rename from driver/src/test/java/org/neo4j/driver/internal/async/outbound/OutboundMessageHandlerTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/outbound/OutboundMessageHandlerTest.java index 4856e3bd7f..6246b84537 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/outbound/OutboundMessageHandlerTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/async/outbound/OutboundMessageHandlerTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.outbound; +package org.neo4j.driver.internal.bolt.basicimpl.async.outbound; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -23,9 +23,7 @@ import static org.mockito.Mockito.mock; 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.internal.messaging.MessageFormat.Writer; -import static org.neo4j.driver.internal.messaging.request.PullAllMessage.PULL_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage.PULL_ALL; import static org.neo4j.driver.testutil.TestUtil.assertByteBufContains; import io.netty.buffer.ByteBuf; @@ -39,19 +37,21 @@ import org.neo4j.driver.Query; import org.neo4j.driver.Value; import org.neo4j.driver.Values; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.v3.MessageFormatV3; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v3.MessageFormatV3; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; class OutboundMessageHandlerTest { private final EmbeddedChannel channel = new EmbeddedChannel(); @BeforeEach void setUp() { - ChannelAttributes.setMessageDispatcher(channel, new InboundMessageDispatcher(channel, DEV_NULL_LOGGING)); + ChannelAttributes.setMessageDispatcher( + channel, new InboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE)); } @AfterEach @@ -109,8 +109,9 @@ private static MessageFormat mockMessageFormatWithWriter( return messageFormat; } - private static Writer mockWriter(final PackOutput output, final int... bytesToWrite) throws IOException { - var writer = mock(Writer.class); + private static MessageFormat.Writer mockWriter(final PackOutput output, final int... bytesToWrite) + throws IOException { + var writer = mock(MessageFormat.Writer.class); doAnswer(invocation -> { for (var b : bytesToWrite) { @@ -125,6 +126,6 @@ private static Writer mockWriter(final PackOutput output, final int... bytesToWr } private static OutboundMessageHandler newHandler(MessageFormat messageFormat) { - return new OutboundMessageHandler(messageFormat, DEV_NULL_LOGGING); + return new OutboundMessageHandler(messageFormat, NoopLoggingProvider.INSTANCE); } } diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/AbstractRoutingProcedureRunnerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/AbstractRoutingProcedureRunnerTest.java new file mode 100644 index 0000000000..a8a6f87dc8 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/AbstractRoutingProcedureRunnerTest.java @@ -0,0 +1,104 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.cluster; +// +// import static java.util.concurrent.CompletableFuture.failedFuture; +// import static org.junit.jupiter.api.Assertions.assertEquals; +// import static org.junit.jupiter.api.Assertions.assertFalse; +// import static org.junit.jupiter.api.Assertions.assertThrows; +// import static org.junit.jupiter.api.Assertions.assertTrue; +// import static org.mockito.Mockito.mock; +// import static org.mockito.Mockito.verify; +// import static org.mockito.Mockito.when; +// import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +// import static org.neo4j.driver.internal.util.Futures.completedWithNull; +// import static org.neo4j.driver.testutil.TestUtil.await; +// +// import java.util.Collections; +// import java.util.List; +// import java.util.concurrent.CompletionStage; +// import org.junit.jupiter.api.Test; +// import org.neo4j.driver.Record; +// import org.neo4j.driver.exceptions.ClientException; +// +// abstract class AbstractRoutingProcedureRunnerTest { +// @Test +// void shouldReturnFailedResponseOnClientException() { +// var error = new ClientException("Hi"); +// var runner = singleDatabaseRoutingProcedureRunner(failedFuture(error)); +// +// var response = await(runner.run(connection(), defaultDatabase(), Collections.emptySet(), null)); +// +// assertFalse(response.isSuccess()); +// assertEquals(error, response.error()); +// } +// +// @Test +// void shouldReturnFailedStageOnError() { +// var error = new Exception("Hi"); +// var runner = singleDatabaseRoutingProcedureRunner(failedFuture(error)); +// +// var e = assertThrows( +// Exception.class, +// () -> await(runner.run(connection(), defaultDatabase(), Collections.emptySet(), null))); +// assertEquals(error, e); +// } +// +// @Test +// void shouldReleaseConnectionOnSuccess() { +// var runner = singleDatabaseRoutingProcedureRunner(); +// +// var connection = connection(); +// var response = await(runner.run(connection, defaultDatabase(), Collections.emptySet(), null)); +// +// assertTrue(response.isSuccess()); +// verify(connection).release(); +// } +// +// @Test +// void shouldPropagateReleaseError() { +// var runner = singleDatabaseRoutingProcedureRunner(); +// +// var releaseError = new RuntimeException("Release failed"); +// var connection = connection(failedFuture(releaseError)); +// +// var e = assertThrows( +// RuntimeException.class, +// () -> await(runner.run(connection, defaultDatabase(), Collections.emptySet(), null))); +// assertEquals(releaseError, e); +// verify(connection).release(); +// } +// +// abstract SingleDatabaseRoutingProcedureRunner singleDatabaseRoutingProcedureRunner(); +// +// abstract SingleDatabaseRoutingProcedureRunner singleDatabaseRoutingProcedureRunner( +// CompletionStage> runProcedureResult); +// +// static Connection connection() { +// return connection(completedWithNull()); +// } +// +// static Connection connection(CompletionStage releaseStage) { +// var connection = mock(Connection.class); +// var boltProtocol = mock(BoltProtocol.class); +// var protocolVersion = new BoltProtocolVersion(4, 4); +// when(boltProtocol.version()).thenReturn(protocolVersion); +// when(connection.protocol()).thenReturn(boltProtocol); +// when(connection.release()).thenReturn(releaseStage); +// return connection; +// } +// } diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/MultiDatabasesRoutingProcedureRunnerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/MultiDatabasesRoutingProcedureRunnerTest.java new file mode 100644 index 0000000000..405ff03219 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/MultiDatabasesRoutingProcedureRunnerTest.java @@ -0,0 +1,126 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.cluster; +// +// import static java.util.Collections.singletonList; +// import static java.util.concurrent.CompletableFuture.completedFuture; +// import static org.hamcrest.MatcherAssert.assertThat; +// import static org.hamcrest.Matchers.equalTo; +// import static org.hamcrest.core.IsInstanceOf.instanceOf; +// import static org.junit.jupiter.api.Assertions.assertEquals; +// import static org.junit.jupiter.api.Assertions.assertTrue; +// import static org.mockito.Mockito.mock; +// import static org.neo4j.driver.Values.parameters; +// import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.SYSTEM_DATABASE_NAME; +// import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +// import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.systemDatabase; +// import static org.neo4j.driver.testutil.TestUtil.await; +// +// import java.net.URI; +// import java.util.Collections; +// import java.util.List; +// import java.util.Map; +// import java.util.Set; +// import java.util.concurrent.CompletionStage; +// import org.junit.jupiter.params.ParameterizedTest; +// import org.junit.jupiter.params.provider.ValueSource; +// import org.neo4j.driver.AccessMode; +// import org.neo4j.driver.Bookmark; +// import org.neo4j.driver.Logging; +// import org.neo4j.driver.Query; +// import org.neo4j.driver.Record; +// import org.neo4j.driver.internal.bolt.api.RoutingContext; +// +// class MultiDatabasesRoutingProcedureRunnerTest extends AbstractRoutingProcedureRunnerTest { +// @ParameterizedTest +// @ValueSource(strings = {"", SYSTEM_DATABASE_NAME, " this is a db name "}) +// void shouldCallGetRoutingTableWithEmptyMapOnSystemDatabaseForDatabase(String db) { +// var runner = new TestRoutingProcedureRunner(RoutingContext.EMPTY); +// var response = await(runner.run(connection(), database(db), Collections.emptySet(), null)); +// +// assertTrue(response.isSuccess()); +// assertEquals(1, response.records().size()); +// +// assertThat(runner.bookmarks, instanceOf(Set.class)); +// assertThat(runner.connection.databaseName(), equalTo(systemDatabase())); +// assertThat(runner.connection.mode(), equalTo(AccessMode.READ)); +// +// var query = generateMultiDatabaseRoutingQuery(Collections.emptyMap(), db); +// assertThat(runner.procedure, equalTo(query)); +// } +// +// @ParameterizedTest +// @ValueSource(strings = {"", SYSTEM_DATABASE_NAME, " this is a db name "}) +// void shouldCallGetRoutingTableWithParamOnSystemDatabaseForDatabase(String db) { +// var uri = URI.create("neo4j://localhost/?key1=value1&key2=value2"); +// var context = new RoutingContext(uri); +// +// var runner = new TestRoutingProcedureRunner(context); +// var response = await(runner.run(connection(), database(db), Collections.emptySet(), null)); +// +// assertTrue(response.isSuccess()); +// assertEquals(1, response.records().size()); +// +// assertThat(runner.bookmarks, instanceOf(Set.class)); +// assertThat(runner.connection.databaseName(), equalTo(systemDatabase())); +// assertThat(runner.connection.mode(), equalTo(AccessMode.READ)); +// +// var query = generateMultiDatabaseRoutingQuery(context.toMap(), db); +// assertThat(response.procedure(), equalTo(query)); +// assertThat(runner.procedure, equalTo(query)); +// } +// +// @Override +// SingleDatabaseRoutingProcedureRunner singleDatabaseRoutingProcedureRunner() { +// return new TestRoutingProcedureRunner(RoutingContext.EMPTY); +// } +// +// @Override +// SingleDatabaseRoutingProcedureRunner singleDatabaseRoutingProcedureRunner( +// CompletionStage> runProcedureResult) { +// return new TestRoutingProcedureRunner(RoutingContext.EMPTY, runProcedureResult); +// } +// +// private static Query generateMultiDatabaseRoutingQuery(Map context, String db) { +// var parameters = parameters(ROUTING_CONTEXT, context, DATABASE_NAME, db); +// return new Query(MULTI_DB_GET_ROUTING_TABLE, parameters); +// } +// +// private static class TestRoutingProcedureRunner extends MultiDatabasesRoutingProcedureRunner { +// final CompletionStage> runProcedureResult; +// private Connection connection; +// private Query procedure; +// private Set bookmarks; +// +// TestRoutingProcedureRunner(RoutingContext context) { +// this(context, completedFuture(singletonList(mock(Record.class)))); +// } +// +// TestRoutingProcedureRunner(RoutingContext context, CompletionStage> runProcedureResult) { +// super(context, Logging.none()); +// this.runProcedureResult = runProcedureResult; +// } +// +// @Override +// CompletionStage> runProcedure(Connection connection, Query procedure, Set bookmarks) { +// this.connection = connection; +// this.procedure = procedure; +// this.bookmarks = bookmarks; +// return runProcedureResult; +// } +// } +// } diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/RouteMessageRoutingProcedureRunnerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/RouteMessageRoutingProcedureRunnerTest.java new file mode 100644 index 0000000000..db11c760da --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/RouteMessageRoutingProcedureRunnerTest.java @@ -0,0 +1,150 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.cluster; +// +// import static org.junit.jupiter.api.Assertions.assertEquals; +// import static org.junit.jupiter.api.Assertions.assertFalse; +// import static org.junit.jupiter.api.Assertions.assertNotNull; +// import static org.junit.jupiter.api.Assertions.assertThrows; +// import static org.junit.jupiter.api.Assertions.assertTrue; +// import static org.mockito.ArgumentMatchers.eq; +// import static org.mockito.Mockito.doReturn; +// import static org.mockito.Mockito.mock; +// import static org.mockito.Mockito.verify; +// +// import java.net.URI; +// import java.util.ArrayList; +// import java.util.HashMap; +// import java.util.List; +// import java.util.Map; +// import java.util.concurrent.CompletableFuture; +// import java.util.stream.Collectors; +// import java.util.stream.Stream; +// import org.junit.jupiter.api.Test; +// import org.junit.jupiter.params.ParameterizedTest; +// import org.junit.jupiter.params.provider.Arguments; +// import org.junit.jupiter.params.provider.MethodSource; +// import org.neo4j.driver.Value; +// import org.neo4j.driver.Values; +// import org.neo4j.driver.internal.bolt.api.DatabaseName; +// import org.neo4j.driver.internal.bolt.api.DatabaseNameUtil; +// import org.neo4j.driver.internal.bolt.api.RoutingContext; +// import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; +// import org.neo4j.driver.testutil.TestUtil; +// +// class RouteMessageRoutingProcedureRunnerTest { +// +// private static Stream shouldRequestRoutingTableForAllValidInputScenarios() { +// return Stream.of( +// Arguments.arguments(RoutingContext.EMPTY, DatabaseNameUtil.defaultDatabase()), +// Arguments.arguments(RoutingContext.EMPTY, DatabaseNameUtil.systemDatabase()), +// Arguments.arguments(RoutingContext.EMPTY, DatabaseNameUtil.database("neo4j")), +// Arguments.arguments( +// new RoutingContext(URI.create("localhost:17601")), DatabaseNameUtil.defaultDatabase()), +// Arguments.arguments( +// new RoutingContext(URI.create("localhost:17602")), DatabaseNameUtil.systemDatabase()), +// Arguments.arguments( +// new RoutingContext(URI.create("localhost:17603")), DatabaseNameUtil.database("neo4j"))); +// } +// +// @ParameterizedTest +// @MethodSource +// void shouldRequestRoutingTableForAllValidInputScenarios(RoutingContext routingContext, DatabaseName databaseName) +// { +// var routingTable = getRoutingTable(); +// var completableFuture = CompletableFuture.completedFuture(routingTable); +// var runner = new RouteMessageRoutingProcedureRunner(routingContext, () -> completableFuture); +// var connection = mock(Connection.class); +// CompletableFuture releaseConnectionFuture = CompletableFuture.completedFuture(null); +// doReturn(releaseConnectionFuture).when(connection).release(); +// +// var response = TestUtil.await(runner.run(connection, databaseName, null, null)); +// +// assertNotNull(response); +// assertTrue(response.isSuccess()); +// assertNotNull(response.procedure()); +// assertEquals(1, response.records().size()); +// assertNotNull(response.records().get(0)); +// +// var record = response.records().get(0); +// assertEquals(routingTable.get("ttl"), record.get("ttl")); +// assertEquals(routingTable.get("servers"), record.get("servers")); +// +// verifyMessageWasWrittenAndFlushed(connection, completableFuture, routingContext, databaseName); +// verify(connection).release(); +// } +// +// @Test +// void shouldReturnFailureWhenSomethingHappensGettingTheRoutingTable() { +// Throwable reason = new RuntimeException("Some error"); +// var completableFuture = new CompletableFuture>(); +// completableFuture.completeExceptionally(reason); +// var runner = new RouteMessageRoutingProcedureRunner(RoutingContext.EMPTY, () -> completableFuture); +// var connection = mock(Connection.class); +// CompletableFuture releaseConnectionFuture = CompletableFuture.completedFuture(null); +// doReturn(releaseConnectionFuture).when(connection).release(); +// +// var response = TestUtil.await(runner.run(connection, DatabaseNameUtil.defaultDatabase(), null, null)); +// +// assertNotNull(response); +// assertFalse(response.isSuccess()); +// assertNotNull(response.procedure()); +// assertEquals(reason, response.error()); +// assertThrows(IllegalStateException.class, () -> response.records().size()); +// +// verifyMessageWasWrittenAndFlushed( +// connection, completableFuture, RoutingContext.EMPTY, DatabaseNameUtil.defaultDatabase()); +// verify(connection).release(); +// } +// +// private void verifyMessageWasWrittenAndFlushed( +// Connection connection, +// CompletableFuture> completableFuture, +// RoutingContext routingContext, +// DatabaseName databaseName) { +// var context = routingContext.toMap().entrySet().stream() +// .collect(Collectors.toMap(Map.Entry::getKey, entry -> Values.value(entry.getValue()))); +// +// verify(connection) +// .writeAndFlush( +// eq(new RouteMessage( +// context, null, databaseName.databaseName().orElse(null), null)), +// eq(new RouteMessageResponseHandler(completableFuture))); +// } +// +// private Map getRoutingTable() { +// Map routingTable = new HashMap<>(); +// routingTable.put("ttl", Values.value(300)); +// routingTable.put("servers", Values.value(getServers())); +// return routingTable; +// } +// +// private List> getServers() { +// List> servers = new ArrayList<>(); +// servers.add(getServer("WRITE", "localhost:17601")); +// servers.add(getServer("READ", "localhost:17601", "localhost:17602", "localhost:17603")); +// servers.add(getServer("ROUTE", "localhost:17601", "localhost:17602", "localhost:17603")); +// return servers; +// } +// +// private Map getServer(String role, String... addresses) { +// Map server = new HashMap<>(); +// server.put("role", Values.value(role)); +// server.put("addresses", Values.value(addresses)); +// return server; +// } +// } diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/RoutingProcedureClusterCompositionProviderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/RoutingProcedureClusterCompositionProviderTest.java new file mode 100644 index 0000000000..b7601fc7cd --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/RoutingProcedureClusterCompositionProviderTest.java @@ -0,0 +1,415 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.cluster; +// +// import static java.util.Arrays.asList; +// import static java.util.concurrent.CompletableFuture.completedFuture; +// import static org.hamcrest.MatcherAssert.assertThat; +// import static org.hamcrest.Matchers.containsString; +// import static org.junit.jupiter.api.Assertions.assertEquals; +// import static org.junit.jupiter.api.Assertions.assertThrows; +// import static org.mockito.ArgumentMatchers.any; +// import static org.mockito.ArgumentMatchers.eq; +// import static org.mockito.Mockito.mock; +// 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.util.Futures.completedWithNull; +// import static org.neo4j.driver.testutil.TestUtil.await; +// +// import java.time.Clock; +// import java.util.Arrays; +// import java.util.Collections; +// import java.util.HashMap; +// import java.util.Map; +// import java.util.Set; +// import java.util.stream.Collectors; +// import org.junit.jupiter.api.Test; +// import org.neo4j.driver.Query; +// import org.neo4j.driver.Record; +// import org.neo4j.driver.Value; +// import org.neo4j.driver.exceptions.ProtocolException; +// import org.neo4j.driver.exceptions.ServiceUnavailableException; +// import org.neo4j.driver.internal.InternalRecord; +// import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; +// import org.neo4j.driver.internal.value.StringValue; +// +// class RoutingProcedureClusterCompositionProviderTest { +// @Test +// void shouldProtocolErrorWhenNoRecord() { +// // Given +// var mockedRunner = newProcedureRunnerMock(); +// var connection = mock(Connection.class); +// ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection); +// +// var noRecordsResponse = newRoutingResponse(); +// when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) +// .thenReturn(completedFuture(noRecordsResponse)); +// +// // When & Then +// var error = assertThrows( +// ProtocolException.class, +// () -> await( +// provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); +// assertThat(error.getMessage(), containsString("records received '0' is too few or too many.")); +// } +// +// @Test +// void shouldProtocolErrorWhenMoreThanOneRecord() { +// // Given +// var mockedRunner = newProcedureRunnerMock(); +// var connection = mock(Connection.class); +// ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection); +// +// Record aRecord = new InternalRecord(asList("key1", "key2"), new Value[] {new StringValue("a value")}); +// var routingResponse = newRoutingResponse(aRecord, aRecord); +// when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) +// .thenReturn(completedFuture(routingResponse)); +// +// // When +// var error = assertThrows( +// ProtocolException.class, +// () -> await( +// provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); +// assertThat(error.getMessage(), containsString("records received '2' is too few or too many.")); +// } +// +// @Test +// void shouldProtocolErrorWhenUnparsableRecord() { +// // Given +// var mockedRunner = newProcedureRunnerMock(); +// var connection = mock(Connection.class); +// ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection); +// +// Record aRecord = new InternalRecord(asList("key1", "key2"), new Value[] {new StringValue("a value")}); +// var routingResponse = newRoutingResponse(aRecord); +// when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) +// .thenReturn(completedFuture(routingResponse)); +// +// // When +// var error = assertThrows( +// ProtocolException.class, +// () -> await( +// provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); +// assertThat(error.getMessage(), containsString("unparsable record received.")); +// } +// +// @Test +// void shouldProtocolErrorWhenNoRouters() { +// // Given +// var mockedRunner = newMultiDBProcedureRunnerMock(); +// var connection = mock(Connection.class); +// var mockedClock = mock(Clock.class); +// ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection, mockedClock); +// +// Record record = new InternalRecord(asList("ttl", "servers"), new Value[] { +// value(100), value(asList(serverInfo("READ", "one:1337", "two:1337"), serverInfo("WRITE", "one:1337"))) +// }); +// var routingResponse = newRoutingResponse(record); +// when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) +// .thenReturn(completedFuture(routingResponse)); +// when(mockedClock.millis()).thenReturn(12345L); +// +// // When +// var error = assertThrows( +// ProtocolException.class, +// () -> await( +// provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); +// assertThat(error.getMessage(), containsString("no router or reader found in response.")); +// } +// +// @Test +// void routeMessageRoutingProcedureShouldProtocolErrorWhenNoRouters() { +// // Given +// var mockedRunner = newRouteMessageRoutingProcedureRunnerMock(); +// var connection = mock(Connection.class); +// var mockedClock = mock(Clock.class); +// ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection, mockedClock); +// +// Record record = new InternalRecord(asList("ttl", "servers"), new Value[] { +// value(100), value(asList(serverInfo("READ", "one:1337", "two:1337"), serverInfo("WRITE", "one:1337"))) +// }); +// var routingResponse = newRoutingResponse(record); +// when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) +// .thenReturn(completedFuture(routingResponse)); +// when(mockedClock.millis()).thenReturn(12345L); +// +// // When +// var error = assertThrows( +// ProtocolException.class, +// () -> await( +// provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); +// assertThat(error.getMessage(), containsString("no router or reader found in response.")); +// } +// +// @Test +// void shouldProtocolErrorWhenNoReaders() { +// // Given +// var mockedRunner = newMultiDBProcedureRunnerMock(); +// var connection = mock(Connection.class); +// var mockedClock = mock(Clock.class); +// ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection, mockedClock); +// +// Record record = new InternalRecord(asList("ttl", "servers"), new Value[] { +// value(100), value(asList(serverInfo("WRITE", "one:1337"), serverInfo("ROUTE", "one:1337", "two:1337"))) +// }); +// var routingResponse = newRoutingResponse(record); +// when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) +// .thenReturn(completedFuture(routingResponse)); +// when(mockedClock.millis()).thenReturn(12345L); +// +// // When +// var error = assertThrows( +// ProtocolException.class, +// () -> await( +// provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); +// assertThat(error.getMessage(), containsString("no router or reader found in response.")); +// } +// +// @Test +// void routeMessageRoutingProcedureShouldProtocolErrorWhenNoReaders() { +// // Given +// var mockedRunner = newRouteMessageRoutingProcedureRunnerMock(); +// var connection = mock(Connection.class); +// var mockedClock = mock(Clock.class); +// ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection, mockedClock); +// +// Record record = new InternalRecord(asList("ttl", "servers"), new Value[] { +// value(100), value(asList(serverInfo("WRITE", "one:1337"), serverInfo("ROUTE", "one:1337", "two:1337"))) +// }); +// var routingResponse = newRoutingResponse(record); +// when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) +// .thenReturn(completedFuture(routingResponse)); +// when(mockedClock.millis()).thenReturn(12345L); +// +// // When +// var error = assertThrows( +// ProtocolException.class, +// () -> await( +// provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); +// assertThat(error.getMessage(), containsString("no router or reader found in response.")); +// } +// +// @Test +// void shouldPropagateConnectionFailureExceptions() { +// // Given +// var mockedRunner = newProcedureRunnerMock(); +// var connection = mock(Connection.class); +// ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection); +// +// when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) +// .thenReturn(failedFuture(new ServiceUnavailableException("Connection breaks during cypher +// execution"))); +// +// // When & Then +// var e = assertThrows( +// ServiceUnavailableException.class, +// () -> await( +// provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); +// assertThat(e.getMessage(), containsString("Connection breaks during cypher execution")); +// } +// +// @Test +// void shouldReturnSuccessResultWhenNoError() { +// // Given +// var mockedClock = mock(Clock.class); +// var connection = mock(Connection.class); +// var mockedRunner = newMultiDBProcedureRunnerMock(); +// ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection, mockedClock); +// +// Record record = new InternalRecord(asList("ttl", "servers"), new Value[] { +// value(100), +// value(asList( +// serverInfo("READ", "one:1337", "two:1337"), +// serverInfo("WRITE", "one:1337"), +// serverInfo("ROUTE", "one:1337", "two:1337"))) +// }); +// var routingResponse = newRoutingResponse(record); +// when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) +// .thenReturn(completedFuture(routingResponse)); +// when(mockedClock.millis()).thenReturn(12345L); +// +// // When +// var cluster = +// await(provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null)); +// +// // Then +// assertEquals(12345 + 100_000, cluster.expirationTimestamp()); +// assertEquals(serverSet("one:1337", "two:1337"), cluster.readers()); +// assertEquals(serverSet("one:1337"), cluster.writers()); +// assertEquals(serverSet("one:1337", "two:1337"), cluster.routers()); +// } +// +// @Test +// void routeMessageRoutingProcedureShouldReturnSuccessResultWhenNoError() { +// // Given +// var mockedClock = mock(Clock.class); +// var connection = mock(Connection.class); +// var mockedRunner = newRouteMessageRoutingProcedureRunnerMock(); +// ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection, mockedClock); +// +// Record record = new InternalRecord(asList("ttl", "servers"), new Value[] { +// value(100), +// value(asList( +// serverInfo("READ", "one:1337", "two:1337"), +// serverInfo("WRITE", "one:1337"), +// serverInfo("ROUTE", "one:1337", "two:1337"))) +// }); +// var routingResponse = newRoutingResponse(record); +// when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) +// .thenReturn(completedFuture(routingResponse)); +// when(mockedClock.millis()).thenReturn(12345L); +// +// // When +// var cluster = +// await(provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null)); +// +// // Then +// assertEquals(12345 + 100_000, cluster.expirationTimestamp()); +// assertEquals(serverSet("one:1337", "two:1337"), cluster.readers()); +// assertEquals(serverSet("one:1337"), cluster.writers()); +// assertEquals(serverSet("one:1337", "two:1337"), cluster.routers()); +// } +// +// @Test +// void shouldReturnFailureWhenProcedureRunnerFails() { +// var procedureRunner = newProcedureRunnerMock(); +// var connection = mock(Connection.class); +// +// var error = new RuntimeException("hi"); +// when(procedureRunner.run(eq(connection), any(DatabaseName.class), any(), any())) +// .thenReturn(completedFuture(newRoutingResponse(error))); +// +// var provider = newClusterCompositionProvider(procedureRunner, connection); +// +// var e = assertThrows( +// RuntimeException.class, +// () -> await( +// provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); +// assertEquals(error, e); +// } +// +// @Test +// void shouldUseMultiDBProcedureRunnerWhenConnectingWith40Server() { +// var procedureRunner = newMultiDBProcedureRunnerMock(); +// var connection = mock(Connection.class); +// +// var provider = newClusterCompositionProvider(procedureRunner, connection); +// +// when(procedureRunner.run(eq(connection), any(DatabaseName.class), any(), any())) +// .thenReturn(completedWithNull()); +// provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null); +// +// verify(procedureRunner).run(eq(connection), any(DatabaseName.class), any(), any()); +// } +// +// @Test +// void shouldUseProcedureRunnerWhenConnectingWith35AndPreviousServers() { +// var procedureRunner = newProcedureRunnerMock(); +// var connection = mock(Connection.class); +// +// var provider = newClusterCompositionProvider(procedureRunner, connection); +// +// when(procedureRunner.run(eq(connection), any(DatabaseName.class), any(), any())) +// .thenReturn(completedWithNull()); +// provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null); +// +// verify(procedureRunner).run(eq(connection), any(DatabaseName.class), any(), any()); +// } +// +// @Test +// void shouldUseRouteMessageProcedureRunnerWhenConnectingWithProtocol43() { +// var procedureRunner = newRouteMessageRoutingProcedureRunnerMock(); +// var connection = mock(Connection.class); +// +// var provider = newClusterCompositionProvider(procedureRunner, connection); +// +// when(procedureRunner.run(eq(connection), any(DatabaseName.class), any(), any())) +// .thenReturn(completedWithNull()); +// provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null); +// +// verify(procedureRunner).run(eq(connection), any(DatabaseName.class), any(), any()); +// } +// +// private static Map serverInfo(String role, String... addresses) { +// Map map = new HashMap<>(); +// map.put("role", role); +// map.put("addresses", asList(addresses)); +// return map; +// } +// +// private static Set serverSet(String... addresses) { +// return Arrays.stream(addresses).map(BoltServerAddress::new).collect(Collectors.toSet()); +// } +// +// private static SingleDatabaseRoutingProcedureRunner newProcedureRunnerMock() { +// return mock(SingleDatabaseRoutingProcedureRunner.class); +// } +// +// private static MultiDatabasesRoutingProcedureRunner newMultiDBProcedureRunnerMock() { +// return mock(MultiDatabasesRoutingProcedureRunner.class); +// } +// +// private static RouteMessageRoutingProcedureRunner newRouteMessageRoutingProcedureRunnerMock() { +// return mock(RouteMessageRoutingProcedureRunner.class); +// } +// +// private static RoutingProcedureResponse newRoutingResponse(Record... records) { +// return new RoutingProcedureResponse(new Query("procedure"), asList(records)); +// } +// +// private static RoutingProcedureResponse newRoutingResponse(Throwable error) { +// return new RoutingProcedureResponse(new Query("procedure"), error); +// } +// +// private static RoutingProcedureClusterCompositionProvider newClusterCompositionProvider( +// SingleDatabaseRoutingProcedureRunner runner, Connection connection) { +// when(connection.protocol()).thenReturn(BoltProtocolV3.INSTANCE); +// return new RoutingProcedureClusterCompositionProvider( +// mock(Clock.class), +// runner, +// newMultiDBProcedureRunnerMock(), +// newRouteMessageRoutingProcedureRunnerMock()); +// } +// +// private static RoutingProcedureClusterCompositionProvider newClusterCompositionProvider( +// MultiDatabasesRoutingProcedureRunner runner, Connection connection) { +// when(connection.protocol()).thenReturn(BoltProtocolV4.INSTANCE); +// return new RoutingProcedureClusterCompositionProvider( +// mock(Clock.class), newProcedureRunnerMock(), runner, newRouteMessageRoutingProcedureRunnerMock()); +// } +// +// private static RoutingProcedureClusterCompositionProvider newClusterCompositionProvider( +// MultiDatabasesRoutingProcedureRunner runner, Connection connection, Clock clock) { +// when(connection.protocol()).thenReturn(BoltProtocolV4.INSTANCE); +// return new RoutingProcedureClusterCompositionProvider( +// clock, newProcedureRunnerMock(), runner, newRouteMessageRoutingProcedureRunnerMock()); +// } +// +// private static RoutingProcedureClusterCompositionProvider newClusterCompositionProvider( +// RouteMessageRoutingProcedureRunner runner, Connection connection) { +// +// return newClusterCompositionProvider(runner, connection, mock(Clock.class)); +// } +// +// private static RoutingProcedureClusterCompositionProvider newClusterCompositionProvider( +// RouteMessageRoutingProcedureRunner runner, Connection connection, Clock clock) { +// when(connection.protocol()).thenReturn(BoltProtocolV43.INSTANCE); +// return new RoutingProcedureClusterCompositionProvider( +// clock, newProcedureRunnerMock(), newMultiDBProcedureRunnerMock(), runner); +// } +// } diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/RoutingProcedureResponseTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/RoutingProcedureResponseTest.java new file mode 100644 index 0000000000..0830599413 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/RoutingProcedureResponseTest.java @@ -0,0 +1,86 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.cluster; +// +// import static java.util.Arrays.asList; +// import static org.junit.jupiter.api.Assertions.assertEquals; +// import static org.junit.jupiter.api.Assertions.assertFalse; +// import static org.junit.jupiter.api.Assertions.assertThrows; +// import static org.junit.jupiter.api.Assertions.assertTrue; +// +// import org.junit.jupiter.api.Test; +// import org.neo4j.driver.Query; +// import org.neo4j.driver.Record; +// import org.neo4j.driver.Value; +// import org.neo4j.driver.internal.InternalRecord; +// import org.neo4j.driver.internal.value.StringValue; +// +// class RoutingProcedureResponseTest { +// private static final Query PROCEDURE = new Query("procedure"); +// +// private static final Record RECORD_1 = +// new InternalRecord(asList("a", "b"), new Value[] {new StringValue("a"), new StringValue("b")}); +// private static final Record RECORD_2 = +// new InternalRecord(asList("a", "b"), new Value[] {new StringValue("aa"), new StringValue("bb")}); +// +// @Test +// void shouldBeSuccessfulWithRecords() { +// var response = new RoutingProcedureResponse(PROCEDURE, asList(RECORD_1, RECORD_2)); +// assertTrue(response.isSuccess()); +// } +// +// @Test +// void shouldNotBeSuccessfulWithError() { +// var response = new RoutingProcedureResponse(PROCEDURE, new RuntimeException()); +// assertFalse(response.isSuccess()); +// } +// +// @Test +// void shouldThrowWhenFailedAndAskedForRecords() { +// var error = new RuntimeException(); +// var response = new RoutingProcedureResponse(PROCEDURE, error); +// +// var e = assertThrows(IllegalStateException.class, response::records); +// assertEquals(e.getCause(), error); +// } +// +// @Test +// void shouldThrowWhenSuccessfulAndAskedForError() { +// var response = new RoutingProcedureResponse(PROCEDURE, asList(RECORD_1, RECORD_2)); +// +// assertThrows(IllegalStateException.class, response::error); +// } +// +// @Test +// void shouldHaveErrorWhenFailed() { +// var error = new RuntimeException("Hi!"); +// var response = new RoutingProcedureResponse(PROCEDURE, error); +// assertEquals(error, response.error()); +// } +// +// @Test +// void shouldHaveRecordsWhenSuccessful() { +// var response = new RoutingProcedureResponse(PROCEDURE, asList(RECORD_1, RECORD_2)); +// assertEquals(asList(RECORD_1, RECORD_2), response.records()); +// } +// +// @Test +// void shouldHaveProcedure() { +// var response = new RoutingProcedureResponse(PROCEDURE, asList(RECORD_1, RECORD_2)); +// assertEquals(PROCEDURE, response.procedure()); +// } +// } diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/SingleDatabaseRoutingProcedureRunnerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/SingleDatabaseRoutingProcedureRunnerTest.java new file mode 100644 index 0000000000..0ea48cebe9 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/cluster/SingleDatabaseRoutingProcedureRunnerTest.java @@ -0,0 +1,136 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.cluster; +// +// import static java.util.Collections.singletonList; +// import static java.util.concurrent.CompletableFuture.completedFuture; +// import static org.hamcrest.MatcherAssert.assertThat; +// import static org.hamcrest.Matchers.equalTo; +// 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.Mockito.mock; +// import static org.neo4j.driver.Values.parameters; +// import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +// import static org.neo4j.driver.testutil.TestUtil.await; +// +// import java.net.URI; +// import java.util.Collections; +// import java.util.List; +// import java.util.Map; +// import java.util.Set; +// import java.util.concurrent.CompletionStage; +// import java.util.stream.Stream; +// import org.junit.jupiter.api.Test; +// import org.junit.jupiter.params.ParameterizedTest; +// import org.junit.jupiter.params.provider.MethodSource; +// import org.neo4j.driver.AccessMode; +// import org.neo4j.driver.Bookmark; +// import org.neo4j.driver.Logging; +// import org.neo4j.driver.Query; +// import org.neo4j.driver.Record; +// import org.neo4j.driver.exceptions.FatalDiscoveryException; +// import org.neo4j.driver.internal.bolt.api.RoutingContext; +// +// class SingleDatabaseRoutingProcedureRunnerTest extends AbstractRoutingProcedureRunnerTest { +// @Test +// void shouldCallGetRoutingTableWithEmptyMap() { +// var runner = new TestRoutingProcedureRunner(RoutingContext.EMPTY); +// var response = await(runner.run(connection(), defaultDatabase(), Collections.emptySet(), null)); +// +// assertTrue(response.isSuccess()); +// assertEquals(1, response.records().size()); +// +// assertThat(runner.bookmarks, equalTo(Collections.emptySet())); +// assertThat(runner.connection.databaseName(), equalTo(defaultDatabase())); +// assertThat(runner.connection.mode(), equalTo(AccessMode.WRITE)); +// +// var query = generateRoutingQuery(Collections.emptyMap()); +// assertThat(runner.procedure, equalTo(query)); +// } +// +// @Test +// void shouldCallGetRoutingTableWithParam() { +// var uri = URI.create("neo4j://localhost/?key1=value1&key2=value2"); +// var context = new RoutingContext(uri); +// +// var runner = new TestRoutingProcedureRunner(context); +// var response = await(runner.run(connection(), defaultDatabase(), Collections.emptySet(), null)); +// +// assertTrue(response.isSuccess()); +// assertEquals(1, response.records().size()); +// +// assertThat(runner.bookmarks, equalTo(Collections.emptySet())); +// assertThat(runner.connection.databaseName(), equalTo(defaultDatabase())); +// assertThat(runner.connection.mode(), equalTo(AccessMode.WRITE)); +// +// var query = generateRoutingQuery(context.toMap()); +// assertThat(response.procedure(), equalTo(query)); +// assertThat(runner.procedure, equalTo(query)); +// } +// +// @ParameterizedTest +// @MethodSource("invalidDatabaseNames") +// void shouldErrorWhenDatabaseIsNotAbsent(String db) { +// var runner = new TestRoutingProcedureRunner(RoutingContext.EMPTY); +// assertThrows( +// FatalDiscoveryException.class, +// () -> await(runner.run(connection(), database(db), Collections.emptySet(), null))); +// } +// +// SingleDatabaseRoutingProcedureRunner singleDatabaseRoutingProcedureRunner() { +// return new TestRoutingProcedureRunner(RoutingContext.EMPTY); +// } +// +// SingleDatabaseRoutingProcedureRunner singleDatabaseRoutingProcedureRunner( +// CompletionStage> runProcedureResult) { +// return new TestRoutingProcedureRunner(RoutingContext.EMPTY, runProcedureResult); +// } +// +// private static Stream invalidDatabaseNames() { +// return Stream.of(SYSTEM_DATABASE_NAME, "This is a string", "null"); +// } +// +// private static Query generateRoutingQuery(Map context) { +// var parameters = parameters(ROUTING_CONTEXT, context); +// return new Query(GET_ROUTING_TABLE, parameters); +// } +// +// private static class TestRoutingProcedureRunner extends SingleDatabaseRoutingProcedureRunner { +// final CompletionStage> runProcedureResult; +// private Connection connection; +// private Query procedure; +// private Set bookmarks; +// +// TestRoutingProcedureRunner(RoutingContext context) { +// this(context, completedFuture(singletonList(mock(Record.class)))); +// } +// +// TestRoutingProcedureRunner(RoutingContext context, CompletionStage> runProcedureResult) { +// super(context, Logging.none()); +// this.runProcedureResult = runProcedureResult; +// } +// +// @Override +// CompletionStage> runProcedure(Connection connection, Query procedure, Set bookmarks) { +// this.connection = connection; +// this.procedure = procedure; +// this.bookmarks = bookmarks; +// return runProcedureResult; +// } +// } +// } diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/CommitTxResponseHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/CommitTxResponseHandlerTest.java similarity index 82% rename from driver/src/test/java/org/neo4j/driver/internal/handlers/CommitTxResponseHandlerTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/CommitTxResponseHandlerTest.java index cabb1cf34a..487d2d2074 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/handlers/CommitTxResponseHandlerTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/CommitTxResponseHandlerTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers; +package org.neo4j.driver.internal.bolt.basicimpl.handlers; import static java.util.Collections.emptyMap; import static java.util.Collections.singletonMap; @@ -26,18 +26,16 @@ import java.util.concurrent.CompletableFuture; import org.junit.jupiter.api.Test; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.InternalBookmark; class CommitTxResponseHandlerTest { - private final CompletableFuture future = new CompletableFuture<>(); + private final CompletableFuture future = new CompletableFuture<>(); private final CommitTxResponseHandler handler = new CommitTxResponseHandler(future); @Test void shouldHandleSuccessWithoutBookmark() { handler.onSuccess(emptyMap()); - assertEquals(new DatabaseBookmark(null, null), await(future)); + assertEquals(null, await(future)); } @Test @@ -46,7 +44,7 @@ void shouldHandleSuccessWithBookmark() { handler.onSuccess(singletonMap("bookmark", value(bookmarkString))); - assertEquals(InternalBookmark.parse(bookmarkString), await(future).bookmark()); + assertEquals(bookmarkString, await(future)); } @Test diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/HelloResponseHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/HelloResponseHandlerTest.java similarity index 54% rename from driver/src/test/java/org/neo4j/driver/internal/handlers/HelloResponseHandlerTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/HelloResponseHandlerTest.java index 2cbf85f90f..fbd8c6dcc7 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/handlers/HelloResponseHandlerTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/HelloResponseHandlerTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers; +package org.neo4j.driver.internal.bolt.basicimpl.handlers; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -22,32 +22,30 @@ import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.Mockito.mock; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.connectionId; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.connectionReadTimeout; -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.setMessageDispatcher; -import static org.neo4j.driver.internal.async.outbound.OutboundMessageHandler.NAME; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.connectionId; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.connectionReadTimeout; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.serverAgent; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setMessageDispatcher; +import static org.neo4j.driver.internal.bolt.basicimpl.async.outbound.OutboundMessageHandler.NAME; import io.netty.channel.embedded.EmbeddedChannel; import java.time.Clock; import java.util.HashMap; import java.util.Map; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionException; import java.util.concurrent.TimeUnit; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import org.neo4j.driver.AuthTokens; import org.neo4j.driver.Value; import org.neo4j.driver.Values; import org.neo4j.driver.exceptions.UntrustedServerException; -import org.neo4j.driver.internal.async.inbound.ChannelErrorHandler; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; -import org.neo4j.driver.internal.async.outbound.OutboundMessageHandler; -import org.neo4j.driver.internal.async.pool.AuthContext; -import org.neo4j.driver.internal.messaging.v3.MessageFormatV3; -import org.neo4j.driver.internal.security.StaticAuthTokenManager; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.ChannelErrorHandler; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.async.outbound.OutboundMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v3.MessageFormatV3; class HelloResponseHandlerTest { private static final String SERVER_AGENT = "Neo4j/4.4.0"; @@ -56,11 +54,10 @@ class HelloResponseHandlerTest { @BeforeEach void setUp() { - setAuthContext(channel, new AuthContext(new StaticAuthTokenManager(AuthTokens.none()))); - setMessageDispatcher(channel, new InboundMessageDispatcher(channel, DEV_NULL_LOGGING)); + setMessageDispatcher(channel, new InboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE)); var pipeline = channel.pipeline(); - pipeline.addLast(NAME, new OutboundMessageHandler(new MessageFormatV3(), DEV_NULL_LOGGING)); - pipeline.addLast(new ChannelErrorHandler(DEV_NULL_LOGGING)); + pipeline.addLast(NAME, new OutboundMessageHandler(new MessageFormatV3(), NoopLoggingProvider.INSTANCE)); + pipeline.addLast(new ChannelErrorHandler(NoopLoggingProvider.INSTANCE)); } @AfterEach @@ -70,92 +67,100 @@ void tearDown() { @Test void shouldSetServerAgentOnChannel() { - var channelPromise = channel.newPromise(); - var handler = new HelloResponseHandler(channelPromise, mock(Clock.class)); + var agentFuture = new CompletableFuture(); + var latestAuth = new CompletableFuture(); + var handler = new HelloResponseHandler(agentFuture, channel, mock(Clock.class), latestAuth); var metadata = metadata(SERVER_AGENT, "bolt-1"); handler.onSuccess(metadata); - assertTrue(channelPromise.isSuccess()); + assertTrue(agentFuture.isDone() && !agentFuture.isCompletedExceptionally() && !agentFuture.isCancelled()); assertEquals(SERVER_AGENT, serverAgent(channel)); } @Test void shouldThrowWhenServerVersionNotReturned() { - var channelPromise = channel.newPromise(); - var handler = new HelloResponseHandler(channelPromise, mock(Clock.class)); + var agentFuture = new CompletableFuture(); + var latestAuth = new CompletableFuture(); + var handler = new HelloResponseHandler(agentFuture, channel, mock(Clock.class), latestAuth); var metadata = metadata(null, "bolt-1"); assertThrows(UntrustedServerException.class, () -> handler.onSuccess(metadata)); - assertFalse(channelPromise.isSuccess()); // initialization failed + assertTrue(agentFuture.isCompletedExceptionally()); // initialization failed assertTrue(channel.closeFuture().isDone()); // channel was closed } @Test void shouldThrowWhenServerVersionIsNull() { - var channelPromise = channel.newPromise(); - var handler = new HelloResponseHandler(channelPromise, mock(Clock.class)); + var agentFuture = new CompletableFuture(); + var latestAuth = new CompletableFuture(); + var handler = new HelloResponseHandler(agentFuture, channel, mock(Clock.class), latestAuth); var metadata = metadata(Values.NULL, "bolt-x"); assertThrows(UntrustedServerException.class, () -> handler.onSuccess(metadata)); - assertFalse(channelPromise.isSuccess()); // initialization failed + assertTrue(agentFuture.isCompletedExceptionally()); // initialization failed assertTrue(channel.closeFuture().isDone()); // channel was closed } @Test void shouldThrowWhenServerAgentIsUnrecognised() { - var channelPromise = channel.newPromise(); - var handler = new HelloResponseHandler(channelPromise, mock(Clock.class)); + var agentFuture = new CompletableFuture(); + var latestAuth = new CompletableFuture(); + var handler = new HelloResponseHandler(agentFuture, channel, mock(Clock.class), latestAuth); var metadata = metadata("WrongServerVersion", "bolt-x"); assertThrows(UntrustedServerException.class, () -> handler.onSuccess(metadata)); - assertFalse(channelPromise.isSuccess()); // initialization failed + assertTrue(agentFuture.isCompletedExceptionally()); // initialization failed assertTrue(channel.closeFuture().isDone()); // channel was closed } @Test void shouldSetConnectionIdOnChannel() { - var channelPromise = channel.newPromise(); - var handler = new HelloResponseHandler(channelPromise, mock(Clock.class)); + var agentFuture = new CompletableFuture(); + var latestAuth = new CompletableFuture(); + var handler = new HelloResponseHandler(agentFuture, channel, mock(Clock.class), latestAuth); var metadata = metadata(SERVER_AGENT, "bolt-42"); handler.onSuccess(metadata); - assertTrue(channelPromise.isSuccess()); + assertTrue(agentFuture.isDone() && !agentFuture.isCompletedExceptionally() && !agentFuture.isCancelled()); assertEquals("bolt-42", connectionId(channel)); } @Test void shouldThrowWhenConnectionIdNotReturned() { - var channelPromise = channel.newPromise(); - var handler = new HelloResponseHandler(channelPromise, mock(Clock.class)); + var agentFuture = new CompletableFuture(); + var latestAuth = new CompletableFuture(); + var handler = new HelloResponseHandler(agentFuture, channel, mock(Clock.class), latestAuth); var metadata = metadata(SERVER_AGENT, null); assertThrows(IllegalStateException.class, () -> handler.onSuccess(metadata)); - assertFalse(channelPromise.isSuccess()); // initialization failed + assertTrue(agentFuture.isCompletedExceptionally()); // initialization failed assertTrue(channel.closeFuture().isDone()); // channel was closed } @Test void shouldThrowWhenConnectionIdIsNull() { - var channelPromise = channel.newPromise(); - var handler = new HelloResponseHandler(channelPromise, mock(Clock.class)); + var agentFuture = new CompletableFuture(); + var latestAuth = new CompletableFuture(); + var handler = new HelloResponseHandler(agentFuture, channel, mock(Clock.class), latestAuth); var metadata = metadata(SERVER_AGENT, Values.NULL); assertThrows(IllegalStateException.class, () -> handler.onSuccess(metadata)); - assertFalse(channelPromise.isSuccess()); // initialization failed + assertTrue(agentFuture.isCompletedExceptionally()); // initialization failed assertTrue(channel.closeFuture().isDone()); // channel was closed } @Test void shouldCloseChannelOnFailure() throws Exception { - var channelPromise = channel.newPromise(); - var handler = new HelloResponseHandler(channelPromise, mock(Clock.class)); + var agentFuture = new CompletableFuture(); + var latestAuth = new CompletableFuture(); + var handler = new HelloResponseHandler(agentFuture, channel, mock(Clock.class), latestAuth); var error = new RuntimeException("Hi!"); handler.onFailure(error); @@ -164,50 +169,56 @@ void shouldCloseChannelOnFailure() throws Exception { channelCloseFuture.await(5, TimeUnit.SECONDS); assertTrue(channelCloseFuture.isSuccess()); - assertTrue(channelPromise.isDone()); - assertEquals(error, channelPromise.cause()); + assertTrue(agentFuture.isCompletedExceptionally()); + assertEquals( + error, + assertThrows(CompletionException.class, agentFuture::join).getCause()); } @Test void shouldNotThrowWhenConfigurationHintsAreAbsent() { - var channelPromise = channel.newPromise(); - var handler = new HelloResponseHandler(channelPromise, mock(Clock.class)); + var agentFuture = new CompletableFuture(); + var latestAuth = new CompletableFuture(); + var handler = new HelloResponseHandler(agentFuture, channel, mock(Clock.class), latestAuth); var metadata = metadata(SERVER_AGENT, "bolt-x"); handler.onSuccess(metadata); - assertTrue(channelPromise.isSuccess()); + assertTrue(agentFuture.isDone() && !agentFuture.isCompletedExceptionally() && !agentFuture.isCancelled()); assertFalse(channel.closeFuture().isDone()); } @Test void shouldNotThrowWhenConfigurationHintsAreEmpty() { - var channelPromise = channel.newPromise(); - var handler = new HelloResponseHandler(channelPromise, mock(Clock.class)); + var agentFuture = new CompletableFuture(); + var latestAuth = new CompletableFuture(); + var handler = new HelloResponseHandler(agentFuture, channel, mock(Clock.class), latestAuth); var metadata = metadata(SERVER_AGENT, "bolt-x", value(new HashMap<>())); handler.onSuccess(metadata); - assertTrue(channelPromise.isSuccess()); + assertTrue(agentFuture.isDone() && !agentFuture.isCompletedExceptionally() && !agentFuture.isCancelled()); assertFalse(channel.closeFuture().isDone()); } @Test void shouldNotThrowWhenConfigurationHintsAreNull() { - var channelPromise = channel.newPromise(); - var handler = new HelloResponseHandler(channelPromise, mock(Clock.class)); + var agentFuture = new CompletableFuture(); + var latestAuth = new CompletableFuture(); + var handler = new HelloResponseHandler(agentFuture, channel, mock(Clock.class), latestAuth); var metadata = metadata(SERVER_AGENT, "bolt-x", Values.NULL); handler.onSuccess(metadata); - assertTrue(channelPromise.isSuccess()); + assertTrue(agentFuture.isDone() && !agentFuture.isCompletedExceptionally() && !agentFuture.isCancelled()); assertFalse(channel.closeFuture().isDone()); } @Test void shouldSetConnectionTimeoutHint() { - var channelPromise = channel.newPromise(); - var handler = new HelloResponseHandler(channelPromise, mock(Clock.class)); + var agentFuture = new CompletableFuture(); + var latestAuth = new CompletableFuture(); + var handler = new HelloResponseHandler(agentFuture, channel, mock(Clock.class), latestAuth); var timeout = 15L; Map hints = new HashMap<>(); @@ -216,7 +227,7 @@ void shouldSetConnectionTimeoutHint() { handler.onSuccess(metadata); assertEquals(timeout, connectionReadTimeout(channel).orElse(null)); - assertTrue(channelPromise.isSuccess()); + assertTrue(agentFuture.isDone() && !agentFuture.isCompletedExceptionally() && !agentFuture.isCancelled()); assertFalse(channel.closeFuture().isDone()); } diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/ResetResponseHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/ResetResponseHandlerTest.java similarity index 89% rename from driver/src/test/java/org/neo4j/driver/internal/handlers/ResetResponseHandlerTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/ResetResponseHandlerTest.java index 864c4ecaf3..716fa8dc97 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/handlers/ResetResponseHandlerTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/ResetResponseHandlerTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers; +package org.neo4j.driver.internal.bolt.basicimpl.handlers; import static java.util.Collections.emptyMap; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -26,7 +26,7 @@ import java.util.concurrent.CompletableFuture; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; class ResetResponseHandlerTest { @Test @@ -43,7 +43,7 @@ void shouldCompleteFutureOnSuccess() throws Exception { } @Test - void shouldCompleteFutureOnFailure() throws Exception { + void shouldCompleteFutureOnFailure() { var future = new CompletableFuture(); var handler = newHandler(future); @@ -51,8 +51,7 @@ void shouldCompleteFutureOnFailure() throws Exception { handler.onFailure(new RuntimeException()); - assertTrue(future.isDone()); - assertNull(future.get()); + assertTrue(future.isCompletedExceptionally()); } @Test diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/RouteMessageResponseHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/RouteMessageResponseHandlerTest.java similarity index 98% rename from driver/src/test/java/org/neo4j/driver/internal/handlers/RouteMessageResponseHandlerTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/RouteMessageResponseHandlerTest.java index 2eae3441d1..4d0682b8e6 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/handlers/RouteMessageResponseHandlerTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/RouteMessageResponseHandlerTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.handlers; +package org.neo4j.driver.internal.bolt.basicimpl.handlers; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/RunResponseHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/RunResponseHandlerTest.java new file mode 100644 index 0000000000..1c28612b72 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/handlers/RunResponseHandlerTest.java @@ -0,0 +1,154 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.handlers; + +import static java.util.Collections.emptyMap; +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.neo4j.driver.Values.values; + +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import org.junit.jupiter.api.Test; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v3.BoltProtocolV3; +import org.neo4j.driver.internal.bolt.basicimpl.util.MetadataExtractor; + +class RunResponseHandlerTest { + @Test + void shouldNotifyRunFutureOnSuccess() { + var runFuture = new CompletableFuture(); + var handler = newHandler(runFuture); + + assertFalse(runFuture.isDone()); + handler.onSuccess(emptyMap()); + + assertTrue(runFuture.isDone() && !runFuture.isCompletedExceptionally() && !runFuture.isCancelled()); + } + + @Test + void shouldNotifyRunFutureOnFailure() { + var runFuture = new CompletableFuture(); + var handler = newHandler(runFuture); + + assertFalse(runFuture.isDone()); + var exception = new RuntimeException(); + handler.onFailure(exception); + + assertTrue(runFuture.isCompletedExceptionally()); + var executionException = assertThrows(ExecutionException.class, runFuture::get); + assertThat(executionException.getCause(), equalTo(exception)); + } + + @Test + void shouldThrowOnRecord() { + var handler = newHandler(); + + assertThrows(UnsupportedOperationException.class, () -> handler.onRecord(values("a", "b", "c"))); + } + + // @Test + // @SuppressWarnings("ThrowableNotThrown") + // void shouldMarkTxAndKeepConnectionAndFailOnFailure() { + // var runFuture = new CompletableFuture(); + // var connection = mock(Connection.class); + // var tx = mock(UnmanagedTransaction.class); + // var handler = new RunResponseHandler(runFuture, BoltProtocolV3.METADATA_EXTRACTOR, connection, tx); + // Throwable throwable = new RuntimeException(); + // + // assertFalse(runFuture.isDone()); + // handler.onFailure(throwable); + // + // assertTrue(runFuture.isCompletedExceptionally()); + // var actualException = assertThrows(Throwable.class, () -> await(runFuture)); + // assertSame(throwable, actualException); + // verify(tx).markTerminated(throwable); + // verify(connection, never()).release(); + // verify(connection, never()).terminateAndRelease(any(String.class)); + // } + // + // @Test + // void shouldNotReleaseConnectionAndFailOnFailure() { + // var runFuture = new CompletableFuture(); + // var connection = mock(Connection.class); + // var handler = new RunResponseHandler(runFuture, BoltProtocolV3.METADATA_EXTRACTOR, connection, null); + // Throwable throwable = new RuntimeException(); + // + // assertFalse(runFuture.isDone()); + // handler.onFailure(throwable); + // + // assertTrue(runFuture.isCompletedExceptionally()); + // var actualException = assertThrows(Throwable.class, () -> await(runFuture)); + // assertSame(throwable, actualException); + // verify(connection, never()).release(); + // verify(connection, never()).terminateAndRelease(any(String.class)); + // } + // + // @Test + // void shouldReleaseConnectionImmediatelyAndFailOnAuthorizationExpiredExceptionFailure() { + // var runFuture = new CompletableFuture(); + // var connection = mock(Connection.class); + // var handler = new RunResponseHandler(runFuture, BoltProtocolV3.METADATA_EXTRACTOR, connection, null); + // var authorizationExpiredException = new AuthorizationExpiredException("code", "message"); + // + // assertFalse(runFuture.isDone()); + // handler.onFailure(authorizationExpiredException); + // + // assertTrue(runFuture.isCompletedExceptionally()); + // var actualException = assertThrows(AuthorizationExpiredException.class, () -> await(runFuture)); + // assertSame(authorizationExpiredException, actualException); + // verify(connection).terminateAndRelease(AuthorizationExpiredException.DESCRIPTION); + // verify(connection, never()).release(); + // } + // + // @Test + // void shouldReleaseConnectionImmediatelyAndFailOnConnectionReadTimeoutExceptionFailure() { + // var runFuture = new CompletableFuture(); + // var connection = mock(Connection.class); + // var handler = new RunResponseHandler(runFuture, BoltProtocolV3.METADATA_EXTRACTOR, connection, null); + // + // assertFalse(runFuture.isDone()); + // handler.onFailure(ConnectionReadTimeoutException.INSTANCE); + // + // assertTrue(runFuture.isCompletedExceptionally()); + // var actualException = assertThrows(ConnectionReadTimeoutException.class, () -> await(runFuture)); + // assertSame(ConnectionReadTimeoutException.INSTANCE, actualException); + // verify(connection).terminateAndRelease(ConnectionReadTimeoutException.INSTANCE.getMessage()); + // verify(connection, never()).release(); + // } + + private static RunResponseHandler newHandler() { + return newHandler(BoltProtocolV3.METADATA_EXTRACTOR); + } + + private static RunResponseHandler newHandler(CompletableFuture runFuture) { + return newHandler(runFuture, BoltProtocolV3.METADATA_EXTRACTOR); + } + + private static RunResponseHandler newHandler( + @SuppressWarnings("SameParameterValue") MetadataExtractor metadataExtractor) { + return newHandler(new CompletableFuture<>(), metadataExtractor); + } + + private static RunResponseHandler newHandler( + CompletableFuture runFuture, MetadataExtractor metadataExtractor) { + return new RunResponseHandler(runFuture, metadataExtractor); + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/logging/ChannelActivityLoggerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/logging/ChannelActivityLoggerTest.java similarity index 81% rename from driver/src/test/java/org/neo4j/driver/internal/logging/ChannelActivityLoggerTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/logging/ChannelActivityLoggerTest.java index 5ea513819a..f61713ee97 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/logging/ChannelActivityLoggerTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/logging/ChannelActivityLoggerTest.java @@ -14,20 +14,20 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.logging; +package org.neo4j.driver.internal.bolt.basicimpl.logging; import static org.junit.jupiter.api.Assertions.assertEquals; import io.netty.channel.embedded.EmbeddedChannel; import org.junit.jupiter.api.Test; -import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; class ChannelActivityLoggerTest { @Test void shouldReformatWhenChannelIsNull() { - var activityLogger = new ChannelActivityLogger(null, Logging.none(), getClass()); + var activityLogger = new ChannelActivityLogger(null, NoopLoggingProvider.INSTANCE, getClass()); var reformatted = activityLogger.reformat("Hello!"); @@ -37,7 +37,7 @@ void shouldReformatWhenChannelIsNull() { @Test void shouldReformatWithChannelId() { var channel = new EmbeddedChannel(); - var activityLogger = new ChannelActivityLogger(channel, Logging.none(), getClass()); + var activityLogger = new ChannelActivityLogger(channel, NoopLoggingProvider.INSTANCE, getClass()); var reformatted = activityLogger.reformat("Hello!"); @@ -48,7 +48,7 @@ void shouldReformatWithChannelId() { void shouldReformatWithChannelIdAndServerAddress() { var channel = new EmbeddedChannel(); ChannelAttributes.setServerAddress(channel, new BoltServerAddress("somewhere", 1234)); - var activityLogger = new ChannelActivityLogger(channel, Logging.none(), getClass()); + var activityLogger = new ChannelActivityLogger(channel, NoopLoggingProvider.INSTANCE, getClass()); var reformatted = activityLogger.reformat("Hello!"); @@ -59,7 +59,7 @@ void shouldReformatWithChannelIdAndServerAddress() { void shouldReformatWithChannelIdAndConnectionId() { var channel = new EmbeddedChannel(); ChannelAttributes.setConnectionId(channel, "bolt-12345"); - var activityLogger = new ChannelActivityLogger(channel, Logging.none(), getClass()); + var activityLogger = new ChannelActivityLogger(channel, NoopLoggingProvider.INSTANCE, getClass()); var reformatted = activityLogger.reformat("Hello!"); diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/BoltProtocolTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/BoltProtocolTest.java similarity index 79% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/BoltProtocolTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/BoltProtocolTest.java index 088860fd97..20c7d183b6 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/BoltProtocolTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/BoltProtocolTest.java @@ -14,22 +14,23 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.messaging; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.instanceOf; import static org.junit.jupiter.api.Assertions.assertAll; import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setProtocolVersion; +import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setProtocolVersion; import io.netty.channel.embedded.EmbeddedChannel; import org.junit.jupiter.api.Test; import org.neo4j.driver.exceptions.ClientException; -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.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v3.BoltProtocolV3; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v4.BoltProtocolV4; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v41.BoltProtocolV41; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v42.BoltProtocolV42; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v43.BoltProtocolV43; class BoltProtocolTest { @Test diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/BoltProtocolVersionTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/BoltProtocolVersionTest.java similarity index 96% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/BoltProtocolVersionTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/BoltProtocolVersionTest.java index 59de671b2f..39c0d83cc5 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/BoltProtocolVersionTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/BoltProtocolVersionTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.messaging; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; @@ -22,6 +22,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; class BoltProtocolVersionTest { diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/MessageFormatTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/MessageFormatTest.java new file mode 100644 index 0000000000..6cc7c47e48 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/MessageFormatTest.java @@ -0,0 +1,179 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging; +// +// import static java.util.Arrays.asList; +// import static org.hamcrest.MatcherAssert.assertThat; +// import static org.hamcrest.Matchers.startsWith; +// 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.neo4j.driver.Values.parameters; +// import static org.neo4j.driver.Values.value; +// import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.messageDispatcher; +// import static org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes.setMessageDispatcher; +// import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; +// import static org.neo4j.driver.internal.util.ValueFactory.emptyNodeValue; +// import static org.neo4j.driver.internal.util.ValueFactory.emptyPathValue; +// import static org.neo4j.driver.internal.util.ValueFactory.emptyRelationshipValue; +// import static org.neo4j.driver.internal.util.ValueFactory.filledNodeValue; +// import static org.neo4j.driver.internal.util.ValueFactory.filledPathValue; +// import static org.neo4j.driver.internal.util.ValueFactory.filledRelationshipValue; +// +// import io.netty.buffer.ByteBuf; +// import io.netty.buffer.Unpooled; +// import io.netty.channel.embedded.EmbeddedChannel; +// import java.util.HashMap; +// import org.junit.jupiter.api.Test; +// import org.neo4j.driver.Value; +// import org.neo4j.driver.exceptions.ClientException; +// import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +// import org.neo4j.driver.internal.bolt.basicimpl.async.connection.BoltProtocolUtil; +// import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelPipelineBuilderImpl; +// import org.neo4j.driver.internal.bolt.basicimpl.async.outbound.ChunkAwareByteBufOutput; +// import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonValueUnpacker; +// import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.FailureMessage; +// import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.IgnoredMessage; +// import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.RecordMessage; +// import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.SuccessMessage; +// import org.neo4j.driver.internal.bolt.basicimpl.messaging.v3.MessageFormatV3; +// import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackStream; +// import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.KnowledgeableMessageFormat; +// import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.MemorizingInboundMessageDispatcher; +// +// class MessageFormatTest { +// public final MessageFormat format = new MessageFormatV3(); +// +// @Test +// void shouldUnpackAllResponses() throws Throwable { +// assertSerializes(new FailureMessage("Hello", "World!")); +// assertSerializes(IgnoredMessage.IGNORED); +// assertSerializes(new RecordMessage(new Value[] {value(1337L)})); +// assertSerializes(new SuccessMessage(new HashMap<>())); +// } +// +// @Test +// void shouldPackUnpackValidValues() throws Throwable { +// assertSerializesValue(value(parameters("cat", null, "dog", null))); +// assertSerializesValue(value(parameters("k", 12, "a", "banana"))); +// assertSerializesValue(value(asList("k", 12, "a", "banana"))); +// } +// +// @Test +// void shouldUnpackNodeRelationshipAndPath() throws Throwable { +// // Given +// assertOnlyDeserializesValue(emptyNodeValue()); +// assertOnlyDeserializesValue(filledNodeValue()); +// assertOnlyDeserializesValue(emptyRelationshipValue()); +// assertOnlyDeserializesValue(filledRelationshipValue()); +// assertOnlyDeserializesValue(emptyPathValue()); +// assertOnlyDeserializesValue(filledPathValue()); +// } +// +// @Test +// void shouldGiveHelpfulErrorOnMalformedNodeStruct() throws Throwable { +// // Given +// var output = new ChunkAwareByteBufOutput(); +// var buf = Unpooled.buffer(); +// output.start(buf); +// var packer = new PackStream.Packer(output); +// +// packer.packStructHeader(1, RecordMessage.SIGNATURE); +// packer.packListHeader(1); +// packer.packStructHeader(0, CommonValueUnpacker.NODE); +// +// output.stop(); +// BoltProtocolUtil.writeMessageBoundary(buf); +// +// // Expect +// var error = assertThrows(ClientException.class, () -> unpack(buf, newEmbeddedChannel())); +// assertThat( +// error.getMessage(), +// startsWith("Invalid message received, serialized NODE structures should have 3 fields, " +// + "received NODE structure has 0 fields.")); +// } +// +// private void assertSerializesValue(Value value) throws Throwable { +// assertSerializes(new RecordMessage(new Value[] {value})); +// } +// +// private void assertSerializes(Message message) throws Throwable { +// var channel = newEmbeddedChannel(new KnowledgeableMessageFormat(false)); +// +// var packed = pack(message, channel); +// var unpackedMessage = unpack(packed, channel); +// +// assertEquals(message, unpackedMessage); +// } +// +// private EmbeddedChannel newEmbeddedChannel() { +// return newEmbeddedChannel(format); +// } +// +// private EmbeddedChannel newEmbeddedChannel(MessageFormat format) { +// var channel = new EmbeddedChannel(); +// setMessageDispatcher(channel, new MemorizingInboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE)); +// new ChannelPipelineBuilderImpl().build(format, channel.pipeline(), NoopLoggingProvider.INSTANCE); +// return channel; +// } +// +// private ByteBuf pack(Message message, EmbeddedChannel channel) { +// assertTrue(channel.writeOutbound(message)); +// +// var packedMessages = +// channel.outboundMessages().stream().map(msg -> (ByteBuf) msg).toArray(ByteBuf[]::new); +// +// return Unpooled.wrappedBuffer(packedMessages); +// } +// +// private Message unpack(ByteBuf packed, EmbeddedChannel channel) throws Throwable { +// channel.writeInbound(packed); +// +// var dispatcher = messageDispatcher(channel); +// var memorizingDispatcher = ((MemorizingInboundMessageDispatcher) dispatcher); +// +// var error = memorizingDispatcher.currentError(); +// if (error != null) { +// throw error; +// } +// +// var unpackedMessages = memorizingDispatcher.messages(); +// +// assertEquals(1, unpackedMessages.size()); +// return unpackedMessages.get(0); +// } +// +// private void assertOnlyDeserializesValue(Value value) throws Throwable { +// var message = new RecordMessage(new Value[] {value}); +// var packed = knowledgeablePack(message); +// +// var channel = newEmbeddedChannel(); +// var unpackedMessage = unpack(packed, channel); +// +// assertEquals(message, unpackedMessage); +// } +// +// private ByteBuf knowledgeablePack(Message message) { +// var channel = newEmbeddedChannel(new KnowledgeableMessageFormat(false)); +// assertTrue(channel.writeOutbound(message)); +// +// var packedMessages = +// channel.outboundMessages().stream().map(msg -> (ByteBuf) msg).toArray(ByteBuf[]::new); +// +// return Unpooled.wrappedBuffer(packedMessages); +// } +// } diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/BeginMessageEncoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/BeginMessageEncoderTest.java similarity index 72% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/encode/BeginMessageEncoderTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/BeginMessageEncoderTest.java index 551e78afee..09998c1198 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/BeginMessageEncoderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/BeginMessageEncoderTest.java @@ -14,34 +14,33 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.mock; -import static org.neo4j.driver.AccessMode.READ; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.messaging.request.ResetMessage.RESET; +import static org.neo4j.driver.internal.bolt.api.AccessMode.READ; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage.RESET; import java.time.Duration; import java.util.Arrays; -import java.util.Collections; import java.util.HashMap; import java.util.Map; +import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.messaging.ValuePacker; -import org.neo4j.driver.internal.messaging.request.BeginMessage; +import org.neo4j.driver.Values; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.DatabaseNameUtil; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; class BeginMessageEncoderTest { private final BeginMessageEncoder encoder = new BeginMessageEncoder(); @@ -50,7 +49,7 @@ class BeginMessageEncoderTest { @ParameterizedTest @MethodSource("arguments") void shouldEncodeBeginMessage(AccessMode mode, String impersonatedUser, String txType) throws Exception { - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx42")); + var bookmarks = Set.of("neo4j:bookmark:v1:tx42"); Map txMetadata = new HashMap<>(); txMetadata.put("hello", value("world")); @@ -58,17 +57,29 @@ void shouldEncodeBeginMessage(AccessMode mode, String impersonatedUser, String t var txTimeout = Duration.ofSeconds(1); + var loggingProvider = new LoggingProvider() { + @Override + public System.Logger getLog(Class cls) { + return mock(System.Logger.class); + } + + @Override + public System.Logger getLog(String name) { + return mock(System.Logger.class); + } + }; + encoder.encode( new BeginMessage( bookmarks, txTimeout, txMetadata, mode, - defaultDatabase(), + DatabaseNameUtil.defaultDatabase(), impersonatedUser, txType, null, - Logging.none()), + loggingProvider), packer); var order = inOrder(packer); @@ -76,7 +87,7 @@ void shouldEncodeBeginMessage(AccessMode mode, String impersonatedUser, String t Map expectedMetadata = new HashMap<>(); expectedMetadata.put( - "bookmarks", value(bookmarks.stream().map(Bookmark::value).collect(Collectors.toSet()))); + "bookmarks", value(bookmarks.stream().map(Values::value).collect(Collectors.toSet()))); expectedMetadata.put("tx_timeout", value(1000)); expectedMetadata.put("tx_metadata", value(txMetadata)); if (mode == READ) { diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/CommitMessageEncoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/CommitMessageEncoderTest.java similarity index 76% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/encode/CommitMessageEncoderTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/CommitMessageEncoderTest.java index a8397f1071..38bf5aa3a0 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/CommitMessageEncoderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/CommitMessageEncoderTest.java @@ -14,17 +14,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; -import static org.neo4j.driver.internal.messaging.request.CommitMessage.COMMIT; -import static org.neo4j.driver.internal.messaging.request.DiscardAllMessage.DISCARD_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage.COMMIT; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage.DISCARD_ALL; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.messaging.ValuePacker; -import org.neo4j.driver.internal.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; class CommitMessageEncoderTest { private final CommitMessageEncoder encoder = new CommitMessageEncoder(); diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/DiscardAllMessageEncoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/DiscardAllMessageEncoderTest.java similarity index 82% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/encode/DiscardAllMessageEncoderTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/DiscardAllMessageEncoderTest.java index f835836884..00071f023e 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/DiscardAllMessageEncoderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/DiscardAllMessageEncoderTest.java @@ -14,16 +14,16 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.messaging.ValuePacker; -import org.neo4j.driver.internal.messaging.request.DiscardAllMessage; -import org.neo4j.driver.internal.messaging.request.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; class DiscardAllMessageEncoderTest { private final DiscardAllMessageEncoder encoder = new DiscardAllMessageEncoder(); diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/DiscardMessageEncoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/DiscardMessageEncoderTest.java similarity index 85% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/encode/DiscardMessageEncoderTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/DiscardMessageEncoderTest.java index 5e049cffb3..5a56e589e7 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/DiscardMessageEncoderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/DiscardMessageEncoderTest.java @@ -14,21 +14,21 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.mock; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.messaging.request.DiscardMessage.newDiscardAllMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage.newDiscardAllMessage; import java.util.HashMap; import java.util.Map; import org.junit.jupiter.api.Test; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.messaging.ValuePacker; -import org.neo4j.driver.internal.messaging.request.DiscardAllMessage; -import org.neo4j.driver.internal.messaging.request.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; class DiscardMessageEncoderTest { private final DiscardMessageEncoder encoder = new DiscardMessageEncoder(); diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/GoodbyeMessageEncoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/GoodbyeMessageEncoderTest.java similarity index 76% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/encode/GoodbyeMessageEncoderTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/GoodbyeMessageEncoderTest.java index 06164ed525..5b3d1bd00b 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/GoodbyeMessageEncoderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/GoodbyeMessageEncoderTest.java @@ -14,17 +14,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; -import static org.neo4j.driver.internal.messaging.request.DiscardAllMessage.DISCARD_ALL; -import static org.neo4j.driver.internal.messaging.request.GoodbyeMessage.GOODBYE; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage.DISCARD_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage.GOODBYE; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.messaging.ValuePacker; -import org.neo4j.driver.internal.messaging.request.GoodbyeMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage; class GoodbyeMessageEncoderTest { private final GoodbyeMessageEncoder encoder = new GoodbyeMessageEncoder(); diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/HelloMessageEncoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/HelloMessageEncoderTest.java similarity index 88% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/encode/HelloMessageEncoderTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/HelloMessageEncoderTest.java index 91736c1af1..3d34040851 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/HelloMessageEncoderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/HelloMessageEncoderTest.java @@ -14,21 +14,21 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.mock; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.messaging.request.PullAllMessage.PULL_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage.PULL_ALL; import java.util.HashMap; import java.util.Map; import org.junit.jupiter.api.Test; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.messaging.ValuePacker; -import org.neo4j.driver.internal.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.api.BoltAgentUtil; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; class HelloMessageEncoderTest { private final HelloMessageEncoder encoder = new HelloMessageEncoder(); diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/PullAllMessageEncoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/PullAllMessageEncoderTest.java similarity index 82% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/encode/PullAllMessageEncoderTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/PullAllMessageEncoderTest.java index 8da1f93163..ebd73b1311 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/PullAllMessageEncoderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/PullAllMessageEncoderTest.java @@ -14,16 +14,16 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.messaging.ValuePacker; -import org.neo4j.driver.internal.messaging.request.PullAllMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; class PullAllMessageEncoderTest { private final PullAllMessageEncoder encoder = new PullAllMessageEncoder(); diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/PullMessageEncoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/PullMessageEncoderTest.java similarity index 89% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/encode/PullMessageEncoderTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/PullMessageEncoderTest.java index b910522973..df18d72fce 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/PullMessageEncoderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/PullMessageEncoderTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.inOrder; @@ -25,9 +25,9 @@ import java.util.Map; import org.junit.jupiter.api.Test; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.messaging.ValuePacker; -import org.neo4j.driver.internal.messaging.request.PullAllMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; class PullMessageEncoderTest { private final PullMessageEncoder encoder = new PullMessageEncoder(); diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/ResetMessageEncoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/ResetMessageEncoderTest.java similarity index 72% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/encode/ResetMessageEncoderTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/ResetMessageEncoderTest.java index d6332b510d..5837f1fce9 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/ResetMessageEncoderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/ResetMessageEncoderTest.java @@ -14,17 +14,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; +import java.util.Collections; import org.junit.jupiter.api.Test; -import org.neo4j.driver.Query; -import org.neo4j.driver.internal.messaging.ValuePacker; -import org.neo4j.driver.internal.messaging.request.ResetMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage; class ResetMessageEncoderTest { private final ResetMessageEncoder encoder = new ResetMessageEncoder(); @@ -41,6 +41,7 @@ void shouldEncodeResetMessage() throws Exception { void shouldFailToEncodeWrongMessage() { assertThrows( IllegalArgumentException.class, - () -> encoder.encode(RunWithMetadataMessage.unmanagedTxRunMessage(new Query("RETURN 2")), packer)); + () -> encoder.encode( + RunWithMetadataMessage.unmanagedTxRunMessage("RETURN 2", Collections.emptyMap()), packer)); } } diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/RollbackMessageEncoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RollbackMessageEncoderTest.java similarity index 76% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/encode/RollbackMessageEncoderTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RollbackMessageEncoderTest.java index 09fa3bec86..c65014a4ca 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/RollbackMessageEncoderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RollbackMessageEncoderTest.java @@ -14,17 +14,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; -import static org.neo4j.driver.internal.messaging.request.ResetMessage.RESET; -import static org.neo4j.driver.internal.messaging.request.RollbackMessage.ROLLBACK; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage.RESET; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage.ROLLBACK; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.messaging.ValuePacker; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; class RollbackMessageEncoderTest { private final RollbackMessageEncoder encoder = new RollbackMessageEncoder(); diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/RouteMessageEncoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RouteMessageEncoderTest.java similarity index 88% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/encode/RouteMessageEncoderTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RouteMessageEncoderTest.java index bfca7b741c..c0c72b4c7e 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/RouteMessageEncoderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RouteMessageEncoderTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; import static java.util.Collections.emptyList; import static org.junit.jupiter.api.Assertions.assertThrows; @@ -31,10 +31,10 @@ import org.junit.jupiter.params.provider.NullSource; import org.junit.jupiter.params.provider.ValueSource; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.ValuePacker; -import org.neo4j.driver.internal.messaging.request.RouteMessage; +import org.neo4j.driver.Values; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RouteMessage; class RouteMessageEncoderTest { private final ValuePacker packer = mock(ValuePacker.class); @@ -61,7 +61,7 @@ void shouldEncodeRouteMessage(String databaseName) throws IOException { @NullSource void shouldEncodeRouteMessageWithBookmark(String databaseName) throws IOException { var routingContext = getRoutingContext(); - var bookmark = InternalBookmark.parse("somebookmark"); + var bookmark = "somebookmark"; encoder.encode( new RouteMessage(getRoutingContext(), Collections.singleton(bookmark), databaseName, null), packer); @@ -70,7 +70,7 @@ void shouldEncodeRouteMessageWithBookmark(String databaseName) throws IOExceptio inOrder.verify(packer).packStructHeader(3, (byte) 0x66); inOrder.verify(packer).pack(routingContext); - inOrder.verify(packer).pack(value(Collections.singleton(bookmark.value()))); + inOrder.verify(packer).pack(value(Collections.singleton(Values.value(bookmark)))); inOrder.verify(packer).pack(databaseName); } diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/RunWithMetadataMessageEncoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RunWithMetadataMessageEncoderTest.java similarity index 60% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/encode/RunWithMetadataMessageEncoderTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RunWithMetadataMessageEncoderTest.java index 3a321d5406..e013f58825 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/RunWithMetadataMessageEncoderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/RunWithMetadataMessageEncoderTest.java @@ -14,17 +14,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; import static java.util.Collections.singletonMap; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.mock; -import static org.neo4j.driver.AccessMode.READ; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.messaging.request.DiscardAllMessage.DISCARD_ALL; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.api.AccessMode.READ; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage.DISCARD_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; import java.time.Duration; import java.util.Collections; @@ -34,14 +34,12 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.EnumSource; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.messaging.ValuePacker; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; +import org.neo4j.driver.Values; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage; class RunWithMetadataMessageEncoderTest { private final RunWithMetadataMessageEncoder encoder = new RunWithMetadataMessageEncoder(); @@ -52,7 +50,7 @@ class RunWithMetadataMessageEncoderTest { void shouldEncodeRunWithMetadataMessage(AccessMode mode) throws Exception { var params = singletonMap("answer", value(42)); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx999")); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx999"); Map txMetadata = new HashMap<>(); txMetadata.put("key1", value("value1")); @@ -61,10 +59,28 @@ void shouldEncodeRunWithMetadataMessage(AccessMode mode) throws Exception { var txTimeout = Duration.ofMillis(42); - var query = new Query("RETURN $answer", value(params)); encoder.encode( autoCommitTxRunMessage( - query, txTimeout, txMetadata, defaultDatabase(), mode, bookmarks, null, null, Logging.none()), + "RETURN $answer", + params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + new LoggingProvider() { + @Override + public System.Logger getLog(Class cls) { + return mock(System.Logger.class); + } + + @Override + public System.Logger getLog(String name) { + return mock(System.Logger.class); + } + }), packer); var order = inOrder(packer); @@ -74,7 +90,7 @@ query, txTimeout, txMetadata, defaultDatabase(), mode, bookmarks, null, null, Lo Map expectedMetadata = new HashMap<>(); expectedMetadata.put( - "bookmarks", value(bookmarks.stream().map(Bookmark::value).collect(Collectors.toSet()))); + "bookmarks", value(bookmarks.stream().map(Values::value).collect(Collectors.toSet()))); expectedMetadata.put("tx_timeout", value(42)); expectedMetadata.put("tx_metadata", value(txMetadata)); if (mode == READ) { diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/TelemetryMessageEncoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/TelemetryMessageEncoderTest.java similarity index 75% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/encode/TelemetryMessageEncoderTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/TelemetryMessageEncoderTest.java index 5e591d9164..bef6eaaac8 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/encode/TelemetryMessageEncoderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/encode/TelemetryMessageEncoderTest.java @@ -14,22 +14,22 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.encode; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.encode; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; +import java.util.Collections; import java.util.stream.Stream; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; -import org.neo4j.driver.Query; import org.neo4j.driver.Values; -import org.neo4j.driver.internal.messaging.ValuePacker; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.messaging.request.TelemetryMessage; -import org.neo4j.driver.internal.telemetry.TelemetryApi; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.TelemetryMessage; class TelemetryMessageEncoderTest { private final TelemetryMessageEncoder encoder = new TelemetryMessageEncoder(); @@ -48,7 +48,8 @@ void shouldEncodeTelemetryMessage(int api) throws Exception { void shouldFailToEncodeWrongMessage() { Assertions.assertThrows( IllegalArgumentException.class, - () -> encoder.encode(RunWithMetadataMessage.unmanagedTxRunMessage(new Query("RETURN 2")), packer)); + () -> encoder.encode( + RunWithMetadataMessage.unmanagedTxRunMessage("RETURN 2", Collections.emptyMap()), packer)); } private static Stream validApis() { diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/request/HelloMessageTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/HelloMessageTest.java similarity index 96% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/request/HelloMessageTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/HelloMessageTest.java index c7421051f9..7bf9eec2bc 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/request/HelloMessageTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/HelloMessageTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.containsString; @@ -29,8 +29,8 @@ import java.util.Map; import org.junit.jupiter.api.Test; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.BoltAgent; -import org.neo4j.driver.internal.BoltAgentUtil; +import org.neo4j.driver.internal.bolt.api.BoltAgent; +import org.neo4j.driver.internal.bolt.api.BoltAgentUtil; class HelloMessageTest { @Test diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/request/TransactionMetadataBuilderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/TransactionMetadataBuilderTest.java similarity index 68% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/request/TransactionMetadataBuilderTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/TransactionMetadataBuilderTest.java index 1323943f29..b031015437 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/request/TransactionMetadataBuilderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/request/TransactionMetadataBuilderTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.request; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.request; import static java.util.Arrays.asList; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -22,12 +22,12 @@ import static org.mockito.BDDMockito.given; import static org.mockito.BDDMockito.then; import static org.mockito.Mockito.mock; -import static org.neo4j.driver.AccessMode.READ; -import static org.neo4j.driver.AccessMode.WRITE; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.messaging.request.TransactionMetadataBuilder.buildMetadata; +import static org.neo4j.driver.internal.bolt.api.AccessMode.READ; +import static org.neo4j.driver.internal.bolt.api.AccessMode.WRITE; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.TransactionMetadataBuilder.buildMetadata; import java.time.Duration; import java.time.LocalDateTime; @@ -41,22 +41,20 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.EnumSource; import org.junit.jupiter.params.provider.ValueSource; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; -import org.neo4j.driver.NotificationCategory; -import org.neo4j.driver.NotificationConfig; -import org.neo4j.driver.NotificationSeverity; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.InternalBookmark; +import org.neo4j.driver.Values; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.NotificationCategory; +import org.neo4j.driver.internal.bolt.api.NotificationConfig; +import org.neo4j.driver.internal.bolt.api.NotificationSeverity; public class TransactionMetadataBuilderTest { @ParameterizedTest @EnumSource(AccessMode.class) void shouldHaveCorrectMetadata(AccessMode mode) { - var bookmarks = Collections.singleton( - InternalBookmark.parse(new HashSet<>(asList("neo4j:bookmark:v1:tx11", "neo4j:bookmark:v1:tx52")))); + var bookmarks = new HashSet<>(asList("neo4j:bookmark:v1:tx11", "neo4j:bookmark:v1:tx52")); Map txMetadata = new HashMap<>(); txMetadata.put("foo", value("bar")); @@ -66,11 +64,19 @@ void shouldHaveCorrectMetadata(AccessMode mode) { var txTimeout = Duration.ofSeconds(7); var metadata = buildMetadata( - txTimeout, txMetadata, defaultDatabase(), mode, bookmarks, null, null, null, Logging.none()); + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + null, + NoopLoggingProvider.INSTANCE); Map expectedMetadata = new HashMap<>(); expectedMetadata.put( - "bookmarks", value(bookmarks.stream().map(Bookmark::value).collect(Collectors.toSet()))); + "bookmarks", value(bookmarks.stream().map(Values::value).collect(Collectors.toSet()))); expectedMetadata.put("tx_timeout", value(7000)); expectedMetadata.put("tx_metadata", value(txMetadata)); if (mode == READ) { @@ -83,8 +89,7 @@ void shouldHaveCorrectMetadata(AccessMode mode) { @ParameterizedTest @ValueSource(strings = {"", "foo", "data"}) void shouldHaveCorrectMetadataForDatabaseName(String databaseName) { - var bookmarks = Collections.singleton( - InternalBookmark.parse(new HashSet<>(asList("neo4j:bookmark:v1:tx11", "neo4j:bookmark:v1:tx52")))); + var bookmarks = new HashSet<>(asList("neo4j:bookmark:v1:tx11", "neo4j:bookmark:v1:tx52")); Map txMetadata = new HashMap<>(); txMetadata.put("foo", value("bar")); @@ -94,11 +99,19 @@ void shouldHaveCorrectMetadataForDatabaseName(String databaseName) { var txTimeout = Duration.ofSeconds(7); var metadata = buildMetadata( - txTimeout, txMetadata, database(databaseName), WRITE, bookmarks, null, null, null, Logging.none()); + txTimeout, + txMetadata, + database(databaseName), + WRITE, + bookmarks, + null, + null, + null, + NoopLoggingProvider.INSTANCE); Map expectedMetadata = new HashMap<>(); expectedMetadata.put( - "bookmarks", value(bookmarks.stream().map(Bookmark::value).collect(Collectors.toSet()))); + "bookmarks", value(bookmarks.stream().map(Values::value).collect(Collectors.toSet()))); expectedMetadata.put("tx_timeout", value(7000)); expectedMetadata.put("tx_metadata", value(txMetadata)); expectedMetadata.put("db", value(databaseName)); @@ -109,10 +122,19 @@ void shouldHaveCorrectMetadataForDatabaseName(String databaseName) { @Test void shouldNotHaveMetadataForDatabaseNameWhenIsNull() { var metadata = buildMetadata( - null, null, defaultDatabase(), WRITE, Collections.emptySet(), null, null, null, Logging.none()); + null, + null, + defaultDatabase(), + WRITE, + Collections.emptySet(), + null, + null, + null, + NoopLoggingProvider.INSTANCE); assertTrue(metadata.isEmpty()); } + @SuppressWarnings("OptionalGetWithoutIsPresent") @Test void shouldIncludeNotificationConfig() { var metadata = buildMetadata( @@ -123,10 +145,10 @@ void shouldIncludeNotificationConfig() { Collections.emptySet(), null, null, - NotificationConfig.defaultConfig() - .enableMinimumSeverity(NotificationSeverity.WARNING) - .disableCategories(Set.of(NotificationCategory.UNSUPPORTED)), - Logging.none()); + new NotificationConfig( + NotificationSeverity.WARNING, + Set.of(NotificationCategory.valueOf("UNSUPPORTED").get())), + NoopLoggingProvider.INSTANCE); var expectedMetadata = new HashMap(); expectedMetadata.put("notifications_minimum_severity", value("WARNING")); @@ -138,8 +160,8 @@ void shouldIncludeNotificationConfig() { @ValueSource(longs = {1, 1_000_001, 100_500_000, 100_700_000, 1_000_000_001}) void shouldRoundUpFractionalTimeoutAndLog(long nanosValue) { // given - var logging = mock(Logging.class); - var logger = mock(Logger.class); + var logging = mock(LoggingProvider.class); + var logger = mock(System.Logger.class); given(logging.getLog(TransactionMetadataBuilder.class)).willReturn(logger); // when @@ -162,15 +184,16 @@ void shouldRoundUpFractionalTimeoutAndLog(long nanosValue) { then(logging).should().getLog(TransactionMetadataBuilder.class); then(logger) .should() - .info( + .log( + System.Logger.Level.INFO, "The transaction timeout has been rounded up to next millisecond value since the config had a fractional millisecond value"); } @Test void shouldNotLogWhenRoundingDoesNotHappen() { // given - var logging = mock(Logging.class); - var logger = mock(Logger.class); + var logging = mock(LoggingProvider.class); + var logger = mock(System.Logger.class); given(logging.getLog(TransactionMetadataBuilder.class)).willReturn(logger); var timeout = 1000; diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/BoltProtocolV3Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/BoltProtocolV3Test.java new file mode 100644 index 0000000000..5aefeea241 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/BoltProtocolV3Test.java @@ -0,0 +1,714 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v3; + +import static java.time.Duration.ofSeconds; +import static java.util.Collections.emptyMap; +import static java.util.Collections.singletonMap; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.hasSize; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.Matchers.startsWith; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +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.ArgumentMatchers.eq; +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.mockito.Mockito.when; +import static org.neo4j.driver.Values.value; +import static org.neo4j.driver.internal.bolt.api.AccessMode.WRITE; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; + +import io.netty.channel.embedded.EmbeddedChannel; +import java.time.Clock; +import java.time.Duration; +import java.util.Collections; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionException; +import java.util.concurrent.CompletionStage; +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.EnumSource; +import org.mockito.stubbing.Answer; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; +import org.neo4j.driver.exceptions.ClientException; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.BeginTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.CommitTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.PullResponseHandlerImpl; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RollbackTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RunResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.PullMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; + +public class BoltProtocolV3Test { + protected static final String query = "RETURN $x"; + protected static final Map query_params = singletonMap("x", value(42)); + private static final long UNLIMITED_FETCH_SIZE = -1; + private static final Duration txTimeout = ofSeconds(12); + private static final Map txMetadata = singletonMap("x", value(42)); + + protected final BoltProtocol protocol = createProtocol(); + private final EmbeddedChannel channel = new EmbeddedChannel(); + private final InboundMessageDispatcher messageDispatcher = + new InboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE); + + @BeforeEach + void beforeEach() { + ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); + } + + @AfterEach + void afterEach() { + channel.finishAndReleaseAll(); + } + + @SuppressWarnings("SameReturnValue") + protected BoltProtocol createProtocol() { + return BoltProtocolV3.INSTANCE; + } + + protected Class expectedMessageFormatType() { + return MessageFormatV3.class; + } + + @Test + void shouldCreateMessageFormat() { + assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); + } + + @Test + void shouldInitializeChannel() { + var promise = channel.newPromise(); + var clock = mock(Clock.class); + var time = 1L; + when(clock.millis()).thenReturn(time); + + var latestAuthMillisFuture = new CompletableFuture(); + + protocol.initializeChannel( + "MyDriver/0.0.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + clock, + latestAuthMillisFuture); + + assertThat(channel.outboundMessages(), hasSize(1)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertEquals(1, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + var metadata = Map.of( + "server", value("Neo4j/3.5.0"), + "connection_id", value("bolt-42")); + + messageDispatcher.handleSuccessMessage(metadata); + + assertTrue(promise.isDone()); + assertTrue(promise.isSuccess()); + verify(clock).millis(); + assertTrue(latestAuthMillisFuture.isDone()); + assertEquals(time, latestAuthMillisFuture.join()); + } + + @Test + void shouldFailToInitializeChannelWhenErrorIsReceived() { + var promise = channel.newPromise(); + + protocol.initializeChannel( + "MyDriver/2.2.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + mock(Clock.class), + new CompletableFuture<>()); + + assertThat(channel.outboundMessages(), hasSize(1)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertEquals(1, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + messageDispatcher.handleFailureMessage("Neo.TransientError.General.DatabaseUnavailable", "Error!"); + + assertTrue(promise.isDone()); + assertFalse(promise.isSuccess()); + } + + @Test + void shouldBeginTransactionWithoutBookmark() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarks() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx100"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + WRITE, + null, + bookmarks, + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + null, + Collections.emptyMap(), + defaultDatabase(), + WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + WRITE, + null, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + txTimeout, + txMetadata, + defaultDatabase(), + WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarksAndConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx4242"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + WRITE, + null, + bookmarks, + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + txTimeout, + txMetadata, + defaultDatabase(), + WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldCommitTransaction() { + var bookmarkString = "neo4j:bookmark:v1:tx4242"; + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var commitHandler = (CommitTxResponseHandler) invocation.getArgument(1); + commitHandler.onSuccess(Map.of("bookmark", value(bookmarkString))); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.commitTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); + then(handler).should().onSummary(bookmarkString); + } + + @Test + void shouldRollbackTransaction() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var rollbackHandler = (RollbackTxResponseHandler) invocation.getArgument(1); + rollbackHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.rollbackTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) + throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx65"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx163"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(false, null, Collections.emptyMap(), mode); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(true); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(false); + } + + @Test + void databaseNameInBeginTransaction() { + testDatabaseNameSupport(false); + } + + @Test + void databaseNameForAutoCommitTransactions() { + testDatabaseNameSupport(true); + } + + @Test + void shouldReturnFailedStageWithNoConnectionInteractionsOnTelemetry() { + var connection = mock(Connection.class); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var future = protocol.telemetry(connection, 1, handler).toCompletableFuture(); + + assertTrue(future.isCompletedExceptionally()); + then(connection).shouldHaveNoInteractions(); + } + + protected void testDatabaseNameSupport(boolean autoCommitTx) { + ClientException e; + if (autoCommitTx) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var future = protocol.runAuto( + connection, + database("foo"), + WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE) + .toCompletableFuture(); + e = (ClientException) + assertThrows(CompletionException.class, future::join).getCause(); + } else { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var future = protocol.beginTransaction( + connection, + database("foo"), + WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE) + .toCompletableFuture(); + e = (ClientException) + assertThrows(CompletionException.class, future::join).getCause(); + } + + assertThat(e.getMessage(), startsWith("Database name parameter for selecting database is not supported")); + } + + protected void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success) throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + if (success) { + runHandler.onSuccess(emptyMap()); + } else { + runHandler.onFailure(error); + } + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + if (success) { + then(handler).should().onSummary(any()); + } else { + then(handler).should().onError(error); + } + } + + protected void testRunAndWaitForRunResponse( + boolean autoCommitTx, Duration txTimeout, Map txMetadata, AccessMode mode) throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var initialBookmarks = Collections.singleton("neo4j:bookmark:v1:tx987"); + + if (autoCommitTx) { + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + initialBookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + initialBookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } + + protected void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, Duration txTimeout, Map txMetadata, AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedRunStage = CompletableFuture.completedStage(null); + var expectedPullStage = CompletableFuture.completedStage(null); + var newBookmarkValue = "neo4j:bookmark:v1:tx98765"; + given(connection.write(any(), any())) + .willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedRunStage; + }) + .willAnswer((Answer>) invocation -> { + var pullHandler = (PullResponseHandlerImpl) invocation.getArgument(1); + pullHandler.onSuccess( + Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue))); + return expectedPullStage; + }); + @SuppressWarnings("unchecked") + var runHandler = (MessageHandler) mock(MessageHandler.class); + var pullHandler = mock(PullMessageHandler.class); + + var runStage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + runHandler, + NoopLoggingProvider.INSTANCE); + var pullStage = protocol.pull(connection, 0, UNLIMITED_FETCH_SIZE, pullHandler); + + assertEquals(expectedRunStage, runStage); + assertEquals(expectedPullStage, pullStage); + var runMessage = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(runMessage), any(RunResponseHandler.class)); + then(connection).should().write(eq(PullAllMessage.PULL_ALL), any(PullResponseHandlerImpl.class)); + then(runHandler).should().onSummary(any()); + then(pullHandler) + .should() + .onSummary(new PullResponseHandlerImpl.PullSummaryImpl( + false, Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue)))); + } + + protected void testFailedRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, Duration txTimeout, Map txMetadata, AccessMode mode) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onFailure(error); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onError(error); + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/MessageFormatV3Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/MessageFormatV3Test.java similarity index 81% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v3/MessageFormatV3Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/MessageFormatV3Test.java index 1e1423c118..395b6a1360 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/MessageFormatV3Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/MessageFormatV3Test.java @@ -14,17 +14,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v3; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v3; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.instanceOf; import static org.mockito.Mockito.mock; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.common.CommonMessageReader; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonMessageReader; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; /** * The MessageFormat under tests is the one provided by the {@link BoltProtocolV3} and not an specific class implementation. diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/MessageReaderV3Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/MessageReaderV3Test.java similarity index 84% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v3/MessageReaderV3Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/MessageReaderV3Test.java index b444d08736..6ee60e6fb9 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/MessageReaderV3Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/MessageReaderV3Test.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v3; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v3; import static java.util.Arrays.asList; import static java.util.Calendar.APRIL; @@ -41,15 +41,15 @@ import org.neo4j.driver.Values; import org.neo4j.driver.internal.InternalPoint2D; import org.neo4j.driver.internal.InternalPoint3D; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.DiscardAllMessage; -import org.neo4j.driver.internal.messaging.response.FailureMessage; -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.packstream.PackInput; -import org.neo4j.driver.internal.util.messaging.AbstractMessageReaderTestBase; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.FailureMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.IgnoredMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.RecordMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.SuccessMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.AbstractMessageReaderTestBase; /** * The MessageReader under tests is the one provided by the {@link BoltProtocolV3} and not an specific class implementation. diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/MessageWriterV3Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/MessageWriterV3Test.java similarity index 57% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v3/MessageWriterV3Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/MessageWriterV3Test.java index 3b7bc3191e..44df6a8eb5 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/MessageWriterV3Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v3/MessageWriterV3Test.java @@ -14,26 +14,26 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v3; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v3; import static java.time.Duration.ofSeconds; import static java.util.Calendar.DECEMBER; import static java.util.Collections.emptyMap; import static java.util.Collections.singletonMap; -import static org.neo4j.driver.AccessMode.READ; -import static org.neo4j.driver.AccessMode.WRITE; import static org.neo4j.driver.AuthTokens.basic; import static org.neo4j.driver.Values.point; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.messaging.request.CommitMessage.COMMIT; -import static org.neo4j.driver.internal.messaging.request.DiscardAllMessage.DISCARD_ALL; -import static org.neo4j.driver.internal.messaging.request.GoodbyeMessage.GOODBYE; -import static org.neo4j.driver.internal.messaging.request.PullAllMessage.PULL_ALL; -import static org.neo4j.driver.internal.messaging.request.ResetMessage.RESET; -import static org.neo4j.driver.internal.messaging.request.RollbackMessage.ROLLBACK; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; +import static org.neo4j.driver.internal.bolt.api.AccessMode.READ; +import static org.neo4j.driver.internal.bolt.api.AccessMode.WRITE; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage.COMMIT; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage.DISCARD_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage.GOODBYE; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage.PULL_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage.RESET; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage.ROLLBACK; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; import java.time.LocalDate; import java.time.LocalDateTime; @@ -44,20 +44,19 @@ import java.time.ZonedDateTime; import java.util.Collections; import java.util.stream.Stream; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.BoltAgentUtil; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.AbstractMessageWriterTestBase; import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.util.messaging.AbstractMessageWriterTestBase; /** - * The MessageWriter under tests is the one provided by the {@link BoltProtocolV3} and not an specific class implementation. + * The MessageWriter under tests is the one provided by the {@link BoltProtocolV3} and not an specific class + * implementation. *

* It's done on this way to make easy to replace the implementation and still getting the same behaviour. */ @@ -71,29 +70,26 @@ protected MessageFormat.Writer newWriter(PackOutput output) { protected Stream supportedMessages() { return Stream.of( // Bolt V2 Data Types - unmanagedTxRunMessage(new Query("RETURN $point", singletonMap("point", point(42, 12.99, -180.0)))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 12.99, -180.0))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123))), + unmanagedTxRunMessage("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L)))), unmanagedTxRunMessage( - new Query("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123)))), + "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN)))), + unmanagedTxRunMessage("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888)))), unmanagedTxRunMessage( - new Query("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L))))), - unmanagedTxRunMessage(new Query( - "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN))))), - unmanagedTxRunMessage( - new Query("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888))))), - unmanagedTxRunMessage(new Query( "RETURN $dateTime", - singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199))))), - unmanagedTxRunMessage(new Query( + singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199)))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", value(ZonedDateTime.of( - 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30)))))), - unmanagedTxRunMessage(new Query( + 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30))))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", - value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm")))))), + value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm"))))), // Bolt V3 messages new HelloMessage( @@ -105,7 +101,7 @@ protected Stream supportedMessages() { null), GOODBYE, new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), READ, @@ -113,9 +109,9 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), WRITE, @@ -123,37 +119,40 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), COMMIT, ROLLBACK, autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), defaultDatabase(), READ, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), defaultDatabase(), WRITE, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN 1")), + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN 1", Collections.emptyMap()), PULL_ALL, DISCARD_ALL, RESET, // Bolt V3 messages with struct values autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), defaultDatabase(), @@ -161,9 +160,10 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), defaultDatabase(), @@ -171,8 +171,8 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN $x", singletonMap("x", point(42, 1, 2, 3))))); + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN $x", singletonMap("x", point(42, 1, 2, 3)))); } @Override diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/BoltProtocolV4Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/BoltProtocolV4Test.java new file mode 100644 index 0000000000..fba3ea071f --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/BoltProtocolV4Test.java @@ -0,0 +1,781 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v4; + +import static java.time.Duration.ofSeconds; +import static java.util.Collections.emptyMap; +import static java.util.Collections.singletonMap; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.hasSize; +import static org.hamcrest.Matchers.instanceOf; +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.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +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.mockito.Mockito.when; +import static org.neo4j.driver.Values.value; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; + +import io.netty.channel.embedded.EmbeddedChannel; +import java.time.Clock; +import java.time.Duration; +import java.util.Collections; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +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.EnumSource; +import org.mockito.stubbing.Answer; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.BeginTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.CommitTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.PullResponseHandlerImpl; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RollbackTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RunResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.PullMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; + +public final class BoltProtocolV4Test { + protected static final String query = "RETURN $x"; + protected static final Map query_params = singletonMap("x", value(42)); + private static final long UNLIMITED_FETCH_SIZE = -1; + private static final Duration txTimeout = ofSeconds(12); + private static final Map txMetadata = singletonMap("x", value(42)); + + private final BoltProtocol protocol = createProtocol(); + private final EmbeddedChannel channel = new EmbeddedChannel(); + private final InboundMessageDispatcher messageDispatcher = + new InboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE); + + @BeforeEach + void beforeEach() { + ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); + } + + @AfterEach + void afterEach() { + channel.finishAndReleaseAll(); + } + + @Test + void shouldCreateMessageFormat() { + assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); + } + + @Test + void shouldInitializeChannel() { + var promise = channel.newPromise(); + var clock = mock(Clock.class); + var time = 1L; + when(clock.millis()).thenReturn(time); + + var latestAuthMillisFuture = new CompletableFuture(); + + protocol.initializeChannel( + "MyDriver/0.0.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + clock, + latestAuthMillisFuture); + + assertThat(channel.outboundMessages(), hasSize(1)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertEquals(1, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + var metadata = Map.of( + "server", value("Neo4j/3.5.0"), + "connection_id", value("bolt-42")); + + messageDispatcher.handleSuccessMessage(metadata); + + assertTrue(promise.isDone()); + assertTrue(promise.isSuccess()); + verify(clock).millis(); + assertTrue(latestAuthMillisFuture.isDone()); + assertEquals(time, latestAuthMillisFuture.join()); + } + + @Test + void shouldFailToInitializeChannelWhenErrorIsReceived() { + var promise = channel.newPromise(); + + protocol.initializeChannel( + "MyDriver/2.2.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + mock(Clock.class), + new CompletableFuture<>()); + + assertThat(channel.outboundMessages(), hasSize(1)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertEquals(1, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + messageDispatcher.handleFailureMessage("Neo.TransientError.General.DatabaseUnavailable", "Error!"); + + assertTrue(promise.isDone()); + assertFalse(promise.isSuccess()); + } + + @Test + void shouldBeginTransactionWithoutBookmark() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarks() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx100"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarksAndConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx4242"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldCommitTransaction() { + var bookmarkString = "neo4j:bookmark:v1:tx4242"; + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var commitHandler = (CommitTxResponseHandler) invocation.getArgument(1); + commitHandler.onSuccess(Map.of("bookmark", value(bookmarkString))); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.commitTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); + then(handler).should().onSummary(bookmarkString); + } + + @Test + void shouldRollbackTransaction() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var rollbackHandler = (RollbackTxResponseHandler) invocation.getArgument(1); + rollbackHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.rollbackTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) + throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx65"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx163"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(false, null, Collections.emptyMap(), mode); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(true); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(false); + } + + @Test + void databaseNameInBeginTransaction() { + testDatabaseNameSupport(false); + } + + @Test + void databaseNameForAutoCommitTransactions() { + testDatabaseNameSupport(true); + } + + @Test + void shouldSupportDatabaseNameInBeginTransaction() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.beginTransaction( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldNotSupportDatabaseNameForAutoCommitTransactions() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.runAuto( + connection, + database("foo"), + AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldReturnFailedStageWithNoConnectionInteractionsOnTelemetry() { + var connection = mock(Connection.class); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var future = protocol.telemetry(connection, 1, handler).toCompletableFuture(); + + assertTrue(future.isCompletedExceptionally()); + then(connection).shouldHaveNoInteractions(); + } + + @SuppressWarnings("SameReturnValue") + private BoltProtocol createProtocol() { + return BoltProtocolV4.INSTANCE; + } + + private Class expectedMessageFormatType() { + return MessageFormatV4.class; + } + + private void testFailedRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onFailure(error); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onError(error); + } + + private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedRunStage = CompletableFuture.completedStage(null); + var expectedPullStage = CompletableFuture.completedStage(null); + var newBookmarkValue = "neo4j:bookmark:v1:tx98765"; + given(connection.write(any(), any())) + .willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedRunStage; + }) + .willAnswer((Answer>) invocation -> { + var pullHandler = (PullResponseHandlerImpl) invocation.getArgument(1); + pullHandler.onSuccess( + Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue))); + return expectedPullStage; + }); + @SuppressWarnings("unchecked") + var runHandler = (MessageHandler) mock(MessageHandler.class); + var pullHandler = mock(PullMessageHandler.class); + + var runStage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + runHandler, + NoopLoggingProvider.INSTANCE); + var pullStage = protocol.pull(connection, 0, UNLIMITED_FETCH_SIZE, pullHandler); + + assertEquals(expectedRunStage, runStage); + assertEquals(expectedPullStage, pullStage); + var runMessage = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(runMessage), any(RunResponseHandler.class)); + var pullMessage = new PullMessage(UNLIMITED_FETCH_SIZE, 0L); + then(connection).should().write(eq(pullMessage), any(PullResponseHandlerImpl.class)); + then(runHandler).should().onSummary(any()); + then(pullHandler) + .should() + .onSummary(new PullResponseHandlerImpl.PullSummaryImpl( + false, Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue)))); + } + + protected void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success) throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + if (success) { + runHandler.onSuccess(emptyMap()); + } else { + runHandler.onFailure(error); + } + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + if (success) { + then(handler).should().onSummary(any()); + } else { + then(handler).should().onError(error); + } + } + + protected void testRunAndWaitForRunResponse( + boolean autoCommitTx, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var initialBookmarks = Collections.singleton("neo4j:bookmark:v1:tx987"); + + if (autoCommitTx) { + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + initialBookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + initialBookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } + + private void testDatabaseNameSupport(boolean autoCommitTx) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + if (autoCommitTx) { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + AccessMode.WRITE, + Collections.emptySet(), + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/MessageFormatV4Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/MessageFormatV4Test.java similarity index 81% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v4/MessageFormatV4Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/MessageFormatV4Test.java index fa9beb46b9..edc45ece20 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/MessageFormatV4Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/MessageFormatV4Test.java @@ -14,17 +14,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v4; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v4; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.instanceOf; import static org.mockito.Mockito.mock; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.common.CommonMessageReader; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonMessageReader; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; /** * The MessageFormat under tests is the one provided by the {@link BoltProtocolV4} and not an specific class implementation. diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/MessageReaderV4Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/MessageReaderV4Test.java similarity index 84% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v4/MessageReaderV4Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/MessageReaderV4Test.java index 7b0e0a2e9b..352244461c 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/MessageReaderV4Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/MessageReaderV4Test.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v4; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v4; import static java.util.Arrays.asList; import static java.util.Calendar.APRIL; @@ -41,15 +41,15 @@ import org.neo4j.driver.Values; import org.neo4j.driver.internal.InternalPoint2D; import org.neo4j.driver.internal.InternalPoint3D; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.DiscardAllMessage; -import org.neo4j.driver.internal.messaging.response.FailureMessage; -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.packstream.PackInput; -import org.neo4j.driver.internal.util.messaging.AbstractMessageReaderTestBase; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.FailureMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.IgnoredMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.RecordMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.SuccessMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.AbstractMessageReaderTestBase; /** * The MessageReader under tests is the one provided by the {@link BoltProtocolV4} and not an specific class implementation. diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/MessageWriterV4Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/MessageWriterV4Test.java similarity index 56% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v4/MessageWriterV4Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/MessageWriterV4Test.java index 5e7660192f..78751d6cd7 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/MessageWriterV4Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v4/MessageWriterV4Test.java @@ -14,27 +14,27 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v4; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v4; import static java.time.Duration.ofSeconds; import static java.util.Calendar.DECEMBER; import static java.util.Collections.emptyMap; import static java.util.Collections.singletonMap; -import static org.neo4j.driver.AccessMode.READ; -import static org.neo4j.driver.AccessMode.WRITE; import static org.neo4j.driver.AuthTokens.basic; import static org.neo4j.driver.Values.point; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.messaging.request.CommitMessage.COMMIT; -import static org.neo4j.driver.internal.messaging.request.DiscardAllMessage.DISCARD_ALL; -import static org.neo4j.driver.internal.messaging.request.GoodbyeMessage.GOODBYE; -import static org.neo4j.driver.internal.messaging.request.PullAllMessage.PULL_ALL; -import static org.neo4j.driver.internal.messaging.request.ResetMessage.RESET; -import static org.neo4j.driver.internal.messaging.request.RollbackMessage.ROLLBACK; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; +import static org.neo4j.driver.internal.bolt.api.AccessMode.READ; +import static org.neo4j.driver.internal.bolt.api.AccessMode.WRITE; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage.COMMIT; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage.DISCARD_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage.GOODBYE; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage.PULL_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage.RESET; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage.ROLLBACK; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; import java.time.LocalDate; import java.time.LocalDateTime; @@ -45,23 +45,22 @@ import java.time.ZonedDateTime; import java.util.Collections; import java.util.stream.Stream; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.DiscardMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.BoltAgentUtil; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v3.BoltProtocolV3; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.AbstractMessageWriterTestBase; import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.util.messaging.AbstractMessageWriterTestBase; /** - * The MessageWriter under tests is the one provided by the {@link BoltProtocolV3} and not an specific class implementation. + * The MessageWriter under tests is the one provided by the {@link BoltProtocolV3} and not an specific class + * implementation. *

* It's done on this way to make easy to replace the implementation and still getting the same behaviour. */ @@ -75,29 +74,26 @@ protected MessageFormat.Writer newWriter(PackOutput output) { protected Stream supportedMessages() { return Stream.of( // Bolt V2 Data Types - unmanagedTxRunMessage(new Query("RETURN $point", singletonMap("point", point(42, 12.99, -180.0)))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 12.99, -180.0))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123))), + unmanagedTxRunMessage("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L)))), unmanagedTxRunMessage( - new Query("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123)))), + "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN)))), + unmanagedTxRunMessage("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888)))), unmanagedTxRunMessage( - new Query("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L))))), - unmanagedTxRunMessage(new Query( - "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN))))), - unmanagedTxRunMessage( - new Query("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888))))), - unmanagedTxRunMessage(new Query( "RETURN $dateTime", - singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199))))), - unmanagedTxRunMessage(new Query( + singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199)))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", value(ZonedDateTime.of( - 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30)))))), - unmanagedTxRunMessage(new Query( + 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30))))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", - value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm")))))), + value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm"))))), // New Bolt V4 messages new PullMessage(100, 200), @@ -113,7 +109,7 @@ protected Stream supportedMessages() { null), GOODBYE, new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), READ, @@ -121,9 +117,9 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), WRITE, @@ -131,35 +127,38 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), COMMIT, ROLLBACK, RESET, autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), defaultDatabase(), READ, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), database("foo"), WRITE, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN 1")), + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN 1", Collections.emptyMap()), // Bolt V3 messages with struct values autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), defaultDatabase(), @@ -167,9 +166,10 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), database("foo"), @@ -177,8 +177,8 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN $x", singletonMap("x", point(42, 1, 2, 3))))); + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN $x", singletonMap("x", point(42, 1, 2, 3)))); } @Override diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v41/BoltProtocolV41Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v41/BoltProtocolV41Test.java new file mode 100644 index 0000000000..17c7a3169c --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v41/BoltProtocolV41Test.java @@ -0,0 +1,782 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v41; + +import static java.time.Duration.ofSeconds; +import static java.util.Collections.emptyMap; +import static java.util.Collections.singletonMap; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.hasSize; +import static org.hamcrest.Matchers.instanceOf; +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.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +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.mockito.Mockito.when; +import static org.neo4j.driver.Values.value; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; + +import io.netty.channel.embedded.EmbeddedChannel; +import java.time.Clock; +import java.time.Duration; +import java.util.Collections; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +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.EnumSource; +import org.mockito.stubbing.Answer; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.BeginTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.CommitTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.PullResponseHandlerImpl; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RollbackTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RunResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.PullMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v4.MessageFormatV4; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; + +public final class BoltProtocolV41Test { + protected static final String query = "RETURN $x"; + protected static final Map query_params = singletonMap("x", value(42)); + private static final long UNLIMITED_FETCH_SIZE = -1; + private static final Duration txTimeout = ofSeconds(12); + private static final Map txMetadata = singletonMap("x", value(42)); + + private final BoltProtocol protocol = createProtocol(); + private final EmbeddedChannel channel = new EmbeddedChannel(); + private final InboundMessageDispatcher messageDispatcher = + new InboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE); + + @SuppressWarnings("SameReturnValue") + private BoltProtocol createProtocol() { + return BoltProtocolV41.INSTANCE; + } + + @BeforeEach + void beforeEach() { + ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); + } + + @AfterEach + void afterEach() { + channel.finishAndReleaseAll(); + } + + @Test + void shouldCreateMessageFormat() { + assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); + } + + @Test + void shouldInitializeChannel() { + var promise = channel.newPromise(); + var clock = mock(Clock.class); + var time = 1L; + when(clock.millis()).thenReturn(time); + + var latestAuthMillisFuture = new CompletableFuture(); + + protocol.initializeChannel( + "MyDriver/0.0.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + clock, + latestAuthMillisFuture); + + assertThat(channel.outboundMessages(), hasSize(1)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertEquals(1, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + var metadata = Map.of( + "server", value("Neo4j/3.5.0"), + "connection_id", value("bolt-42")); + + messageDispatcher.handleSuccessMessage(metadata); + + assertTrue(promise.isDone()); + assertTrue(promise.isSuccess()); + verify(clock).millis(); + assertTrue(latestAuthMillisFuture.isDone()); + assertEquals(time, latestAuthMillisFuture.join()); + } + + @Test + void shouldFailToInitializeChannelWhenErrorIsReceived() { + var promise = channel.newPromise(); + + protocol.initializeChannel( + "MyDriver/2.2.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + mock(Clock.class), + new CompletableFuture<>()); + + assertThat(channel.outboundMessages(), hasSize(1)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertEquals(1, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + messageDispatcher.handleFailureMessage("Neo.TransientError.General.DatabaseUnavailable", "Error!"); + + assertTrue(promise.isDone()); + assertFalse(promise.isSuccess()); + } + + @Test + void shouldBeginTransactionWithoutBookmark() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarks() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx100"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarksAndConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx4242"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldCommitTransaction() { + var bookmarkString = "neo4j:bookmark:v1:tx4242"; + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var commitHandler = (CommitTxResponseHandler) invocation.getArgument(1); + commitHandler.onSuccess(Map.of("bookmark", value(bookmarkString))); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.commitTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); + then(handler).should().onSummary(bookmarkString); + } + + @Test + void shouldRollbackTransaction() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var rollbackHandler = (RollbackTxResponseHandler) invocation.getArgument(1); + rollbackHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.rollbackTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) + throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx65"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx163"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(false, null, Collections.emptyMap(), mode); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(true); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(false); + } + + @Test + void databaseNameInBeginTransaction() { + testDatabaseNameSupport(false); + } + + @Test + void databaseNameForAutoCommitTransactions() { + testDatabaseNameSupport(true); + } + + @Test + void shouldSupportDatabaseNameInBeginTransaction() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.beginTransaction( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldNotSupportDatabaseNameForAutoCommitTransactions() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.runAuto( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldReturnFailedStageWithNoConnectionInteractionsOnTelemetry() { + var connection = mock(Connection.class); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var future = protocol.telemetry(connection, 1, handler).toCompletableFuture(); + + assertTrue(future.isCompletedExceptionally()); + then(connection).shouldHaveNoInteractions(); + } + + private Class expectedMessageFormatType() { + return MessageFormatV4.class; + } + + private void testFailedRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onFailure(error); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onError(error); + } + + private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedRunStage = CompletableFuture.completedStage(null); + var expectedPullStage = CompletableFuture.completedStage(null); + var newBookmarkValue = "neo4j:bookmark:v1:tx98765"; + given(connection.write(any(), any())) + .willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedRunStage; + }) + .willAnswer((Answer>) invocation -> { + var pullHandler = (PullResponseHandlerImpl) invocation.getArgument(1); + pullHandler.onSuccess( + Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue))); + return expectedPullStage; + }); + @SuppressWarnings("unchecked") + var runHandler = (MessageHandler) mock(MessageHandler.class); + var pullHandler = mock(PullMessageHandler.class); + + var runStage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + runHandler, + NoopLoggingProvider.INSTANCE); + var pullStage = protocol.pull(connection, 0, UNLIMITED_FETCH_SIZE, pullHandler); + + assertEquals(expectedRunStage, runStage); + assertEquals(expectedPullStage, pullStage); + var runMessage = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(runMessage), any(RunResponseHandler.class)); + var pullMessage = new PullMessage(UNLIMITED_FETCH_SIZE, 0L); + then(connection).should().write(eq(pullMessage), any(PullResponseHandlerImpl.class)); + then(runHandler).should().onSummary(any()); + then(pullHandler) + .should() + .onSummary(new PullResponseHandlerImpl.PullSummaryImpl( + false, Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue)))); + } + + protected void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success) throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + if (success) { + runHandler.onSuccess(emptyMap()); + } else { + runHandler.onFailure(error); + } + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + if (success) { + then(handler).should().onSummary(any()); + } else { + then(handler).should().onError(error); + } + } + + protected void testRunAndWaitForRunResponse( + boolean autoCommitTx, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var initialBookmarks = Collections.singleton("neo4j:bookmark:v1:tx987"); + + if (autoCommitTx) { + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + initialBookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + initialBookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } + + private void testDatabaseNameSupport(boolean autoCommitTx) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + if (autoCommitTx) { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + Collections.emptySet(), + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v41/MessageFormatV41Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v41/MessageFormatV41Test.java similarity index 74% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v41/MessageFormatV41Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v41/MessageFormatV41Test.java index d87ae331d3..d17dc46e5c 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v41/MessageFormatV41Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v41/MessageFormatV41Test.java @@ -14,19 +14,19 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v41; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v41; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.instanceOf; import static org.mockito.Mockito.mock; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.common.CommonMessageReader; -import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3; -import org.neo4j.driver.internal.messaging.v4.MessageWriterV4; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonMessageReader; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v3.BoltProtocolV3; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v4.MessageWriterV4; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; /** * The MessageFormat under tests is the one provided by the {@link BoltProtocolV3} and not an specific class implementation. diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v41/MessageReaderV41Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v41/MessageReaderV41Test.java similarity index 84% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v41/MessageReaderV41Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v41/MessageReaderV41Test.java index 6347319306..91edbaee60 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v41/MessageReaderV41Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v41/MessageReaderV41Test.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v41; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v41; import static java.util.Arrays.asList; import static java.util.Calendar.APRIL; @@ -41,15 +41,15 @@ import org.neo4j.driver.Values; import org.neo4j.driver.internal.InternalPoint2D; import org.neo4j.driver.internal.InternalPoint3D; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.DiscardAllMessage; -import org.neo4j.driver.internal.messaging.response.FailureMessage; -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.packstream.PackInput; -import org.neo4j.driver.internal.util.messaging.AbstractMessageReaderTestBase; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.FailureMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.IgnoredMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.RecordMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.SuccessMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.AbstractMessageReaderTestBase; /** * The MessageReader under tests is the one provided by the {@link BoltProtocolV41} and not an specific class implementation. diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v41/MessageWriterV41Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v41/MessageWriterV41Test.java similarity index 56% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v41/MessageWriterV41Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v41/MessageWriterV41Test.java index 6d42281b22..4cd1f597cd 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v41/MessageWriterV41Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v41/MessageWriterV41Test.java @@ -14,27 +14,27 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v41; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v41; import static java.time.Duration.ofSeconds; import static java.util.Calendar.DECEMBER; import static java.util.Collections.emptyMap; import static java.util.Collections.singletonMap; -import static org.neo4j.driver.AccessMode.READ; -import static org.neo4j.driver.AccessMode.WRITE; import static org.neo4j.driver.AuthTokens.basic; import static org.neo4j.driver.Values.point; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.messaging.request.CommitMessage.COMMIT; -import static org.neo4j.driver.internal.messaging.request.DiscardAllMessage.DISCARD_ALL; -import static org.neo4j.driver.internal.messaging.request.GoodbyeMessage.GOODBYE; -import static org.neo4j.driver.internal.messaging.request.PullAllMessage.PULL_ALL; -import static org.neo4j.driver.internal.messaging.request.ResetMessage.RESET; -import static org.neo4j.driver.internal.messaging.request.RollbackMessage.ROLLBACK; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; +import static org.neo4j.driver.internal.bolt.api.AccessMode.READ; +import static org.neo4j.driver.internal.bolt.api.AccessMode.WRITE; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage.COMMIT; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage.DISCARD_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage.GOODBYE; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage.PULL_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage.RESET; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage.ROLLBACK; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; import java.time.LocalDate; import java.time.LocalDateTime; @@ -45,22 +45,21 @@ import java.time.ZonedDateTime; import java.util.Collections; import java.util.stream.Stream; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.DiscardMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.BoltAgentUtil; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.AbstractMessageWriterTestBase; import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.util.messaging.AbstractMessageWriterTestBase; /** - * The MessageWriter under tests is the one provided by the {@link BoltProtocolV41} and not an specific class implementation. + * The MessageWriter under tests is the one provided by the {@link BoltProtocolV41} and not an specific class + * implementation. *

* It's done on this way to make easy to replace the implementation and still getting the same behaviour. */ @@ -74,29 +73,26 @@ protected MessageFormat.Writer newWriter(PackOutput output) { protected Stream supportedMessages() { return Stream.of( // Bolt V2 Data Types - unmanagedTxRunMessage(new Query("RETURN $point", singletonMap("point", point(42, 12.99, -180.0)))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 12.99, -180.0))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123))), + unmanagedTxRunMessage("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L)))), unmanagedTxRunMessage( - new Query("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123)))), + "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN)))), + unmanagedTxRunMessage("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888)))), unmanagedTxRunMessage( - new Query("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L))))), - unmanagedTxRunMessage(new Query( - "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN))))), - unmanagedTxRunMessage( - new Query("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888))))), - unmanagedTxRunMessage(new Query( "RETURN $dateTime", - singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199))))), - unmanagedTxRunMessage(new Query( + singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199)))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", value(ZonedDateTime.of( - 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30)))))), - unmanagedTxRunMessage(new Query( + 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30))))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", - value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm")))))), + value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm"))))), // New Bolt V4 messages new PullMessage(100, 200), @@ -112,7 +108,7 @@ protected Stream supportedMessages() { null), GOODBYE, new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), READ, @@ -120,9 +116,9 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), WRITE, @@ -130,35 +126,38 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), COMMIT, ROLLBACK, RESET, autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), defaultDatabase(), READ, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), database("foo"), WRITE, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN 1")), + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN 1", Collections.emptyMap()), // Bolt V3 messages with struct values autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), defaultDatabase(), @@ -166,9 +165,10 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), database("foo"), @@ -176,8 +176,8 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN $x", singletonMap("x", point(42, 1, 2, 3))))); + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN $x", singletonMap("x", point(42, 1, 2, 3)))); } @Override diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v42/BoltProtocolV42Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v42/BoltProtocolV42Test.java new file mode 100644 index 0000000000..6408b2dae0 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v42/BoltProtocolV42Test.java @@ -0,0 +1,782 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v42; + +import static java.time.Duration.ofSeconds; +import static java.util.Collections.emptyMap; +import static java.util.Collections.singletonMap; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.hasSize; +import static org.hamcrest.Matchers.instanceOf; +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.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +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.mockito.Mockito.when; +import static org.neo4j.driver.Values.value; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; + +import io.netty.channel.embedded.EmbeddedChannel; +import java.time.Clock; +import java.time.Duration; +import java.util.Collections; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +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.EnumSource; +import org.mockito.stubbing.Answer; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.BeginTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.CommitTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.PullResponseHandlerImpl; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RollbackTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RunResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.PullMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v4.MessageFormatV4; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; + +public final class BoltProtocolV42Test { + protected static final String query = "RETURN $x"; + protected static final Map query_params = singletonMap("x", value(42)); + private static final long UNLIMITED_FETCH_SIZE = -1; + private static final Duration txTimeout = ofSeconds(12); + private static final Map txMetadata = singletonMap("x", value(42)); + + private final BoltProtocol protocol = createProtocol(); + private final EmbeddedChannel channel = new EmbeddedChannel(); + private final InboundMessageDispatcher messageDispatcher = + new InboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE); + + @SuppressWarnings("SameReturnValue") + private BoltProtocol createProtocol() { + return BoltProtocolV42.INSTANCE; + } + + @BeforeEach + void beforeEach() { + ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); + } + + @AfterEach + void afterEach() { + channel.finishAndReleaseAll(); + } + + @Test + void shouldCreateMessageFormat() { + assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); + } + + @Test + void shouldInitializeChannel() { + var promise = channel.newPromise(); + var clock = mock(Clock.class); + var time = 1L; + when(clock.millis()).thenReturn(time); + + var latestAuthMillisFuture = new CompletableFuture(); + + protocol.initializeChannel( + "MyDriver/0.0.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + clock, + latestAuthMillisFuture); + + assertThat(channel.outboundMessages(), hasSize(1)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertEquals(1, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + var metadata = Map.of( + "server", value("Neo4j/3.5.0"), + "connection_id", value("bolt-42")); + + messageDispatcher.handleSuccessMessage(metadata); + + assertTrue(promise.isDone()); + assertTrue(promise.isSuccess()); + verify(clock).millis(); + assertTrue(latestAuthMillisFuture.isDone()); + assertEquals(time, latestAuthMillisFuture.join()); + } + + @Test + void shouldFailToInitializeChannelWhenErrorIsReceived() { + var promise = channel.newPromise(); + + protocol.initializeChannel( + "MyDriver/2.2.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + mock(Clock.class), + new CompletableFuture<>()); + + assertThat(channel.outboundMessages(), hasSize(1)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertEquals(1, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + messageDispatcher.handleFailureMessage("Neo.TransientError.General.DatabaseUnavailable", "Error!"); + + assertTrue(promise.isDone()); + assertFalse(promise.isSuccess()); + } + + @Test + void shouldBeginTransactionWithoutBookmark() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarks() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx100"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarksAndConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx4242"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldCommitTransaction() { + var bookmarkString = "neo4j:bookmark:v1:tx4242"; + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var commitHandler = (CommitTxResponseHandler) invocation.getArgument(1); + commitHandler.onSuccess(Map.of("bookmark", value(bookmarkString))); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.commitTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); + then(handler).should().onSummary(bookmarkString); + } + + @Test + void shouldRollbackTransaction() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var rollbackHandler = (RollbackTxResponseHandler) invocation.getArgument(1); + rollbackHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.rollbackTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) + throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx65"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx163"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(false, null, Collections.emptyMap(), mode); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(true); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(false); + } + + @Test + void databaseNameInBeginTransaction() { + testDatabaseNameSupport(false); + } + + @Test + void databaseNameForAutoCommitTransactions() { + testDatabaseNameSupport(true); + } + + @Test + void shouldSupportDatabaseNameInBeginTransaction() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.beginTransaction( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldNotSupportDatabaseNameForAutoCommitTransactions() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.runAuto( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldReturnFailedStageWithNoConnectionInteractionsOnTelemetry() { + var connection = mock(Connection.class); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var future = protocol.telemetry(connection, 1, handler).toCompletableFuture(); + + assertTrue(future.isCompletedExceptionally()); + then(connection).shouldHaveNoInteractions(); + } + + private Class expectedMessageFormatType() { + return MessageFormatV4.class; + } + + private void testFailedRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onFailure(error); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onError(error); + } + + private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedRunStage = CompletableFuture.completedStage(null); + var expectedPullStage = CompletableFuture.completedStage(null); + var newBookmarkValue = "neo4j:bookmark:v1:tx98765"; + given(connection.write(any(), any())) + .willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedRunStage; + }) + .willAnswer((Answer>) invocation -> { + var pullHandler = (PullResponseHandlerImpl) invocation.getArgument(1); + pullHandler.onSuccess( + Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue))); + return expectedPullStage; + }); + @SuppressWarnings("unchecked") + var runHandler = (MessageHandler) mock(MessageHandler.class); + var pullHandler = mock(PullMessageHandler.class); + + var runStage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + runHandler, + NoopLoggingProvider.INSTANCE); + var pullStage = protocol.pull(connection, 0, UNLIMITED_FETCH_SIZE, pullHandler); + + assertEquals(expectedRunStage, runStage); + assertEquals(expectedPullStage, pullStage); + var runMessage = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(runMessage), any(RunResponseHandler.class)); + var pullMessage = new PullMessage(UNLIMITED_FETCH_SIZE, 0L); + then(connection).should().write(eq(pullMessage), any(PullResponseHandlerImpl.class)); + then(runHandler).should().onSummary(any()); + then(pullHandler) + .should() + .onSummary(new PullResponseHandlerImpl.PullSummaryImpl( + false, Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue)))); + } + + protected void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success) throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + if (success) { + runHandler.onSuccess(emptyMap()); + } else { + runHandler.onFailure(error); + } + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + if (success) { + then(handler).should().onSummary(any()); + } else { + then(handler).should().onError(error); + } + } + + protected void testRunAndWaitForRunResponse( + boolean autoCommitTx, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var initialBookmarks = Collections.singleton("neo4j:bookmark:v1:tx987"); + + if (autoCommitTx) { + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + initialBookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + initialBookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } + + private void testDatabaseNameSupport(boolean autoCommitTx) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + if (autoCommitTx) { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + Collections.emptySet(), + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v42/MessageFormatV42Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v42/MessageFormatV42Test.java similarity index 77% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v42/MessageFormatV42Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v42/MessageFormatV42Test.java index ef9985baa0..b27ed2d308 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v42/MessageFormatV42Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v42/MessageFormatV42Test.java @@ -14,18 +14,18 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v42; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v42; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.instanceOf; import static org.mockito.Mockito.mock; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.common.CommonMessageReader; -import org.neo4j.driver.internal.messaging.v4.MessageWriterV4; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonMessageReader; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v4.MessageWriterV4; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; /** * The MessageFormat under tests is the one provided by the {@link BoltProtocolV42} and not an specific class implementation. diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v42/MessageReaderV42Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v42/MessageReaderV42Test.java similarity index 84% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v42/MessageReaderV42Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v42/MessageReaderV42Test.java index c351866e03..e296c23e8f 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v42/MessageReaderV42Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v42/MessageReaderV42Test.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v42; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v42; import static java.util.Arrays.asList; import static java.util.Calendar.APRIL; @@ -41,15 +41,15 @@ import org.neo4j.driver.Values; import org.neo4j.driver.internal.InternalPoint2D; import org.neo4j.driver.internal.InternalPoint3D; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.DiscardAllMessage; -import org.neo4j.driver.internal.messaging.response.FailureMessage; -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.packstream.PackInput; -import org.neo4j.driver.internal.util.messaging.AbstractMessageReaderTestBase; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.FailureMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.IgnoredMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.RecordMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.SuccessMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.AbstractMessageReaderTestBase; /** * The MessageReader under tests is the one provided by the {@link BoltProtocolV42} and not an specific class implementation. diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v42/MessageWriterV42Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v42/MessageWriterV42Test.java similarity index 56% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v42/MessageWriterV42Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v42/MessageWriterV42Test.java index 51034a07a9..f55158b5d4 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v42/MessageWriterV42Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v42/MessageWriterV42Test.java @@ -14,27 +14,27 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v42; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v42; import static java.time.Duration.ofSeconds; import static java.util.Calendar.DECEMBER; import static java.util.Collections.emptyMap; import static java.util.Collections.singletonMap; -import static org.neo4j.driver.AccessMode.READ; -import static org.neo4j.driver.AccessMode.WRITE; import static org.neo4j.driver.AuthTokens.basic; import static org.neo4j.driver.Values.point; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.messaging.request.CommitMessage.COMMIT; -import static org.neo4j.driver.internal.messaging.request.DiscardAllMessage.DISCARD_ALL; -import static org.neo4j.driver.internal.messaging.request.GoodbyeMessage.GOODBYE; -import static org.neo4j.driver.internal.messaging.request.PullAllMessage.PULL_ALL; -import static org.neo4j.driver.internal.messaging.request.ResetMessage.RESET; -import static org.neo4j.driver.internal.messaging.request.RollbackMessage.ROLLBACK; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; +import static org.neo4j.driver.internal.bolt.api.AccessMode.READ; +import static org.neo4j.driver.internal.bolt.api.AccessMode.WRITE; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage.COMMIT; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage.DISCARD_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage.GOODBYE; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage.PULL_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage.RESET; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage.ROLLBACK; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; import java.time.LocalDate; import java.time.LocalDateTime; @@ -45,22 +45,21 @@ import java.time.ZonedDateTime; import java.util.Collections; import java.util.stream.Stream; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.DiscardMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.BoltAgentUtil; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.AbstractMessageWriterTestBase; import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.util.messaging.AbstractMessageWriterTestBase; /** - * The MessageWriter under tests is the one provided by the {@link BoltProtocolV42} and not an specific class implementation. + * The MessageWriter under tests is the one provided by the {@link BoltProtocolV42} and not an specific class + * implementation. *

* It's done on this way to make easy to replace the implementation and still getting the same behaviour. */ @@ -74,29 +73,26 @@ protected MessageFormat.Writer newWriter(PackOutput output) { protected Stream supportedMessages() { return Stream.of( // Bolt V2 Data Types - unmanagedTxRunMessage(new Query("RETURN $point", singletonMap("point", point(42, 12.99, -180.0)))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 12.99, -180.0))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123))), + unmanagedTxRunMessage("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L)))), unmanagedTxRunMessage( - new Query("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123)))), + "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN)))), + unmanagedTxRunMessage("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888)))), unmanagedTxRunMessage( - new Query("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L))))), - unmanagedTxRunMessage(new Query( - "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN))))), - unmanagedTxRunMessage( - new Query("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888))))), - unmanagedTxRunMessage(new Query( "RETURN $dateTime", - singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199))))), - unmanagedTxRunMessage(new Query( + singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199)))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", value(ZonedDateTime.of( - 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30)))))), - unmanagedTxRunMessage(new Query( + 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30))))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", - value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm")))))), + value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm"))))), // New Bolt V4 messages new PullMessage(100, 200), @@ -112,7 +108,7 @@ protected Stream supportedMessages() { null), GOODBYE, new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), READ, @@ -120,9 +116,9 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), WRITE, @@ -130,35 +126,38 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), COMMIT, ROLLBACK, RESET, autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), defaultDatabase(), READ, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), database("foo"), WRITE, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN 1")), + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN 1", Collections.emptyMap()), // Bolt V3 messages with struct values autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), defaultDatabase(), @@ -166,9 +165,10 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), database("foo"), @@ -176,8 +176,8 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN $x", singletonMap("x", point(42, 1, 2, 3))))); + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN $x", singletonMap("x", point(42, 1, 2, 3)))); } @Override diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/BoltProtocolV43Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/BoltProtocolV43Test.java new file mode 100644 index 0000000000..483c63ef4f --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/BoltProtocolV43Test.java @@ -0,0 +1,781 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v43; + +import static java.time.Duration.ofSeconds; +import static java.util.Collections.emptyMap; +import static java.util.Collections.singletonMap; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.hasSize; +import static org.hamcrest.Matchers.instanceOf; +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.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +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.mockito.Mockito.when; +import static org.neo4j.driver.Values.value; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; + +import io.netty.channel.embedded.EmbeddedChannel; +import java.time.Clock; +import java.time.Duration; +import java.util.Collections; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +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.EnumSource; +import org.mockito.stubbing.Answer; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.BeginTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.CommitTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.PullResponseHandlerImpl; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RollbackTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RunResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.PullMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; + +public final class BoltProtocolV43Test { + protected static final String query = "RETURN $x"; + protected static final Map query_params = singletonMap("x", value(42)); + private static final long UNLIMITED_FETCH_SIZE = -1; + private static final Duration txTimeout = ofSeconds(12); + private static final Map txMetadata = singletonMap("x", value(42)); + + private final BoltProtocol protocol = createProtocol(); + private final EmbeddedChannel channel = new EmbeddedChannel(); + private final InboundMessageDispatcher messageDispatcher = + new InboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE); + + @SuppressWarnings("SameReturnValue") + private BoltProtocol createProtocol() { + return BoltProtocolV43.INSTANCE; + } + + @BeforeEach + void beforeEach() { + ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); + } + + @AfterEach + void afterEach() { + channel.finishAndReleaseAll(); + } + + @Test + void shouldCreateMessageFormat() { + assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); + } + + @Test + void shouldInitializeChannel() { + var promise = channel.newPromise(); + var clock = mock(Clock.class); + var time = 1L; + when(clock.millis()).thenReturn(time); + + var latestAuthMillisFuture = new CompletableFuture(); + + protocol.initializeChannel( + "MyDriver/0.0.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + clock, + latestAuthMillisFuture); + + assertThat(channel.outboundMessages(), hasSize(1)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertEquals(1, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + var metadata = Map.of( + "server", value("Neo4j/3.5.0"), + "connection_id", value("bolt-42")); + + messageDispatcher.handleSuccessMessage(metadata); + + assertTrue(promise.isDone()); + assertTrue(promise.isSuccess()); + verify(clock).millis(); + assertTrue(latestAuthMillisFuture.isDone()); + assertEquals(time, latestAuthMillisFuture.join()); + } + + @Test + void shouldFailToInitializeChannelWhenErrorIsReceived() { + var promise = channel.newPromise(); + + protocol.initializeChannel( + "MyDriver/2.2.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + mock(Clock.class), + new CompletableFuture<>()); + + assertThat(channel.outboundMessages(), hasSize(1)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertEquals(1, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + messageDispatcher.handleFailureMessage("Neo.TransientError.General.DatabaseUnavailable", "Error!"); + + assertTrue(promise.isDone()); + assertFalse(promise.isSuccess()); + } + + @Test + void shouldBeginTransactionWithoutBookmark() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarks() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx100"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarksAndConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx4242"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldCommitTransaction() { + var bookmarkString = "neo4j:bookmark:v1:tx4242"; + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var commitHandler = (CommitTxResponseHandler) invocation.getArgument(1); + commitHandler.onSuccess(Map.of("bookmark", value(bookmarkString))); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.commitTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); + then(handler).should().onSummary(bookmarkString); + } + + @Test + void shouldRollbackTransaction() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var rollbackHandler = (RollbackTxResponseHandler) invocation.getArgument(1); + rollbackHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.rollbackTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) + throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx65"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx163"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(false, null, Collections.emptyMap(), mode); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(true); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(false); + } + + @Test + void databaseNameInBeginTransaction() { + testDatabaseNameSupport(false); + } + + @Test + void databaseNameForAutoCommitTransactions() { + testDatabaseNameSupport(true); + } + + @Test + void shouldSupportDatabaseNameInBeginTransaction() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.beginTransaction( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldNotSupportDatabaseNameForAutoCommitTransactions() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.runAuto( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldReturnFailedStageWithNoConnectionInteractionsOnTelemetry() { + var connection = mock(Connection.class); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var future = protocol.telemetry(connection, 1, handler).toCompletableFuture(); + + assertTrue(future.isCompletedExceptionally()); + then(connection).shouldHaveNoInteractions(); + } + + private Class expectedMessageFormatType() { + return MessageFormatV43.class; + } + + private void testFailedRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onFailure(error); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onError(error); + } + + private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedRunStage = CompletableFuture.completedStage(null); + var expectedPullStage = CompletableFuture.completedStage(null); + var newBookmarkValue = "neo4j:bookmark:v1:tx98765"; + given(connection.write(any(), any())) + .willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedRunStage; + }) + .willAnswer((Answer>) invocation -> { + var pullHandler = (PullResponseHandlerImpl) invocation.getArgument(1); + pullHandler.onSuccess( + Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue))); + return expectedPullStage; + }); + @SuppressWarnings("unchecked") + var runHandler = (MessageHandler) mock(MessageHandler.class); + var pullHandler = mock(PullMessageHandler.class); + + var runStage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + runHandler, + NoopLoggingProvider.INSTANCE); + var pullStage = protocol.pull(connection, 0, UNLIMITED_FETCH_SIZE, pullHandler); + + assertEquals(expectedRunStage, runStage); + assertEquals(expectedPullStage, pullStage); + var runMessage = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(runMessage), any(RunResponseHandler.class)); + var pullMessage = new PullMessage(UNLIMITED_FETCH_SIZE, 0L); + then(connection).should().write(eq(pullMessage), any(PullResponseHandlerImpl.class)); + then(runHandler).should().onSummary(any()); + then(pullHandler) + .should() + .onSummary(new PullResponseHandlerImpl.PullSummaryImpl( + false, Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue)))); + } + + protected void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success) throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + if (success) { + runHandler.onSuccess(emptyMap()); + } else { + runHandler.onFailure(error); + } + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + if (success) { + then(handler).should().onSummary(any()); + } else { + then(handler).should().onError(error); + } + } + + protected void testRunAndWaitForRunResponse( + boolean autoCommitTx, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var initialBookmarks = Collections.singleton("neo4j:bookmark:v1:tx987"); + + if (autoCommitTx) { + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + initialBookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + initialBookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } + + private void testDatabaseNameSupport(boolean autoCommitTx) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + if (autoCommitTx) { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + Collections.emptySet(), + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v43/MessageFormatV43Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/MessageFormatV43Test.java similarity index 81% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v43/MessageFormatV43Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/MessageFormatV43Test.java index 531832d6e1..e4e222bd22 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v43/MessageFormatV43Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/MessageFormatV43Test.java @@ -14,17 +14,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v43; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v43; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.instanceOf; import static org.mockito.Mockito.mock; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.common.CommonMessageReader; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonMessageReader; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; /** * The MessageFormat under tests is the one provided by the {@link BoltProtocolV43} and not an specific class implementation. diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v43/MessageReaderV43Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/MessageReaderV43Test.java similarity index 83% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v43/MessageReaderV43Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/MessageReaderV43Test.java index 1db6597b68..e4987e9968 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v43/MessageReaderV43Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/MessageReaderV43Test.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v43; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v43; import static java.util.Arrays.asList; import static java.util.Calendar.APRIL; @@ -41,16 +41,16 @@ import org.neo4j.driver.Values; import org.neo4j.driver.internal.InternalPoint2D; import org.neo4j.driver.internal.InternalPoint3D; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.DiscardAllMessage; -import org.neo4j.driver.internal.messaging.response.FailureMessage; -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.messaging.v42.BoltProtocolV42; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.util.messaging.AbstractMessageReaderTestBase; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.FailureMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.IgnoredMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.RecordMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.SuccessMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v42.BoltProtocolV42; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.AbstractMessageReaderTestBase; /** * The MessageReader under tests is the one provided by the {@link BoltProtocolV43} and not an specific class implementation. diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v43/MessageWriterV43Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/MessageWriterV43Test.java similarity index 58% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v43/MessageWriterV43Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/MessageWriterV43Test.java index d9a852640a..4dfdb782bb 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v43/MessageWriterV43Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v43/MessageWriterV43Test.java @@ -14,27 +14,27 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v43; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v43; import static java.time.Duration.ofSeconds; import static java.util.Calendar.DECEMBER; import static java.util.Collections.emptyMap; import static java.util.Collections.singletonMap; -import static org.neo4j.driver.AccessMode.READ; -import static org.neo4j.driver.AccessMode.WRITE; import static org.neo4j.driver.AuthTokens.basic; import static org.neo4j.driver.Values.point; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.messaging.request.CommitMessage.COMMIT; -import static org.neo4j.driver.internal.messaging.request.DiscardAllMessage.DISCARD_ALL; -import static org.neo4j.driver.internal.messaging.request.GoodbyeMessage.GOODBYE; -import static org.neo4j.driver.internal.messaging.request.PullAllMessage.PULL_ALL; -import static org.neo4j.driver.internal.messaging.request.ResetMessage.RESET; -import static org.neo4j.driver.internal.messaging.request.RollbackMessage.ROLLBACK; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; +import static org.neo4j.driver.internal.bolt.api.AccessMode.READ; +import static org.neo4j.driver.internal.bolt.api.AccessMode.WRITE; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage.COMMIT; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage.DISCARD_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage.GOODBYE; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage.PULL_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage.RESET; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage.ROLLBACK; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; import java.time.LocalDate; import java.time.LocalDateTime; @@ -47,25 +47,24 @@ import java.util.HashMap; import java.util.Map; import java.util.stream.Stream; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; import org.neo4j.driver.Value; import org.neo4j.driver.Values; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.DiscardMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RouteMessage; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.BoltAgentUtil; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RouteMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.AbstractMessageWriterTestBase; import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.util.messaging.AbstractMessageWriterTestBase; /** - * The MessageWriter under tests is the one provided by the {@link BoltProtocolV43} and not an specific class implementation. + * The MessageWriter under tests is the one provided by the {@link BoltProtocolV43} and not an specific class + * implementation. *

* It's done on this way to make easy to replace the implementation and still getting the same behaviour. */ @@ -79,29 +78,26 @@ protected MessageFormat.Writer newWriter(PackOutput output) { protected Stream supportedMessages() { return Stream.of( // Bolt V2 Data Types - unmanagedTxRunMessage(new Query("RETURN $point", singletonMap("point", point(42, 12.99, -180.0)))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 12.99, -180.0))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123))), + unmanagedTxRunMessage("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L)))), unmanagedTxRunMessage( - new Query("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123)))), + "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN)))), + unmanagedTxRunMessage("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888)))), unmanagedTxRunMessage( - new Query("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L))))), - unmanagedTxRunMessage(new Query( - "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN))))), - unmanagedTxRunMessage( - new Query("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888))))), - unmanagedTxRunMessage(new Query( "RETURN $dateTime", - singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199))))), - unmanagedTxRunMessage(new Query( + singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199)))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", value(ZonedDateTime.of( - 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30)))))), - unmanagedTxRunMessage(new Query( + 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30))))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", - value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm")))))), + value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm"))))), // New Bolt V4 messages new PullMessage(100, 200), @@ -117,7 +113,7 @@ protected Stream supportedMessages() { null), GOODBYE, new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), READ, @@ -125,9 +121,9 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), WRITE, @@ -135,35 +131,38 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), COMMIT, ROLLBACK, RESET, autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), defaultDatabase(), READ, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), database("foo"), WRITE, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN 1")), + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN 1", Collections.emptyMap()), // Bolt V3 messages with struct values autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), defaultDatabase(), @@ -171,9 +170,10 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), database("foo"), @@ -181,8 +181,8 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN $x", singletonMap("x", point(42, 1, 2, 3)))), + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN $x", singletonMap("x", point(42, 1, 2, 3))), // New 4.3 Messages routeMessage()); diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/BoltProtocolV44Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/BoltProtocolV44Test.java new file mode 100644 index 0000000000..4ee708b4cf --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/BoltProtocolV44Test.java @@ -0,0 +1,745 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v44; + +import static java.time.Duration.ofSeconds; +import static java.util.Collections.emptyMap; +import static java.util.Collections.singletonMap; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.hasSize; +import static org.hamcrest.Matchers.instanceOf; +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.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +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.mockito.Mockito.when; +import static org.neo4j.driver.Values.value; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; + +import io.netty.channel.embedded.EmbeddedChannel; +import java.time.Clock; +import java.time.Duration; +import java.util.Collections; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +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.EnumSource; +import org.mockito.stubbing.Answer; +import org.neo4j.driver.TransactionConfig; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.BeginTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.CommitTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.PullResponseHandlerImpl; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RollbackTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RunResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.PullMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; + +public class BoltProtocolV44Test { + protected static final String query = "RETURN $x"; + protected static final Map query_params = singletonMap("x", value(42)); + private static final long UNLIMITED_FETCH_SIZE = -1; + private static final Duration txTimeout = ofSeconds(12); + private static final Map txMetadata = singletonMap("x", value(42)); + + protected final BoltProtocol protocol = createProtocol(); + private final EmbeddedChannel channel = new EmbeddedChannel(); + private final InboundMessageDispatcher messageDispatcher = + new InboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE); + + private final TransactionConfig txConfig = TransactionConfig.builder() + .withTimeout(ofSeconds(12)) + .withMetadata(singletonMap("key", value(42))) + .build(); + + @SuppressWarnings("SameReturnValue") + protected BoltProtocol createProtocol() { + return BoltProtocolV44.INSTANCE; + } + + @BeforeEach + void beforeEach() { + ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); + } + + @AfterEach + void afterEach() { + channel.finishAndReleaseAll(); + } + + @Test + void shouldCreateMessageFormat() { + assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); + } + + @Test + void shouldInitializeChannel() { + var promise = channel.newPromise(); + var clock = mock(Clock.class); + var time = 1L; + when(clock.millis()).thenReturn(time); + + var latestAuthMillisFuture = new CompletableFuture(); + + protocol.initializeChannel( + "MyDriver/0.0.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + clock, + latestAuthMillisFuture); + + assertThat(channel.outboundMessages(), hasSize(1)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertEquals(1, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + var metadata = Map.of( + "server", value("Neo4j/3.5.0"), + "connection_id", value("bolt-42")); + + messageDispatcher.handleSuccessMessage(metadata); + + assertTrue(promise.isDone()); + assertTrue(promise.isSuccess()); + verify(clock).millis(); + assertTrue(latestAuthMillisFuture.isDone()); + assertEquals(time, latestAuthMillisFuture.join()); + } + + @Test + void shouldFailToInitializeChannelWhenErrorIsReceived() { + var promise = channel.newPromise(); + + protocol.initializeChannel( + "MyDriver/2.2.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + mock(Clock.class), + new CompletableFuture<>()); + + assertThat(channel.outboundMessages(), hasSize(1)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertEquals(1, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + messageDispatcher.handleFailureMessage("Neo.TransientError.General.DatabaseUnavailable", "Error!"); + + assertTrue(promise.isDone()); + assertFalse(promise.isSuccess()); + } + + @Test + void shouldBeginTransactionWithoutBookmark() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarks() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx100"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldCommitTransaction() { + var bookmarkString = "neo4j:bookmark:v1:tx4242"; + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var commitHandler = (CommitTxResponseHandler) invocation.getArgument(1); + commitHandler.onSuccess(Map.of("bookmark", value(bookmarkString))); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.commitTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); + then(handler).should().onSummary(bookmarkString); + } + + @Test + void shouldRollbackTransaction() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var rollbackHandler = (RollbackTxResponseHandler) invocation.getArgument(1); + rollbackHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.rollbackTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) + throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx65"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx163"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(false, null, Collections.emptyMap(), mode); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(true); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(false); + } + + @Test + void databaseNameInBeginTransaction() { + testDatabaseNameSupport(false); + } + + @Test + void databaseNameForAutoCommitTransactions() { + testDatabaseNameSupport(true); + } + + @Test + void shouldSupportDatabaseNameInBeginTransaction() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.beginTransaction( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldNotSupportDatabaseNameForAutoCommitTransactions() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.runAuto( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldReturnFailedStageWithNoConnectionInteractionsOnTelemetry() { + var connection = mock(Connection.class); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var future = protocol.telemetry(connection, 1, handler).toCompletableFuture(); + + assertTrue(future.isCompletedExceptionally()); + then(connection).shouldHaveNoInteractions(); + } + + private Class expectedMessageFormatType() { + return MessageFormatV44.class; + } + + private void testFailedRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onFailure(error); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onError(error); + } + + private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedRunStage = CompletableFuture.completedStage(null); + var expectedPullStage = CompletableFuture.completedStage(null); + var newBookmarkValue = "neo4j:bookmark:v1:tx98765"; + given(connection.write(any(), any())) + .willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedRunStage; + }) + .willAnswer((Answer>) invocation -> { + var pullHandler = (PullResponseHandlerImpl) invocation.getArgument(1); + pullHandler.onSuccess( + Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue))); + return expectedPullStage; + }); + @SuppressWarnings("unchecked") + var runHandler = (MessageHandler) mock(MessageHandler.class); + var pullHandler = mock(PullMessageHandler.class); + + var runStage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + runHandler, + NoopLoggingProvider.INSTANCE); + var pullStage = protocol.pull(connection, 0, UNLIMITED_FETCH_SIZE, pullHandler); + + assertEquals(expectedRunStage, runStage); + assertEquals(expectedPullStage, pullStage); + var runMessage = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(runMessage), any(RunResponseHandler.class)); + var pullMessage = new PullMessage(UNLIMITED_FETCH_SIZE, 0L); + then(connection).should().write(eq(pullMessage), any(PullResponseHandlerImpl.class)); + then(runHandler).should().onSummary(any()); + then(pullHandler) + .should() + .onSummary(new PullResponseHandlerImpl.PullSummaryImpl( + false, Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue)))); + } + + protected void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success) throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + if (success) { + runHandler.onSuccess(emptyMap()); + } else { + runHandler.onFailure(error); + } + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + if (success) { + then(handler).should().onSummary(any()); + } else { + then(handler).should().onError(error); + } + } + + protected void testRunAndWaitForRunResponse( + boolean autoCommitTx, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var initialBookmarks = Collections.singleton("neo4j:bookmark:v1:tx987"); + + if (autoCommitTx) { + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + initialBookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + initialBookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } + + private void testDatabaseNameSupport(boolean autoCommitTx) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + if (autoCommitTx) { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + Collections.emptySet(), + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v44/MessageFormatV44Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/MessageFormatV44Test.java similarity index 78% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v44/MessageFormatV44Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/MessageFormatV44Test.java index f619978358..b256dcbb65 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v44/MessageFormatV44Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/MessageFormatV44Test.java @@ -14,17 +14,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v44; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v44; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.instanceOf; import static org.mockito.Mockito.mock; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.common.CommonMessageReader; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonMessageReader; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; public class MessageFormatV44Test { private static final MessageFormat format = BoltProtocolV44.INSTANCE.createMessageFormat(); diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v44/MessageReaderV44Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/MessageReaderV44Test.java similarity index 84% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v44/MessageReaderV44Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/MessageReaderV44Test.java index d49fecdaf7..9671c81318 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v44/MessageReaderV44Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/MessageReaderV44Test.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v44; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v44; import static java.util.Arrays.asList; import static java.util.Calendar.APRIL; @@ -41,15 +41,15 @@ import org.neo4j.driver.Values; import org.neo4j.driver.internal.InternalPoint2D; import org.neo4j.driver.internal.InternalPoint3D; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.DiscardAllMessage; -import org.neo4j.driver.internal.messaging.response.FailureMessage; -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.packstream.PackInput; -import org.neo4j.driver.internal.util.messaging.AbstractMessageReaderTestBase; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.FailureMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.IgnoredMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.RecordMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.SuccessMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.AbstractMessageReaderTestBase; /** * The MessageReader under tests is the one provided by the {@link BoltProtocolV44} and not a specific class implementation. diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v44/MessageWriterV44Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/MessageWriterV44Test.java similarity index 58% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v44/MessageWriterV44Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/MessageWriterV44Test.java index 7096fc98ee..6000fa07ba 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v44/MessageWriterV44Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v44/MessageWriterV44Test.java @@ -14,27 +14,27 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v44; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v44; import static java.time.Duration.ofSeconds; import static java.util.Calendar.DECEMBER; import static java.util.Collections.emptyMap; import static java.util.Collections.singletonMap; -import static org.neo4j.driver.AccessMode.READ; -import static org.neo4j.driver.AccessMode.WRITE; import static org.neo4j.driver.AuthTokens.basic; import static org.neo4j.driver.Values.point; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.messaging.request.CommitMessage.COMMIT; -import static org.neo4j.driver.internal.messaging.request.DiscardAllMessage.DISCARD_ALL; -import static org.neo4j.driver.internal.messaging.request.GoodbyeMessage.GOODBYE; -import static org.neo4j.driver.internal.messaging.request.PullAllMessage.PULL_ALL; -import static org.neo4j.driver.internal.messaging.request.ResetMessage.RESET; -import static org.neo4j.driver.internal.messaging.request.RollbackMessage.ROLLBACK; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; +import static org.neo4j.driver.internal.bolt.api.AccessMode.READ; +import static org.neo4j.driver.internal.bolt.api.AccessMode.WRITE; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage.COMMIT; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage.DISCARD_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage.GOODBYE; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage.PULL_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage.RESET; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage.ROLLBACK; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; import java.time.LocalDate; import java.time.LocalDateTime; @@ -47,25 +47,24 @@ import java.util.HashMap; import java.util.Map; import java.util.stream.Stream; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; import org.neo4j.driver.Value; import org.neo4j.driver.Values; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.DiscardMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RouteMessage; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.BoltAgentUtil; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RouteMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.AbstractMessageWriterTestBase; import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.util.messaging.AbstractMessageWriterTestBase; /** - * The MessageWriter under tests is the one provided by the {@link BoltProtocolV44} and not a specific class implementation. + * The MessageWriter under tests is the one provided by the {@link BoltProtocolV44} and not a specific class + * implementation. *

* It's done on this way to make easy to replace the implementation and still getting the same behaviour. */ @@ -79,29 +78,26 @@ protected MessageFormat.Writer newWriter(PackOutput output) { protected Stream supportedMessages() { return Stream.of( // Bolt V2 Data Types - unmanagedTxRunMessage(new Query("RETURN $point", singletonMap("point", point(42, 12.99, -180.0)))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 12.99, -180.0))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123))), + unmanagedTxRunMessage("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L)))), unmanagedTxRunMessage( - new Query("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123)))), + "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN)))), + unmanagedTxRunMessage("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888)))), unmanagedTxRunMessage( - new Query("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L))))), - unmanagedTxRunMessage(new Query( - "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN))))), - unmanagedTxRunMessage( - new Query("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888))))), - unmanagedTxRunMessage(new Query( "RETURN $dateTime", - singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199))))), - unmanagedTxRunMessage(new Query( + singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199)))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", value(ZonedDateTime.of( - 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30)))))), - unmanagedTxRunMessage(new Query( + 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30))))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", - value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm")))))), + value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm"))))), // New Bolt V4 messages new PullMessage(100, 200), @@ -117,7 +113,7 @@ protected Stream supportedMessages() { null), GOODBYE, new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), READ, @@ -125,9 +121,9 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), WRITE, @@ -135,35 +131,38 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), COMMIT, ROLLBACK, RESET, autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), defaultDatabase(), READ, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), database("foo"), WRITE, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN 1")), + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN 1", Collections.emptyMap()), // Bolt V3 messages with struct values autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), defaultDatabase(), @@ -171,9 +170,10 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), database("foo"), @@ -181,8 +181,8 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN $x", singletonMap("x", point(42, 1, 2, 3)))), + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN $x", singletonMap("x", point(42, 1, 2, 3))), // New 4.3 Messages routeMessage()); diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/BoltProtocolV5Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/BoltProtocolV5Test.java new file mode 100644 index 0000000000..63363fa9c6 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/BoltProtocolV5Test.java @@ -0,0 +1,787 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v5; + +import static java.time.Duration.ofSeconds; +import static java.util.Collections.emptyMap; +import static java.util.Collections.singletonMap; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.hasSize; +import static org.hamcrest.Matchers.instanceOf; +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.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +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.mockito.Mockito.when; +import static org.neo4j.driver.Values.value; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; + +import io.netty.channel.embedded.EmbeddedChannel; +import java.time.Clock; +import java.time.Duration; +import java.util.Collections; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +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.EnumSource; +import org.mockito.stubbing.Answer; +import org.neo4j.driver.TransactionConfig; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.BeginTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.CommitTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.PullResponseHandlerImpl; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RollbackTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RunResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.PullMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; + +public class BoltProtocolV5Test { + protected static final String query = "RETURN $x"; + protected static final Map query_params = singletonMap("x", value(42)); + private static final long UNLIMITED_FETCH_SIZE = -1; + private static final Duration txTimeout = ofSeconds(12); + private static final Map txMetadata = singletonMap("x", value(42)); + + protected final BoltProtocol protocol = createProtocol(); + private final EmbeddedChannel channel = new EmbeddedChannel(); + private final InboundMessageDispatcher messageDispatcher = + new InboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE); + + private final TransactionConfig txConfig = TransactionConfig.builder() + .withTimeout(ofSeconds(12)) + .withMetadata(singletonMap("key", value(42))) + .build(); + + @SuppressWarnings("SameReturnValue") + protected BoltProtocol createProtocol() { + return BoltProtocolV5.INSTANCE; + } + + @BeforeEach + void beforeEach() { + ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); + } + + @AfterEach + void afterEach() { + channel.finishAndReleaseAll(); + } + + @Test + void shouldCreateMessageFormat() { + assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); + } + + @Test + void shouldInitializeChannel() { + var promise = channel.newPromise(); + var clock = mock(Clock.class); + var time = 1L; + when(clock.millis()).thenReturn(time); + + var latestAuthMillisFuture = new CompletableFuture(); + + protocol.initializeChannel( + "MyDriver/0.0.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + clock, + latestAuthMillisFuture); + + assertThat(channel.outboundMessages(), hasSize(1)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertEquals(1, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + var metadata = Map.of( + "server", value("Neo4j/3.5.0"), + "connection_id", value("bolt-42")); + + messageDispatcher.handleSuccessMessage(metadata); + + assertTrue(promise.isDone()); + assertTrue(promise.isSuccess()); + verify(clock).millis(); + assertTrue(latestAuthMillisFuture.isDone()); + assertEquals(time, latestAuthMillisFuture.join()); + } + + @Test + void shouldFailToInitializeChannelWhenErrorIsReceived() { + var promise = channel.newPromise(); + + protocol.initializeChannel( + "MyDriver/2.2.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + mock(Clock.class), + new CompletableFuture<>()); + + assertThat(channel.outboundMessages(), hasSize(1)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertEquals(1, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + messageDispatcher.handleFailureMessage("Neo.TransientError.General.DatabaseUnavailable", "Error!"); + + assertTrue(promise.isDone()); + assertFalse(promise.isSuccess()); + } + + @Test + void shouldBeginTransactionWithoutBookmark() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarks() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx100"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarksAndConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx4242"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldCommitTransaction() { + var bookmarkString = "neo4j:bookmark:v1:tx4242"; + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var commitHandler = (CommitTxResponseHandler) invocation.getArgument(1); + commitHandler.onSuccess(Map.of("bookmark", value(bookmarkString))); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.commitTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); + then(handler).should().onSummary(bookmarkString); + } + + @Test + void shouldRollbackTransaction() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var rollbackHandler = (RollbackTxResponseHandler) invocation.getArgument(1); + rollbackHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.rollbackTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) + throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx65"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx163"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(false, null, Collections.emptyMap(), mode); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(true); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(false); + } + + @Test + void databaseNameInBeginTransaction() { + testDatabaseNameSupport(false); + } + + @Test + void databaseNameForAutoCommitTransactions() { + testDatabaseNameSupport(true); + } + + @Test + void shouldSupportDatabaseNameInBeginTransaction() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.beginTransaction( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldNotSupportDatabaseNameForAutoCommitTransactions() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.runAuto( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldReturnFailedStageWithNoConnectionInteractionsOnTelemetry() { + var connection = mock(Connection.class); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var future = protocol.telemetry(connection, 1, handler).toCompletableFuture(); + + assertTrue(future.isCompletedExceptionally()); + then(connection).shouldHaveNoInteractions(); + } + + private Class expectedMessageFormatType() { + return MessageFormatV5.class; + } + + private void testFailedRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onFailure(error); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onError(error); + } + + private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedRunStage = CompletableFuture.completedStage(null); + var expectedPullStage = CompletableFuture.completedStage(null); + var newBookmarkValue = "neo4j:bookmark:v1:tx98765"; + given(connection.write(any(), any())) + .willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedRunStage; + }) + .willAnswer((Answer>) invocation -> { + var pullHandler = (PullResponseHandlerImpl) invocation.getArgument(1); + pullHandler.onSuccess( + Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue))); + return expectedPullStage; + }); + @SuppressWarnings("unchecked") + var runHandler = (MessageHandler) mock(MessageHandler.class); + var pullHandler = mock(PullMessageHandler.class); + + var runStage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + runHandler, + NoopLoggingProvider.INSTANCE); + var pullStage = protocol.pull(connection, 0, UNLIMITED_FETCH_SIZE, pullHandler); + + assertEquals(expectedRunStage, runStage); + assertEquals(expectedPullStage, pullStage); + var runMessage = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(runMessage), any(RunResponseHandler.class)); + var pullMessage = new PullMessage(UNLIMITED_FETCH_SIZE, 0L); + then(connection).should().write(eq(pullMessage), any(PullResponseHandlerImpl.class)); + then(runHandler).should().onSummary(any()); + then(pullHandler) + .should() + .onSummary(new PullResponseHandlerImpl.PullSummaryImpl( + false, Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue)))); + } + + protected void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success) throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + if (success) { + runHandler.onSuccess(emptyMap()); + } else { + runHandler.onFailure(error); + } + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + if (success) { + then(handler).should().onSummary(any()); + } else { + then(handler).should().onError(error); + } + } + + protected void testRunAndWaitForRunResponse( + boolean autoCommitTx, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var initialBookmarks = Collections.singleton("neo4j:bookmark:v1:tx987"); + + if (autoCommitTx) { + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + initialBookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + initialBookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } + + private void testDatabaseNameSupport(boolean autoCommitTx) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + if (autoCommitTx) { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + Collections.emptySet(), + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v5/MessageFormatV5Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageFormatV5Test.java similarity index 82% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v5/MessageFormatV5Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageFormatV5Test.java index c1125078c0..ccae6598f2 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v5/MessageFormatV5Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageFormatV5Test.java @@ -14,16 +14,16 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v5; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v5; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.instanceOf; import static org.mockito.Mockito.mock; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; public class MessageFormatV5Test { private static final MessageFormat format = BoltProtocolV5.INSTANCE.createMessageFormat(); diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v5/MessageReaderV5Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageReaderV5Test.java similarity index 85% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v5/MessageReaderV5Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageReaderV5Test.java index 2a9bbe63cb..dd692d697b 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v5/MessageReaderV5Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageReaderV5Test.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v5; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v5; import static java.util.Arrays.asList; import static java.util.Calendar.APRIL; @@ -41,15 +41,15 @@ import org.neo4j.driver.Values; import org.neo4j.driver.internal.InternalPoint2D; import org.neo4j.driver.internal.InternalPoint3D; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.DiscardAllMessage; -import org.neo4j.driver.internal.messaging.response.FailureMessage; -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.packstream.PackInput; -import org.neo4j.driver.internal.util.messaging.AbstractMessageReaderTestBase; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.FailureMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.IgnoredMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.RecordMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.SuccessMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.AbstractMessageReaderTestBase; /** * The MessageReader under tests is the one provided by the {@link BoltProtocolV5} and not a specific class implementation. diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v5/MessageWriterV5Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageWriterV5Test.java similarity index 58% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v5/MessageWriterV5Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageWriterV5Test.java index e2f871f929..3a8145182f 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v5/MessageWriterV5Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v5/MessageWriterV5Test.java @@ -14,27 +14,27 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v5; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v5; import static java.time.Duration.ofSeconds; import static java.util.Calendar.DECEMBER; import static java.util.Collections.emptyMap; import static java.util.Collections.singletonMap; -import static org.neo4j.driver.AccessMode.READ; -import static org.neo4j.driver.AccessMode.WRITE; import static org.neo4j.driver.AuthTokens.basic; import static org.neo4j.driver.Values.point; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.messaging.request.CommitMessage.COMMIT; -import static org.neo4j.driver.internal.messaging.request.DiscardAllMessage.DISCARD_ALL; -import static org.neo4j.driver.internal.messaging.request.GoodbyeMessage.GOODBYE; -import static org.neo4j.driver.internal.messaging.request.PullAllMessage.PULL_ALL; -import static org.neo4j.driver.internal.messaging.request.ResetMessage.RESET; -import static org.neo4j.driver.internal.messaging.request.RollbackMessage.ROLLBACK; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; +import static org.neo4j.driver.internal.bolt.api.AccessMode.READ; +import static org.neo4j.driver.internal.bolt.api.AccessMode.WRITE; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage.COMMIT; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage.DISCARD_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage.GOODBYE; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage.PULL_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage.RESET; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage.ROLLBACK; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; import java.time.LocalDate; import java.time.LocalDateTime; @@ -47,25 +47,24 @@ import java.util.HashMap; import java.util.Map; import java.util.stream.Stream; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; import org.neo4j.driver.Value; import org.neo4j.driver.Values; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.DiscardMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RouteMessage; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.BoltAgentUtil; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RouteMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.AbstractMessageWriterTestBase; import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.util.messaging.AbstractMessageWriterTestBase; /** - * The MessageWriter under tests is the one provided by the {@link BoltProtocolV5} and not a specific class implementation. + * The MessageWriter under tests is the one provided by the {@link BoltProtocolV5} and not a specific class + * implementation. *

* It's done on this way to make easy to replace the implementation and still getting the same behaviour. */ @@ -79,29 +78,26 @@ protected MessageFormat.Writer newWriter(PackOutput output) { protected Stream supportedMessages() { return Stream.of( // Bolt V2 Data Types - unmanagedTxRunMessage(new Query("RETURN $point", singletonMap("point", point(42, 12.99, -180.0)))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 12.99, -180.0))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123))), + unmanagedTxRunMessage("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L)))), unmanagedTxRunMessage( - new Query("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123)))), + "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN)))), + unmanagedTxRunMessage("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888)))), unmanagedTxRunMessage( - new Query("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L))))), - unmanagedTxRunMessage(new Query( - "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN))))), - unmanagedTxRunMessage( - new Query("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888))))), - unmanagedTxRunMessage(new Query( "RETURN $dateTime", - singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199))))), - unmanagedTxRunMessage(new Query( + singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199)))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", value(ZonedDateTime.of( - 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30)))))), - unmanagedTxRunMessage(new Query( + 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30))))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", - value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm")))))), + value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm"))))), // New Bolt V4 messages new PullMessage(100, 200), @@ -117,7 +113,7 @@ protected Stream supportedMessages() { null), GOODBYE, new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), READ, @@ -125,9 +121,9 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), WRITE, @@ -135,35 +131,38 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), COMMIT, ROLLBACK, RESET, autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), defaultDatabase(), READ, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), database("foo"), WRITE, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN 1")), + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN 1", Collections.emptyMap()), // Bolt V3 messages with struct values autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), defaultDatabase(), @@ -171,9 +170,10 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), database("foo"), @@ -181,8 +181,8 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN $x", singletonMap("x", point(42, 1, 2, 3)))), + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN $x", singletonMap("x", point(42, 1, 2, 3))), // New 4.3 Messages routeMessage()); diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/BoltProtocolV51Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/BoltProtocolV51Test.java new file mode 100644 index 0000000000..f2f09209c3 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/BoltProtocolV51Test.java @@ -0,0 +1,765 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v51; + +import static java.time.Duration.ofSeconds; +import static java.util.Collections.emptyMap; +import static java.util.Collections.singletonMap; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.hasSize; +import static org.hamcrest.Matchers.instanceOf; +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.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +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.mockito.Mockito.when; +import static org.neo4j.driver.Values.value; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; + +import io.netty.channel.embedded.EmbeddedChannel; +import java.time.Clock; +import java.time.Duration; +import java.util.Collections; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +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.EnumSource; +import org.mockito.stubbing.Answer; +import org.neo4j.driver.TransactionConfig; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.BeginTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.CommitTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.PullResponseHandlerImpl; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RollbackTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RunResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.PullMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.LogonMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; + +public class BoltProtocolV51Test { + protected static final String query = "RETURN $x"; + protected static final Map query_params = singletonMap("x", value(42)); + private static final long UNLIMITED_FETCH_SIZE = -1; + private static final Duration txTimeout = ofSeconds(12); + private static final Map txMetadata = singletonMap("x", value(42)); + + protected final BoltProtocol protocol = createProtocol(); + private final EmbeddedChannel channel = new EmbeddedChannel(); + private final InboundMessageDispatcher messageDispatcher = + new InboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE); + + private final TransactionConfig txConfig = TransactionConfig.builder() + .withTimeout(ofSeconds(12)) + .withMetadata(singletonMap("key", value(42))) + .build(); + + @SuppressWarnings("SameReturnValue") + protected BoltProtocol createProtocol() { + return BoltProtocolV51.INSTANCE; + } + + @BeforeEach + void beforeEach() { + ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); + } + + @AfterEach + void afterEach() { + channel.finishAndReleaseAll(); + } + + @Test + void shouldCreateMessageFormat() { + assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); + } + + @Test + void shouldInitializeChannel() { + var promise = channel.newPromise(); + var clock = mock(Clock.class); + var time = 1L; + when(clock.millis()).thenReturn(time); + + var latestAuthMillisFuture = new CompletableFuture(); + + protocol.initializeChannel( + "MyDriver/0.0.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + clock, + latestAuthMillisFuture); + + assertThat(channel.outboundMessages(), hasSize(2)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertThat(channel.outboundMessages().poll(), instanceOf(LogonMessage.class)); + assertEquals(2, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + var metadata = Map.of( + "server", value("Neo4j/3.5.0"), + "connection_id", value("bolt-42")); + + messageDispatcher.handleSuccessMessage(metadata); + messageDispatcher.handleSuccessMessage(Collections.emptyMap()); + + assertTrue(promise.isDone()); + assertTrue(promise.isSuccess()); + verify(clock).millis(); + assertTrue(latestAuthMillisFuture.isDone()); + assertEquals(time, latestAuthMillisFuture.join()); + } + + @Test + void shouldBeginTransactionWithoutBookmark() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarks() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx100"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarksAndConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx4242"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldCommitTransaction() { + var bookmarkString = "neo4j:bookmark:v1:tx4242"; + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var commitHandler = (CommitTxResponseHandler) invocation.getArgument(1); + commitHandler.onSuccess(Map.of("bookmark", value(bookmarkString))); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.commitTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); + then(handler).should().onSummary(bookmarkString); + } + + @Test + void shouldRollbackTransaction() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var rollbackHandler = (RollbackTxResponseHandler) invocation.getArgument(1); + rollbackHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.rollbackTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) + throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx65"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx163"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(false, null, Collections.emptyMap(), mode); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(true); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(false); + } + + @Test + void databaseNameInBeginTransaction() { + testDatabaseNameSupport(false); + } + + @Test + void databaseNameForAutoCommitTransactions() { + testDatabaseNameSupport(true); + } + + @Test + void shouldSupportDatabaseNameInBeginTransaction() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.beginTransaction( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldNotSupportDatabaseNameForAutoCommitTransactions() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.runAuto( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldReturnFailedStageWithNoConnectionInteractionsOnTelemetry() { + var connection = mock(Connection.class); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var future = protocol.telemetry(connection, 1, handler).toCompletableFuture(); + + assertTrue(future.isCompletedExceptionally()); + then(connection).shouldHaveNoInteractions(); + } + + private Class expectedMessageFormatType() { + return MessageFormatV51.class; + } + + private void testFailedRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onFailure(error); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onError(error); + } + + private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedRunStage = CompletableFuture.completedStage(null); + var expectedPullStage = CompletableFuture.completedStage(null); + var newBookmarkValue = "neo4j:bookmark:v1:tx98765"; + given(connection.write(any(), any())) + .willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedRunStage; + }) + .willAnswer((Answer>) invocation -> { + var pullHandler = (PullResponseHandlerImpl) invocation.getArgument(1); + pullHandler.onSuccess( + Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue))); + return expectedPullStage; + }); + @SuppressWarnings("unchecked") + var runHandler = (MessageHandler) mock(MessageHandler.class); + var pullHandler = mock(PullMessageHandler.class); + + var runStage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + runHandler, + NoopLoggingProvider.INSTANCE); + var pullStage = protocol.pull(connection, 0, UNLIMITED_FETCH_SIZE, pullHandler); + + assertEquals(expectedRunStage, runStage); + assertEquals(expectedPullStage, pullStage); + var runMessage = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(runMessage), any(RunResponseHandler.class)); + var pullMessage = new PullMessage(UNLIMITED_FETCH_SIZE, 0L); + then(connection).should().write(eq(pullMessage), any(PullResponseHandlerImpl.class)); + then(runHandler).should().onSummary(any()); + then(pullHandler) + .should() + .onSummary(new PullResponseHandlerImpl.PullSummaryImpl( + false, Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue)))); + } + + protected void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success) throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + if (success) { + runHandler.onSuccess(emptyMap()); + } else { + runHandler.onFailure(error); + } + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + if (success) { + then(handler).should().onSummary(any()); + } else { + then(handler).should().onError(error); + } + } + + protected void testRunAndWaitForRunResponse( + boolean autoCommitTx, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var initialBookmarks = Collections.singleton("neo4j:bookmark:v1:tx987"); + + if (autoCommitTx) { + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + initialBookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + initialBookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } + + private void testDatabaseNameSupport(boolean autoCommitTx) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + if (autoCommitTx) { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + Collections.emptySet(), + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v51/MessageFormatV51Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/MessageFormatV51Test.java similarity index 78% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v51/MessageFormatV51Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/MessageFormatV51Test.java index d9258edcdb..6c39600202 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v51/MessageFormatV51Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/MessageFormatV51Test.java @@ -14,17 +14,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v51; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v51; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.instanceOf; import static org.mockito.Mockito.mock; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.v5.MessageReaderV5; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v5.MessageReaderV5; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; public class MessageFormatV51Test { private static final MessageFormat format = BoltProtocolV51.INSTANCE.createMessageFormat(); diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v51/MessageWriterV51Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/MessageWriterV51Test.java similarity index 58% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v51/MessageWriterV51Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/MessageWriterV51Test.java index 75f96116ed..fd35de005f 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v51/MessageWriterV51Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v51/MessageWriterV51Test.java @@ -14,27 +14,27 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v51; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v51; import static java.time.Duration.ofSeconds; import static java.util.Calendar.DECEMBER; import static java.util.Collections.emptyMap; import static java.util.Collections.singletonMap; -import static org.neo4j.driver.AccessMode.READ; -import static org.neo4j.driver.AccessMode.WRITE; import static org.neo4j.driver.AuthTokens.basic; import static org.neo4j.driver.Values.point; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.messaging.request.CommitMessage.COMMIT; -import static org.neo4j.driver.internal.messaging.request.DiscardAllMessage.DISCARD_ALL; -import static org.neo4j.driver.internal.messaging.request.GoodbyeMessage.GOODBYE; -import static org.neo4j.driver.internal.messaging.request.PullAllMessage.PULL_ALL; -import static org.neo4j.driver.internal.messaging.request.ResetMessage.RESET; -import static org.neo4j.driver.internal.messaging.request.RollbackMessage.ROLLBACK; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; +import static org.neo4j.driver.internal.bolt.api.AccessMode.READ; +import static org.neo4j.driver.internal.bolt.api.AccessMode.WRITE; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage.COMMIT; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage.DISCARD_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage.GOODBYE; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage.PULL_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage.RESET; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage.ROLLBACK; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; import java.time.LocalDate; import java.time.LocalDateTime; @@ -47,22 +47,20 @@ import java.util.HashMap; import java.util.Map; import java.util.stream.Stream; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; import org.neo4j.driver.Value; import org.neo4j.driver.Values; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.DiscardMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RouteMessage; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.BoltAgentUtil; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RouteMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.AbstractMessageWriterTestBase; import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.util.messaging.AbstractMessageWriterTestBase; public class MessageWriterV51Test extends AbstractMessageWriterTestBase { @Override @@ -74,29 +72,26 @@ protected MessageFormat.Writer newWriter(PackOutput output) { protected Stream supportedMessages() { return Stream.of( // Bolt V2 Data Types - unmanagedTxRunMessage(new Query("RETURN $point", singletonMap("point", point(42, 12.99, -180.0)))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 12.99, -180.0))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123))), + unmanagedTxRunMessage("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L)))), unmanagedTxRunMessage( - new Query("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123)))), + "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN)))), + unmanagedTxRunMessage("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888)))), unmanagedTxRunMessage( - new Query("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L))))), - unmanagedTxRunMessage(new Query( - "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN))))), - unmanagedTxRunMessage( - new Query("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888))))), - unmanagedTxRunMessage(new Query( "RETURN $dateTime", - singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199))))), - unmanagedTxRunMessage(new Query( + singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199)))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", value(ZonedDateTime.of( - 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30)))))), - unmanagedTxRunMessage(new Query( + 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30))))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", - value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm")))))), + value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm"))))), // New Bolt V4 messages new PullMessage(100, 200), @@ -112,7 +107,7 @@ protected Stream supportedMessages() { null), GOODBYE, new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), READ, @@ -120,9 +115,9 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), WRITE, @@ -130,35 +125,38 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), COMMIT, ROLLBACK, RESET, autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), defaultDatabase(), READ, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), database("foo"), WRITE, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN 1")), + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN 1", Collections.emptyMap()), // Bolt V3 messages with struct values autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), defaultDatabase(), @@ -166,9 +164,10 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), database("foo"), @@ -176,8 +175,8 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN $x", singletonMap("x", point(42, 1, 2, 3)))), + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN $x", singletonMap("x", point(42, 1, 2, 3))), // New 4.3 Messages routeMessage()); diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v52/BoltProtocolV52Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v52/BoltProtocolV52Test.java new file mode 100644 index 0000000000..4b4d15350e --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v52/BoltProtocolV52Test.java @@ -0,0 +1,766 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v52; + +import static java.time.Duration.ofSeconds; +import static java.util.Collections.emptyMap; +import static java.util.Collections.singletonMap; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.hasSize; +import static org.hamcrest.Matchers.instanceOf; +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.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +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.mockito.Mockito.when; +import static org.neo4j.driver.Values.value; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; + +import io.netty.channel.embedded.EmbeddedChannel; +import java.time.Clock; +import java.time.Duration; +import java.util.Collections; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +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.EnumSource; +import org.mockito.stubbing.Answer; +import org.neo4j.driver.TransactionConfig; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.BeginTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.CommitTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.PullResponseHandlerImpl; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RollbackTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RunResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.PullMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.LogonMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v51.MessageFormatV51; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; + +public class BoltProtocolV52Test { + protected static final String query = "RETURN $x"; + protected static final Map query_params = singletonMap("x", value(42)); + private static final long UNLIMITED_FETCH_SIZE = -1; + private static final Duration txTimeout = ofSeconds(12); + private static final Map txMetadata = singletonMap("x", value(42)); + + protected final BoltProtocol protocol = createProtocol(); + private final EmbeddedChannel channel = new EmbeddedChannel(); + private final InboundMessageDispatcher messageDispatcher = + new InboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE); + + private final TransactionConfig txConfig = TransactionConfig.builder() + .withTimeout(ofSeconds(12)) + .withMetadata(singletonMap("key", value(42))) + .build(); + + @SuppressWarnings("SameReturnValue") + protected BoltProtocol createProtocol() { + return BoltProtocolV52.INSTANCE; + } + + @BeforeEach + void beforeEach() { + ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); + } + + @AfterEach + void afterEach() { + channel.finishAndReleaseAll(); + } + + @Test + void shouldCreateMessageFormat() { + assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); + } + + @Test + void shouldInitializeChannel() { + var promise = channel.newPromise(); + var clock = mock(Clock.class); + var time = 1L; + when(clock.millis()).thenReturn(time); + + var latestAuthMillisFuture = new CompletableFuture(); + + protocol.initializeChannel( + "MyDriver/0.0.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + clock, + latestAuthMillisFuture); + + assertThat(channel.outboundMessages(), hasSize(2)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertThat(channel.outboundMessages().poll(), instanceOf(LogonMessage.class)); + assertEquals(2, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + var metadata = Map.of( + "server", value("Neo4j/3.5.0"), + "connection_id", value("bolt-42")); + + messageDispatcher.handleSuccessMessage(metadata); + messageDispatcher.handleSuccessMessage(Collections.emptyMap()); + + assertTrue(promise.isDone()); + assertTrue(promise.isSuccess()); + verify(clock).millis(); + assertTrue(latestAuthMillisFuture.isDone()); + assertEquals(time, latestAuthMillisFuture.join()); + } + + @Test + void shouldBeginTransactionWithoutBookmark() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarks() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx100"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarksAndConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx4242"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldCommitTransaction() { + var bookmarkString = "neo4j:bookmark:v1:tx4242"; + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var commitHandler = (CommitTxResponseHandler) invocation.getArgument(1); + commitHandler.onSuccess(Map.of("bookmark", value(bookmarkString))); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.commitTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); + then(handler).should().onSummary(bookmarkString); + } + + @Test + void shouldRollbackTransaction() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var rollbackHandler = (RollbackTxResponseHandler) invocation.getArgument(1); + rollbackHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.rollbackTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) + throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx65"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx163"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(false, null, Collections.emptyMap(), mode); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(true); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(false); + } + + @Test + void databaseNameInBeginTransaction() { + testDatabaseNameSupport(false); + } + + @Test + void databaseNameForAutoCommitTransactions() { + testDatabaseNameSupport(true); + } + + @Test + void shouldSupportDatabaseNameInBeginTransaction() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.beginTransaction( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldNotSupportDatabaseNameForAutoCommitTransactions() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.runAuto( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldReturnFailedStageWithNoConnectionInteractionsOnTelemetry() { + var connection = mock(Connection.class); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var future = protocol.telemetry(connection, 1, handler).toCompletableFuture(); + + assertTrue(future.isCompletedExceptionally()); + then(connection).shouldHaveNoInteractions(); + } + + private Class expectedMessageFormatType() { + return MessageFormatV51.class; + } + + private void testFailedRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onFailure(error); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onError(error); + } + + private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedRunStage = CompletableFuture.completedStage(null); + var expectedPullStage = CompletableFuture.completedStage(null); + var newBookmarkValue = "neo4j:bookmark:v1:tx98765"; + given(connection.write(any(), any())) + .willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedRunStage; + }) + .willAnswer((Answer>) invocation -> { + var pullHandler = (PullResponseHandlerImpl) invocation.getArgument(1); + pullHandler.onSuccess( + Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue))); + return expectedPullStage; + }); + @SuppressWarnings("unchecked") + var runHandler = (MessageHandler) mock(MessageHandler.class); + var pullHandler = mock(PullMessageHandler.class); + + var runStage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + runHandler, + NoopLoggingProvider.INSTANCE); + var pullStage = protocol.pull(connection, 0, UNLIMITED_FETCH_SIZE, pullHandler); + + assertEquals(expectedRunStage, runStage); + assertEquals(expectedPullStage, pullStage); + var runMessage = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(runMessage), any(RunResponseHandler.class)); + var pullMessage = new PullMessage(UNLIMITED_FETCH_SIZE, 0L); + then(connection).should().write(eq(pullMessage), any(PullResponseHandlerImpl.class)); + then(runHandler).should().onSummary(any()); + then(pullHandler) + .should() + .onSummary(new PullResponseHandlerImpl.PullSummaryImpl( + false, Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue)))); + } + + protected void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success) throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + if (success) { + runHandler.onSuccess(emptyMap()); + } else { + runHandler.onFailure(error); + } + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + if (success) { + then(handler).should().onSummary(any()); + } else { + then(handler).should().onError(error); + } + } + + protected void testRunAndWaitForRunResponse( + boolean autoCommitTx, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var initialBookmarks = Collections.singleton("neo4j:bookmark:v1:tx987"); + + if (autoCommitTx) { + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + initialBookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + initialBookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } + + private void testDatabaseNameSupport(boolean autoCommitTx) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + if (autoCommitTx) { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + Collections.emptySet(), + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v53/BoltProtocolV53Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v53/BoltProtocolV53Test.java new file mode 100644 index 0000000000..4a7334ba88 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v53/BoltProtocolV53Test.java @@ -0,0 +1,766 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v53; + +import static java.time.Duration.ofSeconds; +import static java.util.Collections.emptyMap; +import static java.util.Collections.singletonMap; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.hasSize; +import static org.hamcrest.Matchers.instanceOf; +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.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +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.mockito.Mockito.when; +import static org.neo4j.driver.Values.value; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; + +import io.netty.channel.embedded.EmbeddedChannel; +import java.time.Clock; +import java.time.Duration; +import java.util.Collections; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +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.EnumSource; +import org.mockito.stubbing.Answer; +import org.neo4j.driver.TransactionConfig; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.BeginTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.CommitTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.PullResponseHandlerImpl; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RollbackTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RunResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.PullMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.LogonMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v51.MessageFormatV51; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; + +public class BoltProtocolV53Test { + protected static final String query = "RETURN $x"; + protected static final Map query_params = singletonMap("x", value(42)); + private static final long UNLIMITED_FETCH_SIZE = -1; + private static final Duration txTimeout = ofSeconds(12); + private static final Map txMetadata = singletonMap("x", value(42)); + + protected final BoltProtocol protocol = createProtocol(); + private final EmbeddedChannel channel = new EmbeddedChannel(); + private final InboundMessageDispatcher messageDispatcher = + new InboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE); + + private final TransactionConfig txConfig = TransactionConfig.builder() + .withTimeout(ofSeconds(12)) + .withMetadata(singletonMap("key", value(42))) + .build(); + + @SuppressWarnings("SameReturnValue") + protected BoltProtocol createProtocol() { + return BoltProtocolV53.INSTANCE; + } + + @BeforeEach + void beforeEach() { + ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); + } + + @AfterEach + void afterEach() { + channel.finishAndReleaseAll(); + } + + @Test + void shouldCreateMessageFormat() { + assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); + } + + @Test + void shouldInitializeChannel() { + var promise = channel.newPromise(); + var clock = mock(Clock.class); + var time = 1L; + when(clock.millis()).thenReturn(time); + + var latestAuthMillisFuture = new CompletableFuture(); + + protocol.initializeChannel( + "MyDriver/0.0.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + clock, + latestAuthMillisFuture); + + assertThat(channel.outboundMessages(), hasSize(2)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertThat(channel.outboundMessages().poll(), instanceOf(LogonMessage.class)); + assertEquals(2, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + var metadata = Map.of( + "server", value("Neo4j/3.5.0"), + "connection_id", value("bolt-42")); + + messageDispatcher.handleSuccessMessage(metadata); + messageDispatcher.handleSuccessMessage(Collections.emptyMap()); + + assertTrue(promise.isDone()); + assertTrue(promise.isSuccess()); + verify(clock).millis(); + assertTrue(latestAuthMillisFuture.isDone()); + assertEquals(time, latestAuthMillisFuture.join()); + } + + @Test + void shouldBeginTransactionWithoutBookmark() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarks() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx100"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarksAndConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx4242"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldCommitTransaction() { + var bookmarkString = "neo4j:bookmark:v1:tx4242"; + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var commitHandler = (CommitTxResponseHandler) invocation.getArgument(1); + commitHandler.onSuccess(Map.of("bookmark", value(bookmarkString))); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.commitTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); + then(handler).should().onSummary(bookmarkString); + } + + @Test + void shouldRollbackTransaction() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var rollbackHandler = (RollbackTxResponseHandler) invocation.getArgument(1); + rollbackHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.rollbackTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) + throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx65"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx163"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(false, null, Collections.emptyMap(), mode); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(true); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(false); + } + + @Test + void databaseNameInBeginTransaction() { + testDatabaseNameSupport(false); + } + + @Test + void databaseNameForAutoCommitTransactions() { + testDatabaseNameSupport(true); + } + + @Test + void shouldSupportDatabaseNameInBeginTransaction() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.beginTransaction( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldNotSupportDatabaseNameForAutoCommitTransactions() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.runAuto( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldReturnFailedStageWithNoConnectionInteractionsOnTelemetry() { + var connection = mock(Connection.class); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var future = protocol.telemetry(connection, 1, handler).toCompletableFuture(); + + assertTrue(future.isCompletedExceptionally()); + then(connection).shouldHaveNoInteractions(); + } + + private Class expectedMessageFormatType() { + return MessageFormatV51.class; + } + + private void testFailedRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onFailure(error); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onError(error); + } + + private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedRunStage = CompletableFuture.completedStage(null); + var expectedPullStage = CompletableFuture.completedStage(null); + var newBookmarkValue = "neo4j:bookmark:v1:tx98765"; + given(connection.write(any(), any())) + .willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedRunStage; + }) + .willAnswer((Answer>) invocation -> { + var pullHandler = (PullResponseHandlerImpl) invocation.getArgument(1); + pullHandler.onSuccess( + Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue))); + return expectedPullStage; + }); + @SuppressWarnings("unchecked") + var runHandler = (MessageHandler) mock(MessageHandler.class); + var pullHandler = mock(PullMessageHandler.class); + + var runStage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + runHandler, + NoopLoggingProvider.INSTANCE); + var pullStage = protocol.pull(connection, 0, UNLIMITED_FETCH_SIZE, pullHandler); + + assertEquals(expectedRunStage, runStage); + assertEquals(expectedPullStage, pullStage); + var runMessage = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(runMessage), any(RunResponseHandler.class)); + var pullMessage = new PullMessage(UNLIMITED_FETCH_SIZE, 0L); + then(connection).should().write(eq(pullMessage), any(PullResponseHandlerImpl.class)); + then(runHandler).should().onSummary(any()); + then(pullHandler) + .should() + .onSummary(new PullResponseHandlerImpl.PullSummaryImpl( + false, Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue)))); + } + + protected void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success) throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + if (success) { + runHandler.onSuccess(emptyMap()); + } else { + runHandler.onFailure(error); + } + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + if (success) { + then(handler).should().onSummary(any()); + } else { + then(handler).should().onError(error); + } + } + + protected void testRunAndWaitForRunResponse( + boolean autoCommitTx, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var initialBookmarks = Collections.singleton("neo4j:bookmark:v1:tx987"); + + if (autoCommitTx) { + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + initialBookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + initialBookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } + + private void testDatabaseNameSupport(boolean autoCommitTx) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + if (autoCommitTx) { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + Collections.emptySet(), + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/BoltProtocolV54Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/BoltProtocolV54Test.java new file mode 100644 index 0000000000..dfa65acde2 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/BoltProtocolV54Test.java @@ -0,0 +1,767 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.messaging.v54; + +import static java.time.Duration.ofSeconds; +import static java.util.Collections.emptyMap; +import static java.util.Collections.singletonMap; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.hasSize; +import static org.hamcrest.Matchers.instanceOf; +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.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +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.mockito.Mockito.when; +import static org.neo4j.driver.Values.value; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; + +import io.netty.channel.embedded.EmbeddedChannel; +import java.time.Clock; +import java.time.Duration; +import java.util.Collections; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +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.EnumSource; +import org.mockito.stubbing.Answer; +import org.neo4j.driver.TransactionConfig; +import org.neo4j.driver.Value; +import org.neo4j.driver.Values; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.ChannelAttributes; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.BeginTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.CommitTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.PullResponseHandlerImpl; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RollbackTxResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.handlers.RunResponseHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.PullMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.LogonMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.TelemetryMessage; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; + +public class BoltProtocolV54Test { + protected static final String query = "RETURN $x"; + protected static final Map query_params = singletonMap("x", value(42)); + private static final long UNLIMITED_FETCH_SIZE = -1; + private static final Duration txTimeout = ofSeconds(12); + private static final Map txMetadata = singletonMap("x", value(42)); + + protected final BoltProtocol protocol = createProtocol(); + private final EmbeddedChannel channel = new EmbeddedChannel(); + private final InboundMessageDispatcher messageDispatcher = + new InboundMessageDispatcher(channel, NoopLoggingProvider.INSTANCE); + + private final TransactionConfig txConfig = TransactionConfig.builder() + .withTimeout(ofSeconds(12)) + .withMetadata(singletonMap("key", value(42))) + .build(); + + @SuppressWarnings("SameReturnValue") + protected BoltProtocol createProtocol() { + return BoltProtocolV54.INSTANCE; + } + + @BeforeEach + void beforeEach() { + ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); + } + + @AfterEach + void afterEach() { + channel.finishAndReleaseAll(); + } + + @Test + void shouldCreateMessageFormat() { + assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); + } + + @Test + void shouldInitializeChannel() { + var promise = channel.newPromise(); + var clock = mock(Clock.class); + var time = 1L; + when(clock.millis()).thenReturn(time); + + var latestAuthMillisFuture = new CompletableFuture(); + + protocol.initializeChannel( + "MyDriver/0.0.1", + null, + Collections.emptyMap(), + RoutingContext.EMPTY, + promise, + null, + clock, + latestAuthMillisFuture); + + assertThat(channel.outboundMessages(), hasSize(2)); + assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); + assertThat(channel.outboundMessages().poll(), instanceOf(LogonMessage.class)); + assertEquals(2, messageDispatcher.queuedHandlersCount()); + assertFalse(promise.isDone()); + + var metadata = Map.of( + "server", value("Neo4j/3.5.0"), + "connection_id", value("bolt-42")); + + messageDispatcher.handleSuccessMessage(metadata); + messageDispatcher.handleSuccessMessage(Collections.emptyMap()); + + assertTrue(promise.isDone()); + assertTrue(promise.isSuccess()); + verify(clock).millis(); + assertTrue(latestAuthMillisFuture.isDone()); + assertEquals(time, latestAuthMillisFuture.join()); + } + + @Test + void shouldBeginTransactionWithoutBookmark() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarks() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx100"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldBeginTransactionWithBookmarksAndConfig() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var bookmarks = Collections.singleton("neo4j:bookmark:v1:tx4242"); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + bookmarks, + txTimeout, + txMetadata, + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + bookmarks, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @Test + void shouldCommitTransaction() { + var bookmarkString = "neo4j:bookmark:v1:tx4242"; + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var commitHandler = (CommitTxResponseHandler) invocation.getArgument(1); + commitHandler.onSuccess(Map.of("bookmark", value(bookmarkString))); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.commitTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); + then(handler).should().onSummary(bookmarkString); + } + + @Test + void shouldRollbackTransaction() { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var rollbackHandler = (RollbackTxResponseHandler) invocation.getArgument(1); + rollbackHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.rollbackTransaction(connection, handler); + + assertEquals(expectedStage, stage); + then(connection).should().write(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(true, txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) + throws Exception { + testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx65"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), null, Collections.emptyMap(), mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { + testFailedRunInAutoCommitTxWithWaitingForResponse( + Collections.singleton("neo4j:bookmark:v1:tx163"), txTimeout, txMetadata, mode); + } + + @ParameterizedTest + @EnumSource(AccessMode.class) + void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { + testRunAndWaitForRunResponse(false, null, Collections.emptyMap(), mode); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(true); + } + + @Test + void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse() throws Exception { + testRunInUnmanagedTransactionAndWaitForRunResponse(false); + } + + @Test + void databaseNameInBeginTransaction() { + testDatabaseNameSupport(false); + } + + @Test + void databaseNameForAutoCommitTransactions() { + testDatabaseNameSupport(true); + } + + @Test + void shouldSupportDatabaseNameInBeginTransaction() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.beginTransaction( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldNotSupportDatabaseNameForAutoCommitTransactions() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willReturn(expectedStage); + var future = protocol.runAuto( + connection, + database("foo"), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + mock(), + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, future); + then(connection).should().write(any(), any()); + } + + @Test + void shouldTelemetrySendTelemetryMessage() { + var connection = mock(Connection.class); + var expectedStage = CompletableFuture.completedStage(null); + var expectedApi = 1; + given(connection.write(any(), any())).willReturn(expectedStage); + + var future = protocol.telemetry(connection, expectedApi, mock()); + + assertEquals(expectedStage, future); + then(connection).should().write(eq(new TelemetryMessage(expectedApi)), any()); + } + + private Class expectedMessageFormatType() { + return MessageFormatV54.class; + } + + private void testFailedRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onFailure(error); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onError(error); + } + + private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( + Set bookmarks, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedRunStage = CompletableFuture.completedStage(null); + var expectedPullStage = CompletableFuture.completedStage(null); + var newBookmarkValue = "neo4j:bookmark:v1:tx98765"; + given(connection.write(any(), any())) + .willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedRunStage; + }) + .willAnswer((Answer>) invocation -> { + var pullHandler = (PullResponseHandlerImpl) invocation.getArgument(1); + pullHandler.onSuccess( + Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue))); + return expectedPullStage; + }); + @SuppressWarnings("unchecked") + var runHandler = (MessageHandler) mock(MessageHandler.class); + var pullHandler = mock(PullMessageHandler.class); + + var runStage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + bookmarks, + txTimeout, + txMetadata, + null, + runHandler, + NoopLoggingProvider.INSTANCE); + var pullStage = protocol.pull(connection, 0, UNLIMITED_FETCH_SIZE, pullHandler); + + assertEquals(expectedRunStage, runStage); + assertEquals(expectedPullStage, pullStage); + var runMessage = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + bookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(runMessage), any(RunResponseHandler.class)); + var pullMessage = new PullMessage(UNLIMITED_FETCH_SIZE, 0L); + then(connection).should().write(eq(pullMessage), any(PullResponseHandlerImpl.class)); + then(runHandler).should().onSummary(any()); + then(pullHandler) + .should() + .onSummary(new PullResponseHandlerImpl.PullSummaryImpl( + false, Map.of("has_more", Values.value(false), "bookmark", Values.value(newBookmarkValue)))); + } + + protected void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success) throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + Throwable error = new RuntimeException(); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + if (success) { + runHandler.onSuccess(emptyMap()); + } else { + runHandler.onFailure(error); + } + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + if (success) { + then(handler).should().onSummary(any()); + } else { + then(handler).should().onError(error); + } + } + + protected void testRunAndWaitForRunResponse( + boolean autoCommitTx, + Duration txTimeout, + Map txMetadata, + org.neo4j.driver.internal.bolt.api.AccessMode mode) + throws Exception { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + var initialBookmarks = Collections.singleton("neo4j:bookmark:v1:tx987"); + + if (autoCommitTx) { + var stage = protocol.runAuto( + connection, + defaultDatabase(), + mode, + null, + query, + query_params, + initialBookmarks, + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + mode, + initialBookmarks, + null, + null, + NoopLoggingProvider.INSTANCE); + + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + var stage = protocol.run(connection, query, query_params, handler); + + assertEquals(expectedStage, stage); + var message = unmanagedTxRunMessage(query, query_params); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } + + private void testDatabaseNameSupport(boolean autoCommitTx) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + var expectedStage = CompletableFuture.completedStage(null); + if (autoCommitTx) { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var runHandler = (RunResponseHandler) invocation.getArgument(1); + runHandler.onSuccess(Collections.emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.runAuto( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + query, + query_params, + Collections.emptySet(), + txTimeout, + txMetadata, + null, + handler, + NoopLoggingProvider.INSTANCE); + assertEquals(expectedStage, stage); + var message = autoCommitTxRunMessage( + query, + query_params, + txTimeout, + txMetadata, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + Collections.emptySet(), + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(RunResponseHandler.class)); + then(handler).should().onSummary(any()); + } else { + given(connection.write(any(), any())).willAnswer((Answer>) invocation -> { + var beginHandler = (BeginTxResponseHandler) invocation.getArgument(1); + beginHandler.onSuccess(emptyMap()); + return expectedStage; + }); + @SuppressWarnings("unchecked") + var handler = (MessageHandler) mock(MessageHandler.class); + + var stage = protocol.beginTransaction( + connection, + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + Collections.emptySet(), + null, + Collections.emptyMap(), + null, + null, + handler, + NoopLoggingProvider.INSTANCE); + + assertEquals(expectedStage, stage); + var message = new BeginMessage( + Collections.emptySet(), + null, + Collections.emptyMap(), + defaultDatabase(), + org.neo4j.driver.internal.bolt.api.AccessMode.WRITE, + null, + null, + null, + NoopLoggingProvider.INSTANCE); + then(connection).should().write(eq(message), any(BeginTxResponseHandler.class)); + then(handler).should().onSummary(any()); + } + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v54/MessageFormatV54Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/MessageFormatV54Test.java similarity index 78% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v54/MessageFormatV54Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/MessageFormatV54Test.java index 4f9e3cdf0d..60ccf00efb 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v54/MessageFormatV54Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/MessageFormatV54Test.java @@ -14,17 +14,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v54; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v54; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.instanceOf; import static org.mockito.Mockito.mock; import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.v5.MessageReaderV5; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v5.MessageReaderV5; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; class MessageFormatV54Test { private static final MessageFormat format = BoltProtocolV54.INSTANCE.createMessageFormat(); diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v54/MessageWriterV54Test.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/MessageWriterV54Test.java similarity index 58% rename from driver/src/test/java/org/neo4j/driver/internal/messaging/v54/MessageWriterV54Test.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/MessageWriterV54Test.java index c2fa17bcc0..0d9dbf4c6c 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v54/MessageWriterV54Test.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/messaging/v54/MessageWriterV54Test.java @@ -14,27 +14,27 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.messaging.v54; +package org.neo4j.driver.internal.bolt.basicimpl.messaging.v54; import static java.time.Duration.ofSeconds; import static java.util.Calendar.DECEMBER; import static java.util.Collections.emptyMap; import static java.util.Collections.singletonMap; -import static org.neo4j.driver.AccessMode.READ; -import static org.neo4j.driver.AccessMode.WRITE; import static org.neo4j.driver.AuthTokens.basic; import static org.neo4j.driver.Values.point; import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.messaging.request.CommitMessage.COMMIT; -import static org.neo4j.driver.internal.messaging.request.DiscardAllMessage.DISCARD_ALL; -import static org.neo4j.driver.internal.messaging.request.GoodbyeMessage.GOODBYE; -import static org.neo4j.driver.internal.messaging.request.PullAllMessage.PULL_ALL; -import static org.neo4j.driver.internal.messaging.request.ResetMessage.RESET; -import static org.neo4j.driver.internal.messaging.request.RollbackMessage.ROLLBACK; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; -import static org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; +import static org.neo4j.driver.internal.bolt.api.AccessMode.READ; +import static org.neo4j.driver.internal.bolt.api.AccessMode.WRITE; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.CommitMessage.COMMIT; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage.DISCARD_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.GoodbyeMessage.GOODBYE; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage.PULL_ALL; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage.RESET; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RollbackMessage.ROLLBACK; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.autoCommitTxRunMessage; +import static org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RunWithMetadataMessage.unmanagedTxRunMessage; import java.time.LocalDate; import java.time.LocalDateTime; @@ -47,23 +47,21 @@ import java.util.HashMap; import java.util.Map; import java.util.stream.Stream; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; import org.neo4j.driver.Value; import org.neo4j.driver.Values; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.DiscardMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RouteMessage; -import org.neo4j.driver.internal.messaging.request.TelemetryMessage; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.BoltAgentUtil; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.BeginMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.HelloMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.RouteMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.TelemetryMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.util.messaging.AbstractMessageWriterTestBase; import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.util.messaging.AbstractMessageWriterTestBase; public class MessageWriterV54Test extends AbstractMessageWriterTestBase { @Override @@ -75,29 +73,26 @@ protected MessageFormat.Writer newWriter(PackOutput output) { protected Stream supportedMessages() { return Stream.of( // Bolt V2 Data Types - unmanagedTxRunMessage(new Query("RETURN $point", singletonMap("point", point(42, 12.99, -180.0)))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 12.99, -180.0))), + unmanagedTxRunMessage("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123))), + unmanagedTxRunMessage("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L)))), unmanagedTxRunMessage( - new Query("RETURN $point", singletonMap("point", point(42, 0.51, 2.99, 100.123)))), + "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN)))), + unmanagedTxRunMessage("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888)))), unmanagedTxRunMessage( - new Query("RETURN $date", singletonMap("date", value(LocalDate.ofEpochDay(2147483650L))))), - unmanagedTxRunMessage(new Query( - "RETURN $time", singletonMap("time", value(OffsetTime.of(4, 16, 20, 999, ZoneOffset.MIN))))), - unmanagedTxRunMessage( - new Query("RETURN $time", singletonMap("time", value(LocalTime.of(12, 9, 18, 999_888))))), - unmanagedTxRunMessage(new Query( "RETURN $dateTime", - singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199))))), - unmanagedTxRunMessage(new Query( + singletonMap("dateTime", value(LocalDateTime.of(2049, DECEMBER, 12, 17, 25, 49, 199)))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", value(ZonedDateTime.of( - 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30)))))), - unmanagedTxRunMessage(new Query( + 2000, 1, 10, 12, 2, 49, 300, ZoneOffset.ofHoursMinutes(9, 30))))), + unmanagedTxRunMessage( "RETURN $dateTime", singletonMap( "dateTime", - value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm")))))), + value(ZonedDateTime.of(2000, 1, 10, 12, 2, 49, 300, ZoneId.of("Europe/Stockholm"))))), // New Bolt V4 messages new PullMessage(100, 200), @@ -113,7 +108,7 @@ protected Stream supportedMessages() { null), GOODBYE, new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), READ, @@ -121,9 +116,9 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), new BeginMessage( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx123")), + Collections.singleton("neo4j:bookmark:v1:tx123"), ofSeconds(5), singletonMap("key", value(42)), WRITE, @@ -131,35 +126,38 @@ protected Stream supportedMessages() { null, null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), COMMIT, ROLLBACK, RESET, autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), defaultDatabase(), READ, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN 1"), + "RETURN 1", + Collections.emptyMap(), ofSeconds(5), singletonMap("key", value(42)), database("foo"), WRITE, - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx1")), + Collections.singleton("neo4j:bookmark:v1:tx1"), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN 1")), + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN 1", Collections.emptyMap()), // Bolt V3 messages with struct values autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), defaultDatabase(), @@ -167,9 +165,10 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), + NoopLoggingProvider.INSTANCE), autoCommitTxRunMessage( - new Query("RETURN $x", singletonMap("x", value(ZonedDateTime.now()))), + "RETURN $x", + singletonMap("x", value(ZonedDateTime.now())), ofSeconds(1), emptyMap(), database("foo"), @@ -177,8 +176,8 @@ protected Stream supportedMessages() { Collections.emptySet(), null, null, - Logging.none()), - unmanagedTxRunMessage(new Query("RETURN $x", singletonMap("x", point(42, 1, 2, 3)))), + NoopLoggingProvider.INSTANCE), + unmanagedTxRunMessage("RETURN $x", singletonMap("x", point(42, 1, 2, 3))), // New 4.3 Messages routeMessage(), diff --git a/driver/src/test/java/org/neo4j/driver/internal/packstream/PackStreamTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/packstream/PackStreamTest.java similarity index 99% rename from driver/src/test/java/org/neo4j/driver/internal/packstream/PackStreamTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/packstream/PackStreamTest.java index 4f0d2a6de0..0609379f52 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/packstream/PackStreamTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/packstream/PackStreamTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.packstream; +package org.neo4j.driver.internal.bolt.basicimpl.packstream; import static java.util.Arrays.asList; import static org.hamcrest.CoreMatchers.equalTo; @@ -36,9 +36,9 @@ import java.util.stream.Collectors; import java.util.stream.IntStream; import org.junit.jupiter.api.Test; +import org.neo4j.driver.internal.bolt.basicimpl.util.io.BufferedChannelInput; +import org.neo4j.driver.internal.bolt.basicimpl.util.io.ChannelOutput; import org.neo4j.driver.internal.util.Iterables; -import org.neo4j.driver.internal.util.io.BufferedChannelInput; -import org.neo4j.driver.internal.util.io.ChannelOutput; public class PackStreamTest { public static Map asMap(Object... keysAndValues) { diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/MetadataExtractorTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/MetadataExtractorTest.java new file mode 100644 index 0000000000..ec5a9a0eef --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/MetadataExtractorTest.java @@ -0,0 +1,107 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.basicimpl.util; + +import static java.util.Arrays.asList; +import static java.util.Collections.emptyList; +import static java.util.Collections.emptyMap; +import static java.util.Collections.singletonMap; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; +import static org.neo4j.driver.Values.value; +import static org.neo4j.driver.internal.bolt.basicimpl.util.MetadataExtractor.extractServer; + +import org.junit.jupiter.api.Test; +import org.neo4j.driver.Query; +import org.neo4j.driver.Values; +import org.neo4j.driver.exceptions.UntrustedServerException; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; + +class MetadataExtractorTest { + private static final String RESULT_AVAILABLE_AFTER_KEY = "available_after"; + + private final MetadataExtractor extractor = new MetadataExtractor(RESULT_AVAILABLE_AFTER_KEY); + + @Test + void shouldExtractQueryKeys() { + var keys = asList("hello", " ", "world", "!"); + + var extracted = extractor.extractQueryKeys(singletonMap("fields", value(keys))); + assertEquals(keys, extracted); + } + + @Test + void shouldExtractEmptyQueryKeysWhenNoneInMetadata() { + var extracted = extractor.extractQueryKeys(emptyMap()); + assertEquals(emptyList(), extracted); + } + + @Test + void shouldExtractResultAvailableAfter() { + var metadata = singletonMap(RESULT_AVAILABLE_AFTER_KEY, value(424242)); + var extractedResultAvailableAfter = extractor.extractResultAvailableAfter(metadata); + assertEquals(424242L, extractedResultAvailableAfter); + } + + @Test + void shouldExtractNoResultAvailableAfterWhenNoneInMetadata() { + var extractedResultAvailableAfter = extractor.extractResultAvailableAfter(emptyMap()); + assertEquals(-1, extractedResultAvailableAfter); + } + + @Test + void shouldExtractServer() { + var agent = "Neo4j/3.5.0"; + var metadata = singletonMap("server", value(agent)); + + var serverValue = extractServer(metadata); + + assertEquals(agent, serverValue.asString()); + } + + @Test + void shouldFailToExtractServerVersionWhenMetadataDoesNotContainIt() { + assertThrows(UntrustedServerException.class, () -> extractServer(singletonMap("server", Values.NULL))); + assertThrows(UntrustedServerException.class, () -> extractServer(singletonMap("server", null))); + } + + @Test + void shouldFailToExtractServerVersionFromNonNeo4jProduct() { + assertThrows( + UntrustedServerException.class, () -> extractServer(singletonMap("server", value("NotNeo4j/1.2.3")))); + } + + private static Query query() { + return new Query("RETURN 1"); + } + + private static BoltConnection connectionMock() { + return connectionMock(BoltServerAddress.LOCAL_DEFAULT); + } + + private static BoltConnection connectionMock(BoltServerAddress address) { + var connection = mock(BoltConnection.class); + when(connection.serverAddress()).thenReturn(address); + when(connection.protocolVersion()).thenReturn(new BoltProtocolVersion(4, 3)); + when(connection.serverAgent()).thenReturn("Neo4j/4.2.5"); + return connection; + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/pool/ExtendedChannelPool.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/TestUtil.java similarity index 55% rename from driver/src/main/java/org/neo4j/driver/internal/async/pool/ExtendedChannelPool.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/TestUtil.java index 27f1f37ce6..7fc61b390c 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/pool/ExtendedChannelPool.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/TestUtil.java @@ -14,22 +14,18 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.async.pool; +package org.neo4j.driver.internal.bolt.basicimpl.util; -import io.netty.channel.Channel; -import java.util.concurrent.CompletionStage; -import org.neo4j.driver.AuthToken; +import static org.mockito.BDDMockito.given; +import static org.mockito.Mockito.mock; -public interface ExtendedChannelPool { - CompletionStage acquire(AuthToken overrideAuthToken); +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.spi.Connection; - CompletionStage release(Channel channel); - - boolean isClosed(); - - String id(); - - CompletionStage close(); - - NettyChannelHealthChecker healthChecker(); +public class TestUtil { + public static Connection connectionMock(BoltProtocol protocol) { + var connection = mock(Connection.class); + given(connection.protocol()).willReturn(protocol); + return connection; + } } diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/io/BufferedChannelInput.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/io/BufferedChannelInput.java similarity index 94% rename from driver/src/test/java/org/neo4j/driver/internal/util/io/BufferedChannelInput.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/io/BufferedChannelInput.java index 8725b543ad..f38aacf376 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/io/BufferedChannelInput.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/io/BufferedChannelInput.java @@ -14,14 +14,14 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.util.io; +package org.neo4j.driver.internal.bolt.basicimpl.util.io; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.nio.channels.ReadableByteChannel; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackStream; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackStream; /** * An {@link PackInput} implementation that reads from an input channel into an internal buffer. diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/io/ByteBufOutput.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/io/ByteBufOutput.java similarity index 92% rename from driver/src/test/java/org/neo4j/driver/internal/util/io/ByteBufOutput.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/io/ByteBufOutput.java index 30d4cc5c1e..d47cff1d7f 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/io/ByteBufOutput.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/io/ByteBufOutput.java @@ -14,10 +14,10 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.util.io; +package org.neo4j.driver.internal.bolt.basicimpl.util.io; import io.netty.buffer.ByteBuf; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; public class ByteBufOutput implements PackOutput { private final ByteBuf buf; diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/io/ChannelOutput.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/io/ChannelOutput.java similarity index 94% rename from driver/src/test/java/org/neo4j/driver/internal/util/io/ChannelOutput.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/io/ChannelOutput.java index 716239303e..28d6c9a224 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/io/ChannelOutput.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/io/ChannelOutput.java @@ -14,12 +14,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.util.io; +package org.neo4j.driver.internal.bolt.basicimpl.util.io; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.channels.WritableByteChannel; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; public class ChannelOutput implements PackOutput { private final WritableByteChannel channel; diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/io/MessageToByteBufWriter.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/io/MessageToByteBufWriter.java similarity index 86% rename from driver/src/test/java/org/neo4j/driver/internal/util/io/MessageToByteBufWriter.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/io/MessageToByteBufWriter.java index 4a268d5b0c..37d07a74bb 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/io/MessageToByteBufWriter.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/io/MessageToByteBufWriter.java @@ -14,13 +14,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.util.io; +package org.neo4j.driver.internal.bolt.basicimpl.util.io; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import java.io.IOException; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; public class MessageToByteBufWriter { private final MessageFormat messageFormat; diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/messaging/AbstractMessageReaderTestBase.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/AbstractMessageReaderTestBase.java similarity index 81% rename from driver/src/test/java/org/neo4j/driver/internal/util/messaging/AbstractMessageReaderTestBase.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/AbstractMessageReaderTestBase.java index 8e9b06e8ba..8bf1becb5a 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/messaging/AbstractMessageReaderTestBase.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/AbstractMessageReaderTestBase.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.util.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.util.messaging; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.fail; @@ -27,16 +27,16 @@ import java.util.stream.Stream; import org.junit.jupiter.api.DynamicNode; import org.junit.jupiter.api.TestFactory; -import org.neo4j.driver.internal.async.inbound.ByteBufInput; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.ResponseMessageHandler; -import org.neo4j.driver.internal.messaging.response.FailureMessage; -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.packstream.PackInput; -import org.neo4j.driver.internal.util.io.ByteBufOutput; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.ByteBufInput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ResponseMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.FailureMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.IgnoredMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.RecordMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.SuccessMessage; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackInput; +import org.neo4j.driver.internal.bolt.basicimpl.util.io.ByteBufOutput; public abstract class AbstractMessageReaderTestBase { @TestFactory diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/messaging/AbstractMessageWriterTestBase.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/AbstractMessageWriterTestBase.java similarity index 84% rename from driver/src/test/java/org/neo4j/driver/internal/util/messaging/AbstractMessageWriterTestBase.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/AbstractMessageWriterTestBase.java index 8f185f0935..d69f10f5a3 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/messaging/AbstractMessageWriterTestBase.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/AbstractMessageWriterTestBase.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.util.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.util.messaging; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.greaterThanOrEqualTo; @@ -28,12 +28,12 @@ import java.util.stream.Stream; import org.junit.jupiter.api.DynamicNode; import org.junit.jupiter.api.TestFactory; -import org.neo4j.driver.internal.async.inbound.ByteBufInput; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.packstream.PackOutput; -import org.neo4j.driver.internal.packstream.PackStream; -import org.neo4j.driver.internal.util.io.ByteBufOutput; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.ByteBufInput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageFormat; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackStream; +import org.neo4j.driver.internal.bolt.basicimpl.util.io.ByteBufOutput; public abstract class AbstractMessageWriterTestBase { @TestFactory diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/messaging/FailureMessageEncoder.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/FailureMessageEncoder.java similarity index 77% rename from driver/src/test/java/org/neo4j/driver/internal/util/messaging/FailureMessageEncoder.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/FailureMessageEncoder.java index 27e0498308..44ca3f9079 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/messaging/FailureMessageEncoder.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/FailureMessageEncoder.java @@ -14,17 +14,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.util.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.util.messaging; import java.io.IOException; import java.util.HashMap; import java.util.Map; import org.neo4j.driver.Value; import org.neo4j.driver.Values; -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.response.FailureMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.FailureMessage; public class FailureMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/messaging/IgnoredMessageEncoder.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/IgnoredMessageEncoder.java similarity index 71% rename from driver/src/test/java/org/neo4j/driver/internal/util/messaging/IgnoredMessageEncoder.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/IgnoredMessageEncoder.java index 4eb26df458..b1c0b6709d 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/messaging/IgnoredMessageEncoder.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/IgnoredMessageEncoder.java @@ -14,13 +14,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.util.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.util.messaging; 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.response.IgnoredMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.IgnoredMessage; public class IgnoredMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/messaging/KnowledgeableMessageFormat.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/KnowledgeableMessageFormat.java similarity index 83% rename from driver/src/test/java/org/neo4j/driver/internal/util/messaging/KnowledgeableMessageFormat.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/KnowledgeableMessageFormat.java index 773b62fa58..5e80e3b2b4 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/messaging/KnowledgeableMessageFormat.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/KnowledgeableMessageFormat.java @@ -14,26 +14,26 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.util.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.util.messaging; import java.io.IOException; import java.util.Map; -import org.neo4j.driver.internal.messaging.AbstractMessageWriter; -import org.neo4j.driver.internal.messaging.MessageEncoder; -import org.neo4j.driver.internal.messaging.common.CommonValuePacker; -import org.neo4j.driver.internal.messaging.common.CommonValueUnpacker; -import org.neo4j.driver.internal.messaging.encode.DiscardAllMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.PullAllMessageEncoder; -import org.neo4j.driver.internal.messaging.encode.ResetMessageEncoder; -import org.neo4j.driver.internal.messaging.request.DiscardAllMessage; -import org.neo4j.driver.internal.messaging.request.PullAllMessage; -import org.neo4j.driver.internal.messaging.request.ResetMessage; -import org.neo4j.driver.internal.messaging.response.FailureMessage; -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.messaging.v3.MessageFormatV3; -import org.neo4j.driver.internal.packstream.PackOutput; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.AbstractMessageWriter; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.common.CommonValueUnpacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.DiscardAllMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.PullAllMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.encode.ResetMessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.DiscardAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.PullAllMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.request.ResetMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.FailureMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.IgnoredMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.RecordMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.SuccessMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v3.MessageFormatV3; +import org.neo4j.driver.internal.bolt.basicimpl.packstream.PackOutput; import org.neo4j.driver.internal.util.Iterables; import org.neo4j.driver.internal.value.InternalValue; import org.neo4j.driver.types.Entity; diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/messaging/MemorizingInboundMessageDispatcher.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/MemorizingInboundMessageDispatcher.java similarity index 72% rename from driver/src/test/java/org/neo4j/driver/internal/util/messaging/MemorizingInboundMessageDispatcher.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/MemorizingInboundMessageDispatcher.java index bae3561234..86ddc98e77 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/messaging/MemorizingInboundMessageDispatcher.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/MemorizingInboundMessageDispatcher.java @@ -14,26 +14,26 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.util.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.util.messaging; import io.netty.channel.Channel; import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.concurrent.CopyOnWriteArrayList; -import org.neo4j.driver.Logging; import org.neo4j.driver.Value; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.response.FailureMessage; -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.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.FailureMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.IgnoredMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.RecordMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.SuccessMessage; public class MemorizingInboundMessageDispatcher extends InboundMessageDispatcher { private final List messages = new CopyOnWriteArrayList<>(); - public MemorizingInboundMessageDispatcher(Channel channel, Logging logging) { + public MemorizingInboundMessageDispatcher(Channel channel, LoggingProvider logging) { super(channel, logging); } diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/messaging/RecordMessageEncoder.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/RecordMessageEncoder.java similarity index 75% rename from driver/src/test/java/org/neo4j/driver/internal/util/messaging/RecordMessageEncoder.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/RecordMessageEncoder.java index e655ce558b..22dbb44ec8 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/messaging/RecordMessageEncoder.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/RecordMessageEncoder.java @@ -14,15 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.util.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.util.messaging; import static org.neo4j.driver.Values.value; 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.response.RecordMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.RecordMessage; public class RecordMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/messaging/SuccessMessageEncoder.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/SuccessMessageEncoder.java similarity index 73% rename from driver/src/test/java/org/neo4j/driver/internal/util/messaging/SuccessMessageEncoder.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/SuccessMessageEncoder.java index 732f5a3639..8a3546f361 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/messaging/SuccessMessageEncoder.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/basicimpl/util/messaging/SuccessMessageEncoder.java @@ -14,13 +14,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.util.messaging; +package org.neo4j.driver.internal.bolt.basicimpl.util.messaging; 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.response.SuccessMessage; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.Message; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.MessageEncoder; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.ValuePacker; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.response.SuccessMessage; public class SuccessMessageEncoder implements MessageEncoder { @Override diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/pooledimpl/PooledBoltConnectionProviderTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/pooledimpl/PooledBoltConnectionProviderTest.java new file mode 100644 index 0000000000..33c4d89fd5 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/pooledimpl/PooledBoltConnectionProviderTest.java @@ -0,0 +1,74 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.pooledimpl; + +import static org.mockito.BDDMockito.then; +import static org.mockito.Mockito.mock; +import static org.mockito.MockitoAnnotations.openMocks; + +import java.time.Clock; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.neo4j.driver.internal.bolt.api.BoltAgentUtil; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.MetricsListener; +import org.neo4j.driver.internal.bolt.api.RoutingContext; +import org.neo4j.driver.internal.security.SecurityPlans; + +class PooledBoltConnectionProviderTest { + PooledBoltConnectionProvider provider; + + @Mock + BoltConnectionProvider upstreamProvider; + + @Mock + LoggingProvider loggingProvider; + + @Mock + Clock clock; + + int maxSize = 2; + long acquisitionTimeout = 5000; + long maxLifetime = 60000; + long idleBeforeTest = 30000; + + @BeforeEach + @SuppressWarnings("resource") + void beforeEach() { + openMocks(this); + } + + @Test + void shouldInit() { + provider = new PooledBoltConnectionProvider( + upstreamProvider, maxSize, acquisitionTimeout, maxLifetime, idleBeforeTest, clock, loggingProvider); + var address = BoltServerAddress.LOCAL_DEFAULT; + var plan = SecurityPlans.insecure(); + var context = RoutingContext.EMPTY; + var boltAgent = BoltAgentUtil.VALUE; + var userAgent = "agent"; + var timeout = 1000; + var metricsListener = mock(MetricsListener.class); + + provider.init(address, plan, context, boltAgent, userAgent, timeout, metricsListener); + + then(upstreamProvider).should().init(address, plan, context, boltAgent, userAgent, timeout, metricsListener); + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/ClusterRoutingTableTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/ClusterRoutingTableTest.java similarity index 88% rename from driver/src/test/java/org/neo4j/driver/internal/cluster/ClusterRoutingTableTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/ClusterRoutingTableTest.java index d33da7651f..02da61570a 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/ClusterRoutingTableTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/ClusterRoutingTableTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal.bolt.routedimpl.cluster; import static java.util.Arrays.asList; import static java.util.Collections.singletonList; @@ -22,18 +22,18 @@ 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.neo4j.driver.AccessMode.READ; -import static org.neo4j.driver.AccessMode.WRITE; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.A; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.B; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.C; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.D; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.E; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.EMPTY; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.F; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.createClusterComposition; +import static org.neo4j.driver.internal.bolt.api.AccessMode.READ; +import static org.neo4j.driver.internal.bolt.api.AccessMode.WRITE; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.A; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.B; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.C; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.D; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.E; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.EMPTY; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.F; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.createClusterComposition; import java.time.Clock; import java.time.Duration; @@ -41,7 +41,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource; -import org.neo4j.driver.internal.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; import org.neo4j.driver.internal.util.FakeClock; class ClusterRoutingTableTest { diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/RediscoveryTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RediscoveryTest.java similarity index 61% rename from driver/src/test/java/org/neo4j/driver/internal/cluster/RediscoveryTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RediscoveryTest.java index ce6e4849bf..be3246bc95 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/RediscoveryTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RediscoveryTest.java @@ -14,34 +14,34 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal.bolt.routedimpl.cluster; import static java.util.Collections.emptySet; import static java.util.Collections.singletonMap; import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.hamcrest.CoreMatchers.containsString; -import static org.hamcrest.CoreMatchers.equalTo; +import static java.util.concurrent.CompletableFuture.failedFuture; import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.containsString; +import static org.hamcrest.Matchers.equalTo; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.ArgumentMatchers.startsWith; import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; -import static org.mockito.Mockito.startsWith; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.A; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.B; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.C; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.D; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.E; -import static org.neo4j.driver.internal.util.Futures.failedFuture; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.A; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.B; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.C; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.D; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.E; import static org.neo4j.driver.testutil.TestUtil.asOrderedSet; import static org.neo4j.driver.testutil.TestUtil.await; @@ -54,35 +54,34 @@ import java.util.Map; import java.util.Set; import java.util.concurrent.CompletableFuture; -import org.junit.jupiter.api.Disabled; +import java.util.concurrent.CompletionStage; +import java.util.function.Function; 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.mockito.Mockito; +import org.mockito.stubbing.Answer; import org.neo4j.driver.exceptions.AuthTokenManagerExecutionException; import org.neo4j.driver.exceptions.AuthenticationException; import org.neo4j.driver.exceptions.AuthorizationExpiredException; import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.exceptions.DiscoveryException; -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; -import org.neo4j.driver.internal.DomainNameResolver; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ConnectionPool; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ClusterComposition; +import org.neo4j.driver.internal.bolt.api.DefaultDomainNameResolver; +import org.neo4j.driver.internal.bolt.api.DomainNameResolver; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; +import org.neo4j.driver.internal.bolt.api.ResponseHandler; import org.neo4j.driver.internal.util.FakeClock; import org.neo4j.driver.internal.util.ImmediateSchedulingEventExecutor; -import org.neo4j.driver.net.ServerAddressResolver; class RediscoveryTest { - private final ConnectionPool pool = asyncConnectionPoolMock(); - @Test void shouldUseFirstRouterInTable() { var expectedComposition = @@ -91,12 +90,13 @@ void shouldUseFirstRouterInTable() { Map responsesByAddress = new HashMap<>(); responsesByAddress.put(B, expectedComposition); // first -> valid cluster composition - var compositionProvider = compositionProviderMock(responsesByAddress); - var rediscovery = newRediscovery(A, compositionProvider, mock(ServerAddressResolver.class)); + var connectionProviderGetter = connectionProviderGetter(responsesByAddress); + + var rediscovery = newRediscovery(A, Collections::singleton); var table = routingTableMock(B); - var actualComposition = await( - rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)) + var actualComposition = await(rediscovery.lookupClusterComposition( + table, connectionProviderGetter, emptySet(), null, null, new BoltProtocolVersion(4, 1))) .getClusterComposition(); assertEquals(expectedComposition, actualComposition); @@ -113,12 +113,13 @@ void shouldSkipFailingRouters() { responsesByAddress.put(B, new ServiceUnavailableException("Hi!")); // second -> non-fatal failure responsesByAddress.put(C, expectedComposition); // third -> valid cluster composition - var compositionProvider = compositionProviderMock(responsesByAddress); - var rediscovery = newRediscovery(A, compositionProvider, mock(ServerAddressResolver.class)); + var connectionProviderGetter = connectionProviderGetter(responsesByAddress); + + var rediscovery = newRediscovery(A, Collections::singleton); var table = routingTableMock(A, B, C); - var actualComposition = await( - rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)) + var actualComposition = await(rediscovery.lookupClusterComposition( + table, connectionProviderGetter, emptySet(), null, null, new BoltProtocolVersion(4, 1))) .getClusterComposition(); assertEquals(expectedComposition, actualComposition); @@ -135,13 +136,14 @@ void shouldFailImmediatelyOnAuthError() { responsesByAddress.put(A, new RuntimeException("Hi!")); // first router -> non-fatal failure responsesByAddress.put(B, authError); // second router -> fatal auth error - var compositionProvider = compositionProviderMock(responsesByAddress); - var rediscovery = newRediscovery(A, compositionProvider, mock(ServerAddressResolver.class)); + var connectionProviderGetter = connectionProviderGetter(responsesByAddress); + var rediscovery = newRediscovery(A, Collections::singleton); var table = routingTableMock(A, B, C); var error = assertThrows( AuthenticationException.class, - () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))); + () -> await(rediscovery.lookupClusterComposition( + table, connectionProviderGetter, emptySet(), null, null, new BoltProtocolVersion(4, 1)))); assertEquals(authError, error); verify(table).forget(A); } @@ -156,12 +158,12 @@ void shouldUseAnotherRouterOnAuthorizationExpiredException() { A, new AuthorizationExpiredException("Neo.ClientError.Security.AuthorizationExpired", "message")); responsesByAddress.put(B, expectedComposition); - var compositionProvider = compositionProviderMock(responsesByAddress); - var rediscovery = newRediscovery(A, compositionProvider, mock(ServerAddressResolver.class)); + var connectionProviderGetter = connectionProviderGetter(responsesByAddress); + var rediscovery = newRediscovery(A, Collections::singleton); var table = routingTableMock(A, B, C); - var actualComposition = await( - rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)) + var actualComposition = await(rediscovery.lookupClusterComposition( + table, connectionProviderGetter, emptySet(), null, null, new BoltProtocolVersion(4, 1))) .getClusterComposition(); assertEquals(expectedComposition, actualComposition); @@ -183,32 +185,34 @@ void shouldFailImmediatelyOnBookmarkErrors(String code) { responsesByAddress.put(A, new RuntimeException("Hi!")); responsesByAddress.put(B, error); - var compositionProvider = compositionProviderMock(responsesByAddress); - var rediscovery = newRediscovery(A, compositionProvider, mock(ServerAddressResolver.class)); + var connectionProviderGetter = connectionProviderGetter(responsesByAddress); + var rediscovery = newRediscovery(A, Collections::singleton); var table = routingTableMock(A, B, C); var actualError = assertThrows( ClientException.class, - () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))); + () -> await(rediscovery.lookupClusterComposition( + table, connectionProviderGetter, emptySet(), null, null, new BoltProtocolVersion(4, 1)))); assertEquals(error, actualError); verify(table).forget(A); } @Test void shouldFailImmediatelyOnClosedPoolError() { - var error = new IllegalStateException(ConnectionPool.CONNECTION_POOL_CLOSED_ERROR_MESSAGE); + var error = new IllegalStateException("Connection provider is closed."); Map responsesByAddress = new HashMap<>(); responsesByAddress.put(A, new RuntimeException("Hi!")); responsesByAddress.put(B, error); - var compositionProvider = compositionProviderMock(responsesByAddress); - var rediscovery = newRediscovery(A, compositionProvider, mock(ServerAddressResolver.class)); + var connectionProviderGetter = connectionProviderGetter(responsesByAddress); + var rediscovery = newRediscovery(A, Collections::singleton); var table = routingTableMock(A, B, C); var actualError = assertThrows( IllegalStateException.class, - () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))); + () -> await(rediscovery.lookupClusterComposition( + table, connectionProviderGetter, emptySet(), null, null, new BoltProtocolVersion(4, 1)))); assertEquals(error, actualError); verify(table).forget(A); } @@ -224,13 +228,13 @@ void shouldFallbackToInitialRouterWhenKnownRoutersFail() { responsesByAddress.put(C, new ServiceUnavailableException("Hi!")); // second -> non-fatal failure responsesByAddress.put(initialRouter, expectedComposition); // initial -> valid response - var compositionProvider = compositionProviderMock(responsesByAddress); + var connectionProviderGetter = connectionProviderGetter(responsesByAddress); var resolver = resolverMock(initialRouter, initialRouter); - var rediscovery = newRediscovery(initialRouter, compositionProvider, resolver); + var rediscovery = newRediscovery(initialRouter, resolver); var table = routingTableMock(B, C); - var actualComposition = await( - rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)) + var actualComposition = await(rediscovery.lookupClusterComposition( + table, connectionProviderGetter, emptySet(), null, null, new BoltProtocolVersion(4, 1))) .getClusterComposition(); assertEquals(expectedComposition, actualComposition); @@ -238,40 +242,6 @@ void shouldFallbackToInitialRouterWhenKnownRoutersFail() { verify(table).forget(C); } - @Disabled("this test looks wrong") - @Test - void shouldFailImmediatelyWhenClusterCompositionProviderReturnsFailure() { - var validComposition = new ClusterComposition(42, asOrderedSet(A), asOrderedSet(B), asOrderedSet(C), null); - var protocolError = new ProtocolException("Wrong record!"); - - Map responsesByAddress = new HashMap<>(); - responsesByAddress.put(B, protocolError); // first -> fatal failure - responsesByAddress.put(C, validComposition); // second -> valid cluster composition - - var logging = mock(Logging.class); - var logger = mock(Logger.class); - when(logging.getLog(any(Class.class))).thenReturn(logger); - - var compositionProvider = compositionProviderMock(responsesByAddress); - var rediscovery = newRediscovery(A, compositionProvider, mock(ServerAddressResolver.class), logging); - var table = routingTableMock(B, C); - - // When - var composition = await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)) - .getClusterComposition(); - assertEquals(validComposition, composition); - - var warningMessageCaptor = ArgumentCaptor.forClass(String.class); - var debugMessageCaptor = ArgumentCaptor.forClass(String.class); - var debugThrowableCaptor = ArgumentCaptor.forClass(DiscoveryException.class); - verify(logging).getLog(RediscoveryImpl.class); - verify(logger).warn(warningMessageCaptor.capture()); - verify(logger).debug(debugMessageCaptor.capture(), debugThrowableCaptor.capture()); - assertNotNull(warningMessageCaptor.getValue()); - assertEquals(warningMessageCaptor.getValue(), debugMessageCaptor.getValue()); - assertThat(debugThrowableCaptor.getValue().getCause(), equalTo(protocolError)); - } - @Test void shouldResolveInitialRouterAddress() { var initialRouter = A; @@ -284,14 +254,14 @@ void shouldResolveInitialRouterAddress() { responsesByAddress.put(D, new IOException("Hi!")); // resolved first -> non-fatal failure responsesByAddress.put(E, expectedComposition); // resolved second -> valid response - var compositionProvider = compositionProviderMock(responsesByAddress); + var connectionProviderGetter = connectionProviderGetter(responsesByAddress); // initial router resolved to two other addresses var resolver = resolverMock(initialRouter, D, E); - var rediscovery = newRediscovery(initialRouter, compositionProvider, resolver); + var rediscovery = newRediscovery(initialRouter, resolver); var table = routingTableMock(B, C); - var actualComposition = await( - rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)) + var actualComposition = await(rediscovery.lookupClusterComposition( + table, connectionProviderGetter, emptySet(), null, null, new BoltProtocolVersion(4, 1))) .getClusterComposition(); assertEquals(expectedComposition, actualComposition); @@ -305,7 +275,7 @@ void shouldResolveInitialRouterAddressUsingCustomResolver() { var expectedComposition = new ClusterComposition(42, asOrderedSet(A, B, C), asOrderedSet(A, B, C), asOrderedSet(B, E), null); - ServerAddressResolver resolver = address -> { + Function> resolver = address -> { assertEquals(A, address); return asOrderedSet(B, C, E); }; @@ -315,12 +285,12 @@ void shouldResolveInitialRouterAddressUsingCustomResolver() { responsesByAddress.put(C, new ServiceUnavailableException("Hi!")); // second -> non-fatal failure responsesByAddress.put(E, expectedComposition); // resolved second -> valid response - var compositionProvider = compositionProviderMock(responsesByAddress); - var rediscovery = newRediscovery(A, compositionProvider, resolver); + var connectionProviderGetter = connectionProviderGetter(responsesByAddress); + var rediscovery = newRediscovery(A, resolver); var table = routingTableMock(B, C); - var actualComposition = await( - rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)) + var actualComposition = await(rediscovery.lookupClusterComposition( + table, connectionProviderGetter, emptySet(), null, null, new BoltProtocolVersion(4, 1))) .getClusterComposition(); assertEquals(expectedComposition, actualComposition); @@ -334,21 +304,23 @@ void shouldPropagateFailureWhenResolverFails() { new ClusterComposition(42, asOrderedSet(A, B), asOrderedSet(A, B), asOrderedSet(A, B), null); Map responsesByAddress = singletonMap(A, expectedComposition); - var compositionProvider = compositionProviderMock(responsesByAddress); + var connectionProviderGetter = connectionProviderGetter(responsesByAddress); // failing server address resolver - var resolver = mock(ServerAddressResolver.class); - when(resolver.resolve(A)).thenThrow(new RuntimeException("Resolver fails!")); + @SuppressWarnings("unchecked") + Function> resolver = mock(Function.class); + when(resolver.apply(A)).thenThrow(new RuntimeException("Resolver fails!")); - var rediscovery = newRediscovery(A, compositionProvider, resolver); + var rediscovery = newRediscovery(A, resolver); var table = routingTableMock(); var error = assertThrows( RuntimeException.class, - () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))); + () -> await(rediscovery.lookupClusterComposition( + table, connectionProviderGetter, emptySet(), null, null, new BoltProtocolVersion(4, 1)))); assertEquals("Resolver fails!", error.getMessage()); - verify(resolver).resolve(A); + verify(resolver).apply(A); verify(table, never()).forget(any()); } @@ -362,13 +334,14 @@ void shouldRecordAllErrorsWhenNoRouterRespond() { var third = new IOException("Hi!"); responsesByAddress.put(C, third); // third -> non-fatal failure - var compositionProvider = compositionProviderMock(responsesByAddress); - var rediscovery = newRediscovery(A, compositionProvider, mock(ServerAddressResolver.class)); + var connectionProviderGetter = connectionProviderGetter(responsesByAddress); + var rediscovery = newRediscovery(A, Collections::singleton); var table = routingTableMock(A, B, C); var e = assertThrows( ServiceUnavailableException.class, - () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))); + () -> await(rediscovery.lookupClusterComposition( + table, connectionProviderGetter, emptySet(), null, null, new BoltProtocolVersion(4, 1)))); assertThat(e.getMessage(), containsString("Could not perform discovery")); assertThat(e.getSuppressed().length, equalTo(3)); assertThat(e.getSuppressed()[0].getCause(), equalTo(first)); @@ -386,13 +359,14 @@ void shouldUseInitialRouterAfterDiscoveryReturnsNoWriters() { Map responsesByAddress = new HashMap<>(); responsesByAddress.put(initialRouter, validComposition); // initial -> valid composition - var compositionProvider = compositionProviderMock(responsesByAddress); + var connectionProviderGetter = connectionProviderGetter(responsesByAddress); var resolver = resolverMock(initialRouter, initialRouter); - var rediscovery = newRediscovery(initialRouter, compositionProvider, resolver); + var rediscovery = newRediscovery(initialRouter, resolver); RoutingTable table = new ClusterRoutingTable(defaultDatabase(), new FakeClock()); table.update(noWritersComposition); - var composition2 = await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)) + var composition2 = await(rediscovery.lookupClusterComposition( + table, connectionProviderGetter, emptySet(), null, null, new BoltProtocolVersion(4, 1))) .getClusterComposition(); assertEquals(validComposition, composition2); } @@ -405,12 +379,18 @@ void shouldUseInitialRouterToStartWith() { Map responsesByAddress = new HashMap<>(); responsesByAddress.put(initialRouter, validComposition); // initial -> valid composition - var compositionProvider = compositionProviderMock(responsesByAddress); + var connectionProviderGetter = connectionProviderGetter(responsesByAddress); var resolver = resolverMock(initialRouter, initialRouter); - var rediscovery = newRediscovery(initialRouter, compositionProvider, resolver); + var rediscovery = newRediscovery(initialRouter, resolver); var table = routingTableMock(true, B, C, D); - var composition = await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)) + var composition = await(rediscovery.lookupClusterComposition( + table, + connectionProviderGetter, + Collections.emptySet(), + null, + null, + new BoltProtocolVersion(4, 1))) .getClusterComposition(); assertEquals(validComposition, composition); } @@ -426,12 +406,18 @@ void shouldUseKnownRoutersWhenInitialRouterFails() { responsesByAddress.put(D, new IOException("Hi")); // first known -> non-fatal failure responsesByAddress.put(E, validComposition); // second known -> valid composition - var compositionProvider = compositionProviderMock(responsesByAddress); + var connectionProviderGetter = connectionProviderGetter(responsesByAddress); var resolver = resolverMock(initialRouter, initialRouter); - var rediscovery = newRediscovery(initialRouter, compositionProvider, resolver); + var rediscovery = newRediscovery(initialRouter, resolver); var table = routingTableMock(true, D, E); - var composition = await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null)) + var composition = await(rediscovery.lookupClusterComposition( + table, + connectionProviderGetter, + Collections.emptySet(), + null, + null, + new BoltProtocolVersion(4, 1))) .getClusterComposition(); assertEquals(validComposition, composition); verify(table).forget(initialRouter); @@ -441,25 +427,31 @@ void shouldUseKnownRoutersWhenInitialRouterFails() { @Test void shouldNotLogWhenSingleRetryAttemptFails() { Map responsesByAddress = singletonMap(A, new ServiceUnavailableException("Hi!")); - var compositionProvider = compositionProviderMock(responsesByAddress); + var connectionProviderGetter = connectionProviderGetter(responsesByAddress); var resolver = resolverMock(A, A); var eventExecutor = new ImmediateSchedulingEventExecutor(); - var logging = mock(Logging.class); - var logger = mock(Logger.class); + var logging = mock(LoggingProvider.class); + var logger = mock(System.Logger.class); when(logging.getLog(any(Class.class))).thenReturn(logger); - Rediscovery rediscovery = - new RediscoveryImpl(A, compositionProvider, resolver, logging, DefaultDomainNameResolver.getInstance()); + Rediscovery rediscovery = new RediscoveryImpl(A, resolver, logging, DefaultDomainNameResolver.getInstance()); var table = routingTableMock(A); var e = assertThrows( ServiceUnavailableException.class, - () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))); + () -> await(rediscovery.lookupClusterComposition( + table, + connectionProviderGetter, + Collections.emptySet(), + null, + null, + new BoltProtocolVersion(4, 1)))); assertThat(e.getMessage(), containsString("Could not perform discovery")); // rediscovery should not log about retries and should not schedule any retries verify(logging).getLog(RediscoveryImpl.class); - verify(logger, never()).info(startsWith("Unable to fetch new routing table, will try again in ")); + verify(logger, never()) + .log(eq(System.Logger.Level.INFO), startsWith("Unable to fetch new routing table, will try again in ")); assertEquals(0, eventExecutor.scheduleDelays().size()); } @@ -469,11 +461,11 @@ void shouldResolveToIP() throws UnknownHostException { var domainNameResolver = mock(DomainNameResolver.class); var localhost = InetAddress.getLocalHost(); when(domainNameResolver.resolve(A.host())).thenReturn(new InetAddress[] {localhost}); - Rediscovery rediscovery = new RediscoveryImpl(A, null, resolver, DEV_NULL_LOGGING, domainNameResolver); + Rediscovery rediscovery = new RediscoveryImpl(A, resolver, NoopLoggingProvider.INSTANCE, domainNameResolver); var addresses = rediscovery.resolve(); - verify(resolver, times(1)).resolve(A); + verify(resolver, times(1)).apply(A); verify(domainNameResolver, times(1)).resolve(A.host()); assertEquals(1, addresses.size()); assertEquals(new BoltServerAddress(A.host(), localhost.getHostAddress(), A.port()), addresses.get(0)); @@ -487,13 +479,19 @@ void shouldFailImmediatelyOnAuthTokenManagerExecutionException() { responsesByAddress.put(A, new RuntimeException("Hi!")); // first router -> non-fatal failure responsesByAddress.put(B, exception); // second router -> fatal auth error - var compositionProvider = compositionProviderMock(responsesByAddress); - var rediscovery = newRediscovery(A, compositionProvider, mock(ServerAddressResolver.class)); + var connectionProviderGetter = connectionProviderGetter(responsesByAddress); + var rediscovery = newRediscovery(A, Collections::singleton); var table = routingTableMock(A, B, C); var actualException = assertThrows( AuthTokenManagerExecutionException.class, - () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))); + () -> await(rediscovery.lookupClusterComposition( + table, + connectionProviderGetter, + Collections.emptySet(), + null, + null, + new BoltProtocolVersion(4, 1)))); assertEquals(exception, actualException); verify(table).forget(A); } @@ -506,13 +504,19 @@ void shouldFailImmediatelyOnUnsupportedFeatureException() { responsesByAddress.put(A, new RuntimeException("Hi!")); // first router -> non-fatal failure responsesByAddress.put(B, exception); // second router -> fatal auth error - var compositionProvider = compositionProviderMock(responsesByAddress); - var rediscovery = newRediscovery(A, compositionProvider, mock(ServerAddressResolver.class)); + var connectionProviderGetter = connectionProviderGetter(responsesByAddress); + var rediscovery = newRediscovery(A, Collections::singleton); var table = routingTableMock(A, B, C); var actualException = assertThrows( UnsupportedFeatureException.class, - () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))); + () -> await(rediscovery.lookupClusterComposition( + table, + connectionProviderGetter, + Collections.emptySet(), + null, + null, + new BoltProtocolVersion(4, 1)))); assertEquals(exception, actualException); verify(table).forget(A); } @@ -521,85 +525,88 @@ void shouldFailImmediatelyOnUnsupportedFeatureException() { void shouldLogScopedIPV6AddressWithStringFormattingLogger() throws UnknownHostException { // GIVEN var initialRouter = new BoltServerAddress("initialRouter", 7687); - var compositionProvider = compositionProviderMock(Collections.emptyMap()); + var connectionProviderGetter = connectionProviderGetter(Collections.emptyMap()); var resolver = resolverMock(initialRouter, initialRouter); var domainNameResolver = mock(DomainNameResolver.class); var address = mock(InetAddress.class); given(address.getHostAddress()).willReturn("fe80:0:0:0:ce66:1564:db8q:94b6%6"); given(domainNameResolver.resolve(initialRouter.host())).willReturn(new InetAddress[] {address}); var table = routingTableMock(true); - var pool = mock(ConnectionPool.class); - given(pool.acquire(any(), any())) - .willReturn(CompletableFuture.failedFuture(new ServiceUnavailableException("not available"))); - var logging = mock(Logging.class); - var logger = mock(Logger.class); + var pool = mock(BoltConnectionProvider.class); + given(pool.connect(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(failedFuture(new ServiceUnavailableException("not available"))); + var logging = mock(LoggingProvider.class); + var logger = mock(System.Logger.class); given(logging.getLog(any(Class.class))).willReturn(logger); doAnswer(invocationOnMock -> String.format(invocationOnMock.getArgument(0), invocationOnMock.getArgument(1))) .when(logger) - .warn(any()); - var rediscovery = - new RediscoveryImpl(initialRouter, compositionProvider, resolver, logging, domainNameResolver); + .log(eq(System.Logger.Level.WARNING), anyString()); + var rediscovery = new RediscoveryImpl(initialRouter, resolver, logging, domainNameResolver); // WHEN & THEN assertThrows( ServiceUnavailableException.class, - () -> await(rediscovery.lookupClusterComposition(table, pool, Collections.emptySet(), null, null))); + () -> await(rediscovery.lookupClusterComposition( + table, + connectionProviderGetter, + Collections.emptySet(), + null, + null, + new BoltProtocolVersion(4, 1)))); } private Rediscovery newRediscovery( - BoltServerAddress initialRouter, - ClusterCompositionProvider compositionProvider, - ServerAddressResolver resolver) { - return newRediscovery(initialRouter, compositionProvider, resolver, DEV_NULL_LOGGING); + BoltServerAddress initialRouter, Function> resolver) { + return newRediscovery(initialRouter, resolver, NoopLoggingProvider.INSTANCE); } private Rediscovery newRediscovery( BoltServerAddress initialRouter, - ClusterCompositionProvider compositionProvider, - ServerAddressResolver resolver, - Logging logging) { - return new RediscoveryImpl( - initialRouter, compositionProvider, resolver, logging, DefaultDomainNameResolver.getInstance()); + Function> resolver, + LoggingProvider loggingProvider) { + return new RediscoveryImpl(initialRouter, resolver, loggingProvider, DefaultDomainNameResolver.getInstance()); } - @SuppressWarnings("unchecked") - private static ClusterCompositionProvider compositionProviderMock( + private Function connectionProviderGetter( Map responsesByAddress) { - var provider = mock(ClusterCompositionProvider.class); - when(provider.getClusterComposition(any(Connection.class), any(DatabaseName.class), any(Set.class), any())) - .then(invocation -> { - Connection connection = invocation.getArgument(0); - var address = connection.serverAddress(); - var response = responsesByAddress.get(address); - assertNotNull(response); - if (response instanceof Throwable) { - return failedFuture((Throwable) response); - } else { - return completedFuture(response); - } - }); - return provider; - } + var addressToProvider = new HashMap(); + for (Map.Entry entry : responsesByAddress.entrySet()) { + var boltConnection = setupConnection(entry.getValue()); + + var boltConnectionProvider = mock(BoltConnectionProvider.class); + given(boltConnectionProvider.connect(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(boltConnection)); - private static ServerAddressResolver resolverMock(BoltServerAddress address, BoltServerAddress... resolved) { - var resolver = mock(ServerAddressResolver.class); - when(resolver.resolve(address)).thenReturn(asOrderedSet(resolved)); - return resolver; + addressToProvider.put(entry.getKey(), boltConnectionProvider); + } + return addressToProvider::get; } - private static ConnectionPool asyncConnectionPoolMock() { - var pool = mock(ConnectionPool.class); - when(pool.acquire(any(), any())).then(invocation -> { - BoltServerAddress address = invocation.getArgument(0); - return completedFuture(asyncConnectionMock(address)); + private BoltConnection setupConnection(Object answer) { + var boltConnection = mock(BoltConnection.class); + given(boltConnection.route(any(), any(), any())).willReturn(CompletableFuture.completedStage(boltConnection)); + given(boltConnection.flush(any())).willAnswer((Answer>) invocationOnMock -> { + var handler = (ResponseHandler) invocationOnMock.getArguments()[0]; + + if (answer instanceof ClusterComposition composition) { + handler.onRouteSummary(() -> composition); + } else if (answer instanceof Throwable throwable) { + handler.onError(throwable); + } + handler.onComplete(); + + return CompletableFuture.completedStage(null); }); - return pool; + given(boltConnection.close()).willReturn(CompletableFuture.completedStage(null)); + return boltConnection; } - private static Connection asyncConnectionMock(BoltServerAddress address) { - var connection = mock(Connection.class); - when(connection.serverAddress()).thenReturn(address); - return connection; + private static Function> resolverMock( + BoltServerAddress address, BoltServerAddress... resolved) { + @SuppressWarnings("unchecked") + Function> resolverMock = Mockito.mock(Function.class); + given(resolverMock.apply(address)).willReturn(asOrderedSet(resolved)); + return resolverMock; } private static RoutingTable routingTableMock(BoltServerAddress... routers) { @@ -607,7 +614,7 @@ private static RoutingTable routingTableMock(BoltServerAddress... routers) { } private static RoutingTable routingTableMock(boolean preferInitialRouter, BoltServerAddress... routers) { - var routingTable = mock(RoutingTable.class); + var routingTable = Mockito.mock(RoutingTable.class); when(routingTable.routers()).thenReturn(Arrays.asList(routers)); when(routingTable.database()).thenReturn(defaultDatabase()); when(routingTable.preferInitialRouter()).thenReturn(preferInitialRouter); diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/RediscoveryUtil.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RediscoveryUtil.java similarity index 84% rename from driver/src/test/java/org/neo4j/driver/internal/cluster/RediscoveryUtil.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RediscoveryUtil.java index 096db8de5e..e689190463 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/RediscoveryUtil.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RediscoveryUtil.java @@ -14,10 +14,10 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal.bolt.routedimpl.cluster; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; import java.util.Collections; import org.neo4j.driver.AccessMode; diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableHandlerTest.java new file mode 100644 index 0000000000..bca9528f06 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableHandlerTest.java @@ -0,0 +1,344 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.routedimpl.cluster; + +import static java.util.Arrays.asList; +import static java.util.Collections.emptySet; +import static java.util.Collections.singletonList; +import static java.util.concurrent.CompletableFuture.completedFuture; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.BDDMockito.given; +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.internal.RoutingSettings.STALE_ROUTING_TABLE_PURGE_DELAY_MS; +import static org.neo4j.driver.internal.bolt.api.AccessMode.READ; +import static org.neo4j.driver.internal.bolt.api.AccessMode.WRITE; +import static org.neo4j.driver.internal.bolt.api.BoltServerAddress.LOCAL_DEFAULT; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.A; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.B; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.C; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.D; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.E; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.F; +import static org.neo4j.driver.testutil.TestUtil.asOrderedSet; +import static org.neo4j.driver.testutil.TestUtil.await; + +import java.util.Collections; +import java.util.LinkedHashSet; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.function.Function; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import org.neo4j.driver.exceptions.ServiceUnavailableException; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ClusterComposition; +import org.neo4j.driver.internal.util.FakeClock; + +class RoutingTableHandlerTest { + @Test + void shouldRemoveAddressFromRoutingTableOnConnectionFailure() { + RoutingTable routingTable = new ClusterRoutingTable(defaultDatabase(), new FakeClock()); + routingTable.update( + new ClusterComposition(42, asOrderedSet(A, B, C), asOrderedSet(A, C, E), asOrderedSet(B, D, F), null)); + + var handler = newRoutingTableHandler(routingTable, newRediscoveryMock(), newConnectionPoolMock()); + + handler.onConnectionFailure(B); + + assertArrayEquals(new BoltServerAddress[] {A, C}, routingTable.readers().toArray()); + assertArrayEquals( + new BoltServerAddress[] {A, C, E}, routingTable.writers().toArray()); + assertArrayEquals(new BoltServerAddress[] {D, F}, routingTable.routers().toArray()); + + handler.onConnectionFailure(A); + + assertArrayEquals(new BoltServerAddress[] {C}, routingTable.readers().toArray()); + assertArrayEquals(new BoltServerAddress[] {C, E}, routingTable.writers().toArray()); + assertArrayEquals(new BoltServerAddress[] {D, F}, routingTable.routers().toArray()); + } + + @Test + void acquireShouldUpdateRoutingTableWhenKnownRoutingTableIsStale() { + var initialRouter = new BoltServerAddress("initialRouter", 1); + var reader1 = new BoltServerAddress("reader-1", 2); + var reader2 = new BoltServerAddress("reader-1", 3); + var writer1 = new BoltServerAddress("writer-1", 4); + var router1 = new BoltServerAddress("router-1", 5); + + var connectionPool = newConnectionPoolMock(); + var routingTable = new ClusterRoutingTable(defaultDatabase(), new FakeClock(), initialRouter); + + Set readers = new LinkedHashSet<>(asList(reader1, reader2)); + Set writers = new LinkedHashSet<>(singletonList(writer1)); + Set routers = new LinkedHashSet<>(singletonList(router1)); + var clusterComposition = new ClusterComposition(42, readers, writers, routers, null); + Rediscovery rediscovery = Mockito.mock(RediscoveryImpl.class); + when(rediscovery.lookupClusterComposition(eq(routingTable), eq(connectionPool), any(), any(), any(), any())) + .thenReturn(completedFuture(new ClusterCompositionLookupResult(clusterComposition))); + + var handler = newRoutingTableHandler(routingTable, rediscovery, connectionPool); + assertNotNull(await(handler.ensureRoutingTable( + READ, + Collections.emptySet(), + () -> CompletableFuture.completedStage(Collections.emptyMap()), + new BoltProtocolVersion(4, 1)))); + + verify(rediscovery).lookupClusterComposition(eq(routingTable), eq(connectionPool), any(), any(), any(), any()); + assertArrayEquals( + new BoltServerAddress[] {reader1, reader2}, + routingTable.readers().toArray()); + assertArrayEquals( + new BoltServerAddress[] {writer1}, routingTable.writers().toArray()); + assertArrayEquals( + new BoltServerAddress[] {router1}, routingTable.routers().toArray()); + } + + @Test + void shouldRediscoverOnReadWhenRoutingTableIsStaleForReads() { + testRediscoveryWhenStale(READ); + } + + @Test + void shouldRediscoverOnWriteWhenRoutingTableIsStaleForWrites() { + testRediscoveryWhenStale(WRITE); + } + + @Test + void shouldNotRediscoverOnReadWhenRoutingTableIsStaleForWritesButNotReads() { + testNoRediscoveryWhenNotStale(WRITE, READ); + } + + @Test + void shouldNotRediscoverOnWriteWhenRoutingTableIsStaleForReadsButNotWrites() { + testNoRediscoveryWhenNotStale(READ, WRITE); + } + + // @Test + // void shouldRetainAllFetchedAddressesInConnectionPoolAfterFetchingOfRoutingTable() { + // RoutingTable routingTable = new ClusterRoutingTable(defaultDatabase(), new FakeClock()); + // routingTable.update(new ClusterComposition(42, asOrderedSet(), asOrderedSet(B, C), asOrderedSet(D, E), + // null)); + // + // var connectionPool = newConnectionPoolMock(); + // + // var rediscovery = newRediscoveryMock(); + // when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any(), any())) + // .thenReturn(completedFuture(new ClusterCompositionLookupResult( + // new ClusterComposition(42, asOrderedSet(A, B), asOrderedSet(B, C), asOrderedSet(A, C), + // null)))); + // + // var registry = new RoutingTableRegistry() { + // @Override + // public CompletionStage ensureRoutingTable(CompletableFuture + // databaseNameFuture, AccessMode mode, Set rediscoveryBookmarks, String impersonatedUser, + // Supplier>> authMapStageSupplier, BoltProtocolVersion minVersion) { + // throw new UnsupportedOperationException(); + // } + // + // @Override + // public Set allServers() { + // return routingTable.servers(); + // } + // + // @Override + // public void remove(DatabaseName databaseName) { + // throw new UnsupportedOperationException(); + // } + // + // @Override + // public void removeAged() {} + // + // @Override + // public Optional getRoutingTableHandler(DatabaseName databaseName) { + // return Optional.empty(); + // } + // }; + // + // var handler = newRoutingTableHandler(routingTable, rediscovery, connectionPool, registry); + // + // var actual = await(handler.ensureRoutingTable(READ, Collections.emptySet(), () -> + // CompletableFuture.completedStage(Collections.emptyMap()), new BoltProtocolVersion(4, 1))); + // assertEquals(routingTable, actual); + // + // verify(connectionPool).retainAll(new HashSet<>(asList(A, B, C))); + // } + + @Test + void shouldRemoveRoutingTableHandlerIfFailedToLookup() { + // Given + RoutingTable routingTable = new ClusterRoutingTable(defaultDatabase(), new FakeClock()); + + var rediscovery = newRediscoveryMock(); + when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any(), any())) + .thenReturn(CompletableFuture.failedFuture(new RuntimeException("Bang!"))); + + var connectionPool = newConnectionPoolMock(); + var registry = newRoutingTableRegistryMock(); + // When + + var handler = newRoutingTableHandler(routingTable, rediscovery, connectionPool, registry); + assertThrows( + RuntimeException.class, + () -> await(handler.ensureRoutingTable( + READ, + Collections.emptySet(), + () -> CompletableFuture.completedStage(Collections.emptyMap()), + new BoltProtocolVersion(4, 1)))); + + // Then + verify(registry).remove(defaultDatabase()); + } + + private void testRediscoveryWhenStale(AccessMode mode) { + Function connectionProviderGetter = requestedAddress -> { + var boltConnectionProvider = mock(BoltConnectionProvider.class); + var connection = mock(BoltConnection.class); + given(boltConnectionProvider.connect(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(connection)); + return boltConnectionProvider; + }; + + var routingTable = newStaleRoutingTableMock(mode); + var rediscovery = newRediscoveryMock(); + + var handler = newRoutingTableHandler(routingTable, rediscovery, connectionProviderGetter); + var actual = await(handler.ensureRoutingTable( + mode, + Collections.emptySet(), + () -> CompletableFuture.completedStage(Collections.emptyMap()), + new BoltProtocolVersion(4, 1))); + assertEquals(routingTable, actual); + + verify(routingTable).isStaleFor(mode); + verify(rediscovery) + .lookupClusterComposition(eq(routingTable), eq(connectionProviderGetter), any(), any(), any(), any()); + } + + private void testNoRediscoveryWhenNotStale(AccessMode staleMode, AccessMode notStaleMode) { + Function connectionProviderGetter = requestedAddress -> { + var boltConnectionProvider = mock(BoltConnectionProvider.class); + var connection = mock(BoltConnection.class); + given(boltConnectionProvider.connect(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(connection)); + return boltConnectionProvider; + }; + + var routingTable = newStaleRoutingTableMock(staleMode); + var rediscovery = newRediscoveryMock(); + + var handler = newRoutingTableHandler(routingTable, rediscovery, connectionProviderGetter); + + assertNotNull(await(handler.ensureRoutingTable( + notStaleMode, + Collections.emptySet(), + () -> CompletableFuture.completedStage(Collections.emptyMap()), + new BoltProtocolVersion(4, 1)))); + verify(routingTable).isStaleFor(notStaleMode); + verify(rediscovery, never()) + .lookupClusterComposition(eq(routingTable), eq(connectionProviderGetter), any(), any(), any(), any()); + } + + private static RoutingTable newStaleRoutingTableMock(AccessMode mode) { + var routingTable = Mockito.mock(RoutingTable.class); + when(routingTable.isStaleFor(mode)).thenReturn(true); + + var addresses = singletonList(LOCAL_DEFAULT); + when(routingTable.readers()).thenReturn(addresses); + when(routingTable.writers()).thenReturn(addresses); + when(routingTable.database()).thenReturn(defaultDatabase()); + + return routingTable; + } + + private static RoutingTableRegistry newRoutingTableRegistryMock() { + return Mockito.mock(RoutingTableRegistry.class); + } + + @SuppressWarnings("unchecked") + private static Rediscovery newRediscoveryMock() { + Rediscovery rediscovery = Mockito.mock(RediscoveryImpl.class); + Set noServers = Collections.emptySet(); + var clusterComposition = new ClusterComposition(1, noServers, noServers, noServers, null); + when(rediscovery.lookupClusterComposition( + any(RoutingTable.class), any(Function.class), any(), any(), any(), any())) + .thenReturn(completedFuture(new ClusterCompositionLookupResult(clusterComposition))); + return rediscovery; + } + + private static Function newConnectionPoolMock() { + return newConnectionPoolMockWithFailures(emptySet()); + } + + private static Function newConnectionPoolMockWithFailures( + Set unavailableAddresses) { + return requestedAddress -> { + var boltConnectionProvider = mock(BoltConnectionProvider.class); + if (unavailableAddresses.contains(requestedAddress)) { + given(boltConnectionProvider.connect(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(CompletableFuture.failedFuture( + new ServiceUnavailableException(requestedAddress + " is unavailable!"))); + return boltConnectionProvider; + } + var connection = mock(BoltConnection.class); + when(connection.serverAddress()).thenReturn(requestedAddress); + given(boltConnectionProvider.connect(any(), any(), any(), any(), any(), any(), any(), any())) + .willReturn(completedFuture(connection)); + return boltConnectionProvider; + }; + } + + private static RoutingTableHandler newRoutingTableHandler( + RoutingTable routingTable, + Rediscovery rediscovery, + Function connectionProviderGetter) { + return new RoutingTableHandlerImpl( + routingTable, + rediscovery, + connectionProviderGetter, + newRoutingTableRegistryMock(), + NoopLoggingProvider.INSTANCE, + STALE_ROUTING_TABLE_PURGE_DELAY_MS); + } + + private static RoutingTableHandler newRoutingTableHandler( + RoutingTable routingTable, + Rediscovery rediscovery, + Function connectionProviderGetter, + RoutingTableRegistry routingTableRegistry) { + return new RoutingTableHandlerImpl( + routingTable, + rediscovery, + connectionProviderGetter, + routingTableRegistry, + NoopLoggingProvider.INSTANCE, + STALE_ROUTING_TABLE_PURGE_DELAY_MS); + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingTableRegistryImplTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableRegistryImplTest.java similarity index 51% rename from driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingTableRegistryImplTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableRegistryImplTest.java index ca4187bd34..7707d43755 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingTableRegistryImplTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/RoutingTableRegistryImplTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster; +package org.neo4j.driver.internal.bolt.routedimpl.cluster; import static java.util.concurrent.CompletableFuture.completedFuture; import static org.hamcrest.MatcherAssert.assertThat; @@ -22,7 +22,6 @@ import static org.hamcrest.Matchers.containsInAnyOrder; import static org.hamcrest.Matchers.empty; import static org.hamcrest.Matchers.equalTo; -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; @@ -30,45 +29,42 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import static org.neo4j.driver.internal.DatabaseNameUtil.SYSTEM_DATABASE_NAME; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.cluster.RoutingSettings.STALE_ROUTING_TABLE_PURGE_DELAY_MS; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.A; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.B; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.C; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.D; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.E; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.F; -import static org.neo4j.driver.testutil.TestUtil.await; +import static org.neo4j.driver.internal.RoutingSettings.STALE_ROUTING_TABLE_PURGE_DELAY_MS; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.SYSTEM_DATABASE_NAME; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.A; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.B; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.C; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.D; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.E; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.F; import java.time.Clock; import java.util.Arrays; import java.util.Collections; import java.util.HashSet; +import java.util.concurrent.CompletableFuture; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.EnumSource; import org.junit.jupiter.params.provider.ValueSource; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.async.ImmutableConnectionContext; -import org.neo4j.driver.internal.cluster.RoutingTableRegistryImpl.RoutingTableHandlerFactory; -import org.neo4j.driver.internal.spi.ConnectionPool; +import org.mockito.Mockito; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.AccessMode; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.DatabaseName; class RoutingTableRegistryImplTest { @Test void factoryShouldCreateARoutingTableWithSameDatabaseName() { var clock = Clock.systemUTC(); - var factory = new RoutingTableHandlerFactory( - mock(ConnectionPool.class), - mock(RediscoveryImpl.class), + var factory = new RoutingTableRegistryImpl.RoutingTableHandlerFactory( + mock(), + Mockito.mock(RediscoveryImpl.class), clock, - DEV_NULL_LOGGING, + NoopLoggingProvider.INSTANCE, STALE_ROUTING_TABLE_PURGE_DELAY_MS); var handler = factory.newInstance(database("Molly"), null); @@ -95,52 +91,77 @@ void shouldCreateRoutingTableHandlerIfAbsentWhenFreshRoutingTable(String databas // When var database = database(databaseName); routingTables.ensureRoutingTable( - new ImmutableConnectionContext(database, Collections.emptySet(), AccessMode.READ)); + CompletableFuture.completedFuture(database), + AccessMode.READ, + Collections.emptySet(), + null, + () -> CompletableFuture.completedStage(Collections.emptyMap()), + new BoltProtocolVersion(4, 1)); // Then assertTrue(map.containsKey(database)); verify(factory).newInstance(eq(database), eq(routingTables)); } - @ParameterizedTest - @ValueSource(strings = {SYSTEM_DATABASE_NAME, "", "database", " molly "}) - void shouldReturnExistingRoutingTableHandlerWhenFreshRoutingTable(String databaseName) { - // Given - ConcurrentMap map = new ConcurrentHashMap<>(); - var handler = mockedRoutingTableHandler(); - var database = database(databaseName); - map.put(database, handler); - - var factory = mockedHandlerFactory(); - var routingTables = newRoutingTables(map, factory); - var context = new ImmutableConnectionContext(database, Collections.emptySet(), AccessMode.READ); - - // When - var actual = await(routingTables.ensureRoutingTable(context)); - - // Then it is the one we put in map that is picked up. - verify(handler).ensureRoutingTable(context); - // Then it is the one we put in map that is picked up. - assertEquals(handler, actual); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldReturnFreshRoutingTable(AccessMode mode) { - // Given - ConcurrentMap map = new ConcurrentHashMap<>(); - var handler = mockedRoutingTableHandler(); - var factory = mockedHandlerFactory(handler); - var routingTables = - new RoutingTableRegistryImpl(map, factory, null, null, mock(Rediscovery.class), DEV_NULL_LOGGING); - - var context = new ImmutableConnectionContext(defaultDatabase(), Collections.emptySet(), mode); - // When - routingTables.ensureRoutingTable(context); - - // Then - verify(handler).ensureRoutingTable(context); - } + // @ParameterizedTest + // @ValueSource(strings = {SYSTEM_DATABASE_NAME, "", "database", " molly "}) + // void shouldReturnExistingRoutingTableHandlerWhenFreshRoutingTable(String databaseName) { + // // Given + // ConcurrentMap map = new ConcurrentHashMap<>(); + // var handler = mockedRoutingTableHandler(); + // var database = database(databaseName); + // map.put(database, handler); + // + // var factory = mockedHandlerFactory(); + // var routingTables = newRoutingTables(map, factory); + // + // // When + // var actual = await(routingTables.ensureRoutingTable( + // CompletableFuture.completedFuture(database), + // AccessMode.READ, + // Collections.emptySet(), + // null, + // () -> CompletableFuture.completedStage(Collections.emptyMap()), + // new BoltProtocolVersion(4, 1))); + // + // // Then it is the one we put in map that is picked up. + // verify(handler) + // .ensureRoutingTable( + // AccessMode.READ, + // Collections.emptySet(), + // () -> CompletableFuture.completedStage(Collections.emptyMap()), + // new BoltProtocolVersion(4, 1)); + // // Then it is the one we put in map that is picked up. + // assertEquals(handler, actual); + // } + + // @ParameterizedTest + // @EnumSource(AccessMode.class) + // void shouldReturnFreshRoutingTable(AccessMode mode) { + // // Given + // ConcurrentMap map = new ConcurrentHashMap<>(); + // var handler = mockedRoutingTableHandler(); + // var factory = mockedHandlerFactory(handler); + // var routingTables = new RoutingTableRegistryImpl( + // map, factory, null, null, Mockito.mock(Rediscovery.class), NoopLoggingProvider.INSTANCE); + // + // // When + // routingTables.ensureRoutingTable( + // CompletableFuture.completedFuture(defaultDatabase()), + // mode, + // Collections.emptySet(), + // null, + // () -> CompletableFuture.completedStage(Collections.emptyMap()), + // new BoltProtocolVersion(4, 1)); + // + // // Then + // verify(handler) + // .ensureRoutingTable( + // mode, + // Collections.emptySet(), + // () -> CompletableFuture.completedStage(Collections.emptyMap()), + // new BoltProtocolVersion(4, 1)); + // } @Test void shouldReturnServersInAllRoutingTables() { @@ -150,8 +171,8 @@ void shouldReturnServersInAllRoutingTables() { map.put(database("Banana"), mockedRoutingTableHandler(B, C, D)); map.put(database("Orange"), mockedRoutingTableHandler(E, F, C)); var factory = mockedHandlerFactory(); - var routingTables = - new RoutingTableRegistryImpl(map, factory, null, null, mock(Rediscovery.class), DEV_NULL_LOGGING); + var routingTables = new RoutingTableRegistryImpl( + map, factory, null, null, Mockito.mock(Rediscovery.class), NoopLoggingProvider.INSTANCE); // When var servers = routingTables.allServers(); @@ -199,40 +220,42 @@ void shouldNotAcceptNullRediscovery() { // GIVEN var factory = mockedHandlerFactory(); var clock = mock(Clock.class); - var connectionPool = mock(ConnectionPool.class); // WHEN & THEN assertThrows( NullPointerException.class, () -> new RoutingTableRegistryImpl( - new ConcurrentHashMap<>(), factory, clock, connectionPool, null, DEV_NULL_LOGGING)); + new ConcurrentHashMap<>(), factory, clock, mock(), null, NoopLoggingProvider.INSTANCE)); } private RoutingTableHandler mockedRoutingTableHandler(BoltServerAddress... servers) { - var handler = mock(RoutingTableHandler.class); + var handler = Mockito.mock(RoutingTableHandler.class); when(handler.servers()).thenReturn(new HashSet<>(Arrays.asList(servers))); when(handler.isRoutingTableAged()).thenReturn(true); return handler; } private RoutingTableRegistryImpl newRoutingTables( - ConcurrentMap handlers, RoutingTableHandlerFactory factory) { - return new RoutingTableRegistryImpl(handlers, factory, null, null, mock(Rediscovery.class), DEV_NULL_LOGGING); + ConcurrentMap handlers, + RoutingTableRegistryImpl.RoutingTableHandlerFactory factory) { + return new RoutingTableRegistryImpl( + handlers, factory, null, null, Mockito.mock(Rediscovery.class), NoopLoggingProvider.INSTANCE); } - private RoutingTableHandlerFactory mockedHandlerFactory(RoutingTableHandler handler) { - var factory = mock(RoutingTableHandlerFactory.class); + private RoutingTableRegistryImpl.RoutingTableHandlerFactory mockedHandlerFactory(RoutingTableHandler handler) { + var factory = mock(RoutingTableRegistryImpl.RoutingTableHandlerFactory.class); when(factory.newInstance(any(), any())).thenReturn(handler); return factory; } - private RoutingTableHandlerFactory mockedHandlerFactory() { + private RoutingTableRegistryImpl.RoutingTableHandlerFactory mockedHandlerFactory() { return mockedHandlerFactory(mockedRoutingTableHandler()); } private RoutingTableHandler mockedRoutingTableHandler() { - var handler = mock(RoutingTableHandler.class); - when(handler.ensureRoutingTable(any())).thenReturn(completedFuture(mock(RoutingTable.class))); + var handler = Mockito.mock(RoutingTableHandler.class); + when(handler.ensureRoutingTable(any(), any(), any(), any())) + .thenReturn(completedFuture(Mockito.mock(RoutingTable.class))); return handler; } } diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/loadbalancing/LeastConnectedLoadBalancingStrategyTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/LeastConnectedLoadBalancingStrategyTest.java similarity index 73% rename from driver/src/test/java/org/neo4j/driver/internal/cluster/loadbalancing/LeastConnectedLoadBalancingStrategyTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/LeastConnectedLoadBalancingStrategyTest.java index 7d979fd180..6a26d11d19 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/loadbalancing/LeastConnectedLoadBalancingStrategyTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/LeastConnectedLoadBalancingStrategyTest.java @@ -14,33 +14,33 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster.loadbalancing; +package org.neo4j.driver.internal.bolt.routedimpl.cluster.loadbalancing; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.startsWith; +import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static org.mockito.MockitoAnnotations.openMocks; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.A; +import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.A; import java.util.Arrays; import java.util.Collections; +import java.util.function.Function; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.mockito.Mock; -import org.neo4j.driver.Logger; -import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.spi.ConnectionPool; +import org.neo4j.driver.internal.bolt.NoopLoggingProvider; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.LoggingProvider; class LeastConnectedLoadBalancingStrategyTest { @Mock - private ConnectionPool connectionPool; + private Function inUseFunction; private LeastConnectedLoadBalancingStrategy strategy; @@ -48,7 +48,8 @@ class LeastConnectedLoadBalancingStrategyTest { @SuppressWarnings("resource") void setUp() { openMocks(this); - strategy = new LeastConnectedLoadBalancingStrategy(connectionPool, DEV_NULL_LOGGING); + strategy = new LeastConnectedLoadBalancingStrategy(inUseFunction, NoopLoggingProvider.INSTANCE); + given(inUseFunction.apply(any())).willReturn(0); } @Test @@ -78,7 +79,7 @@ void shouldHandleSingleWriterWithoutActiveConnections() { @Test void shouldHandleSingleReaderWithActiveConnections() { var address = new BoltServerAddress("reader", 9999); - when(connectionPool.inUseConnections(address)).thenReturn(42); + when(inUseFunction.apply(address)).thenReturn(42); assertEquals(address, strategy.selectReader(Collections.singletonList(address))); } @@ -86,7 +87,7 @@ void shouldHandleSingleReaderWithActiveConnections() { @Test void shouldHandleSingleWriterWithActiveConnections() { var address = new BoltServerAddress("writer", 9999); - when(connectionPool.inUseConnections(address)).thenReturn(24); + when(inUseFunction.apply(address)).thenReturn(24); assertEquals(address, strategy.selectWriter(Collections.singletonList(address))); } @@ -97,9 +98,9 @@ void shouldHandleMultipleReadersWithActiveConnections() { var address2 = new BoltServerAddress("reader", 2); var address3 = new BoltServerAddress("reader", 3); - when(connectionPool.inUseConnections(address1)).thenReturn(3); - when(connectionPool.inUseConnections(address2)).thenReturn(4); - when(connectionPool.inUseConnections(address3)).thenReturn(1); + when(inUseFunction.apply(address1)).thenReturn(3); + when(inUseFunction.apply(address2)).thenReturn(4); + when(inUseFunction.apply(address3)).thenReturn(1); assertEquals(address3, strategy.selectReader(Arrays.asList(address1, address2, address3))); } @@ -111,10 +112,10 @@ void shouldHandleMultipleWritersWithActiveConnections() { var address3 = new BoltServerAddress("writer", 3); var address4 = new BoltServerAddress("writer", 4); - when(connectionPool.inUseConnections(address1)).thenReturn(5); - when(connectionPool.inUseConnections(address2)).thenReturn(6); - when(connectionPool.inUseConnections(address3)).thenReturn(0); - when(connectionPool.inUseConnections(address4)).thenReturn(1); + when(inUseFunction.apply(address1)).thenReturn(5); + when(inUseFunction.apply(address2)).thenReturn(6); + when(inUseFunction.apply(address3)).thenReturn(0); + when(inUseFunction.apply(address4)).thenReturn(1); assertEquals(address3, strategy.selectWriter(Arrays.asList(address1, address2, address3, address4))); } @@ -148,33 +149,33 @@ void shouldReturnDifferentWriterOnEveryInvocationWhenNoActiveConnections() { @Test void shouldTraceLogWhenNoAddressSelected() { - var logging = mock(Logging.class); - var logger = mock(Logger.class); + var logging = mock(LoggingProvider.class); + var logger = mock(System.Logger.class); when(logging.getLog(any(Class.class))).thenReturn(logger); - LoadBalancingStrategy strategy = new LeastConnectedLoadBalancingStrategy(connectionPool, logging); + LoadBalancingStrategy strategy = new LeastConnectedLoadBalancingStrategy(inUseFunction, logging); strategy.selectReader(Collections.emptyList()); strategy.selectWriter(Collections.emptyList()); - verify(logger).trace(startsWith("Unable to select"), eq("reader")); - verify(logger).trace(startsWith("Unable to select"), eq("writer")); + verify(logger).log(eq(System.Logger.Level.TRACE), startsWith("Unable to select"), eq("reader")); + verify(logger).log(eq(System.Logger.Level.TRACE), startsWith("Unable to select"), eq("writer")); } @Test void shouldTraceLogSelectedAddress() { - var logging = mock(Logging.class); - var logger = mock(Logger.class); + var logging = mock(LoggingProvider.class); + var logger = mock(System.Logger.class); when(logging.getLog(any(Class.class))).thenReturn(logger); - when(connectionPool.inUseConnections(any(BoltServerAddress.class))).thenReturn(42); + when(inUseFunction.apply(any(BoltServerAddress.class))).thenReturn(42); - LoadBalancingStrategy strategy = new LeastConnectedLoadBalancingStrategy(connectionPool, logging); + LoadBalancingStrategy strategy = new LeastConnectedLoadBalancingStrategy(inUseFunction, logging); strategy.selectReader(Collections.singletonList(A)); strategy.selectWriter(Collections.singletonList(A)); - verify(logger).trace(startsWith("Selected"), eq("reader"), eq(A), eq(42)); - verify(logger).trace(startsWith("Selected"), eq("writer"), eq(A), eq(42)); + verify(logger).log(eq(System.Logger.Level.TRACE), startsWith("Selected"), eq("reader"), eq(A), eq(42)); + verify(logger).log(eq(System.Logger.Level.TRACE), startsWith("Selected"), eq("writer"), eq(A), eq(42)); } } diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/LoadBalancerTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/LoadBalancerTest.java new file mode 100644 index 0000000000..9560969a3b --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/LoadBalancerTest.java @@ -0,0 +1,487 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.routedimpl.cluster.loadbalancing; +// +// import static java.util.Arrays.asList; +// import static java.util.Collections.emptySet; +// import static java.util.concurrent.CompletableFuture.completedFuture; +// import static org.hamcrest.MatcherAssert.assertThat; +// import static org.hamcrest.Matchers.containsString; +// import static org.hamcrest.Matchers.equalTo; +// import static org.hamcrest.Matchers.instanceOf; +// import static org.hamcrest.Matchers.startsWith; +// import static org.junit.jupiter.api.Assertions.assertArrayEquals; +// import static org.junit.jupiter.api.Assertions.assertEquals; +// import static org.junit.jupiter.api.Assertions.assertNotNull; +// 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.Mockito.inOrder; +// import static org.mockito.Mockito.mock; +// 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.AccessMode.READ; +// import static org.neo4j.driver.AccessMode.WRITE; +// import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; +// import static org.neo4j.driver.internal.async.ImmutableConnectionContext.simple; +// import static org.neo4j.driver.internal.bolt.routedimpl.cluster.RediscoveryUtil.contextWithDatabase; +// import static org.neo4j.driver.internal.bolt.routedimpl.cluster.RediscoveryUtil.contextWithMode; +// import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; +// import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.A; +// import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.B; +// import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.C; +// import static org.neo4j.driver.internal.bolt.api.util.ClusterCompositionUtil.D; +// import static org.neo4j.driver.internal.util.Futures.completedWithNull; +// import static org.neo4j.driver.testutil.TestUtil.asOrderedSet; +// import static org.neo4j.driver.testutil.TestUtil.await; +// +// import io.netty.util.concurrent.GlobalEventExecutor; +// import java.util.Arrays; +// import java.util.Collections; +// import java.util.LinkedHashSet; +// import java.util.Set; +// import java.util.concurrent.CompletableFuture; +// import java.util.function.Function; +// import java.util.stream.Collectors; +// import java.util.stream.IntStream; +// import org.junit.jupiter.api.Test; +// import org.junit.jupiter.api.function.Executable; +// import org.junit.jupiter.params.ParameterizedTest; +// import org.junit.jupiter.params.provider.EnumSource; +// import org.junit.jupiter.params.provider.ValueSource; +// import org.neo4j.driver.AccessMode; +// import org.neo4j.driver.exceptions.AuthenticationException; +// import org.neo4j.driver.exceptions.SecurityException; +// import org.neo4j.driver.exceptions.ServiceUnavailableException; +// import org.neo4j.driver.exceptions.SessionExpiredException; +// import org.neo4j.driver.internal.BoltServerAddress; +// import org.neo4j.driver.internal.DatabaseName; +// import org.neo4j.driver.internal.DatabaseNameUtil; +// import org.neo4j.driver.internal.async.ConnectionContext; +// import org.neo4j.driver.internal.async.connection.RoutingConnection; +// import org.neo4j.driver.internal.cluster.ClusterComposition; +// import org.neo4j.driver.internal.cluster.ClusterRoutingTable; +// import org.neo4j.driver.internal.cluster.Rediscovery; +// import org.neo4j.driver.internal.cluster.RoutingTable; +// import org.neo4j.driver.internal.cluster.RoutingTableHandler; +// import org.neo4j.driver.internal.cluster.RoutingTableRegistry; +// import org.neo4j.driver.internal.messaging.BoltProtocol; +// import org.neo4j.driver.internal.messaging.v42.BoltProtocolV42; +// import org.neo4j.driver.internal.spi.Connection; +// import org.neo4j.driver.internal.spi.ConnectionPool; +// import org.neo4j.driver.internal.util.FakeClock; +// import org.neo4j.driver.internal.util.Futures; +// +// class LoadBalancerTest { +// @ParameterizedTest +// @EnumSource(AccessMode.class) +// void returnsCorrectAccessMode(AccessMode mode) { +// var connectionPool = newConnectionPoolMock(); +// var routingTable = mock(RoutingTable.class); +// var readerAddresses = Collections.singletonList(A); +// var writerAddresses = Collections.singletonList(B); +// when(routingTable.readers()).thenReturn(readerAddresses); +// when(routingTable.writers()).thenReturn(writerAddresses); +// +// var loadBalancer = newLoadBalancer(connectionPool, routingTable); +// +// var acquired = await(loadBalancer.acquireConnection(contextWithMode(mode))); +// +// assertThat(acquired, instanceOf(RoutingConnection.class)); +// assertThat(acquired.mode(), equalTo(mode)); +// } +// +// @ParameterizedTest +// @ValueSource(strings = {"", "foo", "data"}) +// void returnsCorrectDatabaseName(String databaseName) { +// var connectionPool = newConnectionPoolMock(); +// var routingTable = mock(RoutingTable.class); +// var writerAddresses = Collections.singletonList(A); +// when(routingTable.writers()).thenReturn(writerAddresses); +// +// var loadBalancer = newLoadBalancer(connectionPool, routingTable); +// +// var acquired = await(loadBalancer.acquireConnection(contextWithDatabase(databaseName))); +// +// assertThat(acquired, instanceOf(RoutingConnection.class)); +// assertThat(acquired.databaseName().description(), equalTo(databaseName)); +// verify(connectionPool).acquire(A, null); +// } +// +// @Test +// void shouldThrowWhenRediscoveryReturnsNoSuitableServers() { +// var connectionPool = newConnectionPoolMock(); +// var routingTable = mock(RoutingTable.class); +// when(routingTable.readers()).thenReturn(Collections.emptyList()); +// when(routingTable.writers()).thenReturn(Collections.emptyList()); +// +// var loadBalancer = newLoadBalancer(connectionPool, routingTable); +// +// var error1 = assertThrows( +// SessionExpiredException.class, () -> await(loadBalancer.acquireConnection(contextWithMode(READ)))); +// assertThat(error1.getMessage(), startsWith("Failed to obtain connection towards READ server")); +// +// var error2 = assertThrows( +// SessionExpiredException.class, () -> await(loadBalancer.acquireConnection(contextWithMode(WRITE)))); +// assertThat(error2.getMessage(), startsWith("Failed to obtain connection towards WRITE server")); +// } +// +// @Test +// void shouldSelectLeastConnectedAddress() { +// var connectionPool = newConnectionPoolMock(); +// +// when(connectionPool.inUseConnections(A)).thenReturn(0); +// when(connectionPool.inUseConnections(B)).thenReturn(20); +// when(connectionPool.inUseConnections(C)).thenReturn(0); +// +// var routingTable = mock(RoutingTable.class); +// var readerAddresses = Arrays.asList(A, B, C); +// when(routingTable.readers()).thenReturn(readerAddresses); +// +// var loadBalancer = newLoadBalancer(connectionPool, routingTable); +// +// var seenAddresses = IntStream.range(0, 10) +// .mapToObj(i -> await(loadBalancer.acquireConnection(newBoltV4ConnectionContext()))) +// .map(Connection::serverAddress) +// .collect(Collectors.toSet()); +// +// // server B should never be selected because it has many active connections +// assertEquals(2, seenAddresses.size()); +// assertTrue(seenAddresses.containsAll(asList(A, C))); +// } +// +// @Test +// void shouldRoundRobinWhenNoActiveConnections() { +// var connectionPool = newConnectionPoolMock(); +// +// var routingTable = mock(RoutingTable.class); +// var readerAddresses = Arrays.asList(A, B, C); +// when(routingTable.readers()).thenReturn(readerAddresses); +// +// var loadBalancer = newLoadBalancer(connectionPool, routingTable); +// +// var seenAddresses = IntStream.range(0, 10) +// .mapToObj(i -> await(loadBalancer.acquireConnection(newBoltV4ConnectionContext()))) +// .map(Connection::serverAddress) +// .collect(Collectors.toSet()); +// +// assertEquals(3, seenAddresses.size()); +// assertTrue(seenAddresses.containsAll(asList(A, B, C))); +// } +// +// @Test +// void shouldTryMultipleServersAfterRediscovery() { +// var unavailableAddresses = asOrderedSet(A); +// var connectionPool = newConnectionPoolMockWithFailures(unavailableAddresses); +// +// RoutingTable routingTable = new ClusterRoutingTable(defaultDatabase(), new FakeClock()); +// routingTable.update( +// new ClusterComposition(-1, new LinkedHashSet<>(Arrays.asList(A, B)), emptySet(), emptySet(), null)); +// +// var loadBalancer = newLoadBalancer(connectionPool, routingTable); +// +// var connection = await(loadBalancer.acquireConnection(newBoltV4ConnectionContext())); +// +// assertNotNull(connection); +// assertEquals(B, connection.serverAddress()); +// // routing table should've forgotten A +// assertArrayEquals(new BoltServerAddress[] {B}, routingTable.readers().toArray()); +// } +// +// @Test +// void shouldFailWithResolverError() throws Throwable { +// var pool = mock(ConnectionPool.class); +// var rediscovery = mock(Rediscovery.class); +// when(rediscovery.resolve()).thenThrow(new RuntimeException("hi there")); +// +// var loadBalancer = newLoadBalancer(pool, rediscovery); +// +// var exception = assertThrows(RuntimeException.class, () -> await(loadBalancer.supportsMultiDb())); +// assertThat(exception.getMessage(), equalTo("hi there")); +// } +// +// @Test +// void shouldFailAfterTryingAllServers() throws Throwable { +// var unavailableAddresses = asOrderedSet(A, B); +// var connectionPool = newConnectionPoolMockWithFailures(unavailableAddresses); +// +// var rediscovery = mock(Rediscovery.class); +// when(rediscovery.resolve()).thenReturn(Arrays.asList(A, B)); +// +// var loadBalancer = newLoadBalancer(connectionPool, rediscovery); +// +// var exception = assertThrows(ServiceUnavailableException.class, () -> await(loadBalancer.supportsMultiDb())); +// var suppressed = exception.getSuppressed(); +// assertThat(suppressed.length, equalTo(2)); // one for A, one for B +// assertThat(suppressed[0].getMessage(), containsString(A.toString())); +// assertThat(suppressed[1].getMessage(), containsString(B.toString())); +// verify(connectionPool, times(2)).acquire(any(), any()); +// } +// +// @Test +// void shouldFailEarlyOnSecurityError() throws Throwable { +// var unavailableAddresses = asOrderedSet(A, B); +// var connectionPool = newConnectionPoolMockWithFailures( +// unavailableAddresses, address -> new SecurityException("code", "hi there")); +// +// var rediscovery = mock(Rediscovery.class); +// when(rediscovery.resolve()).thenReturn(Arrays.asList(A, B)); +// +// var loadBalancer = newLoadBalancer(connectionPool, rediscovery); +// +// var exception = assertThrows(SecurityException.class, () -> await(loadBalancer.supportsMultiDb())); +// assertThat(exception.getMessage(), startsWith("hi there")); +// verify(connectionPool, times(1)).acquire(any(), any()); +// } +// +// @Test +// void shouldSuccessOnFirstSuccessfulServer() throws Throwable { +// var unavailableAddresses = asOrderedSet(A, B); +// var connectionPool = newConnectionPoolMockWithFailures(unavailableAddresses); +// +// var rediscovery = mock(Rediscovery.class); +// when(rediscovery.resolve()).thenReturn(Arrays.asList(A, B, C, D)); +// +// var loadBalancer = newLoadBalancer(connectionPool, rediscovery); +// +// assertTrue(await(loadBalancer.supportsMultiDb())); +// verify(connectionPool, times(3)).acquire(any(), any()); +// } +// +// @Test +// void shouldThrowModifiedErrorWhenSupportMultiDbTestFails() throws Throwable { +// var unavailableAddresses = asOrderedSet(A, B); +// var connectionPool = newConnectionPoolMockWithFailures(unavailableAddresses); +// +// var rediscovery = mock(Rediscovery.class); +// when(rediscovery.resolve()).thenReturn(Arrays.asList(A, B)); +// +// var loadBalancer = newLoadBalancer(connectionPool, rediscovery); +// +// var exception = assertThrows(ServiceUnavailableException.class, () -> +// await(loadBalancer.verifyConnectivity())); +// assertThat(exception.getMessage(), startsWith("Unable to connect to database management service,")); +// } +// +// @Test +// void shouldFailEarlyOnSecurityErrorWhenSupportMultiDbTestFails() throws Throwable { +// var unavailableAddresses = asOrderedSet(A, B); +// var connectionPool = newConnectionPoolMockWithFailures( +// unavailableAddresses, address -> new AuthenticationException("code", "error")); +// +// var rediscovery = mock(Rediscovery.class); +// when(rediscovery.resolve()).thenReturn(Arrays.asList(A, B)); +// +// var loadBalancer = newLoadBalancer(connectionPool, rediscovery); +// +// var exception = assertThrows(AuthenticationException.class, () -> await(loadBalancer.verifyConnectivity())); +// assertThat(exception.getMessage(), startsWith("error")); +// } +// +// @Test +// void shouldThrowModifiedErrorWhenRefreshRoutingTableFails() throws Throwable { +// var connectionPool = newConnectionPoolMock(); +// +// var rediscovery = mock(Rediscovery.class); +// when(rediscovery.resolve()).thenReturn(Arrays.asList(A, B)); +// +// var routingTables = mock(RoutingTableRegistry.class); +// when(routingTables.ensureRoutingTable(any(ConnectionContext.class))) +// .thenThrow(new ServiceUnavailableException("boooo")); +// +// var loadBalancer = newLoadBalancer(connectionPool, routingTables, rediscovery); +// +// var exception = assertThrows(ServiceUnavailableException.class, () -> +// await(loadBalancer.verifyConnectivity())); +// assertThat(exception.getMessage(), startsWith("Unable to connect to database management service,")); +// verify(routingTables).ensureRoutingTable(any(ConnectionContext.class)); +// } +// +// @Test +// void shouldThrowOriginalErrorWhenRefreshRoutingTableFails() throws Throwable { +// var connectionPool = newConnectionPoolMock(); +// +// var rediscovery = mock(Rediscovery.class); +// when(rediscovery.resolve()).thenReturn(Arrays.asList(A, B)); +// +// var routingTables = mock(RoutingTableRegistry.class); +// when(routingTables.ensureRoutingTable(any(ConnectionContext.class))).thenThrow(new RuntimeException("boo")); +// +// var loadBalancer = newLoadBalancer(connectionPool, routingTables, rediscovery); +// +// var exception = assertThrows(RuntimeException.class, () -> await(loadBalancer.verifyConnectivity())); +// assertThat(exception.getMessage(), startsWith("boo")); +// verify(routingTables).ensureRoutingTable(any(ConnectionContext.class)); +// } +// +// @Test +// void shouldReturnSuccessVerifyConnectivity() throws Throwable { +// var connectionPool = newConnectionPoolMock(); +// +// var rediscovery = mock(Rediscovery.class); +// when(rediscovery.resolve()).thenReturn(Arrays.asList(A, B)); +// +// var routingTables = mock(RoutingTableRegistry.class); +// when(routingTables.ensureRoutingTable(any(ConnectionContext.class))).thenReturn(Futures.completedWithNull()); +// +// var loadBalancer = newLoadBalancer(connectionPool, routingTables, rediscovery); +// +// await(loadBalancer.verifyConnectivity()); +// verify(routingTables).ensureRoutingTable(any(ConnectionContext.class)); +// } +// +// @ParameterizedTest +// @ValueSource(booleans = {true, false}) +// void expectsCompetedDatabaseNameAfterRoutingTableRegistry(boolean completed) throws Throwable { +// var connectionPool = newConnectionPoolMock(); +// var routingTable = mock(RoutingTable.class); +// var readerAddresses = Collections.singletonList(A); +// var writerAddresses = Collections.singletonList(B); +// when(routingTable.readers()).thenReturn(readerAddresses); +// when(routingTable.writers()).thenReturn(writerAddresses); +// var routingTables = mock(RoutingTableRegistry.class); +// var handler = mock(RoutingTableHandler.class); +// when(handler.routingTable()).thenReturn(routingTable); +// when(routingTables.ensureRoutingTable(any(ConnectionContext.class))) +// .thenReturn(CompletableFuture.completedFuture(handler)); +// var rediscovery = mock(Rediscovery.class); +// var loadBalancer = new LoadBalancer( +// connectionPool, +// routingTables, +// rediscovery, +// new LeastConnectedLoadBalancingStrategy(connectionPool, DEV_NULL_LOGGING), +// GlobalEventExecutor.INSTANCE, +// DEV_NULL_LOGGING); +// var context = mock(ConnectionContext.class); +// CompletableFuture databaseNameFuture = spy(new CompletableFuture<>()); +// if (completed) { +// databaseNameFuture.complete(DatabaseNameUtil.systemDatabase()); +// } +// when(context.databaseNameFuture()).thenReturn(databaseNameFuture); +// when(context.mode()).thenReturn(WRITE); +// +// Executable action = () -> await(loadBalancer.acquireConnection(context)); +// if (completed) { +// action.execute(); +// } else { +// assertThrows( +// IllegalStateException.class, +// action, +// ConnectionContext.PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER +// .get() +// .getMessage()); +// } +// +// var inOrder = inOrder(routingTables, context, databaseNameFuture); +// inOrder.verify(routingTables).ensureRoutingTable(context); +// inOrder.verify(context).databaseNameFuture(); +// inOrder.verify(databaseNameFuture).isDone(); +// if (completed) { +// inOrder.verify(databaseNameFuture).join(); +// } +// } +// +// @Test +// void shouldNotAcceptNullRediscovery() { +// // GIVEN +// var connectionPool = mock(ConnectionPool.class); +// var routingTables = mock(RoutingTableRegistry.class); +// +// // WHEN & THEN +// assertThrows( +// NullPointerException.class, +// () -> new LoadBalancer( +// connectionPool, +// routingTables, +// null, +// new LeastConnectedLoadBalancingStrategy(connectionPool, DEV_NULL_LOGGING), +// GlobalEventExecutor.INSTANCE, +// DEV_NULL_LOGGING)); +// } +// +// private static ConnectionPool newConnectionPoolMock() { +// return newConnectionPoolMockWithFailures(emptySet()); +// } +// +// private static ConnectionPool newConnectionPoolMockWithFailures(Set unavailableAddresses) { +// return newConnectionPoolMockWithFailures( +// unavailableAddresses, address -> new ServiceUnavailableException(address + " is unavailable!")); +// } +// +// private static ConnectionPool newConnectionPoolMockWithFailures( +// Set unavailableAddresses, Function errorAction) { +// var pool = mock(ConnectionPool.class); +// when(pool.acquire(any(BoltServerAddress.class), any())).then(invocation -> { +// BoltServerAddress requestedAddress = invocation.getArgument(0); +// if (unavailableAddresses.contains(requestedAddress)) { +// return Futures.failedFuture(errorAction.apply(requestedAddress)); +// } +// +// return completedFuture(newBoltV4Connection(requestedAddress)); +// }); +// return pool; +// } +// +// private static Connection newBoltV4Connection(BoltServerAddress address) { +// var connection = mock(Connection.class); +// when(connection.serverAddress()).thenReturn(address); +// when(connection.protocol()).thenReturn(BoltProtocol.forVersion(BoltProtocolV42.VERSION)); +// when(connection.release()).thenReturn(completedWithNull()); +// return connection; +// } +// +// private static ConnectionContext newBoltV4ConnectionContext() { +// return simple(true); +// } +// +// private static LoadBalancer newLoadBalancer(ConnectionPool connectionPool, RoutingTable routingTable) { +// // Used only in testing +// var routingTables = mock(RoutingTableRegistry.class); +// var handler = mock(RoutingTableHandler.class); +// when(handler.routingTable()).thenReturn(routingTable); +// when(routingTables.ensureRoutingTable(any(ConnectionContext.class))) +// .thenReturn(CompletableFuture.completedFuture(handler)); +// var rediscovery = mock(Rediscovery.class); +// return new LoadBalancer( +// connectionPool, +// routingTables, +// rediscovery, +// new LeastConnectedLoadBalancingStrategy(connectionPool, DEV_NULL_LOGGING), +// GlobalEventExecutor.INSTANCE, +// DEV_NULL_LOGGING); +// } +// +// private static LoadBalancer newLoadBalancer(ConnectionPool connectionPool, Rediscovery rediscovery) { +// // Used only in testing +// var routingTables = mock(RoutingTableRegistry.class); +// return newLoadBalancer(connectionPool, routingTables, rediscovery); +// } +// +// private static LoadBalancer newLoadBalancer( +// ConnectionPool connectionPool, RoutingTableRegistry routingTables, Rediscovery rediscovery) { +// // Used only in testing +// return new LoadBalancer( +// connectionPool, +// routingTables, +// rediscovery, +// new LeastConnectedLoadBalancingStrategy(connectionPool, DEV_NULL_LOGGING), +// GlobalEventExecutor.INSTANCE, +// DEV_NULL_LOGGING); +// } +// } diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/loadbalancing/RoundRobinArrayIndexTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/RoundRobinArrayIndexTest.java similarity index 96% rename from driver/src/test/java/org/neo4j/driver/internal/cluster/loadbalancing/RoundRobinArrayIndexTest.java rename to driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/RoundRobinArrayIndexTest.java index 60a076e50a..6dbceef1bc 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/loadbalancing/RoundRobinArrayIndexTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/RoundRobinArrayIndexTest.java @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.internal.cluster.loadbalancing; +package org.neo4j.driver.internal.bolt.routedimpl.cluster.loadbalancing; import static org.junit.jupiter.api.Assertions.assertEquals; diff --git a/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/RoutingTableAndConnectionPoolTest.java b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/RoutingTableAndConnectionPoolTest.java new file mode 100644 index 0000000000..0dbabf4e99 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/bolt/routedimpl/cluster/loadbalancing/RoutingTableAndConnectionPoolTest.java @@ -0,0 +1,380 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.bolt.routedimpl.cluster.loadbalancing; +// +// import static org.hamcrest.CoreMatchers.equalTo; +// import static org.hamcrest.MatcherAssert.assertThat; +// import static org.junit.jupiter.api.Assertions.assertFalse; +// import static org.junit.jupiter.api.Assertions.assertNotNull; +// 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.Mockito.mock; +// import static org.mockito.Mockito.when; +// import static org.neo4j.driver.Logging.none; +// import static org.neo4j.driver.internal.DatabaseNameUtil.SYSTEM_DATABASE_NAME; +// import static org.neo4j.driver.internal.DatabaseNameUtil.database; +// import static org.neo4j.driver.internal.bolt.routedimpl.cluster.RediscoveryUtil.contextWithDatabase; +// import static org.neo4j.driver.internal.cluster.RoutingSettings.STALE_ROUTING_TABLE_PURGE_DELAY_MS; +// import static org.neo4j.driver.testutil.TestUtil.await; +// +// import io.netty.util.concurrent.GlobalEventExecutor; +// import java.time.Clock; +// import java.time.Duration; +// import java.util.ArrayList; +// import java.util.Arrays; +// import java.util.Collections; +// import java.util.HashSet; +// import java.util.LinkedList; +// import java.util.List; +// import java.util.Objects; +// import java.util.Random; +// import java.util.Set; +// import java.util.concurrent.CompletableFuture; +// import java.util.concurrent.CompletionStage; +// import java.util.concurrent.ExecutionException; +// import java.util.concurrent.Executors; +// import java.util.concurrent.Future; +// import java.util.concurrent.TimeUnit; +// import java.util.stream.Collectors; +// import java.util.stream.IntStream; +// import org.junit.jupiter.api.Test; +// import org.neo4j.driver.AuthToken; +// import org.neo4j.driver.Bookmark; +// import org.neo4j.driver.Logging; +// import org.neo4j.driver.exceptions.FatalDiscoveryException; +// import org.neo4j.driver.exceptions.ProtocolException; +// import org.neo4j.driver.internal.BoltServerAddress; +// import org.neo4j.driver.internal.DatabaseNameUtil; +// import org.neo4j.driver.internal.async.connection.BootstrapFactory; +// import org.neo4j.driver.internal.async.pool.NettyChannelTracker; +// import org.neo4j.driver.internal.async.pool.PoolSettings; +// import org.neo4j.driver.internal.async.pool.TestConnectionPool; +// import org.neo4j.driver.internal.cluster.ClusterComposition; +// import org.neo4j.driver.internal.cluster.ClusterCompositionLookupResult; +// import org.neo4j.driver.internal.cluster.Rediscovery; +// 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.metrics.DevNullMetricsListener; +// import org.neo4j.driver.internal.metrics.MetricsListener; +// import org.neo4j.driver.internal.spi.Connection; +// import org.neo4j.driver.internal.spi.ConnectionPool; +// import org.neo4j.driver.internal.util.Futures; +// +// class RoutingTableAndConnectionPoolTest { +// private static final BoltServerAddress A = new BoltServerAddress("localhost:30000"); +// private static final BoltServerAddress B = new BoltServerAddress("localhost:30001"); +// private static final BoltServerAddress C = new BoltServerAddress("localhost:30002"); +// private static final BoltServerAddress D = new BoltServerAddress("localhost:30003"); +// private static final BoltServerAddress E = new BoltServerAddress("localhost:30004"); +// private static final BoltServerAddress F = new BoltServerAddress("localhost:30005"); +// private static final List SERVERS = +// Collections.synchronizedList(new LinkedList<>(Arrays.asList(null, A, B, C, D, E, F))); +// +// private static final String[] DATABASES = new String[] {"", SYSTEM_DATABASE_NAME, "my database"}; +// +// private final Random random = new Random(); +// private final Clock clock = Clock.systemUTC(); +// private final Logging logging = none(); +// +// @Test +// void shouldAddServerToRoutingTableAndConnectionPool() { +// // Given +// var connectionPool = newConnectionPool(); +// var rediscovery = mock(Rediscovery.class); +// when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any())) +// .thenReturn(clusterComposition(A)); +// var routingTables = newRoutingTables(connectionPool, rediscovery); +// var loadBalancer = newLoadBalancer(connectionPool, routingTables); +// +// // When +// await(loadBalancer.acquireConnection(contextWithDatabase("neo4j"))); +// +// // Then +// assertThat(routingTables.allServers().size(), equalTo(1)); +// assertTrue(routingTables.allServers().contains(A)); +// assertTrue(routingTables.contains(database("neo4j"))); +// assertTrue(connectionPool.isOpen(A)); +// } +// +// @Test +// void shouldNotAddToRoutingTableWhenFailedWithRoutingError() { +// // Given +// var connectionPool = newConnectionPool(); +// var rediscovery = mock(Rediscovery.class); +// when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any())) +// .thenReturn(Futures.failedFuture(new FatalDiscoveryException("No database found"))); +// var routingTables = newRoutingTables(connectionPool, rediscovery); +// var loadBalancer = newLoadBalancer(connectionPool, routingTables); +// +// // When +// assertThrows( +// FatalDiscoveryException.class, +// () -> await(loadBalancer.acquireConnection(contextWithDatabase("neo4j")))); +// +// // Then +// assertTrue(routingTables.allServers().isEmpty()); +// assertFalse(routingTables.contains(database("neo4j"))); +// assertFalse(connectionPool.isOpen(A)); +// } +// +// @Test +// void shouldNotAddToRoutingTableWhenFailedWithProtocolError() { +// // Given +// var connectionPool = newConnectionPool(); +// var rediscovery = mock(Rediscovery.class); +// when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any())) +// .thenReturn(Futures.failedFuture(new ProtocolException("No database found"))); +// var routingTables = newRoutingTables(connectionPool, rediscovery); +// var loadBalancer = newLoadBalancer(connectionPool, routingTables); +// +// // When +// assertThrows( +// ProtocolException.class, () -> await(loadBalancer.acquireConnection(contextWithDatabase("neo4j")))); +// +// // Then +// assertTrue(routingTables.allServers().isEmpty()); +// assertFalse(routingTables.contains(database("neo4j"))); +// assertFalse(connectionPool.isOpen(A)); +// } +// +// @Test +// void shouldNotAddToRoutingTableWhenFailedWithSecurityError() { +// // Given +// var connectionPool = newConnectionPool(); +// var rediscovery = mock(Rediscovery.class); +// when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any())) +// .thenReturn(Futures.failedFuture(new SecurityException("No database found"))); +// var routingTables = newRoutingTables(connectionPool, rediscovery); +// var loadBalancer = newLoadBalancer(connectionPool, routingTables); +// +// // When +// assertThrows( +// SecurityException.class, () -> await(loadBalancer.acquireConnection(contextWithDatabase("neo4j")))); +// +// // Then +// assertTrue(routingTables.allServers().isEmpty()); +// assertFalse(routingTables.contains(database("neo4j"))); +// assertFalse(connectionPool.isOpen(A)); +// } +// +// @Test +// void shouldNotRemoveNewlyAddedRoutingTableEvenIfItIsExpired() { +// // Given +// var connectionPool = newConnectionPool(); +// var rediscovery = mock(Rediscovery.class); +// when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any())) +// .thenReturn(expiredClusterComposition(A)); +// var routingTables = newRoutingTables(connectionPool, rediscovery); +// var loadBalancer = newLoadBalancer(connectionPool, routingTables); +// +// // When +// var connection = await(loadBalancer.acquireConnection(contextWithDatabase("neo4j"))); +// await(connection.release()); +// +// // Then +// assertTrue(routingTables.contains(database("neo4j"))); +// +// assertThat(routingTables.allServers().size(), equalTo(1)); +// assertTrue(routingTables.allServers().contains(A)); +// +// assertTrue(connectionPool.isOpen(A)); +// } +// +// @Test +// void shouldRemoveExpiredRoutingTableAndServers() { +// // Given +// var connectionPool = newConnectionPool(); +// var rediscovery = mock(Rediscovery.class); +// when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any())) +// .thenReturn(expiredClusterComposition(A)) +// .thenReturn(clusterComposition(B)); +// var routingTables = newRoutingTables(connectionPool, rediscovery); +// var loadBalancer = newLoadBalancer(connectionPool, routingTables); +// +// // When +// var connection = await(loadBalancer.acquireConnection(contextWithDatabase("neo4j"))); +// await(connection.release()); +// await(loadBalancer.acquireConnection(contextWithDatabase("foo"))); +// +// // Then +// assertFalse(routingTables.contains(database("neo4j"))); +// assertTrue(routingTables.contains(database("foo"))); +// +// assertThat(routingTables.allServers().size(), equalTo(1)); +// assertTrue(routingTables.allServers().contains(B)); +// +// assertTrue(connectionPool.isOpen(B)); +// } +// +// @Test +// void shouldRemoveExpiredRoutingTableButNotServer() { +// // Given +// var connectionPool = newConnectionPool(); +// var rediscovery = mock(Rediscovery.class); +// when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any())) +// .thenReturn(expiredClusterComposition(A)) +// .thenReturn(clusterComposition(B)); +// var routingTables = newRoutingTables(connectionPool, rediscovery); +// var loadBalancer = newLoadBalancer(connectionPool, routingTables); +// +// // When +// await(loadBalancer.acquireConnection(contextWithDatabase("neo4j"))); +// await(loadBalancer.acquireConnection(contextWithDatabase("foo"))); +// +// // Then +// assertThat(routingTables.allServers().size(), equalTo(1)); +// assertTrue(routingTables.allServers().contains(B)); +// assertTrue(connectionPool.isOpen(B)); +// assertFalse(routingTables.contains(database("neo4j"))); +// assertTrue(routingTables.contains(database("foo"))); +// +// // I still have A as A's connection is in use +// assertTrue(connectionPool.isOpen(A)); +// } +// +// @Test +// void shouldHandleAddAndRemoveFromRoutingTableAndConnectionPool() throws Throwable { +// // Given +// var connectionPool = newConnectionPool(); +// Rediscovery rediscovery = new RandomizedRediscovery(); +// RoutingTableRegistry routingTables = newRoutingTables(connectionPool, rediscovery); +// var loadBalancer = newLoadBalancer(connectionPool, routingTables); +// +// // When +// acquireAndReleaseConnections(loadBalancer); +// var servers = routingTables.allServers(); +// var openServer = +// servers.stream().filter(connectionPool::isOpen).findFirst().orElse(null); +// assertNotNull(servers); +// +// // if we remove the open server from servers, then the connection pool should remove the server from the pool. +// SERVERS.remove(openServer); +// // ensure rediscovery is necessary on subsequent interaction +// Arrays.stream(DATABASES).map(DatabaseNameUtil::database).forEach(routingTables::remove); +// acquireAndReleaseConnections(loadBalancer); +// +// assertFalse(connectionPool.isOpen(openServer)); +// } +// +// @SuppressWarnings("ResultOfMethodCallIgnored") +// private void acquireAndReleaseConnections(LoadBalancer loadBalancer) throws InterruptedException { +// var executorService = Executors.newFixedThreadPool(4); +// var count = 100; +// var futures = new Future[count]; +// +// for (var i = 0; i < count; i++) { +// var future = executorService.submit(() -> { +// var index = random.nextInt(DATABASES.length); +// var task = loadBalancer +// .acquireConnection(contextWithDatabase(DATABASES[index])) +// .thenCompose(Connection::release); +// await(task); +// }); +// futures[i] = future; +// } +// +// executorService.shutdown(); +// executorService.awaitTermination(10, TimeUnit.SECONDS); +// +// List errors = new ArrayList<>(); +// for (var f : futures) { +// try { +// f.get(); +// } catch (ExecutionException e) { +// errors.add(e.getCause()); +// } +// } +// +// // Then +// assertThat(errors.size(), equalTo(0)); +// } +// +// private ConnectionPool newConnectionPool() { +// MetricsListener metrics = DevNullMetricsListener.INSTANCE; +// var poolSettings = new PoolSettings(10, 5000, -1, -1); +// var bootstrap = BootstrapFactory.newBootstrap(1); +// var channelTracker = +// new NettyChannelTracker(metrics, bootstrap.config().group().next(), logging); +// +// return new TestConnectionPool(bootstrap, channelTracker, poolSettings, metrics, logging, clock, true); +// } +// +// private RoutingTableRegistryImpl newRoutingTables(ConnectionPool connectionPool, Rediscovery rediscovery) { +// return new RoutingTableRegistryImpl( +// connectionPool, rediscovery, clock, logging, STALE_ROUTING_TABLE_PURGE_DELAY_MS); +// } +// +// private LoadBalancer newLoadBalancer(ConnectionPool connectionPool, RoutingTableRegistry routingTables) { +// var rediscovery = mock(Rediscovery.class); +// return new LoadBalancer( +// connectionPool, +// routingTables, +// rediscovery, +// new LeastConnectedLoadBalancingStrategy(connectionPool, logging), +// GlobalEventExecutor.INSTANCE, +// logging); +// } +// +// private CompletableFuture clusterComposition(BoltServerAddress... addresses) { +// return clusterComposition(Duration.ofSeconds(30).toMillis(), addresses); +// } +// +// private CompletableFuture expiredClusterComposition( +// @SuppressWarnings("SameParameterValue") BoltServerAddress... addresses) { +// return clusterComposition(-STALE_ROUTING_TABLE_PURGE_DELAY_MS - 1, addresses); +// } +// +// private CompletableFuture clusterComposition( +// long expireAfterMs, BoltServerAddress... addresses) { +// var servers = new HashSet<>(Arrays.asList(addresses)); +// var composition = new ClusterComposition(clock.millis() + expireAfterMs, servers, servers, servers, null); +// return CompletableFuture.completedFuture(new ClusterCompositionLookupResult(composition)); +// } +// +// private class RandomizedRediscovery implements Rediscovery { +// @Override +// public CompletionStage lookupClusterComposition( +// RoutingTable routingTable, +// ConnectionPool connectionPool, +// Set bookmarks, +// String impersonatedUser, +// AuthToken overrideAuthToken) { +// // when looking up a new routing table, we return a valid random routing table back +// var servers = IntStream.range(0, 3) +// .map(i -> random.nextInt(SERVERS.size())) +// .mapToObj(SERVERS::get) +// .filter(Objects::nonNull) +// .collect(Collectors.toSet()); +// if (servers.isEmpty()) { +// var address = SERVERS.stream() +// .filter(Objects::nonNull) +// .findFirst() +// .orElseThrow(() -> new RuntimeException("No non null server addresses are available")); +// servers.add(address); +// } +// var composition = new ClusterComposition(clock.millis() + 1, servers, servers, servers, null); +// return CompletableFuture.completedFuture(new ClusterCompositionLookupResult(composition)); +// } +// +// @Override +// public List resolve() { +// throw new UnsupportedOperationException("Not implemented"); +// } +// } +// } diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/AbstractRoutingProcedureRunnerTest.java b/driver/src/test/java/org/neo4j/driver/internal/cluster/AbstractRoutingProcedureRunnerTest.java deleted file mode 100644 index 0cd8da8fd1..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/AbstractRoutingProcedureRunnerTest.java +++ /dev/null @@ -1,107 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cluster; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.util.Futures.completedWithNull; -import static org.neo4j.driver.internal.util.Futures.failedFuture; -import static org.neo4j.driver.testutil.TestUtil.await; - -import java.util.Collections; -import java.util.List; -import java.util.concurrent.CompletionStage; -import org.junit.jupiter.api.Test; -import org.neo4j.driver.Record; -import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.BoltProtocolVersion; -import org.neo4j.driver.internal.spi.Connection; - -abstract class AbstractRoutingProcedureRunnerTest { - @Test - void shouldReturnFailedResponseOnClientException() { - var error = new ClientException("Hi"); - var runner = singleDatabaseRoutingProcedureRunner(failedFuture(error)); - - var response = await(runner.run(connection(), defaultDatabase(), Collections.emptySet(), null)); - - assertFalse(response.isSuccess()); - assertEquals(error, response.error()); - } - - @Test - void shouldReturnFailedStageOnError() { - var error = new Exception("Hi"); - var runner = singleDatabaseRoutingProcedureRunner(failedFuture(error)); - - var e = assertThrows( - Exception.class, - () -> await(runner.run(connection(), defaultDatabase(), Collections.emptySet(), null))); - assertEquals(error, e); - } - - @Test - void shouldReleaseConnectionOnSuccess() { - var runner = singleDatabaseRoutingProcedureRunner(); - - var connection = connection(); - var response = await(runner.run(connection, defaultDatabase(), Collections.emptySet(), null)); - - assertTrue(response.isSuccess()); - verify(connection).release(); - } - - @Test - void shouldPropagateReleaseError() { - var runner = singleDatabaseRoutingProcedureRunner(); - - var releaseError = new RuntimeException("Release failed"); - var connection = connection(failedFuture(releaseError)); - - var e = assertThrows( - RuntimeException.class, - () -> await(runner.run(connection, defaultDatabase(), Collections.emptySet(), null))); - assertEquals(releaseError, e); - verify(connection).release(); - } - - abstract SingleDatabaseRoutingProcedureRunner singleDatabaseRoutingProcedureRunner(); - - abstract SingleDatabaseRoutingProcedureRunner singleDatabaseRoutingProcedureRunner( - CompletionStage> runProcedureResult); - - static Connection connection() { - return connection(completedWithNull()); - } - - static Connection connection(CompletionStage releaseStage) { - var connection = mock(Connection.class); - var boltProtocol = mock(BoltProtocol.class); - var protocolVersion = new BoltProtocolVersion(4, 4); - when(boltProtocol.version()).thenReturn(protocolVersion); - when(connection.protocol()).thenReturn(boltProtocol); - when(connection.release()).thenReturn(releaseStage); - return connection; - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/IdentityResolverTest.java b/driver/src/test/java/org/neo4j/driver/internal/cluster/IdentityResolverTest.java index 29d514b73e..fbbf887e61 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/IdentityResolverTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/cluster/IdentityResolverTest.java @@ -20,7 +20,7 @@ import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.is; import static org.mockito.Mockito.mock; -import static org.neo4j.driver.internal.cluster.IdentityResolver.IDENTITY_RESOLVER; +import static org.neo4j.driver.internal.IdentityResolver.IDENTITY_RESOLVER; import org.junit.jupiter.api.Test; import org.neo4j.driver.net.ServerAddress; diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/MultiDatabasesRoutingProcedureRunnerTest.java b/driver/src/test/java/org/neo4j/driver/internal/cluster/MultiDatabasesRoutingProcedureRunnerTest.java deleted file mode 100644 index 616dc352e9..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/MultiDatabasesRoutingProcedureRunnerTest.java +++ /dev/null @@ -1,129 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cluster; - -import static java.util.Collections.singletonList; -import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.equalTo; -import static org.hamcrest.core.IsInstanceOf.instanceOf; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.mockito.Mockito.mock; -import static org.neo4j.driver.Values.parameters; -import static org.neo4j.driver.internal.DatabaseNameUtil.SYSTEM_DATABASE_NAME; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.systemDatabase; -import static org.neo4j.driver.internal.cluster.MultiDatabasesRoutingProcedureRunner.DATABASE_NAME; -import static org.neo4j.driver.internal.cluster.MultiDatabasesRoutingProcedureRunner.MULTI_DB_GET_ROUTING_TABLE; -import static org.neo4j.driver.internal.cluster.SingleDatabaseRoutingProcedureRunner.ROUTING_CONTEXT; -import static org.neo4j.driver.testutil.TestUtil.await; - -import java.net.URI; -import java.util.Collections; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CompletionStage; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.ValueSource; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.Record; -import org.neo4j.driver.internal.spi.Connection; - -class MultiDatabasesRoutingProcedureRunnerTest extends AbstractRoutingProcedureRunnerTest { - @ParameterizedTest - @ValueSource(strings = {"", SYSTEM_DATABASE_NAME, " this is a db name "}) - void shouldCallGetRoutingTableWithEmptyMapOnSystemDatabaseForDatabase(String db) { - var runner = new TestRoutingProcedureRunner(RoutingContext.EMPTY); - var response = await(runner.run(connection(), database(db), Collections.emptySet(), null)); - - assertTrue(response.isSuccess()); - assertEquals(1, response.records().size()); - - assertThat(runner.bookmarks, instanceOf(Set.class)); - assertThat(runner.connection.databaseName(), equalTo(systemDatabase())); - assertThat(runner.connection.mode(), equalTo(AccessMode.READ)); - - var query = generateMultiDatabaseRoutingQuery(Collections.emptyMap(), db); - assertThat(runner.procedure, equalTo(query)); - } - - @ParameterizedTest - @ValueSource(strings = {"", SYSTEM_DATABASE_NAME, " this is a db name "}) - void shouldCallGetRoutingTableWithParamOnSystemDatabaseForDatabase(String db) { - var uri = URI.create("neo4j://localhost/?key1=value1&key2=value2"); - var context = new RoutingContext(uri); - - var runner = new TestRoutingProcedureRunner(context); - var response = await(runner.run(connection(), database(db), Collections.emptySet(), null)); - - assertTrue(response.isSuccess()); - assertEquals(1, response.records().size()); - - assertThat(runner.bookmarks, instanceOf(Set.class)); - assertThat(runner.connection.databaseName(), equalTo(systemDatabase())); - assertThat(runner.connection.mode(), equalTo(AccessMode.READ)); - - var query = generateMultiDatabaseRoutingQuery(context.toMap(), db); - assertThat(response.procedure(), equalTo(query)); - assertThat(runner.procedure, equalTo(query)); - } - - @Override - SingleDatabaseRoutingProcedureRunner singleDatabaseRoutingProcedureRunner() { - return new TestRoutingProcedureRunner(RoutingContext.EMPTY); - } - - @Override - SingleDatabaseRoutingProcedureRunner singleDatabaseRoutingProcedureRunner( - CompletionStage> runProcedureResult) { - return new TestRoutingProcedureRunner(RoutingContext.EMPTY, runProcedureResult); - } - - private static Query generateMultiDatabaseRoutingQuery(Map context, String db) { - var parameters = parameters(ROUTING_CONTEXT, context, DATABASE_NAME, db); - return new Query(MULTI_DB_GET_ROUTING_TABLE, parameters); - } - - private static class TestRoutingProcedureRunner extends MultiDatabasesRoutingProcedureRunner { - final CompletionStage> runProcedureResult; - private Connection connection; - private Query procedure; - private Set bookmarks; - - TestRoutingProcedureRunner(RoutingContext context) { - this(context, completedFuture(singletonList(mock(Record.class)))); - } - - TestRoutingProcedureRunner(RoutingContext context, CompletionStage> runProcedureResult) { - super(context, Logging.none()); - this.runProcedureResult = runProcedureResult; - } - - @Override - CompletionStage> runProcedure(Connection connection, Query procedure, Set bookmarks) { - this.connection = connection; - this.procedure = procedure; - this.bookmarks = bookmarks; - return runProcedureResult; - } - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/RouteMessageRoutingProcedureRunnerTest.java b/driver/src/test/java/org/neo4j/driver/internal/cluster/RouteMessageRoutingProcedureRunnerTest.java deleted file mode 100644 index c84c322b0e..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/RouteMessageRoutingProcedureRunnerTest.java +++ /dev/null @@ -1,150 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cluster; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; - -import java.net.URI; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.concurrent.CompletableFuture; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.Arguments; -import org.junit.jupiter.params.provider.MethodSource; -import org.neo4j.driver.Value; -import org.neo4j.driver.Values; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.DatabaseNameUtil; -import org.neo4j.driver.internal.handlers.RouteMessageResponseHandler; -import org.neo4j.driver.internal.messaging.request.RouteMessage; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.testutil.TestUtil; - -class RouteMessageRoutingProcedureRunnerTest { - - private static Stream shouldRequestRoutingTableForAllValidInputScenarios() { - return Stream.of( - Arguments.arguments(RoutingContext.EMPTY, DatabaseNameUtil.defaultDatabase()), - Arguments.arguments(RoutingContext.EMPTY, DatabaseNameUtil.systemDatabase()), - Arguments.arguments(RoutingContext.EMPTY, DatabaseNameUtil.database("neo4j")), - Arguments.arguments( - new RoutingContext(URI.create("localhost:17601")), DatabaseNameUtil.defaultDatabase()), - Arguments.arguments( - new RoutingContext(URI.create("localhost:17602")), DatabaseNameUtil.systemDatabase()), - Arguments.arguments( - new RoutingContext(URI.create("localhost:17603")), DatabaseNameUtil.database("neo4j"))); - } - - @ParameterizedTest - @MethodSource - void shouldRequestRoutingTableForAllValidInputScenarios(RoutingContext routingContext, DatabaseName databaseName) { - var routingTable = getRoutingTable(); - var completableFuture = CompletableFuture.completedFuture(routingTable); - var runner = new RouteMessageRoutingProcedureRunner(routingContext, () -> completableFuture); - var connection = mock(Connection.class); - CompletableFuture releaseConnectionFuture = CompletableFuture.completedFuture(null); - doReturn(releaseConnectionFuture).when(connection).release(); - - var response = TestUtil.await(runner.run(connection, databaseName, null, null)); - - assertNotNull(response); - assertTrue(response.isSuccess()); - assertNotNull(response.procedure()); - assertEquals(1, response.records().size()); - assertNotNull(response.records().get(0)); - - var record = response.records().get(0); - assertEquals(routingTable.get("ttl"), record.get("ttl")); - assertEquals(routingTable.get("servers"), record.get("servers")); - - verifyMessageWasWrittenAndFlushed(connection, completableFuture, routingContext, databaseName); - verify(connection).release(); - } - - @Test - void shouldReturnFailureWhenSomethingHappensGettingTheRoutingTable() { - Throwable reason = new RuntimeException("Some error"); - var completableFuture = new CompletableFuture>(); - completableFuture.completeExceptionally(reason); - var runner = new RouteMessageRoutingProcedureRunner(RoutingContext.EMPTY, () -> completableFuture); - var connection = mock(Connection.class); - CompletableFuture releaseConnectionFuture = CompletableFuture.completedFuture(null); - doReturn(releaseConnectionFuture).when(connection).release(); - - var response = TestUtil.await(runner.run(connection, DatabaseNameUtil.defaultDatabase(), null, null)); - - assertNotNull(response); - assertFalse(response.isSuccess()); - assertNotNull(response.procedure()); - assertEquals(reason, response.error()); - assertThrows(IllegalStateException.class, () -> response.records().size()); - - verifyMessageWasWrittenAndFlushed( - connection, completableFuture, RoutingContext.EMPTY, DatabaseNameUtil.defaultDatabase()); - verify(connection).release(); - } - - private void verifyMessageWasWrittenAndFlushed( - Connection connection, - CompletableFuture> completableFuture, - RoutingContext routingContext, - DatabaseName databaseName) { - var context = routingContext.toMap().entrySet().stream() - .collect(Collectors.toMap(Map.Entry::getKey, entry -> Values.value(entry.getValue()))); - - verify(connection) - .writeAndFlush( - eq(new RouteMessage( - context, null, databaseName.databaseName().orElse(null), null)), - eq(new RouteMessageResponseHandler(completableFuture))); - } - - private Map getRoutingTable() { - Map routingTable = new HashMap<>(); - routingTable.put("ttl", Values.value(300)); - routingTable.put("servers", Values.value(getServers())); - return routingTable; - } - - private List> getServers() { - List> servers = new ArrayList<>(); - servers.add(getServer("WRITE", "localhost:17601")); - servers.add(getServer("READ", "localhost:17601", "localhost:17602", "localhost:17603")); - servers.add(getServer("ROUTE", "localhost:17601", "localhost:17602", "localhost:17603")); - return servers; - } - - private Map getServer(String role, String... addresses) { - Map server = new HashMap<>(); - server.put("role", Values.value(role)); - server.put("addresses", Values.value(addresses)); - return server; - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProviderTest.java b/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProviderTest.java deleted file mode 100644 index d236384125..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProviderTest.java +++ /dev/null @@ -1,421 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cluster; - -import static java.util.Arrays.asList; -import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsString; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.mock; -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.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.util.Futures.completedWithNull; -import static org.neo4j.driver.internal.util.Futures.failedFuture; -import static org.neo4j.driver.testutil.TestUtil.await; - -import java.time.Clock; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; -import java.util.stream.Collectors; -import org.junit.jupiter.api.Test; -import org.neo4j.driver.Query; -import org.neo4j.driver.Record; -import org.neo4j.driver.Value; -import org.neo4j.driver.exceptions.ProtocolException; -import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.InternalRecord; -import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3; -import org.neo4j.driver.internal.messaging.v4.BoltProtocolV4; -import org.neo4j.driver.internal.messaging.v43.BoltProtocolV43; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.value.StringValue; - -class RoutingProcedureClusterCompositionProviderTest { - @Test - void shouldProtocolErrorWhenNoRecord() { - // Given - var mockedRunner = newProcedureRunnerMock(); - var connection = mock(Connection.class); - ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection); - - var noRecordsResponse = newRoutingResponse(); - when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) - .thenReturn(completedFuture(noRecordsResponse)); - - // When & Then - var error = assertThrows( - ProtocolException.class, - () -> await( - provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); - assertThat(error.getMessage(), containsString("records received '0' is too few or too many.")); - } - - @Test - void shouldProtocolErrorWhenMoreThanOneRecord() { - // Given - var mockedRunner = newProcedureRunnerMock(); - var connection = mock(Connection.class); - ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection); - - Record aRecord = new InternalRecord(asList("key1", "key2"), new Value[] {new StringValue("a value")}); - var routingResponse = newRoutingResponse(aRecord, aRecord); - when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) - .thenReturn(completedFuture(routingResponse)); - - // When - var error = assertThrows( - ProtocolException.class, - () -> await( - provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); - assertThat(error.getMessage(), containsString("records received '2' is too few or too many.")); - } - - @Test - void shouldProtocolErrorWhenUnparsableRecord() { - // Given - var mockedRunner = newProcedureRunnerMock(); - var connection = mock(Connection.class); - ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection); - - Record aRecord = new InternalRecord(asList("key1", "key2"), new Value[] {new StringValue("a value")}); - var routingResponse = newRoutingResponse(aRecord); - when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) - .thenReturn(completedFuture(routingResponse)); - - // When - var error = assertThrows( - ProtocolException.class, - () -> await( - provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); - assertThat(error.getMessage(), containsString("unparsable record received.")); - } - - @Test - void shouldProtocolErrorWhenNoRouters() { - // Given - var mockedRunner = newMultiDBProcedureRunnerMock(); - var connection = mock(Connection.class); - var mockedClock = mock(Clock.class); - ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection, mockedClock); - - Record record = new InternalRecord(asList("ttl", "servers"), new Value[] { - value(100), value(asList(serverInfo("READ", "one:1337", "two:1337"), serverInfo("WRITE", "one:1337"))) - }); - var routingResponse = newRoutingResponse(record); - when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) - .thenReturn(completedFuture(routingResponse)); - when(mockedClock.millis()).thenReturn(12345L); - - // When - var error = assertThrows( - ProtocolException.class, - () -> await( - provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); - assertThat(error.getMessage(), containsString("no router or reader found in response.")); - } - - @Test - void routeMessageRoutingProcedureShouldProtocolErrorWhenNoRouters() { - // Given - var mockedRunner = newRouteMessageRoutingProcedureRunnerMock(); - var connection = mock(Connection.class); - var mockedClock = mock(Clock.class); - ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection, mockedClock); - - Record record = new InternalRecord(asList("ttl", "servers"), new Value[] { - value(100), value(asList(serverInfo("READ", "one:1337", "two:1337"), serverInfo("WRITE", "one:1337"))) - }); - var routingResponse = newRoutingResponse(record); - when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) - .thenReturn(completedFuture(routingResponse)); - when(mockedClock.millis()).thenReturn(12345L); - - // When - var error = assertThrows( - ProtocolException.class, - () -> await( - provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); - assertThat(error.getMessage(), containsString("no router or reader found in response.")); - } - - @Test - void shouldProtocolErrorWhenNoReaders() { - // Given - var mockedRunner = newMultiDBProcedureRunnerMock(); - var connection = mock(Connection.class); - var mockedClock = mock(Clock.class); - ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection, mockedClock); - - Record record = new InternalRecord(asList("ttl", "servers"), new Value[] { - value(100), value(asList(serverInfo("WRITE", "one:1337"), serverInfo("ROUTE", "one:1337", "two:1337"))) - }); - var routingResponse = newRoutingResponse(record); - when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) - .thenReturn(completedFuture(routingResponse)); - when(mockedClock.millis()).thenReturn(12345L); - - // When - var error = assertThrows( - ProtocolException.class, - () -> await( - provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); - assertThat(error.getMessage(), containsString("no router or reader found in response.")); - } - - @Test - void routeMessageRoutingProcedureShouldProtocolErrorWhenNoReaders() { - // Given - var mockedRunner = newRouteMessageRoutingProcedureRunnerMock(); - var connection = mock(Connection.class); - var mockedClock = mock(Clock.class); - ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection, mockedClock); - - Record record = new InternalRecord(asList("ttl", "servers"), new Value[] { - value(100), value(asList(serverInfo("WRITE", "one:1337"), serverInfo("ROUTE", "one:1337", "two:1337"))) - }); - var routingResponse = newRoutingResponse(record); - when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) - .thenReturn(completedFuture(routingResponse)); - when(mockedClock.millis()).thenReturn(12345L); - - // When - var error = assertThrows( - ProtocolException.class, - () -> await( - provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); - assertThat(error.getMessage(), containsString("no router or reader found in response.")); - } - - @Test - void shouldPropagateConnectionFailureExceptions() { - // Given - var mockedRunner = newProcedureRunnerMock(); - var connection = mock(Connection.class); - ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection); - - when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) - .thenReturn(failedFuture(new ServiceUnavailableException("Connection breaks during cypher execution"))); - - // When & Then - var e = assertThrows( - ServiceUnavailableException.class, - () -> await( - provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); - assertThat(e.getMessage(), containsString("Connection breaks during cypher execution")); - } - - @Test - void shouldReturnSuccessResultWhenNoError() { - // Given - var mockedClock = mock(Clock.class); - var connection = mock(Connection.class); - var mockedRunner = newMultiDBProcedureRunnerMock(); - ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection, mockedClock); - - Record record = new InternalRecord(asList("ttl", "servers"), new Value[] { - value(100), - value(asList( - serverInfo("READ", "one:1337", "two:1337"), - serverInfo("WRITE", "one:1337"), - serverInfo("ROUTE", "one:1337", "two:1337"))) - }); - var routingResponse = newRoutingResponse(record); - when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) - .thenReturn(completedFuture(routingResponse)); - when(mockedClock.millis()).thenReturn(12345L); - - // When - var cluster = - await(provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null)); - - // Then - assertEquals(12345 + 100_000, cluster.expirationTimestamp()); - assertEquals(serverSet("one:1337", "two:1337"), cluster.readers()); - assertEquals(serverSet("one:1337"), cluster.writers()); - assertEquals(serverSet("one:1337", "two:1337"), cluster.routers()); - } - - @Test - void routeMessageRoutingProcedureShouldReturnSuccessResultWhenNoError() { - // Given - var mockedClock = mock(Clock.class); - var connection = mock(Connection.class); - var mockedRunner = newRouteMessageRoutingProcedureRunnerMock(); - ClusterCompositionProvider provider = newClusterCompositionProvider(mockedRunner, connection, mockedClock); - - Record record = new InternalRecord(asList("ttl", "servers"), new Value[] { - value(100), - value(asList( - serverInfo("READ", "one:1337", "two:1337"), - serverInfo("WRITE", "one:1337"), - serverInfo("ROUTE", "one:1337", "two:1337"))) - }); - var routingResponse = newRoutingResponse(record); - when(mockedRunner.run(eq(connection), any(DatabaseName.class), any(), any())) - .thenReturn(completedFuture(routingResponse)); - when(mockedClock.millis()).thenReturn(12345L); - - // When - var cluster = - await(provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null)); - - // Then - assertEquals(12345 + 100_000, cluster.expirationTimestamp()); - assertEquals(serverSet("one:1337", "two:1337"), cluster.readers()); - assertEquals(serverSet("one:1337"), cluster.writers()); - assertEquals(serverSet("one:1337", "two:1337"), cluster.routers()); - } - - @Test - void shouldReturnFailureWhenProcedureRunnerFails() { - var procedureRunner = newProcedureRunnerMock(); - var connection = mock(Connection.class); - - var error = new RuntimeException("hi"); - when(procedureRunner.run(eq(connection), any(DatabaseName.class), any(), any())) - .thenReturn(completedFuture(newRoutingResponse(error))); - - var provider = newClusterCompositionProvider(procedureRunner, connection); - - var e = assertThrows( - RuntimeException.class, - () -> await( - provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null))); - assertEquals(error, e); - } - - @Test - void shouldUseMultiDBProcedureRunnerWhenConnectingWith40Server() { - var procedureRunner = newMultiDBProcedureRunnerMock(); - var connection = mock(Connection.class); - - var provider = newClusterCompositionProvider(procedureRunner, connection); - - when(procedureRunner.run(eq(connection), any(DatabaseName.class), any(), any())) - .thenReturn(completedWithNull()); - provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null); - - verify(procedureRunner).run(eq(connection), any(DatabaseName.class), any(), any()); - } - - @Test - void shouldUseProcedureRunnerWhenConnectingWith35AndPreviousServers() { - var procedureRunner = newProcedureRunnerMock(); - var connection = mock(Connection.class); - - var provider = newClusterCompositionProvider(procedureRunner, connection); - - when(procedureRunner.run(eq(connection), any(DatabaseName.class), any(), any())) - .thenReturn(completedWithNull()); - provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null); - - verify(procedureRunner).run(eq(connection), any(DatabaseName.class), any(), any()); - } - - @Test - void shouldUseRouteMessageProcedureRunnerWhenConnectingWithProtocol43() { - var procedureRunner = newRouteMessageRoutingProcedureRunnerMock(); - var connection = mock(Connection.class); - - var provider = newClusterCompositionProvider(procedureRunner, connection); - - when(procedureRunner.run(eq(connection), any(DatabaseName.class), any(), any())) - .thenReturn(completedWithNull()); - provider.getClusterComposition(connection, defaultDatabase(), Collections.emptySet(), null); - - verify(procedureRunner).run(eq(connection), any(DatabaseName.class), any(), any()); - } - - private static Map serverInfo(String role, String... addresses) { - Map map = new HashMap<>(); - map.put("role", role); - map.put("addresses", asList(addresses)); - return map; - } - - private static Set serverSet(String... addresses) { - return Arrays.stream(addresses).map(BoltServerAddress::new).collect(Collectors.toSet()); - } - - private static SingleDatabaseRoutingProcedureRunner newProcedureRunnerMock() { - return mock(SingleDatabaseRoutingProcedureRunner.class); - } - - private static MultiDatabasesRoutingProcedureRunner newMultiDBProcedureRunnerMock() { - return mock(MultiDatabasesRoutingProcedureRunner.class); - } - - private static RouteMessageRoutingProcedureRunner newRouteMessageRoutingProcedureRunnerMock() { - return mock(RouteMessageRoutingProcedureRunner.class); - } - - private static RoutingProcedureResponse newRoutingResponse(Record... records) { - return new RoutingProcedureResponse(new Query("procedure"), asList(records)); - } - - private static RoutingProcedureResponse newRoutingResponse(Throwable error) { - return new RoutingProcedureResponse(new Query("procedure"), error); - } - - private static RoutingProcedureClusterCompositionProvider newClusterCompositionProvider( - SingleDatabaseRoutingProcedureRunner runner, Connection connection) { - when(connection.protocol()).thenReturn(BoltProtocolV3.INSTANCE); - return new RoutingProcedureClusterCompositionProvider( - mock(Clock.class), - runner, - newMultiDBProcedureRunnerMock(), - newRouteMessageRoutingProcedureRunnerMock()); - } - - private static RoutingProcedureClusterCompositionProvider newClusterCompositionProvider( - MultiDatabasesRoutingProcedureRunner runner, Connection connection) { - when(connection.protocol()).thenReturn(BoltProtocolV4.INSTANCE); - return new RoutingProcedureClusterCompositionProvider( - mock(Clock.class), newProcedureRunnerMock(), runner, newRouteMessageRoutingProcedureRunnerMock()); - } - - private static RoutingProcedureClusterCompositionProvider newClusterCompositionProvider( - MultiDatabasesRoutingProcedureRunner runner, Connection connection, Clock clock) { - when(connection.protocol()).thenReturn(BoltProtocolV4.INSTANCE); - return new RoutingProcedureClusterCompositionProvider( - clock, newProcedureRunnerMock(), runner, newRouteMessageRoutingProcedureRunnerMock()); - } - - private static RoutingProcedureClusterCompositionProvider newClusterCompositionProvider( - RouteMessageRoutingProcedureRunner runner, Connection connection) { - - return newClusterCompositionProvider(runner, connection, mock(Clock.class)); - } - - private static RoutingProcedureClusterCompositionProvider newClusterCompositionProvider( - RouteMessageRoutingProcedureRunner runner, Connection connection, Clock clock) { - when(connection.protocol()).thenReturn(BoltProtocolV43.INSTANCE); - return new RoutingProcedureClusterCompositionProvider( - clock, newProcedureRunnerMock(), newMultiDBProcedureRunnerMock(), runner); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureResponseTest.java b/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureResponseTest.java deleted file mode 100644 index 57a8a60144..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingProcedureResponseTest.java +++ /dev/null @@ -1,86 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cluster; - -import static java.util.Arrays.asList; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import org.junit.jupiter.api.Test; -import org.neo4j.driver.Query; -import org.neo4j.driver.Record; -import org.neo4j.driver.Value; -import org.neo4j.driver.internal.InternalRecord; -import org.neo4j.driver.internal.value.StringValue; - -class RoutingProcedureResponseTest { - private static final Query PROCEDURE = new Query("procedure"); - - private static final Record RECORD_1 = - new InternalRecord(asList("a", "b"), new Value[] {new StringValue("a"), new StringValue("b")}); - private static final Record RECORD_2 = - new InternalRecord(asList("a", "b"), new Value[] {new StringValue("aa"), new StringValue("bb")}); - - @Test - void shouldBeSuccessfulWithRecords() { - var response = new RoutingProcedureResponse(PROCEDURE, asList(RECORD_1, RECORD_2)); - assertTrue(response.isSuccess()); - } - - @Test - void shouldNotBeSuccessfulWithError() { - var response = new RoutingProcedureResponse(PROCEDURE, new RuntimeException()); - assertFalse(response.isSuccess()); - } - - @Test - void shouldThrowWhenFailedAndAskedForRecords() { - var error = new RuntimeException(); - var response = new RoutingProcedureResponse(PROCEDURE, error); - - var e = assertThrows(IllegalStateException.class, response::records); - assertEquals(e.getCause(), error); - } - - @Test - void shouldThrowWhenSuccessfulAndAskedForError() { - var response = new RoutingProcedureResponse(PROCEDURE, asList(RECORD_1, RECORD_2)); - - assertThrows(IllegalStateException.class, response::error); - } - - @Test - void shouldHaveErrorWhenFailed() { - var error = new RuntimeException("Hi!"); - var response = new RoutingProcedureResponse(PROCEDURE, error); - assertEquals(error, response.error()); - } - - @Test - void shouldHaveRecordsWhenSuccessful() { - var response = new RoutingProcedureResponse(PROCEDURE, asList(RECORD_1, RECORD_2)); - assertEquals(asList(RECORD_1, RECORD_2), response.records()); - } - - @Test - void shouldHaveProcedure() { - var response = new RoutingProcedureResponse(PROCEDURE, asList(RECORD_1, RECORD_2)); - assertEquals(PROCEDURE, response.procedure()); - } -} 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 deleted file mode 100644 index ee774514fc..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/RoutingTableHandlerTest.java +++ /dev/null @@ -1,306 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cluster; - -import static java.util.Arrays.asList; -import static java.util.Collections.emptySet; -import static java.util.Collections.singletonList; -import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.eq; -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.AccessMode.READ; -import static org.neo4j.driver.AccessMode.WRITE; -import static org.neo4j.driver.internal.BoltServerAddress.LOCAL_DEFAULT; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.async.ImmutableConnectionContext.simple; -import static org.neo4j.driver.internal.cluster.RediscoveryUtil.contextWithMode; -import static org.neo4j.driver.internal.cluster.RoutingSettings.STALE_ROUTING_TABLE_PURGE_DELAY_MS; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.A; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.B; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.C; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.D; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.E; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.F; -import static org.neo4j.driver.testutil.TestUtil.asOrderedSet; -import static org.neo4j.driver.testutil.TestUtil.await; - -import java.util.Collections; -import java.util.HashSet; -import java.util.LinkedHashSet; -import java.util.Optional; -import java.util.Set; -import java.util.concurrent.CompletionStage; -import org.junit.jupiter.api.Test; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.async.ConnectionContext; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ConnectionPool; -import org.neo4j.driver.internal.util.FakeClock; -import org.neo4j.driver.internal.util.Futures; - -class RoutingTableHandlerTest { - @Test - void shouldRemoveAddressFromRoutingTableOnConnectionFailure() { - RoutingTable routingTable = new ClusterRoutingTable(defaultDatabase(), new FakeClock()); - routingTable.update( - new ClusterComposition(42, asOrderedSet(A, B, C), asOrderedSet(A, C, E), asOrderedSet(B, D, F), null)); - - var handler = newRoutingTableHandler(routingTable, newRediscoveryMock(), newConnectionPoolMock()); - - handler.onConnectionFailure(B); - - assertArrayEquals(new BoltServerAddress[] {A, C}, routingTable.readers().toArray()); - assertArrayEquals( - new BoltServerAddress[] {A, C, E}, routingTable.writers().toArray()); - assertArrayEquals(new BoltServerAddress[] {D, F}, routingTable.routers().toArray()); - - handler.onConnectionFailure(A); - - assertArrayEquals(new BoltServerAddress[] {C}, routingTable.readers().toArray()); - assertArrayEquals(new BoltServerAddress[] {C, E}, routingTable.writers().toArray()); - assertArrayEquals(new BoltServerAddress[] {D, F}, routingTable.routers().toArray()); - } - - @Test - void acquireShouldUpdateRoutingTableWhenKnownRoutingTableIsStale() { - var initialRouter = new BoltServerAddress("initialRouter", 1); - var reader1 = new BoltServerAddress("reader-1", 2); - var reader2 = new BoltServerAddress("reader-1", 3); - var writer1 = new BoltServerAddress("writer-1", 4); - var router1 = new BoltServerAddress("router-1", 5); - - var connectionPool = newConnectionPoolMock(); - var routingTable = new ClusterRoutingTable(defaultDatabase(), new FakeClock(), initialRouter); - - Set readers = new LinkedHashSet<>(asList(reader1, reader2)); - Set writers = new LinkedHashSet<>(singletonList(writer1)); - Set routers = new LinkedHashSet<>(singletonList(router1)); - var clusterComposition = new ClusterComposition(42, readers, writers, routers, null); - Rediscovery rediscovery = mock(RediscoveryImpl.class); - when(rediscovery.lookupClusterComposition(eq(routingTable), eq(connectionPool), any(), any(), any())) - .thenReturn(completedFuture(new ClusterCompositionLookupResult(clusterComposition))); - - var handler = newRoutingTableHandler(routingTable, rediscovery, connectionPool); - - assertNotNull(await(handler.ensureRoutingTable(simple(false)))); - - verify(rediscovery).lookupClusterComposition(eq(routingTable), eq(connectionPool), any(), any(), any()); - assertArrayEquals( - new BoltServerAddress[] {reader1, reader2}, - routingTable.readers().toArray()); - assertArrayEquals( - new BoltServerAddress[] {writer1}, routingTable.writers().toArray()); - assertArrayEquals( - new BoltServerAddress[] {router1}, routingTable.routers().toArray()); - } - - @Test - void shouldRediscoverOnReadWhenRoutingTableIsStaleForReads() { - testRediscoveryWhenStale(READ); - } - - @Test - void shouldRediscoverOnWriteWhenRoutingTableIsStaleForWrites() { - testRediscoveryWhenStale(WRITE); - } - - @Test - void shouldNotRediscoverOnReadWhenRoutingTableIsStaleForWritesButNotReads() { - testNoRediscoveryWhenNotStale(WRITE, READ); - } - - @Test - void shouldNotRediscoverOnWriteWhenRoutingTableIsStaleForReadsButNotWrites() { - testNoRediscoveryWhenNotStale(READ, WRITE); - } - - @Test - void shouldRetainAllFetchedAddressesInConnectionPoolAfterFetchingOfRoutingTable() { - RoutingTable routingTable = new ClusterRoutingTable(defaultDatabase(), new FakeClock()); - routingTable.update(new ClusterComposition(42, asOrderedSet(), asOrderedSet(B, C), asOrderedSet(D, E), null)); - - var connectionPool = newConnectionPoolMock(); - - var rediscovery = newRediscoveryMock(); - 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)))); - - var registry = new RoutingTableRegistry() { - @Override - public CompletionStage ensureRoutingTable(ConnectionContext context) { - throw new UnsupportedOperationException(); - } - - @Override - public Set allServers() { - return routingTable.servers(); - } - - @Override - public void remove(DatabaseName databaseName) { - throw new UnsupportedOperationException(); - } - - @Override - public void removeAged() {} - - @Override - public Optional getRoutingTableHandler(DatabaseName databaseName) { - return Optional.empty(); - } - }; - - var handler = newRoutingTableHandler(routingTable, rediscovery, connectionPool, registry); - - var actual = await(handler.ensureRoutingTable(simple(false))); - assertEquals(routingTable, actual); - - verify(connectionPool).retainAll(new HashSet<>(asList(A, B, C))); - } - - @Test - void shouldRemoveRoutingTableHandlerIfFailedToLookup() { - // Given - RoutingTable routingTable = new ClusterRoutingTable(defaultDatabase(), new FakeClock()); - - var rediscovery = newRediscoveryMock(); - when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any())) - .thenReturn(Futures.failedFuture(new RuntimeException("Bang!"))); - - var connectionPool = newConnectionPoolMock(); - var registry = newRoutingTableRegistryMock(); - // When - - var handler = newRoutingTableHandler(routingTable, rediscovery, connectionPool, registry); - assertThrows(RuntimeException.class, () -> await(handler.ensureRoutingTable(simple(false)))); - - // Then - verify(registry).remove(defaultDatabase()); - } - - private void testRediscoveryWhenStale(AccessMode mode) { - var connectionPool = mock(ConnectionPool.class); - when(connectionPool.acquire(LOCAL_DEFAULT, null)).thenReturn(completedFuture(mock(Connection.class))); - - var routingTable = newStaleRoutingTableMock(mode); - var rediscovery = newRediscoveryMock(); - - var handler = newRoutingTableHandler(routingTable, rediscovery, connectionPool); - var actual = await(handler.ensureRoutingTable(contextWithMode(mode))); - assertEquals(routingTable, actual); - - verify(routingTable).isStaleFor(mode); - verify(rediscovery).lookupClusterComposition(eq(routingTable), eq(connectionPool), any(), any(), any()); - } - - private void testNoRediscoveryWhenNotStale(AccessMode staleMode, AccessMode notStaleMode) { - var connectionPool = mock(ConnectionPool.class); - when(connectionPool.acquire(LOCAL_DEFAULT, null)).thenReturn(completedFuture(mock(Connection.class))); - - var routingTable = newStaleRoutingTableMock(staleMode); - var rediscovery = newRediscoveryMock(); - - var handler = newRoutingTableHandler(routingTable, rediscovery, connectionPool); - - assertNotNull(await(handler.ensureRoutingTable(contextWithMode(notStaleMode)))); - verify(routingTable).isStaleFor(notStaleMode); - verify(rediscovery, never()) - .lookupClusterComposition(eq(routingTable), eq(connectionPool), any(), any(), any()); - } - - private static RoutingTable newStaleRoutingTableMock(AccessMode mode) { - var routingTable = mock(RoutingTable.class); - when(routingTable.isStaleFor(mode)).thenReturn(true); - - var addresses = singletonList(LOCAL_DEFAULT); - when(routingTable.readers()).thenReturn(addresses); - when(routingTable.writers()).thenReturn(addresses); - when(routingTable.database()).thenReturn(defaultDatabase()); - - return routingTable; - } - - private static RoutingTableRegistry newRoutingTableRegistryMock() { - return mock(RoutingTableRegistry.class); - } - - private static Rediscovery newRediscoveryMock() { - Rediscovery rediscovery = mock(RediscoveryImpl.class); - Set noServers = Collections.emptySet(); - var clusterComposition = new ClusterComposition(1, noServers, noServers, noServers, null); - when(rediscovery.lookupClusterComposition( - any(RoutingTable.class), any(ConnectionPool.class), any(), any(), any())) - .thenReturn(completedFuture(new ClusterCompositionLookupResult(clusterComposition))); - return rediscovery; - } - - private static ConnectionPool newConnectionPoolMock() { - return newConnectionPoolMockWithFailures(emptySet()); - } - - private static ConnectionPool newConnectionPoolMockWithFailures(Set unavailableAddresses) { - var pool = mock(ConnectionPool.class); - when(pool.acquire(any(BoltServerAddress.class), any())).then(invocation -> { - BoltServerAddress requestedAddress = invocation.getArgument(0); - if (unavailableAddresses.contains(requestedAddress)) { - return Futures.failedFuture(new ServiceUnavailableException(requestedAddress + " is unavailable!")); - } - var connection = mock(Connection.class); - when(connection.serverAddress()).thenReturn(requestedAddress); - return completedFuture(connection); - }); - return pool; - } - - private static RoutingTableHandler newRoutingTableHandler( - RoutingTable routingTable, Rediscovery rediscovery, ConnectionPool connectionPool) { - return new RoutingTableHandlerImpl( - routingTable, - rediscovery, - connectionPool, - newRoutingTableRegistryMock(), - DEV_NULL_LOGGING, - STALE_ROUTING_TABLE_PURGE_DELAY_MS); - } - - private static RoutingTableHandler newRoutingTableHandler( - RoutingTable routingTable, - Rediscovery rediscovery, - ConnectionPool connectionPool, - RoutingTableRegistry routingTableRegistry) { - return new RoutingTableHandlerImpl( - routingTable, - rediscovery, - connectionPool, - routingTableRegistry, - DEV_NULL_LOGGING, - STALE_ROUTING_TABLE_PURGE_DELAY_MS); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/SingleDatabaseRoutingProcedureRunnerTest.java b/driver/src/test/java/org/neo4j/driver/internal/cluster/SingleDatabaseRoutingProcedureRunnerTest.java deleted file mode 100644 index fe1d265d3a..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/SingleDatabaseRoutingProcedureRunnerTest.java +++ /dev/null @@ -1,140 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cluster; - -import static java.util.Collections.singletonList; -import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.equalTo; -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.Mockito.mock; -import static org.neo4j.driver.Values.parameters; -import static org.neo4j.driver.internal.DatabaseNameUtil.SYSTEM_DATABASE_NAME; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.cluster.SingleDatabaseRoutingProcedureRunner.GET_ROUTING_TABLE; -import static org.neo4j.driver.internal.cluster.SingleDatabaseRoutingProcedureRunner.ROUTING_CONTEXT; -import static org.neo4j.driver.testutil.TestUtil.await; - -import java.net.URI; -import java.util.Collections; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CompletionStage; -import java.util.stream.Stream; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.MethodSource; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.Record; -import org.neo4j.driver.exceptions.FatalDiscoveryException; -import org.neo4j.driver.internal.spi.Connection; - -class SingleDatabaseRoutingProcedureRunnerTest extends AbstractRoutingProcedureRunnerTest { - @Test - void shouldCallGetRoutingTableWithEmptyMap() { - var runner = new TestRoutingProcedureRunner(RoutingContext.EMPTY); - var response = await(runner.run(connection(), defaultDatabase(), Collections.emptySet(), null)); - - assertTrue(response.isSuccess()); - assertEquals(1, response.records().size()); - - assertThat(runner.bookmarks, equalTo(Collections.emptySet())); - assertThat(runner.connection.databaseName(), equalTo(defaultDatabase())); - assertThat(runner.connection.mode(), equalTo(AccessMode.WRITE)); - - var query = generateRoutingQuery(Collections.emptyMap()); - assertThat(runner.procedure, equalTo(query)); - } - - @Test - void shouldCallGetRoutingTableWithParam() { - var uri = URI.create("neo4j://localhost/?key1=value1&key2=value2"); - var context = new RoutingContext(uri); - - var runner = new TestRoutingProcedureRunner(context); - var response = await(runner.run(connection(), defaultDatabase(), Collections.emptySet(), null)); - - assertTrue(response.isSuccess()); - assertEquals(1, response.records().size()); - - assertThat(runner.bookmarks, equalTo(Collections.emptySet())); - assertThat(runner.connection.databaseName(), equalTo(defaultDatabase())); - assertThat(runner.connection.mode(), equalTo(AccessMode.WRITE)); - - var query = generateRoutingQuery(context.toMap()); - assertThat(response.procedure(), equalTo(query)); - assertThat(runner.procedure, equalTo(query)); - } - - @ParameterizedTest - @MethodSource("invalidDatabaseNames") - void shouldErrorWhenDatabaseIsNotAbsent(String db) { - var runner = new TestRoutingProcedureRunner(RoutingContext.EMPTY); - assertThrows( - FatalDiscoveryException.class, - () -> await(runner.run(connection(), database(db), Collections.emptySet(), null))); - } - - SingleDatabaseRoutingProcedureRunner singleDatabaseRoutingProcedureRunner() { - return new TestRoutingProcedureRunner(RoutingContext.EMPTY); - } - - SingleDatabaseRoutingProcedureRunner singleDatabaseRoutingProcedureRunner( - CompletionStage> runProcedureResult) { - return new TestRoutingProcedureRunner(RoutingContext.EMPTY, runProcedureResult); - } - - private static Stream invalidDatabaseNames() { - return Stream.of(SYSTEM_DATABASE_NAME, "This is a string", "null"); - } - - private static Query generateRoutingQuery(Map context) { - var parameters = parameters(ROUTING_CONTEXT, context); - return new Query(GET_ROUTING_TABLE, parameters); - } - - private static class TestRoutingProcedureRunner extends SingleDatabaseRoutingProcedureRunner { - final CompletionStage> runProcedureResult; - private Connection connection; - private Query procedure; - private Set bookmarks; - - TestRoutingProcedureRunner(RoutingContext context) { - this(context, completedFuture(singletonList(mock(Record.class)))); - } - - TestRoutingProcedureRunner(RoutingContext context, CompletionStage> runProcedureResult) { - super(context, Logging.none()); - this.runProcedureResult = runProcedureResult; - } - - @Override - CompletionStage> runProcedure(Connection connection, Query procedure, Set bookmarks) { - this.connection = connection; - this.procedure = procedure; - this.bookmarks = bookmarks; - return runProcedureResult; - } - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/loadbalancing/LoadBalancerTest.java b/driver/src/test/java/org/neo4j/driver/internal/cluster/loadbalancing/LoadBalancerTest.java deleted file mode 100644 index ca083946c8..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/loadbalancing/LoadBalancerTest.java +++ /dev/null @@ -1,485 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cluster.loadbalancing; - -import static java.util.Arrays.asList; -import static java.util.Collections.emptySet; -import static java.util.concurrent.CompletableFuture.completedFuture; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsString; -import static org.hamcrest.Matchers.equalTo; -import static org.hamcrest.Matchers.instanceOf; -import static org.hamcrest.Matchers.startsWith; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -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.Mockito.inOrder; -import static org.mockito.Mockito.mock; -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.AccessMode.READ; -import static org.neo4j.driver.AccessMode.WRITE; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.async.ImmutableConnectionContext.simple; -import static org.neo4j.driver.internal.cluster.RediscoveryUtil.contextWithDatabase; -import static org.neo4j.driver.internal.cluster.RediscoveryUtil.contextWithMode; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.A; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.B; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.C; -import static org.neo4j.driver.internal.util.ClusterCompositionUtil.D; -import static org.neo4j.driver.internal.util.Futures.completedWithNull; -import static org.neo4j.driver.testutil.TestUtil.asOrderedSet; -import static org.neo4j.driver.testutil.TestUtil.await; - -import io.netty.util.concurrent.GlobalEventExecutor; -import java.util.Arrays; -import java.util.Collections; -import java.util.LinkedHashSet; -import java.util.Set; -import java.util.concurrent.CompletableFuture; -import java.util.function.Function; -import java.util.stream.Collectors; -import java.util.stream.IntStream; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.function.Executable; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.EnumSource; -import org.junit.jupiter.params.provider.ValueSource; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.exceptions.AuthenticationException; -import org.neo4j.driver.exceptions.SecurityException; -import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.exceptions.SessionExpiredException; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.DatabaseNameUtil; -import org.neo4j.driver.internal.async.ConnectionContext; -import org.neo4j.driver.internal.async.connection.RoutingConnection; -import org.neo4j.driver.internal.cluster.ClusterComposition; -import org.neo4j.driver.internal.cluster.ClusterRoutingTable; -import org.neo4j.driver.internal.cluster.Rediscovery; -import org.neo4j.driver.internal.cluster.RoutingTable; -import org.neo4j.driver.internal.cluster.RoutingTableHandler; -import org.neo4j.driver.internal.cluster.RoutingTableRegistry; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.v42.BoltProtocolV42; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ConnectionPool; -import org.neo4j.driver.internal.util.FakeClock; -import org.neo4j.driver.internal.util.Futures; - -class LoadBalancerTest { - @ParameterizedTest - @EnumSource(AccessMode.class) - void returnsCorrectAccessMode(AccessMode mode) { - var connectionPool = newConnectionPoolMock(); - var routingTable = mock(RoutingTable.class); - var readerAddresses = Collections.singletonList(A); - var writerAddresses = Collections.singletonList(B); - when(routingTable.readers()).thenReturn(readerAddresses); - when(routingTable.writers()).thenReturn(writerAddresses); - - var loadBalancer = newLoadBalancer(connectionPool, routingTable); - - var acquired = await(loadBalancer.acquireConnection(contextWithMode(mode))); - - assertThat(acquired, instanceOf(RoutingConnection.class)); - assertThat(acquired.mode(), equalTo(mode)); - } - - @ParameterizedTest - @ValueSource(strings = {"", "foo", "data"}) - void returnsCorrectDatabaseName(String databaseName) { - var connectionPool = newConnectionPoolMock(); - var routingTable = mock(RoutingTable.class); - var writerAddresses = Collections.singletonList(A); - when(routingTable.writers()).thenReturn(writerAddresses); - - var loadBalancer = newLoadBalancer(connectionPool, routingTable); - - var acquired = await(loadBalancer.acquireConnection(contextWithDatabase(databaseName))); - - assertThat(acquired, instanceOf(RoutingConnection.class)); - assertThat(acquired.databaseName().description(), equalTo(databaseName)); - verify(connectionPool).acquire(A, null); - } - - @Test - void shouldThrowWhenRediscoveryReturnsNoSuitableServers() { - var connectionPool = newConnectionPoolMock(); - var routingTable = mock(RoutingTable.class); - when(routingTable.readers()).thenReturn(Collections.emptyList()); - when(routingTable.writers()).thenReturn(Collections.emptyList()); - - var loadBalancer = newLoadBalancer(connectionPool, routingTable); - - var error1 = assertThrows( - SessionExpiredException.class, () -> await(loadBalancer.acquireConnection(contextWithMode(READ)))); - assertThat(error1.getMessage(), startsWith("Failed to obtain connection towards READ server")); - - var error2 = assertThrows( - SessionExpiredException.class, () -> await(loadBalancer.acquireConnection(contextWithMode(WRITE)))); - assertThat(error2.getMessage(), startsWith("Failed to obtain connection towards WRITE server")); - } - - @Test - void shouldSelectLeastConnectedAddress() { - var connectionPool = newConnectionPoolMock(); - - when(connectionPool.inUseConnections(A)).thenReturn(0); - when(connectionPool.inUseConnections(B)).thenReturn(20); - when(connectionPool.inUseConnections(C)).thenReturn(0); - - var routingTable = mock(RoutingTable.class); - var readerAddresses = Arrays.asList(A, B, C); - when(routingTable.readers()).thenReturn(readerAddresses); - - var loadBalancer = newLoadBalancer(connectionPool, routingTable); - - var seenAddresses = IntStream.range(0, 10) - .mapToObj(i -> await(loadBalancer.acquireConnection(newBoltV4ConnectionContext()))) - .map(Connection::serverAddress) - .collect(Collectors.toSet()); - - // server B should never be selected because it has many active connections - assertEquals(2, seenAddresses.size()); - assertTrue(seenAddresses.containsAll(asList(A, C))); - } - - @Test - void shouldRoundRobinWhenNoActiveConnections() { - var connectionPool = newConnectionPoolMock(); - - var routingTable = mock(RoutingTable.class); - var readerAddresses = Arrays.asList(A, B, C); - when(routingTable.readers()).thenReturn(readerAddresses); - - var loadBalancer = newLoadBalancer(connectionPool, routingTable); - - var seenAddresses = IntStream.range(0, 10) - .mapToObj(i -> await(loadBalancer.acquireConnection(newBoltV4ConnectionContext()))) - .map(Connection::serverAddress) - .collect(Collectors.toSet()); - - assertEquals(3, seenAddresses.size()); - assertTrue(seenAddresses.containsAll(asList(A, B, C))); - } - - @Test - void shouldTryMultipleServersAfterRediscovery() { - var unavailableAddresses = asOrderedSet(A); - var connectionPool = newConnectionPoolMockWithFailures(unavailableAddresses); - - RoutingTable routingTable = new ClusterRoutingTable(defaultDatabase(), new FakeClock()); - routingTable.update( - new ClusterComposition(-1, new LinkedHashSet<>(Arrays.asList(A, B)), emptySet(), emptySet(), null)); - - var loadBalancer = newLoadBalancer(connectionPool, routingTable); - - var connection = await(loadBalancer.acquireConnection(newBoltV4ConnectionContext())); - - assertNotNull(connection); - assertEquals(B, connection.serverAddress()); - // routing table should've forgotten A - assertArrayEquals(new BoltServerAddress[] {B}, routingTable.readers().toArray()); - } - - @Test - void shouldFailWithResolverError() throws Throwable { - var pool = mock(ConnectionPool.class); - var rediscovery = mock(Rediscovery.class); - when(rediscovery.resolve()).thenThrow(new RuntimeException("hi there")); - - var loadBalancer = newLoadBalancer(pool, rediscovery); - - var exception = assertThrows(RuntimeException.class, () -> await(loadBalancer.supportsMultiDb())); - assertThat(exception.getMessage(), equalTo("hi there")); - } - - @Test - void shouldFailAfterTryingAllServers() throws Throwable { - var unavailableAddresses = asOrderedSet(A, B); - var connectionPool = newConnectionPoolMockWithFailures(unavailableAddresses); - - var rediscovery = mock(Rediscovery.class); - when(rediscovery.resolve()).thenReturn(Arrays.asList(A, B)); - - var loadBalancer = newLoadBalancer(connectionPool, rediscovery); - - var exception = assertThrows(ServiceUnavailableException.class, () -> await(loadBalancer.supportsMultiDb())); - var suppressed = exception.getSuppressed(); - assertThat(suppressed.length, equalTo(2)); // one for A, one for B - assertThat(suppressed[0].getMessage(), containsString(A.toString())); - assertThat(suppressed[1].getMessage(), containsString(B.toString())); - verify(connectionPool, times(2)).acquire(any(), any()); - } - - @Test - void shouldFailEarlyOnSecurityError() throws Throwable { - var unavailableAddresses = asOrderedSet(A, B); - var connectionPool = newConnectionPoolMockWithFailures( - unavailableAddresses, address -> new SecurityException("code", "hi there")); - - var rediscovery = mock(Rediscovery.class); - when(rediscovery.resolve()).thenReturn(Arrays.asList(A, B)); - - var loadBalancer = newLoadBalancer(connectionPool, rediscovery); - - var exception = assertThrows(SecurityException.class, () -> await(loadBalancer.supportsMultiDb())); - assertThat(exception.getMessage(), startsWith("hi there")); - verify(connectionPool, times(1)).acquire(any(), any()); - } - - @Test - void shouldSuccessOnFirstSuccessfulServer() throws Throwable { - var unavailableAddresses = asOrderedSet(A, B); - var connectionPool = newConnectionPoolMockWithFailures(unavailableAddresses); - - var rediscovery = mock(Rediscovery.class); - when(rediscovery.resolve()).thenReturn(Arrays.asList(A, B, C, D)); - - var loadBalancer = newLoadBalancer(connectionPool, rediscovery); - - assertTrue(await(loadBalancer.supportsMultiDb())); - verify(connectionPool, times(3)).acquire(any(), any()); - } - - @Test - void shouldThrowModifiedErrorWhenSupportMultiDbTestFails() throws Throwable { - var unavailableAddresses = asOrderedSet(A, B); - var connectionPool = newConnectionPoolMockWithFailures(unavailableAddresses); - - var rediscovery = mock(Rediscovery.class); - when(rediscovery.resolve()).thenReturn(Arrays.asList(A, B)); - - var loadBalancer = newLoadBalancer(connectionPool, rediscovery); - - var exception = assertThrows(ServiceUnavailableException.class, () -> await(loadBalancer.verifyConnectivity())); - assertThat(exception.getMessage(), startsWith("Unable to connect to database management service,")); - } - - @Test - void shouldFailEarlyOnSecurityErrorWhenSupportMultiDbTestFails() throws Throwable { - var unavailableAddresses = asOrderedSet(A, B); - var connectionPool = newConnectionPoolMockWithFailures( - unavailableAddresses, address -> new AuthenticationException("code", "error")); - - var rediscovery = mock(Rediscovery.class); - when(rediscovery.resolve()).thenReturn(Arrays.asList(A, B)); - - var loadBalancer = newLoadBalancer(connectionPool, rediscovery); - - var exception = assertThrows(AuthenticationException.class, () -> await(loadBalancer.verifyConnectivity())); - assertThat(exception.getMessage(), startsWith("error")); - } - - @Test - void shouldThrowModifiedErrorWhenRefreshRoutingTableFails() throws Throwable { - var connectionPool = newConnectionPoolMock(); - - var rediscovery = mock(Rediscovery.class); - when(rediscovery.resolve()).thenReturn(Arrays.asList(A, B)); - - var routingTables = mock(RoutingTableRegistry.class); - when(routingTables.ensureRoutingTable(any(ConnectionContext.class))) - .thenThrow(new ServiceUnavailableException("boooo")); - - var loadBalancer = newLoadBalancer(connectionPool, routingTables, rediscovery); - - var exception = assertThrows(ServiceUnavailableException.class, () -> await(loadBalancer.verifyConnectivity())); - assertThat(exception.getMessage(), startsWith("Unable to connect to database management service,")); - verify(routingTables).ensureRoutingTable(any(ConnectionContext.class)); - } - - @Test - void shouldThrowOriginalErrorWhenRefreshRoutingTableFails() throws Throwable { - var connectionPool = newConnectionPoolMock(); - - var rediscovery = mock(Rediscovery.class); - when(rediscovery.resolve()).thenReturn(Arrays.asList(A, B)); - - var routingTables = mock(RoutingTableRegistry.class); - when(routingTables.ensureRoutingTable(any(ConnectionContext.class))).thenThrow(new RuntimeException("boo")); - - var loadBalancer = newLoadBalancer(connectionPool, routingTables, rediscovery); - - var exception = assertThrows(RuntimeException.class, () -> await(loadBalancer.verifyConnectivity())); - assertThat(exception.getMessage(), startsWith("boo")); - verify(routingTables).ensureRoutingTable(any(ConnectionContext.class)); - } - - @Test - void shouldReturnSuccessVerifyConnectivity() throws Throwable { - var connectionPool = newConnectionPoolMock(); - - var rediscovery = mock(Rediscovery.class); - when(rediscovery.resolve()).thenReturn(Arrays.asList(A, B)); - - var routingTables = mock(RoutingTableRegistry.class); - when(routingTables.ensureRoutingTable(any(ConnectionContext.class))).thenReturn(Futures.completedWithNull()); - - var loadBalancer = newLoadBalancer(connectionPool, routingTables, rediscovery); - - await(loadBalancer.verifyConnectivity()); - verify(routingTables).ensureRoutingTable(any(ConnectionContext.class)); - } - - @ParameterizedTest - @ValueSource(booleans = {true, false}) - void expectsCompetedDatabaseNameAfterRoutingTableRegistry(boolean completed) throws Throwable { - var connectionPool = newConnectionPoolMock(); - var routingTable = mock(RoutingTable.class); - var readerAddresses = Collections.singletonList(A); - var writerAddresses = Collections.singletonList(B); - when(routingTable.readers()).thenReturn(readerAddresses); - when(routingTable.writers()).thenReturn(writerAddresses); - var routingTables = mock(RoutingTableRegistry.class); - var handler = mock(RoutingTableHandler.class); - when(handler.routingTable()).thenReturn(routingTable); - when(routingTables.ensureRoutingTable(any(ConnectionContext.class))) - .thenReturn(CompletableFuture.completedFuture(handler)); - var rediscovery = mock(Rediscovery.class); - var loadBalancer = new LoadBalancer( - connectionPool, - routingTables, - rediscovery, - new LeastConnectedLoadBalancingStrategy(connectionPool, DEV_NULL_LOGGING), - GlobalEventExecutor.INSTANCE, - DEV_NULL_LOGGING); - var context = mock(ConnectionContext.class); - CompletableFuture databaseNameFuture = spy(new CompletableFuture<>()); - if (completed) { - databaseNameFuture.complete(DatabaseNameUtil.systemDatabase()); - } - when(context.databaseNameFuture()).thenReturn(databaseNameFuture); - when(context.mode()).thenReturn(WRITE); - - Executable action = () -> await(loadBalancer.acquireConnection(context)); - if (completed) { - action.execute(); - } else { - assertThrows( - IllegalStateException.class, - action, - ConnectionContext.PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER - .get() - .getMessage()); - } - - var inOrder = inOrder(routingTables, context, databaseNameFuture); - inOrder.verify(routingTables).ensureRoutingTable(context); - inOrder.verify(context).databaseNameFuture(); - inOrder.verify(databaseNameFuture).isDone(); - if (completed) { - inOrder.verify(databaseNameFuture).join(); - } - } - - @Test - void shouldNotAcceptNullRediscovery() { - // GIVEN - var connectionPool = mock(ConnectionPool.class); - var routingTables = mock(RoutingTableRegistry.class); - - // WHEN & THEN - assertThrows( - NullPointerException.class, - () -> new LoadBalancer( - connectionPool, - routingTables, - null, - new LeastConnectedLoadBalancingStrategy(connectionPool, DEV_NULL_LOGGING), - GlobalEventExecutor.INSTANCE, - DEV_NULL_LOGGING)); - } - - private static ConnectionPool newConnectionPoolMock() { - return newConnectionPoolMockWithFailures(emptySet()); - } - - private static ConnectionPool newConnectionPoolMockWithFailures(Set unavailableAddresses) { - return newConnectionPoolMockWithFailures( - unavailableAddresses, address -> new ServiceUnavailableException(address + " is unavailable!")); - } - - private static ConnectionPool newConnectionPoolMockWithFailures( - Set unavailableAddresses, Function errorAction) { - var pool = mock(ConnectionPool.class); - when(pool.acquire(any(BoltServerAddress.class), any())).then(invocation -> { - BoltServerAddress requestedAddress = invocation.getArgument(0); - if (unavailableAddresses.contains(requestedAddress)) { - return Futures.failedFuture(errorAction.apply(requestedAddress)); - } - - return completedFuture(newBoltV4Connection(requestedAddress)); - }); - return pool; - } - - private static Connection newBoltV4Connection(BoltServerAddress address) { - var connection = mock(Connection.class); - when(connection.serverAddress()).thenReturn(address); - when(connection.protocol()).thenReturn(BoltProtocol.forVersion(BoltProtocolV42.VERSION)); - when(connection.release()).thenReturn(completedWithNull()); - return connection; - } - - private static ConnectionContext newBoltV4ConnectionContext() { - return simple(true); - } - - private static LoadBalancer newLoadBalancer(ConnectionPool connectionPool, RoutingTable routingTable) { - // Used only in testing - var routingTables = mock(RoutingTableRegistry.class); - var handler = mock(RoutingTableHandler.class); - when(handler.routingTable()).thenReturn(routingTable); - when(routingTables.ensureRoutingTable(any(ConnectionContext.class))) - .thenReturn(CompletableFuture.completedFuture(handler)); - var rediscovery = mock(Rediscovery.class); - return new LoadBalancer( - connectionPool, - routingTables, - rediscovery, - new LeastConnectedLoadBalancingStrategy(connectionPool, DEV_NULL_LOGGING), - GlobalEventExecutor.INSTANCE, - DEV_NULL_LOGGING); - } - - private static LoadBalancer newLoadBalancer(ConnectionPool connectionPool, Rediscovery rediscovery) { - // Used only in testing - var routingTables = mock(RoutingTableRegistry.class); - return newLoadBalancer(connectionPool, routingTables, rediscovery); - } - - private static LoadBalancer newLoadBalancer( - ConnectionPool connectionPool, RoutingTableRegistry routingTables, Rediscovery rediscovery) { - // Used only in testing - return new LoadBalancer( - connectionPool, - routingTables, - rediscovery, - new LeastConnectedLoadBalancingStrategy(connectionPool, DEV_NULL_LOGGING), - GlobalEventExecutor.INSTANCE, - DEV_NULL_LOGGING); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/cluster/loadbalancing/RoutingTableAndConnectionPoolTest.java b/driver/src/test/java/org/neo4j/driver/internal/cluster/loadbalancing/RoutingTableAndConnectionPoolTest.java deleted file mode 100644 index 98c588123e..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/cluster/loadbalancing/RoutingTableAndConnectionPoolTest.java +++ /dev/null @@ -1,380 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cluster.loadbalancing; - -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -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.Mockito.mock; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.Logging.none; -import static org.neo4j.driver.internal.DatabaseNameUtil.SYSTEM_DATABASE_NAME; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.cluster.RediscoveryUtil.contextWithDatabase; -import static org.neo4j.driver.internal.cluster.RoutingSettings.STALE_ROUTING_TABLE_PURGE_DELAY_MS; -import static org.neo4j.driver.testutil.TestUtil.await; - -import io.netty.util.concurrent.GlobalEventExecutor; -import java.time.Clock; -import java.time.Duration; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashSet; -import java.util.LinkedList; -import java.util.List; -import java.util.Objects; -import java.util.Random; -import java.util.Set; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionStage; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.Executors; -import java.util.concurrent.Future; -import java.util.concurrent.TimeUnit; -import java.util.stream.Collectors; -import java.util.stream.IntStream; -import org.junit.jupiter.api.Test; -import org.neo4j.driver.AuthToken; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.exceptions.FatalDiscoveryException; -import org.neo4j.driver.exceptions.ProtocolException; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DatabaseNameUtil; -import org.neo4j.driver.internal.async.connection.BootstrapFactory; -import org.neo4j.driver.internal.async.pool.NettyChannelTracker; -import org.neo4j.driver.internal.async.pool.PoolSettings; -import org.neo4j.driver.internal.async.pool.TestConnectionPool; -import org.neo4j.driver.internal.cluster.ClusterComposition; -import org.neo4j.driver.internal.cluster.ClusterCompositionLookupResult; -import org.neo4j.driver.internal.cluster.Rediscovery; -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.metrics.DevNullMetricsListener; -import org.neo4j.driver.internal.metrics.MetricsListener; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ConnectionPool; -import org.neo4j.driver.internal.util.Futures; - -class RoutingTableAndConnectionPoolTest { - private static final BoltServerAddress A = new BoltServerAddress("localhost:30000"); - private static final BoltServerAddress B = new BoltServerAddress("localhost:30001"); - private static final BoltServerAddress C = new BoltServerAddress("localhost:30002"); - private static final BoltServerAddress D = new BoltServerAddress("localhost:30003"); - private static final BoltServerAddress E = new BoltServerAddress("localhost:30004"); - private static final BoltServerAddress F = new BoltServerAddress("localhost:30005"); - private static final List SERVERS = - Collections.synchronizedList(new LinkedList<>(Arrays.asList(null, A, B, C, D, E, F))); - - private static final String[] DATABASES = new String[] {"", SYSTEM_DATABASE_NAME, "my database"}; - - private final Random random = new Random(); - private final Clock clock = Clock.systemUTC(); - private final Logging logging = none(); - - @Test - void shouldAddServerToRoutingTableAndConnectionPool() { - // Given - var connectionPool = newConnectionPool(); - var rediscovery = mock(Rediscovery.class); - when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any())) - .thenReturn(clusterComposition(A)); - var routingTables = newRoutingTables(connectionPool, rediscovery); - var loadBalancer = newLoadBalancer(connectionPool, routingTables); - - // When - await(loadBalancer.acquireConnection(contextWithDatabase("neo4j"))); - - // Then - assertThat(routingTables.allServers().size(), equalTo(1)); - assertTrue(routingTables.allServers().contains(A)); - assertTrue(routingTables.contains(database("neo4j"))); - assertTrue(connectionPool.isOpen(A)); - } - - @Test - void shouldNotAddToRoutingTableWhenFailedWithRoutingError() { - // Given - var connectionPool = newConnectionPool(); - var rediscovery = mock(Rediscovery.class); - when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any())) - .thenReturn(Futures.failedFuture(new FatalDiscoveryException("No database found"))); - var routingTables = newRoutingTables(connectionPool, rediscovery); - var loadBalancer = newLoadBalancer(connectionPool, routingTables); - - // When - assertThrows( - FatalDiscoveryException.class, - () -> await(loadBalancer.acquireConnection(contextWithDatabase("neo4j")))); - - // Then - assertTrue(routingTables.allServers().isEmpty()); - assertFalse(routingTables.contains(database("neo4j"))); - assertFalse(connectionPool.isOpen(A)); - } - - @Test - void shouldNotAddToRoutingTableWhenFailedWithProtocolError() { - // Given - var connectionPool = newConnectionPool(); - var rediscovery = mock(Rediscovery.class); - when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any())) - .thenReturn(Futures.failedFuture(new ProtocolException("No database found"))); - var routingTables = newRoutingTables(connectionPool, rediscovery); - var loadBalancer = newLoadBalancer(connectionPool, routingTables); - - // When - assertThrows( - ProtocolException.class, () -> await(loadBalancer.acquireConnection(contextWithDatabase("neo4j")))); - - // Then - assertTrue(routingTables.allServers().isEmpty()); - assertFalse(routingTables.contains(database("neo4j"))); - assertFalse(connectionPool.isOpen(A)); - } - - @Test - void shouldNotAddToRoutingTableWhenFailedWithSecurityError() { - // Given - var connectionPool = newConnectionPool(); - var rediscovery = mock(Rediscovery.class); - when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any())) - .thenReturn(Futures.failedFuture(new SecurityException("No database found"))); - var routingTables = newRoutingTables(connectionPool, rediscovery); - var loadBalancer = newLoadBalancer(connectionPool, routingTables); - - // When - assertThrows( - SecurityException.class, () -> await(loadBalancer.acquireConnection(contextWithDatabase("neo4j")))); - - // Then - assertTrue(routingTables.allServers().isEmpty()); - assertFalse(routingTables.contains(database("neo4j"))); - assertFalse(connectionPool.isOpen(A)); - } - - @Test - void shouldNotRemoveNewlyAddedRoutingTableEvenIfItIsExpired() { - // Given - var connectionPool = newConnectionPool(); - var rediscovery = mock(Rediscovery.class); - when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any())) - .thenReturn(expiredClusterComposition(A)); - var routingTables = newRoutingTables(connectionPool, rediscovery); - var loadBalancer = newLoadBalancer(connectionPool, routingTables); - - // When - var connection = await(loadBalancer.acquireConnection(contextWithDatabase("neo4j"))); - await(connection.release()); - - // Then - assertTrue(routingTables.contains(database("neo4j"))); - - assertThat(routingTables.allServers().size(), equalTo(1)); - assertTrue(routingTables.allServers().contains(A)); - - assertTrue(connectionPool.isOpen(A)); - } - - @Test - void shouldRemoveExpiredRoutingTableAndServers() { - // Given - var connectionPool = newConnectionPool(); - var rediscovery = mock(Rediscovery.class); - when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any())) - .thenReturn(expiredClusterComposition(A)) - .thenReturn(clusterComposition(B)); - var routingTables = newRoutingTables(connectionPool, rediscovery); - var loadBalancer = newLoadBalancer(connectionPool, routingTables); - - // When - var connection = await(loadBalancer.acquireConnection(contextWithDatabase("neo4j"))); - await(connection.release()); - await(loadBalancer.acquireConnection(contextWithDatabase("foo"))); - - // Then - assertFalse(routingTables.contains(database("neo4j"))); - assertTrue(routingTables.contains(database("foo"))); - - assertThat(routingTables.allServers().size(), equalTo(1)); - assertTrue(routingTables.allServers().contains(B)); - - assertTrue(connectionPool.isOpen(B)); - } - - @Test - void shouldRemoveExpiredRoutingTableButNotServer() { - // Given - var connectionPool = newConnectionPool(); - var rediscovery = mock(Rediscovery.class); - when(rediscovery.lookupClusterComposition(any(), any(), any(), any(), any())) - .thenReturn(expiredClusterComposition(A)) - .thenReturn(clusterComposition(B)); - var routingTables = newRoutingTables(connectionPool, rediscovery); - var loadBalancer = newLoadBalancer(connectionPool, routingTables); - - // When - await(loadBalancer.acquireConnection(contextWithDatabase("neo4j"))); - await(loadBalancer.acquireConnection(contextWithDatabase("foo"))); - - // Then - assertThat(routingTables.allServers().size(), equalTo(1)); - assertTrue(routingTables.allServers().contains(B)); - assertTrue(connectionPool.isOpen(B)); - assertFalse(routingTables.contains(database("neo4j"))); - assertTrue(routingTables.contains(database("foo"))); - - // I still have A as A's connection is in use - assertTrue(connectionPool.isOpen(A)); - } - - @Test - void shouldHandleAddAndRemoveFromRoutingTableAndConnectionPool() throws Throwable { - // Given - var connectionPool = newConnectionPool(); - Rediscovery rediscovery = new RandomizedRediscovery(); - RoutingTableRegistry routingTables = newRoutingTables(connectionPool, rediscovery); - var loadBalancer = newLoadBalancer(connectionPool, routingTables); - - // When - acquireAndReleaseConnections(loadBalancer); - var servers = routingTables.allServers(); - var openServer = - servers.stream().filter(connectionPool::isOpen).findFirst().orElse(null); - assertNotNull(servers); - - // if we remove the open server from servers, then the connection pool should remove the server from the pool. - SERVERS.remove(openServer); - // ensure rediscovery is necessary on subsequent interaction - Arrays.stream(DATABASES).map(DatabaseNameUtil::database).forEach(routingTables::remove); - acquireAndReleaseConnections(loadBalancer); - - assertFalse(connectionPool.isOpen(openServer)); - } - - @SuppressWarnings("ResultOfMethodCallIgnored") - private void acquireAndReleaseConnections(LoadBalancer loadBalancer) throws InterruptedException { - var executorService = Executors.newFixedThreadPool(4); - var count = 100; - var futures = new Future[count]; - - for (var i = 0; i < count; i++) { - var future = executorService.submit(() -> { - var index = random.nextInt(DATABASES.length); - var task = loadBalancer - .acquireConnection(contextWithDatabase(DATABASES[index])) - .thenCompose(Connection::release); - await(task); - }); - futures[i] = future; - } - - executorService.shutdown(); - executorService.awaitTermination(10, TimeUnit.SECONDS); - - List errors = new ArrayList<>(); - for (var f : futures) { - try { - f.get(); - } catch (ExecutionException e) { - errors.add(e.getCause()); - } - } - - // Then - assertThat(errors.size(), equalTo(0)); - } - - private ConnectionPool newConnectionPool() { - MetricsListener metrics = DevNullMetricsListener.INSTANCE; - var poolSettings = new PoolSettings(10, 5000, -1, -1); - var bootstrap = BootstrapFactory.newBootstrap(1); - var channelTracker = - new NettyChannelTracker(metrics, bootstrap.config().group().next(), logging); - - return new TestConnectionPool(bootstrap, channelTracker, poolSettings, metrics, logging, clock, true); - } - - private RoutingTableRegistryImpl newRoutingTables(ConnectionPool connectionPool, Rediscovery rediscovery) { - return new RoutingTableRegistryImpl( - connectionPool, rediscovery, clock, logging, STALE_ROUTING_TABLE_PURGE_DELAY_MS); - } - - private LoadBalancer newLoadBalancer(ConnectionPool connectionPool, RoutingTableRegistry routingTables) { - var rediscovery = mock(Rediscovery.class); - return new LoadBalancer( - connectionPool, - routingTables, - rediscovery, - new LeastConnectedLoadBalancingStrategy(connectionPool, logging), - GlobalEventExecutor.INSTANCE, - logging); - } - - private CompletableFuture clusterComposition(BoltServerAddress... addresses) { - return clusterComposition(Duration.ofSeconds(30).toMillis(), addresses); - } - - private CompletableFuture expiredClusterComposition( - @SuppressWarnings("SameParameterValue") BoltServerAddress... addresses) { - return clusterComposition(-STALE_ROUTING_TABLE_PURGE_DELAY_MS - 1, addresses); - } - - private CompletableFuture clusterComposition( - long expireAfterMs, BoltServerAddress... addresses) { - var servers = new HashSet<>(Arrays.asList(addresses)); - var composition = new ClusterComposition(clock.millis() + expireAfterMs, servers, servers, servers, null); - return CompletableFuture.completedFuture(new ClusterCompositionLookupResult(composition)); - } - - private class RandomizedRediscovery implements Rediscovery { - @Override - public CompletionStage lookupClusterComposition( - RoutingTable routingTable, - ConnectionPool connectionPool, - Set bookmarks, - String impersonatedUser, - AuthToken overrideAuthToken) { - // when looking up a new routing table, we return a valid random routing table back - var servers = IntStream.range(0, 3) - .map(i -> random.nextInt(SERVERS.size())) - .mapToObj(SERVERS::get) - .filter(Objects::nonNull) - .collect(Collectors.toSet()); - if (servers.isEmpty()) { - var address = SERVERS.stream() - .filter(Objects::nonNull) - .findFirst() - .orElseThrow(() -> new RuntimeException("No non null server addresses are available")); - servers.add(address); - } - var composition = new ClusterComposition(clock.millis() + 1, servers, servers, servers, null); - return CompletableFuture.completedFuture(new ClusterCompositionLookupResult(composition)); - } - - @Override - public List resolve() { - throw new UnsupportedOperationException("Not implemented"); - } - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/cursor/AsyncResultCursorOnlyFactoryTest.java b/driver/src/test/java/org/neo4j/driver/internal/cursor/AsyncResultCursorOnlyFactoryTest.java deleted file mode 100644 index 3bb789fdcf..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/cursor/AsyncResultCursorOnlyFactoryTest.java +++ /dev/null @@ -1,130 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cursor; - -import static org.hamcrest.CoreMatchers.containsString; -import static org.hamcrest.CoreMatchers.instanceOf; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.neo4j.driver.internal.util.Futures.getNow; -import static org.neo4j.driver.testutil.TestUtil.await; - -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionException; -import java.util.concurrent.CompletionStage; -import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.handlers.pulln.AutoPullResponseHandler; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.spi.Connection; - -class AsyncResultCursorOnlyFactoryTest { - // asyncResult - @Test - void shouldReturnAsyncResultWhenRunSucceeded() { - // Given - var connection = mock(Connection.class); - ResultCursorFactory cursorFactory = newResultCursorFactory(connection, null); - - // When - var cursorFuture = cursorFactory.asyncResult(); - - // Then - verifyRunCompleted(connection, cursorFuture); - } - - @Test - void shouldReturnAsyncResultWithRunErrorWhenRunFailed() { - // Given - Throwable error = new RuntimeException("Hi there"); - ResultCursorFactory cursorFactory = newResultCursorFactory(error); - - // When - var cursorFuture = cursorFactory.asyncResult(); - - // Then - var cursor = getNow(cursorFuture); - var actual = assertThrows(error.getClass(), () -> await(cursor.mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - - @Test - void shouldPrePopulateRecords() { - // Given - var connection = mock(Connection.class); - var runMessage = mock(Message.class); - - var runHandler = mock(RunResponseHandler.class); - var runFuture = new CompletableFuture(); - - var pullAllHandler = mock(PullAllResponseHandler.class); - - ResultCursorFactory cursorFactory = - new AsyncResultCursorOnlyFactory(connection, runMessage, runHandler, runFuture, pullAllHandler); - - // When - cursorFactory.asyncResult(); - - // Then - verify(pullAllHandler).prePopulateRecords(); - } - - // rxResult - @Test - void shouldErrorForRxResult() { - // Given - ResultCursorFactory cursorFactory = newResultCursorFactory(null); - - // When & Then - var rxCursorFuture = cursorFactory.rxResult(); - var error = assertThrows(CompletionException.class, () -> getNow(rxCursorFuture)); - assertThat( - error.getCause().getMessage(), - containsString("Driver is connected to the database that does not support driver reactive API")); - } - - private AsyncResultCursorOnlyFactory newResultCursorFactory(Connection connection, Throwable runError) { - var runMessage = mock(Message.class); - - var runHandler = mock(RunResponseHandler.class); - var runFuture = new CompletableFuture(); - if (runError != null) { - runFuture.completeExceptionally(runError); - } else { - runFuture.complete(null); - } - - var pullHandler = mock(AutoPullResponseHandler.class); - - return new AsyncResultCursorOnlyFactory(connection, runMessage, runHandler, runFuture, pullHandler); - } - - private AsyncResultCursorOnlyFactory newResultCursorFactory(Throwable runError) { - var connection = mock(Connection.class); - return newResultCursorFactory(connection, runError); - } - - private void verifyRunCompleted(Connection connection, CompletionStage cursorFuture) { - verify(connection).write(any(Message.class), any(RunResponseHandler.class)); - assertThat(getNow(cursorFuture), instanceOf(AsyncResultCursor.class)); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/cursor/DisposableAsyncResultCursorTest.java b/driver/src/test/java/org/neo4j/driver/internal/cursor/DisposableAsyncResultCursorTest.java deleted file mode 100644 index 7b28be42a2..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/cursor/DisposableAsyncResultCursorTest.java +++ /dev/null @@ -1,147 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cursor; - -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertSame; -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.when; -import static org.neo4j.driver.testutil.TestUtil.await; - -import java.util.concurrent.CompletableFuture; -import java.util.function.Function; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.util.Futures; - -class DisposableAsyncResultCursorTest { - DisposableAsyncResultCursor cursor; - - AsyncResultCursor delegate; - - @BeforeEach - void beforeEach() { - delegate = mock(AsyncResultCursor.class); - - when(delegate.consumeAsync()).thenReturn(Futures.completedWithNull()); - when(delegate.discardAllFailureAsync()).thenReturn(Futures.completedWithNull()); - when(delegate.peekAsync()).thenReturn(Futures.completedWithNull()); - when(delegate.nextAsync()).thenReturn(Futures.completedWithNull()); - when(delegate.singleAsync()).thenReturn(Futures.completedWithNull()); - when(delegate.forEachAsync(any())).thenReturn(Futures.completedWithNull()); - when(delegate.listAsync()).thenReturn(Futures.completedWithNull()); - when(delegate.listAsync(any())).thenReturn(Futures.completedWithNull()); - when(delegate.pullAllFailureAsync()).thenReturn(Futures.completedWithNull()); - when(delegate.mapSuccessfulRunCompletionAsync()).thenReturn(CompletableFuture.completedFuture(delegate)); - - cursor = new DisposableAsyncResultCursor(delegate); - } - - @Test - void summaryShouldDisposeCursor() { - // When - await(cursor.consumeAsync()); - - // Then - assertTrue(cursor.isDisposed()); - } - - @Test - void consumeShouldDisposeCursor() { - // When - await(cursor.discardAllFailureAsync()); - - // Then - assertTrue(cursor.isDisposed()); - } - - @Test - void shouldNotDisposeCursor() { - // When - cursor.keys(); - await(cursor.peekAsync()); - await(cursor.nextAsync()); - await(cursor.singleAsync()); - await(cursor.forEachAsync(record -> {})); - await(cursor.listAsync()); - await(cursor.listAsync(Function.identity())); - await(cursor.pullAllFailureAsync()); - - // Then - assertFalse(cursor.isDisposed()); - } - - @Test - void shouldReturnItselfOnMapSuccessfulRunCompletionAsync() { - // When - var actual = await(cursor.mapSuccessfulRunCompletionAsync()); - - // Then - then(delegate).should().mapSuccessfulRunCompletionAsync(); - assertSame(cursor, actual); - } - - @Test - void shouldFailOnMapSuccessfulRunCompletionAsyncFailure() { - // Given - var error = mock(Throwable.class); - given(delegate.mapSuccessfulRunCompletionAsync()).willReturn(Futures.failedFuture(error)); - - // When - var actual = assertThrows(Throwable.class, () -> await(cursor.mapSuccessfulRunCompletionAsync())); - - // Then - then(delegate).should().mapSuccessfulRunCompletionAsync(); - assertSame(error, actual); - } - - @Test - void shouldBeOpenOnCreation() { - assertTrue(await(cursor.isOpenAsync())); - } - - @Test - void shouldCloseOnConsume() { - // Given - boolean initialState = await(cursor.isOpenAsync()); - - // When - await(cursor.consumeAsync()); - - // Then - assertTrue(initialState); - assertFalse(await(cursor.isOpenAsync())); - } - - @Test - void shouldCloseOnDiscardAll() { - // Given - boolean initialState = await(cursor.isOpenAsync()); - - // When - await(cursor.discardAllFailureAsync()); - - // Then - assertTrue(initialState); - assertFalse(await(cursor.isOpenAsync())); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/cursor/ResultCursorFactoryImplTest.java b/driver/src/test/java/org/neo4j/driver/internal/cursor/ResultCursorFactoryImplTest.java deleted file mode 100644 index 597c38ee07..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/cursor/ResultCursorFactoryImplTest.java +++ /dev/null @@ -1,151 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cursor; - -import static org.hamcrest.CoreMatchers.instanceOf; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoMoreInteractions; -import static org.neo4j.driver.internal.util.Futures.getNow; -import static org.neo4j.driver.testutil.TestUtil.await; - -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionStage; -import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.handlers.pulln.PullResponseHandler; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.spi.Connection; - -class ResultCursorFactoryImplTest { - // asyncResult - @Test - void shouldReturnAsyncResultWhenRunSucceeded() { - // Given - var connection = mock(Connection.class); - ResultCursorFactory cursorFactory = newResultCursorFactory(connection, null); - - // When - var cursorFuture = cursorFactory.asyncResult(); - - // Then - verifyRunCompleted(connection, cursorFuture); - } - - @Test - void shouldReturnAsyncResultWithRunErrorWhenRunFailed() { - // Given - Throwable error = new RuntimeException("Hi there"); - ResultCursorFactory cursorFactory = newResultCursorFactory(error); - - // When - var cursorFuture = cursorFactory.asyncResult(); - - // Then - var cursor = getNow(cursorFuture); - var actual = assertThrows(error.getClass(), () -> await(cursor.mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - - @Test - void shouldPrePopulateRecords() { - // Given - var connection = mock(Connection.class); - var runMessage = mock(Message.class); - - var runHandler = mock(RunResponseHandler.class); - var runFuture = new CompletableFuture(); - - var pullHandler = mock(PullResponseHandler.class); - var pullAllHandler = mock(PullAllResponseHandler.class); - - ResultCursorFactory cursorFactory = - new ResultCursorFactoryImpl(connection, runMessage, runHandler, runFuture, pullHandler, pullAllHandler); - - // When - cursorFactory.asyncResult(); - - // Then - verify(pullAllHandler).prePopulateRecords(); - verifyNoMoreInteractions(pullHandler); - } - - // rxResult - @Test - void shouldReturnRxResultWhenRunSucceeded() { - // Given - var connection = mock(Connection.class); - ResultCursorFactory cursorFactory = newResultCursorFactory(connection, null); - - // When - var cursorFuture = cursorFactory.rxResult(); - - // Then - verifyRxRunCompleted(connection, cursorFuture); - } - - @Test - void shouldReturnRxResultWhenRunFailed() { - // Given - var connection = mock(Connection.class); - Throwable error = new RuntimeException("Hi there"); - ResultCursorFactory cursorFactory = newResultCursorFactory(connection, error); - - // When - var cursorFuture = cursorFactory.rxResult(); - - // Then - verifyRxRunCompleted(connection, cursorFuture); - } - - private ResultCursorFactoryImpl newResultCursorFactory(Connection connection, Throwable runError) { - var runMessage = mock(Message.class); - - var runHandler = mock(RunResponseHandler.class); - var runFuture = new CompletableFuture(); - if (runError != null) { - runFuture.completeExceptionally(runError); - } else { - runFuture.complete(null); - } - - var pullHandler = mock(PullResponseHandler.class); - var pullAllHandler = mock(PullAllResponseHandler.class); - - return new ResultCursorFactoryImpl(connection, runMessage, runHandler, runFuture, pullHandler, pullAllHandler); - } - - private ResultCursorFactoryImpl newResultCursorFactory(Throwable runError) { - var connection = mock(Connection.class); - return newResultCursorFactory(connection, runError); - } - - private void verifyRunCompleted(Connection connection, CompletionStage cursorFuture) { - verify(connection).write(any(Message.class), any(RunResponseHandler.class)); - assertThat(getNow(cursorFuture), instanceOf(AsyncResultCursor.class)); - } - - private void verifyRxRunCompleted(Connection connection, CompletionStage cursorFuture) { - verify(connection).writeAndFlush(any(Message.class), any(RunResponseHandler.class)); - assertThat(getNow(cursorFuture), instanceOf(RxResultCursorImpl.class)); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/cursor/ResultCursorImplTest.java b/driver/src/test/java/org/neo4j/driver/internal/cursor/ResultCursorImplTest.java new file mode 100644 index 0000000000..e749f5fd8b --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/cursor/ResultCursorImplTest.java @@ -0,0 +1,75 @@ +/* + * Copyright (c) "Neo4j" + * Neo4j Sweden AB [https://neo4j.com] + * + * 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.cursor; + +import static org.mockito.MockitoAnnotations.openMocks; + +import java.util.Collections; +import java.util.function.Consumer; +import java.util.function.Supplier; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.neo4j.driver.Query; +import org.neo4j.driver.internal.DatabaseBookmark; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; + +class ResultCursorImplTest { + ResultCursorImpl cursor; + + @Mock + BoltConnection connection; + + @Mock + Consumer throwableConsumer; + + @Mock + Consumer bookmarkConsumer; + + @Mock + RunSummary runSummary; + + @Mock + Supplier termSupplier; + + Query query = new Query("query"); + long fetchSize = 1000; + boolean closeOnSummary; + + @BeforeEach + @SuppressWarnings("resource") + void beforeEach() { + openMocks(this); + cursor = new ResultCursorImpl( + connection, + query, + fetchSize, + throwableConsumer, + bookmarkConsumer, + closeOnSummary, + runSummary, + termSupplier, + Collections.emptyList(), + null, + null, + null); + } + + @Test + void test() {} +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/cursor/RxResultCursorImplTest.java b/driver/src/test/java/org/neo4j/driver/internal/cursor/RxResultCursorImplTest.java deleted file mode 100644 index a5821ba5cc..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/cursor/RxResultCursorImplTest.java +++ /dev/null @@ -1,310 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.cursor; - -import static java.util.Arrays.asList; -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.assertSame; -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.Mockito.mock; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoMoreInteractions; -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.cursor.RxResultCursorImpl.DISCARD_RECORD_CONSUMER; -import static org.neo4j.driver.internal.messaging.v3.BoltProtocolV3.METADATA_EXTRACTOR; -import static org.neo4j.driver.internal.util.Futures.completedWithNull; -import static org.neo4j.driver.internal.util.Futures.failedFuture; - -import java.util.Collections; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.ExecutionException; -import java.util.function.BiConsumer; -import org.junit.jupiter.api.Test; -import org.mockito.ArgumentCaptor; -import org.neo4j.driver.Record; -import org.neo4j.driver.exceptions.ResultConsumedException; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.handlers.pulln.PullResponseHandler; -import org.neo4j.driver.internal.reactive.util.ListBasedPullHandler; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.summary.ResultSummary; - -class RxResultCursorImplTest { - @Test - @SuppressWarnings("unchecked") - void shouldInstallSummaryConsumerWithoutReportingError() { - // Given - var error = new RuntimeException("Hi"); - var runHandler = newRunResponseHandler(error); - var pullHandler = mock(PullResponseHandler.class); - - // When - new RxResultCursorImpl(error, runHandler, pullHandler, () -> CompletableFuture.completedStage(null)); - - // Then - verify(pullHandler).installSummaryConsumer(any(BiConsumer.class)); - verifyNoMoreInteractions(pullHandler); - } - - @Test - void shouldReturnQueryKeys() { - // Given - var runHandler = newRunResponseHandler(); - var expected = asList("key1", "key2", "key3"); - runHandler.onSuccess(Collections.singletonMap("fields", value(expected))); - - var pullHandler = mock(PullResponseHandler.class); - - // When - RxResultCursor cursor = new RxResultCursorImpl(runHandler, pullHandler); - var actual = cursor.keys(); - - // Then - assertEquals(expected, actual); - } - - @Test - void shouldSupportReturnQueryKeysMultipleTimes() { - // Given - var runHandler = newRunResponseHandler(); - var expected = asList("key1", "key2", "key3"); - runHandler.onSuccess(Collections.singletonMap("fields", value(expected))); - - var pullHandler = mock(PullResponseHandler.class); - - // When - RxResultCursor cursor = new RxResultCursorImpl(runHandler, pullHandler); - - // Then - var actual = cursor.keys(); - assertEquals(expected, actual); - - // Many times - actual = cursor.keys(); - assertEquals(expected, actual); - - actual = cursor.keys(); - assertEquals(expected, actual); - } - - @Test - void shouldPull() { - // Given - var runHandler = newRunResponseHandler(); - var pullHandler = mock(PullResponseHandler.class); - RxResultCursor cursor = new RxResultCursorImpl(runHandler, pullHandler); - - // When - cursor.request(100); - - // Then - verify(pullHandler).request(100); - } - - @Test - void shouldPullUnboundedOnLongMax() { - // Given - var runHandler = newRunResponseHandler(); - var pullHandler = mock(PullResponseHandler.class); - RxResultCursor cursor = new RxResultCursorImpl(runHandler, pullHandler); - - // When - cursor.request(Long.MAX_VALUE); - - // Then - verify(pullHandler).request(-1); - } - - @Test - void shouldCancel() { - // Given - var runHandler = newRunResponseHandler(); - var pullHandler = mock(PullResponseHandler.class); - RxResultCursor cursor = new RxResultCursorImpl(runHandler, pullHandler); - - // When - cursor.cancel(); - - // Then - verify(pullHandler).cancel(); - } - - @Test - void shouldInstallRecordConsumerAndReportError() { - // Given - var error = new RuntimeException("Hi"); - @SuppressWarnings("unchecked") - BiConsumer recordConsumer = mock(BiConsumer.class); - - // When - var runHandler = newRunResponseHandler(error); - PullResponseHandler pullHandler = new ListBasedPullHandler(); - RxResultCursor cursor = - new RxResultCursorImpl(error, runHandler, pullHandler, () -> CompletableFuture.completedStage(null)); - cursor.installRecordConsumer(recordConsumer); - - // Then - verify(recordConsumer).accept(null, error); - verifyNoMoreInteractions(recordConsumer); - } - - @Test - void shouldReturnSummaryFuture() { - // Given - var runHandler = newRunResponseHandler(); - PullResponseHandler pullHandler = new ListBasedPullHandler(); - RxResultCursor cursor = new RxResultCursorImpl(runHandler, pullHandler); - - // When - cursor.installRecordConsumer(DISCARD_RECORD_CONSUMER); - cursor.request(10); - cursor.summaryAsync(); - - // Then - assertTrue(cursor.isDone()); - } - - @Test - void shouldNotAllowToInstallRecordConsumerAfterSummary() { - // Given - var runHandler = newRunResponseHandler(); - PullResponseHandler pullHandler = new ListBasedPullHandler(); - RxResultCursor cursor = new RxResultCursorImpl(runHandler, pullHandler); - - // When - cursor.summaryAsync(); - - // Then - assertThrows(ResultConsumedException.class, () -> cursor.installRecordConsumer(null)); - } - - @Test - void shouldAllowToCallSummaryMultipleTimes() { - // Given - var runHandler = newRunResponseHandler(); - PullResponseHandler pullHandler = new ListBasedPullHandler(); - RxResultCursor cursor = new RxResultCursorImpl(runHandler, pullHandler); - - // When - cursor.summaryAsync(); - - // Then - cursor.summaryAsync(); - cursor.summaryAsync(); - } - - @Test - void shouldOnlyInstallRecordConsumerOnce() { - // Given - var runHandler = newRunResponseHandler(); - var pullHandler = mock(PullResponseHandler.class); - RxResultCursor cursor = new RxResultCursorImpl(runHandler, pullHandler); - - // When - cursor.installRecordConsumer(DISCARD_RECORD_CONSUMER); // any consumer - cursor.installRecordConsumer(DISCARD_RECORD_CONSUMER); // any consumer - - // Then - verify(pullHandler).installRecordConsumer(any()); - } - - @Test - void shouldCancelIfNotPulled() { - // Given - var runHandler = newRunResponseHandler(); - var pullHandler = mock(PullResponseHandler.class); - RxResultCursor cursor = new RxResultCursorImpl(runHandler, pullHandler); - - // When - cursor.summaryAsync(); - - // Then - verify(pullHandler).installRecordConsumer(DISCARD_RECORD_CONSUMER); - verify(pullHandler).cancel(); - assertFalse(cursor.isDone()); - } - - @Test - void shouldPropagateSummaryErrorViaSummaryStageWhenItIsRetrievedExternally() - throws ExecutionException, InterruptedException { - // Given - var runHandler = mock(RunResponseHandler.class); - var pullHandler = mock(PullResponseHandler.class); - @SuppressWarnings("unchecked") - ArgumentCaptor> summaryConsumerCaptor = - ArgumentCaptor.forClass(BiConsumer.class); - RxResultCursor cursor = new RxResultCursorImpl(runHandler, pullHandler); - verify(pullHandler, times(1)).installSummaryConsumer(summaryConsumerCaptor.capture()); - var summaryConsumer = summaryConsumerCaptor.getValue(); - var exception = mock(RuntimeException.class); - - // When - var summaryStage = cursor.summaryAsync(); - var discardStage = cursor.discardAllFailureAsync(); - summaryConsumer.accept(null, exception); - - // Then - verify(pullHandler).installRecordConsumer(DISCARD_RECORD_CONSUMER); - verify(pullHandler).cancel(); - var actualException = assertThrows( - ExecutionException.class, - () -> summaryStage.toCompletableFuture().get()); - assertSame(exception, actualException.getCause()); - assertNull(discardStage.toCompletableFuture().get()); - } - - @Test - void shouldPropagateSummaryErrorViaDiscardStageWhenSummaryStageIsNotRetrievedExternally() - throws ExecutionException, InterruptedException { - // Given - var runHandler = mock(RunResponseHandler.class); - var pullHandler = mock(PullResponseHandler.class); - @SuppressWarnings("unchecked") - ArgumentCaptor> summaryConsumerCaptor = - ArgumentCaptor.forClass(BiConsumer.class); - RxResultCursor cursor = new RxResultCursorImpl(runHandler, pullHandler); - verify(pullHandler, times(1)).installSummaryConsumer(summaryConsumerCaptor.capture()); - var summaryConsumer = summaryConsumerCaptor.getValue(); - var exception = mock(RuntimeException.class); - - // When - var discardStage = cursor.discardAllFailureAsync(); - summaryConsumer.accept(null, exception); - - // Then - verify(pullHandler).installRecordConsumer(DISCARD_RECORD_CONSUMER); - verify(pullHandler).cancel(); - assertSame(exception, discardStage.toCompletableFuture().get().getCause()); - } - - private static RunResponseHandler newRunResponseHandler(CompletableFuture runFuture) { - return new RunResponseHandler(runFuture, METADATA_EXTRACTOR, mock(Connection.class), null); - } - - private static RunResponseHandler newRunResponseHandler(Throwable error) { - return newRunResponseHandler(failedFuture(error)); - } - - private static RunResponseHandler newRunResponseHandler() { - return newRunResponseHandler(completedWithNull()); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/ChannelReleasingResetResponseHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/ChannelReleasingResetResponseHandlerTest.java deleted file mode 100644 index bc20f807a3..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/handlers/ChannelReleasingResetResponseHandlerTest.java +++ /dev/null @@ -1,95 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.Collections.emptyMap; -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.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.lastUsedTimestamp; -import static org.neo4j.driver.internal.util.Futures.completedWithNull; - -import io.netty.channel.embedded.EmbeddedChannel; -import java.time.Clock; -import java.util.concurrent.CompletableFuture; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.Test; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; -import org.neo4j.driver.internal.async.pool.ExtendedChannelPool; -import org.neo4j.driver.internal.util.FakeClock; - -class ChannelReleasingResetResponseHandlerTest { - private final EmbeddedChannel channel = new EmbeddedChannel(); - private final InboundMessageDispatcher messageDispatcher = mock(InboundMessageDispatcher.class); - - @AfterEach - void tearDown() { - channel.finishAndReleaseAll(); - } - - @Test - void shouldReleaseChannelOnSuccess() { - var pool = newChannelPoolMock(); - var clock = new FakeClock(); - clock.progress(5); - var releaseFuture = new CompletableFuture(); - var handler = newHandler(pool, clock, releaseFuture); - - handler.onSuccess(emptyMap()); - - verifyLastUsedTimestamp(); - verify(pool).release(eq(channel)); - assertTrue(releaseFuture.isDone()); - assertFalse(releaseFuture.isCompletedExceptionally()); - } - - @Test - void shouldCloseAndReleaseChannelOnFailure() { - var pool = newChannelPoolMock(); - var clock = new FakeClock(); - clock.progress(100); - var releaseFuture = new CompletableFuture(); - var handler = newHandler(pool, clock, releaseFuture); - - handler.onFailure(new RuntimeException()); - - assertTrue(channel.closeFuture().isDone()); - verify(pool).release(eq(channel)); - assertTrue(releaseFuture.isDone()); - assertFalse(releaseFuture.isCompletedExceptionally()); - } - - private void verifyLastUsedTimestamp() { - assertEquals(5, lastUsedTimestamp(channel).intValue()); - } - - private ChannelReleasingResetResponseHandler newHandler( - ExtendedChannelPool pool, Clock clock, CompletableFuture releaseFuture) { - return new ChannelReleasingResetResponseHandler(channel, pool, messageDispatcher, clock, releaseFuture); - } - - private static ExtendedChannelPool newChannelPoolMock() { - var pool = mock(ExtendedChannelPool.class); - when(pool.release(any())).thenReturn(completedWithNull()); - return pool; - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/LegacyPullAllResponseHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/LegacyPullAllResponseHandlerTest.java deleted file mode 100644 index 7261b4697f..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/handlers/LegacyPullAllResponseHandlerTest.java +++ /dev/null @@ -1,226 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.Arrays.asList; -import static java.util.Collections.emptyList; -import static java.util.Collections.emptyMap; -import static java.util.Collections.singletonMap; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.verify; -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.Values.values; -import static org.neo4j.driver.testutil.TestUtil.await; - -import java.util.List; -import java.util.concurrent.CompletableFuture; -import java.util.function.Function; -import org.junit.jupiter.api.Test; -import org.neo4j.driver.Query; -import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3; -import org.neo4j.driver.internal.spi.Connection; - -class LegacyPullAllResponseHandlerTest extends PullAllResponseHandlerTestBase { - @Test - void shouldDisableAutoReadWhenTooManyRecordsArrive() { - var connection = connectionMock(); - var handler = newHandler(asList("key1", "key2"), connection); - - for (var i = 0; i < LegacyPullAllResponseHandler.RECORD_BUFFER_HIGH_WATERMARK + 1; i++) { - handler.onRecord(values(100, 200)); - } - - verify(connection).disableAutoRead(); - } - - @Test - void shouldEnableAutoReadWhenRecordsRetrievedFromBuffer() { - var connection = connectionMock(); - var keys = asList("key1", "key2"); - var handler = newHandler(keys, connection); - - int i; - for (i = 0; i < LegacyPullAllResponseHandler.RECORD_BUFFER_HIGH_WATERMARK + 1; i++) { - handler.onRecord(values(100, 200)); - } - - verify(connection, never()).enableAutoRead(); - verify(connection).disableAutoRead(); - - while (i-- > LegacyPullAllResponseHandler.RECORD_BUFFER_LOW_WATERMARK - 1) { - var record = await(handler.nextAsync()); - assertNotNull(record); - assertEquals(keys, record.keys()); - assertEquals(100, record.get("key1").asInt()); - assertEquals(200, record.get("key2").asInt()); - } - verify(connection).enableAutoRead(); - } - - @Test - void shouldNotDisableAutoReadWhenSummaryRequested() { - var connection = connectionMock(); - var keys = asList("key1", "key2"); - var handler = newHandler(keys, connection); - - var summaryFuture = handler.consumeAsync().toCompletableFuture(); - assertFalse(summaryFuture.isDone()); - - var recordCount = LegacyPullAllResponseHandler.RECORD_BUFFER_HIGH_WATERMARK + 10; - for (var i = 0; i < recordCount; i++) { - handler.onRecord(values("a", "b")); - } - - verify(connection, never()).disableAutoRead(); - - handler.onSuccess(emptyMap()); - assertTrue(summaryFuture.isDone()); - - var summary = await(summaryFuture); - assertNotNull(summary); - assertNull(await(handler.nextAsync())); - } - - @Test - void shouldNotDisableAutoReadWhenFailureRequested() { - var connection = connectionMock(); - var keys = asList("key1", "key2"); - var handler = newHandler(keys, connection); - - var failureFuture = handler.pullAllFailureAsync().toCompletableFuture(); - assertFalse(failureFuture.isDone()); - - var recordCount = LegacyPullAllResponseHandler.RECORD_BUFFER_HIGH_WATERMARK + 5; - for (var i = 0; i < recordCount; i++) { - handler.onRecord(values(123, 456)); - } - - verify(connection, never()).disableAutoRead(); - - var error = new IllegalStateException("Wrong config"); - handler.onFailure(error); - - assertTrue(failureFuture.isDone()); - assertEquals(error, await(failureFuture)); - - for (var i = 0; i < recordCount; i++) { - var record = await(handler.nextAsync()); - assertNotNull(record); - assertEquals(keys, record.keys()); - assertEquals(123, record.get("key1").asInt()); - assertEquals(456, record.get("key2").asInt()); - } - - assertNull(await(handler.nextAsync())); - } - - @Test - void shouldEnableAutoReadOnConnectionWhenFailureRequestedButNotAvailable() throws Exception { - var connection = connectionMock(); - var handler = newHandler(asList("key1", "key2"), connection); - - handler.onRecord(values(1, 2)); - handler.onRecord(values(3, 4)); - - verify(connection, never()).enableAutoRead(); - verify(connection, never()).disableAutoRead(); - - var failureFuture = handler.pullAllFailureAsync().toCompletableFuture(); - assertFalse(failureFuture.isDone()); - - verify(connection).enableAutoRead(); - verify(connection, never()).disableAutoRead(); - - assertNotNull(await(handler.nextAsync())); - assertNotNull(await(handler.nextAsync())); - - var error = new RuntimeException("Oh my!"); - handler.onFailure(error); - - assertTrue(failureFuture.isDone()); - assertEquals(error, failureFuture.get()); - } - - @Test - void shouldNotDisableAutoReadWhenAutoReadManagementDisabled() { - var connection = connectionMock(); - var handler = newHandler(asList("key1", "key2"), connection); - handler.disableAutoReadManagement(); - - for (var i = 0; i < LegacyPullAllResponseHandler.RECORD_BUFFER_HIGH_WATERMARK + 1; i++) { - handler.onRecord(values(100, 200)); - } - - verify(connection, never()).disableAutoRead(); - } - - @Test - void shouldReturnEmptyListInListAsyncAfterFailure() { - var handler = newHandler(); - - var error = new RuntimeException("Hi"); - handler.onFailure(error); - - // consume the error - assertEquals(error, await(handler.pullAllFailureAsync())); - assertEquals(emptyList(), await(handler.listAsync(Function.identity()))); - } - - @Test - void shouldEnableAutoReadOnConnectionWhenSummaryRequestedButNotAvailable() throws Exception // TODO for auto run - { - var connection = connectionMock(); - PullAllResponseHandler handler = newHandler(asList("key1", "key2", "key3"), connection); - - handler.onRecord(values(1, 2, 3)); - handler.onRecord(values(4, 5, 6)); - - verify(connection, never()).enableAutoRead(); - verify(connection, never()).disableAutoRead(); - - var summaryFuture = handler.consumeAsync().toCompletableFuture(); - assertFalse(summaryFuture.isDone()); - - verify(connection).enableAutoRead(); - verify(connection, never()).disableAutoRead(); - - assertNull(await(handler.nextAsync())); - - handler.onSuccess(emptyMap()); - - assertTrue(summaryFuture.isDone()); - assertNotNull(summaryFuture.get()); - } - - protected LegacyPullAllResponseHandler newHandler(Query query, List queryKeys, Connection connection) { - var runResponseHandler = new RunResponseHandler( - new CompletableFuture<>(), BoltProtocolV3.METADATA_EXTRACTOR, mock(Connection.class), null); - runResponseHandler.onSuccess(singletonMap("fields", value(queryKeys))); - return new LegacyPullAllResponseHandler( - query, - runResponseHandler, - connection, - BoltProtocolV3.METADATA_EXTRACTOR, - mock(PullResponseCompletionListener.class)); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/PingResponseHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/PingResponseHandlerTest.java deleted file mode 100644 index f1aaed8d57..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/handlers/PingResponseHandlerTest.java +++ /dev/null @@ -1,69 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.Collections.emptyMap; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.mockito.Mockito.mock; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; - -import io.netty.channel.Channel; -import io.netty.util.concurrent.ImmediateEventExecutor; -import io.netty.util.concurrent.Promise; -import org.junit.jupiter.api.Test; -import org.neo4j.driver.Value; - -class PingResponseHandlerTest { - @Test - void shouldResolvePromiseOnSuccess() { - var promise = newPromise(); - var handler = newHandler(promise); - - handler.onSuccess(emptyMap()); - - assertTrue(promise.isSuccess()); - assertTrue(promise.getNow()); - } - - @Test - void shouldResolvePromiseOnFailure() { - var promise = newPromise(); - var handler = newHandler(promise); - - handler.onFailure(new RuntimeException()); - - assertTrue(promise.isSuccess()); - assertFalse(promise.getNow()); - } - - @Test - void shouldNotSupportRecordMessages() { - var handler = newHandler(newPromise()); - - assertThrows(UnsupportedOperationException.class, () -> handler.onRecord(new Value[0])); - } - - private static Promise newPromise() { - return ImmediateEventExecutor.INSTANCE.newPromise(); - } - - private static PingResponseHandler newHandler(Promise result) { - return new PingResponseHandler(result, mock(Channel.class), DEV_NULL_LOGGING); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/PullAllResponseHandlerTestBase.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/PullAllResponseHandlerTestBase.java deleted file mode 100644 index 51fb60f9e3..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/handlers/PullAllResponseHandlerTestBase.java +++ /dev/null @@ -1,663 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.Arrays.asList; -import static java.util.Collections.emptyList; -import static java.util.Collections.emptyMap; -import static java.util.Collections.singletonList; -import static java.util.Collections.singletonMap; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -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 static org.mockito.Mockito.when; -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.Values.values; -import static org.neo4j.driver.testutil.TestUtil.await; - -import java.io.IOException; -import java.nio.channels.ClosedChannelException; -import java.util.List; -import java.util.function.Function; -import org.junit.jupiter.api.Test; -import org.neo4j.driver.Query; -import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.exceptions.SessionExpiredException; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.InternalRecord; -import org.neo4j.driver.internal.messaging.v43.BoltProtocolV43; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.summary.QueryType; - -public abstract class PullAllResponseHandlerTestBase { - @Test - void shouldReturnNoFailureWhenAlreadySucceeded() { - PullAllResponseHandler handler = newHandler(); - handler.onSuccess(emptyMap()); - - var failure = await(handler.pullAllFailureAsync()); - - assertNull(failure); - } - - @Test - void shouldReturnNoFailureWhenSucceededAfterFailureRequested() { - PullAllResponseHandler handler = newHandler(); - - var failureFuture = handler.pullAllFailureAsync().toCompletableFuture(); - assertFalse(failureFuture.isDone()); - - handler.onSuccess(emptyMap()); - - assertTrue(failureFuture.isDone()); - assertNull(await(failureFuture)); - } - - @Test - void shouldReturnFailureWhenAlreadyFailed() { - PullAllResponseHandler handler = newHandler(); - - var failure = new RuntimeException("Ops"); - handler.onFailure(failure); - - var receivedFailure = await(handler.pullAllFailureAsync()); - assertEquals(failure, receivedFailure); - } - - @Test - void shouldReturnFailureWhenFailedAfterFailureRequested() { - PullAllResponseHandler handler = newHandler(); - - var failureFuture = handler.pullAllFailureAsync().toCompletableFuture(); - assertFalse(failureFuture.isDone()); - - var failure = new IOException("Broken pipe"); - handler.onFailure(failure); - - assertTrue(failureFuture.isDone()); - assertEquals(failure, await(failureFuture)); - } - - @Test - void shouldReturnFailureWhenRequestedMultipleTimes() { - PullAllResponseHandler handler = newHandler(); - - var failureFuture1 = handler.pullAllFailureAsync().toCompletableFuture(); - var failureFuture2 = handler.pullAllFailureAsync().toCompletableFuture(); - - assertFalse(failureFuture1.isDone()); - assertFalse(failureFuture2.isDone()); - - var failure = new RuntimeException("Unable to contact database"); - handler.onFailure(failure); - - assertTrue(failureFuture1.isDone()); - assertTrue(failureFuture2.isDone()); - - assertEquals(failure, await(failureFuture1)); - assertEquals(failure, await(failureFuture2)); - } - - @Test - void shouldReturnFailureOnlyOnceWhenFailedBeforeFailureRequested() { - PullAllResponseHandler handler = newHandler(); - - var failure = new ServiceUnavailableException("Connection terminated"); - handler.onFailure(failure); - - assertEquals(failure, await(handler.pullAllFailureAsync())); - assertNull(await(handler.pullAllFailureAsync())); - } - - @Test - void shouldReturnFailureOnlyOnceWhenFailedAfterFailureRequested() { - PullAllResponseHandler handler = newHandler(); - - var failureFuture = handler.pullAllFailureAsync(); - - var failure = new SessionExpiredException("Network unreachable"); - handler.onFailure(failure); - assertEquals(failure, await(failureFuture)); - - assertNull(await(handler.pullAllFailureAsync())); - } - - @Test - void shouldReturnSummaryWhenAlreadyFailedAndFailureConsumed() { - var query = new Query("CREATE ()"); - PullAllResponseHandler handler = newHandler(query); - - var failure = new ServiceUnavailableException("Neo4j unreachable"); - handler.onFailure(failure); - - assertEquals(failure, await(handler.pullAllFailureAsync())); - - var summary = await(handler.consumeAsync()); - assertNotNull(summary); - assertEquals(query, summary.query()); - } - - @Test - void shouldReturnSummaryWhenAlreadySucceeded() { - var query = new Query("CREATE () RETURN 42"); - PullAllResponseHandler handler = newHandler(query); - handler.onSuccess(singletonMap("type", value("rw"))); - - var summary = await(handler.consumeAsync()); - - assertEquals(query, summary.query()); - assertEquals(QueryType.READ_WRITE, summary.queryType()); - } - - @Test - void shouldReturnSummaryWhenSucceededAfterSummaryRequested() { - var query = new Query("RETURN 'Hi!"); - PullAllResponseHandler handler = newHandler(query); - - var summaryFuture = handler.consumeAsync().toCompletableFuture(); - assertFalse(summaryFuture.isDone()); - - handler.onSuccess(singletonMap("type", value("r"))); - - assertTrue(summaryFuture.isDone()); - var summary = await(summaryFuture); - - assertEquals(query, summary.query()); - assertEquals(QueryType.READ_ONLY, summary.queryType()); - } - - @Test - void shouldReturnFailureWhenSummaryRequestedWhenAlreadyFailed() { - PullAllResponseHandler handler = newHandler(); - - var failure = new RuntimeException("Computer is burning"); - handler.onFailure(failure); - - var e = assertThrows(RuntimeException.class, () -> await(handler.consumeAsync())); - assertEquals(failure, e); - } - - @Test - void shouldReturnFailureWhenFailedAfterSummaryRequested() { - PullAllResponseHandler handler = newHandler(); - - var summaryFuture = handler.consumeAsync().toCompletableFuture(); - assertFalse(summaryFuture.isDone()); - - var failure = new IOException("FAILED to write"); - handler.onFailure(failure); - - assertTrue(summaryFuture.isDone()); - var e = assertThrows(Exception.class, () -> await(summaryFuture)); - assertEquals(failure, e); - } - - @Test - void shouldFailSummaryWhenRequestedMultipleTimes() { - PullAllResponseHandler handler = newHandler(); - - var summaryFuture1 = handler.consumeAsync().toCompletableFuture(); - var summaryFuture2 = handler.consumeAsync().toCompletableFuture(); - assertFalse(summaryFuture1.isDone()); - assertFalse(summaryFuture2.isDone()); - - var failure = new ClosedChannelException(); - handler.onFailure(failure); - - assertTrue(summaryFuture1.isDone()); - assertTrue(summaryFuture2.isDone()); - - var e1 = assertThrows(Exception.class, () -> await(summaryFuture2)); - assertEquals(failure, e1); - - var e2 = assertThrows(Exception.class, () -> await(summaryFuture1)); - assertEquals(failure, e2); - } - - @Test - void shouldPropagateFailureOnlyOnceFromSummary() { - var query = new Query("CREATE INDEX ON :Person(name)"); - PullAllResponseHandler handler = newHandler(query); - - var failure = new IllegalStateException("Some state is illegal :("); - handler.onFailure(failure); - - var e = assertThrows(RuntimeException.class, () -> await(handler.consumeAsync())); - assertEquals(failure, e); - - var summary = await(handler.consumeAsync()); - assertNotNull(summary); - assertEquals(query, summary.query()); - } - - @Test - void shouldPeekSingleAvailableRecord() { - var keys = asList("key1", "key2"); - PullAllResponseHandler handler = newHandler(keys); - handler.onRecord(values("a", "b")); - - var record = await(handler.peekAsync()); - - assertEquals(keys, record.keys()); - assertEquals("a", record.get("key1").asString()); - assertEquals("b", record.get("key2").asString()); - } - - @Test - void shouldPeekFirstRecordWhenMultipleAvailable() { - var keys = asList("key1", "key2", "key3"); - PullAllResponseHandler handler = newHandler(keys); - - handler.onRecord(values("a1", "b1", "c1")); - handler.onRecord(values("a2", "b2", "c2")); - handler.onRecord(values("a3", "b3", "c3")); - - var record = await(handler.peekAsync()); - - assertEquals(keys, record.keys()); - assertEquals("a1", record.get("key1").asString()); - assertEquals("b1", record.get("key2").asString()); - assertEquals("c1", record.get("key3").asString()); - } - - @Test - void shouldPeekRecordThatBecomesAvailableLater() { - var keys = asList("key1", "key2"); - PullAllResponseHandler handler = newHandler(keys); - - var recordFuture = handler.peekAsync().toCompletableFuture(); - assertFalse(recordFuture.isDone()); - - handler.onRecord(values(24, 42)); - assertTrue(recordFuture.isDone()); - - var record = await(recordFuture); - assertEquals(keys, record.keys()); - assertEquals(24, record.get("key1").asInt()); - assertEquals(42, record.get("key2").asInt()); - } - - @Test - void shouldPeekAvailableNothingAfterSuccess() { - var keys = asList("key1", "key2", "key3"); - PullAllResponseHandler handler = newHandler(keys); - - handler.onRecord(values(1, 2, 3)); - handler.onSuccess(emptyMap()); - - var record = await(handler.peekAsync()); - assertEquals(keys, record.keys()); - assertEquals(1, record.get("key1").asInt()); - assertEquals(2, record.get("key2").asInt()); - assertEquals(3, record.get("key3").asInt()); - } - - @Test - void shouldPeekNothingAfterSuccess() { - PullAllResponseHandler handler = newHandler(); - handler.onSuccess(emptyMap()); - - assertNull(await(handler.peekAsync())); - } - - @Test - void shouldPeekWhenRequestedMultipleTimes() { - var keys = asList("key1", "key2"); - PullAllResponseHandler handler = newHandler(keys); - - var recordFuture1 = handler.peekAsync().toCompletableFuture(); - var recordFuture2 = handler.peekAsync().toCompletableFuture(); - var recordFuture3 = handler.peekAsync().toCompletableFuture(); - - assertFalse(recordFuture1.isDone()); - assertFalse(recordFuture2.isDone()); - assertFalse(recordFuture3.isDone()); - - handler.onRecord(values(2, 1)); - - assertTrue(recordFuture1.isDone()); - assertTrue(recordFuture2.isDone()); - assertTrue(recordFuture3.isDone()); - - var record1 = await(recordFuture1); - var record2 = await(recordFuture2); - var record3 = await(recordFuture3); - - assertEquals(keys, record1.keys()); - assertEquals(keys, record2.keys()); - assertEquals(keys, record3.keys()); - - assertEquals(2, record1.get("key1").asInt()); - assertEquals(1, record1.get("key2").asInt()); - - assertEquals(2, record2.get("key1").asInt()); - assertEquals(1, record2.get("key2").asInt()); - - assertEquals(2, record3.get("key1").asInt()); - assertEquals(1, record3.get("key2").asInt()); - } - - @Test - void shouldPropagateNotConsumedFailureInPeek() { - PullAllResponseHandler handler = newHandler(); - - var failure = new RuntimeException("Something is wrong"); - handler.onFailure(failure); - - var e = assertThrows(RuntimeException.class, () -> await(handler.peekAsync())); - assertEquals(failure, e); - } - - @Test - void shouldPropagateFailureInPeekWhenItBecomesAvailable() { - PullAllResponseHandler handler = newHandler(); - - var recordFuture = handler.peekAsync().toCompletableFuture(); - assertFalse(recordFuture.isDone()); - - var failure = new RuntimeException("Error"); - handler.onFailure(failure); - - var e = assertThrows(RuntimeException.class, () -> await(recordFuture)); - assertEquals(failure, e); - } - - @Test - void shouldPropagateFailureInPeekOnlyOnce() { - PullAllResponseHandler handler = newHandler(); - - var failure = new RuntimeException("Something is wrong"); - handler.onFailure(failure); - - var e = assertThrows(RuntimeException.class, () -> await(handler.peekAsync())); - assertEquals(failure, e); - assertNull(await(handler.peekAsync())); - } - - @Test - void shouldReturnSingleAvailableRecordInNextAsync() { - var keys = asList("key1", "key2"); - PullAllResponseHandler handler = newHandler(keys); - handler.onRecord(values("1", "2")); - - var record = await(handler.nextAsync()); - - assertNotNull(record); - assertEquals(keys, record.keys()); - assertEquals("1", record.get("key1").asString()); - assertEquals("2", record.get("key2").asString()); - } - - @Test - void shouldReturnNoRecordsWhenNoneAvailableInNextAsync() { - PullAllResponseHandler handler = newHandler(asList("key1", "key2")); - handler.onSuccess(emptyMap()); - - assertNull(await(handler.nextAsync())); - } - - @Test - void shouldReturnNoRecordsWhenSuccessComesAfterNextAsync() { - PullAllResponseHandler handler = newHandler(asList("key1", "key2")); - - var recordFuture = handler.nextAsync().toCompletableFuture(); - assertFalse(recordFuture.isDone()); - - handler.onSuccess(emptyMap()); - assertTrue(recordFuture.isDone()); - - assertNull(await(recordFuture)); - } - - @Test - void shouldPullAllAvailableRecordsWithNextAsync() { - var keys = asList("key1", "key2", "key3"); - PullAllResponseHandler handler = newHandler(keys); - - handler.onRecord(values(1, 2, 3)); - handler.onRecord(values(11, 22, 33)); - handler.onRecord(values(111, 222, 333)); - handler.onRecord(values(1111, 2222, 3333)); - handler.onSuccess(emptyMap()); - - var record1 = await(handler.nextAsync()); - assertNotNull(record1); - assertEquals(keys, record1.keys()); - assertEquals(1, record1.get("key1").asInt()); - assertEquals(2, record1.get("key2").asInt()); - assertEquals(3, record1.get("key3").asInt()); - - var record2 = await(handler.nextAsync()); - assertNotNull(record2); - assertEquals(keys, record2.keys()); - assertEquals(11, record2.get("key1").asInt()); - assertEquals(22, record2.get("key2").asInt()); - assertEquals(33, record2.get("key3").asInt()); - - var record3 = await(handler.nextAsync()); - assertNotNull(record3); - assertEquals(keys, record3.keys()); - assertEquals(111, record3.get("key1").asInt()); - assertEquals(222, record3.get("key2").asInt()); - assertEquals(333, record3.get("key3").asInt()); - - var record4 = await(handler.nextAsync()); - assertNotNull(record4); - assertEquals(keys, record4.keys()); - assertEquals(1111, record4.get("key1").asInt()); - assertEquals(2222, record4.get("key2").asInt()); - assertEquals(3333, record4.get("key3").asInt()); - - assertNull(await(handler.nextAsync())); - assertNull(await(handler.nextAsync())); - } - - @Test - void shouldReturnRecordInNextAsyncWhenItBecomesAvailableLater() { - var keys = asList("key1", "key2"); - PullAllResponseHandler handler = newHandler(keys); - - var recordFuture = handler.nextAsync().toCompletableFuture(); - assertFalse(recordFuture.isDone()); - - handler.onRecord(values(24, 42)); - assertTrue(recordFuture.isDone()); - - var record = await(recordFuture); - assertNotNull(record); - assertEquals(keys, record.keys()); - assertEquals(24, record.get("key1").asInt()); - assertEquals(42, record.get("key2").asInt()); - } - - @Test - void shouldReturnSameRecordOnceWhenRequestedMultipleTimesInNextAsync() { - var keys = asList("key1", "key2"); - PullAllResponseHandler handler = newHandler(keys); - - var recordFuture1 = handler.nextAsync().toCompletableFuture(); - var recordFuture2 = handler.nextAsync().toCompletableFuture(); - assertFalse(recordFuture1.isDone()); - assertFalse(recordFuture2.isDone()); - - handler.onRecord(values("A", "B")); - assertTrue(recordFuture1.isDone()); - assertTrue(recordFuture2.isDone()); - - var record1 = await(recordFuture1); - var record2 = await(recordFuture2); - - // record should be returned only once because #nextAsync() polls it - assertTrue(record1 != null || record2 != null); - var record = record1 != null ? record1 : record2; - - assertNotNull(record); - assertEquals(keys, record.keys()); - assertEquals("A", record.get("key1").asString()); - assertEquals("B", record.get("key2").asString()); - } - - @Test - void shouldPropagateExistingFailureInNextAsync() { - PullAllResponseHandler handler = newHandler(); - var error = new RuntimeException("FAILED to read"); - handler.onFailure(error); - - var e = assertThrows(RuntimeException.class, () -> await(handler.nextAsync())); - assertEquals(error, e); - } - - @Test - void shouldPropagateFailureInNextAsyncWhenFailureMessagesArrivesLater() { - PullAllResponseHandler handler = newHandler(); - - var recordFuture = handler.nextAsync().toCompletableFuture(); - assertFalse(recordFuture.isDone()); - - var error = new RuntimeException("Network failed"); - handler.onFailure(error); - - assertTrue(recordFuture.isDone()); - var e = assertThrows(RuntimeException.class, () -> await(recordFuture)); - assertEquals(error, e); - } - - @Test - void shouldPropagateFailureFromListAsync() { - PullAllResponseHandler handler = newHandler(); - var error = new RuntimeException("Hi!"); - handler.onFailure(error); - - var e = assertThrows(RuntimeException.class, () -> await(handler.listAsync(Function.identity()))); - assertEquals(error, e); - } - - @Test - void shouldPropagateFailureAfterRecordFromListAsync() { - PullAllResponseHandler handler = newHandler(asList("key1", "key2")); - - handler.onRecord(values("a", "b")); - - var error = new RuntimeException("Hi!"); - handler.onFailure(error); - - var e = assertThrows(RuntimeException.class, () -> await(handler.listAsync(Function.identity()))); - assertEquals(error, e); - } - - @Test - void shouldFailListAsyncWhenTransformationFunctionThrows() { - PullAllResponseHandler handler = newHandler(asList("key1", "key2")); - handler.onRecord(values(1, 2)); - handler.onRecord(values(3, 4)); - handler.onSuccess(emptyMap()); - - var error = new RuntimeException("Hi!"); - - var stage = handler.listAsync(record -> { - if (record.get(1).asInt() == 4) { - throw error; - } - return 42; - }); - - var e = assertThrows(RuntimeException.class, () -> await(stage)); - assertEquals(error, e); - } - - @Test - void shouldReturnEmptyListInListAsyncAfterSuccess() { - PullAllResponseHandler handler = newHandler(); - - handler.onSuccess(emptyMap()); - - assertEquals(emptyList(), await(handler.listAsync(Function.identity()))); - } - - @Test - void shouldReturnTransformedListInListAsync() { - PullAllResponseHandler handler = newHandler(singletonList("key1")); - - handler.onRecord(values(1)); - handler.onRecord(values(2)); - handler.onRecord(values(3)); - handler.onRecord(values(4)); - handler.onSuccess(emptyMap()); - - var transformedList = await(handler.listAsync(record -> record.get(0).asInt() * 2)); - - assertEquals(asList(2, 4, 6, 8), transformedList); - } - - @Test - void shouldReturnNotTransformedListInListAsync() { - var keys = asList("key1", "key2"); - PullAllResponseHandler handler = newHandler(keys); - - var fields1 = values("a", "b"); - var fields2 = values("c", "d"); - var fields3 = values("e", "f"); - - handler.onRecord(fields1); - handler.onRecord(fields2); - handler.onRecord(fields3); - handler.onSuccess(emptyMap()); - - var list = await(handler.listAsync(Function.identity())); - - var expectedRecords = asList( - new InternalRecord(keys, fields1), - new InternalRecord(keys, fields2), - new InternalRecord(keys, fields3)); - - assertEquals(expectedRecords, list); - } - - protected T newHandler() { - return newHandler(new Query("RETURN 1")); - } - - protected T newHandler(Query query) { - return newHandler(query, emptyList()); - } - - protected T newHandler(List queryKeys) { - return newHandler(new Query("RETURN 1"), queryKeys, connectionMock()); - } - - protected T newHandler(Query query, List queryKeys) { - return newHandler(query, queryKeys, connectionMock()); - } - - protected T newHandler(List queryKeys, Connection connection) { - return newHandler(new Query("RETURN 1"), queryKeys, connection); - } - - protected abstract T newHandler(Query query, List queryKeys, Connection connection); - - protected Connection connectionMock() { - var connection = mock(Connection.class); - when(connection.serverAddress()).thenReturn(BoltServerAddress.LOCAL_DEFAULT); - when(connection.protocol()).thenReturn(BoltProtocolV43.INSTANCE); - when(connection.serverAgent()).thenReturn("Neo4j/4.2.5"); - return connection; - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/RoutingResponseHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/RoutingResponseHandlerTest.java deleted file mode 100644 index e491019dce..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/handlers/RoutingResponseHandlerTest.java +++ /dev/null @@ -1,171 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.instanceOf; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoInteractions; -import static org.neo4j.driver.internal.BoltServerAddress.LOCAL_DEFAULT; - -import java.util.concurrent.CompletionException; -import org.junit.jupiter.api.Test; -import org.mockito.ArgumentCaptor; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.exceptions.SessionExpiredException; -import org.neo4j.driver.exceptions.TransientException; -import org.neo4j.driver.internal.RoutingErrorHandler; -import org.neo4j.driver.internal.spi.ResponseHandler; - -class RoutingResponseHandlerTest { - @Test - void shouldUnwrapCompletionException() { - var error = new RuntimeException("Hi"); - var errorHandler = mock(RoutingErrorHandler.class); - - var handledError = handle(new CompletionException(error), errorHandler); - - assertEquals(error, handledError); - verifyNoInteractions(errorHandler); - } - - @Test - void shouldHandleServiceUnavailableException() { - var error = new ServiceUnavailableException("Hi"); - var errorHandler = mock(RoutingErrorHandler.class); - - var handledError = handle(error, errorHandler); - - assertThat(handledError, instanceOf(SessionExpiredException.class)); - verify(errorHandler).onConnectionFailure(LOCAL_DEFAULT); - } - - @Test - void shouldHandleDatabaseUnavailableError() { - var error = new TransientException("Neo.TransientError.General.DatabaseUnavailable", "Hi"); - var errorHandler = mock(RoutingErrorHandler.class); - - var handledError = handle(error, errorHandler); - - assertEquals(error, handledError); - verify(errorHandler).onConnectionFailure(LOCAL_DEFAULT); - } - - @Test - void shouldHandleTransientException() { - var error = new TransientException("Neo.TransientError.Transaction.DeadlockDetected", "Hi"); - var errorHandler = mock(RoutingErrorHandler.class); - - var handledError = handle(error, errorHandler); - - assertEquals(error, handledError); - verifyNoInteractions(errorHandler); - } - - @Test - void shouldHandleNotALeaderErrorWithReadAccessMode() { - testWriteFailureWithReadAccessMode("Neo.ClientError.Cluster.NotALeader"); - } - - @Test - void shouldHandleNotALeaderErrorWithWriteAccessMode() { - testWriteFailureWithWriteAccessMode("Neo.ClientError.Cluster.NotALeader"); - } - - @Test - void shouldHandleForbiddenOnReadOnlyDatabaseErrorWithReadAccessMode() { - testWriteFailureWithReadAccessMode("Neo.ClientError.General.ForbiddenOnReadOnlyDatabase"); - } - - @Test - void shouldHandleForbiddenOnReadOnlyDatabaseErrorWithWriteAccessMode() { - testWriteFailureWithWriteAccessMode("Neo.ClientError.General.ForbiddenOnReadOnlyDatabase"); - } - - @Test - void shouldHandleClientException() { - var error = new ClientException("Neo.ClientError.Request.Invalid", "Hi"); - var errorHandler = mock(RoutingErrorHandler.class); - - var handledError = handle(error, errorHandler, AccessMode.READ); - - assertEquals(error, handledError); - verifyNoInteractions(errorHandler); - } - - @Test - public void shouldDelegateCanManageAutoRead() { - var responseHandler = mock(ResponseHandler.class); - var routingResponseHandler = new RoutingResponseHandler(responseHandler, LOCAL_DEFAULT, AccessMode.READ, null); - - routingResponseHandler.canManageAutoRead(); - - verify(responseHandler).canManageAutoRead(); - } - - @Test - public void shouldDelegateDisableAutoReadManagement() { - var responseHandler = mock(ResponseHandler.class); - var routingResponseHandler = new RoutingResponseHandler(responseHandler, LOCAL_DEFAULT, AccessMode.READ, null); - - routingResponseHandler.disableAutoReadManagement(); - - verify(responseHandler).disableAutoReadManagement(); - } - - private void testWriteFailureWithReadAccessMode(String code) { - var error = new ClientException(code, "Hi"); - var errorHandler = mock(RoutingErrorHandler.class); - - var handledError = handle(error, errorHandler, AccessMode.READ); - - assertThat(handledError, instanceOf(ClientException.class)); - assertEquals("Write queries cannot be performed in READ access mode.", handledError.getMessage()); - verifyNoInteractions(errorHandler); - } - - private void testWriteFailureWithWriteAccessMode(String code) { - var error = new ClientException(code, "Hi"); - var errorHandler = mock(RoutingErrorHandler.class); - - var handledError = handle(error, errorHandler, AccessMode.WRITE); - - assertThat(handledError, instanceOf(SessionExpiredException.class)); - assertEquals("Server at " + LOCAL_DEFAULT + " no longer accepts writes", handledError.getMessage()); - verify(errorHandler).onWriteFailure(LOCAL_DEFAULT); - } - - private static Throwable handle(Throwable error, RoutingErrorHandler errorHandler) { - return handle(error, errorHandler, AccessMode.READ); - } - - private static Throwable handle(Throwable error, RoutingErrorHandler errorHandler, AccessMode accessMode) { - var responseHandler = mock(ResponseHandler.class); - var routingResponseHandler = - new RoutingResponseHandler(responseHandler, LOCAL_DEFAULT, accessMode, errorHandler); - - routingResponseHandler.onFailure(error); - - var handledErrorCaptor = ArgumentCaptor.forClass(Throwable.class); - verify(responseHandler).onFailure(handledErrorCaptor.capture()); - return handledErrorCaptor.getValue(); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/RunResponseHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/RunResponseHandlerTest.java deleted file mode 100644 index 4fabc6c3ce..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/handlers/RunResponseHandlerTest.java +++ /dev/null @@ -1,219 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.Arrays.asList; -import static java.util.Collections.emptyList; -import static java.util.Collections.emptyMap; -import static java.util.Collections.singletonMap; -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.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.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -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.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.verify; -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.Values.values; -import static org.neo4j.driver.testutil.TestUtil.await; - -import java.util.HashMap; -import java.util.Map; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.ExecutionException; -import org.junit.jupiter.api.Test; -import org.neo4j.driver.exceptions.AuthorizationExpiredException; -import org.neo4j.driver.exceptions.ConnectionReadTimeoutException; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.util.MetadataExtractor; - -class RunResponseHandlerTest { - @Test - void shouldNotifyRunFutureOnSuccess() throws Exception { - var runFuture = new CompletableFuture(); - var handler = newHandler(runFuture); - - assertFalse(runFuture.isDone()); - handler.onSuccess(emptyMap()); - - assertTrue(runFuture.isDone()); - assertNull(runFuture.get()); - } - - @Test - void shouldNotifyRunFutureOnFailure() { - var runFuture = new CompletableFuture(); - var handler = newHandler(runFuture); - - assertFalse(runFuture.isDone()); - var exception = new RuntimeException(); - handler.onFailure(exception); - - assertTrue(runFuture.isCompletedExceptionally()); - var executionException = assertThrows(ExecutionException.class, runFuture::get); - assertThat(executionException.getCause(), equalTo(exception)); - } - - @Test - void shouldThrowOnRecord() { - var handler = newHandler(); - - assertThrows(UnsupportedOperationException.class, () -> handler.onRecord(values("a", "b", "c"))); - } - - @Test - void shouldReturnNoKeysWhenFailed() { - var handler = newHandler(); - - handler.onFailure(new RuntimeException()); - - assertEquals(emptyList(), handler.queryKeys().keys()); - assertEquals(emptyMap(), handler.queryKeys().keyIndex()); - } - - @Test - void shouldReturnDefaultResultAvailableAfterWhenFailed() { - var handler = newHandler(); - - handler.onFailure(new RuntimeException()); - - assertEquals(-1, handler.resultAvailableAfter()); - } - - @Test - void shouldReturnKeysWhenSucceeded() { - var handler = newHandler(); - - var keys = asList("key1", "key2", "key3"); - Map keyIndex = new HashMap<>(); - keyIndex.put("key1", 0); - keyIndex.put("key2", 1); - keyIndex.put("key3", 2); - handler.onSuccess(singletonMap("fields", value(keys))); - - assertEquals(keys, handler.queryKeys().keys()); - assertEquals(keyIndex, handler.queryKeys().keyIndex()); - } - - @Test - void shouldReturnResultAvailableAfterWhenSucceededV3() { - testResultAvailableAfterOnSuccess(); - } - - @Test - @SuppressWarnings("ThrowableNotThrown") - void shouldMarkTxAndKeepConnectionAndFailOnFailure() { - var runFuture = new CompletableFuture(); - var connection = mock(Connection.class); - var tx = mock(UnmanagedTransaction.class); - var handler = new RunResponseHandler(runFuture, BoltProtocolV3.METADATA_EXTRACTOR, connection, tx); - Throwable throwable = new RuntimeException(); - - assertFalse(runFuture.isDone()); - handler.onFailure(throwable); - - assertTrue(runFuture.isCompletedExceptionally()); - var actualException = assertThrows(Throwable.class, () -> await(runFuture)); - assertSame(throwable, actualException); - verify(tx).markTerminated(throwable); - verify(connection, never()).release(); - verify(connection, never()).terminateAndRelease(any(String.class)); - } - - @Test - void shouldNotReleaseConnectionAndFailOnFailure() { - var runFuture = new CompletableFuture(); - var connection = mock(Connection.class); - var handler = new RunResponseHandler(runFuture, BoltProtocolV3.METADATA_EXTRACTOR, connection, null); - Throwable throwable = new RuntimeException(); - - assertFalse(runFuture.isDone()); - handler.onFailure(throwable); - - assertTrue(runFuture.isCompletedExceptionally()); - var actualException = assertThrows(Throwable.class, () -> await(runFuture)); - assertSame(throwable, actualException); - verify(connection, never()).release(); - verify(connection, never()).terminateAndRelease(any(String.class)); - } - - @Test - void shouldReleaseConnectionImmediatelyAndFailOnAuthorizationExpiredExceptionFailure() { - var runFuture = new CompletableFuture(); - var connection = mock(Connection.class); - var handler = new RunResponseHandler(runFuture, BoltProtocolV3.METADATA_EXTRACTOR, connection, null); - var authorizationExpiredException = new AuthorizationExpiredException("code", "message"); - - assertFalse(runFuture.isDone()); - handler.onFailure(authorizationExpiredException); - - assertTrue(runFuture.isCompletedExceptionally()); - var actualException = assertThrows(AuthorizationExpiredException.class, () -> await(runFuture)); - assertSame(authorizationExpiredException, actualException); - verify(connection).terminateAndRelease(AuthorizationExpiredException.DESCRIPTION); - verify(connection, never()).release(); - } - - @Test - void shouldReleaseConnectionImmediatelyAndFailOnConnectionReadTimeoutExceptionFailure() { - var runFuture = new CompletableFuture(); - var connection = mock(Connection.class); - var handler = new RunResponseHandler(runFuture, BoltProtocolV3.METADATA_EXTRACTOR, connection, null); - - assertFalse(runFuture.isDone()); - handler.onFailure(ConnectionReadTimeoutException.INSTANCE); - - assertTrue(runFuture.isCompletedExceptionally()); - var actualException = assertThrows(ConnectionReadTimeoutException.class, () -> await(runFuture)); - assertSame(ConnectionReadTimeoutException.INSTANCE, actualException); - verify(connection).terminateAndRelease(ConnectionReadTimeoutException.INSTANCE.getMessage()); - verify(connection, never()).release(); - } - - private static void testResultAvailableAfterOnSuccess() { - var handler = newHandler(BoltProtocolV3.METADATA_EXTRACTOR); - - handler.onSuccess(singletonMap("t_first", value(42))); - - assertEquals(42L, handler.resultAvailableAfter()); - } - - private static RunResponseHandler newHandler() { - return newHandler(BoltProtocolV3.METADATA_EXTRACTOR); - } - - private static RunResponseHandler newHandler(CompletableFuture runFuture) { - return newHandler(runFuture, BoltProtocolV3.METADATA_EXTRACTOR); - } - - private static RunResponseHandler newHandler( - @SuppressWarnings("SameParameterValue") MetadataExtractor metadataExtractor) { - return newHandler(new CompletableFuture<>(), metadataExtractor); - } - - private static RunResponseHandler newHandler( - CompletableFuture runFuture, MetadataExtractor metadataExtractor) { - return new RunResponseHandler(runFuture, metadataExtractor, mock(Connection.class), null); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/SessionPullResponseCompletionListenerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/SessionPullResponseCompletionListenerTest.java deleted file mode 100644 index 653b997718..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/handlers/SessionPullResponseCompletionListenerTest.java +++ /dev/null @@ -1,126 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.Collections.emptyMap; -import static java.util.Collections.singletonMap; -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 java.util.concurrent.CompletableFuture; -import java.util.function.Consumer; -import org.junit.jupiter.api.Test; -import org.neo4j.driver.Query; -import org.neo4j.driver.exceptions.AuthorizationExpiredException; -import org.neo4j.driver.exceptions.ConnectionReadTimeoutException; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.handlers.pulln.BasicPullResponseHandler; -import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3; -import org.neo4j.driver.internal.messaging.v43.BoltProtocolV43; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; - -class SessionPullResponseCompletionListenerTest { - @Test - void shouldReleaseConnectionOnSuccess() { - var connection = newConnectionMock(); - PullResponseCompletionListener listener = - new SessionPullResponseCompletionListener(connection, (ignored) -> {}); - var handler = newHandler(connection, listener); - - handler.onSuccess(emptyMap()); - - verify(connection).release(); - } - - @Test - void shouldReleaseConnectionOnFailure() { - var connection = newConnectionMock(); - PullResponseCompletionListener listener = - new SessionPullResponseCompletionListener(connection, (ignored) -> {}); - var handler = newHandler(connection, listener); - - handler.onFailure(new RuntimeException()); - - verify(connection).release(); - } - - @Test - void shouldUpdateBookmarksOnSuccess() { - var connection = newConnectionMock(); - var bookmarkValue = "neo4j:bookmark:v1:tx42"; - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - PullResponseCompletionListener listener = - new SessionPullResponseCompletionListener(connection, bookmarkConsumer); - var handler = newHandler(connection, listener); - - handler.onSuccess(singletonMap("bookmark", value(bookmarkValue))); - - verify(bookmarkConsumer).accept(new DatabaseBookmark(null, InternalBookmark.parse(bookmarkValue))); - } - - @Test - void shouldReleaseConnectionImmediatelyOnAuthorizationExpiredExceptionFailure() { - var connection = newConnectionMock(); - PullResponseCompletionListener listener = - new SessionPullResponseCompletionListener(connection, (ignored) -> {}); - var handler = newHandler(connection, listener); - var exception = new AuthorizationExpiredException("code", "message"); - - handler.onFailure(exception); - - verify(connection).terminateAndRelease(AuthorizationExpiredException.DESCRIPTION); - verify(connection, never()).release(); - } - - @Test - void shouldReleaseConnectionImmediatelyOnConnectionReadTimeoutExceptionFailure() { - var connection = newConnectionMock(); - PullResponseCompletionListener listener = - new SessionPullResponseCompletionListener(connection, (ignored) -> {}); - var handler = newHandler(connection, listener); - - handler.onFailure(ConnectionReadTimeoutException.INSTANCE); - - verify(connection).terminateAndRelease(ConnectionReadTimeoutException.INSTANCE.getMessage()); - verify(connection, never()).release(); - } - - private static ResponseHandler newHandler(Connection connection, PullResponseCompletionListener listener) { - var runHandler = new RunResponseHandler( - new CompletableFuture<>(), BoltProtocolV3.METADATA_EXTRACTOR, mock(Connection.class), null); - var handler = new BasicPullResponseHandler( - new Query("RETURN 1"), runHandler, connection, BoltProtocolV3.METADATA_EXTRACTOR, listener); - handler.installRecordConsumer((record, throwable) -> {}); - handler.installSummaryConsumer((resultSummary, throwable) -> {}); - return handler; - } - - private static Connection newConnectionMock() { - var connection = mock(Connection.class); - when(connection.serverAddress()).thenReturn(BoltServerAddress.LOCAL_DEFAULT); - when(connection.protocol()).thenReturn(BoltProtocolV43.INSTANCE); - when(connection.serverAgent()).thenReturn("Neo4j/4.2.5"); - return connection; - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListenerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListenerTest.java deleted file mode 100644 index 1fc99d650f..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/handlers/TransactionPullResponseCompletionListenerTest.java +++ /dev/null @@ -1,74 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.internal.messaging.v3.BoltProtocolV3.METADATA_EXTRACTOR; - -import java.io.IOException; -import java.util.concurrent.CompletableFuture; -import org.junit.jupiter.api.Test; -import org.neo4j.driver.Query; -import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.exceptions.SessionExpiredException; -import org.neo4j.driver.exceptions.TransientException; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.handlers.pulln.BasicPullResponseHandler; -import org.neo4j.driver.internal.handlers.pulln.PullResponseHandler; -import org.neo4j.driver.internal.messaging.v43.BoltProtocolV43; -import org.neo4j.driver.internal.spi.Connection; - -class TransactionPullResponseCompletionListenerTest { - @Test - void shouldMarkTransactionAsTerminatedOnFailures() { - testErrorHandling(new ClientException("Neo.ClientError.Cluster.NotALeader", "")); - testErrorHandling(new ClientException("Neo.ClientError.Procedure.ProcedureCallFailed", "")); - testErrorHandling(new TransientException("Neo.TransientError.Transaction.Terminated", "")); - testErrorHandling(new TransientException("Neo.TransientError.General.DatabaseUnavailable", "")); - - testErrorHandling(new RuntimeException()); - testErrorHandling(new IOException()); - testErrorHandling(new ServiceUnavailableException("")); - testErrorHandling(new SessionExpiredException("")); - testErrorHandling(new SessionExpiredException("")); - testErrorHandling(new ClientException("Neo.ClientError.Request.Invalid")); - } - - @SuppressWarnings("ThrowableNotThrown") - private static void testErrorHandling(Throwable error) { - var connection = mock(Connection.class); - when(connection.serverAddress()).thenReturn(BoltServerAddress.LOCAL_DEFAULT); - when(connection.protocol()).thenReturn(BoltProtocolV43.INSTANCE); - when(connection.serverAgent()).thenReturn("Neo4j/4.2.5"); - var tx = mock(UnmanagedTransaction.class); - when(tx.isOpen()).thenReturn(true); - var listener = new TransactionPullResponseCompletionListener(tx); - var runHandler = new RunResponseHandler(new CompletableFuture<>(), METADATA_EXTRACTOR, null, null); - PullResponseHandler handler = new BasicPullResponseHandler( - new Query("RETURN 1"), runHandler, connection, METADATA_EXTRACTOR, listener); - handler.installRecordConsumer((record, throwable) -> {}); - handler.installSummaryConsumer((resultSummary, throwable) -> {}); - - handler.onFailure(error); - - verify(tx).markTerminated(error); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/AutoPullResponseHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/AutoPullResponseHandlerTest.java deleted file mode 100644 index 96c24911e9..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/AutoPullResponseHandlerTest.java +++ /dev/null @@ -1,192 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.pulln; - -import static java.util.Collections.emptyMap; -import static java.util.Collections.singletonMap; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.Values.values; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.DEFAULT_FETCH_SIZE; - -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.concurrent.CompletableFuture; -import org.junit.jupiter.api.Test; -import org.mockito.Mockito; -import org.neo4j.driver.Query; -import org.neo4j.driver.Value; -import org.neo4j.driver.internal.handlers.PullAllResponseHandlerTestBase; -import org.neo4j.driver.internal.handlers.PullResponseCompletionListener; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.v3.BoltProtocolV3; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.value.BooleanValue; - -class AutoPullResponseHandlerTest extends PullAllResponseHandlerTestBase { - @Override - protected AutoPullResponseHandler newHandler(Query query, List queryKeys, Connection connection) { - var runResponseHandler = new RunResponseHandler( - new CompletableFuture<>(), BoltProtocolV3.METADATA_EXTRACTOR, mock(Connection.class), null); - runResponseHandler.onSuccess(singletonMap("fields", value(queryKeys))); - var handler = new AutoPullResponseHandler( - query, - runResponseHandler, - connection, - BoltProtocolV3.METADATA_EXTRACTOR, - mock(PullResponseCompletionListener.class), - DEFAULT_FETCH_SIZE); - handler.prePopulateRecords(); - return handler; - } - - protected AutoPullResponseHandler newHandler(Query query, Connection connection, long fetchSize) { - var runResponseHandler = new RunResponseHandler( - new CompletableFuture<>(), BoltProtocolV3.METADATA_EXTRACTOR, mock(Connection.class), null); - runResponseHandler.onSuccess(emptyMap()); - var handler = new AutoPullResponseHandler( - query, - runResponseHandler, - connection, - BoltProtocolV3.METADATA_EXTRACTOR, - mock(PullResponseCompletionListener.class), - fetchSize); - handler.prePopulateRecords(); - return handler; - } - - @Test - void shouldKeepRequestingWhenBetweenRange() { - var connection = connectionMock(); - var inOrder = Mockito.inOrder(connection); - - // highwatermark=2, lowwatermark=1 - var handler = newHandler(new Query("RETURN 1"), connection, 4); - - Map metaData = new HashMap<>(1); - metaData.put("has_more", BooleanValue.TRUE); - - inOrder.verify(connection).writeAndFlush(any(PullMessage.class), any()); - - handler.onRecord(values(1)); - handler.onRecord(values(2)); - handler.onSuccess(metaData); // 2 in the record queue - - // should send another pulln request since maxValue not met - inOrder.verify(connection).writeAndFlush(any(), any()); - } - - @Test - void shouldStopRequestingWhenOverMaxWatermark() { - var connection = connectionMock(); - var inOrder = Mockito.inOrder(connection); - - // highWatermark=2, lowWatermark=1 - var handler = newHandler(new Query("RETURN 1"), connection, 4); - - Map metaData = new HashMap<>(1); - metaData.put("has_more", BooleanValue.TRUE); - - inOrder.verify(connection).writeAndFlush(any(PullMessage.class), any()); - - handler.onRecord(values(1)); - handler.onRecord(values(2)); - handler.onRecord(values(3)); - handler.onSuccess(metaData); - - // only initial writeAndFlush() - verify(connection, times(1)).writeAndFlush(any(PullMessage.class), any()); - } - - @Test - void shouldRestartRequestingWhenMinimumWatermarkMet() { - var connection = connectionMock(); - var inOrder = Mockito.inOrder(connection); - - // highwatermark=4, lowwatermark=2 - var handler = newHandler(new Query("RETURN 1"), connection, 7); - - Map metaData = new HashMap<>(1); - metaData.put("has_more", BooleanValue.TRUE); - - inOrder.verify(connection).writeAndFlush(any(PullMessage.class), any()); - - handler.onRecord(values(1)); - handler.onRecord(values(2)); - handler.onRecord(values(3)); - handler.onRecord(values(4)); - handler.onRecord(values(5)); - handler.onSuccess(metaData); - - verify(connection, times(1)).writeAndFlush(any(PullMessage.class), any()); - - handler.nextAsync(); - handler.nextAsync(); - handler.nextAsync(); - - inOrder.verify(connection).writeAndFlush(any(PullMessage.class), any()); - } - - @Test - void shouldKeepRequestingMoreRecordsWhenPullAll() { - var connection = connectionMock(); - var handler = newHandler(new Query("RETURN 1"), connection, -1); - - Map metaData = new HashMap<>(1); - metaData.put("has_more", BooleanValue.TRUE); - - handler.onRecord(values(1)); - handler.onSuccess(metaData); - - handler.onRecord(values(2)); - handler.onSuccess(metaData); - - handler.onRecord(values(3)); - handler.onSuccess(emptyMap()); - - verify(connection, times(3)).writeAndFlush(any(PullMessage.class), any()); - } - - @Test - void shouldFunctionWhenHighAndLowWatermarksAreEqual() { - var connection = connectionMock(); - var inOrder = Mockito.inOrder(connection); - - // highwatermark=0, lowwatermark=0 - var handler = newHandler(new Query("RETURN 1"), connection, 1); - - Map metaData = new HashMap<>(1); - metaData.put("has_more", BooleanValue.TRUE); - - inOrder.verify(connection).writeAndFlush(any(PullMessage.class), any()); - - handler.onRecord(values(1)); - handler.onSuccess(metaData); - - inOrder.verify(connection, never()).writeAndFlush(any(), any()); - - handler.nextAsync(); - - inOrder.verify(connection).writeAndFlush(any(PullMessage.class), any()); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/BasicPullResponseHandlerTestBase.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/BasicPullResponseHandlerTestBase.java deleted file mode 100644 index dd8eced30e..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/BasicPullResponseHandlerTestBase.java +++ /dev/null @@ -1,269 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.pulln; - -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoMoreInteractions; -import static org.mockito.Mockito.when; - -import java.util.HashMap; -import java.util.function.BiConsumer; -import java.util.stream.Stream; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.MethodSource; -import org.neo4j.driver.Record; -import org.neo4j.driver.Value; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.messaging.request.DiscardMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.v43.BoltProtocolV43; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.value.BooleanValue; -import org.neo4j.driver.summary.ResultSummary; - -abstract class BasicPullResponseHandlerTestBase { - protected abstract void shouldHandleSuccessWithSummary(BasicPullResponseHandler.State state); - - protected abstract void shouldHandleFailure(BasicPullResponseHandler.State state); - - protected abstract BasicPullResponseHandler newResponseHandlerWithStatus( - Connection conn, - BiConsumer recordConsumer, - BiConsumer summaryConsumer, - BasicPullResponseHandler.State state); - - // on success with summary - @ParameterizedTest - @MethodSource("allStatus") - void shouldSuccessWithSummary(BasicPullResponseHandler.State state) { - shouldHandleSuccessWithSummary(state); - } - - // on success with has_more - @Test - void shouldRequestMoreWithHasMore() { - // Given a handler in streaming state - var conn = mockConnection(); - var handler = newResponseHandlerWithStatus(conn, BasicPullResponseHandler.State.STREAMING_STATE); - - // When - handler.request(100); // I append a request to ask for more - - handler.onSuccess(metaWithHasMoreEqualsTrue()); - - // Then - verify(conn).writeAndFlush(any(PullMessage.class), eq(handler)); - assertThat(handler.state(), equalTo(BasicPullResponseHandler.State.STREAMING_STATE)); - } - - @Test - void shouldInformSummaryConsumerSuccessWithHasMore() { - // Given - var conn = mockConnection(); - @SuppressWarnings("unchecked") - BiConsumer recordConsumer = mock(BiConsumer.class); - @SuppressWarnings("unchecked") - BiConsumer summaryConsumer = mock(BiConsumer.class); - var handler = newResponseHandlerWithStatus( - conn, recordConsumer, summaryConsumer, BasicPullResponseHandler.State.STREAMING_STATE); - // When - - handler.onSuccess(metaWithHasMoreEqualsTrue()); - - // Then - verifyNoMoreInteractions(conn); - verifyNoMoreInteractions(recordConsumer); - verify(summaryConsumer).accept(null, null); - assertThat(handler.state(), equalTo(BasicPullResponseHandler.State.READY_STATE)); - } - - @Test - void shouldDiscardIfStreamingIsCanceled() { - // Given a handler in streaming state - var conn = mockConnection(); - var handler = newResponseHandlerWithStatus(conn, BasicPullResponseHandler.State.CANCELLED_STATE); - handler.onSuccess(metaWithHasMoreEqualsTrue()); - - // Then - verify(conn).writeAndFlush(any(DiscardMessage.class), eq(handler)); - assertThat(handler.state(), equalTo(BasicPullResponseHandler.State.CANCELLED_STATE)); - } - - // on failure - @ParameterizedTest - @MethodSource("allStatus") - void shouldErrorToRecordAndSummaryConsumer(BasicPullResponseHandler.State state) { - shouldHandleFailure(state); - } - - // on record - @Test - void shouldReportRecordInStreaming() { - // Given a handler in streaming state - var conn = mockConnection(); - @SuppressWarnings("unchecked") - BiConsumer recordConsumer = mock(BiConsumer.class); - @SuppressWarnings("unchecked") - BiConsumer summaryConsumer = mock(BiConsumer.class); - var handler = newResponseHandlerWithStatus( - conn, recordConsumer, summaryConsumer, BasicPullResponseHandler.State.STREAMING_STATE); - - // When - handler.onRecord(new Value[0]); - - // Then - verify(recordConsumer).accept(any(Record.class), eq(null)); - verifyNoMoreInteractions(summaryConsumer); - verifyNoMoreInteractions(conn); - assertThat(handler.state(), equalTo(BasicPullResponseHandler.State.STREAMING_STATE)); - } - - @ParameterizedTest - @MethodSource("allStatusExceptStreaming") - void shouldNotReportRecordWhenNotStreaming(BasicPullResponseHandler.State state) { - // Given a handler in streaming state - var conn = mockConnection(); - @SuppressWarnings("unchecked") - BiConsumer recordConsumer = mock(BiConsumer.class); - @SuppressWarnings("unchecked") - BiConsumer summaryConsumer = mock(BiConsumer.class); - var handler = newResponseHandlerWithStatus(conn, recordConsumer, summaryConsumer, state); - - // When - handler.onRecord(new Value[0]); - - // Then - verifyNoMoreInteractions(recordConsumer); - verifyNoMoreInteractions(summaryConsumer); - assertThat(handler.state(), equalTo(state)); - } - - // request - @Test - void shouldStayInStreaming() { - // Given - var conn = mockConnection(); - var handler = newResponseHandlerWithStatus(conn, BasicPullResponseHandler.State.STREAMING_STATE); - - // When - handler.request(100); - - // Then - assertThat(handler.state(), equalTo(BasicPullResponseHandler.State.STREAMING_STATE)); - } - - @Test - void shouldPullAndSwitchStreamingInReady() { - // Given - var conn = mockConnection(); - var handler = newResponseHandlerWithStatus(conn, BasicPullResponseHandler.State.READY_STATE); - - // When - handler.request(100); - - // Then - verify(conn).writeAndFlush(any(PullMessage.class), eq(handler)); - assertThat(handler.state(), equalTo(BasicPullResponseHandler.State.STREAMING_STATE)); - } - - // cancel - @Test - void shouldStayInCancel() { - // Given - var conn = mockConnection(); - var handler = newResponseHandlerWithStatus(conn, BasicPullResponseHandler.State.CANCELLED_STATE); - - // When - handler.cancel(); - - // Then - verifyNoMoreInteractions(conn); - assertThat(handler.state(), equalTo(BasicPullResponseHandler.State.CANCELLED_STATE)); - } - - @Test - void shouldSwitchFromStreamingToCancel() { - // Given - var conn = mockConnection(); - var handler = newResponseHandlerWithStatus(conn, BasicPullResponseHandler.State.STREAMING_STATE); - - // When - handler.cancel(); - - // Then - verifyNoMoreInteractions(conn); - assertThat(handler.state(), equalTo(BasicPullResponseHandler.State.CANCELLED_STATE)); - } - - @Test - void shouldSwitchFromReadyToCancel() { - // Given - var conn = mockConnection(); - var handler = newResponseHandlerWithStatus(conn, BasicPullResponseHandler.State.READY_STATE); - - // When - handler.cancel(); - - // Then - verify(conn).writeAndFlush(any(DiscardMessage.class), eq(handler)); - assertThat(handler.state(), equalTo(BasicPullResponseHandler.State.CANCELLED_STATE)); - } - - static Connection mockConnection() { - var conn = mock(Connection.class); - when(conn.serverAddress()).thenReturn(mock(BoltServerAddress.class)); - when(conn.protocol()).thenReturn(BoltProtocolV43.INSTANCE); - when(conn.serverAgent()).thenReturn("Neo4j/4.2.5"); - return conn; - } - - private BasicPullResponseHandler newResponseHandlerWithStatus( - Connection conn, BasicPullResponseHandler.State state) { - @SuppressWarnings("unchecked") - BiConsumer recordConsumer = mock(BiConsumer.class); - @SuppressWarnings("unchecked") - BiConsumer summaryConsumer = mock(BiConsumer.class); - return newResponseHandlerWithStatus(conn, recordConsumer, summaryConsumer, state); - } - - private static HashMap metaWithHasMoreEqualsTrue() { - var meta = new HashMap(1); - meta.put("has_more", BooleanValue.TRUE); - return meta; - } - - private static Stream allStatusExceptStreaming() { - return Stream.of( - BasicPullResponseHandler.State.SUCCEEDED_STATE, BasicPullResponseHandler.State.FAILURE_STATE, - BasicPullResponseHandler.State.CANCELLED_STATE, BasicPullResponseHandler.State.READY_STATE); - } - - private static Stream allStatus() { - return Stream.of( - BasicPullResponseHandler.State.SUCCEEDED_STATE, - BasicPullResponseHandler.State.FAILURE_STATE, - BasicPullResponseHandler.State.CANCELLED_STATE, - BasicPullResponseHandler.State.READY_STATE, - BasicPullResponseHandler.State.STREAMING_STATE); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/SessionPullResponseCompletionListenerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/SessionPullResponseCompletionListenerTest.java deleted file mode 100644 index 66eb4441d5..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/SessionPullResponseCompletionListenerTest.java +++ /dev/null @@ -1,108 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.pulln; - -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; - -import java.util.Collections; -import java.util.function.BiConsumer; -import java.util.function.Consumer; -import org.neo4j.driver.Query; -import org.neo4j.driver.Record; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.handlers.SessionPullResponseCompletionListener; -import org.neo4j.driver.internal.messaging.v4.BoltProtocolV4; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.summary.ResultSummary; - -class SessionPullResponseCompletionListenerTest extends BasicPullResponseHandlerTestBase { - protected void shouldHandleSuccessWithSummary(BasicPullResponseHandler.State state) { - // Given - var conn = mockConnection(); - @SuppressWarnings("unchecked") - BiConsumer recordConsumer = mock(BiConsumer.class); - @SuppressWarnings("unchecked") - BiConsumer summaryConsumer = mock(BiConsumer.class); - @SuppressWarnings("unchecked") - Consumer bookmarksConsumer = mock(Consumer.class); - PullResponseHandler handler = - newSessionResponseHandler(conn, recordConsumer, summaryConsumer, bookmarksConsumer, state); - - // When - handler.onSuccess(Collections.emptyMap()); - - // Then - verify(conn).release(); - verify(bookmarksConsumer).accept(any()); - verify(recordConsumer).accept(null, null); - verify(summaryConsumer).accept(any(ResultSummary.class), eq(null)); - } - - @Override - protected void shouldHandleFailure(BasicPullResponseHandler.State state) { - // Given - var conn = mockConnection(); - @SuppressWarnings("unchecked") - BiConsumer recordConsumer = mock(BiConsumer.class); - @SuppressWarnings("unchecked") - BiConsumer summaryConsumer = mock(BiConsumer.class); - var handler = newResponseHandlerWithStatus(conn, recordConsumer, summaryConsumer, state); - - // When - var error = new RuntimeException("I am an error"); - handler.onFailure(error); - - // Then - assertThat(handler.state(), equalTo(BasicPullResponseHandler.State.FAILURE_STATE)); - verify(conn).release(); - verify(recordConsumer).accept(null, error); - verify(summaryConsumer).accept(any(ResultSummary.class), eq(error)); - } - - @Override - protected BasicPullResponseHandler newResponseHandlerWithStatus( - Connection conn, - BiConsumer recordConsumer, - BiConsumer summaryConsumer, - BasicPullResponseHandler.State state) { - return newSessionResponseHandler(conn, recordConsumer, summaryConsumer, (ignored) -> {}, state); - } - - private static BasicPullResponseHandler newSessionResponseHandler( - Connection conn, - BiConsumer recordConsumer, - BiConsumer summaryConsumer, - Consumer bookmarkConsumer, - BasicPullResponseHandler.State state) { - var runHandler = mock(RunResponseHandler.class); - var listener = new SessionPullResponseCompletionListener(conn, bookmarkConsumer); - var handler = new BasicPullResponseHandler( - mock(Query.class), runHandler, conn, BoltProtocolV4.METADATA_EXTRACTOR, listener); - - handler.installRecordConsumer(recordConsumer); - handler.installSummaryConsumer(summaryConsumer); - - handler.state(state); - return handler; - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/TransactionPullResponseCompletionListenerTest.java b/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/TransactionPullResponseCompletionListenerTest.java deleted file mode 100644 index 862a559558..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/handlers/pulln/TransactionPullResponseCompletionListenerTest.java +++ /dev/null @@ -1,109 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.pulln; - -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -import java.util.Collections; -import java.util.function.BiConsumer; -import org.neo4j.driver.Query; -import org.neo4j.driver.Record; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.handlers.TransactionPullResponseCompletionListener; -import org.neo4j.driver.internal.messaging.v4.BoltProtocolV4; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.summary.ResultSummary; - -public class TransactionPullResponseCompletionListenerTest extends BasicPullResponseHandlerTestBase { - @Override - protected void shouldHandleSuccessWithSummary(BasicPullResponseHandler.State state) { - // Given - var conn = mockConnection(); - @SuppressWarnings("unchecked") - BiConsumer recordConsumer = mock(BiConsumer.class); - @SuppressWarnings("unchecked") - BiConsumer summaryConsumer = mock(BiConsumer.class); - var handler = newResponseHandlerWithStatus(conn, recordConsumer, summaryConsumer, state); - - // When - handler.onSuccess(Collections.emptyMap()); - - // Then - assertThat(handler.state(), equalTo(BasicPullResponseHandler.State.SUCCEEDED_STATE)); - verify(recordConsumer).accept(null, null); - verify(summaryConsumer).accept(any(ResultSummary.class), eq(null)); - } - - @Override - @SuppressWarnings("ThrowableNotThrown") - protected void shouldHandleFailure(BasicPullResponseHandler.State state) { - // Given - var conn = mockConnection(); - @SuppressWarnings("unchecked") - BiConsumer recordConsumer = mock(BiConsumer.class); - @SuppressWarnings("unchecked") - BiConsumer summaryConsumer = mock(BiConsumer.class); - var tx = mock(UnmanagedTransaction.class); - when(tx.isOpen()).thenReturn(true); - var handler = newTxResponseHandler(conn, recordConsumer, summaryConsumer, tx, state); - - // When - var error = new RuntimeException("I am an error"); - handler.onFailure(error); - - // Then - assertThat(handler.state(), equalTo(BasicPullResponseHandler.State.FAILURE_STATE)); - verify(tx).markTerminated(error); - verify(recordConsumer).accept(null, error); - verify(summaryConsumer).accept(any(ResultSummary.class), eq(error)); - } - - @Override - protected BasicPullResponseHandler newResponseHandlerWithStatus( - Connection conn, - BiConsumer recordConsumer, - BiConsumer summaryConsumer, - BasicPullResponseHandler.State state) { - var tx = mock(UnmanagedTransaction.class); - return newTxResponseHandler(conn, recordConsumer, summaryConsumer, tx, state); - } - - private static BasicPullResponseHandler newTxResponseHandler( - Connection conn, - BiConsumer recordConsumer, - BiConsumer summaryConsumer, - UnmanagedTransaction tx, - BasicPullResponseHandler.State state) { - var runHandler = mock(RunResponseHandler.class); - var listener = new TransactionPullResponseCompletionListener(tx); - var handler = new BasicPullResponseHandler( - mock(Query.class), runHandler, conn, BoltProtocolV4.METADATA_EXTRACTOR, listener); - - handler.installRecordConsumer(recordConsumer); - handler.installSummaryConsumer(summaryConsumer); - - handler.state(state); - return handler; - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/MessageFormatTest.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/MessageFormatTest.java deleted file mode 100644 index 27bfb2ad6a..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/MessageFormatTest.java +++ /dev/null @@ -1,178 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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; - -import static java.util.Arrays.asList; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.startsWith; -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.neo4j.driver.Values.parameters; -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.messageDispatcher; -import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setMessageDispatcher; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; -import static org.neo4j.driver.internal.util.ValueFactory.emptyNodeValue; -import static org.neo4j.driver.internal.util.ValueFactory.emptyPathValue; -import static org.neo4j.driver.internal.util.ValueFactory.emptyRelationshipValue; -import static org.neo4j.driver.internal.util.ValueFactory.filledNodeValue; -import static org.neo4j.driver.internal.util.ValueFactory.filledPathValue; -import static org.neo4j.driver.internal.util.ValueFactory.filledRelationshipValue; - -import io.netty.buffer.ByteBuf; -import io.netty.buffer.Unpooled; -import io.netty.channel.embedded.EmbeddedChannel; -import java.util.HashMap; -import org.junit.jupiter.api.Test; -import org.neo4j.driver.Value; -import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.internal.async.connection.BoltProtocolUtil; -import org.neo4j.driver.internal.async.connection.ChannelPipelineBuilderImpl; -import org.neo4j.driver.internal.async.outbound.ChunkAwareByteBufOutput; -import org.neo4j.driver.internal.messaging.common.CommonValueUnpacker; -import org.neo4j.driver.internal.messaging.response.FailureMessage; -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.messaging.v3.MessageFormatV3; -import org.neo4j.driver.internal.packstream.PackStream; -import org.neo4j.driver.internal.util.messaging.KnowledgeableMessageFormat; -import org.neo4j.driver.internal.util.messaging.MemorizingInboundMessageDispatcher; - -class MessageFormatTest { - public final MessageFormat format = new MessageFormatV3(); - - @Test - void shouldUnpackAllResponses() throws Throwable { - assertSerializes(new FailureMessage("Hello", "World!")); - assertSerializes(IgnoredMessage.IGNORED); - assertSerializes(new RecordMessage(new Value[] {value(1337L)})); - assertSerializes(new SuccessMessage(new HashMap<>())); - } - - @Test - void shouldPackUnpackValidValues() throws Throwable { - assertSerializesValue(value(parameters("cat", null, "dog", null))); - assertSerializesValue(value(parameters("k", 12, "a", "banana"))); - assertSerializesValue(value(asList("k", 12, "a", "banana"))); - } - - @Test - void shouldUnpackNodeRelationshipAndPath() throws Throwable { - // Given - assertOnlyDeserializesValue(emptyNodeValue()); - assertOnlyDeserializesValue(filledNodeValue()); - assertOnlyDeserializesValue(emptyRelationshipValue()); - assertOnlyDeserializesValue(filledRelationshipValue()); - assertOnlyDeserializesValue(emptyPathValue()); - assertOnlyDeserializesValue(filledPathValue()); - } - - @Test - void shouldGiveHelpfulErrorOnMalformedNodeStruct() throws Throwable { - // Given - var output = new ChunkAwareByteBufOutput(); - var buf = Unpooled.buffer(); - output.start(buf); - var packer = new PackStream.Packer(output); - - packer.packStructHeader(1, RecordMessage.SIGNATURE); - packer.packListHeader(1); - packer.packStructHeader(0, CommonValueUnpacker.NODE); - - output.stop(); - BoltProtocolUtil.writeMessageBoundary(buf); - - // Expect - var error = assertThrows(ClientException.class, () -> unpack(buf, newEmbeddedChannel())); - assertThat( - error.getMessage(), - startsWith("Invalid message received, serialized NODE structures should have 3 fields, " - + "received NODE structure has 0 fields.")); - } - - private void assertSerializesValue(Value value) throws Throwable { - assertSerializes(new RecordMessage(new Value[] {value})); - } - - private void assertSerializes(Message message) throws Throwable { - var channel = newEmbeddedChannel(new KnowledgeableMessageFormat(false)); - - var packed = pack(message, channel); - var unpackedMessage = unpack(packed, channel); - - assertEquals(message, unpackedMessage); - } - - private EmbeddedChannel newEmbeddedChannel() { - return newEmbeddedChannel(format); - } - - private EmbeddedChannel newEmbeddedChannel(MessageFormat format) { - var channel = new EmbeddedChannel(); - setMessageDispatcher(channel, new MemorizingInboundMessageDispatcher(channel, DEV_NULL_LOGGING)); - new ChannelPipelineBuilderImpl().build(format, channel.pipeline(), DEV_NULL_LOGGING); - return channel; - } - - private ByteBuf pack(Message message, EmbeddedChannel channel) { - assertTrue(channel.writeOutbound(message)); - - var packedMessages = - channel.outboundMessages().stream().map(msg -> (ByteBuf) msg).toArray(ByteBuf[]::new); - - return Unpooled.wrappedBuffer(packedMessages); - } - - private Message unpack(ByteBuf packed, EmbeddedChannel channel) throws Throwable { - channel.writeInbound(packed); - - var dispatcher = messageDispatcher(channel); - var memorizingDispatcher = ((MemorizingInboundMessageDispatcher) dispatcher); - - var error = memorizingDispatcher.currentError(); - if (error != null) { - throw error; - } - - var unpackedMessages = memorizingDispatcher.messages(); - - assertEquals(1, unpackedMessages.size()); - return unpackedMessages.get(0); - } - - private void assertOnlyDeserializesValue(Value value) throws Throwable { - var message = new RecordMessage(new Value[] {value}); - var packed = knowledgeablePack(message); - - var channel = newEmbeddedChannel(); - var unpackedMessage = unpack(packed, channel); - - assertEquals(message, unpackedMessage); - } - - private ByteBuf knowledgeablePack(Message message) { - var channel = newEmbeddedChannel(new KnowledgeableMessageFormat(false)); - assertTrue(channel.writeOutbound(message)); - - var packedMessages = - channel.outboundMessages().stream().map(msg -> (ByteBuf) msg).toArray(ByteBuf[]::new); - - return Unpooled.wrappedBuffer(packedMessages); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java deleted file mode 100644 index 65fb78c6ab..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v3/BoltProtocolV3Test.java +++ /dev/null @@ -1,601 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v3; - -import static java.time.Duration.ofSeconds; -import static java.util.Collections.emptyMap; -import static java.util.Collections.singletonMap; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.hasSize; -import static org.hamcrest.Matchers.instanceOf; -import static org.hamcrest.Matchers.startsWith; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -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.ArgumentMatchers.eq; -import static org.mockito.BDDMockito.then; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.AccessMode.WRITE; -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE; -import static org.neo4j.driver.testutil.TestUtil.await; -import static org.neo4j.driver.testutil.TestUtil.connectionMock; - -import io.netty.channel.embedded.EmbeddedChannel; -import java.time.Clock; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CompletionStage; -import java.util.function.Consumer; -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.EnumSource; -import org.mockito.ArgumentCaptor; -import org.mockito.Mockito; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.AuthTokens; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.TransactionConfig; -import org.neo4j.driver.Value; -import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; -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.cursor.AsyncResultCursor; -import org.neo4j.driver.internal.handlers.BeginTxResponseHandler; -import org.neo4j.driver.internal.handlers.CommitTxResponseHandler; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.RollbackTxResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -import org.neo4j.driver.internal.messaging.request.GoodbyeMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.messaging.request.PullAllMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; - -public class BoltProtocolV3Test { - protected static final String QUERY_TEXT = "RETURN $x"; - protected static final Map PARAMS = singletonMap("x", value(42)); - protected static final Query QUERY = new Query(QUERY_TEXT, value(PARAMS)); - - protected final BoltProtocol protocol = createProtocol(); - private final EmbeddedChannel channel = new EmbeddedChannel(); - private final InboundMessageDispatcher messageDispatcher = new InboundMessageDispatcher(channel, Logging.none()); - - private final TransactionConfig txConfig = TransactionConfig.builder() - .withTimeout(ofSeconds(12)) - .withMetadata(singletonMap("key", value(42))) - .build(); - - @BeforeEach - void beforeEach() { - ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); - } - - @AfterEach - void afterEach() { - channel.finishAndReleaseAll(); - } - - @SuppressWarnings("SameReturnValue") - protected BoltProtocol createProtocol() { - return BoltProtocolV3.INSTANCE; - } - - protected Class expectedMessageFormatType() { - return MessageFormatV3.class; - } - - @Test - void shouldCreateMessageFormat() { - assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); - } - - @Test - void shouldInitializeChannel() { - var promise = channel.newPromise(); - var clock = mock(Clock.class); - var time = 1L; - when(clock.millis()).thenReturn(time); - var authContext = mock(AuthContext.class); - when(authContext.getAuthToken()).thenReturn(dummyAuthToken()); - ChannelAttributes.setAuthContext(channel, authContext); - - protocol.initializeChannel( - "MyDriver/0.0.1", null, dummyAuthToken(), RoutingContext.EMPTY, promise, null, clock); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertFalse(promise.isDone()); - - Map metadata = new HashMap<>(); - metadata.put("server", value("Neo4j/3.5.0")); - metadata.put("connection_id", value("bolt-42")); - - messageDispatcher.handleSuccessMessage(metadata); - - assertTrue(promise.isDone()); - assertTrue(promise.isSuccess()); - verify(clock).millis(); - verify(authContext).finishAuth(time); - } - - @Test - void shouldPrepareToCloseChannel() { - protocol.prepareToCloseChannel(channel); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(GoodbyeMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - } - - @Test - void shouldFailToInitializeChannelWhenErrorIsReceived() { - var promise = channel.newPromise(); - - protocol.initializeChannel( - "MyDriver/2.2.1", null, dummyAuthToken(), RoutingContext.EMPTY, promise, null, mock(Clock.class)); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertFalse(promise.isDone()); - - messageDispatcher.handleFailureMessage("Neo.TransientError.General.DatabaseUnavailable", "Error!"); - - assertTrue(promise.isDone()); - assertFalse(promise.isSuccess()); - } - - @Test - void shouldBeginTransactionWithoutBookmark() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarks() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx100")); - - var stage = protocol.beginTransaction( - connection, bookmarks, TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithConfig() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - txConfig, - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarksAndConfig() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx4242")); - - var stage = protocol.beginTransaction(connection, bookmarks, txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, txConfig, defaultDatabase(), WRITE, null, null, null, Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldCommitTransaction() { - var bookmarkString = "neo4j:bookmark:v1:tx4242"; - - var connection = connectionMock(protocol); - when(connection.protocol()).thenReturn(protocol); - doAnswer(invocation -> { - ResponseHandler commitHandler = invocation.getArgument(1); - commitHandler.onSuccess(singletonMap("bookmark", value(bookmarkString))); - return null; - }) - .when(connection) - .writeAndFlush(eq(CommitMessage.COMMIT), any()); - - var stage = protocol.commitTransaction(connection); - - verify(connection).writeAndFlush(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); - assertEquals(InternalBookmark.parse(bookmarkString), await(stage).bookmark()); - } - - @Test - void shouldRollbackTransaction() { - var connection = connectionMock(protocol); - - var stage = protocol.rollbackTransaction(connection); - - verify(connection).writeAndFlush(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); - assertNull(await(stage)); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) - throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx65")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx163")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(false, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(true, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(false, mode); - } - - @Test - void databaseNameInBeginTransaction() { - testDatabaseNameSupport(false); - } - - @Test - void databaseNameForAutoCommitTransactions() { - testDatabaseNameSupport(true); - } - - @Test - void shouldNotSupportDatabaseNameInBeginTransaction() { - var txStage = protocol.beginTransaction( - connectionMock("foo", protocol), - Collections.emptySet(), - TransactionConfig.empty(), - null, - null, - Logging.none(), - true); - - var e = assertThrows(ClientException.class, () -> await(txStage)); - assertThat(e.getMessage(), startsWith("Database name parameter for selecting database is not supported")); - } - - @Test - void shouldNotSupportDatabaseNameForAutoCommitTransactions() { - var e = assertThrows( - ClientException.class, - () -> protocol.runInAutoCommitTransaction( - connectionMock("foo", protocol), - new Query("RETURN 1"), - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none())); - assertThat(e.getMessage(), startsWith("Database name parameter for selecting database is not supported")); - } - - @Test - void shouldTelemetryReturnCompletedStageWithoutSendAnyMessage() { - var connection = connectionMock(); - - await(protocol.telemetry(connection, 1)); - - verify(connection, never()).write(Mockito.any(), Mockito.any()); - verify(connection, never()).writeAndFlush(Mockito.any(), Mockito.any()); - } - - protected void testDatabaseNameSupport(boolean autoCommitTx) { - ClientException e; - if (autoCommitTx) { - e = assertThrows( - ClientException.class, - () -> protocol.runInAutoCommitTransaction( - connectionMock("foo", protocol), - new Query("RETURN 1"), - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none())); - } else { - var txStage = protocol.beginTransaction( - connectionMock("foo", protocol), - Collections.emptySet(), - TransactionConfig.empty(), - null, - null, - Logging.none(), - true); - e = assertThrows(ClientException.class, () -> await(txStage)); - } - - assertThat(e.getMessage(), startsWith("Database name parameter for selecting database is not supported")); - } - - protected void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success, AccessMode mode) - throws Exception { - // Given - var connection = connectionMock(mode, protocol); - - var cursorFuture = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult() - .toCompletableFuture(); - - var runResponseHandler = - verifyRunInvoked(connection, false, Collections.emptySet(), TransactionConfig.empty(), mode).runHandler; - assertFalse(cursorFuture.isDone()); - Throwable error = new RuntimeException(); - - if (success) { - runResponseHandler.onSuccess(emptyMap()); - } else { - // When responded with a failure - runResponseHandler.onFailure(error); - } - - // Then - assertTrue(cursorFuture.isDone()); - if (success) { - assertNotNull(await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - } else { - var actual = assertThrows( - error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - } - - protected void testRunAndWaitForRunResponse(boolean autoCommitTx, TransactionConfig config, AccessMode mode) - throws Exception { - var connection = connectionMock(mode, protocol); - var initialBookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx987")); - - CompletionStage cursorStage; - if (autoCommitTx) { - cursorStage = protocol.runInAutoCommitTransaction( - connection, - QUERY, - initialBookmarks, - (ignored) -> {}, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult(); - } else { - cursorStage = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult(); - } - - var cursorFuture = cursorStage.toCompletableFuture(); - assertFalse(cursorFuture.isDone()); - - Set bookmarks = autoCommitTx ? initialBookmarks : Collections.emptySet(); - - var runResponseHandler = verifyRunInvoked(connection, autoCommitTx, bookmarks, config, mode).runHandler; - runResponseHandler.onSuccess(emptyMap()); - - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - protected void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) throws Exception { - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - assertFalse(cursorFuture.isDone()); - - var handlers = verifyRunInvoked(connection, true, bookmarks, config, mode); - - var newBookmarkValue = "neo4j:bookmark:v1:tx98765"; - handlers.runHandler.onSuccess(emptyMap()); - handlers.pullAllHandler.onSuccess(singletonMap("bookmark", value(newBookmarkValue))); - then(bookmarkConsumer).should().accept(new DatabaseBookmark(null, InternalBookmark.parse(newBookmarkValue))); - - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - protected void testFailedRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) { - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - assertFalse(cursorFuture.isDone()); - - var runResponseHandler = verifyRunInvoked(connection, true, bookmarks, config, mode).runHandler; - Throwable error = new RuntimeException(); - runResponseHandler.onFailure(error); - then(bookmarkConsumer).should(times(0)).accept(any()); - - assertTrue(cursorFuture.isDone()); - var actual = - assertThrows(error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - - private static InternalAuthToken dummyAuthToken() { - return (InternalAuthToken) AuthTokens.basic("hello", "world"); - } - - private static ResponseHandlers verifyRunInvoked( - Connection connection, - boolean session, - Set bookmarks, - TransactionConfig config, - AccessMode mode) { - var runHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var pullAllHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - - RunWithMetadataMessage expectedMessage; - if (session) { - expectedMessage = RunWithMetadataMessage.autoCommitTxRunMessage( - QUERY, config, defaultDatabase(), mode, bookmarks, null, null, Logging.none()); - } else { - expectedMessage = RunWithMetadataMessage.unmanagedTxRunMessage(QUERY); - } - - verify(connection).write(eq(expectedMessage), runHandlerCaptor.capture()); - verify(connection).writeAndFlush(eq(PullAllMessage.PULL_ALL), pullAllHandlerCaptor.capture()); - - assertThat(runHandlerCaptor.getValue(), instanceOf(RunResponseHandler.class)); - assertThat(pullAllHandlerCaptor.getValue(), instanceOf(PullAllResponseHandler.class)); - - return new ResponseHandlers(runHandlerCaptor.getValue(), pullAllHandlerCaptor.getValue()); - } - - private record ResponseHandlers(ResponseHandler runHandler, ResponseHandler pullAllHandler) {} -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java deleted file mode 100644 index 52a6ba121e..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v4/BoltProtocolV4Test.java +++ /dev/null @@ -1,609 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v4; - -import static java.time.Duration.ofSeconds; -import static java.util.Collections.emptyMap; -import static java.util.Collections.singletonMap; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.hasSize; -import static org.hamcrest.Matchers.instanceOf; -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -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.ArgumentMatchers.eq; -import static org.mockito.BDDMockito.then; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.AccessMode.WRITE; -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE; -import static org.neo4j.driver.testutil.TestUtil.await; -import static org.neo4j.driver.testutil.TestUtil.connectionMock; - -import io.netty.channel.embedded.EmbeddedChannel; -import java.time.Clock; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CompletionStage; -import java.util.function.Consumer; -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.EnumSource; -import org.mockito.ArgumentCaptor; -import org.mockito.Mockito; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.AuthTokens; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.TransactionConfig; -import org.neo4j.driver.Value; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; -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.cursor.AsyncResultCursor; -import org.neo4j.driver.internal.handlers.BeginTxResponseHandler; -import org.neo4j.driver.internal.handlers.CommitTxResponseHandler; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.RollbackTxResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -import org.neo4j.driver.internal.messaging.request.GoodbyeMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; - -public final class BoltProtocolV4Test { - - private static final String QUERY_TEXT = "RETURN $x"; - private static final Map PARAMS = singletonMap("x", value(42)); - private static final Query QUERY = new Query(QUERY_TEXT, value(PARAMS)); - - private final BoltProtocol protocol = createProtocol(); - private final EmbeddedChannel channel = new EmbeddedChannel(); - private final InboundMessageDispatcher messageDispatcher = new InboundMessageDispatcher(channel, Logging.none()); - - private final TransactionConfig txConfig = TransactionConfig.builder() - .withTimeout(ofSeconds(12)) - .withMetadata(singletonMap("key", value(42))) - .build(); - - @BeforeEach - void beforeEach() { - ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); - } - - @AfterEach - void afterEach() { - channel.finishAndReleaseAll(); - } - - @Test - void shouldCreateMessageFormat() { - assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); - } - - @Test - void shouldInitializeChannel() { - var promise = channel.newPromise(); - var clock = mock(Clock.class); - var time = 1L; - when(clock.millis()).thenReturn(time); - var authContext = mock(AuthContext.class); - when(authContext.getAuthToken()).thenReturn(dummyAuthToken()); - ChannelAttributes.setAuthContext(channel, authContext); - - protocol.initializeChannel( - "MyDriver/0.0.1", null, dummyAuthToken(), RoutingContext.EMPTY, promise, null, clock); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertFalse(promise.isDone()); - - Map metadata = new HashMap<>(); - metadata.put("server", value("Neo4j/4.0.0")); - metadata.put("connection_id", value("bolt-42")); - - messageDispatcher.handleSuccessMessage(metadata); - - assertTrue(promise.isDone()); - assertTrue(promise.isSuccess()); - verify(clock).millis(); - verify(authContext).finishAuth(time); - } - - @Test - void shouldPrepareToCloseChannel() { - protocol.prepareToCloseChannel(channel); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(GoodbyeMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - } - - @Test - void shouldFailToInitializeChannelWhenErrorIsReceived() { - var promise = channel.newPromise(); - - protocol.initializeChannel( - "MyDriver/2.2.1", null, dummyAuthToken(), RoutingContext.EMPTY, promise, null, mock(Clock.class)); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertFalse(promise.isDone()); - - messageDispatcher.handleFailureMessage("Neo.TransientError.General.DatabaseUnavailable", "Error!"); - - assertTrue(promise.isDone()); - assertFalse(promise.isSuccess()); - } - - @Test - void shouldBeginTransactionWithoutBookmark() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarks() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx100")); - - var stage = protocol.beginTransaction( - connection, bookmarks, TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithConfig() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - txConfig, - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarksAndConfig() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx4242")); - - var stage = protocol.beginTransaction(connection, bookmarks, txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, txConfig, defaultDatabase(), WRITE, null, null, null, Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldCommitTransaction() { - var bookmarkString = "neo4j:bookmark:v1:tx4242"; - - var connection = connectionMock(protocol); - when(connection.protocol()).thenReturn(protocol); - doAnswer(invocation -> { - ResponseHandler commitHandler = invocation.getArgument(1); - commitHandler.onSuccess(singletonMap("bookmark", value(bookmarkString))); - return null; - }) - .when(connection) - .writeAndFlush(eq(CommitMessage.COMMIT), any()); - - var stage = protocol.commitTransaction(connection); - - verify(connection).writeAndFlush(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); - assertEquals(InternalBookmark.parse(bookmarkString), await(stage).bookmark()); - } - - @Test - void shouldRollbackTransaction() { - var connection = connectionMock(protocol); - - var stage = protocol.rollbackTransaction(connection); - - verify(connection).writeAndFlush(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); - assertNull(await(stage)); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) - throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx65")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx163")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(false, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(true, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(false, mode); - } - - @Test - void databaseNameInBeginTransaction() { - testDatabaseNameSupport(false); - } - - @Test - void databaseNameForAutoCommitTransactions() { - testDatabaseNameSupport(true); - } - - @Test - void shouldSupportDatabaseNameInBeginTransaction() { - var txStage = protocol.beginTransaction( - connectionMock("foo", protocol), - Collections.emptySet(), - TransactionConfig.empty(), - null, - null, - Logging.none(), - true); - - assertDoesNotThrow(() -> await(txStage)); - } - - @Test - void shouldNotSupportDatabaseNameForAutoCommitTransactions() { - assertDoesNotThrow(() -> protocol.runInAutoCommitTransaction( - connectionMock("foo", protocol), - new Query("RETURN 1"), - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none())); - } - - @Test - void shouldTelemetryReturnCompletedStageWithoutSendAnyMessage() { - var connection = connectionMock(); - - await(protocol.telemetry(connection, 1)); - - verify(connection, never()).write(Mockito.any(), Mockito.any()); - verify(connection, never()).writeAndFlush(Mockito.any(), Mockito.any()); - } - - @SuppressWarnings("SameReturnValue") - private BoltProtocol createProtocol() { - return BoltProtocolV4.INSTANCE; - } - - private Class expectedMessageFormatType() { - return MessageFormatV4.class; - } - - private static InternalAuthToken dummyAuthToken() { - return (InternalAuthToken) AuthTokens.basic("hello", "world"); - } - - private void testFailedRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to Run message with a failure - Throwable error = new RuntimeException(); - runHandler.onFailure(error); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - var actual = - assertThrows(error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - - private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to the run message - runHandler.onSuccess(emptyMap()); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - - var cursorFuture = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifyTxRunInvoked(connection); - assertFalse(cursorFuture.isDone()); - Throwable error = new RuntimeException(); - - if (success) { - runHandler.onSuccess(emptyMap()); - } else { - // When responded with a failure - runHandler.onFailure(error); - } - - // Then - assertTrue(cursorFuture.isDone()); - if (success) { - assertNotNull(await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - } else { - var actual = assertThrows( - error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - } - - private void testRunAndWaitForRunResponse(boolean autoCommitTx, TransactionConfig config, AccessMode mode) - throws Exception { - // Given - var connection = connectionMock(mode, protocol); - var initialBookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx987")); - - CompletionStage cursorStage; - if (autoCommitTx) { - cursorStage = protocol.runInAutoCommitTransaction( - connection, - QUERY, - initialBookmarks, - (ignored) -> {}, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult(); - } else { - cursorStage = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult(); - } - - // When & Then - var cursorFuture = cursorStage.toCompletableFuture(); - assertFalse(cursorFuture.isDone()); - - var runResponseHandler = autoCommitTx - ? verifySessionRunInvoked(connection, initialBookmarks, config, mode, defaultDatabase()) - : verifyTxRunInvoked(connection); - runResponseHandler.onSuccess(emptyMap()); - - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testDatabaseNameSupport(boolean autoCommitTx) { - var connection = connectionMock("foo", protocol); - if (autoCommitTx) { - var factory = protocol.runInAutoCommitTransaction( - connection, - QUERY, - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none()); - var resultStage = factory.asyncResult(); - var runHandler = verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - runHandler.onSuccess(emptyMap()); - await(resultStage); - } else { - var txStage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - await(txStage); - verifyBeginInvoked(connection, Collections.emptySet(), TransactionConfig.empty(), database("foo")); - } - } - - private ResponseHandler verifyTxRunInvoked(Connection connection) { - return verifyRunInvoked(connection, RunWithMetadataMessage.unmanagedTxRunMessage(QUERY)); - } - - private ResponseHandler verifySessionRunInvoked( - Connection connection, - Set bookmarks, - TransactionConfig config, - AccessMode mode, - DatabaseName databaseName) { - var runMessage = RunWithMetadataMessage.autoCommitTxRunMessage( - QUERY, config, databaseName, mode, bookmarks, null, null, Logging.none()); - return verifyRunInvoked(connection, runMessage); - } - - private ResponseHandler verifyRunInvoked(Connection connection, RunWithMetadataMessage runMessage) { - var runHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var pullHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - - verify(connection).write(eq(runMessage), runHandlerCaptor.capture()); - verify(connection).writeAndFlush(any(PullMessage.class), pullHandlerCaptor.capture()); - - assertThat(runHandlerCaptor.getValue(), instanceOf(RunResponseHandler.class)); - assertThat(pullHandlerCaptor.getValue(), instanceOf(PullAllResponseHandler.class)); - - return runHandlerCaptor.getValue(); - } - - private void verifyBeginInvoked( - Connection connection, Set bookmarks, TransactionConfig config, DatabaseName databaseName) { - var beginHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var beginMessage = - new BeginMessage(bookmarks, config, databaseName, AccessMode.WRITE, null, null, null, Logging.none()); - verify(connection).writeAndFlush(eq(beginMessage), beginHandlerCaptor.capture()); - assertThat(beginHandlerCaptor.getValue(), instanceOf(BeginTxResponseHandler.class)); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v41/BoltProtocolV41Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v41/BoltProtocolV41Test.java deleted file mode 100644 index b0e5d2ff09..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v41/BoltProtocolV41Test.java +++ /dev/null @@ -1,609 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v41; - -import static java.time.Duration.ofSeconds; -import static java.util.Collections.emptyMap; -import static java.util.Collections.singletonMap; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.hasSize; -import static org.hamcrest.Matchers.instanceOf; -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -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.ArgumentMatchers.eq; -import static org.mockito.BDDMockito.then; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.AccessMode.WRITE; -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE; -import static org.neo4j.driver.testutil.TestUtil.await; -import static org.neo4j.driver.testutil.TestUtil.connectionMock; - -import io.netty.channel.embedded.EmbeddedChannel; -import java.time.Clock; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CompletionStage; -import java.util.function.Consumer; -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.EnumSource; -import org.mockito.ArgumentCaptor; -import org.mockito.Mockito; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.AuthTokens; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.TransactionConfig; -import org.neo4j.driver.Value; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; -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.cursor.AsyncResultCursor; -import org.neo4j.driver.internal.handlers.BeginTxResponseHandler; -import org.neo4j.driver.internal.handlers.CommitTxResponseHandler; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.RollbackTxResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -import org.neo4j.driver.internal.messaging.request.GoodbyeMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.messaging.v4.MessageFormatV4; -import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; - -public final class BoltProtocolV41Test { - private static final String QUERY_TEXT = "RETURN $x"; - private static final Map PARAMS = singletonMap("x", value(42)); - private static final Query QUERY = new Query(QUERY_TEXT, value(PARAMS)); - - private final BoltProtocol protocol = createProtocol(); - private final EmbeddedChannel channel = new EmbeddedChannel(); - private final InboundMessageDispatcher messageDispatcher = new InboundMessageDispatcher(channel, Logging.none()); - - private final TransactionConfig txConfig = TransactionConfig.builder() - .withTimeout(ofSeconds(12)) - .withMetadata(singletonMap("key", value(42))) - .build(); - - @SuppressWarnings("SameReturnValue") - private BoltProtocol createProtocol() { - return BoltProtocolV41.INSTANCE; - } - - @BeforeEach - void beforeEach() { - ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); - } - - @AfterEach - void afterEach() { - channel.finishAndReleaseAll(); - } - - @Test - void shouldCreateMessageFormat() { - assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); - } - - @Test - void shouldInitializeChannel() { - var promise = channel.newPromise(); - var clock = mock(Clock.class); - var time = 1L; - when(clock.millis()).thenReturn(time); - var authContext = mock(AuthContext.class); - when(authContext.getAuthToken()).thenReturn(dummyAuthToken()); - ChannelAttributes.setAuthContext(channel, authContext); - - protocol.initializeChannel( - "MyDriver/0.0.1", null, dummyAuthToken(), RoutingContext.EMPTY, promise, null, clock); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertFalse(promise.isDone()); - - Map metadata = new HashMap<>(); - metadata.put("server", value("Neo4j/4.1.0")); - metadata.put("connection_id", value("bolt-42")); - - messageDispatcher.handleSuccessMessage(metadata); - - assertTrue(promise.isDone()); - assertTrue(promise.isSuccess()); - verify(clock).millis(); - verify(authContext).finishAuth(time); - } - - @Test - void shouldPrepareToCloseChannel() { - protocol.prepareToCloseChannel(channel); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(GoodbyeMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - } - - @Test - void shouldFailToInitializeChannelWhenErrorIsReceived() { - var promise = channel.newPromise(); - - protocol.initializeChannel( - "MyDriver/2.2.1", null, dummyAuthToken(), RoutingContext.EMPTY, promise, null, mock(Clock.class)); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertFalse(promise.isDone()); - - messageDispatcher.handleFailureMessage("Neo.TransientError.General.DatabaseUnavailable", "Error!"); - - assertTrue(promise.isDone()); - assertFalse(promise.isSuccess()); - } - - @Test - void shouldBeginTransactionWithoutBookmark() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarks() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx100")); - - var stage = protocol.beginTransaction( - connection, bookmarks, TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithConfig() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - txConfig, - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarksAndConfig() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx4242")); - - var stage = protocol.beginTransaction(connection, bookmarks, txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, txConfig, defaultDatabase(), WRITE, null, null, null, Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldCommitTransaction() { - var bookmarkString = "neo4j:bookmark:v1:tx4242"; - - var connection = connectionMock(protocol); - when(connection.protocol()).thenReturn(protocol); - doAnswer(invocation -> { - ResponseHandler commitHandler = invocation.getArgument(1); - commitHandler.onSuccess(singletonMap("bookmark", value(bookmarkString))); - return null; - }) - .when(connection) - .writeAndFlush(eq(CommitMessage.COMMIT), any()); - - var stage = protocol.commitTransaction(connection); - - verify(connection).writeAndFlush(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); - assertEquals(InternalBookmark.parse(bookmarkString), await(stage).bookmark()); - } - - @Test - void shouldRollbackTransaction() { - var connection = connectionMock(protocol); - - var stage = protocol.rollbackTransaction(connection); - - verify(connection).writeAndFlush(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); - assertNull(await(stage)); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) - throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx65")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx163")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(false, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(true, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(false, mode); - } - - @Test - void databaseNameInBeginTransaction() { - testDatabaseNameSupport(false); - } - - @Test - void databaseNameForAutoCommitTransactions() { - testDatabaseNameSupport(true); - } - - @Test - void shouldSupportDatabaseNameInBeginTransaction() { - var txStage = protocol.beginTransaction( - connectionMock("foo", protocol), - Collections.emptySet(), - TransactionConfig.empty(), - null, - null, - Logging.none(), - true); - - assertDoesNotThrow(() -> await(txStage)); - } - - @Test - void shouldNotSupportDatabaseNameForAutoCommitTransactions() { - assertDoesNotThrow(() -> protocol.runInAutoCommitTransaction( - connectionMock("foo", protocol), - new Query("RETURN 1"), - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none())); - } - - @Test - void shouldTelemetryReturnCompletedStageWithoutSendAnyMessage() { - var connection = connectionMock(); - - await(protocol.telemetry(connection, 1)); - - verify(connection, never()).write(Mockito.any(), Mockito.any()); - verify(connection, never()).writeAndFlush(Mockito.any(), Mockito.any()); - } - - private Class expectedMessageFormatType() { - return MessageFormatV4.class; - } - - private void testFailedRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to Run message with a failure - Throwable error = new RuntimeException(); - runHandler.onFailure(error); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - var actual = - assertThrows(error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - - private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to the run message - runHandler.onSuccess(emptyMap()); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - - var cursorFuture = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifyTxRunInvoked(connection); - assertFalse(cursorFuture.isDone()); - Throwable error = new RuntimeException(); - - if (success) { - runHandler.onSuccess(emptyMap()); - } else { - // When responded with a failure - runHandler.onFailure(error); - } - - // Then - assertTrue(cursorFuture.isDone()); - if (success) { - assertNotNull(await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - } else { - var actual = assertThrows( - error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - } - - private void testRunAndWaitForRunResponse(boolean autoCommitTx, TransactionConfig config, AccessMode mode) - throws Exception { - // Given - var connection = connectionMock(mode, protocol); - var initialBookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx987")); - - CompletionStage cursorStage; - if (autoCommitTx) { - cursorStage = protocol.runInAutoCommitTransaction( - connection, - QUERY, - initialBookmarks, - (ignored) -> {}, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult(); - } else { - cursorStage = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult(); - } - - // When & Then - var cursorFuture = cursorStage.toCompletableFuture(); - assertFalse(cursorFuture.isDone()); - var runResponseHandler = autoCommitTx - ? verifySessionRunInvoked(connection, initialBookmarks, config, mode, defaultDatabase()) - : verifyTxRunInvoked(connection); - runResponseHandler.onSuccess(emptyMap()); - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testDatabaseNameSupport(boolean autoCommitTx) { - var connection = connectionMock("foo", protocol); - if (autoCommitTx) { - var factory = protocol.runInAutoCommitTransaction( - connection, - QUERY, - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none()); - var resultStage = factory.asyncResult(); - var runHandler = verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - runHandler.onSuccess(emptyMap()); - await(resultStage); - verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - } else { - var txStage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - await(txStage); - verifyBeginInvoked(connection, Collections.emptySet(), TransactionConfig.empty(), database("foo")); - } - } - - private ResponseHandler verifyTxRunInvoked(Connection connection) { - return verifyRunInvoked(connection, RunWithMetadataMessage.unmanagedTxRunMessage(QUERY)); - } - - private ResponseHandler verifySessionRunInvoked( - Connection connection, - Set bookmarks, - TransactionConfig config, - AccessMode mode, - DatabaseName databaseName) { - var runMessage = RunWithMetadataMessage.autoCommitTxRunMessage( - QUERY, config, databaseName, mode, bookmarks, null, null, Logging.none()); - return verifyRunInvoked(connection, runMessage); - } - - private ResponseHandler verifyRunInvoked(Connection connection, RunWithMetadataMessage runMessage) { - var runHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var pullHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - - verify(connection).write(eq(runMessage), runHandlerCaptor.capture()); - verify(connection).writeAndFlush(any(PullMessage.class), pullHandlerCaptor.capture()); - - assertThat(runHandlerCaptor.getValue(), instanceOf(RunResponseHandler.class)); - assertThat(pullHandlerCaptor.getValue(), instanceOf(PullAllResponseHandler.class)); - - return runHandlerCaptor.getValue(); - } - - private void verifyBeginInvoked( - Connection connection, Set bookmarks, TransactionConfig config, DatabaseName databaseName) { - var beginHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var beginMessage = - new BeginMessage(bookmarks, config, databaseName, AccessMode.WRITE, null, null, null, Logging.none()); - verify(connection).writeAndFlush(eq(beginMessage), beginHandlerCaptor.capture()); - assertThat(beginHandlerCaptor.getValue(), instanceOf(BeginTxResponseHandler.class)); - } - - private static InternalAuthToken dummyAuthToken() { - return (InternalAuthToken) AuthTokens.basic("hello", "world"); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v42/BoltProtocolV42Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v42/BoltProtocolV42Test.java deleted file mode 100644 index 3ad79fb776..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v42/BoltProtocolV42Test.java +++ /dev/null @@ -1,610 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v42; - -import static java.time.Duration.ofSeconds; -import static java.util.Collections.emptyMap; -import static java.util.Collections.singletonMap; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.hasSize; -import static org.hamcrest.Matchers.instanceOf; -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -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.ArgumentMatchers.eq; -import static org.mockito.BDDMockito.then; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.AccessMode.WRITE; -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE; -import static org.neo4j.driver.testutil.TestUtil.await; -import static org.neo4j.driver.testutil.TestUtil.connectionMock; - -import io.netty.channel.embedded.EmbeddedChannel; -import java.time.Clock; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CompletionStage; -import java.util.function.Consumer; -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.EnumSource; -import org.mockito.ArgumentCaptor; -import org.mockito.Mockito; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.AuthTokens; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.TransactionConfig; -import org.neo4j.driver.Value; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; -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.cursor.AsyncResultCursor; -import org.neo4j.driver.internal.handlers.BeginTxResponseHandler; -import org.neo4j.driver.internal.handlers.CommitTxResponseHandler; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.RollbackTxResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -import org.neo4j.driver.internal.messaging.request.GoodbyeMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.messaging.v4.MessageFormatV4; -import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; - -public final class BoltProtocolV42Test { - private static final String QUERY_TEXT = "RETURN $x"; - private static final Map PARAMS = singletonMap("x", value(42)); - private static final Query QUERY = new Query(QUERY_TEXT, value(PARAMS)); - - private final BoltProtocol protocol = createProtocol(); - private final EmbeddedChannel channel = new EmbeddedChannel(); - private final InboundMessageDispatcher messageDispatcher = new InboundMessageDispatcher(channel, Logging.none()); - - private final TransactionConfig txConfig = TransactionConfig.builder() - .withTimeout(ofSeconds(12)) - .withMetadata(singletonMap("key", value(42))) - .build(); - - @SuppressWarnings("SameReturnValue") - private BoltProtocol createProtocol() { - return BoltProtocolV42.INSTANCE; - } - - @BeforeEach - void beforeEach() { - ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); - } - - @AfterEach - void afterEach() { - channel.finishAndReleaseAll(); - } - - @Test - void shouldCreateMessageFormat() { - assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); - } - - @Test - void shouldInitializeChannel() { - var promise = channel.newPromise(); - var clock = mock(Clock.class); - var time = 1L; - when(clock.millis()).thenReturn(time); - var authContext = mock(AuthContext.class); - when(authContext.getAuthToken()).thenReturn(dummyAuthToken()); - ChannelAttributes.setAuthContext(channel, authContext); - - protocol.initializeChannel( - "MyDriver/0.0.1", null, dummyAuthToken(), RoutingContext.EMPTY, promise, null, clock); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertFalse(promise.isDone()); - - Map metadata = new HashMap<>(); - metadata.put("server", value("Neo4j/4.2.0")); - metadata.put("connection_id", value("bolt-42")); - - messageDispatcher.handleSuccessMessage(metadata); - - assertTrue(promise.isDone()); - assertTrue(promise.isSuccess()); - verify(clock).millis(); - verify(authContext).finishAuth(time); - } - - @Test - void shouldPrepareToCloseChannel() { - protocol.prepareToCloseChannel(channel); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(GoodbyeMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - } - - @Test - void shouldFailToInitializeChannelWhenErrorIsReceived() { - var promise = channel.newPromise(); - - protocol.initializeChannel( - "MyDriver/2.2.1", null, dummyAuthToken(), RoutingContext.EMPTY, promise, null, mock(Clock.class)); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertFalse(promise.isDone()); - - messageDispatcher.handleFailureMessage("Neo.TransientError.General.DatabaseUnavailable", "Error!"); - - assertTrue(promise.isDone()); - assertFalse(promise.isSuccess()); - } - - @Test - void shouldBeginTransactionWithoutBookmark() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarks() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx100")); - - var stage = protocol.beginTransaction( - connection, bookmarks, TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithConfig() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - txConfig, - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarksAndConfig() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx4242")); - - var stage = protocol.beginTransaction(connection, bookmarks, txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, txConfig, defaultDatabase(), WRITE, null, null, null, Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldCommitTransaction() { - var bookmarkString = "neo4j:bookmark:v1:tx4242"; - - var connection = connectionMock(protocol); - when(connection.protocol()).thenReturn(protocol); - doAnswer(invocation -> { - ResponseHandler commitHandler = invocation.getArgument(1); - commitHandler.onSuccess(singletonMap("bookmark", value(bookmarkString))); - return null; - }) - .when(connection) - .writeAndFlush(eq(CommitMessage.COMMIT), any()); - - var stage = protocol.commitTransaction(connection); - - verify(connection).writeAndFlush(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); - assertEquals(InternalBookmark.parse(bookmarkString), await(stage).bookmark()); - } - - @Test - void shouldRollbackTransaction() { - var connection = connectionMock(protocol); - - var stage = protocol.rollbackTransaction(connection); - - verify(connection).writeAndFlush(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); - assertNull(await(stage)); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) - throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx65")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx163")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(false, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(true, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(false, mode); - } - - @Test - void databaseNameInBeginTransaction() { - testDatabaseNameSupport(false); - } - - @Test - void databaseNameForAutoCommitTransactions() { - testDatabaseNameSupport(true); - } - - @Test - void shouldSupportDatabaseNameInBeginTransaction() { - var txStage = protocol.beginTransaction( - connectionMock("foo", protocol), - Collections.emptySet(), - TransactionConfig.empty(), - null, - null, - Logging.none(), - true); - - assertDoesNotThrow(() -> await(txStage)); - } - - @Test - void shouldNotSupportDatabaseNameForAutoCommitTransactions() { - assertDoesNotThrow(() -> protocol.runInAutoCommitTransaction( - connectionMock("foo", protocol), - new Query("RETURN 1"), - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none())); - } - - @Test - void shouldTelemetryReturnCompletedStageWithoutSendAnyMessage() { - var connection = connectionMock(); - - await(protocol.telemetry(connection, 1)); - - verify(connection, never()).write(Mockito.any(), Mockito.any()); - verify(connection, never()).writeAndFlush(Mockito.any(), Mockito.any()); - } - - private Class expectedMessageFormatType() { - return MessageFormatV4.class; - } - - private void testFailedRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to Run message with a failure - Throwable error = new RuntimeException(); - runHandler.onFailure(error); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - var actual = - assertThrows(error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - - private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to the run message - runHandler.onSuccess(emptyMap()); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - - var cursorFuture = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifyTxRunInvoked(connection); - assertFalse(cursorFuture.isDone()); - Throwable error = new RuntimeException(); - - if (success) { - runHandler.onSuccess(emptyMap()); - } else { - // When responded with a failure - runHandler.onFailure(error); - } - - // Then - assertTrue(cursorFuture.isDone()); - if (success) { - assertNotNull(await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - } else { - var actual = assertThrows( - error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - } - - private void testRunAndWaitForRunResponse(boolean autoCommitTx, TransactionConfig config, AccessMode mode) - throws Exception { - // Given - var connection = connectionMock(mode, protocol); - var initialBookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx987")); - - CompletionStage cursorStage; - if (autoCommitTx) { - cursorStage = protocol.runInAutoCommitTransaction( - connection, - QUERY, - initialBookmarks, - (ignored) -> {}, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult(); - } else { - cursorStage = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult(); - } - - // When & Then - var cursorFuture = cursorStage.toCompletableFuture(); - assertFalse(cursorFuture.isDone()); - - var runResponseHandler = autoCommitTx - ? verifySessionRunInvoked(connection, initialBookmarks, config, mode, defaultDatabase()) - : verifyTxRunInvoked(connection); - runResponseHandler.onSuccess(emptyMap()); - - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testDatabaseNameSupport(boolean autoCommitTx) { - var connection = connectionMock("foo", protocol); - if (autoCommitTx) { - var factory = protocol.runInAutoCommitTransaction( - connection, - QUERY, - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none()); - var resultStage = factory.asyncResult(); - var runHandler = verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - runHandler.onSuccess(emptyMap()); - await(resultStage); - verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - } else { - var txStage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - await(txStage); - verifyBeginInvoked(connection, Collections.emptySet(), TransactionConfig.empty(), database("foo")); - } - } - - private ResponseHandler verifyTxRunInvoked(Connection connection) { - return verifyRunInvoked(connection, RunWithMetadataMessage.unmanagedTxRunMessage(QUERY)); - } - - private ResponseHandler verifySessionRunInvoked( - Connection connection, - Set bookmarks, - TransactionConfig config, - AccessMode mode, - DatabaseName databaseName) { - var runMessage = RunWithMetadataMessage.autoCommitTxRunMessage( - QUERY, config, databaseName, mode, bookmarks, null, null, Logging.none()); - return verifyRunInvoked(connection, runMessage); - } - - private ResponseHandler verifyRunInvoked(Connection connection, RunWithMetadataMessage runMessage) { - var runHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var pullHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - - verify(connection).write(eq(runMessage), runHandlerCaptor.capture()); - verify(connection).writeAndFlush(any(PullMessage.class), pullHandlerCaptor.capture()); - - assertThat(runHandlerCaptor.getValue(), instanceOf(RunResponseHandler.class)); - assertThat(pullHandlerCaptor.getValue(), instanceOf(PullAllResponseHandler.class)); - - return runHandlerCaptor.getValue(); - } - - private void verifyBeginInvoked( - Connection connection, Set bookmarks, TransactionConfig config, DatabaseName databaseName) { - var beginHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var beginMessage = - new BeginMessage(bookmarks, config, databaseName, AccessMode.WRITE, null, null, null, Logging.none()); - verify(connection).writeAndFlush(eq(beginMessage), beginHandlerCaptor.capture()); - assertThat(beginHandlerCaptor.getValue(), instanceOf(BeginTxResponseHandler.class)); - } - - private static InternalAuthToken dummyAuthToken() { - return (InternalAuthToken) AuthTokens.basic("hello", "world"); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v43/BoltProtocolV43Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v43/BoltProtocolV43Test.java deleted file mode 100644 index b12f3f3dc6..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v43/BoltProtocolV43Test.java +++ /dev/null @@ -1,612 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v43; - -import static java.time.Duration.ofSeconds; -import static java.util.Collections.emptyMap; -import static java.util.Collections.singletonMap; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.hasSize; -import static org.hamcrest.Matchers.instanceOf; -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -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.ArgumentMatchers.eq; -import static org.mockito.BDDMockito.then; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.AccessMode.WRITE; -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE; -import static org.neo4j.driver.testutil.TestUtil.await; -import static org.neo4j.driver.testutil.TestUtil.connectionMock; - -import io.netty.channel.embedded.EmbeddedChannel; -import java.time.Clock; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CompletionStage; -import java.util.function.Consumer; -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.EnumSource; -import org.mockito.ArgumentCaptor; -import org.mockito.Mockito; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.AuthTokens; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.TransactionConfig; -import org.neo4j.driver.Value; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; -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.cursor.AsyncResultCursor; -import org.neo4j.driver.internal.handlers.BeginTxResponseHandler; -import org.neo4j.driver.internal.handlers.CommitTxResponseHandler; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.RollbackTxResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -import org.neo4j.driver.internal.messaging.request.GoodbyeMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; - -public final class BoltProtocolV43Test { - private static final String QUERY_TEXT = "RETURN $x"; - private static final Map PARAMS = singletonMap("x", value(42)); - private static final Query QUERY = new Query(QUERY_TEXT, value(PARAMS)); - - private final BoltProtocol protocol = createProtocol(); - private final EmbeddedChannel channel = new EmbeddedChannel(); - private final InboundMessageDispatcher messageDispatcher = new InboundMessageDispatcher(channel, Logging.none()); - - private final TransactionConfig txConfig = TransactionConfig.builder() - .withTimeout(ofSeconds(12)) - .withMetadata(singletonMap("key", value(42))) - .build(); - - @SuppressWarnings("SameReturnValue") - private BoltProtocol createProtocol() { - return BoltProtocolV43.INSTANCE; - } - - @BeforeEach - void beforeEach() { - ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); - } - - @AfterEach - void afterEach() { - channel.finishAndReleaseAll(); - } - - @Test - void shouldCreateMessageFormat() { - assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); - } - - @Test - void shouldInitializeChannel() { - var promise = channel.newPromise(); - var clock = mock(Clock.class); - var time = 1L; - when(clock.millis()).thenReturn(time); - var authContext = mock(AuthContext.class); - when(authContext.getAuthToken()).thenReturn(dummyAuthToken()); - ChannelAttributes.setAuthContext(channel, authContext); - - protocol.initializeChannel( - "MyDriver/0.0.1", null, dummyAuthToken(), RoutingContext.EMPTY, promise, null, clock); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertFalse(promise.isDone()); - - Map metadata = new HashMap<>(); - metadata.put("server", value("Neo4j/4.3.0")); - metadata.put("connection_id", value("bolt-42")); - - messageDispatcher.handleSuccessMessage(metadata); - - assertTrue(promise.isDone()); - assertTrue(promise.isSuccess()); - verify(clock).millis(); - verify(authContext).finishAuth(time); - } - - @Test - void shouldPrepareToCloseChannel() { - protocol.prepareToCloseChannel(channel); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(GoodbyeMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - } - - @Test - void shouldFailToInitializeChannelWhenErrorIsReceived() { - var promise = channel.newPromise(); - - protocol.initializeChannel( - "MyDriver/2.2.1", null, dummyAuthToken(), RoutingContext.EMPTY, promise, null, mock(Clock.class)); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertFalse(promise.isDone()); - - messageDispatcher.handleFailureMessage("Neo.TransientError.General.DatabaseUnavailable", "Error!"); - - assertTrue(promise.isDone()); - assertFalse(promise.isSuccess()); - } - - @Test - void shouldBeginTransactionWithoutBookmark() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarks() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx100")); - - var stage = protocol.beginTransaction( - connection, bookmarks, TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithConfig() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - txConfig, - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarksAndConfig() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx4242")); - - var stage = protocol.beginTransaction(connection, bookmarks, txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, txConfig, defaultDatabase(), WRITE, null, null, null, Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldCommitTransaction() { - var bookmarkString = "neo4j:bookmark:v1:tx4242"; - - var connection = connectionMock(protocol); - when(connection.protocol()).thenReturn(protocol); - doAnswer(invocation -> { - ResponseHandler commitHandler = invocation.getArgument(1); - commitHandler.onSuccess(singletonMap("bookmark", value(bookmarkString))); - return null; - }) - .when(connection) - .writeAndFlush(eq(CommitMessage.COMMIT), any()); - - var stage = protocol.commitTransaction(connection); - - verify(connection).writeAndFlush(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); - assertEquals(InternalBookmark.parse(bookmarkString), await(stage).bookmark()); - } - - @Test - void shouldRollbackTransaction() { - var connection = connectionMock(protocol); - - var stage = protocol.rollbackTransaction(connection); - - verify(connection).writeAndFlush(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); - assertNull(await(stage)); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) - throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx65")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx163")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(false, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(true, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(false, mode); - } - - @Test - void databaseNameInBeginTransaction() { - testDatabaseNameSupport(false); - } - - @Test - void databaseNameForAutoCommitTransactions() { - testDatabaseNameSupport(true); - } - - @Test - void shouldSupportDatabaseNameInBeginTransaction() { - var txStage = protocol.beginTransaction( - connectionMock("foo", protocol), - Collections.emptySet(), - TransactionConfig.empty(), - null, - null, - Logging.none(), - true); - - assertDoesNotThrow(() -> await(txStage)); - } - - @Test - void shouldNotSupportDatabaseNameForAutoCommitTransactions() { - assertDoesNotThrow(() -> protocol.runInAutoCommitTransaction( - connectionMock("foo", protocol), - new Query("RETURN 1"), - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none())); - } - - @Test - void shouldTelemetryReturnCompletedStageWithoutSendAnyMessage() { - var connection = connectionMock(); - - await(protocol.telemetry(connection, 1)); - - verify(connection, never()).write(Mockito.any(), Mockito.any()); - verify(connection, never()).writeAndFlush(Mockito.any(), Mockito.any()); - } - - private Class expectedMessageFormatType() { - return MessageFormatV43.class; - } - - private void testFailedRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to Run message with a failure - Throwable error = new RuntimeException(); - runHandler.onFailure(error); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - var actual = - assertThrows(error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - - private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to the run message - runHandler.onSuccess(emptyMap()); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - - var cursorFuture = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifyTxRunInvoked(connection); - assertFalse(cursorFuture.isDone()); - Throwable error = new RuntimeException(); - - if (success) { - runHandler.onSuccess(emptyMap()); - } else { - // When responded with a failure - runHandler.onFailure(error); - } - - // Then - assertTrue(cursorFuture.isDone()); - if (success) { - assertNotNull(await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - } else { - var actual = assertThrows( - error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - } - - private void testRunAndWaitForRunResponse(boolean autoCommitTx, TransactionConfig config, AccessMode mode) - throws Exception { - // Given - var connection = connectionMock(mode, protocol); - var initialBookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx987")); - - CompletionStage cursorStage; - if (autoCommitTx) { - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - cursorStage = protocol.runInAutoCommitTransaction( - connection, - QUERY, - initialBookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult(); - } else { - cursorStage = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult(); - } - - // When & Then - var cursorFuture = cursorStage.toCompletableFuture(); - assertFalse(cursorFuture.isDone()); - - var runResponseHandler = autoCommitTx - ? verifySessionRunInvoked(connection, initialBookmarks, config, mode, defaultDatabase()) - : verifyTxRunInvoked(connection); - runResponseHandler.onSuccess(emptyMap()); - - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testDatabaseNameSupport(boolean autoCommitTx) { - var connection = connectionMock("foo", protocol); - if (autoCommitTx) { - var factory = protocol.runInAutoCommitTransaction( - connection, - QUERY, - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none()); - var resultStage = factory.asyncResult(); - var runHandler = verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - runHandler.onSuccess(emptyMap()); - await(resultStage); - verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - } else { - var txStage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - await(txStage); - verifyBeginInvoked(connection, Collections.emptySet(), TransactionConfig.empty(), database("foo")); - } - } - - private ResponseHandler verifyTxRunInvoked(Connection connection) { - return verifyRunInvoked(connection, RunWithMetadataMessage.unmanagedTxRunMessage(QUERY)); - } - - private ResponseHandler verifySessionRunInvoked( - Connection connection, - Set bookmarks, - TransactionConfig config, - AccessMode mode, - DatabaseName databaseName) { - var runMessage = RunWithMetadataMessage.autoCommitTxRunMessage( - QUERY, config, databaseName, mode, bookmarks, null, null, Logging.none()); - return verifyRunInvoked(connection, runMessage); - } - - private ResponseHandler verifyRunInvoked(Connection connection, RunWithMetadataMessage runMessage) { - var runHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var pullHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - - verify(connection).write(eq(runMessage), runHandlerCaptor.capture()); - verify(connection).writeAndFlush(any(PullMessage.class), pullHandlerCaptor.capture()); - - assertThat(runHandlerCaptor.getValue(), instanceOf(RunResponseHandler.class)); - assertThat(pullHandlerCaptor.getValue(), instanceOf(PullAllResponseHandler.class)); - - return runHandlerCaptor.getValue(); - } - - private void verifyBeginInvoked( - Connection connection, Set bookmarks, TransactionConfig config, DatabaseName databaseName) { - var beginHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var beginMessage = - new BeginMessage(bookmarks, config, databaseName, AccessMode.WRITE, null, null, null, Logging.none()); - verify(connection).writeAndFlush(eq(beginMessage), beginHandlerCaptor.capture()); - assertThat(beginHandlerCaptor.getValue(), instanceOf(BeginTxResponseHandler.class)); - } - - private static InternalAuthToken dummyAuthToken() { - return (InternalAuthToken) AuthTokens.basic("hello", "world"); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v44/BoltProtocolV44Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v44/BoltProtocolV44Test.java deleted file mode 100644 index 83aef37628..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v44/BoltProtocolV44Test.java +++ /dev/null @@ -1,610 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v44; - -import static java.time.Duration.ofSeconds; -import static java.util.Collections.emptyMap; -import static java.util.Collections.singletonMap; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.hasSize; -import static org.hamcrest.Matchers.instanceOf; -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -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.ArgumentMatchers.eq; -import static org.mockito.BDDMockito.then; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.AccessMode.WRITE; -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE; -import static org.neo4j.driver.testutil.TestUtil.await; -import static org.neo4j.driver.testutil.TestUtil.connectionMock; - -import io.netty.channel.embedded.EmbeddedChannel; -import java.time.Clock; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CompletionStage; -import java.util.function.Consumer; -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.EnumSource; -import org.mockito.ArgumentCaptor; -import org.mockito.Mockito; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.AuthTokens; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.TransactionConfig; -import org.neo4j.driver.Value; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; -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.cursor.AsyncResultCursor; -import org.neo4j.driver.internal.handlers.BeginTxResponseHandler; -import org.neo4j.driver.internal.handlers.CommitTxResponseHandler; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.RollbackTxResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -import org.neo4j.driver.internal.messaging.request.GoodbyeMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; - -public class BoltProtocolV44Test { - protected static final String QUERY_TEXT = "RETURN $x"; - protected static final Map PARAMS = singletonMap("x", value(42)); - protected static final Query QUERY = new Query(QUERY_TEXT, value(PARAMS)); - - protected final BoltProtocol protocol = createProtocol(); - private final EmbeddedChannel channel = new EmbeddedChannel(); - private final InboundMessageDispatcher messageDispatcher = new InboundMessageDispatcher(channel, Logging.none()); - - private final TransactionConfig txConfig = TransactionConfig.builder() - .withTimeout(ofSeconds(12)) - .withMetadata(singletonMap("key", value(42))) - .build(); - - @SuppressWarnings("SameReturnValue") - protected BoltProtocol createProtocol() { - return BoltProtocolV44.INSTANCE; - } - - @BeforeEach - void beforeEach() { - ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); - } - - @AfterEach - void afterEach() { - channel.finishAndReleaseAll(); - } - - @Test - void shouldCreateMessageFormat() { - assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); - } - - @Test - void shouldInitializeChannel() { - var promise = channel.newPromise(); - var clock = mock(Clock.class); - var time = 1L; - when(clock.millis()).thenReturn(time); - var authContext = mock(AuthContext.class); - when(authContext.getAuthToken()).thenReturn(dummyAuthToken()); - ChannelAttributes.setAuthContext(channel, authContext); - - protocol.initializeChannel( - "MyDriver/0.0.1", null, dummyAuthToken(), RoutingContext.EMPTY, promise, null, clock); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertFalse(promise.isDone()); - - Map metadata = new HashMap<>(); - metadata.put("server", value("Neo4j/4.4.0")); - metadata.put("connection_id", value("bolt-42")); - - messageDispatcher.handleSuccessMessage(metadata); - - assertTrue(promise.isDone()); - assertTrue(promise.isSuccess()); - verify(clock).millis(); - verify(authContext).finishAuth(time); - } - - @Test - void shouldPrepareToCloseChannel() { - protocol.prepareToCloseChannel(channel); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(GoodbyeMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - } - - @Test - void shouldFailToInitializeChannelWhenErrorIsReceived() { - var promise = channel.newPromise(); - - protocol.initializeChannel( - "MyDriver/2.2.1", null, dummyAuthToken(), RoutingContext.EMPTY, promise, null, mock(Clock.class)); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertFalse(promise.isDone()); - - messageDispatcher.handleFailureMessage("Neo.TransientError.General.DatabaseUnavailable", "Error!"); - - assertTrue(promise.isDone()); - assertFalse(promise.isSuccess()); - } - - @Test - void shouldBeginTransactionWithoutBookmark() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarks() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx100")); - - var stage = protocol.beginTransaction( - connection, bookmarks, TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithConfig() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - txConfig, - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarksAndConfig() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx4242")); - - var stage = protocol.beginTransaction(connection, bookmarks, txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, txConfig, defaultDatabase(), WRITE, null, null, null, Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldCommitTransaction() { - var bookmarkString = "neo4j:bookmark:v1:tx4242"; - - var connection = connectionMock(protocol); - when(connection.protocol()).thenReturn(protocol); - doAnswer(invocation -> { - ResponseHandler commitHandler = invocation.getArgument(1); - commitHandler.onSuccess(singletonMap("bookmark", value(bookmarkString))); - return null; - }) - .when(connection) - .writeAndFlush(eq(CommitMessage.COMMIT), any()); - - var stage = protocol.commitTransaction(connection); - - verify(connection).writeAndFlush(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); - assertEquals(InternalBookmark.parse(bookmarkString), await(stage).bookmark()); - } - - @Test - void shouldRollbackTransaction() { - var connection = connectionMock(protocol); - - var stage = protocol.rollbackTransaction(connection); - - verify(connection).writeAndFlush(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); - assertNull(await(stage)); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) - throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx65")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx163")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(false, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(true, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(false, mode); - } - - @Test - void databaseNameInBeginTransaction() { - testDatabaseNameSupport(false); - } - - @Test - void databaseNameForAutoCommitTransactions() { - testDatabaseNameSupport(true); - } - - @Test - void shouldSupportDatabaseNameInBeginTransaction() { - var txStage = protocol.beginTransaction( - connectionMock("foo", protocol), - Collections.emptySet(), - TransactionConfig.empty(), - null, - null, - Logging.none(), - true); - - assertDoesNotThrow(() -> await(txStage)); - } - - @Test - void shouldNotSupportDatabaseNameForAutoCommitTransactions() { - assertDoesNotThrow(() -> protocol.runInAutoCommitTransaction( - connectionMock("foo", protocol), - new Query("RETURN 1"), - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none())); - } - - @Test - void shouldTelemetryReturnCompletedStageWithoutSendAnyMessage() { - var connection = connectionMock(); - - await(protocol.telemetry(connection, 1)); - - verify(connection, never()).write(Mockito.any(), Mockito.any()); - verify(connection, never()).writeAndFlush(Mockito.any(), Mockito.any()); - } - - private Class expectedMessageFormatType() { - return MessageFormatV44.class; - } - - private void testFailedRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to Run message with a failure - Throwable error = new RuntimeException(); - runHandler.onFailure(error); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - var actual = - assertThrows(error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - - private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to the run message - runHandler.onSuccess(emptyMap()); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - - var cursorFuture = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifyTxRunInvoked(connection); - assertFalse(cursorFuture.isDone()); - Throwable error = new RuntimeException(); - - if (success) { - runHandler.onSuccess(emptyMap()); - } else { - // When responded with a failure - runHandler.onFailure(error); - } - - // Then - assertTrue(cursorFuture.isDone()); - if (success) { - assertNotNull(await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - } else { - var actual = assertThrows( - error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - } - - private void testRunAndWaitForRunResponse(boolean autoCommitTx, TransactionConfig config, AccessMode mode) - throws Exception { - // Given - var connection = connectionMock(mode, protocol); - var initialBookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx987")); - - CompletionStage cursorStage; - if (autoCommitTx) { - cursorStage = protocol.runInAutoCommitTransaction( - connection, - QUERY, - initialBookmarks, - (ignored) -> {}, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult(); - } else { - cursorStage = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult(); - } - - // When & Then - var cursorFuture = cursorStage.toCompletableFuture(); - assertFalse(cursorFuture.isDone()); - - var runResponseHandler = autoCommitTx - ? verifySessionRunInvoked(connection, initialBookmarks, config, mode, defaultDatabase()) - : verifyTxRunInvoked(connection); - runResponseHandler.onSuccess(emptyMap()); - - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testDatabaseNameSupport(boolean autoCommitTx) { - var connection = connectionMock("foo", protocol); - if (autoCommitTx) { - var factory = protocol.runInAutoCommitTransaction( - connection, - QUERY, - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none()); - var resultStage = factory.asyncResult(); - var runHandler = verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - runHandler.onSuccess(emptyMap()); - await(resultStage); - verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - } else { - var txStage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - await(txStage); - verifyBeginInvoked(connection, Collections.emptySet(), TransactionConfig.empty(), database("foo")); - } - } - - private ResponseHandler verifyTxRunInvoked(Connection connection) { - return verifyRunInvoked(connection, RunWithMetadataMessage.unmanagedTxRunMessage(QUERY)); - } - - private ResponseHandler verifySessionRunInvoked( - Connection connection, - Set bookmarks, - TransactionConfig config, - AccessMode mode, - DatabaseName databaseName) { - var runMessage = RunWithMetadataMessage.autoCommitTxRunMessage( - QUERY, config, databaseName, mode, bookmarks, null, null, Logging.none()); - return verifyRunInvoked(connection, runMessage); - } - - private ResponseHandler verifyRunInvoked(Connection connection, RunWithMetadataMessage runMessage) { - var runHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var pullHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - - verify(connection).write(eq(runMessage), runHandlerCaptor.capture()); - verify(connection).writeAndFlush(any(PullMessage.class), pullHandlerCaptor.capture()); - - assertThat(runHandlerCaptor.getValue(), instanceOf(RunResponseHandler.class)); - assertThat(pullHandlerCaptor.getValue(), instanceOf(PullAllResponseHandler.class)); - - return runHandlerCaptor.getValue(); - } - - private void verifyBeginInvoked( - Connection connection, Set bookmarks, TransactionConfig config, DatabaseName databaseName) { - var beginHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var beginMessage = - new BeginMessage(bookmarks, config, databaseName, AccessMode.WRITE, null, null, null, Logging.none()); - verify(connection).writeAndFlush(eq(beginMessage), beginHandlerCaptor.capture()); - assertThat(beginHandlerCaptor.getValue(), instanceOf(BeginTxResponseHandler.class)); - } - - private static InternalAuthToken dummyAuthToken() { - return (InternalAuthToken) AuthTokens.basic("hello", "world"); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v5/BoltProtocolV5Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v5/BoltProtocolV5Test.java deleted file mode 100644 index be6f6874c8..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v5/BoltProtocolV5Test.java +++ /dev/null @@ -1,610 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v5; - -import static java.time.Duration.ofSeconds; -import static java.util.Collections.emptyMap; -import static java.util.Collections.singletonMap; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.hasSize; -import static org.hamcrest.Matchers.instanceOf; -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -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.ArgumentMatchers.eq; -import static org.mockito.BDDMockito.then; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.AccessMode.WRITE; -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE; -import static org.neo4j.driver.testutil.TestUtil.await; -import static org.neo4j.driver.testutil.TestUtil.connectionMock; - -import io.netty.channel.embedded.EmbeddedChannel; -import java.time.Clock; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CompletionStage; -import java.util.function.Consumer; -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.EnumSource; -import org.mockito.ArgumentCaptor; -import org.mockito.Mockito; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.AuthTokens; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.TransactionConfig; -import org.neo4j.driver.Value; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; -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.cursor.AsyncResultCursor; -import org.neo4j.driver.internal.handlers.BeginTxResponseHandler; -import org.neo4j.driver.internal.handlers.CommitTxResponseHandler; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.RollbackTxResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -import org.neo4j.driver.internal.messaging.request.GoodbyeMessage; -import org.neo4j.driver.internal.messaging.request.HelloMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; - -public class BoltProtocolV5Test { - protected static final String QUERY_TEXT = "RETURN $x"; - protected static final Map PARAMS = singletonMap("x", value(42)); - protected static final Query QUERY = new Query(QUERY_TEXT, value(PARAMS)); - - protected final BoltProtocol protocol = createProtocol(); - private final EmbeddedChannel channel = new EmbeddedChannel(); - private final InboundMessageDispatcher messageDispatcher = new InboundMessageDispatcher(channel, Logging.none()); - - private final TransactionConfig txConfig = TransactionConfig.builder() - .withTimeout(ofSeconds(12)) - .withMetadata(singletonMap("key", value(42))) - .build(); - - @SuppressWarnings("SameReturnValue") - protected BoltProtocol createProtocol() { - return BoltProtocolV5.INSTANCE; - } - - @BeforeEach - void beforeEach() { - ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); - } - - @AfterEach - void afterEach() { - channel.finishAndReleaseAll(); - } - - @Test - void shouldCreateMessageFormat() { - assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); - } - - @Test - void shouldInitializeChannel() { - var promise = channel.newPromise(); - var clock = mock(Clock.class); - var time = 1L; - when(clock.millis()).thenReturn(time); - var authContext = mock(AuthContext.class); - when(authContext.getAuthToken()).thenReturn(dummyAuthToken()); - ChannelAttributes.setAuthContext(channel, authContext); - - protocol.initializeChannel( - "MyDriver/0.0.1", null, dummyAuthToken(), RoutingContext.EMPTY, promise, null, clock); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertFalse(promise.isDone()); - - Map metadata = new HashMap<>(); - metadata.put("server", value("Neo4j/4.4.0")); - metadata.put("connection_id", value("bolt-42")); - - messageDispatcher.handleSuccessMessage(metadata); - - assertTrue(promise.isDone()); - assertTrue(promise.isSuccess()); - verify(clock).millis(); - verify(authContext).finishAuth(time); - } - - @Test - void shouldPrepareToCloseChannel() { - protocol.prepareToCloseChannel(channel); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(GoodbyeMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - } - - @Test - void shouldFailToInitializeChannelWhenErrorIsReceived() { - var promise = channel.newPromise(); - - protocol.initializeChannel( - "MyDriver/2.2.1", null, dummyAuthToken(), RoutingContext.EMPTY, promise, null, mock(Clock.class)); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(HelloMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertFalse(promise.isDone()); - - messageDispatcher.handleFailureMessage("Neo.TransientError.General.DatabaseUnavailable", "Error!"); - - assertTrue(promise.isDone()); - assertFalse(promise.isSuccess()); - } - - @Test - void shouldBeginTransactionWithoutBookmark() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarks() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx100")); - - var stage = protocol.beginTransaction( - connection, bookmarks, TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithConfig() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - txConfig, - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarksAndConfig() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx4242")); - - var stage = protocol.beginTransaction(connection, bookmarks, txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, txConfig, defaultDatabase(), WRITE, null, null, null, Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldCommitTransaction() { - var bookmarkString = "neo4j:bookmark:v1:tx4242"; - - var connection = connectionMock(protocol); - when(connection.protocol()).thenReturn(protocol); - doAnswer(invocation -> { - ResponseHandler commitHandler = invocation.getArgument(1); - commitHandler.onSuccess(singletonMap("bookmark", value(bookmarkString))); - return null; - }) - .when(connection) - .writeAndFlush(eq(CommitMessage.COMMIT), any()); - - var stage = protocol.commitTransaction(connection); - - verify(connection).writeAndFlush(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); - assertEquals(InternalBookmark.parse(bookmarkString), await(stage).bookmark()); - } - - @Test - void shouldRollbackTransaction() { - var connection = connectionMock(protocol); - - var stage = protocol.rollbackTransaction(connection); - - verify(connection).writeAndFlush(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); - assertNull(await(stage)); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) - throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx65")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx163")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(false, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(true, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(false, mode); - } - - @Test - void databaseNameInBeginTransaction() { - testDatabaseNameSupport(false); - } - - @Test - void databaseNameForAutoCommitTransactions() { - testDatabaseNameSupport(true); - } - - @Test - void shouldSupportDatabaseNameInBeginTransaction() { - var txStage = protocol.beginTransaction( - connectionMock("foo", protocol), - Collections.emptySet(), - TransactionConfig.empty(), - null, - null, - Logging.none(), - true); - - assertDoesNotThrow(() -> await(txStage)); - } - - @Test - void shouldNotSupportDatabaseNameForAutoCommitTransactions() { - assertDoesNotThrow(() -> protocol.runInAutoCommitTransaction( - connectionMock("foo", protocol), - new Query("RETURN 1"), - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none())); - } - - @Test - void shouldTelemetryReturnCompletedStageWithoutSendAnyMessage() { - var connection = connectionMock(); - - await(protocol.telemetry(connection, 1)); - - verify(connection, never()).write(Mockito.any(), Mockito.any()); - verify(connection, never()).writeAndFlush(Mockito.any(), Mockito.any()); - } - - private Class expectedMessageFormatType() { - return MessageFormatV5.class; - } - - private void testFailedRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to Run message with a failure - Throwable error = new RuntimeException(); - runHandler.onFailure(error); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - var actual = - assertThrows(error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - - private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to the run message - runHandler.onSuccess(emptyMap()); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - - var cursorFuture = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifyTxRunInvoked(connection); - assertFalse(cursorFuture.isDone()); - Throwable error = new RuntimeException(); - - if (success) { - runHandler.onSuccess(emptyMap()); - } else { - // When responded with a failure - runHandler.onFailure(error); - } - - // Then - assertTrue(cursorFuture.isDone()); - if (success) { - assertNotNull(await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - } else { - var actual = assertThrows( - error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - } - - private void testRunAndWaitForRunResponse(boolean autoCommitTx, TransactionConfig config, AccessMode mode) - throws Exception { - // Given - var connection = connectionMock(mode, protocol); - var initialBookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx987")); - - CompletionStage cursorStage; - if (autoCommitTx) { - cursorStage = protocol.runInAutoCommitTransaction( - connection, - QUERY, - initialBookmarks, - (ignored) -> {}, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult(); - } else { - cursorStage = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult(); - } - - // When & Then - var cursorFuture = cursorStage.toCompletableFuture(); - assertFalse(cursorFuture.isDone()); - - var runResponseHandler = autoCommitTx - ? verifySessionRunInvoked(connection, initialBookmarks, config, mode, defaultDatabase()) - : verifyTxRunInvoked(connection); - runResponseHandler.onSuccess(emptyMap()); - - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testDatabaseNameSupport(boolean autoCommitTx) { - var connection = connectionMock("foo", protocol); - if (autoCommitTx) { - var factory = protocol.runInAutoCommitTransaction( - connection, - QUERY, - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none()); - var resultStage = factory.asyncResult(); - var runHandler = verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - runHandler.onSuccess(emptyMap()); - await(resultStage); - verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - } else { - var txStage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - await(txStage); - verifyBeginInvoked(connection, Collections.emptySet(), TransactionConfig.empty(), database("foo")); - } - } - - private ResponseHandler verifyTxRunInvoked(Connection connection) { - return verifyRunInvoked(connection, RunWithMetadataMessage.unmanagedTxRunMessage(QUERY)); - } - - private ResponseHandler verifySessionRunInvoked( - Connection connection, - Set bookmark, - TransactionConfig config, - AccessMode mode, - DatabaseName databaseName) { - var runMessage = RunWithMetadataMessage.autoCommitTxRunMessage( - QUERY, config, databaseName, mode, bookmark, null, null, Logging.none()); - return verifyRunInvoked(connection, runMessage); - } - - private ResponseHandler verifyRunInvoked(Connection connection, RunWithMetadataMessage runMessage) { - var runHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var pullHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - - verify(connection).write(eq(runMessage), runHandlerCaptor.capture()); - verify(connection).writeAndFlush(any(PullMessage.class), pullHandlerCaptor.capture()); - - assertThat(runHandlerCaptor.getValue(), instanceOf(RunResponseHandler.class)); - assertThat(pullHandlerCaptor.getValue(), instanceOf(PullAllResponseHandler.class)); - - return runHandlerCaptor.getValue(); - } - - private void verifyBeginInvoked( - Connection connection, Set bookmarks, TransactionConfig config, DatabaseName databaseName) { - var beginHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var beginMessage = - new BeginMessage(bookmarks, config, databaseName, AccessMode.WRITE, null, null, null, Logging.none()); - verify(connection).writeAndFlush(eq(beginMessage), beginHandlerCaptor.capture()); - assertThat(beginHandlerCaptor.getValue(), instanceOf(BeginTxResponseHandler.class)); - } - - private static InternalAuthToken dummyAuthToken() { - return (InternalAuthToken) AuthTokens.basic("hello", "world"); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v51/BoltProtocolV51Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v51/BoltProtocolV51Test.java deleted file mode 100644 index d34fbdea40..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v51/BoltProtocolV51Test.java +++ /dev/null @@ -1,582 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v51; - -import static java.time.Duration.ofSeconds; -import static java.util.Collections.emptyMap; -import static java.util.Collections.singletonMap; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.hasSize; -import static org.hamcrest.Matchers.instanceOf; -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -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.ArgumentMatchers.eq; -import static org.mockito.BDDMockito.then; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.AccessMode.WRITE; -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE; -import static org.neo4j.driver.testutil.TestUtil.await; -import static org.neo4j.driver.testutil.TestUtil.connectionMock; - -import io.netty.channel.embedded.EmbeddedChannel; -import java.time.Clock; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CompletionStage; -import java.util.function.Consumer; -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.EnumSource; -import org.mockito.ArgumentCaptor; -import org.mockito.Mockito; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.AuthTokens; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.TransactionConfig; -import org.neo4j.driver.Value; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; -import org.neo4j.driver.internal.cluster.RoutingContext; -import org.neo4j.driver.internal.cursor.AsyncResultCursor; -import org.neo4j.driver.internal.handlers.BeginTxResponseHandler; -import org.neo4j.driver.internal.handlers.CommitTxResponseHandler; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.RollbackTxResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -import org.neo4j.driver.internal.messaging.request.GoodbyeMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; - -public class BoltProtocolV51Test { - protected static final String QUERY_TEXT = "RETURN $x"; - protected static final Map PARAMS = singletonMap("x", value(42)); - protected static final Query QUERY = new Query(QUERY_TEXT, value(PARAMS)); - - protected final BoltProtocol protocol = createProtocol(); - private final EmbeddedChannel channel = new EmbeddedChannel(); - private final InboundMessageDispatcher messageDispatcher = new InboundMessageDispatcher(channel, Logging.none()); - - private final TransactionConfig txConfig = TransactionConfig.builder() - .withTimeout(ofSeconds(12)) - .withMetadata(singletonMap("key", value(42))) - .build(); - - @SuppressWarnings("SameReturnValue") - protected BoltProtocol createProtocol() { - return BoltProtocolV51.INSTANCE; - } - - @BeforeEach - void beforeEach() { - ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); - } - - @AfterEach - void afterEach() { - channel.finishAndReleaseAll(); - } - - @Test - void shouldCreateMessageFormat() { - assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); - } - - @Test - void shouldInitializeChannel() { - var promise = channel.newPromise(); - - protocol.initializeChannel( - "MyDriver/0.0.1", null, dummyAuthToken(), RoutingContext.EMPTY, promise, null, mock(Clock.class)); - - assertThat(channel.outboundMessages(), hasSize(0)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertTrue(promise.isDone()); - - Map metadata = new HashMap<>(); - metadata.put("server", value("Neo4j/4.4.0")); - metadata.put("connection_id", value("bolt-42")); - - messageDispatcher.handleSuccessMessage(metadata); - - channel.flush(); - assertTrue(promise.isDone()); - assertTrue(promise.isSuccess()); - } - - @Test - void shouldPrepareToCloseChannel() { - protocol.prepareToCloseChannel(channel); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(GoodbyeMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - } - - @Test - void shouldBeginTransactionWithoutBookmark() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarks() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx100")); - - var stage = protocol.beginTransaction( - connection, bookmarks, TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithConfig() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - txConfig, - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarksAndConfig() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx4242")); - - var stage = protocol.beginTransaction(connection, bookmarks, txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, txConfig, defaultDatabase(), WRITE, null, null, null, Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldCommitTransaction() { - var bookmarkString = "neo4j:bookmark:v1:tx4242"; - - var connection = connectionMock(protocol); - when(connection.protocol()).thenReturn(protocol); - doAnswer(invocation -> { - ResponseHandler commitHandler = invocation.getArgument(1); - commitHandler.onSuccess(singletonMap("bookmark", value(bookmarkString))); - return null; - }) - .when(connection) - .writeAndFlush(eq(CommitMessage.COMMIT), any()); - - var stage = protocol.commitTransaction(connection); - - verify(connection).writeAndFlush(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); - assertEquals(InternalBookmark.parse(bookmarkString), await(stage).bookmark()); - } - - @Test - void shouldRollbackTransaction() { - var connection = connectionMock(protocol); - - var stage = protocol.rollbackTransaction(connection); - - verify(connection).writeAndFlush(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); - assertNull(await(stage)); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) - throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx65")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx163")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(false, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(true, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(false, mode); - } - - @Test - void databaseNameInBeginTransaction() { - testDatabaseNameSupport(false); - } - - @Test - void databaseNameForAutoCommitTransactions() { - testDatabaseNameSupport(true); - } - - @Test - void shouldSupportDatabaseNameInBeginTransaction() { - var txStage = protocol.beginTransaction( - connectionMock("foo", protocol), - Collections.emptySet(), - TransactionConfig.empty(), - null, - null, - Logging.none(), - true); - - assertDoesNotThrow(() -> await(txStage)); - } - - @Test - void shouldNotSupportDatabaseNameForAutoCommitTransactions() { - assertDoesNotThrow(() -> protocol.runInAutoCommitTransaction( - connectionMock("foo", protocol), - new Query("RETURN 1"), - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none())); - } - - @Test - void shouldTelemetryReturnCompletedStageWithoutSendAnyMessage() { - var connection = connectionMock(); - - await(protocol.telemetry(connection, 1)); - - verify(connection, never()).write(Mockito.any(), Mockito.any()); - verify(connection, never()).writeAndFlush(Mockito.any(), Mockito.any()); - } - - private Class expectedMessageFormatType() { - return MessageFormatV51.class; - } - - private void testFailedRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to Run message with a failure - Throwable error = new RuntimeException(); - runHandler.onFailure(error); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - var actual = - assertThrows(error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - - private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to the run message - runHandler.onSuccess(emptyMap()); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - - var cursorFuture = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifyTxRunInvoked(connection); - assertFalse(cursorFuture.isDone()); - Throwable error = new RuntimeException(); - - if (success) { - runHandler.onSuccess(emptyMap()); - } else { - // When responded with a failure - runHandler.onFailure(error); - } - - // Then - assertTrue(cursorFuture.isDone()); - if (success) { - assertNotNull(await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - } else { - var actual = assertThrows( - error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - } - - private void testRunAndWaitForRunResponse(boolean autoCommitTx, TransactionConfig config, AccessMode mode) - throws Exception { - // Given - var connection = connectionMock(mode, protocol); - var initialBookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx987")); - - CompletionStage cursorStage; - if (autoCommitTx) { - cursorStage = protocol.runInAutoCommitTransaction( - connection, - QUERY, - initialBookmarks, - (ignored) -> {}, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult(); - } else { - cursorStage = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult(); - } - - // When & Then - var cursorFuture = cursorStage.toCompletableFuture(); - assertFalse(cursorFuture.isDone()); - - var runResponseHandler = autoCommitTx - ? verifySessionRunInvoked(connection, initialBookmarks, config, mode, defaultDatabase()) - : verifyTxRunInvoked(connection); - runResponseHandler.onSuccess(emptyMap()); - - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testDatabaseNameSupport(boolean autoCommitTx) { - var connection = connectionMock("foo", protocol); - if (autoCommitTx) { - var factory = protocol.runInAutoCommitTransaction( - connection, - QUERY, - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none()); - var resultStage = factory.asyncResult(); - var runHandler = verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - runHandler.onSuccess(emptyMap()); - await(resultStage); - verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - } else { - var txStage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - await(txStage); - verifyBeginInvoked(connection, Collections.emptySet(), TransactionConfig.empty(), database("foo")); - } - } - - private ResponseHandler verifyTxRunInvoked(Connection connection) { - return verifyRunInvoked(connection, RunWithMetadataMessage.unmanagedTxRunMessage(QUERY)); - } - - private ResponseHandler verifySessionRunInvoked( - Connection connection, - Set bookmark, - TransactionConfig config, - AccessMode mode, - DatabaseName databaseName) { - var runMessage = RunWithMetadataMessage.autoCommitTxRunMessage( - QUERY, config, databaseName, mode, bookmark, null, null, Logging.none()); - return verifyRunInvoked(connection, runMessage); - } - - private ResponseHandler verifyRunInvoked(Connection connection, RunWithMetadataMessage runMessage) { - var runHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var pullHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - - verify(connection).write(eq(runMessage), runHandlerCaptor.capture()); - verify(connection).writeAndFlush(any(PullMessage.class), pullHandlerCaptor.capture()); - - assertThat(runHandlerCaptor.getValue(), instanceOf(RunResponseHandler.class)); - assertThat(pullHandlerCaptor.getValue(), instanceOf(PullAllResponseHandler.class)); - - return runHandlerCaptor.getValue(); - } - - private void verifyBeginInvoked( - Connection connection, Set bookmarks, TransactionConfig config, DatabaseName databaseName) { - var beginHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var beginMessage = - new BeginMessage(bookmarks, config, databaseName, AccessMode.WRITE, null, null, null, Logging.none()); - verify(connection).writeAndFlush(eq(beginMessage), beginHandlerCaptor.capture()); - assertThat(beginHandlerCaptor.getValue(), instanceOf(BeginTxResponseHandler.class)); - } - - private static InternalAuthToken dummyAuthToken() { - return (InternalAuthToken) AuthTokens.basic("hello", "world"); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v52/BoltProtocolV52Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v52/BoltProtocolV52Test.java deleted file mode 100644 index 35b54f5dde..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v52/BoltProtocolV52Test.java +++ /dev/null @@ -1,583 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v52; - -import static java.time.Duration.ofSeconds; -import static java.util.Collections.emptyMap; -import static java.util.Collections.singletonMap; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.hasSize; -import static org.hamcrest.Matchers.instanceOf; -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -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.ArgumentMatchers.eq; -import static org.mockito.BDDMockito.then; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.AccessMode.WRITE; -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE; -import static org.neo4j.driver.testutil.TestUtil.await; -import static org.neo4j.driver.testutil.TestUtil.connectionMock; - -import io.netty.channel.embedded.EmbeddedChannel; -import java.time.Clock; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CompletionStage; -import java.util.function.Consumer; -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.EnumSource; -import org.mockito.ArgumentCaptor; -import org.mockito.Mockito; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.AuthTokens; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.TransactionConfig; -import org.neo4j.driver.Value; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; -import org.neo4j.driver.internal.cluster.RoutingContext; -import org.neo4j.driver.internal.cursor.AsyncResultCursor; -import org.neo4j.driver.internal.handlers.BeginTxResponseHandler; -import org.neo4j.driver.internal.handlers.CommitTxResponseHandler; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.RollbackTxResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -import org.neo4j.driver.internal.messaging.request.GoodbyeMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.messaging.v51.MessageFormatV51; -import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; - -public class BoltProtocolV52Test { - protected static final String QUERY_TEXT = "RETURN $x"; - protected static final Map PARAMS = singletonMap("x", value(42)); - protected static final Query QUERY = new Query(QUERY_TEXT, value(PARAMS)); - - protected final BoltProtocol protocol = createProtocol(); - private final EmbeddedChannel channel = new EmbeddedChannel(); - private final InboundMessageDispatcher messageDispatcher = new InboundMessageDispatcher(channel, Logging.none()); - - private final TransactionConfig txConfig = TransactionConfig.builder() - .withTimeout(ofSeconds(12)) - .withMetadata(singletonMap("key", value(42))) - .build(); - - @SuppressWarnings("SameReturnValue") - protected BoltProtocol createProtocol() { - return BoltProtocolV52.INSTANCE; - } - - @BeforeEach - void beforeEach() { - ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); - } - - @AfterEach - void afterEach() { - channel.finishAndReleaseAll(); - } - - @Test - void shouldCreateMessageFormat() { - assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); - } - - @Test - void shouldInitializeChannel() { - var promise = channel.newPromise(); - - protocol.initializeChannel( - "MyDriver/0.0.1", null, dummyAuthToken(), RoutingContext.EMPTY, promise, null, mock(Clock.class)); - - assertThat(channel.outboundMessages(), hasSize(0)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertTrue(promise.isDone()); - - Map metadata = new HashMap<>(); - metadata.put("server", value("Neo4j/4.4.0")); - metadata.put("connection_id", value("bolt-42")); - - messageDispatcher.handleSuccessMessage(metadata); - - channel.flush(); - assertTrue(promise.isDone()); - assertTrue(promise.isSuccess()); - } - - @Test - void shouldPrepareToCloseChannel() { - protocol.prepareToCloseChannel(channel); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(GoodbyeMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - } - - @Test - void shouldBeginTransactionWithoutBookmark() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarks() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx100")); - - var stage = protocol.beginTransaction( - connection, bookmarks, TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithConfig() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - txConfig, - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarksAndConfig() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx4242")); - - var stage = protocol.beginTransaction(connection, bookmarks, txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, txConfig, defaultDatabase(), WRITE, null, null, null, Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldCommitTransaction() { - var bookmarkString = "neo4j:bookmark:v1:tx4242"; - - var connection = connectionMock(protocol); - when(connection.protocol()).thenReturn(protocol); - doAnswer(invocation -> { - ResponseHandler commitHandler = invocation.getArgument(1); - commitHandler.onSuccess(singletonMap("bookmark", value(bookmarkString))); - return null; - }) - .when(connection) - .writeAndFlush(eq(CommitMessage.COMMIT), any()); - - var stage = protocol.commitTransaction(connection); - - verify(connection).writeAndFlush(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); - assertEquals(InternalBookmark.parse(bookmarkString), await(stage).bookmark()); - } - - @Test - void shouldRollbackTransaction() { - var connection = connectionMock(protocol); - - var stage = protocol.rollbackTransaction(connection); - - verify(connection).writeAndFlush(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); - assertNull(await(stage)); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) - throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx65")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx163")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(false, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(true, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(false, mode); - } - - @Test - void databaseNameInBeginTransaction() { - testDatabaseNameSupport(false); - } - - @Test - void databaseNameForAutoCommitTransactions() { - testDatabaseNameSupport(true); - } - - @Test - void shouldSupportDatabaseNameInBeginTransaction() { - var txStage = protocol.beginTransaction( - connectionMock("foo", protocol), - Collections.emptySet(), - TransactionConfig.empty(), - null, - null, - Logging.none(), - true); - - assertDoesNotThrow(() -> await(txStage)); - } - - @Test - void shouldNotSupportDatabaseNameForAutoCommitTransactions() { - assertDoesNotThrow(() -> protocol.runInAutoCommitTransaction( - connectionMock("foo", protocol), - new Query("RETURN 1"), - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none())); - } - - @Test - void shouldTelemetryReturnCompletedStageWithoutSendAnyMessage() { - var connection = connectionMock(); - - await(protocol.telemetry(connection, 1)); - - verify(connection, never()).write(Mockito.any(), Mockito.any()); - verify(connection, never()).writeAndFlush(Mockito.any(), Mockito.any()); - } - - private Class expectedMessageFormatType() { - return MessageFormatV51.class; - } - - private void testFailedRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to Run message with a failure - Throwable error = new RuntimeException(); - runHandler.onFailure(error); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - var actual = - assertThrows(error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - - private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to the run message - runHandler.onSuccess(emptyMap()); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - - var cursorFuture = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifyTxRunInvoked(connection); - assertFalse(cursorFuture.isDone()); - Throwable error = new RuntimeException(); - - if (success) { - runHandler.onSuccess(emptyMap()); - } else { - // When responded with a failure - runHandler.onFailure(error); - } - - // Then - assertTrue(cursorFuture.isDone()); - if (success) { - assertNotNull(await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - } else { - var actual = assertThrows( - error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - } - - private void testRunAndWaitForRunResponse(boolean autoCommitTx, TransactionConfig config, AccessMode mode) - throws Exception { - // Given - var connection = connectionMock(mode, protocol); - var initialBookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx987")); - - CompletionStage cursorStage; - if (autoCommitTx) { - cursorStage = protocol.runInAutoCommitTransaction( - connection, - QUERY, - initialBookmarks, - (ignored) -> {}, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult(); - } else { - cursorStage = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult(); - } - - // When & Then - var cursorFuture = cursorStage.toCompletableFuture(); - assertFalse(cursorFuture.isDone()); - - var runResponseHandler = autoCommitTx - ? verifySessionRunInvoked(connection, initialBookmarks, config, mode, defaultDatabase()) - : verifyTxRunInvoked(connection); - runResponseHandler.onSuccess(emptyMap()); - - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testDatabaseNameSupport(boolean autoCommitTx) { - var connection = connectionMock("foo", protocol); - if (autoCommitTx) { - var factory = protocol.runInAutoCommitTransaction( - connection, - QUERY, - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none()); - var resultStage = factory.asyncResult(); - var runHandler = verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - runHandler.onSuccess(emptyMap()); - await(resultStage); - verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - } else { - var txStage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - await(txStage); - verifyBeginInvoked(connection, Collections.emptySet(), TransactionConfig.empty(), database("foo")); - } - } - - private ResponseHandler verifyTxRunInvoked(Connection connection) { - return verifyRunInvoked(connection, RunWithMetadataMessage.unmanagedTxRunMessage(QUERY)); - } - - private ResponseHandler verifySessionRunInvoked( - Connection connection, - Set bookmark, - TransactionConfig config, - AccessMode mode, - DatabaseName databaseName) { - var runMessage = RunWithMetadataMessage.autoCommitTxRunMessage( - QUERY, config, databaseName, mode, bookmark, null, null, Logging.none()); - return verifyRunInvoked(connection, runMessage); - } - - private ResponseHandler verifyRunInvoked(Connection connection, RunWithMetadataMessage runMessage) { - var runHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var pullHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - - verify(connection).write(eq(runMessage), runHandlerCaptor.capture()); - verify(connection).writeAndFlush(any(PullMessage.class), pullHandlerCaptor.capture()); - - assertThat(runHandlerCaptor.getValue(), instanceOf(RunResponseHandler.class)); - assertThat(pullHandlerCaptor.getValue(), instanceOf(PullAllResponseHandler.class)); - - return runHandlerCaptor.getValue(); - } - - private void verifyBeginInvoked( - Connection connection, Set bookmarks, TransactionConfig config, DatabaseName databaseName) { - var beginHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var beginMessage = - new BeginMessage(bookmarks, config, databaseName, AccessMode.WRITE, null, null, null, Logging.none()); - verify(connection).writeAndFlush(eq(beginMessage), beginHandlerCaptor.capture()); - assertThat(beginHandlerCaptor.getValue(), instanceOf(BeginTxResponseHandler.class)); - } - - private static InternalAuthToken dummyAuthToken() { - return (InternalAuthToken) AuthTokens.basic("hello", "world"); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v53/BoltProtocolV53Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v53/BoltProtocolV53Test.java deleted file mode 100644 index 46e1dd7afa..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v53/BoltProtocolV53Test.java +++ /dev/null @@ -1,590 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v53; - -import static java.time.Duration.ofSeconds; -import static java.util.Collections.emptyMap; -import static java.util.Collections.singletonMap; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.hasSize; -import static org.hamcrest.Matchers.instanceOf; -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -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.ArgumentMatchers.eq; -import static org.mockito.BDDMockito.then; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.AccessMode.WRITE; -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE; -import static org.neo4j.driver.testutil.TestUtil.await; -import static org.neo4j.driver.testutil.TestUtil.connectionMock; - -import io.netty.channel.embedded.EmbeddedChannel; -import java.time.Clock; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CompletionStage; -import java.util.function.Consumer; -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.EnumSource; -import org.mockito.ArgumentCaptor; -import org.mockito.Mockito; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.AuthTokens; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.TransactionConfig; -import org.neo4j.driver.Value; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; -import org.neo4j.driver.internal.cluster.RoutingContext; -import org.neo4j.driver.internal.cursor.AsyncResultCursor; -import org.neo4j.driver.internal.handlers.BeginTxResponseHandler; -import org.neo4j.driver.internal.handlers.CommitTxResponseHandler; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.RollbackTxResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -import org.neo4j.driver.internal.messaging.request.GoodbyeMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.messaging.v51.MessageFormatV51; -import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; - -public class BoltProtocolV53Test { - protected static final String QUERY_TEXT = "RETURN $x"; - protected static final Map PARAMS = singletonMap("x", value(42)); - protected static final Query QUERY = new Query(QUERY_TEXT, value(PARAMS)); - - protected final BoltProtocol protocol = createProtocol(); - private final EmbeddedChannel channel = new EmbeddedChannel(); - private final InboundMessageDispatcher messageDispatcher = new InboundMessageDispatcher(channel, Logging.none()); - - private final TransactionConfig txConfig = TransactionConfig.builder() - .withTimeout(ofSeconds(12)) - .withMetadata(singletonMap("key", value(42))) - .build(); - - @SuppressWarnings("SameReturnValue") - protected BoltProtocol createProtocol() { - return BoltProtocolV53.INSTANCE; - } - - @BeforeEach - void beforeEach() { - ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); - } - - @AfterEach - void afterEach() { - channel.finishAndReleaseAll(); - } - - @Test - void shouldCreateMessageFormat() { - assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); - } - - @Test - void shouldInitializeChannel() { - var promise = channel.newPromise(); - - protocol.initializeChannel( - "MyDriver/0.0.1", - BoltAgentUtil.VALUE, - dummyAuthToken(), - RoutingContext.EMPTY, - promise, - null, - mock(Clock.class)); - - assertThat(channel.outboundMessages(), hasSize(0)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertTrue(promise.isDone()); - - Map metadata = new HashMap<>(); - metadata.put("server", value("Neo4j/4.4.0")); - metadata.put("connection_id", value("bolt-42")); - - messageDispatcher.handleSuccessMessage(metadata); - - channel.flush(); - assertTrue(promise.isDone()); - assertTrue(promise.isSuccess()); - } - - @Test - void shouldPrepareToCloseChannel() { - protocol.prepareToCloseChannel(channel); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(GoodbyeMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - } - - @Test - void shouldBeginTransactionWithoutBookmark() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarks() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx100")); - - var stage = protocol.beginTransaction( - connection, bookmarks, TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithConfig() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - txConfig, - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarksAndConfig() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx4242")); - - var stage = protocol.beginTransaction(connection, bookmarks, txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, txConfig, defaultDatabase(), WRITE, null, null, null, Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldCommitTransaction() { - var bookmarkString = "neo4j:bookmark:v1:tx4242"; - - var connection = connectionMock(protocol); - when(connection.protocol()).thenReturn(protocol); - doAnswer(invocation -> { - ResponseHandler commitHandler = invocation.getArgument(1); - commitHandler.onSuccess(singletonMap("bookmark", value(bookmarkString))); - return null; - }) - .when(connection) - .writeAndFlush(eq(CommitMessage.COMMIT), any()); - - var stage = protocol.commitTransaction(connection); - - verify(connection).writeAndFlush(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); - assertEquals(InternalBookmark.parse(bookmarkString), await(stage).bookmark()); - } - - @Test - void shouldRollbackTransaction() { - var connection = connectionMock(protocol); - - var stage = protocol.rollbackTransaction(connection); - - verify(connection).writeAndFlush(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); - assertNull(await(stage)); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) - throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx65")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx163")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(false, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(true, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(false, mode); - } - - @Test - void databaseNameInBeginTransaction() { - testDatabaseNameSupport(false); - } - - @Test - void databaseNameForAutoCommitTransactions() { - testDatabaseNameSupport(true); - } - - @Test - void shouldSupportDatabaseNameInBeginTransaction() { - var txStage = protocol.beginTransaction( - connectionMock("foo", protocol), - Collections.emptySet(), - TransactionConfig.empty(), - null, - null, - Logging.none(), - true); - - assertDoesNotThrow(() -> await(txStage)); - } - - @Test - void shouldNotSupportDatabaseNameForAutoCommitTransactions() { - assertDoesNotThrow(() -> protocol.runInAutoCommitTransaction( - connectionMock("foo", protocol), - new Query("RETURN 1"), - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none())); - } - - @Test - void shouldTelemetryReturnCompletedStageWithoutSendAnyMessage() { - var connection = connectionMock(); - - await(protocol.telemetry(connection, 1)); - - verify(connection, never()).write(Mockito.any(), Mockito.any()); - verify(connection, never()).writeAndFlush(Mockito.any(), Mockito.any()); - } - - private Class expectedMessageFormatType() { - return MessageFormatV51.class; - } - - private void testFailedRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to Run message with a failure - Throwable error = new RuntimeException(); - runHandler.onFailure(error); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - var actual = - assertThrows(error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - - private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to the run message - runHandler.onSuccess(emptyMap()); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - - var cursorFuture = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifyTxRunInvoked(connection); - assertFalse(cursorFuture.isDone()); - Throwable error = new RuntimeException(); - - if (success) { - runHandler.onSuccess(emptyMap()); - } else { - // When responded with a failure - runHandler.onFailure(error); - } - - // Then - assertTrue(cursorFuture.isDone()); - if (success) { - assertNotNull(await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - } else { - var actual = assertThrows( - error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - } - - private void testRunAndWaitForRunResponse(boolean autoCommitTx, TransactionConfig config, AccessMode mode) - throws Exception { - // Given - var connection = connectionMock(mode, protocol); - var initialBookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx987")); - - CompletionStage cursorStage; - if (autoCommitTx) { - cursorStage = protocol.runInAutoCommitTransaction( - connection, - QUERY, - initialBookmarks, - (ignored) -> {}, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult(); - } else { - cursorStage = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult(); - } - - // When & Then - var cursorFuture = cursorStage.toCompletableFuture(); - assertFalse(cursorFuture.isDone()); - - var runResponseHandler = autoCommitTx - ? verifySessionRunInvoked(connection, initialBookmarks, config, mode, defaultDatabase()) - : verifyTxRunInvoked(connection); - runResponseHandler.onSuccess(emptyMap()); - - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testDatabaseNameSupport(boolean autoCommitTx) { - var connection = connectionMock("foo", protocol); - if (autoCommitTx) { - var factory = protocol.runInAutoCommitTransaction( - connection, - QUERY, - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none()); - var resultStage = factory.asyncResult(); - var runHandler = verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - runHandler.onSuccess(emptyMap()); - await(resultStage); - verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - } else { - var txStage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - await(txStage); - verifyBeginInvoked(connection, Collections.emptySet(), TransactionConfig.empty(), database("foo")); - } - } - - private ResponseHandler verifyTxRunInvoked(Connection connection) { - return verifyRunInvoked(connection, RunWithMetadataMessage.unmanagedTxRunMessage(QUERY)); - } - - private ResponseHandler verifySessionRunInvoked( - Connection connection, - Set bookmark, - TransactionConfig config, - AccessMode mode, - DatabaseName databaseName) { - var runMessage = RunWithMetadataMessage.autoCommitTxRunMessage( - QUERY, config, databaseName, mode, bookmark, null, null, Logging.none()); - return verifyRunInvoked(connection, runMessage); - } - - private ResponseHandler verifyRunInvoked(Connection connection, RunWithMetadataMessage runMessage) { - var runHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var pullHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - - verify(connection).write(eq(runMessage), runHandlerCaptor.capture()); - verify(connection).writeAndFlush(any(PullMessage.class), pullHandlerCaptor.capture()); - - assertThat(runHandlerCaptor.getValue(), instanceOf(RunResponseHandler.class)); - assertThat(pullHandlerCaptor.getValue(), instanceOf(PullAllResponseHandler.class)); - - return runHandlerCaptor.getValue(); - } - - private void verifyBeginInvoked( - Connection connection, Set bookmarks, TransactionConfig config, DatabaseName databaseName) { - var beginHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var beginMessage = - new BeginMessage(bookmarks, config, databaseName, AccessMode.WRITE, null, null, null, Logging.none()); - verify(connection).writeAndFlush(eq(beginMessage), beginHandlerCaptor.capture()); - assertThat(beginHandlerCaptor.getValue(), instanceOf(BeginTxResponseHandler.class)); - } - - private static InternalAuthToken dummyAuthToken() { - return (InternalAuthToken) AuthTokens.basic("hello", "world"); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/v54/BoltProtocolV54Test.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/v54/BoltProtocolV54Test.java deleted file mode 100644 index 14035d6e30..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/v54/BoltProtocolV54Test.java +++ /dev/null @@ -1,599 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.v54; - -import static java.time.Duration.ofSeconds; -import static java.util.Collections.emptyMap; -import static java.util.Collections.singletonMap; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.hasSize; -import static org.hamcrest.Matchers.instanceOf; -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -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.ArgumentMatchers.eq; -import static org.mockito.BDDMockito.then; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.neo4j.driver.AccessMode.WRITE; -import static org.neo4j.driver.Values.value; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE; -import static org.neo4j.driver.testutil.TestUtil.await; -import static org.neo4j.driver.testutil.TestUtil.connectionMock; - -import io.netty.channel.embedded.EmbeddedChannel; -import java.time.Clock; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CompletionStage; -import java.util.function.Consumer; -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.EnumSource; -import org.mockito.ArgumentCaptor; -import org.mockito.Mockito; -import org.neo4j.driver.AccessMode; -import org.neo4j.driver.AuthTokens; -import org.neo4j.driver.Bookmark; -import org.neo4j.driver.Logging; -import org.neo4j.driver.Query; -import org.neo4j.driver.TransactionConfig; -import org.neo4j.driver.Value; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.DatabaseBookmark; -import org.neo4j.driver.internal.DatabaseName; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.async.UnmanagedTransaction; -import org.neo4j.driver.internal.async.connection.ChannelAttributes; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; -import org.neo4j.driver.internal.cluster.RoutingContext; -import org.neo4j.driver.internal.cursor.AsyncResultCursor; -import org.neo4j.driver.internal.handlers.BeginTxResponseHandler; -import org.neo4j.driver.internal.handlers.CommitTxResponseHandler; -import org.neo4j.driver.internal.handlers.PullAllResponseHandler; -import org.neo4j.driver.internal.handlers.RollbackTxResponseHandler; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.handlers.TelemetryResponseHandler; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -import org.neo4j.driver.internal.messaging.request.GoodbyeMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -import org.neo4j.driver.internal.messaging.request.TelemetryMessage; -import org.neo4j.driver.internal.security.InternalAuthToken; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ResponseHandler; - -public class BoltProtocolV54Test { - protected static final String QUERY_TEXT = "RETURN $x"; - protected static final Map PARAMS = singletonMap("x", value(42)); - protected static final Query QUERY = new Query(QUERY_TEXT, value(PARAMS)); - - protected final BoltProtocol protocol = createProtocol(); - private final EmbeddedChannel channel = new EmbeddedChannel(); - private final InboundMessageDispatcher messageDispatcher = new InboundMessageDispatcher(channel, Logging.none()); - - private final TransactionConfig txConfig = TransactionConfig.builder() - .withTimeout(ofSeconds(12)) - .withMetadata(singletonMap("key", value(42))) - .build(); - - @SuppressWarnings("SameReturnValue") - protected BoltProtocol createProtocol() { - return BoltProtocolV54.INSTANCE; - } - - @BeforeEach - void beforeEach() { - ChannelAttributes.setMessageDispatcher(channel, messageDispatcher); - } - - @AfterEach - void afterEach() { - channel.finishAndReleaseAll(); - } - - @Test - void shouldCreateMessageFormat() { - assertThat(protocol.createMessageFormat(), instanceOf(expectedMessageFormatType())); - } - - @Test - void shouldInitializeChannel() { - var promise = channel.newPromise(); - - protocol.initializeChannel( - "MyDriver/0.0.1", - BoltAgentUtil.VALUE, - dummyAuthToken(), - RoutingContext.EMPTY, - promise, - null, - mock(Clock.class)); - - assertThat(channel.outboundMessages(), hasSize(0)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - assertTrue(promise.isDone()); - - Map metadata = new HashMap<>(); - metadata.put("server", value("Neo4j/4.4.0")); - metadata.put("connection_id", value("bolt-42")); - - messageDispatcher.handleSuccessMessage(metadata); - - channel.flush(); - assertTrue(promise.isDone()); - assertTrue(promise.isSuccess()); - } - - @Test - void shouldPrepareToCloseChannel() { - protocol.prepareToCloseChannel(channel); - - assertThat(channel.outboundMessages(), hasSize(1)); - assertThat(channel.outboundMessages().poll(), instanceOf(GoodbyeMessage.class)); - assertEquals(1, messageDispatcher.queuedHandlersCount()); - } - - @Test - void shouldBeginTransactionWithoutBookmark() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarks() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx100")); - - var stage = protocol.beginTransaction( - connection, bookmarks, TransactionConfig.empty(), null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, - TransactionConfig.empty(), - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithConfig() { - var connection = connectionMock(protocol); - - var stage = protocol.beginTransaction( - connection, Collections.emptySet(), txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - Collections.emptySet(), - txConfig, - defaultDatabase(), - WRITE, - null, - null, - null, - Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldBeginTransactionWithBookmarksAndConfig() { - var connection = connectionMock(protocol); - var bookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx4242")); - - var stage = protocol.beginTransaction(connection, bookmarks, txConfig, null, null, Logging.none(), true); - - verify(connection) - .writeAndFlush( - eq(new BeginMessage( - bookmarks, txConfig, defaultDatabase(), WRITE, null, null, null, Logging.none())), - any(BeginTxResponseHandler.class)); - assertNull(await(stage)); - } - - @Test - void shouldCommitTransaction() { - var bookmarkString = "neo4j:bookmark:v1:tx4242"; - - var connection = connectionMock(protocol); - when(connection.protocol()).thenReturn(protocol); - doAnswer(invocation -> { - ResponseHandler commitHandler = invocation.getArgument(1); - commitHandler.onSuccess(singletonMap("bookmark", value(bookmarkString))); - return null; - }) - .when(connection) - .writeAndFlush(eq(CommitMessage.COMMIT), any()); - - var stage = protocol.commitTransaction(connection); - - verify(connection).writeAndFlush(eq(CommitMessage.COMMIT), any(CommitTxResponseHandler.class)); - assertEquals(InternalBookmark.parse(bookmarkString), await(stage).bookmark()); - } - - @Test - void shouldRollbackTransaction() { - var connection = connectionMock(protocol); - - var stage = protocol.rollbackTransaction(connection); - - verify(connection).writeAndFlush(eq(RollbackMessage.ROLLBACK), any(RollbackTxResponseHandler.class)); - assertNull(await(stage)); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitWithConfigTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(true, txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForSuccessRunResponse(AccessMode mode) - throws Exception { - testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx65")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse(Collections.emptySet(), TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInAutoCommitTransactionWithBookmarkAndConfigAndWaitForFailureRunResponse(AccessMode mode) { - testFailedRunInAutoCommitTxWithWaitingForResponse( - Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx163")), txConfig, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForRunResponse(AccessMode mode) throws Exception { - testRunAndWaitForRunResponse(false, TransactionConfig.empty(), mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForSuccessRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(true, mode); - } - - @ParameterizedTest - @EnumSource(AccessMode.class) - void shouldRunInUnmanagedTransactionAndWaitForFailureRunResponse(AccessMode mode) throws Exception { - testRunInUnmanagedTransactionAndWaitForRunResponse(false, mode); - } - - @Test - void databaseNameInBeginTransaction() { - testDatabaseNameSupport(false); - } - - @Test - void databaseNameForAutoCommitTransactions() { - testDatabaseNameSupport(true); - } - - @Test - void shouldSupportDatabaseNameInBeginTransaction() { - var txStage = protocol.beginTransaction( - connectionMock("foo", protocol), - Collections.emptySet(), - TransactionConfig.empty(), - null, - null, - Logging.none(), - true); - - assertDoesNotThrow(() -> await(txStage)); - } - - @Test - void shouldNotSupportDatabaseNameForAutoCommitTransactions() { - assertDoesNotThrow(() -> protocol.runInAutoCommitTransaction( - connectionMock("foo", protocol), - new Query("RETURN 1"), - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none())); - } - - @Test - void shouldTelemetrySendTelemetryMessage() { - var connection = connectionMock(); - doAnswer((invocationOnMock) -> { - var handler = (TelemetryResponseHandler) invocationOnMock.getArgument(1); - handler.onSuccess(Map.of()); - return null; - }) - .when(connection) - .write(Mockito.any(), Mockito.any()); - var expectedApi = 1; - - await(protocol.telemetry(connection, expectedApi)); - - verify(connection).write(Mockito.eq(new TelemetryMessage(expectedApi)), Mockito.any()); - verify(connection, never()).writeAndFlush(Mockito.any(), Mockito.any()); - } - - private Class expectedMessageFormatType() { - return MessageFormatV54.class; - } - - private void testFailedRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to Run message with a failure - Throwable error = new RuntimeException(); - runHandler.onFailure(error); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - var actual = - assertThrows(error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - - private void testSuccessfulRunInAutoCommitTxWithWaitingForResponse( - Set bookmarks, TransactionConfig config, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - @SuppressWarnings("unchecked") - Consumer bookmarkConsumer = mock(Consumer.class); - - var cursorFuture = protocol.runInAutoCommitTransaction( - connection, - QUERY, - bookmarks, - bookmarkConsumer, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifySessionRunInvoked(connection, bookmarks, config, mode, defaultDatabase()); - assertFalse(cursorFuture.isDone()); - - // When I response to the run message - runHandler.onSuccess(emptyMap()); - - // Then - then(bookmarkConsumer).should(times(0)).accept(any()); - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testRunInUnmanagedTransactionAndWaitForRunResponse(boolean success, AccessMode mode) throws Exception { - // Given - var connection = connectionMock(mode, protocol); - - var cursorFuture = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult() - .toCompletableFuture(); - - var runHandler = verifyTxRunInvoked(connection); - assertFalse(cursorFuture.isDone()); - Throwable error = new RuntimeException(); - - if (success) { - runHandler.onSuccess(emptyMap()); - } else { - // When responded with a failure - runHandler.onFailure(error); - } - - // Then - assertTrue(cursorFuture.isDone()); - if (success) { - assertNotNull(await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - } else { - var actual = assertThrows( - error.getClass(), () -> await(cursorFuture.get().mapSuccessfulRunCompletionAsync())); - assertSame(error, actual); - } - } - - private void testRunAndWaitForRunResponse(boolean autoCommitTx, TransactionConfig config, AccessMode mode) - throws Exception { - // Given - var connection = connectionMock(mode, protocol); - var initialBookmarks = Collections.singleton(InternalBookmark.parse("neo4j:bookmark:v1:tx987")); - - CompletionStage cursorStage; - if (autoCommitTx) { - cursorStage = protocol.runInAutoCommitTransaction( - connection, - QUERY, - initialBookmarks, - (ignored) -> {}, - config, - UNLIMITED_FETCH_SIZE, - null, - Logging.none()) - .asyncResult(); - } else { - cursorStage = protocol.runInUnmanagedTransaction( - connection, QUERY, mock(UnmanagedTransaction.class), UNLIMITED_FETCH_SIZE) - .asyncResult(); - } - - // When & Then - var cursorFuture = cursorStage.toCompletableFuture(); - assertFalse(cursorFuture.isDone()); - - var runResponseHandler = autoCommitTx - ? verifySessionRunInvoked(connection, initialBookmarks, config, mode, defaultDatabase()) - : verifyTxRunInvoked(connection); - runResponseHandler.onSuccess(emptyMap()); - - assertTrue(cursorFuture.isDone()); - assertNotNull(cursorFuture.get()); - } - - private void testDatabaseNameSupport(boolean autoCommitTx) { - var connection = connectionMock("foo", protocol); - if (autoCommitTx) { - var factory = protocol.runInAutoCommitTransaction( - connection, - QUERY, - Collections.emptySet(), - (ignored) -> {}, - TransactionConfig.empty(), - UNLIMITED_FETCH_SIZE, - null, - Logging.none()); - var resultStage = factory.asyncResult(); - var runHandler = verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - runHandler.onSuccess(emptyMap()); - await(resultStage); - verifySessionRunInvoked( - connection, Collections.emptySet(), TransactionConfig.empty(), AccessMode.WRITE, database("foo")); - } else { - var txStage = protocol.beginTransaction( - connection, Collections.emptySet(), TransactionConfig.empty(), null, null, Logging.none(), true); - await(txStage); - verifyBeginInvoked(connection, Collections.emptySet(), TransactionConfig.empty(), database("foo")); - } - } - - private ResponseHandler verifyTxRunInvoked(Connection connection) { - return verifyRunInvoked(connection, RunWithMetadataMessage.unmanagedTxRunMessage(QUERY)); - } - - private ResponseHandler verifySessionRunInvoked( - Connection connection, - Set bookmark, - TransactionConfig config, - AccessMode mode, - DatabaseName databaseName) { - var runMessage = RunWithMetadataMessage.autoCommitTxRunMessage( - QUERY, config, databaseName, mode, bookmark, null, null, Logging.none()); - return verifyRunInvoked(connection, runMessage); - } - - private ResponseHandler verifyRunInvoked(Connection connection, RunWithMetadataMessage runMessage) { - var runHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var pullHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - - verify(connection).write(eq(runMessage), runHandlerCaptor.capture()); - verify(connection).writeAndFlush(any(PullMessage.class), pullHandlerCaptor.capture()); - - assertThat(runHandlerCaptor.getValue(), instanceOf(RunResponseHandler.class)); - assertThat(pullHandlerCaptor.getValue(), instanceOf(PullAllResponseHandler.class)); - - return runHandlerCaptor.getValue(); - } - - private void verifyBeginInvoked( - Connection connection, Set bookmarks, TransactionConfig config, DatabaseName databaseName) { - var beginHandlerCaptor = ArgumentCaptor.forClass(ResponseHandler.class); - var beginMessage = - new BeginMessage(bookmarks, config, databaseName, AccessMode.WRITE, null, null, null, Logging.none()); - verify(connection).writeAndFlush(eq(beginMessage), beginHandlerCaptor.capture()); - assertThat(beginHandlerCaptor.getValue(), instanceOf(BeginTxResponseHandler.class)); - } - - private static InternalAuthToken dummyAuthToken() { - return (InternalAuthToken) AuthTokens.basic("hello", "world"); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/metrics/MicrometerConnectionPoolMetricsTest.java b/driver/src/test/java/org/neo4j/driver/internal/metrics/MicrometerConnectionPoolMetricsTest.java index 3cba84b24f..9b8ecbe679 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/metrics/MicrometerConnectionPoolMetricsTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/metrics/MicrometerConnectionPoolMetricsTest.java @@ -29,7 +29,8 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.neo4j.driver.ConnectionPoolMetrics; -import org.neo4j.driver.internal.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ListenerEvent; class MicrometerConnectionPoolMetricsTest { static final String ID = "id"; diff --git a/driver/src/test/java/org/neo4j/driver/internal/metrics/MicrometerMetricsTest.java b/driver/src/test/java/org/neo4j/driver/internal/metrics/MicrometerMetricsTest.java index 5b430217f5..29fd350913 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/metrics/MicrometerMetricsTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/metrics/MicrometerMetricsTest.java @@ -27,7 +27,8 @@ import org.junit.jupiter.api.Test; import org.mockito.Mockito; import org.neo4j.driver.ConnectionPoolMetrics; -import org.neo4j.driver.internal.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ListenerEvent; class MicrometerMetricsTest { static final String ID = "id"; diff --git a/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalReactiveSessionTest.java b/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalReactiveSessionTest.java index a657fddba6..752c86b719 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalReactiveSessionTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalReactiveSessionTest.java @@ -19,6 +19,7 @@ import static java.util.Collections.singletonList; import static java.util.Collections.singletonMap; import static java.util.concurrent.CompletableFuture.completedFuture; +import static java.util.concurrent.CompletableFuture.failedFuture; import static org.hamcrest.CoreMatchers.equalTo; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; @@ -58,11 +59,11 @@ import org.neo4j.driver.internal.InternalRecord; import org.neo4j.driver.internal.async.NetworkSession; import org.neo4j.driver.internal.async.UnmanagedTransaction; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; import org.neo4j.driver.internal.cursor.RxResultCursor; import org.neo4j.driver.internal.cursor.RxResultCursorImpl; import org.neo4j.driver.internal.retry.RetryLogic; import org.neo4j.driver.internal.telemetry.ApiTelemetryWork; -import org.neo4j.driver.internal.telemetry.TelemetryApi; import org.neo4j.driver.internal.util.FixedRetryLogic; import org.neo4j.driver.internal.util.Futures; import org.neo4j.driver.internal.value.IntegerValue; @@ -123,7 +124,7 @@ void shouldReleaseConnectionIfFailedToRun(Function>) invocation -> { + var handler = (ResponseHandler) invocation.getArguments()[0]; + handler.onRecord(values(1, 1, 1)); + handler.onRecord(values(2, 2, 2)); + handler.onRecord(values(3, 3, 3)); + handler.onPullSummary(mock()); + return CompletableFuture.completedFuture(null); + }); + var runSummary = mock(RunSummary.class); + given(runSummary.keys()).willReturn(List.of("key1", "key2", "key3")); Record record1 = new InternalRecord(asList("key1", "key2", "key3"), values(1, 1, 1)); Record record2 = new InternalRecord(asList("key1", "key2", "key3"), values(2, 2, 2)); Record record3 = new InternalRecord(asList("key1", "key2", "key3"), values(3, 3, 3)); - PullResponseHandler pullHandler = new ListBasedPullHandler(Arrays.asList(record1, record2, record3)); - RxResult rxResult = newRxResult(pullHandler); + RxResult rxResult = newRxResult(boltConnection, runSummary); // When StepVerifier.create(Flux.from(rxResult.records())) @@ -147,12 +167,23 @@ void shouldObtainRecordsAndSummary() { @Test void shouldCancelStreamingButObtainSummary() { // Given + var boltConnection = mock(BoltConnection.class); + given(boltConnection.pull(anyLong(), anyLong())).willReturn(CompletableFuture.completedFuture(boltConnection)); + given(boltConnection.serverAddress()).willReturn(new BoltServerAddress("localhost")); + given(boltConnection.protocolVersion()).willReturn(new BoltProtocolVersion(5, 1)); + given(boltConnection.flush(any())).willAnswer((Answer>) invocation -> { + var handler = (ResponseHandler) invocation.getArguments()[0]; + handler.onRecord(values(1, 1, 1)); + handler.onRecord(values(2, 2, 2)); + handler.onRecord(values(3, 3, 3)); + handler.onPullSummary(mock()); + return CompletableFuture.completedFuture(null); + }); + var runSummary = mock(RunSummary.class); + given(runSummary.keys()).willReturn(List.of("key1", "key2", "key3")); Record record1 = new InternalRecord(asList("key1", "key2", "key3"), values(1, 1, 1)); - Record record2 = new InternalRecord(asList("key1", "key2", "key3"), values(2, 2, 2)); - Record record3 = new InternalRecord(asList("key1", "key2", "key3"), values(3, 3, 3)); - PullResponseHandler pullHandler = new ListBasedPullHandler(Arrays.asList(record1, record2, record3)); - RxResult rxResult = newRxResult(pullHandler); + RxResult rxResult = newRxResult(boltConnection, runSummary); // When StepVerifier.create(Flux.from(rxResult.records()).limitRate(1).take(1)) @@ -179,8 +210,17 @@ void shouldErrorIfFailedToCreateCursor() { @Test void shouldErrorIfFailedToStream() { // Given + var boltConnection = mock(BoltConnection.class); + given(boltConnection.pull(anyLong(), anyLong())).willReturn(CompletableFuture.completedFuture(boltConnection)); + given(boltConnection.serverAddress()).willReturn(new BoltServerAddress("localhost")); + given(boltConnection.protocolVersion()).willReturn(new BoltProtocolVersion(5, 1)); Throwable error = new RuntimeException("Hi"); - RxResult rxResult = newRxResult(new ListBasedPullHandler(error)); + given(boltConnection.flush(any())).willAnswer((Answer>) invocation -> { + var handler = (ResponseHandler) invocation.getArguments()[0]; + handler.onError(error); + return CompletableFuture.completedFuture(null); + }); + RxResult rxResult = newRxResult(boltConnection); // When & Then StepVerifier.create(Flux.from(rxResult.records())) @@ -207,9 +247,21 @@ void shouldDelegateIsOpen(boolean expectedState) { then(cursor).should().isDone(); } - private InternalRxResult newRxResult(PullResponseHandler pullHandler) { - var runHandler = mock(RunResponseHandler.class); - RxResultCursor cursor = new RxResultCursorImpl(runHandler, pullHandler); + private InternalRxResult newRxResult(BoltConnection boltConnection) { + return newRxResult(boltConnection, mock()); + } + + private InternalRxResult newRxResult(BoltConnection boltConnection, RunSummary runSummary) { + RxResultCursor cursor = new RxResultCursorImpl( + boltConnection, + mock(), + runSummary, + null, + () -> null, + databaseBookmark -> {}, + throwable -> {}, + false, + () -> null); return newRxResult(cursor); } diff --git a/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxSessionTest.java b/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxSessionTest.java index 37d55787b3..942f89ff91 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxSessionTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/reactive/InternalRxSessionTest.java @@ -19,6 +19,7 @@ import static java.util.Collections.singletonList; import static java.util.Collections.singletonMap; import static java.util.concurrent.CompletableFuture.completedFuture; +import static java.util.concurrent.CompletableFuture.failedFuture; import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.MatcherAssert.assertThat; import static org.junit.jupiter.api.Assertions.assertThrows; @@ -48,10 +49,10 @@ import org.neo4j.driver.internal.InternalRecord; import org.neo4j.driver.internal.async.NetworkSession; import org.neo4j.driver.internal.async.UnmanagedTransaction; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; import org.neo4j.driver.internal.cursor.RxResultCursor; import org.neo4j.driver.internal.cursor.RxResultCursorImpl; import org.neo4j.driver.internal.telemetry.ApiTelemetryWork; -import org.neo4j.driver.internal.telemetry.TelemetryApi; import org.neo4j.driver.internal.util.FixedRetryLogic; import org.neo4j.driver.internal.util.Futures; import org.neo4j.driver.internal.value.IntegerValue; @@ -122,7 +123,7 @@ void shouldReleaseConnectionIfFailedToRun(Function runRetur // Run failed with error when(session.runRx(any(Query.class), any(TransactionConfig.class), any())) - .thenReturn(Futures.failedFuture(error)); + .thenReturn(failedFuture(error)); when(session.releaseConnectionAsync()).thenReturn(Futures.completedWithNull()); var rxSession = new InternalRxSession(session); @@ -169,7 +170,7 @@ void shouldReleaseConnectionIfFailedToBeginTx(Function runReturnOne) { var tx = mock(UnmanagedTransaction.class); // Run failed with error - when(tx.runRx(any(Query.class))).thenReturn(Futures.failedFuture(error)); + when(tx.runRx(any(Query.class))).thenReturn(failedFuture(error)); var rxTx = new InternalRxTransaction(tx); // When diff --git a/driver/src/test/java/org/neo4j/driver/internal/reactive/RxUtilsTest.java b/driver/src/test/java/org/neo4j/driver/internal/reactive/RxUtilsTest.java index 29ec8f2767..422626ebb4 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/reactive/RxUtilsTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/reactive/RxUtilsTest.java @@ -16,11 +16,11 @@ */ package org.neo4j.driver.internal.reactive; +import static java.util.concurrent.CompletableFuture.failedFuture; import static org.mockito.BDDMockito.then; import static org.mockito.Mockito.mock; import static org.neo4j.driver.internal.reactive.RxUtils.createEmptyPublisher; import static org.neo4j.driver.internal.reactive.RxUtils.createSingleItemPublisher; -import static org.neo4j.driver.internal.util.Futures.failedFuture; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionStage; @@ -59,7 +59,7 @@ void singleItemPublisherShouldCompleteWithValue() { @Test void singleItemPublisherShouldErrorWhenFutureCompletesWithNull() { - var error = mock(Throwable.class); + var error = new RuntimeException(); Publisher publisher = createSingleItemPublisher(Futures::completedWithNull, () -> error, (ignored) -> {}); @@ -68,7 +68,7 @@ void singleItemPublisherShouldErrorWhenFutureCompletesWithNull() { @Test void singleItemPublisherShouldErrorWhenSupplierErrors() { - var error = mock(RuntimeException.class); + var error = new RuntimeException(); Publisher publisher = createSingleItemPublisher(() -> failedFuture(error), () -> mock(Throwable.class), (ignored) -> {}); diff --git a/driver/src/test/java/org/neo4j/driver/internal/reactive/util/ListBasedPullHandler.java b/driver/src/test/java/org/neo4j/driver/internal/reactive/util/ListBasedPullHandler.java deleted file mode 100644 index 755734af74..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/reactive/util/ListBasedPullHandler.java +++ /dev/null @@ -1,101 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.reactive.util; - -import static java.util.Collections.emptyList; -import static java.util.Collections.emptyMap; -import static java.util.Collections.singletonMap; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyLong; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.when; - -import java.util.List; -import org.neo4j.driver.Query; -import org.neo4j.driver.Record; -import org.neo4j.driver.Value; -import org.neo4j.driver.internal.handlers.PullResponseCompletionListener; -import org.neo4j.driver.internal.handlers.RunResponseHandler; -import org.neo4j.driver.internal.handlers.pulln.BasicPullResponseHandler; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.util.MetadataExtractor; -import org.neo4j.driver.internal.util.QueryKeys; -import org.neo4j.driver.internal.value.BooleanValue; -import org.neo4j.driver.summary.ResultSummary; - -public class ListBasedPullHandler extends BasicPullResponseHandler { - private final List list; - private final Throwable error; - private int index = 0; - - public ListBasedPullHandler() { - this(emptyList(), null); - } - - public ListBasedPullHandler(List list) { - this(list, null); - } - - public ListBasedPullHandler(Throwable error) { - this(emptyList(), error); - } - - private ListBasedPullHandler(List list, Throwable error) { - super( - mock(Query.class), - mock(RunResponseHandler.class), - mock(Connection.class), - mock(MetadataExtractor.class), - mock(PullResponseCompletionListener.class)); - this.list = list; - this.error = error; - when(super.metadataExtractor.extractSummary(any(Query.class), any(Connection.class), anyLong(), any())) - .thenReturn(mock(ResultSummary.class)); - if (list.size() > 1) { - var record = list.get(0); - when(super.runResponseHandler.queryKeys()).thenReturn(new QueryKeys(record.keys())); - } - } - - @Override - public void request(long n) { - super.request(n); - while (index < list.size() && (n == -1 || n-- > 0)) { - onRecord(list.get(index++).values().toArray(new Value[0])); - } - - if (index == list.size()) { - complete(); - } else { - onSuccess(singletonMap("has_more", BooleanValue.TRUE)); - } - } - - @Override - public void cancel() { - super.cancel(); - complete(); - } - - private void complete() { - if (error != null) { - onFailure(error); - } else { - onSuccess(emptyMap()); - } - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/retry/ExponentialBackoffRetryLogicTest.java b/driver/src/test/java/org/neo4j/driver/internal/retry/ExponentialBackoffRetryLogicTest.java index cbf43457c4..10cb2379ce 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/retry/ExponentialBackoffRetryLogicTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/retry/ExponentialBackoffRetryLogicTest.java @@ -18,6 +18,7 @@ import static java.lang.Long.MAX_VALUE; import static java.util.concurrent.CompletableFuture.completedFuture; +import static java.util.concurrent.CompletableFuture.failedFuture; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.allOf; import static org.hamcrest.Matchers.closeTo; @@ -42,7 +43,6 @@ import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.when; import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; -import static org.neo4j.driver.internal.util.Futures.failedFuture; import static org.neo4j.driver.testutil.TestUtil.await; import java.time.Clock; diff --git a/driver/src/test/java/org/neo4j/driver/internal/security/SecurityPlans.java b/driver/src/test/java/org/neo4j/driver/internal/security/SecurityPlans.java index 849ece030e..8225875460 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/security/SecurityPlans.java +++ b/driver/src/test/java/org/neo4j/driver/internal/security/SecurityPlans.java @@ -16,13 +16,9 @@ */ package org.neo4j.driver.internal.security; -import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.neo4j.driver.RevocationCheckingStrategy.NO_CHECKS; -import static org.neo4j.driver.RevocationCheckingStrategy.STRICT; -import static org.neo4j.driver.RevocationCheckingStrategy.VERIFY_IF_PRESENT; import java.util.stream.Stream; import org.junit.jupiter.params.ParameterizedTest; @@ -67,7 +63,6 @@ void testSystemCertCompatibleConfiguration(String scheme) { assertTrue(securityPlan.requiresEncryption()); assertTrue(securityPlan.requiresHostnameVerification()); - assertEquals(NO_CHECKS, securityPlan.revocationCheckingStrategy()); } @ParameterizedTest @@ -156,45 +151,4 @@ void testConfiguredAllCertificates(String scheme) { assertTrue(securityPlan.requiresEncryption()); } - - @ParameterizedTest - @MethodSource("unencryptedSchemes") - void testConfigureStrictRevocationChecking(String scheme) { - var securitySettings = new SecuritySettings.SecuritySettingsBuilder() - .withTrustStrategy( - Config.TrustStrategy.trustSystemCertificates().withStrictRevocationChecks()) - .withEncryption() - .build(); - - var securityPlan = SecurityPlans.createSecurityPlan(securitySettings, scheme); - - assertEquals(STRICT, securityPlan.revocationCheckingStrategy()); - } - - @ParameterizedTest - @MethodSource("unencryptedSchemes") - void testConfigureVerifyIfPresentRevocationChecking(String scheme) { - var securitySettings = new SecuritySettings.SecuritySettingsBuilder() - .withTrustStrategy( - Config.TrustStrategy.trustSystemCertificates().withVerifyIfPresentRevocationChecks()) - .withEncryption() - .build(); - - var securityPlan = SecurityPlans.createSecurityPlan(securitySettings, scheme); - - assertEquals(VERIFY_IF_PRESENT, securityPlan.revocationCheckingStrategy()); - } - - @ParameterizedTest - @MethodSource("unencryptedSchemes") - void testRevocationCheckingDisabledByDefault(String scheme) { - var securitySettings = new SecuritySettings.SecuritySettingsBuilder() - .withTrustStrategy(Config.TrustStrategy.trustSystemCertificates()) - .withEncryption() - .build(); - - var securityPlan = SecurityPlans.createSecurityPlan(securitySettings, scheme); - - assertEquals(NO_CHECKS, securityPlan.revocationCheckingStrategy()); - } } diff --git a/driver/src/test/java/org/neo4j/driver/internal/telemetry/ApiTelemetryWorkTest.java b/driver/src/test/java/org/neo4j/driver/internal/telemetry/ApiTelemetryWorkTest.java index 4e3a96ddc7..8b0b55cbe3 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/telemetry/ApiTelemetryWorkTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/telemetry/ApiTelemetryWorkTest.java @@ -16,134 +16,77 @@ */ package org.neo4j.driver.internal.telemetry; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.BDDMockito.given; +import static org.mockito.BDDMockito.then; + import java.util.concurrent.CompletableFuture; -import java.util.function.Consumer; -import java.util.stream.Stream; -import org.junit.jupiter.api.Assertions; import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.Arguments; -import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.EnumSource; import org.mockito.Mockito; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.testutil.TestUtil; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.TelemetryApi; class ApiTelemetryWorkTest { @ParameterizedTest - @MethodSource("shouldNotSendTelemetrySource") - public void shouldNotCallTelemetryAndCompleteStage( - boolean telemetryEnabled, Consumer transformWorker) { - var apiTelemetryWork = new ApiTelemetryWork(TelemetryApi.UNMANAGED_TRANSACTION); - var protocol = Mockito.mock(BoltProtocol.class); - var connection = Mockito.mock(Connection.class); - Mockito.doReturn(telemetryEnabled).when(connection).isTelemetryEnabled(); - transformWorker.accept(apiTelemetryWork); + @EnumSource(TelemetryApi.class) + void shouldPipelineTelemetryWhenTelemetryIsEnabledAndConnectionSupportsTelemetry(TelemetryApi telemetryApi) { + var apiTelemetryWork = new ApiTelemetryWork(telemetryApi); + apiTelemetryWork.setEnabled(true); + var boltConnection = Mockito.mock(BoltConnection.class); + var boltConnectionStage = CompletableFuture.completedFuture(boltConnection); + given(boltConnection.telemetrySupported()).willReturn(true); + given(boltConnection.telemetry(telemetryApi)).willReturn(boltConnectionStage); - TestUtil.await(apiTelemetryWork.execute(connection, protocol)); + var stage = apiTelemetryWork.pipelineTelemetryIfEnabled(boltConnection); - Mockito.verify(protocol, Mockito.never()).telemetry(Mockito.any(), Mockito.any()); + assertEquals(boltConnectionStage, stage); + then(boltConnection).should().telemetry(telemetryApi); } @ParameterizedTest - @MethodSource("shouldCallTelemetry") - public void shouldCallTelemetryWithCorrectValuesAndResolveFuture( - TelemetryApi telemetryApi, boolean telemetryEnabled, Consumer transformWorker) { + @EnumSource(TelemetryApi.class) + void shouldNotPipelineTelemetryWhenTelemetryIsEnabledAndConnectionDoesNotSupportTelemetry( + TelemetryApi telemetryApi) { var apiTelemetryWork = new ApiTelemetryWork(telemetryApi); - var protocol = Mockito.mock(BoltProtocol.class); - var connection = Mockito.mock(Connection.class); - Mockito.doReturn(telemetryEnabled).when(connection).isTelemetryEnabled(); - Mockito.doReturn(CompletableFuture.completedFuture(null)) - .when(protocol) - .telemetry(Mockito.any(), Mockito.any()); - transformWorker.accept(apiTelemetryWork); + apiTelemetryWork.setEnabled(true); + var boltConnection = Mockito.mock(BoltConnection.class); - TestUtil.await(apiTelemetryWork.execute(connection, protocol)); + var future = apiTelemetryWork.pipelineTelemetryIfEnabled(boltConnection).toCompletableFuture(); - Mockito.verify(protocol, Mockito.only()).telemetry(connection, telemetryApi.getValue()); + assertTrue(future.isDone()); + assertEquals(boltConnection, future.join()); + then(boltConnection).should().telemetrySupported(); + then(boltConnection).shouldHaveNoMoreInteractions(); } @ParameterizedTest - @MethodSource("shouldCallTelemetry") - public void shouldCallTelemetryWithCorrectValuesAndFailedFuture( - TelemetryApi telemetryApi, boolean telemetryEnabled, Consumer transformWorker) { + @EnumSource(TelemetryApi.class) + void shouldNotPipelineTelemetryWhenTelemetryIsDisabledAndConnectionDoesNotSupportTelemetry( + TelemetryApi telemetryApi) { var apiTelemetryWork = new ApiTelemetryWork(telemetryApi); - var protocol = Mockito.mock(BoltProtocol.class); - var connection = Mockito.mock(Connection.class); - var exception = new RuntimeException("something wrong"); - Mockito.doReturn(telemetryEnabled).when(connection).isTelemetryEnabled(); - Mockito.doReturn(CompletableFuture.failedFuture(exception)) - .when(protocol) - .telemetry(Mockito.any(), Mockito.any()); - transformWorker.accept(apiTelemetryWork); - - Assertions.assertThrows( - RuntimeException.class, () -> TestUtil.await(apiTelemetryWork.execute(connection, protocol))); - - Mockito.verify(protocol, Mockito.only()).telemetry(connection, telemetryApi.getValue()); - } - - public static Stream shouldNotSendTelemetrySource() { - return Stream.of( - Arguments.of(false, (Consumer) - ApiTelemetryWorkTest::callApiTelemetryWorkSetEnabledWithFalse), - Arguments.of(false, (Consumer) - ApiTelemetryWorkTest::callApiTelemetryWorkSetEnabledWithTrue), - Arguments.of(false, (Consumer) - ApiTelemetryWorkTest::callApiTelemetryWorkExecuteWithSuccess), - Arguments.of( - false, (Consumer) ApiTelemetryWorkTest::callApiTelemetryWorkExecuteWithError), - Arguments.of(false, (Consumer) ApiTelemetryWorkTest::noop), - Arguments.of(true, (Consumer) - ApiTelemetryWorkTest::callApiTelemetryWorkSetEnabledWithFalse), - Arguments.of(true, (Consumer) - ApiTelemetryWorkTest::callApiTelemetryWorkExecuteWithSuccess)); - } + var boltConnection = Mockito.mock(BoltConnection.class); - private static Stream shouldCallTelemetry() { - return Stream.of(TelemetryApi.values()) - .flatMap(telemetryApi -> Stream.of( - Arguments.of(telemetryApi, true, (Consumer) - ApiTelemetryWorkTest::callApiTelemetryWorkSetEnabledWithTrue), - Arguments.of(telemetryApi, true, (Consumer) - ApiTelemetryWorkTest::callApiTelemetryWorkExecuteWithError), - Arguments.of(telemetryApi, true, (Consumer) ApiTelemetryWorkTest::noop))); - } + var future = apiTelemetryWork.pipelineTelemetryIfEnabled(boltConnection).toCompletableFuture(); - private static void callApiTelemetryWorkSetEnabledWithTrue(ApiTelemetryWork apiTelemetryWork) { - apiTelemetryWork.setEnabled(true); + assertTrue(future.isDone()); + assertEquals(boltConnection, future.join()); + then(boltConnection).shouldHaveNoInteractions(); } - private static void callApiTelemetryWorkSetEnabledWithFalse(ApiTelemetryWork apiTelemetryWork) { - apiTelemetryWork.setEnabled(false); - } - - @SuppressWarnings("EmptyMethod") - private static void noop(ApiTelemetryWork apiTelemetryWork) {} - - private static void callApiTelemetryWorkExecuteWithSuccess(ApiTelemetryWork apiTelemetryWork) { - var protocol = Mockito.mock(BoltProtocol.class); - var connection = Mockito.mock(Connection.class); - Mockito.doReturn(CompletableFuture.completedFuture(null)) - .when(protocol) - .telemetry(Mockito.any(), Mockito.any()); - Mockito.doReturn(true).when(connection).isTelemetryEnabled(); - - TestUtil.await(apiTelemetryWork.execute(connection, protocol)); - } + @ParameterizedTest + @EnumSource(TelemetryApi.class) + void shouldNotPipelineTelemetryWhenTelemetryIsDisabledAndConnectionSupportsTelemetry(TelemetryApi telemetryApi) { + var apiTelemetryWork = new ApiTelemetryWork(telemetryApi); + var boltConnection = Mockito.mock(BoltConnection.class); + given(boltConnection.telemetrySupported()).willReturn(true); - private static void callApiTelemetryWorkExecuteWithError(ApiTelemetryWork apiTelemetryWork) { - var protocol = Mockito.mock(BoltProtocol.class); - var connection = Mockito.mock(Connection.class); - Mockito.doReturn(CompletableFuture.failedFuture(new RuntimeException("WRONG"))) - .when(protocol) - .telemetry(Mockito.any(), Mockito.any()); - Mockito.doReturn(true).when(connection).isTelemetryEnabled(); + var future = apiTelemetryWork.pipelineTelemetryIfEnabled(boltConnection).toCompletableFuture(); - try { - TestUtil.await(apiTelemetryWork.execute(connection, protocol)); - } catch (Exception ex) { - // ignore since the error is expected. - } + assertTrue(future.isDone()); + assertEquals(boltConnection, future.join()); + then(boltConnection).shouldHaveNoInteractions(); } } diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/FailingMessageFormat.java b/driver/src/test/java/org/neo4j/driver/internal/util/FailingMessageFormat.java deleted file mode 100644 index 9595e3711f..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/util/FailingMessageFormat.java +++ /dev/null @@ -1,95 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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 io.netty.util.internal.PlatformDependent; -import java.io.IOException; -import java.util.concurrent.atomic.AtomicReference; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.messaging.ResponseMessageHandler; -import org.neo4j.driver.internal.messaging.response.FailureMessage; -import org.neo4j.driver.internal.packstream.PackInput; -import org.neo4j.driver.internal.packstream.PackOutput; - -public class FailingMessageFormat implements MessageFormat { - private final MessageFormat delegate; - private final AtomicReference writerThrowableRef = new AtomicReference<>(); - private final AtomicReference readerThrowableRef = new AtomicReference<>(); - private final AtomicReference readerFailureRef = new AtomicReference<>(); - - public FailingMessageFormat(MessageFormat delegate) { - this.delegate = delegate; - } - - public void makeWriterThrow(Throwable error) { - writerThrowableRef.set(error); - } - - public void makeReaderThrow(Throwable error) { - readerThrowableRef.set(error); - } - - public void makeReaderFail(FailureMessage failureMsg) { - readerFailureRef.set(failureMsg); - } - - @Override - public Writer newWriter(PackOutput output) { - return new ThrowingWriter(delegate.newWriter(output), writerThrowableRef); - } - - @Override - public Reader newReader(PackInput input) { - return new ThrowingReader(delegate.newReader(input), readerThrowableRef, readerFailureRef); - } - - private record ThrowingWriter(Writer delegate, AtomicReference throwableRef) implements Writer { - - @Override - public void write(Message msg) throws IOException { - var error = throwableRef.getAndSet(null); - if (error != null) { - PlatformDependent.throwException(error); - } else { - delegate.write(msg); - } - } - } - - private record ThrowingReader( - Reader delegate, AtomicReference throwableRef, AtomicReference failureRef) - implements Reader { - - @Override - public void read(ResponseMessageHandler handler) throws IOException { - var error = throwableRef.getAndSet(null); - if (error != null) { - PlatformDependent.throwException(error); - return; - } - - var failureMsg = failureRef.getAndSet(null); - if (failureMsg != null) { - handler.handleFailureMessage(failureMsg.code(), failureMsg.message()); - return; - } - - delegate.read(handler); - } - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/FuturesTest.java b/driver/src/test/java/org/neo4j/driver/internal/util/FuturesTest.java index 2f422c5313..0487bcc4b4 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/FuturesTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/util/FuturesTest.java @@ -16,142 +16,22 @@ */ package org.neo4j.driver.internal.util; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; import static org.junit.jupiter.api.Assertions.assertArrayEquals; 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.neo4j.driver.internal.util.Matchers.blockingOperationInEventLoopError; import static org.neo4j.driver.testutil.DaemonThreadFactory.daemon; import static org.neo4j.driver.testutil.TestUtil.sleep; -import io.netty.util.concurrent.DefaultPromise; -import io.netty.util.concurrent.FailedFuture; -import io.netty.util.concurrent.ImmediateEventExecutor; -import io.netty.util.concurrent.SucceededFuture; import java.io.IOException; -import java.util.concurrent.CancellationException; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionException; -import java.util.concurrent.ExecutionException; import java.util.concurrent.Executors; import org.junit.jupiter.api.Test; import org.neo4j.driver.exceptions.Neo4jException; -import org.neo4j.driver.internal.async.connection.EventLoopGroupFactory; class FuturesTest { - @Test - void shouldConvertCanceledNettyFutureToCompletionStage() { - var promise = new DefaultPromise(ImmediateEventExecutor.INSTANCE); - promise.cancel(true); - - var future = Futures.asCompletionStage(promise).toCompletableFuture(); - - assertTrue(future.isCancelled()); - assertTrue(future.isCompletedExceptionally()); - assertThrows(CancellationException.class, future::get); - } - - @Test - void shouldConvertSucceededNettyFutureToCompletionStage() throws Exception { - var nettyFuture = new SucceededFuture<>(ImmediateEventExecutor.INSTANCE, "Hello"); - - var future = Futures.asCompletionStage(nettyFuture).toCompletableFuture(); - - assertTrue(future.isDone()); - assertFalse(future.isCompletedExceptionally()); - assertEquals("Hello", future.get()); - } - - @Test - void shouldConvertFailedNettyFutureToCompletionStage() { - var error = new RuntimeException("Hello"); - var nettyFuture = new FailedFuture<>(ImmediateEventExecutor.INSTANCE, error); - - var future = Futures.asCompletionStage(nettyFuture).toCompletableFuture(); - - assertTrue(future.isCompletedExceptionally()); - var e = assertThrows(ExecutionException.class, future::get); - assertEquals(error, e.getCause()); - } - - @Test - void shouldConvertRunningNettyFutureToCompletionStageWhenFutureCanceled() { - var promise = new DefaultPromise(ImmediateEventExecutor.INSTANCE); - - var future = Futures.asCompletionStage(promise).toCompletableFuture(); - - assertFalse(future.isDone()); - promise.cancel(true); - - assertTrue(future.isCancelled()); - assertTrue(future.isCompletedExceptionally()); - assertThrows(CancellationException.class, future::get); - } - - @Test - void shouldConvertRunningNettyFutureToCompletionStageWhenFutureSucceeded() throws Exception { - var promise = new DefaultPromise(ImmediateEventExecutor.INSTANCE); - - var future = Futures.asCompletionStage(promise).toCompletableFuture(); - - assertFalse(future.isDone()); - promise.setSuccess("Hello"); - - assertTrue(future.isDone()); - assertFalse(future.isCompletedExceptionally()); - assertEquals("Hello", future.get()); - } - - @Test - void shouldConvertRunningNettyFutureToCompletionStageWhenFutureFailed() { - var error = new RuntimeException("Hello"); - var promise = new DefaultPromise(ImmediateEventExecutor.INSTANCE); - - var future = Futures.asCompletionStage(promise).toCompletableFuture(); - - assertFalse(future.isDone()); - promise.setFailure(error); - - assertTrue(future.isCompletedExceptionally()); - var e = assertThrows(ExecutionException.class, future::get); - assertEquals(error, e.getCause()); - } - - @Test - void shouldCreateFailedFutureWithUncheckedException() { - var error = new RuntimeException("Hello"); - var future = Futures.failedFuture(error).toCompletableFuture(); - assertTrue(future.isCompletedExceptionally()); - var e = assertThrows(ExecutionException.class, future::get); - assertEquals(error, e.getCause()); - } - - @Test - void shouldCreateFailedFutureWithCheckedException() { - var error = new IOException("Hello"); - var future = Futures.failedFuture(error).toCompletableFuture(); - assertTrue(future.isCompletedExceptionally()); - var e = assertThrows(ExecutionException.class, future::get); - assertEquals(error, e.getCause()); - } - - @Test - void shouldFailBlockingGetInEventLoopThread() { - var eventExecutor = EventLoopGroupFactory.newEventLoopGroup(1); - try { - var future = new CompletableFuture(); - var result = eventExecutor.submit(() -> Futures.blockingGet(future)); - - var e = assertThrows(ExecutionException.class, result::get); - assertThat(e.getCause(), is(blockingOperationInEventLoopError())); - } finally { - eventExecutor.shutdownGracefully(); - } - } @Test void shouldThrowInBlockingGetWhenFutureThrowsUncheckedException() { diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/Matchers.java b/driver/src/test/java/org/neo4j/driver/internal/util/Matchers.java index a640f5b688..aea8ae1795 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/Matchers.java +++ b/driver/src/test/java/org/neo4j/driver/internal/util/Matchers.java @@ -16,66 +16,58 @@ */ package org.neo4j.driver.internal.util; -import java.util.Objects; import java.util.concurrent.TimeUnit; import org.hamcrest.Description; import org.hamcrest.Matcher; import org.hamcrest.TypeSafeMatcher; -import org.neo4j.driver.Driver; import org.neo4j.driver.exceptions.ClientException; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DirectConnectionProvider; -import org.neo4j.driver.internal.InternalDriver; -import org.neo4j.driver.internal.SessionFactoryImpl; -import org.neo4j.driver.internal.cluster.loadbalancing.LoadBalancer; -import org.neo4j.driver.internal.spi.ConnectionProvider; import org.neo4j.driver.summary.ResultSummary; public final class Matchers { private Matchers() {} - public static Matcher directDriver() { - return new TypeSafeMatcher<>() { - @Override - protected boolean matchesSafely(Driver driver) { - return hasConnectionProvider(driver, DirectConnectionProvider.class); - } - - @Override - public void describeTo(Description description) { - description.appendText("direct 'bolt://' driver "); - } - }; - } - - public static Matcher directDriverWithAddress(final BoltServerAddress address) { - return new TypeSafeMatcher<>() { - @Override - protected boolean matchesSafely(Driver driver) { - var provider = extractConnectionProvider(driver, DirectConnectionProvider.class); - return provider != null && Objects.equals(provider.getAddress(), address); - } - - @Override - public void describeTo(Description description) { - description.appendText("direct driver with address bolt://").appendValue(address); - } - }; - } - - public static Matcher clusterDriver() { - return new TypeSafeMatcher<>() { - @Override - protected boolean matchesSafely(Driver driver) { - return hasConnectionProvider(driver, LoadBalancer.class); - } - - @Override - public void describeTo(Description description) { - description.appendText("cluster 'neo4j://' driver "); - } - }; - } + // public static Matcher directDriver() { + // return new TypeSafeMatcher<>() { + // @Override + // protected boolean matchesSafely(Driver driver) { + // return hasConnectionProvider(driver, DirectConnectionProvider.class); + // } + // + // @Override + // public void describeTo(Description description) { + // description.appendText("direct 'bolt://' driver "); + // } + // }; + // } + // + // public static Matcher directDriverWithAddress(final BoltServerAddress address) { + // return new TypeSafeMatcher<>() { + // @Override + // protected boolean matchesSafely(Driver driver) { + // var provider = extractConnectionProvider(driver, DirectConnectionProvider.class); + // return provider != null && Objects.equals(provider.getAddress(), address); + // } + // + // @Override + // public void describeTo(Description description) { + // description.appendText("direct driver with address bolt://").appendValue(address); + // } + // }; + // } + // + // public static Matcher clusterDriver() { + // return new TypeSafeMatcher<>() { + // @Override + // protected boolean matchesSafely(Driver driver) { + // return hasConnectionProvider(driver, LoadBalancer.class); + // } + // + // @Override + // public void describeTo(Description description) { + // description.appendText("cluster 'neo4j://' driver "); + // } + // }; + // } public static Matcher containsResultAvailableAfterAndResultConsumedAfter() { return new TypeSafeMatcher<>() { @@ -165,20 +157,22 @@ public void describeTo(Description description) { }; } - private static boolean hasConnectionProvider(Driver driver, Class providerClass) { - return extractConnectionProvider(driver, providerClass) != null; - } - - private static T extractConnectionProvider(Driver driver, Class providerClass) { - if (driver instanceof InternalDriver) { - var sessionFactory = ((InternalDriver) driver).getSessionFactory(); - if (sessionFactory instanceof SessionFactoryImpl) { - var provider = ((SessionFactoryImpl) sessionFactory).getConnectionProvider(); - if (providerClass.isInstance(provider)) { - return providerClass.cast(provider); - } - } - } - return null; - } + // private static boolean hasConnectionProvider(Driver driver, Class providerClass) + // { + // return extractConnectionProvider(driver, providerClass) != null; + // } + // + // private static T extractConnectionProvider(Driver driver, Class + // providerClass) { + // if (driver instanceof InternalDriver) { + // var sessionFactory = ((InternalDriver) driver).getSessionFactory(); + // if (sessionFactory instanceof SessionFactoryImpl) { + // var provider = ((SessionFactoryImpl) sessionFactory).getConnectionProvider(); + // if (providerClass.isInstance(provider)) { + // return providerClass.cast(provider); + // } + // } + // } + // return null; + // } } diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/MessageRecordingDriverFactory.java b/driver/src/test/java/org/neo4j/driver/internal/util/MessageRecordingDriverFactory.java deleted file mode 100644 index 7d16f60c91..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/util/MessageRecordingDriverFactory.java +++ /dev/null @@ -1,92 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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 io.netty.channel.Channel; -import io.netty.channel.ChannelHandlerContext; -import io.netty.channel.ChannelPipeline; -import io.netty.handler.codec.MessageToMessageEncoder; -import java.time.Clock; -import java.util.List; -import java.util.Map; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.CopyOnWriteArrayList; -import org.neo4j.driver.Config; -import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.BoltAgent; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.ConnectionSettings; -import org.neo4j.driver.internal.DefaultDomainNameResolver; -import org.neo4j.driver.internal.DriverFactory; -import org.neo4j.driver.internal.async.connection.ChannelConnector; -import org.neo4j.driver.internal.async.connection.ChannelConnectorImpl; -import org.neo4j.driver.internal.async.connection.ChannelPipelineBuilder; -import org.neo4j.driver.internal.async.connection.ChannelPipelineBuilderImpl; -import org.neo4j.driver.internal.async.outbound.OutboundMessageHandler; -import org.neo4j.driver.internal.cluster.RoutingContext; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.security.SecurityPlan; - -public class MessageRecordingDriverFactory extends DriverFactory { - private final Map> messagesByChannel = new ConcurrentHashMap<>(); - - public Map> getMessagesByChannel() { - return messagesByChannel; - } - - @Override - protected ChannelConnector createConnector( - ConnectionSettings settings, - SecurityPlan securityPlan, - Config config, - Clock clock, - RoutingContext routingContext, - BoltAgent boltAgent) { - ChannelPipelineBuilder pipelineBuilder = new MessageRecordingChannelPipelineBuilder(); - return new ChannelConnectorImpl( - settings, - securityPlan, - pipelineBuilder, - config.logging(), - clock, - routingContext, - DefaultDomainNameResolver.getInstance(), - null, - BoltAgentUtil.VALUE); - } - - private class MessageRecordingChannelPipelineBuilder extends ChannelPipelineBuilderImpl { - @Override - public void build(MessageFormat messageFormat, ChannelPipeline pipeline, Logging logging) { - super.build(messageFormat, pipeline, logging); - pipeline.addAfter( - OutboundMessageHandler.NAME, - MessageRecordingHandler.class.getSimpleName(), - new MessageRecordingHandler()); - } - } - - private class MessageRecordingHandler extends MessageToMessageEncoder { - @Override - protected void encode(ChannelHandlerContext ctx, Message msg, List out) { - var messages = messagesByChannel.computeIfAbsent(ctx.channel(), ignore -> new CopyOnWriteArrayList<>()); - messages.add(msg); - out.add(msg); - } - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/MetadataExtractorTest.java b/driver/src/test/java/org/neo4j/driver/internal/util/MetadataExtractorTest.java index 8a7f5bf714..322abc766f 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/MetadataExtractorTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/util/MetadataExtractorTest.java @@ -17,7 +17,6 @@ package org.neo4j.driver.internal.util; import static java.util.Arrays.asList; -import static java.util.Collections.emptyList; import static java.util.Collections.emptyMap; import static java.util.Collections.singletonMap; import static org.hamcrest.CoreMatchers.startsWith; @@ -34,70 +33,28 @@ import static org.neo4j.driver.Values.values; import static org.neo4j.driver.internal.summary.InternalSummaryCounters.EMPTY_STATS; import static org.neo4j.driver.internal.util.MetadataExtractor.extractDatabaseInfo; -import static org.neo4j.driver.internal.util.MetadataExtractor.extractServer; import static org.neo4j.driver.summary.QueryType.READ_ONLY; import static org.neo4j.driver.summary.QueryType.READ_WRITE; import static org.neo4j.driver.summary.QueryType.SCHEMA_WRITE; import static org.neo4j.driver.summary.QueryType.WRITE_ONLY; -import java.util.HashMap; -import java.util.Map; import java.util.concurrent.TimeUnit; import org.junit.jupiter.api.Test; import org.neo4j.driver.NotificationCategory; import org.neo4j.driver.NotificationSeverity; import org.neo4j.driver.Query; import org.neo4j.driver.Value; -import org.neo4j.driver.Values; -import org.neo4j.driver.exceptions.UntrustedServerException; import org.neo4j.driver.exceptions.value.Uncoercible; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.InternalBookmark; -import org.neo4j.driver.internal.messaging.v43.BoltProtocolV43; -import org.neo4j.driver.internal.spi.Connection; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; import org.neo4j.driver.internal.summary.InternalInputPosition; import org.neo4j.driver.summary.ResultSummary; class MetadataExtractorTest { - private static final String RESULT_AVAILABLE_AFTER_KEY = "available_after"; private static final String RESULT_CONSUMED_AFTER_KEY = "consumed_after"; - private final MetadataExtractor extractor = - new MetadataExtractor(RESULT_AVAILABLE_AFTER_KEY, RESULT_CONSUMED_AFTER_KEY); - - @Test - void shouldExtractQueryKeys() { - var keys = asList("hello", " ", "world", "!"); - Map keyIndex = new HashMap<>(); - keyIndex.put("hello", 0); - keyIndex.put(" ", 1); - keyIndex.put("world", 2); - keyIndex.put("!", 3); - - var extracted = extractor.extractQueryKeys(singletonMap("fields", value(keys))); - assertEquals(keys, extracted.keys()); - assertEquals(keyIndex, extracted.keyIndex()); - } - - @Test - void shouldExtractEmptyQueryKeysWhenNoneInMetadata() { - var extracted = extractor.extractQueryKeys(emptyMap()); - assertEquals(emptyList(), extracted.keys()); - assertEquals(emptyMap(), extracted.keyIndex()); - } - - @Test - void shouldExtractResultAvailableAfter() { - var metadata = singletonMap(RESULT_AVAILABLE_AFTER_KEY, value(424242)); - var extractedResultAvailableAfter = extractor.extractResultAvailableAfter(metadata); - assertEquals(424242L, extractedResultAvailableAfter); - } - - @Test - void shouldExtractNoResultAvailableAfterWhenNoneInMetadata() { - var extractedResultAvailableAfter = extractor.extractResultAvailableAfter(emptyMap()); - assertEquals(-1, extractedResultAvailableAfter); - } + private final MetadataExtractor extractor = new MetadataExtractor(RESULT_CONSUMED_AFTER_KEY); @Test void shouldBuildResultSummaryWithQuery() { @@ -340,46 +297,6 @@ void shouldBuildResultSummaryWithoutResultConsumedAfter() { assertEquals(-1, summary.resultConsumedAfter(TimeUnit.MILLISECONDS)); } - @Test - void shouldExtractBookmark() { - var bookmarkValue = "neo4j:bookmark:v1:tx123456"; - - var bookmark = MetadataExtractor.extractBookmark(singletonMap("bookmark", value(bookmarkValue))); - - assertEquals(InternalBookmark.parse(bookmarkValue), bookmark); - } - - @Test - void shouldExtractNoBookmarkWhenMetadataContainsNull() { - var bookmark = MetadataExtractor.extractBookmark(singletonMap("bookmark", null)); - - assertNull(bookmark); - } - - @Test - void shouldExtractNoBookmarkWhenMetadataContainsNullValue() { - var bookmark = MetadataExtractor.extractBookmark(singletonMap("bookmark", Values.NULL)); - - assertNull(bookmark); - } - - @Test - void shouldExtractNoBookmarkWhenMetadataContainsValueOfIncorrectType() { - var bookmark = MetadataExtractor.extractBookmark(singletonMap("bookmark", value(42))); - - assertNull(bookmark); - } - - @Test - void shouldExtractServer() { - var agent = "Neo4j/3.5.0"; - var metadata = singletonMap("server", value(agent)); - - var serverValue = extractServer(metadata); - - assertEquals(agent, serverValue.asString()); - } - @Test void shouldExtractDatabase() { // Given @@ -416,18 +333,6 @@ void shouldErrorWhenTypeIsWrong() { assertThat(error.getMessage(), startsWith("Cannot coerce INTEGER to Java String")); } - @Test - void shouldFailToExtractServerVersionWhenMetadataDoesNotContainIt() { - assertThrows(UntrustedServerException.class, () -> extractServer(singletonMap("server", Values.NULL))); - assertThrows(UntrustedServerException.class, () -> extractServer(singletonMap("server", null))); - } - - @Test - void shouldFailToExtractServerVersionFromNonNeo4jProduct() { - assertThrows( - UntrustedServerException.class, () -> extractServer(singletonMap("server", value("NotNeo4j/1.2.3")))); - } - private ResultSummary createWithQueryType(Value typeValue) { var metadata = singletonMap("type", typeValue); return extractor.extractSummary(query(), connectionMock(), 42, metadata); @@ -437,14 +342,14 @@ private static Query query() { return new Query("RETURN 1"); } - private static Connection connectionMock() { + private static BoltConnection connectionMock() { return connectionMock(BoltServerAddress.LOCAL_DEFAULT); } - private static Connection connectionMock(BoltServerAddress address) { - var connection = mock(Connection.class); + private static BoltConnection connectionMock(BoltServerAddress address) { + var connection = mock(BoltConnection.class); when(connection.serverAddress()).thenReturn(address); - when(connection.protocol()).thenReturn(BoltProtocolV43.INSTANCE); + when(connection.protocolVersion()).thenReturn(new BoltProtocolVersion(4, 3)); when(connection.serverAgent()).thenReturn("Neo4j/4.2.5"); return connection; } diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/io/ChannelPipelineBuilderWithFailingMessageFormat.java b/driver/src/test/java/org/neo4j/driver/internal/util/io/ChannelPipelineBuilderWithFailingMessageFormat.java deleted file mode 100644 index 5d17f9f0ed..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/util/io/ChannelPipelineBuilderWithFailingMessageFormat.java +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.io; - -import io.netty.channel.ChannelPipeline; -import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.async.connection.ChannelPipelineBuilder; -import org.neo4j.driver.internal.async.connection.ChannelPipelineBuilderImpl; -import org.neo4j.driver.internal.messaging.MessageFormat; -import org.neo4j.driver.internal.util.FailingMessageFormat; - -public class ChannelPipelineBuilderWithFailingMessageFormat implements ChannelPipelineBuilder { - private volatile FailingMessageFormat failingMessageFormat; - - @Override - public void build(MessageFormat messageFormat, ChannelPipeline pipeline, Logging logging) { - if (failingMessageFormat == null) { - failingMessageFormat = new FailingMessageFormat(messageFormat); - } - new ChannelPipelineBuilderImpl().build(failingMessageFormat, pipeline, logging); - } - - FailingMessageFormat getFailingMessageFormat() { - return failingMessageFormat; - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/io/ChannelTrackingConnector.java b/driver/src/test/java/org/neo4j/driver/internal/util/io/ChannelTrackingConnector.java deleted file mode 100644 index 00440cbda1..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/util/io/ChannelTrackingConnector.java +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.io; - -import io.netty.bootstrap.Bootstrap; -import io.netty.channel.Channel; -import io.netty.channel.ChannelFuture; -import java.util.List; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.async.connection.ChannelConnector; - -public class ChannelTrackingConnector implements ChannelConnector { - private final ChannelConnector realConnector; - private final List channels; - - public ChannelTrackingConnector(ChannelConnector realConnector, List channels) { - this.realConnector = realConnector; - this.channels = channels; - } - - @Override - public ChannelFuture connect(BoltServerAddress address, Bootstrap bootstrap) { - var channelFuture = realConnector.connect(address, bootstrap); - channels.add(channelFuture.channel()); - return channelFuture; - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/io/ChannelTrackingDriverFactory.java b/driver/src/test/java/org/neo4j/driver/internal/util/io/ChannelTrackingDriverFactory.java deleted file mode 100644 index 74c67bf497..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/util/io/ChannelTrackingDriverFactory.java +++ /dev/null @@ -1,104 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.io; - -import io.netty.bootstrap.Bootstrap; -import io.netty.channel.Channel; -import java.time.Clock; -import java.util.ArrayList; -import java.util.List; -import java.util.concurrent.CopyOnWriteArrayList; -import org.neo4j.driver.AuthTokenManager; -import org.neo4j.driver.Config; -import org.neo4j.driver.internal.BoltAgent; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.ConnectionSettings; -import org.neo4j.driver.internal.async.connection.BootstrapFactory; -import org.neo4j.driver.internal.async.connection.ChannelConnector; -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.spi.ConnectionPool; -import org.neo4j.driver.internal.util.DriverFactoryWithClock; - -public class ChannelTrackingDriverFactory extends DriverFactoryWithClock { - private final List channels = new CopyOnWriteArrayList<>(); - private final int eventLoopThreads; - private ConnectionPool pool; - - public ChannelTrackingDriverFactory(Clock clock) { - this(0, clock); - } - - public ChannelTrackingDriverFactory(int eventLoopThreads, Clock clock) { - super(clock); - this.eventLoopThreads = eventLoopThreads; - } - - @Override - protected Bootstrap createBootstrap(int size) { - return BootstrapFactory.newBootstrap(eventLoopThreads); - } - - @Override - protected final ChannelConnector createConnector( - ConnectionSettings settings, - SecurityPlan securityPlan, - Config config, - Clock clock, - RoutingContext routingContext, - BoltAgent boltAgent) { - return createChannelTrackingConnector( - createRealConnector(settings, securityPlan, config, clock, routingContext)); - } - - @Override - protected final ConnectionPool createConnectionPool( - AuthTokenManager authTokenManager, - SecurityPlan securityPlan, - Bootstrap bootstrap, - MetricsProvider metricsProvider, - Config config, - boolean ownsEventLoopGroup, - RoutingContext routingContext) { - pool = super.createConnectionPool( - authTokenManager, securityPlan, bootstrap, metricsProvider, config, ownsEventLoopGroup, routingContext); - return pool; - } - - protected ChannelConnector createRealConnector( - ConnectionSettings settings, - SecurityPlan securityPlan, - Config config, - Clock clock, - RoutingContext routingContext) { - return super.createConnector(settings, securityPlan, config, clock, routingContext, BoltAgentUtil.VALUE); - } - - private ChannelTrackingConnector createChannelTrackingConnector(ChannelConnector connector) { - return new ChannelTrackingConnector(connector, channels); - } - - public List channels() { - return new ArrayList<>(channels); - } - - public int activeChannels(BoltServerAddress address) { - return pool == null ? 0 : pool.inUseConnections(address); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/io/ChannelTrackingDriverFactoryWithFailingMessageFormat.java b/driver/src/test/java/org/neo4j/driver/internal/util/io/ChannelTrackingDriverFactoryWithFailingMessageFormat.java deleted file mode 100644 index cd1e29b711..0000000000 --- a/driver/src/test/java/org/neo4j/driver/internal/util/io/ChannelTrackingDriverFactoryWithFailingMessageFormat.java +++ /dev/null @@ -1,60 +0,0 @@ -/* - * Copyright (c) "Neo4j" - * Neo4j Sweden AB [https://neo4j.com] - * - * 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.io; - -import java.time.Clock; -import org.neo4j.driver.Config; -import org.neo4j.driver.internal.BoltAgentUtil; -import org.neo4j.driver.internal.ConnectionSettings; -import org.neo4j.driver.internal.DefaultDomainNameResolver; -import org.neo4j.driver.internal.async.connection.ChannelConnector; -import org.neo4j.driver.internal.async.connection.ChannelConnectorImpl; -import org.neo4j.driver.internal.cluster.RoutingContext; -import org.neo4j.driver.internal.security.SecurityPlan; -import org.neo4j.driver.internal.util.FailingMessageFormat; - -public class ChannelTrackingDriverFactoryWithFailingMessageFormat extends ChannelTrackingDriverFactory { - private final ChannelPipelineBuilderWithFailingMessageFormat pipelineBuilder = - new ChannelPipelineBuilderWithFailingMessageFormat(); - - public ChannelTrackingDriverFactoryWithFailingMessageFormat(Clock clock) { - super(clock); - } - - @Override - protected ChannelConnector createRealConnector( - ConnectionSettings settings, - SecurityPlan securityPlan, - Config config, - Clock clock, - RoutingContext routingContext) { - return new ChannelConnectorImpl( - settings, - securityPlan, - pipelineBuilder, - config.logging(), - clock, - routingContext, - DefaultDomainNameResolver.getInstance(), - null, - BoltAgentUtil.VALUE); - } - - public FailingMessageFormat getFailingMessageFormat() { - return pipelineBuilder.getFailingMessageFormat(); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/testutil/DatabaseExtension.java b/driver/src/test/java/org/neo4j/driver/testutil/DatabaseExtension.java index e2265f4274..5729d02d69 100644 --- a/driver/src/test/java/org/neo4j/driver/testutil/DatabaseExtension.java +++ b/driver/src/test/java/org/neo4j/driver/testutil/DatabaseExtension.java @@ -45,7 +45,7 @@ import org.neo4j.driver.Config; import org.neo4j.driver.Driver; import org.neo4j.driver.GraphDatabase; -import org.neo4j.driver.internal.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; import org.neo4j.driver.internal.security.StaticAuthTokenManager; import org.neo4j.driver.testutil.CertificateUtil.CertificateKeyPair; import org.testcontainers.DockerClientFactory; diff --git a/driver/src/test/java/org/neo4j/driver/testutil/LoggingUtil.java b/driver/src/test/java/org/neo4j/driver/testutil/LoggingUtil.java index c9fa880045..826094ccb9 100644 --- a/driver/src/test/java/org/neo4j/driver/testutil/LoggingUtil.java +++ b/driver/src/test/java/org/neo4j/driver/testutil/LoggingUtil.java @@ -27,8 +27,8 @@ import java.util.List; import org.neo4j.driver.Logger; import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; -import org.neo4j.driver.internal.async.outbound.OutboundMessageHandler; +import org.neo4j.driver.internal.bolt.basicimpl.async.inbound.InboundMessageDispatcher; +import org.neo4j.driver.internal.bolt.basicimpl.async.outbound.OutboundMessageHandler; public class LoggingUtil { public static Logging boltLogging(List messages) { diff --git a/driver/src/test/java/org/neo4j/driver/testutil/TestUtil.java b/driver/src/test/java/org/neo4j/driver/testutil/TestUtil.java index fb77ac9ac9..a3c872a56c 100644 --- a/driver/src/test/java/org/neo4j/driver/testutil/TestUtil.java +++ b/driver/src/test/java/org/neo4j/driver/testutil/TestUtil.java @@ -16,26 +16,25 @@ */ package org.neo4j.driver.testutil; -import static java.util.Collections.emptyMap; import static java.util.concurrent.TimeUnit.MILLISECONDS; import static java.util.concurrent.TimeUnit.MINUTES; import static java.util.stream.Collectors.toList; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.argThat; -import static org.mockito.Mockito.doAnswer; +import static org.mockito.ArgumentMatchers.anyLong; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.BDDMockito.given; +import static org.mockito.BDDMockito.then; +import static org.mockito.Mockito.atLeastOnce; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static org.neo4j.driver.AccessMode.WRITE; import static org.neo4j.driver.SessionConfig.forDatabase; -import static org.neo4j.driver.internal.DatabaseNameUtil.database; -import static org.neo4j.driver.internal.DatabaseNameUtil.defaultDatabase; -import static org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil.UNLIMITED_FETCH_SIZE; +import static org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.defaultDatabase; import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; -import static org.neo4j.driver.internal.util.Futures.completedWithNull; import io.netty.buffer.ByteBuf; import io.netty.util.internal.PlatformDependent; @@ -52,7 +51,6 @@ import java.util.HashSet; import java.util.LinkedHashSet; import java.util.List; -import java.util.Objects; import java.util.Set; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionStage; @@ -60,47 +58,34 @@ import java.util.concurrent.Future; import java.util.concurrent.ThreadLocalRandom; import java.util.concurrent.TimeoutException; -import java.util.function.Predicate; +import java.util.function.Consumer; import java.util.stream.Collectors; import java.util.stream.IntStream; -import org.mockito.ArgumentMatcher; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; import org.mockito.verification.VerificationMode; import org.neo4j.driver.AccessMode; +import org.neo4j.driver.AuthTokenManager; import org.neo4j.driver.Bookmark; +import org.neo4j.driver.Config; import org.neo4j.driver.Driver; import org.neo4j.driver.Session; import org.neo4j.driver.SessionConfig; import org.neo4j.driver.exceptions.ServiceUnavailableException; -import org.neo4j.driver.internal.BoltServerAddress; import org.neo4j.driver.internal.NoOpBookmarkManager; import org.neo4j.driver.internal.async.NetworkSession; -import org.neo4j.driver.internal.async.connection.EventLoopGroupFactory; -import org.neo4j.driver.internal.handlers.BeginTxResponseHandler; -import org.neo4j.driver.internal.messaging.BoltProtocol; -import org.neo4j.driver.internal.messaging.BoltProtocolVersion; -import org.neo4j.driver.internal.messaging.Message; -import org.neo4j.driver.internal.messaging.request.BeginMessage; -import org.neo4j.driver.internal.messaging.request.CommitMessage; -import org.neo4j.driver.internal.messaging.request.PullMessage; -import org.neo4j.driver.internal.messaging.request.RollbackMessage; -import org.neo4j.driver.internal.messaging.request.RunWithMetadataMessage; -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.messaging.v52.BoltProtocolV52; -import org.neo4j.driver.internal.messaging.v53.BoltProtocolV53; -import org.neo4j.driver.internal.messaging.v54.BoltProtocolV54; +import org.neo4j.driver.internal.bolt.api.BoltConnection; +import org.neo4j.driver.internal.bolt.api.BoltConnectionProvider; +import org.neo4j.driver.internal.bolt.api.BoltProtocolVersion; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.ResponseHandler; +import org.neo4j.driver.internal.bolt.api.summary.CommitSummary; +import org.neo4j.driver.internal.bolt.api.summary.PullSummary; +import org.neo4j.driver.internal.bolt.api.summary.RunSummary; +import org.neo4j.driver.internal.bolt.basicimpl.async.connection.EventLoopGroupFactory; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.BoltProtocol; +import org.neo4j.driver.internal.bolt.basicimpl.messaging.v4.BoltProtocolV4; import org.neo4j.driver.internal.retry.RetryLogic; -import org.neo4j.driver.internal.spi.Connection; -import org.neo4j.driver.internal.spi.ConnectionProvider; -import org.neo4j.driver.internal.spi.ResponseHandler; import org.neo4j.driver.internal.util.FixedRetryLogic; import org.reactivestreams.Publisher; import reactor.core.publisher.Flux; @@ -110,7 +95,7 @@ public final class TestUtil { public static final BoltProtocolVersion DEFAULT_TEST_PROTOCOL_VERSION = BoltProtocolV4.VERSION; public static final BoltProtocol DEFAULT_TEST_PROTOCOL = BoltProtocol.forVersion(DEFAULT_TEST_PROTOCOL_VERSION); - private static final long DEFAULT_WAIT_TIME_MS = MINUTES.toMillis(2); + private static final long DEFAULT_WAIT_TIME_MS = MINUTES.toMillis(100); private static final String ALPHANUMERICS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz123456789"; public static final Duration TX_TIMEOUT_TEST_TIMEOUT = Duration.ofSeconds(10); @@ -230,34 +215,37 @@ public static boolean databaseExists(Driver driver, String database) { } } - public static NetworkSession newSession(ConnectionProvider connectionProvider, Set bookmarks) { + public static NetworkSession newSession(BoltConnectionProvider connectionProvider, Set bookmarks) { return newSession(connectionProvider, WRITE, bookmarks); } private static NetworkSession newSession( - ConnectionProvider connectionProvider, AccessMode mode, Set bookmarks) { + BoltConnectionProvider connectionProvider, AccessMode mode, Set bookmarks) { return newSession(connectionProvider, mode, new FixedRetryLogic(0), bookmarks); } - public static NetworkSession newSession(ConnectionProvider connectionProvider, AccessMode mode) { + public static NetworkSession newSession(BoltConnectionProvider connectionProvider, AccessMode mode) { return newSession(connectionProvider, mode, Collections.emptySet()); } - public static NetworkSession newSession(ConnectionProvider connectionProvider, RetryLogic logic) { + public static NetworkSession newSession(BoltConnectionProvider connectionProvider, RetryLogic logic) { return newSession(connectionProvider, WRITE, logic, Collections.emptySet()); } - public static NetworkSession newSession(ConnectionProvider connectionProvider) { + public static NetworkSession newSession(BoltConnectionProvider connectionProvider) { return newSession(connectionProvider, WRITE, Collections.emptySet()); } public static NetworkSession newSession( - ConnectionProvider connectionProvider, AccessMode mode, RetryLogic retryLogic, Set bookmarks) { + BoltConnectionProvider connectionProvider, + AccessMode mode, + RetryLogic retryLogic, + Set bookmarks) { return newSession(connectionProvider, mode, retryLogic, bookmarks, true); } public static NetworkSession newSession( - ConnectionProvider connectionProvider, + BoltConnectionProvider connectionProvider, AccessMode mode, RetryLogic retryLogic, Set bookmarks, @@ -269,212 +257,260 @@ public static NetworkSession newSession( mode, bookmarks, null, - UNLIMITED_FETCH_SIZE, + -1, DEV_NULL_LOGGING, NoOpBookmarkManager.INSTANCE, + Config.defaultConfig().notificationConfig(), + Config.defaultConfig().notificationConfig(), null, - null, - telemetryDisabled); + telemetryDisabled, + mock(AuthTokenManager.class)); } - public static void verifyRunRx(Connection connection, String query) { - verify(connection).writeAndFlush(argThat(runWithMetaMessageWithQueryMatcher(query)), any()); + public static void setupConnectionAnswers( + BoltConnection connection, List> handlerConsumers) { + given(connection.flush(any())).willAnswer(new Answer>() { + private int index; + + @Override + public CompletionStage answer(InvocationOnMock invocation) throws Throwable { + var handler = (ResponseHandler) invocation.getArguments()[0]; + var consumer = handlerConsumers.get(index++); + consumer.accept(handler); + return CompletableFuture.completedFuture(null); + } + }); } - public static void verifyRunAndPull(Connection connection, String query) { - verify(connection).write(argThat(runWithMetaMessageWithQueryMatcher(query)), any()); - verify(connection).writeAndFlush(any(PullMessage.class), any()); + public static void verifyAutocommitRunRx(BoltConnection connection, String query) { + then(connection) + .should() + .runInAutoCommitTransaction(any(), any(), any(), any(), eq(query), any(), any(), any(), any()); + then(connection).should().flush(any()); } - public static void verifyCommitTx(Connection connection, VerificationMode mode) { - verify(connection, mode).writeAndFlush(any(CommitMessage.class), any()); + public static void verifyRunAndPull(BoltConnection connection, String query) { + then(connection).should().run(eq(query), any()); + then(connection).should().pull(anyLong(), anyLong()); + then(connection).should(atLeastOnce()).flush(any()); } - public static void verifyCommitTx(Connection connection) { - verifyCommitTx(connection, times(1)); + public static void verifyAutocommitRunAndPull(BoltConnection connection, String query) { + then(connection) + .should() + .runInAutoCommitTransaction(any(), any(), any(), any(), eq(query), any(), any(), any(), any()); + then(connection).should().pull(anyLong(), anyLong()); + then(connection).should().flush(any()); } - public static void verifyRollbackTx(Connection connection, VerificationMode mode) { - verify(connection, mode).writeAndFlush(any(RollbackMessage.class), any()); + public static void verifyCommitTx(BoltConnection connection, VerificationMode mode) { + verify(connection, mode).commit(); + verify(connection, mode).close(); } - public static void verifyRollbackTx(Connection connection) { - verifyRollbackTx(connection, times(1)); + public static void verifyCommitTx(BoltConnection connection) { + verifyCommitTx(connection, times(1)); } - public static void verifyBeginTx(Connection connectionMock) { - verifyBeginTx(connectionMock, 1); + public static void verifyRollbackTx(BoltConnection connection, VerificationMode mode) { + verify(connection, mode).rollback(); } - public static void verifyBeginTx(Connection connectionMock, int times) { - verify(connectionMock, times(times)).writeAndFlush(any(BeginMessage.class), any(BeginTxResponseHandler.class)); + public static void verifyRollbackTx(BoltConnection connection) { + verifyRollbackTx(connection, times(1)); + verify(connection, atLeastOnce()).close(); + } + + // public static void verifyBeginTx(Connection connectionMock) { + // verifyBeginTx(connectionMock, 1); + // } + // + // public static void verifyBeginTx(Connection connectionMock, int times) { + // verify(connectionMock, times(times)).writeAndFlush(any(BeginMessage.class), + // any(BeginTxResponseHandler.class)); + // } + + public static void setupFailingRun(BoltConnection connection, Throwable error) { + given(connection.run(any(), any())).willAnswer((Answer>) + invocation -> CompletableFuture.completedStage(connection)); + given(connection.pull(anyLong(), anyLong())).willAnswer((Answer>) + invocation -> CompletableFuture.completedStage(connection)); + given(connection.flush(any())).willAnswer((Answer>) invocation -> { + var handler = (ResponseHandler) invocation.getArgument(0); + handler.onError(error); + handler.onComplete(); + return CompletableFuture.completedStage(null); + }); } - public static void setupFailingRun(Connection connection, Throwable error) { - doAnswer(invocation -> { - ResponseHandler runHandler = invocation.getArgument(1); - runHandler.onFailure(error); - return null; - }) - .when(connection) - .write(any(RunWithMetadataMessage.class), any()); + // public static void setupFailingBegin(Connection connection, Throwable error) { + // // with bookmarks + // doAnswer(invocation -> { + // ResponseHandler handler = invocation.getArgument(1); + // handler.onFailure(error); + // return null; + // }) + // .when(connection) + // .writeAndFlush(any(BeginMessage.class), any(BeginTxResponseHandler.class)); + // } - doAnswer(invocation -> { - ResponseHandler pullHandler = invocation.getArgument(1); - pullHandler.onFailure(error); - return null; - }) - .when(connection) - .writeAndFlush(any(PullMessage.class), any()); + public static void setupFailingCommit(BoltConnection connection) { + setupFailingCommit(connection, 1); } - public static void setupFailingBegin(Connection connection, Throwable error) { - // with bookmarks - doAnswer(invocation -> { - ResponseHandler handler = invocation.getArgument(1); - handler.onFailure(error); - return null; - }) - .when(connection) - .writeAndFlush(any(BeginMessage.class), any(BeginTxResponseHandler.class)); + public static void setupFailingCommit(BoltConnection connection, int times) { + given(connection.commit()).willAnswer((Answer>) + invocation -> CompletableFuture.completedStage(connection)); + given(connection.flush(any())).willAnswer(new Answer>() { + int invoked; + + @Override + public CompletionStage answer(InvocationOnMock invocation) throws Throwable { + var handler = (ResponseHandler) invocation.getArgument(0); + if (invoked++ < times) { + handler.onError(new ServiceUnavailableException("")); + } else { + handler.onCommitSummary(mock(CommitSummary.class)); + } + handler.onComplete(); + return CompletableFuture.completedStage(null); + } + }); } - public static void setupFailingCommit(Connection connection) { - setupFailingCommit(connection, 1); + public static void setupFailingRollback(BoltConnection connection) { + setupFailingRollback(connection, 1); } - public static void setupFailingCommit(Connection connection, int times) { - doAnswer(new Answer() { - int invoked; + public static void setupFailingRollback(BoltConnection connection, int times) { + given(connection.rollback()).willAnswer((Answer>) + invocation -> CompletableFuture.completedStage(connection)); + given(connection.flush(any())).willAnswer(new Answer>() { + int invoked; + + @Override + public CompletionStage answer(InvocationOnMock invocation) throws Throwable { + var handler = (ResponseHandler) invocation.getArgument(0); + if (invoked++ < times) { + handler.onError(new ServiceUnavailableException("")); + } else { + handler.onCommitSummary(mock(CommitSummary.class)); + } + return CompletableFuture.completedStage(null); + } + }); + } - @Override - public Void answer(InvocationOnMock invocation) { - ResponseHandler handler = invocation.getArgument(1); - if (invoked++ < times) { - handler.onFailure(new ServiceUnavailableException("")); - } else { - handler.onSuccess(emptyMap()); - } - return null; - } - }) - .when(connection) - .writeAndFlush(any(CommitMessage.class), any()); + public static void setupSuccessfulRunAndPull(BoltConnection connection) { + given(connection.run(any(), any())).willAnswer((Answer>) + invocation -> CompletableFuture.completedStage(connection)); + given(connection.pull(anyLong(), anyLong())).willAnswer((Answer>) + invocation -> CompletableFuture.completedStage(connection)); + given(connection.flush(any())).willAnswer((Answer>) invocation -> { + var handler = (ResponseHandler) invocation.getArgument(0); + var runSummary = mock(RunSummary.class); + given(runSummary.keys()).willReturn(Collections.emptyList()); + handler.onRunSummary(runSummary); + var pullSummary = mock(PullSummary.class); + given(pullSummary.metadata()).willReturn(Collections.emptyMap()); + handler.onPullSummary(pullSummary); + handler.onComplete(); + return CompletableFuture.completedStage(null); + }); } - public static void setupFailingRollback(Connection connection) { - setupFailingRollback(connection, 1); + public static void setupSuccessfulAutocommitRunAndPull(BoltConnection connection) { + given(connection.runInAutoCommitTransaction(any(), any(), any(), any(), any(), any(), any(), any(), any())) + .willAnswer((Answer>) + invocation -> CompletableFuture.completedStage(connection)); + given(connection.pull(anyLong(), anyLong())).willAnswer((Answer>) + invocation -> CompletableFuture.completedStage(connection)); + given(connection.flush(any())).willAnswer((Answer>) invocation -> { + var handler = (ResponseHandler) invocation.getArgument(0); + var runSummary = mock(RunSummary.class); + given(runSummary.keys()).willReturn(Collections.emptyList()); + handler.onRunSummary(runSummary); + var pullSummary = mock(PullSummary.class); + given(pullSummary.metadata()).willReturn(Collections.emptyMap()); + handler.onPullSummary(pullSummary); + handler.onComplete(); + return CompletableFuture.completedStage(null); + }); } - public static void setupFailingRollback(Connection connection, int times) { - doAnswer(new Answer() { - int invoked; - - @Override - public Void answer(InvocationOnMock invocation) { - ResponseHandler handler = invocation.getArgument(1); - if (invoked++ < times) { - handler.onFailure(new ServiceUnavailableException("")); - } else { - handler.onSuccess(emptyMap()); - } - return null; - } - }) - .when(connection) - .writeAndFlush(any(RollbackMessage.class), any()); - } - - public static void setupSuccessfulRunAndPull(Connection connection) { - doAnswer(invocation -> { - ResponseHandler runHandler = invocation.getArgument(1); - runHandler.onSuccess(emptyMap()); - return null; - }) - .when(connection) - .write(any(RunWithMetadataMessage.class), any()); - - doAnswer(invocation -> { - ResponseHandler pullHandler = invocation.getArgument(1); - pullHandler.onSuccess(emptyMap()); - return null; - }) - .when(connection) - .writeAndFlush(any(PullMessage.class), any()); - } - - public static void setupSuccessfulRunRx(Connection connection) { - doAnswer(invocation -> { - ResponseHandler runHandler = invocation.getArgument(1); - runHandler.onSuccess(emptyMap()); - return null; - }) - .when(connection) - .writeAndFlush(any(RunWithMetadataMessage.class), any()); - } - - public static void setupSuccessfulRunAndPull(Connection connection, String query) { - doAnswer(invocation -> { - ResponseHandler runHandler = invocation.getArgument(1); - runHandler.onSuccess(emptyMap()); - return null; - }) - .when(connection) - .write(argThat(runWithMetaMessageWithQueryMatcher(query)), any()); - - doAnswer(invocation -> { - ResponseHandler pullHandler = invocation.getArgument(1); - pullHandler.onSuccess(emptyMap()); - return null; - }) - .when(connection) - .writeAndFlush(any(PullMessage.class), any()); - } - - public static Connection connectionMock() { - return connectionMock(BoltProtocolV42.INSTANCE); - } - - public static Connection connectionMock(BoltProtocol protocol) { + // public static void setupSuccessfulRunRx(Connection connection) { + // doAnswer(invocation -> { + // ResponseHandler runHandler = invocation.getArgument(1); + // runHandler.onSuccess(emptyMap()); + // return null; + // }) + // .when(connection) + // .writeAndFlush(any(RunWithMetadataMessage.class), any()); + // } + // + // public static void setupSuccessfulRunAndPull(Connection connection, String query) { + // doAnswer(invocation -> { + // ResponseHandler runHandler = invocation.getArgument(1); + // runHandler.onSuccess(emptyMap()); + // return null; + // }) + // .when(connection) + // .write(argThat(runWithMetaMessageWithQueryMatcher(query)), any()); + // + // doAnswer(invocation -> { + // ResponseHandler pullHandler = invocation.getArgument(1); + // pullHandler.onSuccess(emptyMap()); + // return null; + // }) + // .when(connection) + // .writeAndFlush(any(PullMessage.class), any()); + // } + + public static BoltConnection connectionMock() { + return connectionMock(new BoltProtocolVersion(4, 2)); + } + + public static BoltConnection connectionMock(BoltProtocolVersion protocol) { return connectionMock(WRITE, protocol); } - public static Connection connectionMock(AccessMode mode, BoltProtocol protocol) { + public static BoltConnection connectionMock(AccessMode mode, BoltProtocolVersion protocol) { return connectionMock(null, mode, protocol); } - public static Connection connectionMock(String databaseName, BoltProtocol protocol) { + public static BoltConnection connectionMock(String databaseName, BoltProtocolVersion protocol) { return connectionMock(databaseName, WRITE, protocol); } - public static Connection connectionMock(String databaseName, AccessMode mode, BoltProtocol protocol) { - var connection = mock(Connection.class); + public static BoltConnection connectionMock( + String databaseName, AccessMode mode, BoltProtocolVersion protocolVersion) { + var connection = mock(BoltConnection.class); when(connection.serverAddress()).thenReturn(BoltServerAddress.LOCAL_DEFAULT); - when(connection.protocol()).thenReturn(protocol); - when(connection.mode()).thenReturn(mode); - when(connection.databaseName()).thenReturn(database(databaseName)); - var version = protocol.version(); - if (List.of( - BoltProtocolV3.VERSION, - BoltProtocolV4.VERSION, - BoltProtocolV41.VERSION, - BoltProtocolV42.VERSION, - BoltProtocolV43.VERSION, - BoltProtocolV44.VERSION, - BoltProtocolV5.VERSION, - BoltProtocolV51.VERSION, - BoltProtocolV52.VERSION, - BoltProtocolV53.VERSION, - BoltProtocolV54.VERSION) - .contains(version)) { - setupSuccessResponse(connection, CommitMessage.class); - setupSuccessResponse(connection, RollbackMessage.class); - setupSuccessResponse(connection, BeginMessage.class); - when(connection.release()).thenReturn(completedWithNull()); - when(connection.reset(any())).thenReturn(completedWithNull()); - } else { - throw new IllegalArgumentException("Unsupported bolt protocol version: " + version); - } + when(connection.protocolVersion()).thenReturn(protocolVersion); + // when(connection.mode()).thenReturn(mode); + // when(connection.databaseName()).thenReturn(database(databaseName)); + // var version = protocolVersion.version(); + // if (List.of( + // BoltProtocolV3.VERSION, + // BoltProtocolV4.VERSION, + // BoltProtocolV41.VERSION, + // BoltProtocolV42.VERSION, + // BoltProtocolV43.VERSION, + // BoltProtocolV44.VERSION, + // BoltProtocolV5.VERSION, + // BoltProtocolV51.VERSION, + // BoltProtocolV52.VERSION, + // BoltProtocolV53.VERSION, + // BoltProtocolV54.VERSION) + // .contains(version)) { + // setupSuccessResponse(connection, CommitMessage.class); + // setupSuccessResponse(connection, RollbackMessage.class); + // setupSuccessResponse(connection, BeginMessage.class); + // when(connection.release()).thenReturn(completedWithNull()); + // when(connection.reset(any())).thenReturn(completedWithNull()); + // } else { + // throw new IllegalArgumentException("Unsupported bolt protocol version: " + version); + // } return connection; } @@ -505,18 +541,18 @@ public static String randomString(int size) { .collect(Collectors.joining()); } - public static ArgumentMatcher runWithMetaMessageWithQueryMatcher(String query) { - return message -> message instanceof RunWithMetadataMessage - && Objects.equals(query, ((RunWithMetadataMessage) message).query()); - } - - public static ArgumentMatcher beginMessage() { - return beginMessageWithPredicate(ignored -> true); - } - - public static ArgumentMatcher beginMessageWithPredicate(Predicate predicate) { - return message -> message instanceof BeginMessage && predicate.test((BeginMessage) message); - } + // public static ArgumentMatcher runWithMetaMessageWithQueryMatcher(String query) { + // return message -> message instanceof RunWithMetadataMessage + // && Objects.equals(query, ((RunWithMetadataMessage) message).query()); + // } + // + // public static ArgumentMatcher beginMessage() { + // return beginMessageWithPredicate(ignored -> true); + // } + // + // public static ArgumentMatcher beginMessageWithPredicate(Predicate predicate) { + // return message -> message instanceof BeginMessage && predicate.test((BeginMessage) message); + // } public static void assertNoCircularReferences(Throwable ex) { assertNoCircularReferences(ex, new ArrayList<>()); @@ -538,15 +574,15 @@ private static void assertNoCircularReferences(Throwable ex, List lis } } - private static void setupSuccessResponse(Connection connection, Class messageType) { - doAnswer(invocation -> { - ResponseHandler handler = invocation.getArgument(1); - handler.onSuccess(emptyMap()); - return null; - }) - .when(connection) - .writeAndFlush(any(messageType), any()); - } + // private static void setupSuccessResponse(Connection connection, Class messageType) { + // doAnswer(invocation -> { + // ResponseHandler handler = invocation.getArgument(1); + // handler.onSuccess(emptyMap()); + // return null; + // }) + // .when(connection) + // .writeAndFlush(any(messageType), any()); + // } private static void cleanDb(Session session) { int nodesDeleted; diff --git a/examples/pom.xml b/examples/pom.xml index 55816d839c..060db236e8 100644 --- a/examples/pom.xml +++ b/examples/pom.xml @@ -6,7 +6,7 @@ org.neo4j.driver neo4j-java-driver-parent - 5.15-SNAPSHOT + 5.18-SNAPSHOT org.neo4j.doc.driver diff --git a/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java b/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java index 5424c22493..1acebb61c3 100644 --- a/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java +++ b/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java @@ -17,6 +17,7 @@ package org.neo4j.docs.driver; import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.neo4j.driver.SessionConfig; @@ -333,6 +334,7 @@ void testShouldConfigureTransactionMetadataExample() { } } + @Disabled @Test @SuppressWarnings("resource") void testShouldRunAsyncTransactionFunctionExample() { diff --git a/pom.xml b/pom.xml index 819d3074a0..2452ad46b2 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ org.neo4j.driver neo4j-java-driver-parent - 5.15-SNAPSHOT + 5.18-SNAPSHOT pom Neo4j Java Driver Project @@ -36,27 +36,32 @@ - 4.1.101.Final + 4.1.111.Final - 2023.0.0 + 2023.0.7 1.7.36 2.2 - 5.7.0 - 5.10.1 + 5.12.0 + 5.10.3 - 7.8.0 + 7.10.2 1.2.0 - 1.77 + + 1.25.0 + + 1.16.1 + 1.78.1 1.2.12 - 2.16.0 - 1.18.30 + 2.17.2 + 1.18.34 23.1.1 - 1.12.0 - 1.0.8.RELEASE - 1.19.3 - 5.14.0 + 1.13.2 + 1.0.9.RELEASE + 1.19.8 + 1.2.1 + 5.18.1 @@ -67,6 +72,7 @@ examples testkit-backend testkit-tests + benchkit-backend @@ -171,6 +177,18 @@ ${jarchivelib.version} test + + org.apache.commons + commons-compress + ${commons-compress.version} + test + + + commons-codec + commons-codec + ${commons-codec.version} + test + org.bouncycastle bcprov-jdk18on @@ -202,6 +220,12 @@ pom import + + com.tngtech.archunit + archunit-junit5 + ${archunit-junit5.version} + test + diff --git a/testkit-backend/pom.xml b/testkit-backend/pom.xml index 6ba6aa8d5e..9da5ffb90d 100644 --- a/testkit-backend/pom.xml +++ b/testkit-backend/pom.xml @@ -7,7 +7,7 @@ neo4j-java-driver-parent org.neo4j.driver - 5.15-SNAPSHOT + 5.18-SNAPSHOT testkit-backend diff --git a/testkit-backend/src/main/java/neo4j/org/testkit/backend/TestkitState.java b/testkit-backend/src/main/java/neo4j/org/testkit/backend/TestkitState.java index 3822823c56..d09bbf8fa5 100644 --- a/testkit-backend/src/main/java/neo4j/org/testkit/backend/TestkitState.java +++ b/testkit-backend/src/main/java/neo4j/org/testkit/backend/TestkitState.java @@ -44,7 +44,7 @@ import org.neo4j.driver.AuthTokenManager; import org.neo4j.driver.BookmarkManager; import org.neo4j.driver.Logging; -import org.neo4j.driver.internal.cluster.RoutingTableRegistry; +import org.neo4j.driver.internal.bolt.routedimpl.cluster.RoutingTableRegistry; import reactor.core.publisher.Mono; public class TestkitState { diff --git a/testkit-backend/src/main/java/neo4j/org/testkit/backend/channel/handler/TestkitRequestProcessorHandler.java b/testkit-backend/src/main/java/neo4j/org/testkit/backend/channel/handler/TestkitRequestProcessorHandler.java index adc9cb566d..f874441fb1 100644 --- a/testkit-backend/src/main/java/neo4j/org/testkit/backend/channel/handler/TestkitRequestProcessorHandler.java +++ b/testkit-backend/src/main/java/neo4j/org/testkit/backend/channel/handler/TestkitRequestProcessorHandler.java @@ -39,7 +39,6 @@ import org.neo4j.driver.exceptions.NoSuchRecordException; import org.neo4j.driver.exceptions.RetryableException; import org.neo4j.driver.exceptions.UntrustedServerException; -import org.neo4j.driver.internal.spi.ConnectionPool; public class TestkitRequestProcessorHandler extends ChannelInboundHandlerAdapter { private final TestkitState testkitState; @@ -161,7 +160,7 @@ private TestkitResponse createErrorResponse(Throwable throwable) { private boolean isConnectionPoolClosedException(Throwable throwable) { return throwable instanceof IllegalStateException && throwable.getMessage() != null - && throwable.getMessage().equals(ConnectionPool.CONNECTION_POOL_CLOSED_ERROR_MESSAGE); + && throwable.getMessage().equals("Connection provider is closed."); } private void writeAndFlush(TestkitResponse response) { diff --git a/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/ExecuteQuery.java b/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/ExecuteQuery.java index da3cf6b937..accb341790 100644 --- a/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/ExecuteQuery.java +++ b/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/ExecuteQuery.java @@ -25,6 +25,7 @@ import java.util.concurrent.CompletionStage; import lombok.Getter; import lombok.Setter; +import neo4j.org.testkit.backend.AuthTokenUtil; import neo4j.org.testkit.backend.TestkitState; import neo4j.org.testkit.backend.messages.requests.deserializer.TestkitCypherParamDeserializer; import neo4j.org.testkit.backend.messages.responses.EagerResult; @@ -73,10 +74,15 @@ public TestkitResponse process(TestkitState testkitState) { Optional.ofNullable(data.getConfig().getTxMeta()).ifPresent(configBuilder::withMetadata); + var authToken = data.getConfig().getAuthorizationToken() != null + ? AuthTokenUtil.parseAuthToken(data.getConfig().getAuthorizationToken()) + : null; + var params = data.getParams() != null ? data.getParams() : Collections.emptyMap(); var eagerResult = driver.executableQuery(data.getCypher()) .withParameters(params) .withConfig(configBuilder.build()) + .withAuthToken(authToken) .execute(); return EagerResult.builder() @@ -135,5 +141,7 @@ public static class QueryConfigData { @JsonDeserialize(using = TestkitCypherParamDeserializer.class) private Map txMeta; + + private AuthorizationToken authorizationToken; } } diff --git a/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/GetConnectionPoolMetrics.java b/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/GetConnectionPoolMetrics.java index 742c56b102..5352ae25f8 100644 --- a/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/GetConnectionPoolMetrics.java +++ b/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/GetConnectionPoolMetrics.java @@ -24,8 +24,7 @@ import neo4j.org.testkit.backend.TestkitState; import neo4j.org.testkit.backend.messages.responses.ConnectionPoolMetrics; import neo4j.org.testkit.backend.messages.responses.TestkitResponse; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.net.ServerAddress; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; import reactor.core.publisher.Mono; @Getter @@ -66,15 +65,15 @@ private ConnectionPoolMetrics getConnectionPoolMetrics(TestkitState testkitState .filter(pm -> { // Brute forcing the access via reflections avoid having the InternalConnectionPoolMetrics a public // class - ServerAddress poolAddress; + BoltServerAddress poolAddress; try { var m = pm.getClass().getDeclaredMethod("getAddress"); m.setAccessible(true); - poolAddress = (ServerAddress) m.invoke(pm); + poolAddress = (BoltServerAddress) m.invoke(pm); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { return false; } - ServerAddress address = new BoltServerAddress(data.getAddress()); + BoltServerAddress address = new BoltServerAddress(data.getAddress()); return address.host().equals(poolAddress.host()) && address.port() == poolAddress.port(); }) .findFirst() diff --git a/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/GetFeatures.java b/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/GetFeatures.java index 6a2b15145f..a95f6b8c23 100644 --- a/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/GetFeatures.java +++ b/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/GetFeatures.java @@ -78,6 +78,7 @@ public class GetFeatures implements TestkitRequest { "Optimization:ResultListFetchAll", "Feature:API:Result.Single", "Feature:API:Driver.ExecuteQuery", + "Feature:API:Driver.ExecuteQuery:WithAuth", "Feature:API:Driver.VerifyAuthentication", "Optimization:ExecuteQueryPipelining")); diff --git a/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/GetRoutingTable.java b/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/GetRoutingTable.java index cd7818ab06..78e5bdf122 100644 --- a/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/GetRoutingTable.java +++ b/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/GetRoutingTable.java @@ -26,8 +26,8 @@ import neo4j.org.testkit.backend.TestkitState; import neo4j.org.testkit.backend.messages.responses.RoutingTable; import neo4j.org.testkit.backend.messages.responses.TestkitResponse; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DatabaseNameUtil; +import org.neo4j.driver.internal.bolt.api.BoltServerAddress; +import org.neo4j.driver.internal.bolt.api.DatabaseNameUtil; import reactor.core.publisher.Mono; @Setter diff --git a/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/NewDriver.java b/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/NewDriver.java index 781f44a5c0..b0d407a75c 100644 --- a/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/NewDriver.java +++ b/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/NewDriver.java @@ -47,14 +47,13 @@ import org.neo4j.driver.AuthTokenManager; import org.neo4j.driver.Config; import org.neo4j.driver.NotificationConfig; -import org.neo4j.driver.internal.BoltServerAddress; -import org.neo4j.driver.internal.DefaultDomainNameResolver; -import org.neo4j.driver.internal.DomainNameResolver; import org.neo4j.driver.internal.DriverFactory; import org.neo4j.driver.internal.InternalNotificationCategory; import org.neo4j.driver.internal.InternalNotificationSeverity; +import org.neo4j.driver.internal.InternalServerAddress; import org.neo4j.driver.internal.SecuritySettings; -import org.neo4j.driver.internal.cluster.loadbalancing.LoadBalancer; +import org.neo4j.driver.internal.bolt.api.DefaultDomainNameResolver; +import org.neo4j.driver.internal.bolt.api.DomainNameResolver; import org.neo4j.driver.internal.security.SecurityPlans; import org.neo4j.driver.internal.security.StaticAuthTokenManager; import org.neo4j.driver.net.ServerAddressResolver; @@ -157,7 +156,7 @@ private ServerAddressResolver callbackResolver(TestkitState testkitState) { throw new RuntimeException(e); } return resolutionCompleted.getData().getAddresses().stream() - .map(BoltServerAddress::new) + .map(InternalServerAddress::new) .collect(Collectors.toCollection(LinkedHashSet::new)); }; } @@ -211,7 +210,7 @@ private org.neo4j.driver.Driver driver( var securitySettings = securitySettingsBuilder.build(); var securityPlan = SecurityPlans.createSecurityPlan(securitySettings, uri.getScheme()); return new DriverFactoryWithDomainNameResolver(domainNameResolver, testkitState, driverId) - .newInstance(uri, authTokenManager, config, securityPlan, null, null); + .newInstance(uri, authTokenManager, config, securityPlan, null); } private Optional handleExceptionAsErrorResponse(TestkitState testkitState, RuntimeException e) { @@ -306,11 +305,6 @@ protected DomainNameResolver getDomainNameResolver() { return domainNameResolver; } - @Override - protected void handleNewLoadBalancer(LoadBalancer loadBalancer) { - testkitState.getRoutingTableRegistry().put(driverId, loadBalancer.getRoutingTableRegistry()); - } - @Override protected Clock createClock() { return TestkitClock.INSTANCE; diff --git a/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/StartTest.java b/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/StartTest.java index 03ddd0e68b..186e8e98d0 100644 --- a/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/StartTest.java +++ b/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/StartTest.java @@ -83,6 +83,10 @@ public class StartTest implements TestkitRequest { "^.*\\.TestOptimizations\\.test_uses_implicit_default_arguments_multi_query$", skipMessage); COMMON_SKIP_PATTERN_TO_REASON.put( "^.*\\.TestOptimizations\\.test_uses_implicit_default_arguments_multi_query_nested$", skipMessage); + COMMON_SKIP_PATTERN_TO_REASON.put("^.*\\.TestResultSingle\\.test_result_single_with_2_records$", skipMessage); + COMMON_SKIP_PATTERN_TO_REASON.put( + "^stub\\.routing\\.test_routing_v[^.]*\\.RoutingV[^.]*\\.test_ipv6_read", + "Needs trying all DNS resolved addresses for hosts in the routing table"); SYNC_SKIP_PATTERN_TO_REASON.putAll(COMMON_SKIP_PATTERN_TO_REASON); skipMessage = diff --git a/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/deserializer/TestkitCypherParamDeserializer.java b/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/deserializer/TestkitCypherParamDeserializer.java index 13732a4686..9e6925ff74 100644 --- a/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/deserializer/TestkitCypherParamDeserializer.java +++ b/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/deserializer/TestkitCypherParamDeserializer.java @@ -56,7 +56,7 @@ public Map deserialize(JsonParser p, DeserializationContext ctxt if (t != JsonToken.FIELD_NAME) { ctxt.reportWrongTokenException(this, JsonToken.FIELD_NAME, null); } - key = p.getCurrentName(); + key = p.currentName(); } for (; key != null; key = p.nextFieldName()) { diff --git a/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/deserializer/TestkitCypherTypeMapper.java b/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/deserializer/TestkitCypherTypeMapper.java index 7b489692b5..df6df8b5ad 100644 --- a/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/deserializer/TestkitCypherTypeMapper.java +++ b/testkit-backend/src/main/java/neo4j/org/testkit/backend/messages/requests/deserializer/TestkitCypherTypeMapper.java @@ -30,7 +30,7 @@ public T mapData(JsonParser p, DeserializationContext ctxt, T data) throws I || token == JsonToken.VALUE_NUMBER_INT || token == JsonToken.VALUE_STRING) { if (token == JsonToken.VALUE_NUMBER_INT) { - var field = p.getCurrentName(); + var field = p.currentName(); if (fieldIsType(data, field, Long.class)) { setField(data, field, p.getLongValue()); } else if (fieldIsType(data, field, Integer.class)) { @@ -39,7 +39,7 @@ public T mapData(JsonParser p, DeserializationContext ctxt, T data) throws I throw new RuntimeException("Unhandled field type: " + field); } } else if (token == JsonToken.VALUE_STRING) { - var field = p.getCurrentName(); + var field = p.currentName(); var value = p.getValueAsString(); setField(data, field, value); } diff --git a/testkit-tests/pom.xml b/testkit-tests/pom.xml index 2c437a755c..e00827f881 100644 --- a/testkit-tests/pom.xml +++ b/testkit-tests/pom.xml @@ -6,7 +6,7 @@ org.neo4j.driver neo4j-java-driver-parent - 5.15-SNAPSHOT + 5.18-SNAPSHOT .. diff --git a/testkit/testkit.json b/testkit/testkit.json index 931900356f..c28155671c 100644 --- a/testkit/testkit.json +++ b/testkit/testkit.json @@ -1,6 +1,6 @@ { "testkit": { "uri": "https://github.com/neo4j-drivers/testkit.git", - "ref": "5.0" + "ref": "102f96ed3971ea06417cc7390d062f2cc642dad6" } }