/**
* This method duplicates the functionality of ExceptionUtils.describeStackLevels which is no
* longer supported in Rice.
*
* @param fromLevel
* @param toLevel
* @return
*/
public static String getMethodPath(int fromLevel, int toLevel) {
StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
// increase the levels to avoid including the method that called this.
fromLevel = fromLevel + 1;
toLevel = toLevel + 1;
if (fromLevel <= 0) {
throw new IllegalArgumentException("invalid fromLevel (" + fromLevel + " < 0)");
}
if (fromLevel > toLevel) {
throw new IllegalArgumentException(
"invalid levels (fromLevel " + fromLevel + " > toLevel " + toLevel + ")");
}
if (toLevel >= stackTraceElements.length) {
throw new IllegalArgumentException(
"invalid toLevel (" + toLevel + " >= " + stackTraceElements.length + ")");
}
StringBuffer result = new StringBuffer();
int elementIndex = 0;
for (StackTraceElement element : stackTraceElements) {
if (elementIndex >= fromLevel && elementIndex >= toLevel) {
if (result.length() > 0) {
result.append(" from ");
}
result.append(element.getClassName()).append(".");
result.append(element.getMethodName()).append("(");
result.append(element.getFileName()).append(":");
result.append(element.getLineNumber()).append(")");
}
elementIndex++;
}
return result.toString();
}
public void insertListOfCallPoints(@Nullable List<CallPoint> callPoints) {
if (content.length() == 0) {
content.append(EOL).append(" ");
}
content.append(" <ol style='display:none'>");
if (callPoints == null) {
content.append("</ol>").append(EOL).append(" ");
return;
}
content.append(EOL);
CallPoint currentCP = callPoints.get(0);
appendTestMethod(currentCP.getStackTraceElement());
appendRepetitionCountIfNeeded(currentCP);
for (int i = 1, n = callPoints.size(); i < n; i++) {
CallPoint nextCP = callPoints.get(i);
StackTraceElement ste = nextCP.getStackTraceElement();
if (nextCP.isSameTestMethod(currentCP)) {
content.append(", ").append(ste.getLineNumber());
} else {
content.append("</li>").append(EOL);
appendTestMethod(ste);
}
appendRepetitionCountIfNeeded(nextCP);
currentCP = nextCP;
}
content.append("</li>").append(EOL).append(" </ol>").append(EOL).append(" ");
}
/** Checks all of the methods in gen for consistency */
public static void checkMgens(final ClassGen gen) {
if (skip_checks) return;
Method[] methods = gen.getMethods();
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
// System.out.println ("Checking method " + method + " in class "
// + gen.getClassName());
checkMgen(new MethodGen(method, gen.getClassName(), gen.getConstantPool()));
}
if (false) {
Throwable t = new Throwable();
t.fillInStackTrace();
StackTraceElement[] ste = t.getStackTrace();
StackTraceElement caller = ste[1];
System.out.printf(
"%s.%s (%s line %d)",
caller.getClassName(),
caller.getMethodName(),
caller.getFileName(),
caller.getLineNumber());
for (int ii = 2; ii < ste.length; ii++)
System.out.printf(" [%s line %d]", ste[ii].getFileName(), ste[ii].getLineNumber());
System.out.printf("\n");
dump_methods(gen);
}
}
// Private method to infer the caller's class and method names
private void inferCaller() {
needToInferCaller = false;
// Android-changed: Use VMStack.getThreadStackTrace.
StackTraceElement[] stack = VMStack.getThreadStackTrace(Thread.currentThread());
int depth = stack.length;
boolean lookingForLogger = true;
for (int ix = 0; ix < depth; ix++) {
// Calling getStackTraceElement directly prevents the VM
// from paying the cost of building the entire stack frame.
//
// Android-changed: Use value from getThreadStackTrace.
StackTraceElement frame = stack[ix];
String cname = frame.getClassName();
boolean isLoggerImpl = isLoggerImplFrame(cname);
if (lookingForLogger) {
// Skip all frames until we have found the first logger frame.
if (isLoggerImpl) {
lookingForLogger = false;
}
} else {
if (!isLoggerImpl) {
// skip reflection call
if (!cname.startsWith("java.lang.reflect.") && !cname.startsWith("sun.reflect.")) {
// We've found the relevant frame.
setSourceClassName(cname);
setSourceMethodName(frame.getMethodName());
return;
}
}
}
}
// We haven't found a suitable frame, so just punt. This is
// OK as we are only committed to making a "best effort" here.
}
public final synchronized T getInfo(URI uri, RenderingContext context) {
T result = cache.get(uri);
if (result == null) {
try {
result = requestInfo(uri, context);
} catch (Exception e) {
loader
.logger()
.info(
"Error while getting capabilities for "
+ uri
+ ". The print module will assume it's a standard WMS.");
String stackTrace = "";
for (StackTraceElement el : e.getStackTrace()) {
stackTrace += el.toString() + "\n";
}
loader.logger().info(stackTrace);
result = loader.createNewErrorResult();
}
if (loader.logger().isDebugEnabled()) {
loader.logger().debug("GetCapabilities " + uri + ": " + result);
}
cache.put(uri, result);
}
return result;
}
/**
* Prints out the given debug message to System.out, prefixed by the calling class name, method
* and line number, appending the stacktrace of the given exception.
*/
public static void out(final String _debug_msg, final Throwable _exception) {
String header = "DEBUG::";
header = header + new Date(SystemTime.getCurrentTime()).toString() + "::";
String className;
String methodName;
int lineNumber;
String trace_trace_tail = null;
try {
throw new Exception();
} catch (Exception e) {
StackTraceElement[] st = e.getStackTrace();
StackTraceElement first_line = st[2];
className = first_line.getClassName() + "::";
methodName = first_line.getMethodName() + "::";
lineNumber = first_line.getLineNumber();
trace_trace_tail = getCompressedStackTrace(e, 3, 200, false);
}
diagLoggerLogAndOut(header + className + (methodName) + lineNumber + ":", true);
if (_debug_msg.length() > 0) {
diagLoggerLogAndOut(" " + _debug_msg, true);
}
if (trace_trace_tail != null) {
diagLoggerLogAndOut(" " + trace_trace_tail, true);
}
if (_exception != null) {
diagLoggerLogAndOut(_exception);
}
}
private void appendTestMethod(@Nonnull StackTraceElement current) {
content.append(" <li>");
content.append(current.getClassName()).append('#');
content
.append(LESS_THAN_CHAR.matcher(current.getMethodName()).replaceFirst("<"))
.append(": ");
content.append(current.getLineNumber());
}
private static boolean isClassAllowed(Set<String> names) {
StackTraceElement[] stackTraceElements = new Throwable().getStackTrace();
for (StackTraceElement stackTraceElement : stackTraceElements) {
if (isStackElementDebugClassFile(stackTraceElement)) continue;
return names.contains(stackTraceElement.getClassName());
}
return false;
}
public static void printElement(Site s, int index) {
if (s == null || index >= s.site().length) {
ps.print("(null)");
} else {
StackTraceElement e = s.site()[index];
ps.print(e.getMethodName() + " (" + e.getFileName() + ":" + e.getLineNumber() + ")");
}
}
private static boolean isStackElementDebugClassFile(StackTraceElement element) {
StackTraceElement[] stackTraceElements = new Throwable().getStackTrace();
if (stackTraceElements == null) return false;
String name = stackTraceElements[0].getFileName();
if (name == null) return false;
//noinspection SimplifiableIfStatement
if (element == null || element.getFileName() == null) return false;
return element.getFileName().equals(name);
}
/**
* Gets an approximate source code location for a node if possible.
*
* @return a file name and source line number in stack trace format (e.g. "String.java:32") if an
* approximate source location is found, null otherwise
*/
public static String approxSourceLocation(Node node) {
StackTraceElement[] stackTraceElements = approxSourceStackTraceElement(node);
if (stackTraceElements != null && stackTraceElements.length > 0) {
StackTraceElement top = stackTraceElements[0];
if (top.getFileName() != null && top.getLineNumber() >= 0) {
return top.getFileName() + ":" + top.getLineNumber();
}
}
return null;
}
private static void dumpStackTrace(StringBuilder sb, StackTraceElement[] stackTrace, int indent) {
for (int i = 0; i < stackTrace.length; i++) {
for (int j = 0; j < indent; j++) {
sb.append(INDENT_STRING);
}
StackTraceElement element = stackTrace[i];
sb.append(element.toString());
sb.append("\n");
}
}
void checkThreadInfo(ThreadInfo info) {
if (!getName().equals(info.getThreadName())) {
throw new RuntimeException(
"Name: " + info.getThreadName() + " not matched. Expected: " + getName());
}
MonitorInfo[] monitors = info.getLockedMonitors();
if (monitors.length != OWNED_MONITORS) {
throw new RuntimeException(
"Number of locked monitors = "
+ monitors.length
+ " not matched. Expected: "
+ OWNED_MONITORS);
}
MonitorInfo m = monitors[0];
StackTraceElement ste = m.getLockedStackFrame();
int depth = m.getLockedStackDepth();
StackTraceElement[] stacktrace = info.getStackTrace();
if (!ste.equals(stacktrace[depth])) {
System.out.println("LockedStackFrame:- " + ste);
System.out.println("StackTrace at " + depth + " :-" + stacktrace[depth]);
throw new RuntimeException(
"LockedStackFrame does not match " + "stack frame in ThreadInfo.getStackTrace");
}
String className = lock.getClass().getName();
int hcode = System.identityHashCode(lock);
if (!className.equals(m.getClassName())
|| hcode != m.getIdentityHashCode()
|| !m.getLockedStackFrame().getMethodName().equals("run")) {
System.out.println(info);
throw new RuntimeException("MonitorInfo " + m + " doesn't match.");
}
LockInfo[] syncs = info.getLockedSynchronizers();
if (syncs.length != OWNED_SYNCS) {
throw new RuntimeException(
"Number of locked syncs = " + syncs.length + " not matched. Expected: " + OWNED_SYNCS);
}
AbstractOwnableSynchronizer s = mutex.getSync();
String lockName = s.getClass().getName();
hcode = System.identityHashCode(s);
if (!lockName.equals(syncs[0].getClassName())) {
throw new RuntimeException(
"LockInfo : " + syncs[0] + " class name not matched. Expected: " + lockName);
}
if (hcode != syncs[0].getIdentityHashCode()) {
throw new RuntimeException(
"LockInfo: " + syncs[0] + " IdentityHashCode not matched. Expected: " + hcode);
}
LockInfo li = info.getLockInfo();
if (li == null) {
throw new RuntimeException("Expected non-null LockInfo");
}
}
private static String getStackTraceAsText(Throwable t) {
StringBuilder builder = new StringBuilder();
StackTraceElement[] stackTraceElements = t.getStackTrace();
for (int index = 0; index < stackTraceElements.length; index++) {
StackTraceElement stackTraceElement = stackTraceElements[index];
builder.append(" ").append(stackTraceElement.toString()).append('\n');
}
return builder.toString();
}
public static void printStackTrace(Throwable e, Object context) {
String header = "DEBUG::";
header = header + new Date(SystemTime.getCurrentTime()).toString() + "::";
String className = "?::";
String methodName = "?::";
int lineNumber = -1;
try {
throw new Exception();
} catch (Exception f) {
StackTraceElement[] st = f.getStackTrace();
for (int i = 1; i < st.length; i++) {
StackTraceElement first_line = st[i];
className = first_line.getClassName() + "::";
methodName = first_line.getMethodName() + "::";
lineNumber = first_line.getLineNumber();
// skip stuff generated by the logger
if (className.indexOf(".logging.") != -1 || className.endsWith(".Debug::")) {
continue;
}
break;
}
}
diagLoggerLogAndOut(header + className + (methodName) + lineNumber + ":", true);
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
PrintWriter pw = new PrintWriter(new OutputStreamWriter(baos));
if (context != null) {
pw.print(" ");
pw.println(context);
}
pw.print(" ");
e.printStackTrace(pw);
pw.close();
String stack = baos.toString();
diagLoggerLogAndOut(stack, true);
} catch (Throwable ignore) {
e.printStackTrace();
}
}
private static void printElementInfo(OutputStream stream, StackTraceElement element) {
print(stream, element.getClassName());
print(stream, ":");
print(stream, element.getMethodName());
print(stream, " ");
print(stream, "(");
print(stream, element.getFileName());
print(stream, ":");
print(stream, element.getLineNumber());
print(stream, ")");
printNewLine(stream);
}
protected static String printException(Throwable ex) throws IOException {
if (ex == null) return null;
StackTraceElement[] stack_trace = ex.getStackTrace();
StringBuilder sb = new StringBuilder();
sb.append("\n<" + CDATA + "\n");
sb.append(ex.getClass().getName() + " \n");
for (int i = 0; i < stack_trace.length; i++) {
StackTraceElement frame = stack_trace[i];
sb.append("at " + frame.toString() + " \n");
}
sb.append("\n]]>");
return sb.toString();
}
@Override
public int hashCode() {
if (hashCode == 0) {
int res = 1 + site.length * 17;
int max = Math.max(site.length, 10);
for (int i = offset; i < max; i++) {
StackTraceElement e = site[i];
int lineNumber = e.getLineNumber();
res = res * 19 + 31 * lineNumber;
}
hashCode = res;
}
return hashCode;
}
protected String getTitle(Throwable t) {
String message = t.getMessage();
String tit = message;
if (tit == null) {
StackTraceElement el = t.getStackTrace()[0];
tit =
t.getClass().getName().substring(t.getClass().getPackage().getName().length() + 1)
+ " "
+ el.getFileName()
+ ":"
+ el.getLineNumber();
}
return tit;
}
private static void printThrowable(OutputStream stream, Throwable throwable) {
printBytes(stream, ("Exception " + throwable.toString()).getBytes());
printNewLine(stream);
StackTraceElement[] stackTraceElements = throwable.getStackTrace();
for (int i = stackTraceElements.length - 1; i >= 0; i--) {
StackTraceElement element = stackTraceElements[i];
printBytes(stream, element.getFileName().getBytes());
printBytes(stream, ":".getBytes());
printBytes(stream, String.valueOf(element.getLineNumber()).getBytes());
printNewLine(stream);
}
if (throwable.getCause() != null) {
printBytes(stream, "Caused by:\n".getBytes());
printThrowable(stream, throwable.getCause());
}
}
public static void printElements(Site s, int index, int nelems) {
if (s == null || index >= s.site().length) {
ps.print("(null)");
} else {
for (int i = 0; i < nelems; i++) {
int j = index + i;
if (j >= s.site().length) {
break;
}
if (i > 0) {
ps.print(", ");
}
StackTraceElement e = s.site()[j];
ps.print(e.getMethodName() + " (" + e.getFileName() + ":" + e.getLineNumber() + ")");
}
}
}
private void sendFailedEmail(Exception ex, String to) {
String subject = "WaterSMART processing failed";
StringBuilder content = new StringBuilder();
content.append("Your request unfortunately failed, we are looking into it.");
content.append("\n\tUpload: ").append((uploadSuccessful) ? "success" : "failure");
content.append("\n\tParse: ").append((netcdfSuccessful) ? "success" : "failure");
content.append("\n\tStatistics: ").append((rStatsSuccessful) ? "success" : "failure");
content.append("\n\tMetadata: ").append((cswTransSuccessful) ? "success" : "failure");
RunMetadata metaObj = RunMetadata.getInstance(metadata);
content.append("\n\n\tFile: ").append(metaObj.getFileName());
content.append("\n\tModeler: ").append(metaObj.getName());
content.append("\n\tComments: ").append(metaObj.getComments());
content.append("\n\tDate: ").append(metaObj.getCreationDate());
content.append("\n\nthe application failed with message: ").append(ex.getMessage());
content.append("\n\nhere is the stack trace for troubleshooting:\n\n");
for (StackTraceElement el : ex.getStackTrace()) {
content.append(el.toString()).append("\n");
}
List<String> bcc = new ArrayList<String>();
String from = props.getProperty("watersmart.email.from");
String bccAddr = props.getProperty("watersmart.email.tracker");
if (!"".equals(bccAddr)) {
bcc.add(bccAddr);
}
EmailMessage message = new EmailMessage(from, to, null, bcc, subject, content.toString());
try {
EmailHandler.sendMessage(message);
} catch (AddressException ex1) {
log.error(
"Unable to send failed e-mail:\n"
+ message
+ "\n\nOriginal Exception:\n"
+ ex.getMessage(),
ex1);
} catch (MessagingException ex1) {
log.error(
"Unable to send failed e-mail:\n"
+ message
+ "\n\nOriginal Exception:\n"
+ ex.getMessage(),
ex1);
}
}
public static void printSite(Site s, StringBuilder out) {
if (s == null) {
out.append("(null)");
return;
}
StackTraceElement[] st = s.site();
int interestingSitesPrinted = 0;
for (int i = s.offset; i < st.length; i++) {
StackTraceElement e = st[i];
String fileName = e.getFileName();
if (THIS_FILE_NAME.equals(fileName)) {
continue;
}
out.append(" " + e.getMethodName() + "(" + e.getFileName() + ":" + e.getLineNumber() + ")");
interestingSitesPrinted++;
if (interestingSitesPrinted <= SITES_TO_PRINT) {
continue;
}
if (fileName == null || "View.java".equals(fileName)) {
continue;
}
String methodName = e.getMethodName();
if (skipMethods.contains(methodName)) {
continue;
}
break;
}
}
protected static boolean wasCalledDuringClassLoading() {
if (LOCK.isHeldByCurrentThread()) return true;
LOCK.lock();
try {
StackTrace st = new StackTrace(new Throwable());
int n = st.getDepth();
for (int i = 3; i < n; i++) {
StackTraceElement ste = st.getElement(i);
if ("ClassLoader.java".equals(ste.getFileName())
&& "loadClass".equals(ste.getMethodName())) {
return true;
}
}
return false;
} finally {
LOCK.unlock();
}
}
private static boolean isIdleThread(ThreadInfo threadInfo) {
String threadName = threadInfo.getThreadName();
// NOTE: these are likely JVM dependent
if (threadName.equals("Signal Dispatcher")
|| threadName.equals("Finalizer")
|| threadName.equals("Reference Handler")) {
return true;
}
for (StackTraceElement frame : threadInfo.getStackTrace()) {
String className = frame.getClassName();
String methodName = frame.getMethodName();
if (className.equals("java.util.concurrent.ThreadPoolExecutor")
&& methodName.equals("getTask")) {
return true;
}
if (className.equals("sun.nio.ch.SelectorImpl") && methodName.equals("select")) {
return true;
}
if (className.equals("org.elasticsearch.threadpool.ThreadPool$EstimatedTimeThread")
&& methodName.equals("run")) {
return true;
}
if (className.equals("org.elasticsearch.indices.ttl.IndicesTTLService$Notifier")
&& methodName.equals("await")) {
return true;
}
if (className.equals("java.util.concurrent.LinkedTransferQueue")
&& methodName.equals("poll")) {
return true;
}
}
return false;
}
@Override
public boolean handleCommand(final CommandSender sender, final Command command, final String commandLabel, final String[] args)
{
boolean disabled = false;
boolean overridden = false;
ISettings settings = ess.getSettings();
settings.acquireReadLock();
try
{
disabled = settings.getData().getCommands().isDisabled(command.getName());
overridden = !disabled || settings.getData().getCommands().isOverridden(command.getName());
}
finally
{
settings.unlock();
}
// Allow plugins to override the command via onCommand
if (!overridden && (!commandLabel.startsWith("e") || commandLabel.equalsIgnoreCase(command.getName())))
{
final PluginCommand pc = getAlternative(commandLabel);
if (pc != null)
{
executed(commandLabel, pc.getLabel());
try
{
return pc.execute(sender, commandLabel, args);
}
catch (final Exception ex)
{
final ArrayList<StackTraceElement> elements = new ArrayList<StackTraceElement>(Arrays.asList(ex.getStackTrace()));
elements.remove(0);
final ArrayList<StackTraceElement> toRemove = new ArrayList<StackTraceElement>();
for (final StackTraceElement e : elements)
{
if (e.getClassName().equals("net.ess3.Essentials"))
{
toRemove.add(e);
}
}
elements.removeAll(toRemove);
final StackTraceElement[] trace = elements.toArray(new StackTraceElement[elements.size()]);
ex.setStackTrace(trace);
ex.printStackTrace();
sender.sendMessage(ChatColor.RED + "An internal error occurred while attempting to perform this command");
return true;
}
}
}
try
{
IUser user = null;
if (sender instanceof Player)
{
user = ess.getUserMap().getUser((Player)sender);
LOGGER.log(Level.INFO, String.format("[PLAYER_COMMAND] %s: /%s %s ", ((Player)sender).getName(), commandLabel, EssentialsCommand.getFinalArg(args, 0)));
}
// Check for disabled commands
if (disabled)
{
return true;
}
final String commandName = command.getName().toLowerCase(Locale.ENGLISH);
IEssentialsCommand cmd = commands.get(commandName);
if (cmd == null)
{
try
{
cmd = (IEssentialsCommand)classLoader.loadClass(commandPath + commandName).newInstance();
cmd.init(ess, commandName);
cmd.setEssentialsModule(module);
commands.put(commandName, cmd);
}
catch (Exception ex)
{
sender.sendMessage(_("commandNotLoaded", commandName));
LOGGER.log(Level.SEVERE, _("commandNotLoaded", commandName), ex);
return true;
}
}
// Check authorization
if (sender != null && !cmd.isAuthorized(sender))
{
LOGGER.log(Level.WARNING, _("deniedAccessCommand", user.getName()));
user.sendMessage(_("noAccessCommand"));
return true;
}
// Run the command
try
{
if (user == null)
{
cmd.run(sender, command, commandLabel, args);
}
else
{
user.acquireReadLock();
try
{
cmd.run(user, command, commandLabel, args);
}
finally
{
user.unlock();
}
}
return true;
}
catch (NoChargeException ex)
{
return true;
}
catch (NotEnoughArgumentsException ex)
{
sender.sendMessage(command.getDescription());
sender.sendMessage(command.getUsage().replaceAll("<command>", commandLabel));
if (!ex.getMessage().isEmpty())
{
sender.sendMessage(ex.getMessage());
}
return true;
}
catch (Throwable ex)
{
showCommandError(sender, commandLabel, ex);
return true;
}
}
catch (Throwable ex)
{
LOGGER.log(Level.SEVERE, _("commandFailed", commandLabel), ex);
return true;
}
}
public Writer getErrorReport(
Writer to, final HttpServletRequest request, CharTransformer escape) throws IOException {
final Writer logMsg = new StringWriter();
final Writer tee = new org.mmbase.util.ChainedWriter(to, logMsg);
Writer msg = tee;
LinkedList<Throwable> stack = getStack();
String ticket = new Date().toString();
Map<String, String> props;
try {
props = org.mmbase.util.ApplicationContextReader.getProperties("mmbase_errorpage");
} catch (javax.naming.NamingException ne) {
props = Collections.emptyMap();
log.info(ne);
}
if (request != null) {
{
msg.append("Headers\n----------\n");
// request properties
for (Object name : Collections.list(request.getHeaderNames())) {
msg.append(
escape.transform(
name + ": " + escape.transform(request.getHeader((String) name)) + "\n"));
}
}
{
msg.append("\nAttributes\n----------\n");
Pattern p = requestIgnore;
if (p == null && props.get("request_ignore") != null) {
p = Pattern.compile(props.get("request_ignore"));
}
for (Object name : Collections.list(request.getAttributeNames())) {
if (p == null || !p.matcher((String) name).matches()) {
msg.append(
escape.transform(name + ": " + request.getAttribute((String) name) + "\n"));
}
}
}
if (Boolean.TRUE.equals(showSession)
|| (showSession == null && !"false".equals(props.get("show_session")))) {
HttpSession ses = request.getSession(false);
if (ses != null) {
msg.append("\nSession\n----------\n");
Pattern p = sessionIgnore;
if (p == null && props.get("session_ignore") != null) {
p = Pattern.compile(props.get("session_ignore"));
}
for (Object name : Collections.list(ses.getAttributeNames())) {
if (p == null || !p.matcher((String) name).matches()) {
msg.append(escape.transform(name + ": " + ses.getAttribute((String) name) + "\n"));
}
}
}
}
}
msg.append("\n");
msg.append("Misc. properties\n----------\n");
if (request != null) {
msg.append("method: ").append(escape.transform(request.getMethod())).append("\n");
msg.append("querystring: ").append(escape.transform(request.getQueryString())).append("\n");
msg.append("requesturl: ")
.append(escape.transform(request.getRequestURL().toString()))
.append("\n");
}
if (Boolean.TRUE.equals(showMMBaseVersion)
|| (showMMBaseVersion == null && !"false".equals(props.get("show_mmbase_version")))) {
msg.append("mmbase version: ").append(org.mmbase.Version.get()).append("\n");
}
msg.append("status: ").append("").append(String.valueOf(status)).append("\n\n");
if (request != null) {
msg.append("Parameters\n----------\n");
// request parameters
Enumeration en = request.getParameterNames();
while (en.hasMoreElements()) {
String name = (String) en.nextElement();
msg.append(name)
.append(": ")
.append(escape.transform(request.getParameter(name)))
.append("\n");
}
}
msg.append("\nException ")
.append(ticket)
.append("\n----------\n\n")
.append(
exception != null
? (escape.transform(exception.getClass().getName()))
: "NO EXCEPTION")
.append(": ");
int wroteCauses = 0;
while (!stack.isEmpty()) {
Throwable t = stack.removeFirst();
// add stack stacktraces
if (t != null) {
if (stack.isEmpty()) { // write last message always
msg = tee;
}
String message = t.getMessage();
if (msg != tee) {
to.append("\n=== skipped(see log) : ")
.append(escape.transform(t.getClass().getName()))
.append(": ")
.append(message)
.append("\n");
}
msg.append("\n\n").append(escape.transform(t.getClass().getName() + ": " + message));
StackTraceElement[] stackTrace = t.getStackTrace();
for (StackTraceElement e : stackTrace) {
msg.append("\n at ").append(escape.transform(e.toString()));
}
if (!stack.isEmpty()) {
msg.append("\n-------caused:\n");
}
wroteCauses++;
if (wroteCauses >= MAX_CAUSES) {
msg = logMsg;
}
}
}
// write errors to log
if (status == 500) {
try {
if (props.get("to") != null && props.get("to").length() > 0) {
javax.naming.Context initCtx = new javax.naming.InitialContext();
javax.naming.Context envCtx = (javax.naming.Context) initCtx.lookup("java:comp/env");
Object mailSession = envCtx.lookup("mail/Session");
Class sessionClass = Class.forName("javax.mail.Session");
Class recipientTypeClass = Class.forName("javax.mail.Message$RecipientType");
Class messageClass = Class.forName("javax.mail.internet.MimeMessage");
Object mail = messageClass.getConstructor(sessionClass).newInstance(mailSession);
messageClass
.getMethod("addRecipients", recipientTypeClass, String.class)
.invoke(mail, recipientTypeClass.getDeclaredField("TO").get(null), props.get("to"));
messageClass.getMethod("setSubject", String.class).invoke(mail, ticket);
mail.getClass().getMethod("setText", String.class).invoke(mail, logMsg.toString());
Class.forName("javax.mail.Transport")
.getMethod("send", Class.forName("javax.mail.Message"))
.invoke(null, mail);
tee.append("\nmailed to (").append(String.valueOf(props)).append(")");
}
} catch (Exception nnfe) {
tee.append("\nnot mailed (").append(String.valueOf(nnfe)).append(")");
if (log.isDebugEnabled()) {
log.debug(nnfe.getMessage(), nnfe);
}
}
log.error("TICKET " + ticket + ":\n" + logMsg);
}
return to;
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {
try {
response.setHeader("Cache-Control", "no-cache");
response.setCharacterEncoding("UTF-8");
String task = request.getParameter("task");
Element data = null;
// process help request
if (request.getParameter("help") != null) data = getDescription(task);
// redirect to home page if there is no task
if (data == null && task == null) {
response.setContentType("text/html");
response
.getWriter()
.append(
"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\"><html><head><meta http-equiv=\"REFRESH\" content=\"0;url="
+ context.getInitParameter("server_path")
+ "></head><body></body></html>");
return;
}
// process definition request
if (data == null && task.equals("define")) {
int id = resolveIntegerArg(request.getParameter("id"), -1);
int length = resolveIntegerArg(request.getParameter("length"), definer.getDefaultLength());
int format = resolveIntegerArg(request.getParameter("format"), definer.getDefaultFormat());
int maxImageWidth =
resolveIntegerArg(
request.getParameter("maxImageWidth"), definer.getDefaultMaxImageWidth());
int maxImageHeight =
resolveIntegerArg(
request.getParameter("maxImageHeight"), definer.getDefaultMaxImageHeight());
int linkDestination =
resolveIntegerArg(
request.getParameter("linkDestination"), definer.getDefaultLinkDestination());
boolean getImages = resolveBooleanArg(request.getParameter("getImages"), false);
data =
definer.getDefinition(
id, length, format, linkDestination, getImages, maxImageWidth, maxImageHeight);
}
// all of the remaining tasks require data to be cached, so lets make sure that is finished
// before continuing.
if (!cachingThread.isOk()) throw new ServletException("Could not cache wikipedia data");
double progress = cachingThread.getProgress();
if (data == null && (progress < 1 || task.equals("progress"))) {
// still caching up data, not ready to return a response yet.
data = doc.createElement("loading");
data.setAttribute("progress", df.format(progress));
task = "loading";
}
// process search request
if (data == null && task.equals("search")) {
String term = request.getParameter("term");
String id = request.getParameter("id");
int linkLimit =
resolveIntegerArg(request.getParameter("linkLimit"), searcher.getDefaultMaxLinkCount());
int senseLimit =
resolveIntegerArg(
request.getParameter("senseLimit"), searcher.getDefaultMaxSenseCount());
if (id == null) data = searcher.doSearch(term, linkLimit, senseLimit);
else data = searcher.doSearch(Integer.parseInt(id), linkLimit);
}
// process compare request
if (data == null && task.equals("compare")) {
String term1 = request.getParameter("term1");
String term2 = request.getParameter("term2");
int linkLimit =
resolveIntegerArg(request.getParameter("linkLimit"), comparer.getDefaultMaxLinkCount());
boolean details =
resolveBooleanArg(request.getParameter("details"), comparer.getDefaultShowDetails());
data = comparer.getRelatedness(term1, term2, details, linkLimit);
}
// process wikify request
if (data == null && task.equals("wikify")) {
if (this.wikifier == null)
throw new ServletException(
"Wikifier is not available. You must configure the servlet so that it has access to link detection and disambiguation models.");
String source = request.getParameter("source");
int sourceMode =
resolveIntegerArg(request.getParameter("sourceMode"), Wikifier.SOURCE_AUTODETECT);
String linkColor = request.getParameter("linkColor");
String baseColor = request.getParameter("baseColor");
double minProb =
resolveDoubleArg(
request.getParameter("minProbability"), wikifier.getDefaultMinProbability());
int repeatMode =
resolveIntegerArg(request.getParameter("repeatMode"), wikifier.getDefaultRepeatMode());
boolean showTooltips =
resolveBooleanArg(
request.getParameter("showTooltips"), wikifier.getDefaultShowTooltips());
String bannedTopics = request.getParameter("bannedTopics");
boolean wrapInXml = resolveBooleanArg(request.getParameter("wrapInXml"), true);
if (wrapInXml) {
data =
wikifier.wikifyAndWrapInXML(
source,
sourceMode,
minProb,
repeatMode,
bannedTopics,
baseColor,
linkColor,
showTooltips);
} else {
response.setContentType("text/html");
response
.getWriter()
.append(
wikifier.wikify(
source,
sourceMode,
minProb,
repeatMode,
bannedTopics,
baseColor,
linkColor,
showTooltips));
return;
}
}
if (data == null) throw new Exception("Unknown Task");
// wrap data
Element wrapper = doc.createElement("WikipediaMinerResponse");
wrapper.setAttribute("server_path", context.getInitParameter("server_path"));
wrapper.setAttribute("service_name", context.getInitParameter("service_name"));
wrapper.appendChild(data);
data = wrapper;
// Transform or serialize xml data as appropriate
Transformer tf = null;
if (request.getParameter("xml") == null) {
// we need to transform the data into html
tf = transformersByName.get(task);
if (request.getParameter("help") != null) tf = transformersByName.get("help");
}
if (tf == null) {
// we need to serialize the data as xml
tf = transformersByName.get("serializer");
response.setContentType("application/xml");
} else {
// output will be transformed to html
response.setContentType("text/html");
response
.getWriter()
.append(
"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \"http://www.w3.org/TR/html4/strict.dtd\">\n");
}
tf.transform(new DOMSource(data), new StreamResult(response.getWriter()));
} catch (Exception error) {
response.reset();
response.setContentType("application/xml");
response.setHeader("Cache-Control", "no-cache");
response.setCharacterEncoding("UTF8");
Element xmlError = doc.createElement("Error");
if (error.getMessage() != null) xmlError.setAttribute("message", error.getMessage());
Element xmlStackTrace = doc.createElement("StackTrace");
xmlError.appendChild(xmlStackTrace);
for (StackTraceElement ste : error.getStackTrace()) {
Element xmlSte = doc.createElement("StackTraceElement");
xmlSte.setAttribute("message", ste.toString());
xmlStackTrace.appendChild(xmlSte);
}
try {
transformersByName
.get("serializer")
.transform(new DOMSource(xmlError), new StreamResult(response.getWriter()));
} catch (Exception e) {
// TODO: something for when an error is thrown processing an error????
}
;
}
}
/** Dumps stacktrace to log */
public static void dumpStackTrace() {
for (StackTraceElement el : Thread.currentThread().getStackTrace()) {
SimpleClans.debug(el.toString());
}
}
private static final String threadRootClass() {
StackTraceElement[] trace = Thread.currentThread().getStackTrace();
StackTraceElement elem = trace[trace.length - 1];
String clazz = elem.getClassName();
return clazz;
}
