| // Copyright 2006, 2007, 2008, 2009, 2010 The Apache Software Foundation |
| // |
| // 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 org.apache.tapestry5.ioc.internal.services; |
| |
| import org.apache.tapestry5.ioc.internal.util.CollectionFactory; |
| import org.apache.tapestry5.ioc.services.*; |
| |
| import java.util.*; |
| |
| public class ExceptionAnalyzerImpl implements ExceptionAnalyzer |
| { |
| private final PropertyAccess propertyAccess; |
| |
| private final Set<String> throwableProperties; |
| |
| /** |
| * A tuple used to communicate up a lavel both the exception info |
| * and the next exception in the stack. |
| */ |
| private class ExceptionData |
| { |
| final ExceptionInfo exceptionInfo; |
| final Throwable cause; |
| |
| public ExceptionData(ExceptionInfo exceptionInfo, Throwable cause) |
| { |
| this.exceptionInfo = exceptionInfo; |
| this.cause = cause; |
| } |
| } |
| |
| public ExceptionAnalyzerImpl(PropertyAccess propertyAccess) |
| { |
| this.propertyAccess = propertyAccess; |
| |
| throwableProperties = CollectionFactory.newSet(this.propertyAccess.getAdapter(Throwable.class) |
| .getPropertyNames()); |
| } |
| |
| public ExceptionAnalysis analyze(Throwable rootException) |
| { |
| List<ExceptionInfo> list = CollectionFactory.newList(); |
| |
| Throwable t = rootException; |
| |
| ExceptionInfo previousInfo = null; |
| |
| while (t != null) |
| { |
| ExceptionData data = extractData(t); |
| |
| ExceptionInfo info = data.exceptionInfo; |
| |
| if (addsValue(previousInfo, info)) |
| { |
| list.add(info); |
| previousInfo = info; |
| } |
| |
| t = data.cause; |
| } |
| |
| return new ExceptionAnalysisImpl(list); |
| } |
| |
| /** |
| * We want to filter out exceptions that do not provide any additional value. Additional value includes: an |
| * exception message not present in the containing exception or a property value not present in the containing |
| * exception. Also the first exception is always valued and the last exception (with the stack trace) is valued. |
| * |
| * @param previousInfo |
| * @param info |
| * @return |
| */ |
| private boolean addsValue(ExceptionInfo previousInfo, ExceptionInfo info) |
| { |
| if (previousInfo == null) |
| return true; |
| |
| if (!info.getStackTrace().isEmpty()) |
| return true; |
| |
| if (!previousInfo.getMessage().contains(info.getMessage())) |
| return true; |
| |
| for (String name : info.getPropertyNames()) |
| { |
| if (info.getProperty(name).equals(previousInfo.getProperty(name))) |
| continue; |
| |
| // Found something new and different at this level. |
| |
| return true; |
| } |
| |
| // This exception adds nothing that is not present at a higher level. |
| |
| return false; |
| } |
| |
| private ExceptionData extractData(Throwable t) |
| { |
| Map<String, Object> properties = CollectionFactory.newMap(); |
| |
| ClassPropertyAdapter adapter = propertyAccess.getAdapter(t); |
| |
| Throwable cause = null; |
| |
| for (String name : adapter.getPropertyNames()) |
| { |
| PropertyAdapter pa = adapter.getPropertyAdapter(name); |
| |
| if (!pa.isRead()) |
| continue; |
| |
| if (cause == null && Throwable.class.isAssignableFrom(pa.getType())) |
| { |
| // Ignore the property, but track it as the cause. |
| |
| Throwable nestedException = (Throwable) pa.get(t); |
| |
| // Handle the case where an exception is its own cause (avoid endless loop!) |
| if (t != nestedException) |
| cause = nestedException; |
| |
| continue; |
| } |
| |
| // Otherwise, ignore properties defined by the Throwable class |
| |
| if (throwableProperties.contains(name)) |
| continue; |
| |
| Object value = pa.get(t); |
| |
| if (value == null) |
| continue; |
| |
| // An interesting property, let's save it for the analysis. |
| |
| properties.put(name, value); |
| } |
| |
| // Provide the stack trace only at the deepest exception. |
| |
| List<StackTraceElement> stackTrace = Collections.emptyList(); |
| |
| // Usually, I'd use a terniary expression here, but Generics gets in |
| // the way here. |
| |
| if (cause == null) |
| stackTrace = Arrays.asList(t.getStackTrace()); |
| |
| ExceptionInfo info = new ExceptionInfoImpl(t, properties, stackTrace); |
| |
| return new ExceptionData(info, cause); |
| } |
| } |