/*
* Copyright (c) 2005-2011 KOM - Multimedia Communications Lab
*
* This file is part of PeerfactSim.KOM.
*
* PeerfactSim.KOM is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* PeerfactSim.KOM is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with PeerfactSim.KOM. If not, see .
*
*/
package de.tud.kom.p2psim.impl.common;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import de.tud.kom.p2psim.api.simengine.SimulatorObserver;
import de.tud.kom.p2psim.impl.simengine.Simulator;
import de.tud.kom.p2psim.impl.util.db.dao.DAO;
import de.tudarmstadt.maki.simonstrator.api.Event;
import de.tudarmstadt.maki.simonstrator.api.EventHandler;
import de.tudarmstadt.maki.simonstrator.api.Monitor;
import de.tudarmstadt.maki.simonstrator.api.Monitor.Level;
import de.tudarmstadt.maki.simonstrator.api.Time;
import de.tudarmstadt.maki.simonstrator.api.component.core.MonitorComponent;
/**
* New Monitor-Component to work with the simonstrator-API (provides
* overlay-access to analyzers)
*
* @author Bjoern Richerzhagen
* @version 1.0, Jul 8, 2013
*/
public class DefaultMonitor implements MonitorComponent, EventHandler,
SimulatorObserver {
private final static List analyzers = new LinkedList();
private final static Map, Logger> loggers = new LinkedHashMap, Logger>();
private static DefaultMonitor singletonInstance = null;
private DefaultMonitor() {
this.isMonitoring = false;
}
public static DefaultMonitor getInstance() {
if (singletonInstance == null) {
singletonInstance = new DefaultMonitor();
}
return singletonInstance;
}
@Override
public List getAnalyzers(Class analyzerType)
throws AnalyzerNotAvailableException {
List found = new LinkedList();
for (Analyzer a : analyzers) {
if (analyzerType.isInstance(a)) {
found.add(analyzerType.cast(a));
}
}
if (found.isEmpty()) {
throw new AnalyzerNotAvailableException();
}
return found;
}
@Override
public void registerAnalyzer(A analyzer) {
analyzers.add(analyzer);
}
@Override
public void log(Class> subject, Level level, String msg, Object... data) {
Logger log = loggers.get(subject);
if (log == null) {
log = Logger.getLogger(subject);
loggers.put(subject, log);
}
switch (level) {
case DEBUG:
if (log.isDebugEnabled()) {
log.debug(String.format(msg, data));
}
break;
case ERROR:
log.error(String.format(msg, data));
break;
case WARN:
log.warn(String.format(msg, data));
break;
case INFO:
if (log.isInfoEnabled()) {
log.info(String.format(msg, data));
}
break;
}
}
/**
* Called by the Configurator
*
* @param analyzer
*/
public void setAnalyzer(Analyzer analyzer) {
Monitor.registerAnalyzer(analyzer);
}
/**
* Specifies where to write the monitoring results to.
*
* @param output
* writer (e.g. FileWriter, StringWriter, ...)
*/
public void setResultWriter(Writer output) {
this.output = new BufferedWriter(output);
}
/**
* @deprecated use the MetricOutputDAO instead!
* @param tableName
*/
public void setTableName(String tableName) {
System.out.println("Table Name is set to: " + tableName);
if (tableName != null && !tableName.equals("")) {
DAO.configOverwrites.put("hibernate.connection.url",
"jdbc:mysql://localhost/" + tableName);
}
}
/*
* FROM HERE ON: deprecated!
*/
private BufferedWriter output = new BufferedWriter(new OutputStreamWriter(
System.out));
private MonitorState state = MonitorState.INIT;
private boolean isMonitoring = false;
protected String experimentDescription = "IS NOT SET";
public final int MONITOR_START = 1;
public final int MONITOR_STOP = 2;
public final int MONITOR_TEST = 3;
public void setStart(long time) {
if (state.equals(MonitorState.STOP_SET)) {
state = MonitorState.READY;
} else if (state.equals(MonitorState.INIT)) {
state = MonitorState.START_SET;
} else {
return;
}
Event.scheduleWithDelay(Time.getCurrentTime() + time, this, null,
MONITOR_START);
Event.scheduleWithDelay(0, this, null, MONITOR_TEST);
Simulator.getInstance().addObserver(this);
}
public void setStop(long time) {
if (state.equals(MonitorState.START_SET)) {
state = MonitorState.READY;
} else if (state.equals(MonitorState.INIT)) {
state = MonitorState.STOP_SET;
} else {
return;
}
Event.scheduleWithDelay(time, this, null, MONITOR_STOP);
}
@Override
public void simulationFinished() {
close();
}
public void setExperimentDescription(String description) {
this.experimentDescription = description;
}
public String getExperimentDescription() {
return experimentDescription;
}
public void close() {
if (this.isMonitoring && analyzers.size() != 0) {
try {
output.write("*******************************************************\n");
output.write("# Monitoring results \n");
output.newLine();
for (Analyzer analyzer : analyzers) {
analyzer.stop(output);
}
output.write("*******************************************************\n");
// output.close();
} catch (IOException e) {
throw new AssertionError();
}
}
this.isMonitoring = false;
}
@Override
public void eventOccurred(Object se, int type) {
if (type == MONITOR_START) {
this.isMonitoring = true;
for (Analyzer analyzer : analyzers) {
analyzer.start();
}
} else if (type == MONITOR_TEST) {
//
} else if (type == MONITOR_STOP) {
this.close();
} else {
throw new AssertionError("Unknown event type.");
}
}
private enum MonitorState {
INIT, START_SET, STOP_SET, READY;
}
}