private String detectAgentUrl(
HttpServer pServer, JolokiaServerConfig pConfig, String pContextPath) {
serverAddress = pServer.getAddress();
InetAddress realAddress;
int port;
if (serverAddress != null) {
realAddress = serverAddress.getAddress();
if (realAddress.isAnyLocalAddress()) {
try {
realAddress = NetworkUtil.getLocalAddress();
} catch (IOException e) {
try {
realAddress = InetAddress.getLocalHost();
} catch (UnknownHostException e1) {
// Ok, ok. We take the original one
realAddress = serverAddress.getAddress();
}
}
}
port = serverAddress.getPort();
} else {
realAddress = pConfig.getAddress();
port = pConfig.getPort();
}
return String.format(
"%s://%s:%d%s", pConfig.getProtocol(), realAddress.getHostAddress(), port, pContextPath);
}
private static HttpServer createHttpServer(ExecutorService execs) throws Exception {
InetSocketAddress inetAddress = new InetSocketAddress(0);
HttpServer testServer = HttpServer.create(inetAddress, 5);
testServer.setExecutor(execs);
HttpContext context = testServer.createContext("/test");
context.setHandler(
new HttpHandler() {
public void handle(HttpExchange msg) {
try {
synchronized (lock) {
++s_received;
if ((s_received % 1000) == 0) {
System.out.println("Received=" + s_received);
}
}
String method = msg.getRequestMethod();
if (method.equals("POST")) {
InputStream is = msg.getRequestBody();
byte[] buf = readFully(is);
is.close();
writePostReply(msg, buf);
} else {
System.out.println("****** METHOD not handled ***** " + method);
System.out.println("Received=" + s_received);
}
synchronized (lock) {
++sent;
if ((sent % 1000) == 0) {
System.out.println("sent=" + sent);
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
msg.close();
}
}
});
return testServer;
}
/**
* Create the HttpServer to use. Can be overridden if a custom or already existing HttpServer
* should be used
*
* @return HttpServer to use
* @throws IOException if something fails during the initialisation
*/
private HttpServer createHttpServer(JolokiaServerConfig pConfig) throws IOException {
int port = pConfig.getPort();
InetAddress address = pConfig.getAddress();
InetSocketAddress socketAddress = new InetSocketAddress(address, port);
HttpServer server =
pConfig.useHttps()
? createHttpsServer(socketAddress, pConfig)
: HttpServer.create(socketAddress, pConfig.getBacklog());
// Prepare executor pool
Executor executor;
String mode = pConfig.getExecutor();
if ("fixed".equalsIgnoreCase(mode)) {
executor = Executors.newFixedThreadPool(pConfig.getThreadNr(), daemonThreadFactory);
} else if ("cached".equalsIgnoreCase(mode)) {
executor = Executors.newCachedThreadPool(daemonThreadFactory);
} else {
executor = Executors.newSingleThreadExecutor(daemonThreadFactory);
}
server.setExecutor(executor);
return server;
}
public static void main(String[] args) throws Exception {
try {
lock = new Object();
if (args.length > 0) {
NUM = Integer.parseInt(args[0]);
}
execs = Executors.newFixedThreadPool(5);
httpServer = createHttpServer(execs);
port = httpServer.getAddress().getPort();
pool = Executors.newFixedThreadPool(10);
httpServer.start();
for (int i = 0; i < NUM; i++) {
pool.execute(new Client());
if (error) {
throw new Exception("error in test");
}
}
System.out.println("Main thread waiting");
pool.shutdown();
long latest = System.currentTimeMillis() + 200 * 1000;
while (System.currentTimeMillis() < latest) {
if (pool.awaitTermination(2000L, TimeUnit.MILLISECONDS)) {
System.out.println("Main thread done!");
return;
}
if (error) {
throw new Exception("error in test");
}
}
throw new Exception("error in test: timed out");
} finally {
httpServer.stop(0);
pool.shutdownNow();
execs.shutdownNow();
}
}
/**
* Initialize this JolokiaServer with the given HttpServer. The calle is responsible for managing
* (starting/stopping) the HttpServer.
*
* @param pServer server to use
* @param pConfig configuration
* @param pLazy whether the initialization should be done lazy or not
*/
protected final void init(HttpServer pServer, JolokiaServerConfig pConfig, boolean pLazy) {
config = pConfig;
lazy = pLazy;
// Create proper context along with handler
final String contextPath = pConfig.getContextPath();
jolokiaHttpHandler = new JolokiaHttpHandler(pConfig.getJolokiaConfig());
HttpContext context = pServer.createContext(contextPath, jolokiaHttpHandler);
// Add authentication if configured
final Authenticator authenticator = pConfig.getAuthenticator();
if (authenticator != null) {
context.setAuthenticator(authenticator);
}
url = detectAgentUrl(pServer, pConfig, contextPath);
}
public static void main(String[] args) throws Exception {
HttpServer s1 = null;
HttpsServer s2 = null;
ExecutorService executor = null;
try {
String root = System.getProperty("test.src") + "/docs";
System.out.print("Test12: ");
InetSocketAddress addr = new InetSocketAddress(0);
s1 = HttpServer.create(addr, 0);
s2 = HttpsServer.create(addr, 0);
HttpHandler h = new FileServerHandler(root);
HttpContext c1 = s1.createContext("/test1", h);
HttpContext c2 = s2.createContext("/test1", h);
executor = Executors.newCachedThreadPool();
s1.setExecutor(executor);
s2.setExecutor(executor);
ctx = new SimpleSSLContext(System.getProperty("test.src")).get();
s2.setHttpsConfigurator(new HttpsConfigurator(ctx));
s1.start();
s2.start();
int port = s1.getAddress().getPort();
int httpsport = s2.getAddress().getPort();
Runner r[] = new Runner[8];
r[0] = new Runner(true, "http", root + "/test1", port, "smallfile.txt", 23);
r[1] = new Runner(true, "http", root + "/test1", port, "largefile.txt", 2730088);
r[2] = new Runner(true, "https", root + "/test1", httpsport, "smallfile.txt", 23);
r[3] = new Runner(true, "https", root + "/test1", httpsport, "largefile.txt", 2730088);
r[4] = new Runner(false, "http", root + "/test1", port, "smallfile.txt", 23);
r[5] = new Runner(false, "http", root + "/test1", port, "largefile.txt", 2730088);
r[6] = new Runner(false, "https", root + "/test1", httpsport, "smallfile.txt", 23);
r[7] = new Runner(false, "https", root + "/test1", httpsport, "largefile.txt", 2730088);
start(r);
join(r);
System.out.println("OK");
} finally {
delay();
if (s1 != null) s1.stop(2);
if (s2 != null) s2.stop(2);
if (executor != null) executor.shutdown();
}
}
