/*
* 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.
*
* 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
* @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();
}
}
}