< prev index next >

test/jdk/com/sun/jndi/ldap/LdapTimeoutTest.java

Print this page

        

*** 1,7 **** /* ! * Copyright (c) 2011, 2016, 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. --- 1,7 ---- /* ! * 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.
*** 19,444 **** * 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 ! * @run main/othervm LdapTimeoutTest ! * @bug 7094377 8000487 6176036 7056489 * @summary Timeout tests for ldap */ 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.concurrent.Callable; import java.util.concurrent.ExecutionException; - import java.util.concurrent.Executors; import java.util.concurrent.ExecutorService; import java.util.concurrent.Future; ! import java.util.concurrent.ScheduledExecutorService; ! import java.util.concurrent.ScheduledFuture; ! import java.util.concurrent.TimeoutException; import java.util.concurrent.TimeUnit; ! import javax.net.ssl.SSLHandshakeException; import static java.util.concurrent.TimeUnit.MILLISECONDS; import static java.util.concurrent.TimeUnit.NANOSECONDS; ! 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); } ! ! boolean shutItDown(InitialContext ctx) { try { ! if (ctx != null) ctx.close(); ! return true; ! } catch (NamingException ex) { ! return false; } } ! 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<Void>() { ! public Void call() throws Exception { ! current.interrupt(); ! return null; } - }, HANGING_TEST_TIMEOUT, MILLISECONDS); } ! env.put(Context.PROVIDER_URL, "ldap://localhost:" + ! server.getLocalPort()); ! ! 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(); ! } ! return passed; ! } catch (IOException|InterruptedException e) { ! throw new RuntimeException(e); } } - } - - abstract class ReadServerTest extends LdapTest { ! public ReadServerTest(Hashtable env) throws IOException { ! super(new BindableServer(), env); } - - public ReadServerTest(Hashtable env, - ScheduledExecutorService killSwitchPool) - throws IOException - { - super(new BindableServer(), env, killSwitchPool); } ! public void performOp(InitialContext ctx) throws NamingException { SearchControls scl = new SearchControls(); scl.setSearchScope(SearchControls.SUBTREE_SCOPE); ! NamingEnumeration<SearchResult> answer = ((InitialDirContext)ctx) ! .search("ou=People,o=JNDITutorial", "(objectClass=*)", scl); } - } - - abstract class DeadServerTest extends LdapTest { - - public DeadServerTest(Hashtable env) throws IOException { - super(new DeadServer(), env); } ! public DeadServerTest(Hashtable env, ! ScheduledExecutorService killSwitchPool) ! throws IOException ! { ! super(new DeadServer(), env, killSwitchPool); } - - public void performOp(InitialContext ctx) throws NamingException {} - } - - class DeadServerNoTimeoutTest extends DeadServerTest { - - public DeadServerNoTimeoutTest(Hashtable env, - ScheduledExecutorService killSwitchPool) - throws IOException - { - super(env, killSwitchPool); } ! public void handleNamingException(NamingException e, long start, long end) { ! if (e instanceof InterruptedNamingException) Thread.interrupted(); ! ! if (NANOSECONDS.toMillis(end - start) < LdapTimeoutTest.MIN_TIMEOUT) { ! System.err.printf("DeadServerNoTimeoutTest fail: timeout should be " + ! "at least %s ms, actual time is %s ms%n", ! LdapTimeoutTest.MIN_TIMEOUT, ! NANOSECONDS.toMillis(end - start)); ! fail(); ! } else { ! pass(); } } - } ! class DeadServerTimeoutTest extends DeadServerTest { ! public DeadServerTimeoutTest(Hashtable env) throws IOException { ! super(env); ! } ! ! public void handleNamingException(NamingException e, long start, long end) ! { ! // non SSL connect will timeout via readReply using connectTimeout ! if (NANOSECONDS.toMillis(end - start) < 2_900) { ! pass(); ! } else { ! System.err.println("Fail: Waited too long"); ! fail(); ! } ! } ! } ! class ReadServerNoTimeoutTest extends ReadServerTest { ! public ReadServerNoTimeoutTest(Hashtable env, ! ScheduledExecutorService killSwitchPool) ! throws IOException ! { ! super(env, killSwitchPool); } ! public void handleNamingException(NamingException e, long start, long end) { ! if (e instanceof InterruptedNamingException) Thread.interrupted(); ! ! if (NANOSECONDS.toMillis(end - start) < LdapTimeoutTest.MIN_TIMEOUT) { ! System.err.printf("ReadServerNoTimeoutTest fail: timeout should be " + ! "at least %s ms, actual time is %s ms%n", ! LdapTimeoutTest.MIN_TIMEOUT, ! NANOSECONDS.toMillis(end - start)); ! fail(); ! } else { ! pass(); } } - } ! class ReadServerTimeoutTest extends ReadServerTest { ! public ReadServerTimeoutTest(Hashtable env) throws IOException { ! super(env); ! } ! public void handleNamingException(NamingException e, long start, long end) { ! System.out.println("ReadServerTimeoutTest: end-start=" + NANOSECONDS.toMillis(end - start)); ! if (NANOSECONDS.toMillis(end - start) < 2_500) { ! fail(); ! } else { ! pass(); } } - } ! class TestServer extends Thread { ! ServerSocket serverSock; ! boolean accepting = false; ! public TestServer() throws IOException { ! this.serverSock = new ServerSocket(0); ! start(); ! } ! public int getLocalPort() { ! return serverSock.getLocalPort(); } - - public boolean accepting() { - return accepting; } - - public void close() throws IOException { - serverSock.close(); } - } ! class BindableServer extends TestServer { ! public BindableServer() throws IOException { ! super(); ! } ! ! private byte[] bindResponse = { ! 0x30, 0x0C, 0x02, 0x01, 0x01, 0x61, 0x07, 0x0A, ! 0x01, 0x00, 0x04, 0x00, 0x04, 0x00 }; ! public void run() { ! try { ! accepting = true; ! Socket socket = serverSock.accept(); ! InputStream in = socket.getInputStream(); ! OutputStream out = socket.getOutputStream(); ! ! // Read the LDAP BindRequest ! while (in.read() != -1) { ! in.skip(in.available()); ! break; ! } ! // Write an LDAP BindResponse ! out.write(bindResponse); ! out.flush(); ! } catch (IOException e) { ! // ignore ! } } - } ! class DeadServer extends TestServer { - public DeadServer() throws IOException { - super(); - } - - public void run() { - while(true) { try { ! accepting = true; ! Socket socket = serverSock.accept(); ! } catch (Exception e) { ! break; ! } } } - } - - public class LdapTimeoutTest { ! private static final ExecutorService testPool = ! Executors.newFixedThreadPool(3); ! private static final ScheduledExecutorService killSwitchPool = ! Executors.newScheduledThreadPool(3); ! public static int MIN_TIMEOUT = 18_000; ! ! static Hashtable createEnv() { ! Hashtable env = new Hashtable(11); ! env.put(Context.INITIAL_CONTEXT_FACTORY, ! "com.sun.jndi.ldap.LdapCtxFactory"); ! return env; } ! public static void main(String[] args) throws Exception { ! InitialContext ctx = null; ! List<Future> results = new ArrayList<>(); try { ! // run the DeadServerTest with no timeouts set ! // this should get stuck indefinitely, so we need to kill ! // it after a timeout ! System.out.println("Running connect timeout test with 20s kill switch"); ! Hashtable env = createEnv(); ! results.add( ! testPool.submit(new DeadServerNoTimeoutTest(env, killSwitchPool))); ! ! // run the ReadServerTest with connect timeout set ! // this should get stuck indefinitely so we need to kill ! // it after a timeout ! System.out.println("Running read timeout test with 10ms connect timeout & 20s kill switch"); ! Hashtable env1 = createEnv(); ! env1.put("com.sun.jndi.ldap.connect.timeout", "10"); ! results.add(testPool.submit( ! new ReadServerNoTimeoutTest(env1, killSwitchPool))); ! ! // run the ReadServerTest with no timeouts set ! // this should get stuck indefinitely, so we need to kill ! // it after a timeout ! System.out.println("Running read timeout test with 20s kill switch"); ! Hashtable env2 = createEnv(); ! results.add(testPool.submit( ! new ReadServerNoTimeoutTest(env2, killSwitchPool))); ! ! // run the DeadServerTest with connect / read timeouts set ! // this should exit after the connect timeout expires ! System.out.println("Running connect timeout test with 10ms connect timeout, 3000ms read timeout"); ! Hashtable env3 = createEnv(); ! env3.put("com.sun.jndi.ldap.connect.timeout", "10"); ! env3.put("com.sun.jndi.ldap.read.timeout", "3000"); ! results.add(testPool.submit(new DeadServerTimeoutTest(env3))); ! ! ! // run the ReadServerTest with connect / read timeouts set ! // this should exit after the connect timeout expires ! // ! // NOTE: commenting this test out as it is failing intermittently. ! // ! // System.out.println("Running read timeout test with 10ms connect timeout, 3000ms read timeout"); ! // Hashtable env4 = createEnv(); ! // env4.put("com.sun.jndi.ldap.connect.timeout", "10"); ! // env4.put("com.sun.jndi.ldap.read.timeout", "3000"); ! // results.add(testPool.submit(new ReadServerTimeoutTest(env4))); ! ! // run the DeadServerTest with connect timeout set ! // this should exit after the connect timeout expires ! System.out.println("Running connect timeout test with 10ms connect timeout"); ! Hashtable env5 = createEnv(); ! env5.put("com.sun.jndi.ldap.connect.timeout", "10"); ! results.add(testPool.submit(new DeadServerTimeoutTest(env5))); ! // 8000487: Java JNDI connection library on ldap conn is ! // not honoring configured timeout ! System.out.println("Running simple auth connection test"); ! Hashtable env6 = createEnv(); ! env6.put("com.sun.jndi.ldap.connect.timeout", "10"); ! env6.put("com.sun.jndi.ldap.read.timeout", "3000"); ! env6.put(Context.SECURITY_AUTHENTICATION, "simple"); ! env6.put(Context.SECURITY_PRINCIPAL, "user"); ! env6.put(Context.SECURITY_CREDENTIALS, "password"); ! results.add(testPool.submit(new DeadServerTimeoutTest(env6))); ! ! boolean testFailed = false; ! for (Future test : results) { ! while (!test.isDone()) { ! if ((Boolean) test.get() == false) ! testFailed = true; } } - - if (testFailed) { - throw new AssertionError("some tests failed"); } ! } finally { ! LdapTimeoutTest.killSwitchPool.shutdown(); ! LdapTimeoutTest.testPool.shutdown(); } } ! } --- 19,507 ---- * 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(); + } + }
< prev index next >