/*
* Copyright 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.junit.server;
import com.google.gwt.dev.util.JsniRef;
import com.google.gwt.dev.util.StringKey;
import com.google.gwt.junit.JUnitFatalLaunchException;
import com.google.gwt.junit.JUnitMessageQueue;
import com.google.gwt.junit.JUnitShell;
import com.google.gwt.junit.JUnitMessageQueue.ClientInfoExt;
import com.google.gwt.junit.client.TimeoutException;
import com.google.gwt.junit.client.impl.JUnitHost;
import com.google.gwt.junit.client.impl.JUnitResult;
import com.google.gwt.user.client.rpc.InvocationException;
import com.google.gwt.user.server.rpc.HybridServiceServlet;
import com.google.gwt.user.server.rpc.RPCServletUtils;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* An RPC servlet that serves as a proxy to JUnitTestShell. Enables
* communication between the unit test code running in a browser and the real
* test process.
*/
public class JUnitHostImpl extends HybridServiceServlet implements JUnitHost {
private static class StrongName extends StringKey {
protected StrongName(String value) {
super(value);
}
}
private static class SymbolName extends StringKey {
protected SymbolName(String value) {
super(value);
}
}
/**
* A hook into GWTUnitTestShell, the underlying unit test process.
*/
private static JUnitMessageQueue sHost = null;
/**
* A maximum timeout to wait for the test system to respond with the next
* test. The test system should respond nearly instantly if there are further
* tests to run, unless the tests have not yet been compiled.
*/
private static final int TIME_TO_WAIT_FOR_TESTNAME = 300000;
/**
* Monotonic increase counter to create unique client session ids.
*/
private static final AtomicInteger uniqueSessionId = new AtomicInteger();
/**
* Tries to grab the GWTUnitTestShell sHost environment to communicate with
* the real test process.
*/
private static synchronized JUnitMessageQueue getHost() {
if (sHost == null) {
sHost = JUnitShell.getMessageQueue();
if (sHost == null) {
throw new InvocationException(
"Unable to find JUnitShell; is this servlet running under GWTTestCase?");
}
}
return sHost;
}
private Map<StrongName, Map<SymbolName, String>> symbolMaps = new HashMap<StrongName, Map<SymbolName, String>>();
public InitialResponse getTestBlock(int blockIndex, ClientInfo clientInfo)
throws TimeoutException {
ClientInfoExt clientInfoExt;
HttpServletRequest request = getThreadLocalRequest();
if (clientInfo.getSessionId() < 0) {
clientInfoExt = createNewClientInfo(clientInfo.getUserAgent(), request);
} else {
clientInfoExt = createClientInfo(clientInfo, request);
}
TestBlock initialTestBlock = getHost().getTestBlock(clientInfoExt,
blockIndex, TIME_TO_WAIT_FOR_TESTNAME);
// Send back the updated session id.
return new InitialResponse(clientInfoExt.getSessionId(), initialTestBlock);
}
public TestBlock reportResultsAndGetTestBlock(
HashMap<TestInfo, JUnitResult> results, int testBlock,
ClientInfo clientInfo) throws TimeoutException {
for (JUnitResult result : results.values()) {
initResult(getThreadLocalRequest(), result);
resymbolize(result.getException());
}
JUnitMessageQueue host = getHost();
ClientInfoExt clientInfoExt = createClientInfo(clientInfo,
getThreadLocalRequest());
host.reportResults(clientInfoExt, results);
return host.getTestBlock(clientInfoExt, testBlock,
TIME_TO_WAIT_FOR_TESTNAME);
}
@Override
protected void service(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
String requestURI = request.getRequestURI();
if (requestURI.endsWith("/junithost/loadError")) {
String requestPayload = RPCServletUtils.readContentAsGwtRpc(request);
JUnitResult result = new JUnitResult();
initResult(request, result);
result.setException(new JUnitFatalLaunchException(requestPayload));
getHost().reportFatalLaunch(createNewClientInfo(null, request), result);
} else {
super.service(request, response);
}
}
private ClientInfoExt createClientInfo(ClientInfo clientInfo,
HttpServletRequest request) {
assert (clientInfo.getSessionId() >= 0);
return new ClientInfoExt(clientInfo.getSessionId(),
clientInfo.getUserAgent(), getClientDesc(request));
}
private ClientInfoExt createNewClientInfo(String userAgent,
HttpServletRequest request) {
return new ClientInfoExt(createSessionId(), userAgent,
getClientDesc(request));
}
private int createSessionId() {
return uniqueSessionId.getAndIncrement();
}
/**
* Returns a client description for the current request.
*/
private String getClientDesc(HttpServletRequest request) {
String machine = request.getRemoteHost();
String agent = request.getHeader("User-Agent");
return machine + " / " + agent;
}
private void initResult(HttpServletRequest request, JUnitResult result) {
String agent = request.getHeader("User-Agent");
result.setAgent(agent);
String machine = request.getRemoteHost();
result.setHost(machine);
}
private synchronized Map<SymbolName, String> loadSymbolMap(
StrongName strongName) {
Map<SymbolName, String> toReturn = symbolMaps.get(strongName);
if (toReturn != null) {
return toReturn;
}
toReturn = new HashMap<SymbolName, String>();
/*
* Collaborate with SymbolMapsLinker for the location of the symbol data
* because the -aux directory isn't accessible via the servlet context.
*/
String path = getRequestModuleBasePath() + "/.junit_symbolMaps/"
+ strongName.get() + ".symbolMap";
InputStream in = getServletContext().getResourceAsStream(path);
if (in == null) {
symbolMaps.put(strongName, null);
return null;
}
BufferedReader bin = new BufferedReader(new InputStreamReader(in));
String line;
try {
try {
while ((line = bin.readLine()) != null) {
if (line.charAt(0) == '#') {
continue;
}
int idx = line.indexOf(',');
toReturn.put(new SymbolName(line.substring(0, idx)),
line.substring(idx + 1));
}
} finally {
bin.close();
}
} catch (IOException e) {
toReturn = null;
}
symbolMaps.put(strongName, toReturn);
return toReturn;
}
/**
* Resymbolizes a trace from obfuscated symbols to Java names.
*/
private void resymbolize(Throwable exception) {
if (exception == null) {
return;
}
StackTraceElement[] stackTrace = exception.getStackTrace();
StrongName strongName = new StrongName(getPermutationStrongName());
Map<SymbolName, String> map = loadSymbolMap(strongName);
if (map == null) {
return;
}
for (int i = 0; i < stackTrace.length; ++i) {
StackTraceElement ste = stackTrace[i];
String symbolData = map.get(new SymbolName(ste.getMethodName()));
if (symbolData != null) {
// jsniIdent, className, memberName, sourceUri, sourceLine
String[] parts = symbolData.split(",");
assert parts.length == 6 : "Expected 6, have " + parts.length;
JsniRef ref = JsniRef.parse(parts[0].substring(0,
parts[0].lastIndexOf(')') + 1));
stackTrace[i] = new StackTraceElement(ref.className(),
ref.memberName(), ste.getFileName(), ste.getLineNumber());
}
}
exception.setStackTrace(stackTrace);
resymbolize(exception.getCause());
}
}