public JilterStatus eom(JilterEOMActions eomActions, Properties properties) {
logger.debug("jilter eom()");
try {
bos.close(); // close stream
} catch (IOException io) {
logger.error("jilter failed to close io stream during eom", io);
}
byte[] messageBytes = bos.toByteArray();
bos = new ByteArrayOutputStream();
ByteArrayInputStream bis = new ByteArrayInputStream(messageBytes);
try {
logger.debug("jilter store callback execute");
Config.getStopBlockFactory()
.detectBlock("milter server", Thread.currentThread(), this, IDLE_TIMEOUT);
callback.store(bis, host);
logger.debug("jilter store callback finished");
} catch (ArchiveException e) {
logger.error("failed to store the message via milter", e);
if (e.getRecoveryDirective() == ArchiveException.RecoveryDirective.REJECT) {
logger.debug("jilter reject");
return JilterStatus.SMFIS_REJECT;
} else if (e.getRecoveryDirective() == ArchiveException.RecoveryDirective.RETRYLATER) {
logger.debug("jilter temp fail");
return JilterStatus.SMFIS_TEMPFAIL;
}
} catch (Throwable oome) {
logger.error("failed to store message:" + oome.getMessage(), oome);
return JilterStatus.SMFIS_REJECT;
} finally {
Config.getStopBlockFactory().endDetectBlock(Thread.currentThread());
}
return JilterStatus.SMFIS_CONTINUE;
}
public boolean hasNext() {
try {
return iterator.hasNext();
} catch (Throwable t) {
if ("ServiceConfigurationError".equals(t.getClass().getSimpleName())) {
log.error("proc.bad.config.file", t.getLocalizedMessage());
}
throw new Abort(t);
}
}
public Processor next() {
try {
return (Processor) (iterator.next());
} catch (Throwable t) {
if ("ServiceConfigurationError".equals(t.getClass().getSimpleName())) {
log.error("proc.bad.config.file", t.getLocalizedMessage());
} else {
log.error("proc.processor.constructor.error", t.getLocalizedMessage());
}
throw new Abort(t);
}
}
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;
}
public void run() {
Connection con = null;
Statement stmt = null;
try {
DataSource ds = getDataSource();
con = ds.getConnection();
if (executeOnlyIf(con, onlyIfQuery)) {
stmt = con.createStatement();
if (query != null) {
executeQuery(stmt, query);
} else if (update != null) {
executeUpdate(stmt, update);
} else {
throw new IllegalStateException("Both query and update properties are unset");
}
} else {
LOG.debug("Skipped because of " + onlyIfQuery);
}
} catch (RuntimeException e) {
throw e;
} catch (Throwable t) {
if (ignore.matcher(t.getMessage()).matches()) {
LOG.info("Ignoring " + t.getMessage());
} else {
throw new RuntimeException(t.getMessage(), t);
}
} finally {
try {
if (stmt != null) {
stmt.close();
}
} catch (Exception g) {
}
try {
if (con != null) {
con.close();
}
} catch (Exception g) {
}
}
}
@Override
public MathsEpsReturn getEps(MathsEpsParams params) {
long start = System.currentTimeMillis();
MathsEpsReturn result = new MathsEpsReturn();
result.setOk(false);
result.setEps(EMPTY);
result.setError("");
try {
// Parse XML
Document mathml = parseMathml(params, result, start);
if (mathml == null) {
return result;
}
return getEps(params, mathml, result, start);
} catch (Throwable t) {
result.setError("MathML unexpected error - " + t.getMessage());
t.printStackTrace();
return result;
}
}
protected LinkedList<Throwable> getStack() {
Throwable e = exception;
LinkedList<Throwable> stack = new LinkedList<Throwable>();
while (e != null) {
stack.addFirst(e);
if (e instanceof NotFoundException) {
status = HttpServletResponse.SC_NOT_FOUND;
}
if (e instanceof ServletException) {
Throwable t = ((ServletException) e).getRootCause();
if (t == null) t = e.getCause();
e = t;
} else if (e instanceof javax.servlet.jsp.JspException) {
Throwable t = ((JspException) e).getRootCause();
if (t == null) t = e.getCause();
e = t;
} else {
e = e.getCause();
}
}
return stack;
}
public void addError(Test test, Throwable t) {
StringBuffer sb = new StringBuffer();
sb.append(test.toString());
sb.append("\n");
StringWriter sw = new StringWriter();
t.printStackTrace(new PrintWriter(sw, true));
sb.append(sw.toString());
Log.getLogWriter().severe("zzzzzERROR IN " + test, t);
// reportFailure(test, sb.toString());
lastFailClass = getClassName(test);
lastFailMethod = getMethodName(test);
lastThrowable = t;
}
/**
* Given another class, return a transformed version of the class which replaces specified calls
* with alternative static implementations
*/
public byte[] transform(
ClassLoader loader,
String className,
Class<?> classBeingRedefined,
ProtectionDomain protectionDomain,
byte[] classfileBuffer)
throws IllegalClassFormatException {
// debug = className.equals ("chicory/Test");
String fullClassName = className.replace("/", ".");
debug_transform.log("In Transform: class = %s%n", className);
// Don't instrument boot classes. We only want to instrument
// user classes classpath.
// Most boot classes have the null loader,
// but some generated classes (such as those in sun.reflect) will
// have a non-null loader. Some of these have a null parent loader,
// but some do not. The check for the sun.reflect package is a hack
// to catch all of these. A more consistent mechanism to determine
// boot classes would be preferrable.
if (loader == null) {
debug_transform.log("ignoring system class %s, class loader == null", fullClassName);
return (null);
} else if (loader.getParent() == null) {
debug_transform.log("ignoring system class %s, parent loader == null\n", fullClassName);
return (null);
} else if (fullClassName.startsWith("sun.reflect")) {
debug_transform.log("ignoring system class %s, in sun.reflect package", fullClassName);
return (null);
} else if (fullClassName.startsWith("com.sun")) {
System.out.printf("Class from com.sun package %s with nonnull loaders\n", fullClassName);
}
// Don't intrument our code
if (className.startsWith("randoop.")) {
debug_transform.log("Not considering randoop class %s%n", fullClassName);
return (null);
}
// Look for match with specified regular expressions for class
method_map = null;
debug_class = false;
for (MethodMapInfo mmi : map_list) {
if (mmi.class_regex.matcher(className).matches()) {
if (false && className.startsWith("RandoopTest")) debug_class = true;
if (debug_class)
System.out.printf("Classname %s matches re %s%n", className, mmi.class_regex);
method_map = mmi.map;
break;
}
}
if (method_map == null) return null;
debug_transform.log(
"transforming class %s, loader %s - %s%n", className, loader, loader.getParent());
// Parse the bytes of the classfile, die on any errors
JavaClass c = null;
ClassParser parser = new ClassParser(new ByteArrayInputStream(classfileBuffer), className);
try {
c = parser.parse();
} catch (Exception e) {
throw new RuntimeException("Unexpected error", e);
}
try {
// Get the class information
ClassGen cg = new ClassGen(c);
ifact = new InstructionFactory(cg);
map_calls(cg, className, loader);
JavaClass njc = cg.getJavaClass();
if (debug) njc.dump("/tmp/ret/" + njc.getClassName() + ".class");
if (true) {
return (cg.getJavaClass().getBytes());
} else {
debug_transform.log("not including class %s (filtered out)", className);
return null;
}
} catch (Throwable e) {
out.format("Unexpected error %s in transform", e);
e.printStackTrace();
return (null);
}
}
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;
}
static void unexpected(Throwable t) {
failed++;
t.printStackTrace();
}