/**
* Filter the stacktrace elements with only interesting one.
*
* @param throwable throwable
* @return {@link Throwable} instance with interested stacktrace elements.
*/
public static Throwable sanitize(Throwable throwable) {
if (throwable instanceof NGrinderRuntimeException) {
if (((NGrinderRuntimeException) throwable).isSanitized()) {
return throwable;
}
}
Throwable t = throwable;
while (t != null) {
// Note that this getBoolean access may well be synced...
StackTraceElement[] trace = t.getStackTrace();
List<StackTraceElement> newTrace = CollectionUtils.newArrayList();
for (StackTraceElement stackTraceElement : trace) {
if (isApplicationClass(stackTraceElement.getClassName())) {
newTrace.add(stackTraceElement);
}
}
StackTraceElement[] clean = new StackTraceElement[newTrace.size()];
newTrace.toArray(clean);
t.setStackTrace(clean);
t = t.getCause();
}
if (throwable instanceof NGrinderRuntimeException) {
((NGrinderRuntimeException) throwable).setSanitized(true);
}
return throwable;
}
/**
* Gets the stack trace of the Throwable that caused this crash report, or if that fails, the
* cause .toString().
*/
public String getCauseStackTraceOrString() {
StringWriter stringwriter = null;
PrintWriter printwriter = null;
Throwable throwable = this.cause;
if (throwable.getMessage() == null) {
if (throwable instanceof NullPointerException) {
throwable = new NullPointerException(this.description);
} else if (throwable instanceof StackOverflowError) {
throwable = new StackOverflowError(this.description);
} else if (throwable instanceof OutOfMemoryError) {
throwable = new OutOfMemoryError(this.description);
}
throwable.setStackTrace(this.cause.getStackTrace());
}
String s = throwable.toString();
try {
stringwriter = new StringWriter();
printwriter = new PrintWriter(stringwriter);
throwable.printStackTrace(printwriter);
s = stringwriter.toString();
} finally {
IOUtils.closeQuietly((Writer) stringwriter);
IOUtils.closeQuietly((Writer) printwriter);
}
return s;
}
Throwable cleanStackTrace(Throwable e) {
List<StackTraceElement> cleanTrace = new ArrayList<StackTraceElement>();
for (StackTraceElement se : e.getStackTrace()) {
if (se.getClassName().startsWith("Template_")) {
String tn = se.getClassName().substring(9);
if (tn.indexOf("$") > -1) {
tn = tn.substring(0, tn.indexOf("$"));
}
Integer line = TemplateLoader.templates.get(tn).linesMatrix.get(se.getLineNumber());
if (line != null) {
String ext = "";
if (tn.indexOf(".") > -1) {
ext = tn.substring(tn.indexOf(".") + 1);
tn = tn.substring(0, tn.indexOf("."));
}
StackTraceElement nse = new StackTraceElement(TemplateLoader.templates.get(tn).name, ext, "line", line);
cleanTrace.add(nse);
}
}
if (!se.getClassName().startsWith("org.codehaus.groovy.") && !se.getClassName().startsWith("groovy.") && !se.getClassName().startsWith("sun.reflect.") && !se.getClassName().startsWith("java.lang.reflect.") && !se.getClassName().startsWith("Template_")) {
cleanTrace.add(se);
}
}
e.setStackTrace(cleanTrace.toArray(new StackTraceElement[cleanTrace.size()]));
return e;
}
private void finishConnect() {
// Note this method is invoked by the event loop only if the connection attempt was
// neither cancelled nor timed out.
assert eventLoop().inEventLoop();
boolean connectStillInProgress = false;
try {
boolean wasActive = isActive();
if (!doFinishConnect()) {
connectStillInProgress = true;
return;
}
fulfillConnectPromise(connectPromise, wasActive);
} catch (Throwable t) {
if (t instanceof ConnectException) {
Throwable newT = new ConnectException(t.getMessage() + ": " + requestedRemoteAddress);
newT.setStackTrace(t.getStackTrace());
t = newT;
}
fulfillConnectPromise(connectPromise, t);
} finally {
if (!connectStillInProgress) {
// Check for null as the connectTimeoutFuture is only created if a connectTimeoutMillis >
// 0 is used
// See https://github.com/netty/netty/issues/1770
if (connectTimeoutFuture != null) {
connectTimeoutFuture.cancel(false);
}
connectPromise = null;
}
}
}
public static <T extends Throwable> T trace(String message, T t) {
Throwable filtered = new RuntimeException(t.getMessage());
filtered.setStackTrace(Exceptions.filterStackTraceElements(t).toArray(steArrayType));
LOG.info(message);
LOG.trace(message, filtered);
return t;
}
@Override
public void uncaughtException(Thread thread, Throwable ex) {
final Writer result = new StringWriter();
final PrintWriter printWriter = new PrintWriter(result);
// Inject some info about android version and the device, since google can't provide them in the
// developer console
StackTraceElement[] trace = ex.getStackTrace();
StackTraceElement[] trace2 = new StackTraceElement[trace.length + 3];
System.arraycopy(trace, 0, trace2, 0, trace.length);
trace2[trace.length + 0] =
new StackTraceElement("Android", "MODEL", android.os.Build.MODEL, -1);
trace2[trace.length + 1] =
new StackTraceElement("Android", "VERSION", android.os.Build.VERSION.RELEASE, -1);
trace2[trace.length + 2] =
new StackTraceElement("Android", "FINGERPRINT", android.os.Build.FINGERPRINT, -1);
ex.setStackTrace(trace2);
ex.printStackTrace(printWriter);
String stacktrace = result.toString();
printWriter.close();
Log.e(TAG, stacktrace);
// Save the log on SD card if available
if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
String sdcardPath = Environment.getExternalStorageDirectory().getPath();
writeLog(stacktrace, sdcardPath + "/vlc_crash");
writeLogcat(sdcardPath + "/vlc_logcat");
}
defaultUEH.uncaughtException(thread, ex);
}
static <Z> void verifyUsingMatcher(@Nullable Z actualValue, Matcher<? super Z> matcher) {
try {
MatcherAssert.assertThat(actualValue, matcher);
} catch (Throwable ex) {
ex.setStackTrace(trimStackTrace(ex.getStackTrace()));
Throwables.propagate(ex);
}
}
static void verifyCheck(String description, boolean assertionState) {
try {
MatcherAssert.assertThat(description, assertionState);
} catch (Throwable ex) {
ex.setStackTrace(trimStackTrace(ex.getStackTrace()));
Throwables.propagate(ex);
}
}
@Override
public Object invoke(final Object proxy, final Method method, final Object[] args)
throws Throwable {
if (super.shouldHandle(method, args)) return super.handle(method, args);
if (args != null) {
for (final Object o : args) {
if (o != null && !(o instanceof Serializable)) {
throw new IllegalArgumentException(
o
+ " is not serializable, all remote method args must be serializable. method:"
+ method);
}
}
}
final RemoteMethodCall remoteMethodMsg =
new RemoteMethodCall(
m_endPointName, method.getName(), args, method.getParameterTypes(), m_remoteType);
if (m_ignoreResults) {
m_messenger.invoke(m_endPointName, remoteMethodMsg);
return null;
} else {
final RemoteMethodCallResults response =
m_messenger.invokeAndWait(m_endPointName, remoteMethodMsg);
if (response.getException() != null) {
if (response.getException() instanceof MessengerException) {
final MessengerException cle = (MessengerException) response.getException();
cle.fillInInvokerStackTrace();
} else {
// do not chain the exception, we want to keep whatever the original exception's class
// was, so just add our bit to the stack trace.
final Throwable throwable = response.getException();
final StackTraceElement[] exceptionTrace = throwable.getStackTrace();
final Exception ourException =
new Exception(throwable.getMessage() + " exception in response from other system");
final StackTraceElement[] ourTrace =
ourException.getStackTrace(); // Thread.currentThread().getStackTrace();
if (exceptionTrace != null && ourTrace != null) {
final StackTraceElement[] combinedTrace =
new StackTraceElement[(exceptionTrace.length + ourTrace.length)];
int i = 0;
for (int j = 0; j < exceptionTrace.length; j++) {
combinedTrace[i] = exceptionTrace[j];
i++;
}
for (int k = 0; k < ourTrace.length; k++) {
combinedTrace[i] = ourTrace[k];
i++;
}
throwable.setStackTrace(combinedTrace);
}
}
throw response.getException();
}
return response.getRVal();
}
}
public void afterInvocation(IInvokedMethod method, ITestResult result) {
resultT = result;
String textMsg = "Completed executing " + returnMethodName(method.getTestMethod());
Reporter.log(textMsg, true);
Reporter.setCurrentTestResult(result);
if (method.isTestMethod()) {
List<Throwable> verificationFailures = TestBase.getVerificationFailures();
// if there are verification failures...
if (verificationFailures.size() > 0) {
// set the test to failed
result.setStatus(ITestResult.FAILURE);
// if there is an assertion failure add it to verificationFailures
if (result.getThrowable() != null) {
verificationFailures.add(result.getThrowable());
}
int size = verificationFailures.size();
// if there's only one failure just set that
if (size == 1) {
result.setThrowable(verificationFailures.get(0));
} else {
// create a failure message with all failures and stack traces (except last failure)
StringBuffer failureMessage =
new StringBuffer("Multiple failures (").append(size).append("):\n\n");
for (int i = 0; i < size - 1; i++) {
failureMessage
.append("Failure ")
.append(i + 1)
.append(" of ")
.append(size)
.append(":\n");
Throwable t = verificationFailures.get(i);
String fullStackTrace = Utils.stackTrace(t, false)[1];
failureMessage.append(fullStackTrace).append("\n\n");
}
// final failure
Throwable last = verificationFailures.get(size - 1);
failureMessage.append("Failure ").append(size).append(" of ").append(size).append(":\n");
failureMessage.append(last.toString());
// set merged throwable
Throwable merged = new Throwable(failureMessage.toString());
merged.setStackTrace(last.getStackTrace());
result.setThrowable(merged);
}
}
}
}
public Throwable read(ClassLoader classLoader) throws IOException {
final Throwable causeThrowable = getCause(classLoader);
Throwable throwable = null;
if (serializedException != null) {
try {
final ExceptionReplacingObjectInputStream ois =
new ExceptionReplacingObjectInputStream(
new ByteArrayInputStream(serializedException), classLoader) {
@Override
protected Object resolveObject(Object obj) throws IOException {
if (obj instanceof CausePlaceholder) {
return causeThrowable;
}
return super.resolveObject(obj);
}
};
throwable = (Throwable) ois.readObject();
} catch (ClassNotFoundException e) {
// Ignore
} catch (InvalidClassException e) {
try {
Constructor<?> constructor = classLoader.loadClass(type).getConstructor(String.class);
throwable = (Throwable) constructor.newInstance(message);
throwable.initCause(causeThrowable);
throwable.setStackTrace(stackTrace);
} catch (ClassNotFoundException e1) {
// Ignore
} catch (NoSuchMethodException e1) {
// Ignore
} catch (Throwable t) {
throw UncheckedException.throwAsUncheckedException(t);
}
}
}
if (throwable == null) {
throwable = new PlaceholderException(type, message, causeThrowable);
throwable.setStackTrace(stackTrace);
}
return throwable;
}
private static ExecutionException addSubmissionTrace(
StackTraceElement[] submissionTrace, ExecutionException e) {
if (e.getCause() == null) {
return filterTrace(e);
}
Throwable cause = e.getCause();
StackTraceElement[] combined =
filterTrace(concat(cause.getStackTrace(), submissionTrace, StackTraceElement.class));
cause.setStackTrace(combined);
return filterTrace(e);
}
protected void doThrowable(final Throwable e) throws Exception {
if (parent.launchLocation != null) {
final ArrayList<StackTraceElement> stack = new ArrayList<StackTraceElement>(Arrays.asList(e.getStackTrace()));
stack.addAll(Arrays.asList(parent.launchLocation));
e.setStackTrace(stack.toArray(new StackTraceElement[stack.size()]));
}
postToUiThreadAndWait(new Callable<Object>() {
public Object call() throws Exception {
parent.onThrowable(e);
return null;
}
});
}
/**
* Filter the throwable, but will also filter any causes (right up the cause chain) as well if the
* <b>filterCause</b> boolean is set to <code>true</code>.
*
* @param t The throwable instance to filter.
* @param filterCause When set to <code>true</code> will also filter the cause chain as well.
* @throws QueryExecutionException If the where clause cannot be executed.
*/
public void filter(Throwable t, boolean filterCause) throws QueryExecutionException {
if (filterCause) {
Throwable c = t.getCause();
if (c != null) {
this.filter(c, filterCause);
}
}
t.setStackTrace(this.filterStackTrace(t.getStackTrace()));
}
/**
* Transforms the given throwable and its recursively referenced throwables into a new exception
* hierarchy. Exceptions that are most likely not known by an external calling party are replaced
* by a {@link PlaceholderException} object:
*
* <ul>
* <li>{@link ProcessingException} are mapped to itself if possible, otherwise to a {@link
* ProcessingException}
* <li>Exceptions in package <code>java.*</code> are mapped to itself if possible, otherwise to
* a {@link PlaceholderException}
* <li>All other exceptions are transformed to {@link PlaceholderException}
* </ul>
*
* @param t
* @return
*/
public static Throwable transformException(Throwable t) {
// first, go to exception stack and reverse it
ArrayList<Throwable> throwableStack = new ArrayList<Throwable>();
while (t != null) {
throwableStack.add(0, t);
t = t.getCause();
}
// second, transform each exception so that they do not use probably
// proprietary exception classes
Throwable cause = null;
for (Throwable throwable : throwableStack) {
Throwable transformedThrowable = null;
if (throwable instanceof ProcessingException) {
ProcessingException pe = null;
IProcessingStatus oldStatus = ((ProcessingException) throwable).getStatus();
ProcessingStatus newStatus =
(oldStatus instanceof ProcessingStatus
? (ProcessingStatus) oldStatus
: new ProcessingStatus(oldStatus));
newStatus.setException(cause);
try {
pe = (ProcessingException) transformWellKnownException(throwable, cause, newStatus);
} catch (RuntimeException fatal) {
// nop
}
if (pe == null) {
pe = new ProcessingException();
}
transformedThrowable = pe.withStatus(newStatus);
} else if (throwable.getClass().getPackage() != null
&& throwable.getClass().getPackage().getName().startsWith("java.")) {
transformedThrowable = transformWellKnownException(throwable, cause, null);
}
if (transformedThrowable == null) {
transformedThrowable = new PlaceholderException(throwable, cause);
}
transformedThrowable.setStackTrace(throwable.getStackTrace());
cause = transformedThrowable;
}
return cause;
}
public static void fixStackTrace(Throwable cause, StackTraceElement[] clientSideStackTrace) {
notNull(cause, "cause");
notNull(clientSideStackTrace, "clientSideStackTrace");
StackTraceElement[] serverSideStackTrace = cause.getStackTrace();
StackTraceElement[] newStackTrace =
new StackTraceElement[clientSideStackTrace.length + serverSideStackTrace.length];
System.arraycopy(serverSideStackTrace, 0, newStackTrace, 0, serverSideStackTrace.length);
newStackTrace[serverSideStackTrace.length] =
new StackTraceElement(EXCEPTION_SEPARATOR, "", null, -1);
System.arraycopy(
clientSideStackTrace,
1,
newStackTrace,
serverSideStackTrace.length + 1,
clientSideStackTrace.length - 1);
cause.setStackTrace(newStackTrace);
}
// recursively parse the causes and instantiate corresponding throwables
private Throwable getCause(Iterator<String> linesIterator, String firstLine) {
// The actual exception class of the cause might be unavailable at the
// client -> use a standard throwable to represent the cause.
Throwable res = new Throwable(firstLine.substring(firstLine.indexOf(":") + 2));
List<StackTraceElement> stackTraceList = new ArrayList<StackTraceElement>();
while (linesIterator.hasNext()) {
String oneLine = linesIterator.next();
if (oneLine.startsWith("Caused by:")) {
Throwable nestedCause = getCause(linesIterator, oneLine);
res.initCause(nestedCause);
break;
}
stackTraceList.add(parseStackTrackLine(oneLine));
}
StackTraceElement[] stackTraceElement = new StackTraceElement[stackTraceList.size()];
res.setStackTrace(stackTraceList.toArray(stackTraceElement));
return res;
}
public void cancel(Throwable cause) {
if (state == State.CREATED) {
assert heirs.size() == 0;
state = State.CLOSED;
parent.remove(this);
return;
}
if (failure == null) {
canceled = true;
failure = new CancellationException();
if (stackTrace != null) {
failure.setStackTrace(stackTrace.getStackTrace());
}
failure.initCause(cause);
if (state == State.TRYING) {
cancelHeirs();
}
}
}
private static Throwable makeLanguageStackTrace(
@NotNull Throwable currentThrowable, @NotNull PsiFile file) {
Throwable langThrowable = new Throwable();
FormattingModelBuilder builder = LanguageFormatting.INSTANCE.forContext(file);
if (builder == null) return currentThrowable;
Class builderClass = builder.getClass();
Class declaringClass = builderClass.getDeclaringClass();
String guessedFileName =
(declaringClass == null ? builderClass.getSimpleName() : declaringClass.getSimpleName())
+ ".java";
StackTraceElement ste =
new StackTraceElement(builder.getClass().getName(), "createModel", guessedFileName, 1);
StackTraceElement[] originalStackTrace = currentThrowable.getStackTrace();
StackTraceElement[] modifiedStackTrace = new StackTraceElement[originalStackTrace.length + 1];
System.arraycopy(originalStackTrace, 0, modifiedStackTrace, 1, originalStackTrace.length);
modifiedStackTrace[0] = ste;
langThrowable.setStackTrace(modifiedStackTrace);
return langThrowable;
}
protected Throwable looseUnmarsalThrowable(OpenWireFormat wireFormat, DataInput dataIn)
throws IOException {
if (dataIn.readBoolean()) {
String clazz = looseUnmarshalString(dataIn);
String message = looseUnmarshalString(dataIn);
Throwable o = createThrowable(clazz, message);
if (wireFormat.isStackTraceEnabled()) {
if (STACK_TRACE_ELEMENT_CONSTRUCTOR != null) {
StackTraceElement ss[] = new StackTraceElement[dataIn.readShort()];
for (int i = 0; i < ss.length; i++) {
try {
ss[i] =
(StackTraceElement)
STACK_TRACE_ELEMENT_CONSTRUCTOR.newInstance(
new Object[] {
looseUnmarshalString(dataIn),
looseUnmarshalString(dataIn),
looseUnmarshalString(dataIn),
Integer.valueOf(dataIn.readInt())
});
} catch (IOException e) {
throw e;
} catch (Throwable e) {
}
}
o.setStackTrace(ss);
} else {
short size = dataIn.readShort();
for (int i = 0; i < size; i++) {
looseUnmarshalString(dataIn);
looseUnmarshalString(dataIn);
looseUnmarshalString(dataIn);
dataIn.readInt();
}
}
o.initCause(looseUnmarsalThrowable(wireFormat, dataIn));
}
return o;
} else {
return null;
}
}
private static Throwable toStackTrace(
List<String> details, StackTraceElement[] parent, int index) {
String detail = details.get(index++);
if (!detail.startsWith("*")) {
return null; // should not be happened. ignore remaining
}
int i1 = detail.indexOf(':');
int i3 = detail.lastIndexOf(':');
int i2 = detail.substring(0, i3).lastIndexOf(':');
String exceptionClass = detail.substring(1, i1);
String exceptionMessage = detail.substring(i1 + 1, i2);
Throwable ex = newInstance(exceptionClass, exceptionMessage);
int length = Integer.parseInt(detail.substring(i2 + 1, i3));
int unique = Integer.parseInt(detail.substring(i3 + 1));
int i = 0;
StackTraceElement[] trace = new StackTraceElement[length];
for (; i <= unique; i++) {
detail = details.get(index++);
int j1 = detail.indexOf(':');
int j3 = detail.lastIndexOf(':');
int j2 = detail.substring(0, j3).lastIndexOf(':');
String className = detail.substring(0, j1);
String methodName = detail.substring(j1 + 1, j2);
String fileName = detail.substring(j2 + 1, j3);
if (fileName.isEmpty()) {
fileName = null;
}
int lineNumber = Integer.parseInt(detail.substring(j3 + 1));
trace[i] = new StackTraceElement(className, methodName, fileName, lineNumber);
}
int common = trace.length - i;
if (common > 0) {
System.arraycopy(parent, parent.length - common, trace, trace.length - common, common);
}
if (details.size() > index) {
ex.initCause(toStackTrace(details, trace, index));
}
ex.setStackTrace(trace);
return ex;
}
@Override
public void fail(final Throwable e) {
if (failure != null) {
throw new IllegalStateException(
"Invalid ExternalTaskCompletionHandle as " + methodName + " failed with exception.",
failure);
}
if (completed) {
throw new IllegalStateException("Already completed");
}
if (stackTrace != null && !parent.isRethrown(e)) {
AsyncStackTrace merged = new AsyncStackTrace(stackTrace, e.getStackTrace(), 0);
merged.setStartFrom(getParentTaskMethodName());
e.setStackTrace(merged.getStackTrace());
}
failure = e;
if (!inCancellationHandler) {
failToParent(e);
}
}
@Override
public void run() {
if (canceled) {
return;
}
setCurrent(parent);
try {
cancellationHandler = task.doExecute(completionHandle);
} catch (Throwable e) {
completionHandle.setDoExecuteFailed("ExternalTask.doExecute", e);
if (stackTrace != null && !parent.isRethrown(e)) {
AsyncStackTrace merged = new AsyncStackTrace(stackTrace, e.getStackTrace(), 0);
merged.setStartFrom(getParentTaskMethodName());
e.setStackTrace(merged.getStackTrace());
}
parent.fail(this, e);
} finally {
setCurrent(null);
}
}
public static void rewriteBlameStackTrace(final Throwable innerBlame) {
final StackTraceElement[] stackTrace = innerBlame.getStackTrace();
final List<StackTraceElement> innerStackTrace = new ArrayList<StackTraceElement>(10);
final List<StackTraceElement> outerStackTrace = new ArrayList<StackTraceElement>(10);
for (final StackTraceElement el : stackTrace) {
if (el.getClassName().startsWith("org.jboss.errai.codegen.")) {
innerStackTrace.add(el);
} else {
outerStackTrace.add(el);
}
}
innerBlame.setStackTrace(
innerStackTrace.toArray(new StackTraceElement[innerStackTrace.size()]));
final RuntimeException outerBlame = new RuntimeException("External call to API");
outerBlame.setStackTrace(
outerStackTrace.toArray(new StackTraceElement[outerStackTrace.size()]));
innerBlame.initCause(outerBlame);
}
private Throwable removeFrameworkFramesAndAppendStepLocation(
Throwable error, StackTraceElement stepLocation) {
StackTraceElement[] stackTraceElements = error.getStackTrace();
if (stackTraceElements.length == 0 || stepLocation == null) {
return error;
}
int newStackTraceLength;
for (newStackTraceLength = 1;
newStackTraceLength < stackTraceElements.length;
++newStackTraceLength) {
if (stepDefinition.isDefinedAt(stackTraceElements[newStackTraceLength - 1])) {
break;
}
}
StackTraceElement[] newStackTrace = new StackTraceElement[newStackTraceLength + 1];
System.arraycopy(stackTraceElements, 0, newStackTrace, 0, newStackTraceLength);
newStackTrace[newStackTraceLength] = stepLocation;
error.setStackTrace(newStackTrace);
return error;
}
@NotNull
private static String renderStackTrace(@NotNull Throwable cause) {
StackTraceElement[] oldTrace = cause.getStackTrace();
List<StackTraceElement> newTrace = new ArrayList<StackTraceElement>();
boolean skip = true;
for (int i = oldTrace.length - 1; i >= 0; i--) {
StackTraceElement element = oldTrace[i];
// All our code happens in the script constructor, and no reflection/native code happens in
// constructors.
// So we ignore everything in the stack trace until the first constructor
if (element.getMethodName().equals("<init>")) {
skip = false;
}
if (!skip) {
newTrace.add(element);
}
}
Collections.reverse(newTrace);
cause.setStackTrace(newTrace.toArray(new StackTraceElement[newTrace.size()]));
return Throwables.getStackTraceAsString(cause);
}
/**
* translate japid runtime exception to Play's TemplateExecutionException for formated error
* reporting
*/
static void handleException(Throwable e) throws RuntimeException {
if (Play.mode == Mode.PROD) throw new RuntimeException(e);
if (e instanceof TemplateExecutionException) throw (TemplateExecutionException) e;
if (e instanceof RuntimeException && e.getCause() != null) e = e.getCause();
// find the latest japidviews exception
StackTraceElement[] stackTrace = e.getStackTrace();
for (StackTraceElement ele : stackTrace) {
String className = ele.getClassName();
if (className.startsWith("japidviews")) {
int lineNumber = ele.getLineNumber();
RendererClass applicationClass = JapidPlayRenderer.japidClasses.get(className);
// ApplicationClass applicationClass = Play.classes.getApplicationClass(className);
if (applicationClass != null) {
// let's get the line of problem
String jsrc = applicationClass.getSourceCode();
String[] splitSrc = jsrc.split("\n");
String line = splitSrc[lineNumber - 1];
// can we have a line marker?
int lineMarker = line.lastIndexOf("// line ");
if (lineMarker > 0) {
int oriLineNumber = Integer.parseInt(line.substring(lineMarker + 8).trim());
StackTraceElement[] newStack = new StackTraceElement[stackTrace.length + 1];
newStack[0] =
new StackTraceElement(
className, "", applicationClass.getSrcFile().getPath(), oriLineNumber);
System.arraycopy(stackTrace, 0, newStack, 1, stackTrace.length);
e.setStackTrace(newStack);
JapidPlayTemplate jpt = new JapidPlayTemplate();
jpt.name = applicationClass.getSrcFile().getPath();
jpt.source = applicationClass.getOriSourceCode();
throw new TemplateExecutionException(jpt, oriLineNumber, e.getMessage(), e);
}
}
}
}
throw new RuntimeException(e);
}
@Override
public void run() {
if (state == State.CLOSED) {
return;
}
if (state == State.CREATED) {
state = State.TRYING;
}
setCurrent(this);
Throwable f = failure;
try {
switch (state) {
case TRYING:
if (canceled) {
return;
}
tryCatchFinally.doTry();
break;
case CATCHING:
failure = null;
tryCatchFinally.doCatch(f);
break;
case FINALIZING:
tryCatchFinally.doFinally();
}
} catch (Throwable e) {
if (stackTrace != null && e != f) {
AsyncStackTrace merged = new AsyncStackTrace(stackTrace, e.getStackTrace(), 0);
merged.setStartFrom(getParentTaskMethodName());
e.setStackTrace(merged.getStackTrace());
}
failure = e;
cancelHeirs();
} finally {
setCurrent(null);
executed = true;
updateState();
}
}
public Throwable filter(Throwable source) {
if (shouldFilter) {
StackTraceElement[] trace = source.getStackTrace();
List<StackTraceElement> newTrace = filterTraceWithCutOff(trace, cutOffPackage);
if (newTrace.isEmpty()) {
// filter with no cut-off so at least there is some trace
newTrace = filterTraceWithCutOff(trace, null);
}
// Only trim the trace if there was some application trace on the stack
// if not we will just skip sanitizing and leave it as is
if (!newTrace.isEmpty()) {
// We don't want to lose anything, so log it
STACK_LOG.error(FULL_STACK_TRACE_MESSAGE, source);
StackTraceElement[] clean = new StackTraceElement[newTrace.size()];
newTrace.toArray(clean);
source.setStackTrace(clean);
}
}
return source;
}
private Throwable getCause(Method method, Throwable th) throws Throwable {
Class<?> exTypes[] = method.getExceptionTypes();
Throwable cause = th;
Throwable lastThrowable = th;
while (cause != null) {
lastThrowable = cause;
for (Class<?> exType : exTypes) {
if (exType == cause.getClass()) {
RuntimeException ex = new RuntimeException();
StackTraceElement ste[] = ex.getStackTrace();
StackTraceElement causeSte[] = lastThrowable.getStackTrace();
StackTraceElement aggregateSte[] = new StackTraceElement[ste.length + causeSte.length];
System.arraycopy(causeSte, 0, aggregateSte, 0, causeSte.length);
System.arraycopy(ste, 0, aggregateSte, causeSte.length, ste.length);
lastThrowable.setStackTrace(aggregateSte);
throw lastThrowable;
}
}
cause = cause.getCause();
}
throw lastThrowable;
}
