--- old/src/java.naming/share/classes/com/sun/jndi/ldap/DefaultLdapDnsProvider.java 2019-08-30 13:49:18.000000000 +0100
+++ new/src/java.naming/share/classes/com/sun/jndi/ldap/DefaultLdapDnsProvider.java 2019-08-30 13:49:18.000000000 +0100
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -76,7 +76,7 @@
}
LdapDnsProviderResult res = new LdapDnsProviderResult(domainName, endpoints);
- if (res.getEndpoints().size() == 0 && res.getDomainName().isEmpty()) {
+ if (res.getEndpoints().isEmpty() && res.getDomainName().isEmpty()) {
return Optional.empty();
} else {
return Optional.of(res);
--- old/src/java.naming/share/classes/com/sun/jndi/ldap/LdapDnsProviderService.java 2019-08-30 13:49:19.000000000 +0100
+++ new/src/java.naming/share/classes/com/sun/jndi/ldap/LdapDnsProviderService.java 2019-08-30 13:49:19.000000000 +0100
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -37,6 +37,8 @@
* The {@code LdapDnsProviderService} is responsible for creating and providing
* access to the registered {@code LdapDnsProvider}s. The {@link ServiceLoader}
* is used to find and register any implementations of {@link LdapDnsProvider}.
+ *
+ *
Instances of this class are safe for use by multiple threads.
*/
final class LdapDnsProviderService {
@@ -68,11 +70,11 @@
}
/**
- * Retrieve the singleton static instance of LdapDnsProviderService.
+ * Retrieves the singleton instance of LdapDnsProviderService.
*/
static LdapDnsProviderService getInstance() {
if (service != null) return service;
- synchronized(LOCK) {
+ synchronized (LOCK) {
if (service != null) return service;
service = new LdapDnsProviderService();
}
@@ -80,7 +82,7 @@
}
/**
- * Retrieve result from the first provider that successfully resolves
+ * Retrieves result from the first provider that successfully resolves
* the endpoints. If no results are found when calling installed
* subclasses of {@code LdapDnsProvider} then this method will fall back
* to the {@code DefaultLdapDnsProvider}.
@@ -91,14 +93,15 @@
LdapDnsProviderResult lookupEndpoints(String url, Hashtable,?> env)
throws NamingException
{
- Iterator iterator = providers.iterator();
- Hashtable, ?> envCopy = new Hashtable<>(env);
LdapDnsProviderResult result = null;
-
- while (result == null && iterator.hasNext()) {
- result = iterator.next().lookupEndpoints(url, envCopy)
- .filter(r -> r.getEndpoints().size() > 0)
- .orElse(null);
+ Hashtable, ?> envCopy = new Hashtable<>(env);
+ synchronized (LOCK) {
+ Iterator iterator = providers.iterator();
+ while (result == null && iterator.hasNext()) {
+ result = iterator.next().lookupEndpoints(url, envCopy)
+ .filter(r -> !r.getEndpoints().isEmpty())
+ .orElse(null);
+ }
}
if (result == null) {
--- old/test/jdk/ProblemList.txt 2019-08-30 13:49:20.000000000 +0100
+++ new/test/jdk/ProblemList.txt 2019-08-30 13:49:20.000000000 +0100
@@ -873,8 +873,6 @@
com/sun/jndi/ldap/DeadSSLLdapTimeoutTest.java 8169942 linux-i586,macosx-all,windows-x64
-com/sun/jndi/ldap/LdapTimeoutTest.java 8151678 generic-all
-
com/sun/jndi/dns/ConfigTests/PortUnreachable.java 7164518 macosx-all
javax/rmi/ssl/SSLSocketParametersTest.sh 8162906 generic-all
--- old/test/jdk/com/sun/jndi/ldap/LdapTimeoutTest.java 2019-08-30 13:49:21.000000000 +0100
+++ new/test/jdk/com/sun/jndi/ldap/LdapTimeoutTest.java 2019-08-30 13:49:21.000000000 +0100
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -21,424 +21,496 @@
* questions.
*/
-/**
+/*
* @test
- * @run main/othervm LdapTimeoutTest
- * @bug 7094377 8000487 6176036 7056489
+ * @library lib/
+ * @run testng/othervm LdapTimeoutTest
+ * @bug 7094377 8000487 6176036 7056489 8151678
* @summary Timeout tests for ldap
*/
+import org.testng.Assert;
+import org.testng.annotations.BeforeTest;
+import org.testng.annotations.Test;
+
+import javax.naming.Context;
+import javax.naming.NamingException;
+import javax.naming.directory.InitialDirContext;
+import javax.naming.directory.SearchControls;
+import java.io.IOException;
+import java.io.OutputStream;
import java.net.Socket;
-import java.net.ServerSocket;
-import java.net.SocketTimeoutException;
-import java.io.*;
-import javax.naming.*;
-import javax.naming.directory.*;
-import java.util.List;
-import java.util.Hashtable;
import java.util.ArrayList;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Objects;
import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
import java.util.concurrent.Future;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeoutException;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;
-import javax.net.ssl.SSLHandshakeException;
+import java.util.concurrent.TimeoutException;
+import static java.lang.String.format;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
+import static org.testng.Assert.assertTrue;
+import static org.testng.Assert.expectThrows;
+public class LdapTimeoutTest {
-abstract class LdapTest implements Callable {
-
- Hashtable env;
- TestServer server;
- ScheduledExecutorService killSwitchPool;
- boolean passed = false;
- private int HANGING_TEST_TIMEOUT = 20_000;
-
- public LdapTest (TestServer server, Hashtable env) {
- this.server = server;
- this.env = env;
- }
-
- public LdapTest(TestServer server, Hashtable env,
- ScheduledExecutorService killSwitchPool)
- {
- this(server, env);
- this.killSwitchPool = killSwitchPool;
- }
-
- public abstract void performOp(InitialContext ctx) throws NamingException;
- public abstract void handleNamingException(
- NamingException e, long start, long end);
-
- public void pass() {
- this.passed = true;
- }
-
- public void fail() {
- throw new RuntimeException("Test failed");
- }
-
- public void fail(Exception e) {
- throw new RuntimeException("Test failed", e);
- }
+ // ------ configure test timeouts here ------
- boolean shutItDown(InitialContext ctx) {
+ /*
+ * Practical representation of "indefinite" timeout.
+ */
+ private static final long INFINITY_MILLIS = 20_000;
+ /*
+ * The lag.
+ *
+ * In other words, how long it takes to observe a timeout after it has
+ * occurred. This time is provisioned for things like stack unwinding and
+ * threads communication.
+ */
+ private static final long RIGHT_MARGIN = 3_000;
+ /*
+ * The accuracy.
+ *
+ * Consider an activity that is supposed to take 10 seconds starts a little
+ * bit before we start measuring those 10 seconds. So from our point of view
+ * that 10-second activity may finish within, say, 9.7 seconds.
+ *
+ * Another example would be using a timed operation that returns prematurely.
+ */
+ private static final long LEFT_MARGIN = 200;
+
+ private static final long CONNECT_MILLIS = 3_000;
+ private static final long READ_MILLIS = 10_000;
+
+ static {
+ // quick sanity check to make sure this timeouts configuration is
+ // consistent and the timeouts do not overlap
+ assert (LEFT_MARGIN >= 0 && RIGHT_MARGIN >= 0);
+ assert (2 * CONNECT_MILLIS + RIGHT_MARGIN < READ_MILLIS - LEFT_MARGIN);
+ assert (2 * CONNECT_MILLIS + READ_MILLIS + RIGHT_MARGIN < INFINITY_MILLIS - LEFT_MARGIN);
+ }
+
+ @BeforeTest
+ public void beforeTest() {
+ startAuxiliaryDiagnosticOutput();
+ }
+
+ /*
+ * These are timeout tests and they are run in parallel to reduce the total
+ * amount of run time.
+ *
+ * Currently it doesn't seem possible to instruct JTREG to run TestNG test
+ * methods in parallel. That said, this JTREG test is still
+ * a "TestNG-flavored" test for the sake of having org.testng.Assert
+ * capability.
+ */
+ @Test
+ public void test() throws Exception {
+ List> futures = new ArrayList<>();
+ ExecutorService executorService = Executors.newCachedThreadPool();
try {
- if (ctx != null) ctx.close();
- return true;
- } catch (NamingException ex) {
- return false;
+ futures.add(executorService.submit(() -> { test1(); return null; }));
+ futures.add(executorService.submit(() -> { test2(); return null; }));
+ futures.add(executorService.submit(() -> { test3(); return null; }));
+ futures.add(executorService.submit(() -> { test4(); return null; }));
+ futures.add(executorService.submit(() -> { test5(); return null; }));
+ futures.add(executorService.submit(() -> { test6(); return null; }));
+ futures.add(executorService.submit(() -> { test7(); return null; }));
+ } finally {
+ executorService.shutdown();
}
- }
-
- public Boolean call() {
- InitialContext ctx = null;
- ScheduledFuture killer = null;
- long start = System.nanoTime();
-
- try {
- while(!server.accepting())
- Thread.sleep(200); // allow the server to start up
- Thread.sleep(200); // to be sure
-
- // if this is a hanging test, scheduled a thread to
- // interrupt after a certain time
- if (killSwitchPool != null) {
- final Thread current = Thread.currentThread();
- killer = killSwitchPool.schedule(
- new Callable() {
- public Void call() throws Exception {
- current.interrupt();
- return null;
- }
- }, HANGING_TEST_TIMEOUT, MILLISECONDS);
- }
-
- env.put(Context.PROVIDER_URL, "ldap://localhost:" +
- server.getLocalPort());
-
+ int failedCount = 0;
+ for (var f : futures) {
try {
- ctx = new InitialDirContext(env);
- performOp(ctx);
- fail();
- } catch (NamingException e) {
- long end = System.nanoTime();
- System.out.println(this.getClass().toString() + " - elapsed: "
- + NANOSECONDS.toMillis(end - start));
- handleNamingException(e, start, end);
- } finally {
- if (killer != null && !killer.isDone())
- killer.cancel(true);
- shutItDown(ctx);
- server.close();
+ f.get();
+ } catch (ExecutionException e) {
+ failedCount++;
+ e.getCause().printStackTrace(System.out);
}
- return passed;
- } catch (IOException|InterruptedException e) {
- throw new RuntimeException(e);
}
+ if (failedCount > 0)
+ throw new RuntimeException(failedCount + " (sub)tests failed");
}
-}
-abstract class ReadServerTest extends LdapTest {
+ static void test1() throws Exception {
+ Hashtable