-
log4j.rootLogger= DEBUG, A1
log4j.logger.servlet= INFO, ServletA
+log4j.logger.media= DEBUG, MediaA
+log4j.logger.producer= INFO, ProducerA
log4j.appender.A1=org.apache.log4j.ConsoleAppender
-
-log4j.appender.ServletA=org.apache.log4j.RollingFileAppender
-log4j.appender.ServletA.File=${log.home}/servlet.log
-
-# A1 uses PatternLayout.
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n
+log4j.appender.ServletA=org.apache.log4j.RollingFileAppender
+log4j.appender.ServletA.File=${log.home}/servlet.log
log4j.appender.ServletA.layout=org.apache.log4j.PatternLayout
log4j.appender.ServletA.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n
+
+
+log4j.appender.MediaA=org.apache.log4j.RollingFileAppender
+log4j.appender.MediaA.File=${log.home}/media.log
+log4j.appender.MediaA.layout=org.apache.log4j.PatternLayout
+log4j.appender.MediaA.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n
+
+log4j.appender.ProducerA=org.apache.log4j.RollingFileAppender
+log4j.appender.ProducerA.File=${log.home}/producer.log
+log4j.appender.ProducerA.layout=org.apache.log4j.PatternLayout
+log4j.appender.ProducerA.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n
--- /dev/null
+package mir.log;
+
+import java.io.*;
+import java.util.*;
+
+public class LoggerToWriterAdapter extends Writer {
+ private LoggerWrapper logger;
+ private int messageType;
+ private StringBuffer lineBuffer;
+ private String lineSeparator;
+
+ public LoggerToWriterAdapter(LoggerWrapper aLogger, int aMessageType) {
+ lineBuffer = new StringBuffer();
+ logger = aLogger;
+ messageType = aMessageType;
+ lineSeparator = System.getProperty("line.separator");
+ }
+
+ public LoggerToWriterAdapter(Logger aLogger, int aMessageType) {
+ this(new LoggerWrapper(aLogger), aMessageType);
+ }
+
+ public void close() {
+ flush();
+ }
+
+ public void flush() {
+ if (lineBuffer.length()>0) {
+ logger.message(messageType, lineBuffer.toString());
+ lineBuffer.delete(0, lineBuffer.length());
+ }
+ }
+
+ protected void checkBuffer() {
+ int from = 0;
+ int until = lineBuffer.toString().indexOf(lineSeparator, from);
+
+ while (until>-1) {
+ String line = lineBuffer.substring(from, until);
+ logger.message(messageType, line);
+ from = until + lineSeparator.length();
+ until = lineBuffer.toString().indexOf(lineSeparator, from);
+ }
+
+ lineBuffer.delete(0, from);
+ };
+
+ public void write(char[] aBuffer, int anOffset, int aLength) {
+ lineBuffer.append(aBuffer, anOffset, aLength);
+ checkBuffer();
+ }
+}
\ No newline at end of file
+++ /dev/null
-package mir.log;
-
-import java.io.*;
-import java.util.*;
-
-public class WriterToLoggerAdapter extends Writer {
- private LoggerWrapper logger;
- private int messageType;
- private StringBuffer lineBuffer;
- private String lineSeparator;
-
- public WriterToLoggerAdapter(LoggerWrapper aLogger, int aMessageType) {
- lineBuffer = new StringBuffer();
- logger = aLogger;
- messageType = aMessageType;
- lineSeparator = System.getProperty("line.separator");
- }
-
- public WriterToLoggerAdapter(Logger aLogger, int aMessageType) {
- this(new LoggerWrapper(aLogger), aMessageType);
- }
-
- public void close() {
- flush();
- }
-
- public void flush() {
- if (lineBuffer.length()>0) {
- logger.message(messageType, lineBuffer.toString());
- lineBuffer.delete(0, lineBuffer.length());
- }
- }
-
- protected void checkBuffer() {
- int from = 0;
- int until = lineBuffer.toString().indexOf(lineSeparator, from);
-
- while (until>-1) {
- String line = lineBuffer.substring(from, until);
- logger.message(messageType, line);
- from = until + lineSeparator.length();
- until = lineBuffer.toString().indexOf(lineSeparator, from);
- }
-
- lineBuffer.delete(0, from);
- };
-
- public void write(char[] aBuffer, int anOffset, int aLength) {
- lineBuffer.append(aBuffer, anOffset, aLength);
- checkBuffer();
- }
-}
\ No newline at end of file
/**
* Statische Hilfsmethoden zur Stringbehandlung
*
- * @version $Id: StringUtil.java,v 1.26 2002/11/04 04:35:21 mh Exp $
+ * @version $Id: StringUtil.java,v 1.27 2002/11/25 19:06:45 zapata Exp $
* @author mir-coders group
*
*/
return s;
}
-
/**
* verwandelt einen String in eine gültige Url, konvertiert Sonderzeichen
* und Spaces werden zu Underscores
*
* @return gültige Url
*/
+/*
+ ML: I don't exactly understand the point of this routine, and I think it isn't
+ being used anymore. (And it sometimes causes locale problems). So I commented
+ it.
+
public static String convert2url(String s) {
s = toLowerCase(s);
StringBuffer buf = new StringBuffer();
}
return buf.toString();
}
-
+*/
public static String decodeHTMLinTags(String s){
StringBuffer buffer = new StringBuffer();
+package mir.misc;
+
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.index.IndexWriter;
class createIndex{
public static void main(String[] args){
- try{
-
- IndexWriter indexWriter = new IndexWriter(args[0], new StandardAnalyzer(), true);
+ try{
+
+ IndexWriter indexWriter = new IndexWriter(args[0], new StandardAnalyzer(), true);
- indexWriter.close();
- //and make it owned by correct user?(not in java!)
- }
- catch (Exception e){
- System.out.println(e.toString());
- }
+ indexWriter.close();
+ //and make it owned by correct user?(not in java!)
+ }
+ catch (Exception e){
+ System.out.println(e.toString());
+ }
}
}
import java.util.*;
import java.io.*;
+
import org.apache.struts.util.MessageResources;
+
import mir.util.*;
+import mir.log.*;
public class AssignmentProducerNode extends ProducerNodeDecorator {
private String key;
value = aValue;
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
try {
ParameterExpander.setValueForKey(aValueMap, key, value);
import java.util.*;
import java.io.*;
+import mir.log.*;
+
public class CompositeProducerNode implements ProducerNode {
private List subNodes;
((NodedProducer) producerValue).getIsAborted());
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure, ProducerExc {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure, ProducerExc {
Iterator i = subNodes.iterator();
while (i.hasNext() && !isAborted(aValueMap)) {
import java.util.*;
import java.io.*;
+
import mir.util.*;
+import mir.log.*;
public class ConditionalProducerNode implements ProducerNode {
private String condition;
falseNode = aFalseNode;
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
try {
if (ParameterExpander.evaluateBooleanExpression(aValueMap, condition)) {
if (trueNode!=null)
import java.io.*;
import java.util.*;
+
import mir.util.*;
+import mir.log.*;
public class DirCopyingProducerNode implements ProducerNode {
private String sourceExpression;
destinationExpression = aDestination;
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
String source = "";
String destination = "";
File sourceFile;
try {
source = ParameterExpander.expandExpression( aValueMap, sourceExpression );
destination = ParameterExpander.expandExpression( aValueMap, destinationExpression );
- aLogger.println("Copying " + source + " into " + destination);
FileCopier.copy(
new File(sourceBasePath, source),
new File(destinationBasePath, destination));
+ aLogger.info(source + " copied into " + destination);
}
catch (Throwable e) {
- throw new ProducerFailure("Copying " + source + " into " + destination + " failed: " + e.getMessage(), e);
+ aLogger.error("Copying " + source + " into " + destination + " failed: " + e.getMessage());
}
}
}
import java.util.*;
import java.io.*;
+
import mir.entity.adapter.*;
import mir.entity.*;
import mir.storage.*;
import mir.util.*;
+import mir.log.*;
public class EntityBatchingProducerNode implements ProducerNode {
private String batchInfoKey;
((NodedProducer) producerValue).getIsAborted());
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
Iterator browser;
int nrEntities;
int nrBatchesAfterFirst;
}
}
catch (Throwable t) {
- throw new ProducerFailure(t.getMessage(), t);
+ aLogger.error("EntityBatchingProducerNode caused an exception: " + t.getMessage());
}
};
import java.util.*;
import java.io.*;
+
import mir.entity.adapter.*;
import mir.entity.*;
import mir.storage.*;
import mir.util.*;
+import mir.log.*;
public class EntityEnumeratingProducerNode extends ProducerNodeDecorator {
private String key;
skip = aSkip;
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
Iterator browser;
try {
}
}
catch (Throwable t) {
- aLogger.println("Exception occurred inside an EntityEnumeratingProducerNode: " + t.getMessage());
+ aLogger.error("Exception occurred inside an EntityEnumeratingProducerNode: " + t.getMessage());
}
};
}
\ No newline at end of file
import java.util.*;
import java.io.*;
+
import mir.entity.adapter.*;
import mir.entity.*;
import mir.storage.*;
import mir.util.*;
+import mir.log.*;
public class EntityListProducerNode extends ProducerNodeDecorator {
private String key;
Integer.toString(aLimit), Integer.toString(aSkip), aSubNode);
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure, ProducerExc {
try {
int limit = ParameterExpander.evaluateIntegerExpressionWithDefault(aValueMap, limitExpression, -1);
int skip = ParameterExpander.evaluateIntegerExpressionWithDefault(aValueMap, skipExpression, 0);
skip )
)
);
- super.produce(aValueMap, aVerb, aLogger);
}
catch (Throwable t) {
- throw new ProducerFailure(t.getMessage(), t);
+ aLogger.error("cannot retrieve list into key " + key + ": " + t.getMessage());
+ try {
+ ParameterExpander.setValueForKey(
+ aValueMap,
+ key,
+ new CachingRewindableIterator(new Vector().iterator())
+ );
+ }
+ catch (Throwable s) {
+ }
}
+
+ super.produce(aValueMap, aVerb, aLogger);
};
}
\ No newline at end of file
import java.util.*;
import java.io.*;
+
import mir.util.*;
+import mir.log.*;
public class EvaluatedAssignmentProducerNode implements ProducerNode {
private String key;
value = aValue;
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
try {
ParameterExpander.setValueForKey(
aValueMap,
}
catch (Throwable t) {
- throw new ProducerFailure(t.getMessage(), t);
+ aLogger.error("key " + key + " could not be set to " + value + ": " + t.getMessage());
}
};
}
\ No newline at end of file
import java.util.*;
import java.io.*;
+
import mir.util.*;
+import mir.log.*;
public class ExpandedAssignmentProducerNode implements ProducerNode {
private String key;
value = aValue;
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
try {
ParameterExpander.setValueForKey(
aValueMap,
}
catch (Throwable t) {
- throw new ProducerFailure(t.getMessage(), t);
+ aLogger.error("key " + key + " could not be set to " + value + ": " + t.getMessage());
}
};
}
\ No newline at end of file
import java.util.*;
import java.io.*;
+
+import mir.log.*;
import mir.util.*;
import mir.producer.*;
import mir.generator.*;
dateExpression = aDateExpression;
}
- protected void perform(File aFile, Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ protected void perform(File aFile, Map aValueMap, String aVerb, LoggerWrapper aLogger) {
try {
Object date = ParameterExpander.findValueForKey( aValueMap, dateExpression );
if (!(date instanceof Date))
- throw new ProducerFailure("FileDateSettingProducerNode: expression " + dateExpression + " does not evaluate to a Date!", null );
+ aLogger.error( "FileDateSettingProducerNode: expression " + dateExpression + " does not evaluate to a Date!") ;
if (!aFile.setLastModified(((Date) date).getTime())) {
- aLogger.println("Can't set date for " + aFile.getName());
+ aLogger.error("Can't set date for " + aFile.getName());
}
}
catch (Throwable t) {
- throw new ProducerFailure(t.getMessage(), t);
+ aLogger.error( "File " + aFile.getName() + " could not be set to date " + dateExpression + ": " + t.getMessage());
}
}
}
\ No newline at end of file
import java.util.*;
import java.io.*;
+
import mir.util.*;
import mir.producer.*;
import mir.generator.*;
+import mir.log.*;
+
import mircoders.global.*;
import mircoders.localizer.*;
super(aFileIdentifier);
}
- protected void perform(File aFile, Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ protected void perform(File aFile, Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
if (!aFile.delete()) {
- aLogger.print("Can't delete " + aFile.getName());
+ aLogger.error("Can't delete file " + aFile.getName());
+ }
+ else {
+ aLogger.info("File " + aFile.getName() + " deleted");
}
}
}
\ No newline at end of file
import java.util.*;
import java.io.*;
+
import mir.util.*;
import mir.producer.*;
import mir.generator.*;
+import mir.log.*;
+
import mircoders.global.*;
import mircoders.localizer.*;
fileName = aFileName;
}
- protected abstract void perform(File aFile, Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure;
+ protected abstract void perform(File aFile, Map aValueMap, String aVerb, LoggerWrapper aLogger);
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
String fileIdentifier;
try {
perform(file, aValueMap, aVerb, aLogger);
}
catch (Throwable t) {
- aLogger.println("Error while performing file operation: " + t.getMessage());
-
- throw new ProducerFailure(t.getMessage(), t);
+ aLogger.error("Error while performing file operation: " + t.getMessage());
}
}
}
\ No newline at end of file
import java.util.*;
import java.io.*;
+
import mir.util.*;
import mir.producer.*;
import mir.generator.*;
+import mir.log.*;
public class GeneratingProducerNode implements ProducerNode {
private String generatorExpression;
this(aGeneratorLibrary, aWriterEngine, aGenerator, aDestination, "");
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
Generator generator;
Object writer;
String generatorIdentifier;
generatorIdentifier = ParameterExpander.expandExpression( aValueMap, generatorExpression );
parameters = ParameterExpander.expandExpression( aValueMap, parametersExpression );
- aLogger.println("Generating " + generatorIdentifier + " into " + destinationIdentifier + " using parameters " + parameters);
- aLogger.flush();
-
writer = writerEngine.openWriter( destinationIdentifier, parameters );
generator = generatorLibrary.makeGenerator( generatorIdentifier );
- generator.generate(writer, aValueMap, aLogger);
+ generator.generate(writer, aValueMap, new PrintWriter(new LoggerToWriterAdapter(aLogger, LoggerWrapper.INFO_MESSAGE)));
writerEngine.closeWriter( writer );
+
+ endTime = System.currentTimeMillis();
+ aLogger.info("Generated " + generatorIdentifier + " into " + destinationIdentifier + " [" + parameters + "] in " + (endTime-startTime) + " ms");
}
catch (Throwable t) {
- aLogger.println(" error while generating: " + t.getClass().getName() + ": " + t.getMessage());
+ aLogger.error(" error while generating: " + t.getClass().getName() + ": " + t.getMessage());
}
- endTime = System.currentTimeMillis();
-
- aLogger.println(" Time: " + (endTime-startTime) + " ms");
- aLogger.flush();
}
}
\ No newline at end of file
import java.io.*;
import java.util.*;
+
import mir.util.*;
import mir.producer.*;
+import mir.log.*;
public class LoggingProducerNode implements ProducerNode {
private String expression;
+ private int messageType;
- public LoggingProducerNode(String anExpression) {
+ public LoggingProducerNode(String anExpression, int aMessageType) {
expression = anExpression;
+ messageType = aMessageType;
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
String text;
try {
text = ParameterExpander.expandExpression( aValueMap, expression );
- aLogger.println(text);
+ aLogger.message(messageType, text);
}
catch (Throwable t) {
try {
- aLogger.println("Exception while logging message '"+expression+"': " + t.getMessage());
+ aLogger.error("Exception while logging message '"+expression+"': " + t.getMessage());
}
catch (Throwable s) {
}
import java.util.*;
import java.io.*;
+
import mir.util.*;
+import mir.log.*;
public class LoopProducerNode extends ProducerNodeDecorator {
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
int loopNr;
int maxNrLoops;
}
}
catch (Throwable t) {
- throw new ProducerFailure(t.getMessage(), t);
+ aLogger.error("LoopProducerNode raised an exception: " + t.getMessage());
}
};
}
\ No newline at end of file
import java.util.*;
import java.io.*;
+import mir.log.*;
+
public class NodedProducer implements Producer {
private ProducerNode rootNode;
private String verb;
isAborted = false;
}
- public void produce( PrintWriter aLogger ) throws ProducerFailure, ProducerExc {
+ public void produce( LoggerWrapper aLogger ) throws ProducerFailure, ProducerExc {
Map valueMap;
valueMap = new HashMap();
package mir.producer;
import java.io.*;
+import mir.log.*;
public interface Producer {
- public void produce( PrintWriter aLogger ) throws ProducerFailure, ProducerExc;
+ public void produce( LoggerWrapper aLogger ) throws ProducerFailure, ProducerExc;
public void abort();
}
import java.util.*;
import java.io.*;
+import mir.log.*;
+
public interface ProducerNode {
- public void produce(Map aValueSet, String aVerb, PrintWriter aLogger) throws ProducerExc, ProducerFailure;
+ public void produce(Map aValueSet, String aVerb, LoggerWrapper aLogger) throws ProducerExc, ProducerFailure;
}
\ No newline at end of file
import java.util.*;
import java.io.*;
+import mir.log.*;
+
public class ProducerNodeDecorator implements ProducerNode {
private ProducerNode slave;
((NodedProducer) producerValue).getIsAborted());
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure, ProducerExc {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure, ProducerExc {
if (slave!=null)
slave.produce(aValueMap, aVerb, aLogger);
}
import java.util.*;
import java.io.*;
import org.apache.struts.util.MessageResources;
+
import mir.util.*;
import mir.misc.*;
+import mir.log.*;
public class ResourceBundleProducerNode implements ProducerNode {
private String key;
- private String bundleIdentifier;
- private String languageIdentifier;
+ private String bundleExpression;
+ private String languageExpression;
- public ResourceBundleProducerNode(String aKey, String aBundleIdentifier) {
- this (aKey, aBundleIdentifier, null);
+ public ResourceBundleProducerNode(String aKey, String aBundleExpression) {
+ this (aKey, aBundleExpression, null);
}
- public ResourceBundleProducerNode(String aKey, String aBundleIdentifier, String aLanguageIdentifier) {
- bundleIdentifier = aBundleIdentifier;
- languageIdentifier = aLanguageIdentifier;
+ public ResourceBundleProducerNode(String aKey, String aBundleExpression, String aLanguageExpression) {
+ bundleExpression = aBundleExpression;
+ languageExpression = aLanguageExpression;
key = aKey;
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
Object messages;
try {
- if (languageIdentifier!=null) {
+ if (languageExpression!=null) {
messages =
new ResourceBundleGeneratorFunction(
- new Locale(ParameterExpander.expandExpression( aValueMap, languageIdentifier ), "" ),
- MessageResources.getMessageResources( ParameterExpander.expandExpression( aValueMap, bundleIdentifier ))
+ new Locale(ParameterExpander.expandExpression( aValueMap, languageExpression ), "" ),
+ MessageResources.getMessageResources( ParameterExpander.expandExpression( aValueMap, bundleExpression ))
);
}
else {
messages =
MessageResources.getMessageResources(
- ParameterExpander.expandExpression( aValueMap, bundleIdentifier ));
+ ParameterExpander.expandExpression( aValueMap, bundleExpression ));
}
ParameterExpander.setValueForKey( aValueMap, key, messages );
}
catch (Throwable t) {
- throw new ProducerFailure(t.getMessage(), t);
+ aLogger.error("Failed to load bundle " + bundleExpression + " for language " + languageExpression + " into key " + key + ": " + t.getMessage());
}
};
import java.io.*;
import java.util.*;
+
import mir.util.*;
+import mir.log.*;
public class ScriptCallingProducerNode implements ProducerNode {
String scriptExpression;
scriptExpression = aScriptExpression;
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
String script;
Process process;
int returnValue;
try {
script = ParameterExpander.expandExpression( aValueMap, scriptExpression );
- aLogger.println("Executing " + script + ":");
-
process = Runtime.getRuntime().exec(script);
returnValue = process.waitFor();
- aLogger.println("Terminated successfully, return value = " + returnValue + ".");
+ aLogger.info(script + " terminated successfully, return value = " + returnValue + ".");
}
catch (Throwable e) {
- throw new ProducerFailure("Executing script failed: " + e.getMessage(), e);
+ aLogger.error(scriptExpression + " failed to execute: " + e.getMessage());
}
}
}
import java.util.*;
import java.io.*;
import org.apache.struts.util.MessageResources;
+
import mir.util.*;
+import mir.log.*;
public class ValuesMapProducerNode extends ProducerNodeDecorator {
private String key;
super(aSubNode);
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
try {
aValueMap.putAll(map);
package mir.producer.reader;
import java.util.*;
+
import mir.generator.*;
+
import mir.producer.*;
import mir.entity.adapter.*;
import mir.util.*;
+import mir.log.*;
public class DefaultProducerNodeBuilders {
public static class LoggingProducerNodeBuilder extends AbstractProducerNodeBuilder {
private final static String LOG_MESSAGE_ATTRIBUTE = "message";
+ private final static String LOG_TYPE_ATTRIBUTE = "type";
private final static String[] LOG_REQUIRED_ATTRIBUTES = { LOG_MESSAGE_ATTRIBUTE };
- private final static String[] LOG_OPTIONAL_ATTRIBUTES = {};
+ private final static String[] LOG_OPTIONAL_ATTRIBUTES = { LOG_TYPE_ATTRIBUTE };
private final static String[] LOG_SUBNODES = {};
private String message;
+ private int type = LoggerWrapper.INFO_MESSAGE;
public LoggingProducerNodeBuilder() {
super(LOG_SUBNODES);
}
public void setAttributes(Map anAttributes) throws ProducerConfigExc {
+ String typeString;
+
ReaderTool.checkAttributes(anAttributes, LOG_REQUIRED_ATTRIBUTES, LOG_OPTIONAL_ATTRIBUTES);
message = (String) anAttributes.get(LOG_MESSAGE_ATTRIBUTE);
+ if (anAttributes.containsKey(LOG_TYPE_ATTRIBUTE)) {
+ typeString = ((String) anAttributes.get( LOG_TYPE_ATTRIBUTE ));
+
+ if (typeString.toLowerCase().equals("debug"))
+ type = LoggerWrapper.DEBUG_MESSAGE;
+ else if (typeString.toLowerCase().equals("info"))
+ type = LoggerWrapper.INFO_MESSAGE;
+ else if (typeString.toLowerCase().equals("error"))
+ type = LoggerWrapper.ERROR_MESSAGE;
+ else if (typeString.toLowerCase().equals("warning"))
+ type = LoggerWrapper.WARN_MESSAGE;
+ else if (typeString.toLowerCase().equals("fatal"))
+ type = LoggerWrapper.FATAL_MESSAGE;
+ else
+ throw new ProducerConfigExc("unknown log type: " + typeString + " (allowed are debug, info, warning, error, fatal)");
+ }
+ else
+ type = LoggerWrapper.INFO_MESSAGE;
};
public ProducerNode constructNode() {
- return new LoggingProducerNode(message);
+ return new LoggingProducerNode(message, type);
};
}
import java.util.*;
import java.io.*;
+
import mir.producer.*;
import mir.util.*;
+import mir.log.*;
public class ScriptedProducerNode implements ProducerNode {
private ScriptedProducerNodeDefinition definition;
nodeParameterValues.putAll(aNodeParameterValues);
}
- public void produce(Map aValues, String aVerb, PrintWriter aLogger) throws ProducerFailure, ProducerExc {
+ public void produce(Map aValues, String aVerb, LoggerWrapper aLogger) throws ProducerFailure, ProducerExc {
try {
Map oldValues = new HashMap();
ScriptedProducerNodeTool.saveMapValues(oldValues, aValues, definition.getStringParameters().keySet());
}
}
catch (Exception e) {
- throw new ProducerFailure(e);
+ aLogger.error("Scripted producer node " + definition.getName() + " caused an exception: " + e.getMessage());
}
}
import java.util.*;
import java.io.*;
+
import mir.producer.*;
+import mir.log.*;
public class ScriptedProducerNodeDefinition {
private Map integerParameters; // name -> default value
parameterName = aParameterName;
}
- public void produce(Map aValues, String aVerb, PrintWriter aLogger) throws ProducerExc, ProducerFailure {
+ public void produce(Map aValues, String aVerb, LoggerWrapper aLogger) throws ProducerExc, ProducerFailure {
ProducerNode producerNode;
Map runTimeData = (Map) ((Map) aValues.get(SCRIPTED_PRODUCERNODE_RUNTIMEDATA_KEY)).get(definitionName);
import mir.util.*;
import multex.Exc;
import multex.Failure;
+import mir.log.*;
public class ProducerEngine {
// private Map producers;
private JobQueue producerJobQueue;
private Thread queueThread;
- private PrintWriter log;
+ private LoggerWrapper logger;
+
protected ProducerEngine() {
producerJobQueue = new JobQueue();
- try {
- RandomAccessFile raFile = (new RandomAccessFile(MirGlobal.getConfigProperty("Home") + "/" + MirGlobal.getConfigProperty("Producer.Logfile"), "rw"));
- raFile.seek(raFile.length());
- log = new PrintWriter(new FileWriter( raFile.getFD()));
- }
- catch (Exception e) {
- log = new PrintWriter(new NullWriter());
- }
+ logger = new LoggerWrapper("producer");
+
queueThread = new Thread(new ProducerJobQueueThread());
queueThread.start();
}
Map startingMap = new HashMap();
startTime = System.currentTimeMillis();
- log.println("Producing job: "+factoryName+"."+verb);
+ logger.info("Producing job: "+factoryName+"."+verb);
try {
factory = MirGlobal.localizer().producers().getFactoryForName( factoryName );
producer = factory.makeProducer(verb, startingMap);
}
if (producer!=null) {
- producer.produce(log);
+ producer.produce(logger);
}
}
}
catch (Throwable t) {
- log.println(" exception "+t.getMessage());
- t.printStackTrace(log);
+ logger.error("Exception occurred while producing " + factoryName + "." + verb + t.getMessage());
+ t.printStackTrace(new PrintWriter(new LoggerToWriterAdapter(logger, LoggerWrapper.ERROR_MESSAGE)));
}
- log.println("Done producing job: "+factoryName+"."+verb);
endTime = System.currentTimeMillis();
- log.println("Time: " + (endTime-startTime) + " ms");
- log.flush();
+ logger.info("Done producing job: " + factoryName + "." + verb + ", time elapsed:" + (endTime-startTime) + " ms");
}
boolean isAborted() {
private class ProducerJobQueueThread implements Runnable {
public void run() {
- log.println("starting ProducerJobQueueThread");
- log.flush();
+ logger.debug("starting ProducerJobQueueThread");
while (true) {
ProducerJob job = (ProducerJob) producerJobQueue.acquirePendingJob();
return result;\r
}\r
}\r
+\r
protected class ContentCommentCountField implements EntityAdapterDefinition.CalculatedField {\r
private String extraCondition;\r
\r
import java.util.*;
import java.io.*;
import mir.producer.*;
+import mir.log.*;
public class CompositeProducer implements mir.producer.Producer {
private List producers;
producers.add(aProducer);
}
- public void produce( PrintWriter aLogger ) throws ProducerFailure, ProducerExc {
+ public void produce( LoggerWrapper aLogger ) throws ProducerFailure, ProducerExc {
Iterator i;
i=producers.iterator();
package mircoders.producer;
import java.util.*;
-import java.io.*;
+
+import mir.log.*;
import mir.util.*;
import mir.producer.*;
import mir.entity.*;
contentKey = aContentKey;
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
Object data;
Entity entity;
((EntityContent) entity).setProduced(true);
}
catch (Throwable t) {
- aLogger.println("Error while marking content: " + t.getMessage());
- t.printStackTrace(aLogger);
-
- throw new ProducerFailure(t.getMessage(), t);
+ aLogger.error("Error while marking content: " + t.getMessage());
}
}
}
\ No newline at end of file
import java.util.*;
import java.io.*;
+
import mir.util.*;
import mir.producer.*;
import mir.entity.*;
import mir.entity.adapter.*;
+import mir.log.*;
+
import mircoders.entity.*;
import mircoders.module.*;
import mircoders.storage.*;
valueExpression = aValueExpression;
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) {
Object data;
Entity entity;
String value;
entity.setValueForProperty(fieldName, value);
entity.update();
- aLogger.println(" Modified content " + entity.get("id") + ": " + fieldName + " = " + value );
+ aLogger.info(" Modified content " + entity.get("id") + ": " + fieldName + " = " + value );
}
catch (Throwable t) {
- aLogger.println("Error while modifying content: " + t.getMessage());
- t.printStackTrace(aLogger);
-
- throw new ProducerFailure(t.getMessage(), t);
+ aLogger.error("Error while modifying content: " + t.getMessage());
}
}
}
import java.util.*;
import java.io.*;
-
+
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.index.*;
import org.apache.lucene.document.Document;
import mir.util.*;
+import mir.log.*;
import mir.producer.*;
//import mir.generator.*;
import mircoders.global.*;
public class IndexingProducerNode implements ProducerNode {
private String contentKey;
private String indexPath;
-
-
+
+
public IndexingProducerNode(String aContentKey, String pathToIndex) {
contentKey = aContentKey;
indexPath=pathToIndex;
}
-
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
IndexReader indexReader = null;
IndexWriter indexWriter = null;
Object data;
Entity entity;
-
+
long startTime;
long endTime;
-
+
startTime = System.currentTimeMillis();
-
+
try {
data = ParameterExpander.findValueForKey( aValueMap, contentKey );
-
+
if (! (data instanceof EntityAdapter)) {
- throw new ProducerFailure("IndexingProducerNode: value of '"+contentKey+"' is not an EntityAdapter, but an " + data.getClass().getName(), null);
+ throw new ProducerFailure("IndexingProducerNode: value of '"+contentKey+"' is not an EntityAdapter, but an " + data.getClass().getName(), null);
}
-
+
entity = ((EntityAdapter) data).getEntity();
if (! (entity instanceof EntityContent)) {
- throw new ProducerFailure("IndexingProducerNode: value of '"+contentKey+"' is not a content EntityAdapter, but a " + entity.getClass().getName() + " adapter", null);
+ throw new ProducerFailure("IndexingProducerNode: value of '"+contentKey+"' is not a content EntityAdapter, but a " + entity.getClass().getName() + " adapter", null);
}
- aLogger.println("Indexing " + (String) entity.getValue("id") + " into " + indexPath);
- aLogger.flush();
-
+ aLogger.info("Indexing " + (String) entity.getValue("id") + " into " + indexPath);
+
indexReader = IndexReader.open(indexPath);
indexReader.delete(new Term("id",entity.getValue("id")));
indexReader.close();
-
+
indexWriter = new IndexWriter(indexPath, new StandardAnalyzer(), false);
Document theDoc = new Document();
-
+
// Keyword is stored and indexed, but not tokenized
// Text is tokenized,stored, indexed
// Unindexed is not tokenized or indexed, only stored
// Unstored is tokenized and indexed, but not stored
-
+
theDoc.add(Field.Keyword("id",entity.getValue("id")));
theDoc.add(Field.Keyword("where",entity.getValue("publish_path")+entity.getValue("id")+".shtml"));
theDoc.add(Field.Text("creator",entity.getValue("creator")));
theDoc.add(Field.Text("title",entity.getValue("title")));
theDoc.add(Field.Keyword("webdb_create",entity.getValue("webdb_create_formatted")));
theDoc.add(Field.UnStored("content_and_description",entity.getValue("description")+entity.getValue("content_data")));
-
+
//topics
TemplateModel topics=entity.get("to_topics");
- aLogger.println("THE CLASS NAME WAS: "+entity.get("to_topics").getClass().getName());
+ aLogger.debug("THE CLASS NAME WAS: "+entity.get("to_topics").getClass().getName());
while (((TemplateListModel)topics).hasNext()){
- theDoc.add(Field.UnStored("topic",((TemplateHashModel)((TemplateListModel)topics).next()).get("title").toString()));
+ theDoc.add(Field.UnStored("topic",((TemplateHashModel)((TemplateListModel)topics).next()).get("title").toString()));
}
-
-
+
+
//media
-
+
//images
TemplateModel images=entity.get("to_media_images");
if (images != null){
- //here we should really store a list of urls instead,
- //so we can thumbnail from another server
- theDoc.add(Field.UnStored("media","images"));
-
+ //here we should really store a list of urls instead,
+ //so we can thumbnail from another server
+ theDoc.add(Field.UnStored("media","images"));
+
}
//audio
TemplateModel audio=entity.get("to_media_audio");
if (audio != null){
- theDoc.add(Field.UnStored("media","audio"));
+ theDoc.add(Field.UnStored("media","audio"));
}
//video
TemplateModel video=entity.get("to_media_video");
if (video != null){
- theDoc.add(Field.UnStored("media","video"));
+ theDoc.add(Field.UnStored("media","video"));
}
//comments-just aggregate all relevant fields
String commentsAggregate = "";
TemplateModel comments=entity.get("to_comments");
if (comments != null){
- while (((TemplateListModel)comments).hasNext()){
- TemplateModel aComment = ((TemplateListModel)comments).next();
- commentsAggregate = commentsAggregate + " " + ((TemplateHashModel)aComment).get("title").toString()
- + " " + ((TemplateHashModel)aComment).get("creator").toString()
- + " " + ((TemplateHashModel)aComment).get("text").toString();
- }
+ while (((TemplateListModel)comments).hasNext()){
+ TemplateModel aComment = ((TemplateListModel)comments).next();
+ commentsAggregate = commentsAggregate + " " + ((TemplateHashModel)aComment).get("title").toString()
+ + " " + ((TemplateHashModel)aComment).get("creator").toString()
+ + " " + ((TemplateHashModel)aComment).get("text").toString();
+ }
}
theDoc.add(Field.UnStored("comments",commentsAggregate));
indexWriter.addDocument(theDoc);
-
+
}
catch (Throwable t) {
- aLogger.println("Error while indexing content: " + t.getMessage());
- t.printStackTrace(aLogger);
+ aLogger.error("Error while indexing content: " + t.getMessage());
+ t.printStackTrace(new PrintWriter(new LoggerToWriterAdapter(aLogger, LoggerWrapper.DEBUG_MESSAGE)));
//should remove index lock here.....jd
- throw new ProducerFailure(t.getMessage(), t);
}
finally {
if (indexReader != null){
- try{
- indexReader.close();
- }
- catch (Throwable t) {
- aLogger.println("Error while closing indexReader: " + t.getMessage());
- }
-
+ try{
+ indexReader.close();
+ }
+ catch (Throwable t) {
+ aLogger.warn("Error while closing indexReader: " + t.getMessage());
+ }
+
}
if (indexWriter != null){
- try{
- indexWriter.close();
- }
- catch (Throwable t) {
- aLogger.println("Error while closing indexWriter: " + t.getMessage());
- }
-
+ try{
+ indexWriter.close();
+ }
+ catch (Throwable t) {
+ aLogger.warn("Error while closing indexWriter: " + t.getMessage());
+ }
+
}
-
+
try{
- FSDirectory theIndexDir=FSDirectory.getDirectory(indexPath,false);
- if (indexReader.isLocked(theIndexDir)){
- indexReader.unlock(theIndexDir);
- }
+ FSDirectory theIndexDir=FSDirectory.getDirectory(indexPath,false);
+ if (indexReader.isLocked(theIndexDir)){
+ indexReader.unlock(theIndexDir);
+ }
}
catch (Throwable t) {
- aLogger.println("Error while unlocking index: " + t.getMessage());
+ aLogger.warn("Error while unlocking index: " + t.getMessage());
}
}
-
-
-
+
+
+
endTime = System.currentTimeMillis();
-
- aLogger.println(" IndexTime: " + (endTime-startTime) + " ms<br>");
- aLogger.flush();
+
+ aLogger.info(" IndexTime: " + (endTime-startTime) + " ms<br>");
}
}
import java.util.*;
import java.io.*;
+
import mir.util.*;
+import mir.log.*;
import mir.misc.*;
import mir.media.*;
import mir.producer.*;
import mir.generator.*;
import mir.entity.*;
import mir.entity.adapter.*;
-//import mircoders.global.*;
-//import mircoders.localizer.*;
+
import mircoders.entity.*;
import mircoders.storage.*;
mediaEntityKey = aMediaEntityKey;
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure, ProducerExc {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) {
Object data;
Entity entity;
EntityUploadedMedia uploadedMediaEntity = null;
entity.setValueForProperty("is_produced", "1");
entity.update();
- aLogger.println("media with id "+uploadedMediaEntity.getValue("id") + ", mediaType " + mediaType.getValue("name") + " successfully produced");
+ aLogger.info("media with id "+uploadedMediaEntity.getValue("id") + ", mediaType " + mediaType.getValue("name") + " successfully produced");
}
catch (Throwable t) {
String message = "Error while generating media";
}
message = message + ": " + t.getMessage();
- aLogger.println(message);
+ aLogger.error(message);
}
}
}
package mircoders.producer;
-import mir.producer.*;
import java.io.*;
+import mir.producer.*;
+import mir.log.*;
+
public class OldProducerAdapter implements mir.producer.Producer {
private mircoders.producer.Producer oldProducer;
forced = aForced;
}
- public void produce( PrintWriter aLogger ) throws ProducerFailure {
+ public void produce( LoggerWrapper aLogger ) throws ProducerFailure {
try {
- oldProducer.handle( aLogger, null, forced.booleanValue(), false );
+ oldProducer.handle( new PrintWriter(new LoggerToWriterAdapter( aLogger, LoggerWrapper.INFO_MESSAGE )), null, forced.booleanValue(), false );
}
catch (Throwable e) {
throw new ProducerFailure("Failure at handling old Producers",e);
import java.util.*;
import java.io.*;
+
+import mir.log.*;
import mir.util.*;
import mir.producer.*;
import mir.misc.PDFUtil;
stylesheet=aStylesheet;
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) {
String generatorIdentifier;
String destinationIdentifier;
generatorIdentifier = ParameterExpander.expandExpression( aValueMap, generatorExpression );
stylesheetIdentifier = ParameterExpander.expandExpression( aValueMap, stylesheet);
- aLogger.println("Generating " + generatorIdentifier + " into " + destinationIdentifier + " using "+ stylesheetIdentifier);
- aLogger.flush();
+ aLogger.info("Generating " + generatorIdentifier + " into " + destinationIdentifier + " using "+ stylesheetIdentifier);
PDFUtil.makePDF(generatorIdentifier,destinationIdentifier,stylesheetIdentifier);
- }
- catch (Throwable t) {
- t.printStackTrace();
- aLogger.println(" error while generating: " + t.getMessage() + t.toString());
- aLogger.flush();
+ }
+ catch (Throwable t) {
+ t.printStackTrace();
+ aLogger.error(" error while generating: " + t.getMessage() + t.toString());
}
endTime = System.currentTimeMillis();
- aLogger.println(" Time: " + (endTime-startTime) + " ms<br>");
- aLogger.flush();
+ aLogger.info(" Time: " + (endTime-startTime) + " ms<br>");
}
}
import java.util.*;
import java.io.*;
+
import mir.util.*;
import mir.producer.*;
import mir.entity.*;
import mir.entity.adapter.*;
+import mir.log.*;
+
import mircoders.entity.*;
import mircoders.storage.*;
//float lineHeightCM = .5F;
}
- public void produce(Map aValueMap, String aVerb, PrintWriter aLogger) throws ProducerFailure {
+ public void produce(Map aValueMap, String aVerb, LoggerWrapper aLogger) throws ProducerFailure {
Object data;
Entity entity;
}
row0.put("hasImage","0");
brokenUpContent.add(row0);
- aLogger.println("CP1 is "+ currentPosition);
+ aLogger.debug("CP1 is "+ currentPosition);
while(images.hasNext()){
HashMap row1 = new HashMap();
HashMap row2 = new HashMap();
row1.put("img_width",Float.toString(img_width));
row1.put("img_height",Float.toString(img_height));
- aLogger.println("img_width " +Float.toString(img_width));
- aLogger.println("img_height "+Float.toString(img_height));
+ aLogger.debug("img_width " +Float.toString(img_width));
+ aLogger.debug("img_height "+Float.toString(img_height));
row1.put("img_src",currentImage.getValue("publish_path"));
row1.put("hasImage","1");
outOfText = true;
}
}
- aLogger.println("CP2 is "+ currentPosition);
+ aLogger.debug("CP2 is "+ currentPosition);
brokenUpContent.add(row1);
if (! outOfText){
row2.put("hasImage","0");
brokenUpContent.add(row2);
- aLogger.println("CP3 is "+ currentPosition);
+ aLogger.debug("CP3 is "+ currentPosition);
}
HashMap row3 = new HashMap();
if (! outOfText){
}
catch (Throwable t) {
- aLogger.println("Error while formatting content for PDF: " + t.getMessage());
- t.printStackTrace(aLogger);
-
- throw new ProducerFailure(t.getMessage(), t);
+ aLogger.error("Error while formatting content for PDF: " + t.getMessage());
+ t.printStackTrace(new PrintWriter(new LoggerToWriterAdapter(aLogger, LoggerWrapper.DEBUG_MESSAGE)));
}
}
}
projects / mir.git / commitdiff