508 lines
21 KiB
Java
508 lines
21 KiB
Java
/*
|
|
* 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
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/*
|
|
* @test
|
|
* @library /test/lib
|
|
* 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.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.ExecutorService;
|
|
import java.util.concurrent.Executors;
|
|
import java.util.concurrent.Future;
|
|
import java.util.concurrent.FutureTask;
|
|
import java.util.concurrent.SynchronousQueue;
|
|
import java.util.concurrent.TimeUnit;
|
|
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 jdk.test.lib.Utils.adjustTimeout;
|
|
import static org.testng.Assert.assertTrue;
|
|
import static org.testng.Assert.expectThrows;
|
|
|
|
public class LdapTimeoutTest {
|
|
|
|
// ------ configure test timeouts here ------
|
|
|
|
/*
|
|
* Practical representation of an infinite timeout.
|
|
*/
|
|
private static final long INFINITY_MILLIS = adjustTimeout(20_000);
|
|
/*
|
|
* The acceptable variation in timeout measurements.
|
|
*/
|
|
private static final long TOLERANCE = adjustTimeout( 3_500);
|
|
|
|
private static final long CONNECT_MILLIS = adjustTimeout( 3_000);
|
|
private static final long READ_MILLIS = adjustTimeout(10_000);
|
|
|
|
static {
|
|
// a series of checks to make sure this timeouts configuration is
|
|
// consistent and the timeouts do not overlap
|
|
|
|
assert (TOLERANCE >= 0);
|
|
// context creation
|
|
assert (2 * CONNECT_MILLIS + TOLERANCE < READ_MILLIS);
|
|
// context creation immediately followed by search
|
|
assert (2 * CONNECT_MILLIS + READ_MILLIS + TOLERANCE < INFINITY_MILLIS);
|
|
}
|
|
|
|
@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<Future<?>> futures = new ArrayList<>();
|
|
ExecutorService executorService = Executors.newCachedThreadPool();
|
|
try {
|
|
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();
|
|
}
|
|
int failedCount = 0;
|
|
for (var f : futures) {
|
|
try {
|
|
f.get();
|
|
} catch (ExecutionException e) {
|
|
failedCount++;
|
|
e.getCause().printStackTrace(System.out);
|
|
}
|
|
}
|
|
if (failedCount > 0)
|
|
throw new RuntimeException(failedCount + " (sub)tests failed");
|
|
}
|
|
|
|
static void test1() throws Exception {
|
|
Hashtable<Object, Object> env = new Hashtable<>();
|
|
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
|
|
// Here and in the other tests it's important to close the server as
|
|
// calling `thread.interrupt` from assertion may not be enough
|
|
// (depending on where the blocking call has stuck)
|
|
try (TestServer server = new NotBindableServer()) {
|
|
env.put(Context.PROVIDER_URL, urlTo(server));
|
|
server.start();
|
|
// Here and in the other tests joining done purely to reduce timing
|
|
// jitter. Commenting out or removing that should not make the test
|
|
// incorrect. (ServerSocket can accept connection as soon as it is
|
|
// bound, not need to call `accept` before that.)
|
|
server.starting().join();
|
|
assertIncompletion(INFINITY_MILLIS, () -> new InitialDirContext(env));
|
|
}
|
|
}
|
|
|
|
static void test2() throws Exception {
|
|
Hashtable<Object, Object> env = new Hashtable<>();
|
|
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
|
|
env.put("com.sun.jndi.ldap.connect.timeout", String.valueOf(CONNECT_MILLIS));
|
|
try (TestServer server = new BindableButNotReadableServer()) {
|
|
env.put(Context.PROVIDER_URL, urlTo(server));
|
|
server.start();
|
|
server.starting().join();
|
|
InitialDirContext ctx = new InitialDirContext(env);
|
|
SearchControls scl = new SearchControls();
|
|
scl.setSearchScope(SearchControls.SUBTREE_SCOPE);
|
|
assertIncompletion(INFINITY_MILLIS,
|
|
() -> ctx.search("ou=People,o=JNDITutorial", "(objectClass=*)", scl));
|
|
}
|
|
}
|
|
|
|
static void test3() throws Exception {
|
|
Hashtable<Object, Object> env = new Hashtable<>();
|
|
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
|
|
try (TestServer server = new BindableButNotReadableServer()) {
|
|
env.put(Context.PROVIDER_URL, urlTo(server));
|
|
server.start();
|
|
server.starting().join();
|
|
InitialDirContext ctx = new InitialDirContext(env);
|
|
SearchControls scl = new SearchControls();
|
|
scl.setSearchScope(SearchControls.SUBTREE_SCOPE);
|
|
assertIncompletion(INFINITY_MILLIS,
|
|
() -> ctx.search("ou=People,o=JNDITutorial", "(objectClass=*)", scl));
|
|
}
|
|
}
|
|
|
|
static void test4() throws Exception {
|
|
Hashtable<Object, Object> env = new Hashtable<>();
|
|
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
|
|
env.put("com.sun.jndi.ldap.connect.timeout", String.valueOf(CONNECT_MILLIS));
|
|
env.put("com.sun.jndi.ldap.read.timeout", String.valueOf(READ_MILLIS));
|
|
try (TestServer server = new NotBindableServer()) {
|
|
env.put(Context.PROVIDER_URL, urlTo(server));
|
|
server.start();
|
|
server.starting().join();
|
|
Assert.ThrowingRunnable completion =
|
|
() -> assertCompletion(CONNECT_MILLIS,
|
|
2 * CONNECT_MILLIS + TOLERANCE,
|
|
() -> new InitialDirContext(env));
|
|
NamingException e = expectThrows(NamingException.class, completion);
|
|
String msg = e.getMessage();
|
|
assertTrue(msg != null && msg.contains("timeout")
|
|
&& msg.contains(String.valueOf(CONNECT_MILLIS)),
|
|
msg);
|
|
}
|
|
}
|
|
|
|
static void test5() throws Exception {
|
|
Hashtable<Object, Object> env = new Hashtable<>();
|
|
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
|
|
env.put("com.sun.jndi.ldap.connect.timeout", String.valueOf(CONNECT_MILLIS));
|
|
env.put("com.sun.jndi.ldap.read.timeout", String.valueOf(READ_MILLIS));
|
|
try (TestServer server = new BindableButNotReadableServer()) {
|
|
env.put(Context.PROVIDER_URL, urlTo(server));
|
|
server.start();
|
|
server.starting().join();
|
|
InitialDirContext ctx = new InitialDirContext(env);
|
|
SearchControls scl = new SearchControls();
|
|
scl.setSearchScope(SearchControls.SUBTREE_SCOPE);
|
|
Assert.ThrowingRunnable completion =
|
|
() -> assertCompletion(READ_MILLIS,
|
|
READ_MILLIS + TOLERANCE,
|
|
() -> ctx.search("ou=People,o=JNDITutorial", "(objectClass=*)", scl));
|
|
NamingException e = expectThrows(NamingException.class, completion);
|
|
String msg = e.getMessage();
|
|
assertTrue(msg != null && msg.contains("timeout")
|
|
&& msg.contains(String.valueOf(READ_MILLIS)),
|
|
msg);
|
|
}
|
|
}
|
|
|
|
static void test6() throws Exception {
|
|
Hashtable<Object, Object> env = new Hashtable<>();
|
|
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
|
|
env.put("com.sun.jndi.ldap.connect.timeout", String.valueOf(CONNECT_MILLIS));
|
|
env.put("com.sun.jndi.ldap.read.timeout", String.valueOf(READ_MILLIS));
|
|
try (TestServer server = new NotBindableServer()) {
|
|
env.put(Context.PROVIDER_URL, urlTo(server));
|
|
server.start();
|
|
server.starting().join();
|
|
Assert.ThrowingRunnable completion =
|
|
() -> assertCompletion(CONNECT_MILLIS,
|
|
2 * CONNECT_MILLIS + TOLERANCE,
|
|
() -> new InitialDirContext(env));
|
|
NamingException e = expectThrows(NamingException.class, completion);
|
|
String msg = e.getMessage();
|
|
assertTrue(msg != null && msg.contains("timeout")
|
|
&& msg.contains(String.valueOf(CONNECT_MILLIS)),
|
|
msg);
|
|
}
|
|
}
|
|
|
|
static void test7() throws Exception {
|
|
// 8000487: Java JNDI connection library on ldap conn is
|
|
// not honoring configured timeout
|
|
Hashtable<Object, Object> env = new Hashtable<>();
|
|
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
|
|
env.put("com.sun.jndi.ldap.connect.timeout", String.valueOf(CONNECT_MILLIS));
|
|
env.put("com.sun.jndi.ldap.read.timeout", String.valueOf(READ_MILLIS));
|
|
env.put(Context.SECURITY_AUTHENTICATION, "simple");
|
|
env.put(Context.SECURITY_PRINCIPAL, "user");
|
|
env.put(Context.SECURITY_CREDENTIALS, "password");
|
|
try (TestServer server = new NotBindableServer()) {
|
|
env.put(Context.PROVIDER_URL, urlTo(server));
|
|
server.start();
|
|
server.starting().join();
|
|
Assert.ThrowingRunnable completion =
|
|
() -> assertCompletion(CONNECT_MILLIS,
|
|
2 * CONNECT_MILLIS + TOLERANCE,
|
|
() -> new InitialDirContext(env));
|
|
NamingException e = expectThrows(NamingException.class, completion);
|
|
String msg = e.getMessage();
|
|
assertTrue(msg != null && msg.contains("timeout")
|
|
&& msg.contains(String.valueOf(CONNECT_MILLIS)),
|
|
msg);
|
|
}
|
|
}
|
|
|
|
// ------ test stub servers ------
|
|
|
|
static class TestServer extends BaseLdapServer {
|
|
|
|
private final CompletableFuture<Void> starting = new CompletableFuture<>();
|
|
|
|
TestServer() throws IOException { }
|
|
|
|
@Override
|
|
protected void beforeAcceptingConnections() {
|
|
starting.completeAsync(() -> null);
|
|
}
|
|
|
|
public CompletableFuture<Void> starting() {
|
|
return starting.copy();
|
|
}
|
|
}
|
|
|
|
static class BindableButNotReadableServer extends TestServer {
|
|
|
|
BindableButNotReadableServer() throws IOException { }
|
|
|
|
private static final byte[] bindResponse = {
|
|
0x30, 0x0C, 0x02, 0x01, 0x01, 0x61, 0x07, 0x0A,
|
|
0x01, 0x00, 0x04, 0x00, 0x04, 0x00
|
|
};
|
|
|
|
@Override
|
|
protected void handleRequest(Socket socket,
|
|
LdapMessage msg,
|
|
OutputStream out)
|
|
throws IOException {
|
|
switch (msg.getOperation()) {
|
|
case BIND_REQUEST:
|
|
out.write(bindResponse);
|
|
out.flush();
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static class NotBindableServer extends TestServer {
|
|
|
|
NotBindableServer() throws IOException { }
|
|
|
|
@Override
|
|
protected void beforeConnectionHandled(Socket socket) {
|
|
try {
|
|
TimeUnit.DAYS.sleep(Integer.MAX_VALUE);
|
|
} catch (InterruptedException e) {
|
|
Thread.currentThread().interrupt();
|
|
}
|
|
}
|
|
}
|
|
|
|
// ------ timeouts check utilities ------
|
|
|
|
/*
|
|
* Asserts that the specified executable yields a result or an exception
|
|
* within the specified time frame. Interrupts the executable
|
|
* unconditionally.
|
|
*
|
|
* If the executable yields a result or an exception within the specified
|
|
* time frame, the result will be returned and the exception will be
|
|
* rethrown respectively in a transparent fashion as if the executable was
|
|
* executed directly.
|
|
*/
|
|
public static <T> T assertCompletion(long loMillis,
|
|
long hiMillis,
|
|
Callable<T> code)
|
|
throws Throwable {
|
|
if (loMillis < 0 || hiMillis < 0 || loMillis > hiMillis) {
|
|
throw new IllegalArgumentException("loMillis=" + loMillis +
|
|
", hiMillis=" + hiMillis);
|
|
}
|
|
Objects.requireNonNull(code);
|
|
|
|
// this queue acts both as an exchange point and a barrier
|
|
SynchronousQueue<Long> startTime = new SynchronousQueue<>();
|
|
|
|
Callable<T> wrappedTask = () -> {
|
|
// by the time this value reaches the "stopwatch" thread it might be
|
|
// well outdated and that's okay, we will adjust the wait time
|
|
startTime.put(System.nanoTime());
|
|
return code.call();
|
|
};
|
|
|
|
FutureTask<T> task = new FutureTask<>(wrappedTask);
|
|
Thread t = new Thread(task);
|
|
t.start();
|
|
|
|
final long startNanos;
|
|
try {
|
|
startNanos = startTime.take(); // (1) wait for the initial time mark
|
|
} catch (Throwable e) {
|
|
t.interrupt();
|
|
throw e;
|
|
}
|
|
|
|
final long waitTime = hiMillis -
|
|
NANOSECONDS.toMillis(System.nanoTime() - startNanos); // (2) adjust wait time
|
|
|
|
try {
|
|
T r = task.get(waitTime, MILLISECONDS); // (3) wait for the task to complete
|
|
long elapsed = NANOSECONDS.toMillis(System.nanoTime() - startNanos);
|
|
if (elapsed < loMillis || elapsed > hiMillis) {
|
|
throw new RuntimeException(format(
|
|
"After %s ms. (waitTime %s ms.) returned result '%s'", elapsed, waitTime, r));
|
|
}
|
|
return r;
|
|
} catch (ExecutionException e) {
|
|
long elapsed = NANOSECONDS.toMillis(System.nanoTime() - startNanos);
|
|
if (elapsed < loMillis || elapsed > hiMillis) {
|
|
throw new RuntimeException(format(
|
|
"After %s ms. (waitTime %s ms.) thrown exception", elapsed, waitTime), e);
|
|
}
|
|
throw e.getCause();
|
|
} catch (TimeoutException e) {
|
|
// We trust timed get not to throw TimeoutException prematurely
|
|
// (i.e. before the wait time elapses)
|
|
long elapsed = NANOSECONDS.toMillis(System.nanoTime() - startNanos);
|
|
throw new RuntimeException(format(
|
|
"After %s ms. (waitTime %s ms.) is incomplete", elapsed, waitTime));
|
|
} finally {
|
|
t.interrupt();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Asserts that the specified executable yields no result and no exception
|
|
* for at least the specified amount of time. Interrupts the executable
|
|
* unconditionally.
|
|
*/
|
|
public static void assertIncompletion(long millis, Callable<?> code)
|
|
throws Exception
|
|
{
|
|
if (millis < 0) {
|
|
throw new IllegalArgumentException("millis=" + millis);
|
|
}
|
|
Objects.requireNonNull(code);
|
|
|
|
// this queue acts both as an exchange point and a barrier
|
|
SynchronousQueue<Long> startTime = new SynchronousQueue<>();
|
|
|
|
Callable<?> wrappedTask = () -> {
|
|
// by the time this value reaches the "stopwatch" thread it might be
|
|
// well outdated and that's okay, we will adjust the wait time
|
|
startTime.put(System.nanoTime());
|
|
return code.call();
|
|
};
|
|
|
|
FutureTask<?> task = new FutureTask<>(wrappedTask);
|
|
Thread t = new Thread(task);
|
|
t.start();
|
|
|
|
final long startNanos;
|
|
try {
|
|
startNanos = startTime.take(); // (1) wait for the initial time mark
|
|
} catch (Throwable e) {
|
|
t.interrupt();
|
|
throw e;
|
|
}
|
|
|
|
final long waitTime = millis -
|
|
NANOSECONDS.toMillis(System.nanoTime() - startNanos); // (2) adjust wait time
|
|
|
|
try {
|
|
Object r = task.get(waitTime, MILLISECONDS); // (3) wait for the task to complete
|
|
long elapsed = NANOSECONDS.toMillis(System.nanoTime() - startNanos);
|
|
if (elapsed < waitTime) {
|
|
throw new RuntimeException(format(
|
|
"After %s ms. (waitTime %s ms.) returned result '%s'", elapsed, waitTime, r));
|
|
}
|
|
} catch (ExecutionException e) {
|
|
long elapsed = NANOSECONDS.toMillis(System.nanoTime() - startNanos);
|
|
if (elapsed < waitTime) {
|
|
throw new RuntimeException(format(
|
|
"After %s ms. (waitTime %s ms.) thrown exception", elapsed, waitTime), e);
|
|
}
|
|
} catch (TimeoutException expected) {
|
|
} finally {
|
|
t.interrupt();
|
|
}
|
|
}
|
|
|
|
// ------ miscellaneous utilities ------
|
|
|
|
private static String urlTo(TestServer server) {
|
|
String hostAddress = server.getInetAddress().getHostAddress();
|
|
String addr;
|
|
if (hostAddress.contains(":")) { // IPv6
|
|
addr = '[' + hostAddress + ']';
|
|
} else { // IPv4
|
|
addr = hostAddress;
|
|
}
|
|
return "ldap://" + addr + ":" + server.getPort();
|
|
}
|
|
|
|
/*
|
|
* A diagnostic aid that might help with debugging timeout issues. The idea
|
|
* is to continuously measure accuracy and responsiveness of the system that
|
|
* runs this test. If the system is overwhelmed (with something else), it
|
|
* might affect the test run. At the very least we will have traces of that
|
|
* in the logs.
|
|
*
|
|
* This utility does not automatically scale up test timeouts, it simply
|
|
* gathers information.
|
|
*/
|
|
private static void startAuxiliaryDiagnosticOutput() {
|
|
System.out.printf("Starting diagnostic output (probe)%n");
|
|
Thread t = new Thread(() -> {
|
|
for (int i = 0; ; i = ((i % 20) + 1)) {
|
|
// 500, 1_000, 1_500, ..., 9_500, 10_000, 500, 1_000, ...
|
|
long expected = i * 500;
|
|
long start = System.nanoTime();
|
|
try {
|
|
MILLISECONDS.sleep(expected);
|
|
} catch (InterruptedException e) {
|
|
return;
|
|
}
|
|
long stop = System.nanoTime();
|
|
long actual = NANOSECONDS.toMillis(stop - start);
|
|
System.out.printf("(probe) expected [ms.]: %s, actual [ms.]: %s%n",
|
|
expected, actual);
|
|
|
|
}
|
|
}, "probe");
|
|
t.setDaemon(true);
|
|
t.start();
|
|
}
|
|
}
|