Merge branch '5.0' into micrometer-metrics

Author: injectives

driver/clirr-ignored-differences.xml

@@ -49,4 +49,41 @@
         <method>java.lang.String version()</method>
     </difference>
 
+    <difference>
+        <className>org/neo4j/driver/Record</className>
+        <differenceType>7012</differenceType>
+        <method>java.lang.Iterable keys()</method>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/Record</className>
+        <differenceType>7012</differenceType>
+        <method>java.lang.Iterable values()</method>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/Session</className>
+        <differenceType>7002</differenceType>
+        <method>void reset()</method>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/Config$ConfigBuilder</className>
+        <differenceType>7002</differenceType>
+        <method>org.neo4j.driver.Config$ConfigBuilder withRoutingFailureLimit(int)</method>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/Config$ConfigBuilder</className>
+        <differenceType>7002</differenceType>
+        <method>org.neo4j.driver.Config$ConfigBuilder withRoutingRetryDelay(long, java.util.concurrent.TimeUnit)</method>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/Config$TrustStrategy</className>
+        <differenceType>7005</differenceType>
+        <method>org.neo4j.driver.Config$TrustStrategy trustCustomCertificateSignedBy(java.io.File)</method>
+        <to>org.neo4j.driver.Config$TrustStrategy trustCustomCertificateSignedBy(java.io.File[])</to>
+    </difference>
+
 </differences>

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

@@ -21,6 +21,10 @@
 import java.io.File;
 import java.io.Serializable;
 import java.net.InetAddress;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
 import java.util.Objects;
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
@@ -84,8 +88,6 @@ public class Config implements Serializable
 
     private final SecuritySettings securitySettings;
 
-    private final int routingFailureLimit;
-    private final long routingRetryDelayMillis;
     private final long fetchSize;
     private final long routingTablePurgeDelayMillis;
 
@@ -110,8 +112,6 @@ private Config( ConfigBuilder builder )
 
         this.securitySettings = builder.securitySettingsBuilder.build();
 
-        this.routingFailureLimit = builder.routingFailureLimit;
-        this.routingRetryDelayMillis = builder.routingRetryDelayMillis;
         this.connectionTimeoutMillis = builder.connectionTimeoutMillis;
         this.routingTablePurgeDelayMillis = builder.routingTablePurgeDelayMillis;
         this.retrySettings = builder.retrySettings;
@@ -234,7 +234,7 @@ SecuritySettings securitySettings()
 
     RoutingSettings routingSettings()
     {
-        return new RoutingSettings( routingFailureLimit, routingRetryDelayMillis, routingTablePurgeDelayMillis );
+        return new RoutingSettings( routingTablePurgeDelayMillis );
     }
 
     RetrySettings retrySettings()
@@ -286,8 +286,6 @@ public static class ConfigBuilder
         private long connectionAcquisitionTimeoutMillis = PoolSettings.DEFAULT_CONNECTION_ACQUISITION_TIMEOUT;
         private String userAgent = format( "neo4j-java/%s", driverVersion() );
         private final SecuritySettings.SecuritySettingsBuilder securitySettingsBuilder = new SecuritySettings.SecuritySettingsBuilder();
-        private int routingFailureLimit = RoutingSettings.DEFAULT.maxRoutingFailures();
-        private long routingRetryDelayMillis = RoutingSettings.DEFAULT.retryTimeoutDelay();
         private long routingTablePurgeDelayMillis = RoutingSettings.DEFAULT.routingTablePurgeDelayMs();
         private int connectionTimeoutMillis = (int) TimeUnit.SECONDS.toMillis( 30 );
         private RetrySettings retrySettings = RetrySettings.DEFAULT;
@@ -475,7 +473,7 @@ public ConfigBuilder withoutEncryption()
 
         /**
          * Specify how to determine the authenticity of an encryption certificate provided by the Neo4j instance we are connecting to. This defaults to {@link
-         * TrustStrategy#trustSystemCertificates()}. See {@link TrustStrategy#trustCustomCertificateSignedBy(File)} for using certificate signatures instead to
+         * TrustStrategy#trustSystemCertificates()}. See {@link TrustStrategy#trustCustomCertificateSignedBy(File...)} for using certificate signatures instead to
          * verify trust.
          * <p>
          * This is an important setting to understand, because unless we know that the remote server we have an encrypted connection to is really Neo4j, there
@@ -493,86 +491,6 @@ public ConfigBuilder withTrustStrategy( TrustStrategy trustStrategy )
             return this;
         }
 
-        /**
-         * Specify how many times the client should attempt to reconnect to the routing servers before declaring the
-         * cluster unavailable.
-         * <p>
-         * The routing servers are tried in order. If connecting any of them fails, they are all retried after
-         * {@linkplain #withRoutingRetryDelay a delay}. This process of retrying all servers is then repeated for the
-         * number of times specified here before considering the cluster unavailable.
-         * <p>
-         * The default value of this parameter is {@code 1}, which means that the the driver will not re-attempt to
-         * connect to the cluster when connecting has failed to each individual server in the list of routers. This
-         * default value is sensible under this assumption that if the attempt to connect fails for all servers, then
-         * the entire cluster is down, or the client is disconnected from the network, and retrying to connect will
-         * not bring it back up, in which case it is better to report the failure sooner.
-         *
-         * @param routingFailureLimit
-         *         the number of times to retry each server in the list of routing servers
-         * @return this builder
-         * @deprecated in 1.2 because driver memorizes seed URI used during construction and falls back to it at
-         * runtime when all other known router servers failed to respond. Driver is also able to perform DNS lookup
-         * for the seed URI during rediscovery. This means updates of cluster members will be picked up if they are
-         * reflected in a DNS record. This configuration allowed driver to retry rediscovery procedure and postpone
-         * failure. Currently there exists a better way of doing retries via
-         * {@link Session#readTransaction(TransactionWork)} and {@link Session#writeTransaction(TransactionWork)}.
-         * <b>Method will be removed in the next major release.</b>
-         */
-        @Deprecated
-        public ConfigBuilder withRoutingFailureLimit( int routingFailureLimit )
-        {
-            if ( routingFailureLimit < 1 )
-            {
-                throw new IllegalArgumentException(
-                        "The failure limit may not be smaller than 1, but was: " + routingFailureLimit );
-            }
-            this.routingFailureLimit = routingFailureLimit;
-            return this;
-        }
-
-        /**
-         * Specify how long to wait before retrying to connect to a routing server.
-         * <p>
-         * When connecting to all routing servers fail, connecting will be retried after the delay specified here.
-         * The delay is measured from when the first attempt to connect was made, so that the delay time specifies a
-         * retry interval.
-         * <p>
-         * For each {@linkplain #withRoutingFailureLimit retry attempt} the delay time will be doubled. The time
-         * specified here is the base time, i.e. the time to wait before the first retry. If that attempt (on all
-         * servers) also fails, the delay before the next retry will be double the time specified here, and the next
-         * attempt after that will be double that, et.c. So if, for example, the delay specified here is
-         * {@code 5 SECONDS}, then after attempting to connect to each server fails reconnecting will be attempted
-         * 5 seconds after the first connection attempt to the first server. If that attempt also fails to connect to
-         * all servers, the next attempt will start 10 seconds after the second attempt started.
-         * <p>
-         * The default value of this parameter is {@code 5 SECONDS}.
-         *
-         * @param delay
-         *         the amount of time between attempts to reconnect to the same server
-         * @param unit
-         *         the unit in which the duration is given
-         * @return this builder
-         * @deprecated in 1.2 because driver memorizes seed URI used during construction and falls back to it at
-         * runtime when all other known router servers failed to respond. Driver is also able to perform DNS lookup
-         * for the seed URI during rediscovery. This means updates of cluster members will be picked up if they are
-         * reflected in a DNS record. This configuration allowed driver to retry rediscovery procedure and postpone
-         * failure. Currently there exists a better way of doing retries via
-         * {@link Session#readTransaction(TransactionWork)} and {@link Session#writeTransaction(TransactionWork)}.
-         * <b>Method will be removed in the next major release.</b>
-         */
-        @Deprecated
-        public ConfigBuilder withRoutingRetryDelay( long delay, TimeUnit unit )
-        {
-            long routingRetryDelayMillis = unit.toMillis( delay );
-            if ( routingRetryDelayMillis < 0 )
-            {
-                throw new IllegalArgumentException( String.format(
-                        "The retry delay may not be smaller than 0, but was %d %s.", delay, unit ) );
-            }
-            this.routingRetryDelayMillis = routingRetryDelayMillis;
-            return this;
-        }
-
         /**
          * Specify how long to wait before purging stale routing tables.
          * <p>
@@ -833,19 +751,20 @@ public enum Strategy
         }
 
         private final Strategy strategy;
-        private final File certFile;
+        private final List<File> certFiles;
         private boolean hostnameVerificationEnabled = true;
         private RevocationStrategy revocationStrategy = RevocationStrategy.NO_CHECKS;
 
         private TrustStrategy( Strategy strategy )
         {
-            this( strategy, null );
+            this( strategy, Collections.emptyList() );
         }
 
-        private TrustStrategy( Strategy strategy, File certFile )
+        private TrustStrategy( Strategy strategy, List<File> certFiles )
         {
+            Objects.requireNonNull( certFiles, "certFiles can't be null" );
             this.strategy = strategy;
-            this.certFile = certFile;
+            this.certFiles = Collections.unmodifiableList( new ArrayList<>( certFiles ) );
         }
 
         /**
@@ -862,10 +781,22 @@ public Strategy strategy()
          * Return the configured certificate file.
          *
          * @return configured certificate or {@code null} if trust strategy does not require a certificate.
+         * @deprecated superseded by {@link TrustStrategy#certFiles()}
          */
+        @Deprecated
         public File certFile()
         {
-            return certFile;
+            return certFiles.isEmpty() ? null : certFiles.get( 0 );
+        }
+
+        /**
+         * Return the configured certificate files.
+         *
+         * @return configured certificate files or empty list if trust strategy does not require certificates.
+         */
+        public List<File> certFiles()
+        {
+            return certFiles;
         }
 
         /**
@@ -901,18 +832,18 @@ public TrustStrategy withoutHostnameVerification()
         }
 
         /**
-         * Only encrypted connections to Neo4j instances with certificates signed by a trusted certificate will be accepted.
-         * The file specified should contain one or more trusted X.509 certificates.
+         * Only encrypted connections to Neo4j instances with certificates signed by a trusted certificate will be accepted. The file(s) specified should
+         * contain one or more trusted X.509 certificates.
          * <p>
-         * The certificate(s) in the file must be encoded using PEM encoding, meaning the certificates in the file should be encoded using Base64,
-         * and each certificate is bounded at the beginning by "-----BEGIN CERTIFICATE-----", and bounded at the end by "-----END CERTIFICATE-----".
+         * The certificate(s) in the file(s) must be encoded using PEM encoding, meaning the certificates in the file(s) should be encoded using Base64, and
+         * each certificate is bounded at the beginning by "-----BEGIN CERTIFICATE-----", and bounded at the end by "-----END CERTIFICATE-----".
          *
-         * @param certFile the trusted certificate file
+         * @param certFiles the trusted certificate files
          * @return an authentication config
          */
-        public static TrustStrategy trustCustomCertificateSignedBy( File certFile )
+        public static TrustStrategy trustCustomCertificateSignedBy( File... certFiles )
         {
-            return new TrustStrategy( Strategy.TRUST_CUSTOM_CA_SIGNED_CERTIFICATES, certFile );
+            return new TrustStrategy( Strategy.TRUST_CUSTOM_CA_SIGNED_CERTIFICATES, Arrays.asList( certFiles ) );
         }
 
         /**

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

@@ -19,13 +19,10 @@
 package org.neo4j.driver;
 
 import java.util.List;
-import java.util.Map;
 
-import org.neo4j.driver.internal.value.NullValue;
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.exceptions.NoSuchRecordException;
 import org.neo4j.driver.types.MapAccessorWithDefaultValue;
-import java.util.function.Function;
 import org.neo4j.driver.util.Immutable;
 import org.neo4j.driver.util.Pair;
 
@@ -49,23 +46,17 @@ public interface Record extends MapAccessorWithDefaultValue
      *
      * @return all field keys in order
      */
+    @Override
     List<String> keys();
 
     /**
      * Retrieve the values of the underlying map
      *
      * @return all field keys in order
      */
+    @Override
     List<Value> values();
 
-    /**
-     * Check if the list of keys contains the given key
-     *
-     * @param key the key
-     * @return {@code true} if this map keys contains the given key otherwise {@code false}
-     */
-    boolean containsKey( String key );
-
     /**
      * Retrieve the index of the field with the given key
      *
@@ -75,15 +66,6 @@ public interface Record extends MapAccessorWithDefaultValue
      */
     int index( String key );
 
-    /**
-     * Retrieve the value of the property with the given key
-     *
-     * @param key the key of the property
-     * @return the property's value or a {@link NullValue} if no such key exists
-     * @throws NoSuchRecordException if the associated underlying record is not available
-     */
-    Value get( String key );
-
     /**
      * Retrieve the value at the given field index
      *
@@ -93,40 +75,11 @@ public interface Record extends MapAccessorWithDefaultValue
      */
     Value get( int index );
 
-    /**
-     * Retrieve the number of fields in this record
-     *
-     * @return the number of fields in this record
-     */
-    int size();
-
-    /**
-     * Return this record as a map, where each value has been converted to a default
-     * java object using {@link Value#asObject()}.
-     *
-     * This is equivalent to calling {@link #asMap(Function)} with {@link Values#ofObject()}.
-     *
-     * @return this record as a map
-     */
-    Map<String, Object> asMap();
-
-    /**
-     * Return this record as a map, where each value has been converted using the provided
-     * mapping function. You can find a library of common mapping functions in {@link Values}.
-     *
-     * @see Values for a long list of built-in conversion functions
-     * @param mapper the mapping function
-     * @param <T> the type to convert to
-     * @return this record as a map
-     */
-    <T> Map<String, T> asMap( Function<Value, T> mapper );
-
     /**
      * Retrieve all record fields
      *
      * @return all fields in key order
      * @throws NoSuchRecordException if the associated underlying record is not available
      */
     List<Pair<String, Value>> fields();
-
 }

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

@@ -222,23 +222,6 @@ public interface Session extends Resource, QueryRunner
      */
     Bookmark lastBookmark();
 
-    /**
-     * Reset the current session. This sends an immediate RESET signal to the server which both interrupts
-     * any query that is currently executing and ignores any subsequently queued queries. Following
-     * the reset, the current transaction will have been rolled back and any outstanding failures will
-     * have been acknowledged.
-     *
-     * @deprecated This method should not be used and violates the expected usage pattern of {@link Session} objects.
-     * They are expected to be not thread-safe and should not be shared between thread. However this method is only
-     * useful when {@link Session} object is passed to another monitoring thread that calls it when appropriate.
-     * It is not useful when {@link Session} is used in a single thread because in this case {@link #close()}
-     * can be used. Since version 3.1, Neo4j database allows users to specify maximum transaction execution time and
-     * contains procedures to list and terminate running queries. These functions should be used instead of calling
-     * this method.
-     */
-    @Deprecated
-    void reset();
-
     /**
      * Signal that you are done using this session. In the default driver usage, closing and accessing sessions is
      * very low cost.