+ * represents infos of a client, e.g., its id + *
+ * + * @author Patrick Harms + */ +class ClientInfos { + + /** + * id of a client + */ + private String clientId; + + /** + * id of the app the client uses + */ + private String appId; + + /** + *+ * instantiates an infos object with client id and an app id + *
+ * + * @param clientId id of a client + * @param appId id of the app that the client uses + */ + ClientInfos(String clientId, String appId) { + this.clientId = clientId; + this.appId = appId; + } + + /** + * @return the clientId + */ + String getClientId() { + return clientId; + } + + /** + * @return the appId + */ + String getAppId() { + return appId; + } + +} Index: /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/GenericEvent.java =================================================================== --- /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/GenericEvent.java (revision 2155) +++ /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/GenericEvent.java (revision 2155) @@ -0,0 +1,122 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.genericeventmonitor; + +import java.util.Map; + +/** + *+ * represents an event caused by a user on a client. An event contains the infos + * about the client ({@link ClientInfos}, when and where the event took place, the type of + * event and some additional infos such as the event coordinates or the number of the pressed + * key. + *
+ * + * @author Patrick Harms + */ +class GenericEvent { + + /** + * infos about the client that caused the event + */ + private ClientInfos clientInfos; + + /** + * the time stamp of the event + */ + private Long time; + + /** + * the target on which the event was executed + */ + private GenericEventTarget target; + + /** + * the type of the event, e.g. onclick + */ + private String eventType; + + /** + * additional parameters of the event + */ + private Map+ * initializes the event with all relevant infos + *
+ * + * @param clientInfos infos about the client that caused the event + * @param time the time stamp of the event + * @param target the HTML element on which the event was executed + * @param eventType the type of the event + * @param parameters the parameters of the event + */ + GenericEvent(ClientInfos clientInfos, + Long time, + GenericEventTarget target, + String eventType, + Map+ * The generic event monitor starts a web server ({@link GenericEventMonitorServer}) that receives + * events in JSON format. These events are logged using the {@link GenericEventMonitorLogManager}. + * The class assures that on shutdown e.g. caused by CTRL-C the server and the log manager are + * stopped correctly. + *
+ * + * @author Patrick Harms + */ +public class GenericEventMonitor implements GenericEventMonitorComponent { + + /** + * the port on which the webserver shall listen. Defaults to 8090. + */ + private int port = 8090; + + /** + * the web server receiving the log messages + */ + private GenericEventMonitorServer server; + + /** + * the directory into which the log files shall be written + */ + private String logFileBaseDir; + + /** + * the log manager being responsible for performing the logging + */ + private GenericEventMonitorLogManager logManager; + + /** + * the thread needed to handle CTRL-C events + */ + private Thread shutdownHook; + + /** + *+ * initializes the monitor with the command line arguments. Those may be the log directory + * as first argument and the port to listen on as second + *
+ * + * @param commandLineArguments the command line arguments when starting the monitor using + * the {@link Runner} + */ + public GenericEventMonitor(String[] commandLineArguments) { + if (commandLineArguments.length > 0) { + this.logFileBaseDir = commandLineArguments[0]; + Console.println("putting logs into directory " + this.logFileBaseDir); + } + + if (commandLineArguments.length > 1) { + try { + this.port = Integer.parseInt(commandLineArguments[1]); + } + catch (NumberFormatException e) { + Console.println("ignoring invalid port specification " + commandLineArguments[1]); + } + Console.println("listening on port " + this.port); + } + } + + /* (non-Javadoc) + * @see de.ugoe.cs.autoquest.genericeventmonitor.GenericEventMonitorComponent#init() + */ + @Override + public synchronized void init() throws GenericEventMonitorException { + if (server != null) { + throw new IllegalStateException("already initialized."); + } + + try { + logManager = new GenericEventMonitorLogManager(logFileBaseDir); + logManager.init(); + + server = new GenericEventMonitorServer(port, logManager); + server.init(); + + shutdownHook = new Thread(new ShutdownHook(server, logManager)); + } + catch (GenericEventMonitorException e) { + Console.printerrln("could not initialize generic event monitor: " + e); + Console.logException(e); + } + } + + /* (non-Javadoc) + * @see de.ugoe.cs.autoquest.genericeventmonitor.GenericEventMonitorComponent#start() + */ + @Override + public synchronized void start() { + if (server == null) { + throw new IllegalStateException("not initialized."); + } + + try { + Runtime.getRuntime().addShutdownHook(shutdownHook); + logManager.start(); + server.start(); + } + catch (GenericEventMonitorException e) { + Console.printerrln("could not start generic event monitor: " + e); + Console.logException(e); + } + } + + /* (non-Javadoc) + * @see de.ugoe.cs.autoquest.genericeventmonitor.GenericEventMonitorComponent#stop() + */ + @Override + public synchronized void stop() { + if (server == null) { + throw new IllegalStateException("not initialized."); + } + + Runtime.getRuntime().removeShutdownHook(shutdownHook); + server.stop(); + logManager.stop(); + + server = null; + logManager = null; + } + +} Index: /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/GenericEventMonitorComponent.java =================================================================== --- /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/GenericEventMonitorComponent.java (revision 2155) +++ /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/GenericEventMonitorComponent.java (revision 2155) @@ -0,0 +1,56 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.genericeventmonitor; + +/** + *+ * convenience interface for all components making up the generic event monitor. All components + * implement this interface to ensure homogeneity throughout them. A component must first be + * initialized ({@link #init()}), then started ({@link #start()}) and finally stopped + * ({@link #stop()}). + *
+ * + * @author Patrick Harms + */ +interface GenericEventMonitorComponent { + + /** + * initializes a component, i.e. it does everything needed to prepare starting the component + * + * @throws IllegalStateException thrown if the method was already called before but + * {@link #stop()} wasn't called yet + * @throws GenericEventMonitorException thrown if the initialization fails, e.g. because needed + * infos are missing + */ + void init() throws IllegalStateException, GenericEventMonitorException; + + /** + * starts a component + * + * @throws IllegalStateException thrown if {@link #init()} wasn't called yet of if the + * component is already started through a preceding call + * to this method + * @throws GenericEventMonitorException thrown if the startup fails, e.g. because needed infos + * are missing + */ + void start() throws IllegalStateException, GenericEventMonitorException; + + /** + * stops a component and cleans up any derivate. In the following, {@link #init()} must be + * callable again. If the component is not initialized or started, nothing must happen. If the + * component is initialized but not started, the initialization is revoked. + */ + void stop(); +} Index: /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/GenericEventMonitorException.java =================================================================== --- /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/GenericEventMonitorException.java (revision 2155) +++ /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/GenericEventMonitorException.java (revision 2155) @@ -0,0 +1,53 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.genericeventmonitor; + +/** + *+ * Exception to notify all irregularities, that are specific to the generic event monitor and its + * components. + *
+ * + * @author Patrick Harms + */ +class GenericEventMonitorException extends Exception { + + /** */ + private static final long serialVersionUID = 1L; + + /** + *+ * initializes an exception with a simple message + *
+ * + * @param message the message of the exception + */ + GenericEventMonitorException(String message) { + super(message); + } + + /** + *+ * initializes an exception with a simple message and a causing exception + *
+ * + * @param message the message of the exception + * @param cause the root cause of the exception + */ + GenericEventMonitorException(String message, Throwable cause) { + super(message, cause); + } + +} Index: /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/GenericEventMonitorLogManager.java =================================================================== --- /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/GenericEventMonitorLogManager.java (revision 2155) +++ /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/GenericEventMonitorLogManager.java (revision 2155) @@ -0,0 +1,198 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.genericeventmonitor; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Timer; +import java.util.TimerTask; + +import de.ugoe.cs.util.console.Console; + +/** + *+ * The log manager handles different {@link OutputWriter}s to perform the logging + * of recorded events. It initializes a new writer if the first event set for a specific + * client is received and it closes a writer if for a specific period of time no further message + * of the same client was received. The writers themselves consider log rotation. For handling + * messages, the {@link GenericEventMonitorMessageListener} mechanism provided by the + * {@link GenericEventMonitorServer} is used. + *
+ * + * @author Patrick Harms + */ +class GenericEventMonitorLogManager + implements GenericEventMonitorComponent, GenericEventMonitorMessageListener +{ + + /** + * the timeout after which a writer of an inactive client is closed + */ + private static final int SESSION_TIMEOUT = 10 * 60 * 1000; + + /** + * the directory into which the log files shall be written + */ + private String logFileBaseDir; + + /** + * the mapping of client ids to the respective writers. + */ + private Map+ * initializes the log manager with the directory into which the log files shall be stored + *
+ * + * @param logFileBaseDir the directory into which the log files shall be stored + */ + GenericEventMonitorLogManager(String logFileBaseDir) { + this.logFileBaseDir = logFileBaseDir; + } + + /* (non-Javadoc) + * @see de.ugoe.cs.autoquest.genericeventmonitor.GenericEventMonitorComponent#init() + */ + @Override + public synchronized void init() throws IllegalStateException, GenericEventMonitorException { + if (writers != null) { + throw new IllegalStateException("already initialized"); + } + + writers = new HashMap+ * internal timer task used for detecting session timeouts of clients + *
+ * + * @author Patrick Harms + */ + public class LogFileMonitorTimerTask extends TimerTask { + + /* (non-Javadoc) + * @see java.lang.Runnable#run() + */ + @Override + public void run() { + synchronized (GenericEventMonitorLogManager.this) { + List+ * a message listener to be registered with the {@link GenericEventMonitorServer} for being called + * for new messages containing events. + *
+ * + * @author Patrick Harms + */ +public interface GenericEventMonitorMessageListener { + + /** + *
+ * called for new received messages containing events. The client is described through the
+ * clientInfos. The events are several events that were recorded at client side.
+ *
+ * this is the web server, that receives the events. It is initialized with a port on which it + * shall listen, as well as a message listener to forward the received messages to. Internally it + * starts a jetty web server with a single {@link GenericEventMonitorServlet} to receive the + * events. + *
+ * + * @author Patrick Harms + */ +class GenericEventMonitorServer implements GenericEventMonitorComponent { + + /** + * the port to listen on + */ + private int port; + + /** + * the jetty web server used for receiving messages + */ + private Server server; + + /** + * the message listener to forward the messages to + */ + private GenericEventMonitorMessageListener messageListener; + + /** + *+ * initializes the server with the port to listen on and the message listener to forward + * the messages to. + *
+ * + * @param port the port to listen on + * @param messageListener the message listener to forward the messages to + */ + GenericEventMonitorServer(int port, GenericEventMonitorMessageListener messageListener) { + this.port = port; + this.messageListener = messageListener; + } + + /* (non-Javadoc) + * @see de.ugoe.cs.autoquest.genericeventmonitor.GenericEventMonitorComponent#init() + */ + @Override + public synchronized void init() { + if (server != null) { + throw new IllegalStateException("already initialized. First call stop()"); + } + + server = new Server(port); + + /* + // the following code can be used to support SSL directly + server = new Server(); + + SslSocketConnector connector = new SslSocketConnector(); + connector.setPort(port); + connector.setKeystore("data/keystore"); + connector.setPassword("123456"); + connector.setKeyPassword("123456"); + connector.setTruststore("data/keystore"); + connector.setTrustPassword("123456"); + server.addConnector(connector);*/ + + ServletContextHandler root = + new ServletContextHandler(server, "/", ServletContextHandler.SESSIONS); + + GenericEventMonitorServlet servlet = new GenericEventMonitorServlet(messageListener); + ServletHolder servletHolder = new ServletHolder(servlet); + root.addServlet(servletHolder, "/*"); + + CrossOriginFilter filter = new CrossOriginFilter(); + FilterHolder filterHolder = new FilterHolder(filter); + filterHolder.setInitParameter("allowedOrigins", "*"); + filterHolder.setInitParameter("allowedMethods", "GET,POST"); + root.addFilter(filterHolder, "/*", EnumSet.allOf(DispatcherType.class)); + } + + /* (non-Javadoc) + * @see de.ugoe.cs.autoquest.genericeventmonitor.GenericEventMonitorComponent#start() + */ + @Override + public synchronized void start() throws GenericEventMonitorException { + if (server == null) { + throw new IllegalStateException("server not initialized yet. First call init()"); + } + + try { + server.start(); + } + catch (Exception e) { + throw new GenericEventMonitorException("could not start server", e); + } + } + + + /* (non-Javadoc) + * @see de.ugoe.cs.autoquest.genericeventmonitor.GenericEventMonitorComponent#stop() + */ + @Override + public synchronized void stop() { + try { + if (server != null) { + server.stop(); + } + } + catch (Exception e) { + Console.printerrln("could not stop generic event monitor server: " + e.getMessage()); + Console.logException(e); + } + } + +} Index: /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/GenericEventMonitorServlet.java =================================================================== --- /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/GenericEventMonitorServlet.java (revision 2155) +++ /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/GenericEventMonitorServlet.java (revision 2155) @@ -0,0 +1,613 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.genericeventmonitor; + +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.net.MalformedURLException; +import java.net.URL; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import javax.servlet.ServletException; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.eclipse.jetty.servlet.DefaultServlet; +import org.json.simple.JSONArray; +import org.json.simple.JSONObject; +import org.json.simple.JSONValue; +import org.json.simple.parser.ParseException; + +import de.ugoe.cs.util.console.Console; + +/** + *+ * the servlet deployed in the web server that receives all generic events. The messages are parsed, + * validated, and forwarded to the provided message listener. If a message is not valid, it is + * discarded. If an event in a message is not valid, it is discarded. Messages are only received via + * the POST HTTP method. + *
+ * + * @author Patrick Harms + */ +class GenericEventMonitorServlet extends DefaultServlet { + + /** */ + private static final long serialVersionUID = 1L; + + /** must be true to do some detailed logging of what the server does */ + private static final boolean DO_TRACE = false; + + /** + * the map of event target ids to the concrete target objects. + */ + private transient Map+ * initializes the servlet with the message listener to which all events shall be forwarded + *
+ * + * @param messageListener the message listener that shall receive all events + */ + GenericEventMonitorServlet(GenericEventMonitorMessageListener messageListener) { + this.messageListener = messageListener; + } + + /** + * this implements handling of doPost. For this servlet this means that + * the data from the post request will be parsed and validated. + * + * (non-Javadoc) + * @see org.mortbay.jetty.servlet.DefaultServlet#doPost(HttpServletRequest, HttpServletResponse) + */ + @Override + protected void doPost(HttpServletRequest request, HttpServletResponse response) + throws ServletException, IOException + { + Object value = null; + try { + //InputStream requestInputStream = dumpStreamContent(request.getInputStream()); + InputStream requestInputStream = request.getInputStream(); + + value = JSONValue.parseWithException + (new InputStreamReader(requestInputStream, "UTF-8")); + + if (!(value instanceof JSONObject)) { + Console.printerrln("incoming data is not of the expected type --> discarding it"); + } + else { + handleJSONObject((JSONObject) value); + } + } + catch (ParseException e) { + Console.printerrln + ("could not parse incoming data --> discarding it (" + e.toString() + ")"); + } + + // this must be done to prevent firefox from notifying the "element not found" error + response.setContentType("text/plain"); + response.getOutputStream().write(' '); + } + + /** + *+ * processes a received JSON object and validates it. If the message is ok, it is forwarded + * to the message listener + *
+ * + * @param object the JSON object that contains a client message + */ + private void handleJSONObject(JSONObject object) { + if (DO_TRACE) { + dumpJSONObject(object, ""); + } + + JSONObject message = assertValue(object, "message", JSONObject.class); + + if (message == null) { + Console.printerrln("incoming data is no valid message --> discarding it"); + } + else { + ClientInfos clientInfos = extractClientInfos(message); + + if (clientInfos == null) { + Console.printerrln + ("incoming message does not contain valid client infos --> discarding it"); + } + else { + extractGenericEventTargets(message, clientInfos); + GenericEvent[] events = extractGenericEvents(message, clientInfos); + + if (events == null) { + Console.printerrln + ("incoming message does not contain valid events --> discarding it"); + } + else { + messageListener.handleEvents(clientInfos, events); + Console.println + ("handled message of " + clientInfos.getClientId() + " for app " + + clientInfos.getAppId() + " (" + events.length + " events)"); + } + } + } + } + + /** + *+ * tries to extract the client infos out of the received JSON object. If this is not fully + * possible, an appropriate message is dumped and the whole message is discarded (the method + * return null). + *
+ * + * @param message the message to parse the client infos from + * + * @return the client infos, if the message is valid in this respect, or null if not + */ + private ClientInfos extractClientInfos(JSONObject message) { + ClientInfos clientInfos = null; + + JSONObject infos = assertValue(message, "clientInfos", JSONObject.class); + + if (infos != null) { + String clientId = assertValue((JSONObject) infos, "clientId", String.class); + String appId = assertValue((JSONObject) infos, "appId", String.class); + + if (clientId == null) { + Console.printerrln("client infos do not contain a valid client id"); + } + else if (appId == null) { + Console.printerrln("client infos do not contain a valid application id"); + } + else { + clientInfos = new ClientInfos(clientId, appId); + } + } + + return clientInfos; + } + + /** + *+ * tries to extract the events out of the received JSON object. If this is not fully + * possible, an appropriate message is dumped and the errorprone event is discarded. If no + * valid event is found, the whole message is discarded. + *
+ * + * @param object the message to parse the events from + * @param clientInfos the infos about the client that send the events + * + * @return the valid events stored in the message, or null if there are none + */ + private GenericEvent[] extractGenericEvents(JSONObject object, ClientInfos clientInfos) { + List+ * extracts the event target structure from the provided JSON object. + *
+ * + * @param object the JSON object to extract the event target structure from + * @param clientInfos infos about the client who send the data + * + * @return the event target structure extracted from the JSON object of which the root nodes + * are provided + */ + private GenericEventTarget[] extractGenericEventTargets(JSONObject object, + ClientInfos clientInfos) + { + JSONObject[] jsonTargets = assertValue(object, "targetStructure", JSONObject[].class); + + if (jsonTargets != null) { + GenericEventTarget[] result = new GenericEventTarget[jsonTargets.length]; + + for (int i = 0; i < jsonTargets.length; i++) { + result[i] = convert(jsonTargets[i], null); + } + + return result; + } + else { + return null; + } + } + + /** + *+ * converts a JSON object representing a target to the generic target. Calls + * itself recursively to also convert the children of the element, if any. + *
+ * + * @param jsonTarget the JSON object to be converted + * @param parent the parent target of the converted element, or null, if none + * is present. + * + * @return as described. + */ + private GenericEventTarget convert(JSONObject jsonTarget, + GenericEventTarget parent) + { + GenericEventTarget result = null; + + if (jsonTarget != null) { + String targetId = assertValue(jsonTarget, "targetId", String.class); + Map+ * converts a value in the provided object matching the provided key to the provided type. If + * there is no value with the key or if the value can not be transformed to the provided type, + * the method returns null. + *
+ * + * @param object the object to read the value from + * @param key the key of the value + * @param clazz the type to which the value should be transformed + * + * @return the value or null if either the value does not exist or if it can not be transformed + * to the expected type + */ + @SuppressWarnings("unchecked") + private+ * determines other parameters provided in the JSON object. The parameters with the provided + * keys to ignore are not put into the resulting map. + *
+ * + * @param object the object, from which parameters shall be read + * @param ignoredKeys the parameters not to be put into the resulting map + * + * @return a map with the parameters contained in the provided JSON object + */ + private Map+ * convenience method for dumping the content of a stream and returning a new stream + * containing the same data. + *
+ * + * @param inputStream the stream to be dumped and copied + * @return the copy of the stream + * + * @throws IOException if the stream can not be read + */ +/* private InputStream dumpStreamContent(ServletInputStream inputStream) throws IOException { + List+ * convenience method for dumping an object to std out. If the object is a JSON object, it is + * deeply analyzed and its internal structure is dumped as well. + *
+ * + * @param object the object to dump + * @param indent the indentation to be used. + */ + private void dumpJSONObject(Object object, String indent) { + if (object instanceof JSONArray) { + boolean arrayContainsJSONObjects = false; + for (Object arrayElem : (JSONArray) object) { + if (arrayElem instanceof JSONObject) { + arrayContainsJSONObjects = true; + break; + } + } + + if (arrayContainsJSONObjects) { + System.out.println(); + System.out.print(indent); + System.out.println('['); + System.out.print(indent); + System.out.print(' '); + } + else { + System.out.print(' '); + System.out.print('['); + } + + int index = 0; + for (Object arrayElem : (JSONArray) object) { + if (index++ > 0) { + System.out.print(","); + if (arrayContainsJSONObjects) { + System.out.println(); + System.out.print(indent); + } + + System.out.print(' '); + } + + dumpJSONObject(arrayElem, indent + " "); + } + + if (arrayContainsJSONObjects) { + System.out.println(); + System.out.print(indent); + } + + System.out.print(']'); + } + else if (object instanceof JSONObject) { + System.out.println(" {"); + + @SuppressWarnings("unchecked") + Set+ * a generic representation of event target. An event target has an id, optionally a parent or a + * list of children, and parameters. + *
+ * + * @author Patrick Harms + */ +class GenericEventTarget { + + /** the id of the target */ + private String targetId; + + /** the parameters of the target providing further important target details */ + private Map+ * initialized the generic event target with an id, the parameters and a parent if any. All + * parameters may be null. + *
+ * + * @param targetId the id of the target + * @param parameters the parameters to provide further target details + * @param parent if available the parent of the given target + */ + GenericEventTarget(String targetId, + Map+ * used to add a child to this target + *
+ * + * @param child the new child of this event target + */ + synchronized void addChild(GenericEventTarget child) { + if (children == null) { + children = new ArrayList<>(); + } + + this.children.add(child); + } + + /** + * @return the targetId + */ + String getId() { + return targetId; + } + + /** + * @return the parameters + */ + Map+ * dumps messages to a log file belonging to a specific app and client id. In the provided base log + * directory, it creates a subdirectory for the app and a subsubdirectory for the client id. In this + * subsubdirectory it creates appropriate log files. The name of each finished log file starts with + * "genericevents_" followed by the client id and an index of the log file. An unfinished log file + * has no index yet. A log file is finished if + *
+ * initializes the writer with the log file base directory, the id of the client for which + * this writer logs the messages and the id of the app that is used by the client. + *
+ * + * @param logFileBaseDir the log file base directory, or null if the default directory shall + * be taken + * @param appId the ID of the app used by the client + * @param clientId the ID of the client, for which this writer logs + */ + public OutputWriter(String logFileBaseDir, String appId, String clientId) { + if (logFileBaseDir == null) { + this.logFileBaseDir = new File(DEFAULT_LOG_FILE_BASE_DIR); + } + else { + this.logFileBaseDir = new File(logFileBaseDir); + } + + this.appId = appId; + this.clientId = clientId; + + lastUpdate = System.currentTimeMillis(); + } + + /* (non-Javadoc) + * @see de.ugoe.cs.autoquest.genericeventmonitor.GenericEventMonitorComponent#init() + */ + @Override + public synchronized void init() throws GenericEventMonitorException { + if (outputWriter != null) { + throw new IllegalStateException("already initialized. Call close() first"); + } + + synchronized (OutputWriter.class) { + try { + File clientLogDir = new File(new File(logFileBaseDir, appId), clientId); + + if (!clientLogDir.exists()) { + if (!clientLogDir.mkdirs()) { + throw new GenericEventMonitorException("client log file directory " + + clientLogDir + " cannot be created"); + } + } + else if (!clientLogDir.isDirectory()) { + throw new GenericEventMonitorException("client log file directory " + + clientLogDir + " already exists as a file"); + } + + logFile = new File(clientLogDir, getLogFileName(-1)); + + if (logFile.exists()) { + rotateLogFile(); + } + + createLogWriter(); + } + catch (IOException e) { + throw new GenericEventMonitorException("could not open logfile " + logFile, e); + } + } + + lastUpdate = System.currentTimeMillis(); + } + + /** + *+ * used to calculate a log file name. If the provided index is smaller 0, then no index + * is added to the file name. A filename is e.g. "genericevents_12345_001.log". + *
+ * + * @param index the index of the log file or -1 one, if no index shall be added + * + * @return the file name as described + */ + private String getLogFileName(int index) { + String result = "genericevents_" + clientId; + + if (index >= 0) { + result += "_" + new DecimalFormat("000" ).format(index); + } + + result += ".log"; + + return result; + } + + /* (non-Javadoc) + * @see de.ugoe.cs.autoquest.genericeventmonitor.GenericEventMonitorComponent#start() + */ + @Override + public synchronized void start() throws IllegalStateException, GenericEventMonitorException { + lastUpdate = System.currentTimeMillis(); + } + + /* (non-Javadoc) + * @see GenericEventMonitorMessageListener#handleEvents(ClientInfos, GenericEvent[]) + */ + @Override + public void handleEvents(ClientInfos clientInfos, + GenericEvent[] events) + { + if (outputWriter == null) { + throw new IllegalStateException("not initialized. Call init() first"); + } + + for (GenericEvent event : events) { + dumpEvent(event); + } + + outputWriter.flush(); + + try { + considerLogRotate(); + } + catch (IOException e) { + throw new IllegalStateException("could not perform log rotation: " + e, e); + } + + lastUpdate = System.currentTimeMillis(); + } + + /** + *+ * formats a received event and writes it to the log file. One event results in one line + * in the log file containing all infos of the event. + *
+ * + * @param event to be written to the log file + */ + private void dumpEvent(GenericEvent event) { + if (event.getTarget() != null) { + ensureGuiElementDumped(event.getTarget()); + } + + outputWriter.print("+ * ensures that a target element and its corresponding target element tree are logged + *
+ * + * @param target the GUI structure to be logged + */ + private void ensureGuiElementDumped(GenericEventTarget target) { + if (!loggedTargets.contains(target.getId())) { + GenericEventTarget parent = target; + + // get the root + while (parent.getParent() != null) { + parent = parent.getParent(); + } + + dumpTargetStructure(parent); + } + } + + /** + *+ * dumps the target provided by the parameter into the log file. Calls itself + * recursively to traverse the target structure. + *
+ * + * @param target the target structure to be logged + */ + private void dumpTargetStructure(GenericEventTarget target) { + dumpTarget(target); + + if (target.getChildren() != null) { + for (GenericEventTarget child : target.getChildren()) { + dumpTargetStructure(child); + } + } + } + + /** + *+ * dumps the target provided by the parameter into the log file. + *
+ * + * @param guiElement the GUI element to be logged + */ + private void dumpTarget(GenericEventTarget target) { + if (!loggedTargets.contains(target.getId())) { + outputWriter.print("+ * dumps a parameter with the given name and value to the log file. The result is a + * tag named param with a name attribute and a value attribute. The value is transformed + * to a String if it is no String already. Furthermore, an XML entity replacement is performed + * if required. + *
+ * + * @param name the name of the parameter to be dumped + * @param value the value of the parameter to be dumped + */ + private void dumpParam(String name, Object value) { + if (value == null) { + return; + } + + String val; + + if (value instanceof String) { + val = (String) value; + } + else { + val = String.valueOf(value); + } + + outputWriter.print(" "); + } + + /** + *+ * checks, if the log file exceeded the {@link #MAXIMUM_LOG_FILE_SIZE}. If so, the current + * log file is closed, the next log file name is determined and this new file is opened for + * writing. + *
+ */ + private synchronized void considerLogRotate() throws IOException { + if (logFile.length() > MAXIMUM_LOG_FILE_SIZE) { + closeLogWriter(); + rotateLogFile(); + createLogWriter(); + } + } + + /** + *+ * renames the current log file to a new log file with the next available index. It further + * sets the current log file to the default name, i.e. without index. + *
+ */ + private void rotateLogFile() { + File clientLogDir = logFile.getParentFile(); + File checkFile; + + int logFileIndex = -1; + do { + logFileIndex++; + + checkFile = new File(clientLogDir, getLogFileName(logFileIndex)); + } + while (checkFile.exists()); + + if (!logFile.renameTo(checkFile)) { + Console.printerrln("could not rename log file " + logFile + " to " + checkFile + + ". Will not perform log rotation."); + } + else { + logFileIndex++; + logFile = new File(clientLogDir, getLogFileName(-1)); + } + } + + /** + *+ * instantiates a writer to be used for writing messages into the log file. + *
+ */ + private void createLogWriter() throws IOException { + FileOutputStream fis = new FileOutputStream(logFile); + outputWriter = new PrintWriter(new OutputStreamWriter(fis, "UTF-8")); + outputWriter.println(""); + outputWriter.print("+ * parses the POM properties if accessible and returns them. If they are not available, + * unknown is returned. + *
+ */ + private String getMonitorVersion() { + InputStream properties = this.getClass().getClassLoader().getResourceAsStream + ("META-INF/maven/de.ugoe.cs.autoquest/autoquest-generic-event-monitor/pom.properties"); + + if (properties != null) { + try { + StringBuffer result = new StringBuffer(); + BufferedReader reader = new BufferedReader(new InputStreamReader(properties)); + + String line = null; + + do { + line = reader.readLine(); + + if (line != null) { + if (result.length() > 0) { + result.append(" "); + } + + result.append(line); + } + } + while (line != null); + + reader.close(); + return result.toString(); + } + catch (IOException e) { + return "unknown"; + } + } + else { + return "unknown"; + } + } + + /** + *+ * closed the current writer if it is open. + *
+ */ + private void closeLogWriter() { + if (outputWriter != null) { + outputWriter.println("+ * return the time stamp of the last activity that happened on this writer. + *
+ * + * @return as described + */ + public long getLastUpdate() { + return lastUpdate; + } +} Index: /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/Runner.java =================================================================== --- /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/Runner.java (revision 2155) +++ /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/Runner.java (revision 2155) @@ -0,0 +1,51 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.genericeventmonitor; + +import de.ugoe.cs.util.console.Console; +import de.ugoe.cs.util.console.TextConsole; + +/** + *+ * implements the main method to start the {@link GenericEventMonitor}. + *
+ * + * @author Patrick Harms + * @version 1.0 + */ +public class Runner { + + /** + *+ * Main method of the application. + *
+ * + * @param args command line arguments + */ + public static void main(String[] args) { + new TextConsole(); + + GenericEventMonitor monitor = new GenericEventMonitor(args); + try { + monitor.init(); + } + catch (GenericEventMonitorException e) { + Console.printerrln("could not initialize generic event monitor: " + e.getMessage()); + Console.logException(e); + } + + monitor.start(); + } +} Index: /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/ShutdownHook.java =================================================================== --- /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/ShutdownHook.java (revision 2155) +++ /trunk/autoquest-generic-event-monitor/src/main/java/de/ugoe/cs/autoquest/genericeventmonitor/ShutdownHook.java (revision 2155) @@ -0,0 +1,60 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.genericeventmonitor; + +/** + *+ * used to be able to shut down any {@link GenericEventMonitorComponent} that must be stopped if the + * application stops. + *
+ * + * @author Patrick Harms + */ +public class ShutdownHook implements Runnable { + + /** + * the components to be stopped on shutdown + */ + private GenericEventMonitorComponent[] components; + + /** + *+ * initializes the shutdown hook with the components to be shut down on shutdown of the whole + * application + *
+ * + */ + public ShutdownHook(GenericEventMonitorComponent... components) { + this.components = components; + } + + /* (non-Javadoc) + * @see java.lang.Thread#run() + */ + @Override + public void run() { + for (GenericEventMonitorComponent component : components) { + if (component != null) { + try { + component.stop(); + } + catch (Exception e) { + // ignore and go on + } + } + } + } + +}