public void assertDeserialized(Serializable initial, Serializable deserialized) {
Level init = (Level) initial;
Level dser = (Level) deserialized;
assertEquals("Class", init.getClass(), dser.getClass());
assertEquals("Name", init.getName(), dser.getName());
assertEquals("Value", init.intValue(), dser.intValue());
assertEquals(
"ResourceBundleName", init.getResourceBundleName(), dser.getResourceBundleName());
}
public void setLevel(Level level) {
LogService.getRoot().setLevel(level);
handler.setLevel(level);
ParameterService.setParameterValue(
MainFrame.PROPERTY_RAPIDMINER_GUI_LOG_LEVEL, level.getName());
ParameterService.saveParameters();
}
public static void log(Level pLevel, Exception pExp) {
if (pLevel.intValue() >= Catalog.LOG_LEVEL.intValue()) {
StringWriter pMsg = new StringWriter();
pExp.printStackTrace(new PrintWriter(pMsg));
log("[" + pLevel.getName() + "] " + pMsg.toString());
}
}
private ModelNode addFileHandler(
final KernelServices kernelServices,
final String loggingProfile,
final String name,
final Level level,
final File file,
final boolean assign)
throws Exception {
final ModelNode address = createFileHandlerAddress(loggingProfile, name).toModelNode();
// add file handler
ModelNode op = SubsystemOperations.createAddOperation(address);
op.get(CommonAttributes.NAME.getName()).set(name);
op.get(CommonAttributes.LEVEL.getName()).set(level.getName());
op.get(CommonAttributes.FILE.getName())
.get(PathResourceDefinition.PATH.getName())
.set(file.getAbsolutePath());
op.get(CommonAttributes.AUTOFLUSH.getName()).set(true);
executeOperation(kernelServices, op);
// register it with root logger
if (assign) {
op =
SubsystemOperations.createOperation(
RootLoggerResourceDefinition.ROOT_LOGGER_ADD_HANDLER_OPERATION_NAME,
createRootLoggerAddress(loggingProfile).toModelNode());
op.get(CommonAttributes.NAME.getName()).set(name);
executeOperation(kernelServices, op);
}
return address;
}
private void logToChat(Level l, String message) {
if (chatLevel.intValue() <= l.intValue()) {
for (Player player : getServer().getOnlinePlayers()) {
if (hasPermission(player, PermissionData.PERMISSION_NOTIFY, false)) {
player.sendMessage("[" + l.getName() + "] " + message);
}
}
}
}
public void log(Level level, Plugin plugin, String message) {
write(
"["
+ this.plugin.time.getLongDate()
+ "] "
+ "["
+ plugin.getName()
+ "] ["
+ level.getName()
+ "] "
+ message);
}
private static void setDBLoggingLevel(
EnvironmentConfig envConfig, String loggingLevel, DN dn, boolean loggingFileHandlerOn)
throws ConfigException {
Logger parent = Logger.getLogger("com.sleepycat.je");
try {
parent.setLevel(Level.parse(loggingLevel));
} catch (Exception e) {
throw new ConfigException(ERR_JEB_INVALID_LOGGING_LEVEL.get(loggingLevel, dn));
}
final Level level = loggingFileHandlerOn ? Level.ALL : Level.OFF;
envConfig.setConfigParam(FILE_LOGGING_LEVEL, level.getName());
}
public static String getCanonicalName(final Level level) {
if (Level.CONFIG == level) {
return "config";
} else if (Level.FINER == level) {
return "verbose";
} else if (Level.FINE == level) {
return "debug";
} else if (Level.INFO == level) {
return "info";
} else if (Level.WARNING == level) {
return "warning";
} else if (Level.SEVERE == level) {
return "error";
} else {
return level.getName().toLowerCase();
}
}
/*
* (non-Javadoc)
*
* @see java.util.logging.LoggingMXBean#getLoggerLevel(java.lang.String)
*/
public String getLoggerLevel(String loggerName) {
String result = null;
Logger logger = LogManager.getLogManager().getLogger(loggerName);
if (logger != null) {
// The named Logger exists. Now attempt to obtain its log level.
Level level = logger.getLevel();
if (level != null) {
result = level.getName();
} else {
// A null return from getLevel() means that the Logger
// is inheriting its log level from an ancestor. Return an
// empty string to the caller.
result = "";
}
}
return result;
}
private void initLogLevel() {
String logLevelStr = getProperty(logLevelKey, Level.OFF.getName());
Level[] validLevels =
new Level[] {
Level.SEVERE,
Level.WARNING,
Level.INFO,
Level.CONFIG,
Level.FINE,
Level.FINER,
Level.FINEST,
Level.ALL,
Level.OFF,
};
logLevel = Level.OFF;
for (Level level : validLevels) {
if (level.getName().equalsIgnoreCase(logLevelStr)) {
logLevel = level;
break;
}
}
}
// initialization
static {
Properties p = new Properties();
File f = new File("redpin.properties");
if (f.exists()) {
try {
FileInputStream reader = new FileInputStream(f);
p.load(reader);
try {
ServerPort = new Integer(p.getProperty("port", ServerPort.toString()));
} catch (NumberFormatException e) {
}
ImageUploadPath = p.getProperty("image.upload.path", ImageUploadPath);
if (ImageUploadPath.charAt(ImageUploadPath.length() - 1) == '/') {
ImageUploadPath = ImageUploadPath.substring(0, ImageUploadPath.length() - 1);
}
LogFile = p.getProperty("log.file", LogFile);
String format = "";
try {
format = p.getProperty("log.format", LogFormat.name());
LogFormat = LoggerFormat.valueOf(format.toUpperCase());
} catch (IllegalArgumentException e) {
Log.getLogger()
.log(Level.CONFIG, "No such log format type " + format + ": " + e.getMessage(), e);
}
String level = "";
try {
level = p.getProperty("log.level", LogLevel.getName());
LogLevel = Level.parse(level);
} catch (IllegalArgumentException e) {
Log.getLogger()
.log(Level.CONFIG, "No such log format type " + format + ": " + e.getMessage(), e);
}
LogRequests =
Boolean.valueOf(p.getProperty("requests.log", Boolean.valueOf(LogRequests).toString()));
LogRequestPath = p.getProperty("requests.log.path", LogRequestPath);
if (LogRequestPath.charAt(LogRequestPath.length() - 1) == '/') {
LogRequestPath = LogRequestPath.substring(0, LogRequestPath.length() - 1);
}
if (LogRequests) {
File lrp = new File(LogRequestPath);
if (!lrp.exists()) {
lrp.mkdirs();
}
}
String type = "";
try {
type = p.getProperty("db.type", DatabaseType.name());
DatabaseType = DatabaseTypes.valueOf(type.toUpperCase());
} catch (IllegalArgumentException e) {
Log.getLogger()
.log(Level.CONFIG, "No such database type " + type + ": " + e.getMessage(), e);
}
if (DatabaseType == DatabaseTypes.SQLITE) {
DatabaseLocation = p.getProperty("db.location", DatabaseLocation);
DatabaseDriver = "org.sqlite.JDBC";
}
if (DatabaseType == DatabaseTypes.MYSQL) {
DatabaseDriver = "com.mysql.jdbc.Driver";
DatabaseLocation = p.getProperty("db.location", DatabaseLocation);
}
if (DatabaseType == DatabaseTypes.POSTGRESQL) {
DatabaseDriver = "org.postgresql.Driver";
DatabaseLocation = p.getProperty("db.location", DatabaseLocation);
}
LibSVMDirectory = p.getProperty("svm.libdir", LibSVMDirectory);
try {
SVMTrainRate = Long.parseLong(p.getProperty("svm.trainrate", SVMTrainRate + ""));
} catch (NumberFormatException e) {
}
} catch (Exception e) {
Log.getLogger().log(Level.SEVERE, "Config initialization failed: " + e.getMessage(), e);
e.printStackTrace();
}
}
File dir = new File(ImageUploadPath);
if (!dir.exists()) {
if (!dir.mkdirs()) {
Log.getLogger().log(Level.WARNING, "Image Upload Path could not be created");
} else {
Log.getLogger()
.log(Level.FINE, "No image upload dir found, now creating {0}", ImageUploadPath);
}
}
if ((DatabaseType == DatabaseTypes.SQLITE) && (!new File(DatabaseLocation).exists())) {
Log.getLogger().fine("No database file found, now importing database schema");
importSQLiteSchema();
}
dir = new File(LibSVMDirectory);
if (dir.isDirectory() && dir.exists()) {
File trainPl = new File(SVMSupport.TRAIN_SCRIPT);
try {
if (!trainPl.exists()) {
try (Writer w = new FileWriter(trainPl)) {
w.write(generateTrainScript(LibSVMDirectory));
w.flush();
}
trainPl.setExecutable(true);
}
} catch (Exception e) {
Log.getLogger().fine("could not create " + SVMSupport.TRAIN_SCRIPT);
}
}
}
private void testChangeRootLogLevel(final String loggingProfile) throws Exception {
final KernelServices kernelServices = boot();
final String fileHandlerName = "test-file-handler";
// add new file logger so we can track logged messages
final File logFile = createLogFile();
addFileHandler(
kernelServices,
loggingProfile,
fileHandlerName,
org.jboss.logmanager.Level.TRACE,
logFile,
true);
final Level[] levels = {
org.jboss.logmanager.Level.FATAL,
org.jboss.logmanager.Level.ERROR,
org.jboss.logmanager.Level.WARN,
org.jboss.logmanager.Level.INFO,
org.jboss.logmanager.Level.DEBUG,
org.jboss.logmanager.Level.TRACE
};
final Map<Level, Integer> levelOrd = new HashMap<Level, Integer>();
levelOrd.put(org.jboss.logmanager.Level.FATAL, 0);
levelOrd.put(org.jboss.logmanager.Level.ERROR, 1);
levelOrd.put(org.jboss.logmanager.Level.WARN, 2);
levelOrd.put(org.jboss.logmanager.Level.INFO, 3);
levelOrd.put(org.jboss.logmanager.Level.DEBUG, 4);
levelOrd.put(org.jboss.logmanager.Level.TRACE, 5);
// log messages on all levels with different root logger level settings
final ModelNode address = createRootLoggerAddress(loggingProfile).toModelNode();
for (Level level : levels) {
// change root log level
final ModelNode op =
SubsystemOperations.createWriteAttributeOperation(
address, CommonAttributes.LEVEL, level.getName());
executeOperation(kernelServices, op);
doLog(loggingProfile, levels, "RootLoggerTestCaseTST %s", level);
}
// Remove the handler
removeFileHandler(kernelServices, loggingProfile, fileHandlerName, true);
// go through logged messages - test that with each root logger level settings
// message with equal priority and also messages with all higher
// priorities were logged
final boolean[][] logFound = new boolean[levelOrd.size()][levelOrd.size()];
final List<String> logLines = FileUtils.readLines(logFile);
for (String line : logLines) {
if (!line.contains("RootLoggerTestCaseTST")) continue; // not our log
final String[] words = line.split("\\s+");
try {
final Level lineLogLevel = Level.parse(words[1]);
final Level rootLogLevel = Level.parse(words[5]);
final int producedLevel = levelOrd.get(lineLogLevel);
final int loggedLevel = levelOrd.get(rootLogLevel);
assertTrue(
String.format(
"Produced level(%s) greater than logged level (%s)", lineLogLevel, rootLogLevel),
producedLevel <= loggedLevel);
logFound[producedLevel][loggedLevel] = true;
} catch (Exception e) {
throw new Exception("Unexpected log:" + line);
}
}
for (Level level : levels) {
final int rl = levelOrd.get(level);
for (int ll = 0; ll <= rl; ll++) assertTrue(logFound[ll][rl]);
}
}
public static void log(Level level, String msg, Throwable thrown) {
System.out.println(level.getName() + " : " + thrown.getMessage() + " ----- " + msg);
}
/*
* Test method parse, with an undefined valid number strings.
*/
public void testParse_UndefinedNumber() {
Level l = Level.parse("0");
assertEquals(0, l.intValue());
assertEquals("0", l.getName());
assertNull(l.getResourceBundleName());
}
public void testParse_NegativeNumber() {
Level l = Level.parse("-4");
assertEquals(-4, l.intValue());
assertEquals("-4", l.getName());
assertNull(l.getResourceBundleName());
}
public static void log(Level pLevel, String pText) {
if (pLevel.intValue() >= Catalog.LOG_LEVEL.intValue()) {
log("[" + pLevel.getName() + "] " + pText);
}
}
private void logToIRC(Level l, String message) {
if (irc != null && ircLevel.intValue() <= l.intValue()) {
irc.sendMessageToTag("[" + l.getName() + "] " + message, ircTag);
}
}
public SetLogLevelAction(Level pLevel) {
super(getResourceString("LogFileViewer.SetLogLevelAction_" + pLevel.getName()));
mLevel = pLevel;
}
/**
* Sets the new log level to be used by all <code>java.util.logging</code> loggers, and persists
* it in the application preferences.
*
* @param level the new log level to be used by all <code>java.util.logging</code> loggers.
*/
public static void setLogLevel(Level level) {
MuConfiguration.setVariable(MuConfiguration.LOG_LEVEL, level.getName());
updateLogLevel(level);
}
/*
* (non-Javadoc)
*
* @see freemind.extensions.HookAdapter#startupMapHook()
*/
public void startupMapHook() {
super.startupMapHook();
if (logger == null) {
logger = freemind.main.Resources.getInstance().getLogger(this.getClass().getName());
}
mMyMindMapController = super.getMindMapController();
mSimpleFormatter = new SimpleFormatter();
// retrieve content
final String pathname =
getMindMapController().getFrame().getFreemindDirectory()
+ File.separator
+ FreeMind.LOG_FILE_NAME
+ ".0";
String logFileContents = Tools.getFile(new File(pathname));
// done.
getMindMapController().getController().getMapModuleManager().addListener(this);
mLogFileViewer = new JDialog(getController().getFrame().getJFrame(), false);
mLogFileViewer.setTitle(getResourceString("LogFileViewer_title") + pathname);
mLogFileViewer.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
mLogFileViewer.addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent event) {
disposeDialog();
}
});
mCloseAction = new CloseAction();
// the action title is changed by the following method, thus we create
// another close action.
Tools.addEscapeActionToDialog(mLogFileViewer, new CloseAction());
/** Menu * */
StructuredMenuHolder menuHolder = new StructuredMenuHolder();
mMenuBar = new JMenuBar();
JMenu mainItem = new JMenu(getResourceString("MapControllerPopupDialog.Actions"));
menuHolder.addMenu(mainItem, "main/actions/.");
Action printOperationAction = new PrintOperationAction();
addAccelerator(
menuHolder.addAction(printOperationAction, "main/actions/printOperationAction"),
"keystroke_accessories/plugins/LogFileViewer_printOperationAction");
JMenu loggerItem = new JMenu(getResourceString("MapControllerPopupDialog.LogLevels"));
menuHolder.addMenu(loggerItem, "main/loglevel/.");
Level[] levels =
new Level[] {
Level.FINEST, Level.FINER, Level.FINE, Level.INFO, Level.WARNING, Level.SEVERE, Level.OFF
};
for (int i = 0; i < levels.length; i++) {
Level level = levels[i];
menuHolder.addAction(
new SetLogLevelAction(level), "main/loglevel/setLogLevel_" + level.getName());
}
menuHolder.updateMenus(mMenuBar, "main/");
mLogFileViewer.setJMenuBar(mMenuBar);
mLogFileViewer.setSize(400, 400);
mLogFileViewer.setLayout(new BorderLayout());
mTextArea = new JTextArea(logFileContents);
mTextArea.setEditable(false);
mTextArea.getCaret().setVisible(true);
// scroll at the end
mTextArea.setCaretPosition(logFileContents.length());
mLogFileViewer.add(new JScrollPane(mTextArea), BorderLayout.CENTER);
// restore preferences:
// Retrieve window size and column positions.
LogFileViewerConfigurationStorage storage =
(LogFileViewerConfigurationStorage)
getMindMapController()
.decorateDialog(mLogFileViewer, WINDOW_PREFERENCE_STORAGE_PROPERTY);
if (storage != null) {
// retrieve_additional_data_here
}
mLogFileViewer.setVisible(true);
mUpdateTextAreaThread = new UpdateTextAreaThread();
mUpdateTextAreaThread.start();
LogFileLogHandler baseHandler = getBaseHandler();
if (baseHandler != null) {
baseHandler.setLogReceiver(this);
}
}
