();
+
+ /**
+ *
+ * Constructor. Creates a new message with a given message type.
+ *
+ *
+ * @param type
+ * type of the message
+ */
+ public WindowsMessage(int type) {
+ this.type = type;
+ }
+
+ /**
+ *
+ * Adds a parameter to the message.
+ *
+ *
+ * @param type
+ * type descriptor of the parameter
+ * @param value
+ * value of the parameter
+ */
+ public void addParameter(String type, String value) {
+ params.put(type, value);
+ if (type.equals("LPARAM")) {
+ LPARAM = Long.parseLong(value);
+ } else if (type.equals("WPARAM")) {
+ WPARAM = Long.parseLong(value);
+ }
+ }
+
+ /**
+ *
+ * Returns the type of the message.
+ *
+ *
+ * @return type of the message
+ */
+ public int getType() {
+ return type;
+ }
+
+ /**
+ *
+ * Returns the value of a parameter, given its type. If the parameter is not
+ * found, {@code null} is returned.
+ *
+ *
+ * @param type
+ * type of the parameter
+ * @return value of the parameter
+ */
+ public String getParameter(String type) {
+ return params.get(type);
+ }
+
+ /**
+ *
+ * Returns the window class of the message target.
+ *
+ *
+ * @return window class of the message target
+ */
+ public String getWindowClass() {
+ return windowClass;
+ }
+
+ /**
+ *
+ * Returns the HWND the message is addressed to.
+ *
+ *
+ * @return HWND the message is addressed to
+ */
+ public int getHwnd() {
+ int hwnd = -1;
+ String hwndString = getParameter("window.hwnd"); // possible, as
+ // "window.hwnd" is
+ // mandatory
+ if (hwndString != null) {
+ hwnd = Integer.parseInt(hwndString);
+ }
+ return hwnd;
+ }
+
+ /**
+ *
+ * Returns the resource Id of the message target.
+ *
+ *
+ * @return resource Id of the message target
+ */
+ public int getWindowResourceId() {
+ return resourceId;
+ }
+
+ /**
+ *
+ * Two {@link WindowsMessage} are equal, if their {@link #type},
+ * {@link #xmlWindowDescription}, and {@link #params} are equal.
+ *
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object other) {
+ if (other == this) {
+ return true;
+ }
+ boolean isEqual = false;
+ if (other instanceof WindowsMessage) {
+ isEqual = ((WindowsMessage) other).type == this.type
+ && ((WindowsMessage) other).xmlWindowDescription
+ .equals(this.xmlWindowDescription)
+ && ((WindowsMessage) other).params.equals(this.params);
+ }
+ return isEqual;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ int multiplier = 17;
+ int hash = 42;
+
+ hash = multiplier * hash + type;
+ hash = multiplier * hash + xmlWindowDescription.hashCode();
+ hash = multiplier * hash + params.hashCode();
+
+ return hash;
+ }
+
+ /**
+ *
+ * Returns a string representation of the message of the form
+ * "msg[target=HWND;type=TYPE]".
+ *
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return "msg[target=" + getParameter("window.hwnd") + ";type=" + type
+ + "]";
+ }
+
+ /**
+ *
+ * Retrieves the target string of a message from a given {@link WindowTree}
+ * through looking up the HWND the message is addressed to in the window
+ * tree.
+ *
+ *
+ * @param windowTree
+ * {@link WindowTree} from which the target is extracted
+ * @throws InvalidParameterException
+ * thrown if HWND is not contained in windowTree
+ */
+ public void setTarget(WindowTree windowTree)
+ throws InvalidParameterException {
+ int hwnd = Integer.parseInt(getParameter("window.hwnd"));
+ WindowTreeNode node = windowTree.find(hwnd);
+ if (node == null) {
+ throw new InvalidParameterException("No window with HWND " + hwnd
+ + " found in window tree!");
+ } else {
+ windowClass = node.getClassName();
+ resourceId = node.getResourceId();
+ xmlWindowDescription = node.xmlRepresentation();
+ parentNames = node.getParentNames();
+ WindowTreeNode parent = node.getParent();
+ if (parent == null) {
+ parentClass = "";
+ } else {
+ parentClass = parent.getClassName();
+ }
+ }
+ }
+
+ /**
+ *
+ * Sets the LPARAM of a message.
+ *
+ *
+ * @param paramValue
+ * value of the LPARAM
+ */
+ public void setLPARAM(long paramValue) {
+ LPARAM = paramValue;
+ }
+
+ /**
+ *
+ * Sets the WPARAM of a message.
+ *
+ *
+ * @param paramValue
+ * value of the WPARAM
+ */
+ public void setWPARAM(long paramValue) {
+ WPARAM = paramValue;
+ }
+
+ /**
+ *
+ * Returns the LPARAM of a message.
+ *
+ *
+ * @return LPARAM of the message
+ */
+ public long getLPARAM() {
+ return LPARAM;
+ }
+
+ /**
+ *
+ * Returns the WPARAM of a message.
+ *
+ *
+ * @return WPARAM of the message
+ */
+ public long getWPARAM() {
+ return WPARAM;
+ }
+
+ /**
+ *
+ * If the LPARAM contains a HWND, this function can be used to set a target
+ * string to identify the HWND at run-time.
+ *
+ *
+ * @param windowDesc
+ * target string
+ */
+ public void setLPARAMasWindowDesc(String windowDesc) {
+ LPARAMasWindowDesc = windowDesc;
+ }
+
+ /**
+ *
+ * If the WPARAM contains a HWND, this function can be used to set a target
+ * string to identify the HWND at run-time.
+ *
+ *
+ * @param windowDesc
+ * target string
+ */
+ public void setWPARAMasWindowDesc(String windowDesc) {
+ WPARAMasWindowDesc = windowDesc;
+ }
+
+ /**
+ *
+ * If the LPARAM contains a HWND and the target string for the HWND is set,
+ * this function returns the target string. Otherwise, {@code null} is
+ * returned.
+ *
+ *
+ * @return target string if available; {@code null} otherwise
+ */
+ public String getLPARAMasWindowDesc() {
+ return LPARAMasWindowDesc;
+ }
+
+ /**
+ *
+ * If the WPARAM contains a HWND and the target string for the HWND is set,
+ * this function returns the target string. Otherwise, {@code null} is
+ * returned.
+ *
+ *
+ * @return target string if available; {@code null} otherwise
+ */
+ public String getWPARAMasWindowDesc() {
+ return WPARAMasWindowDesc;
+ }
+
+ /**
+ *
+ * Returns the target string of the message.
+ *
+ *
+ * @return target string of the message
+ */
+ public String getXmlWindowDescription() {
+ return xmlWindowDescription;
+ }
+
+ /**
+ *
+ * Sets the target string manually.
+ *
+ *
+ * @param xmlWindowDescription
+ * target string
+ */
+ public void setXmlWindowDescription(String xmlWindowDescription) {
+ this.xmlWindowDescription = xmlWindowDescription;
+ }
+
+ /**
+ *
+ * Returns the delay after this message during replays.
+ *
+ *
+ * @return delay after this message
+ */
+ public int getDelay() {
+ return delay;
+ }
+
+ /**
+ *
+ * Sets the delay after this message during replays.
+ *
+ *
+ * @param delay
+ * delay after this message
+ */
+ public void setDelay(int delay) {
+ this.delay = delay;
+ }
+
+ /**
+ *
+ * Returns the parent names separated by dots, e.g., "GrandParent.Parent".
+ *
+ *
+ * @return names of the parents
+ */
+ public String getParentNames() {
+ return parentNames;
+ }
+
+ /**
+ *
+ * Returns the window class of the parent.
+ *
+ *
+ * @return window classes of the parents
+ */
+ public String getParentClass() {
+ return parentClass;
+ }
+
+ /**
+ *
+ * Returns the number of parameters stored together with this message.
+ *
+ *
+ * @return number of parameters stored with this message
+ */
+ public int getNumParams() {
+ return params.size();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.quest.eventcore.IReplayable#getReplay()
+ */
+ @Override
+ public String getReplay() {
+ StringBuilder currentMsgStr = new StringBuilder(400);
+ currentMsgStr.append(" ");
+ if (LPARAMasWindowDesc != null) {
+ currentMsgStr.append(StringTools.ENDLINE);
+ currentMsgStr.append(" ");
+ currentMsgStr.append(StringTools.ENDLINE);
+ currentMsgStr.append(LPARAMasWindowDesc);
+ currentMsgStr.append(StringTools.ENDLINE);
+ currentMsgStr.append(" ");
+ }
+ if (WPARAMasWindowDesc != null) {
+ currentMsgStr.append(StringTools.ENDLINE);
+ currentMsgStr.append(" ");
+ currentMsgStr.append(StringTools.ENDLINE);
+ currentMsgStr.append(WPARAMasWindowDesc);
+ currentMsgStr.append(StringTools.ENDLINE);
+ currentMsgStr.append(" ");
+ }
+ currentMsgStr.append(StringTools.ENDLINE);
+ currentMsgStr.append(xmlWindowDescription);
+ currentMsgStr.append(StringTools.ENDLINE);
+ currentMsgStr.append(" ");
+ currentMsgStr.append(StringTools.ENDLINE);
+ return currentMsgStr.toString();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.quest.eventcore.IReplayable#getTarget()
+ */
+ @Override
+ public String getTarget() {
+ return xmlWindowDescription;
+ }
+}
Index: trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/plugin/php/WeblogParser.java
===================================================================
--- trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/plugin/php/WeblogParser.java (revision 488)
+++ trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/plugin/php/WeblogParser.java (revision 488)
@@ -0,0 +1,497 @@
+package de.ugoe.cs.quest.plugin.php;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import de.ugoe.cs.quest.plugin.php.eventcore.WebEvent;
+import de.ugoe.cs.util.FileTools;
+import de.ugoe.cs.util.console.Console;
+
+/**
+ *
+ * Provides functionality to parse log files with web request.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class WeblogParser {
+
+ /**
+ *
+ * Timeout between two sessions in milliseconds.
+ *
+ */
+ private long timeout;
+
+ /**
+ *
+ * Minimal length of a session. All shorter sessions will be pruned.
+ */
+ private int minLength = 2;
+
+ /**
+ *
+ * Maximal length of a session. All longer sessions will be pruned.
+ */
+ private int maxLength = 100;
+
+ /**
+ *
+ * URL of the server that generated the log that is currently parser; null
+ * of URL is not available.
+ */
+ private String url = null;
+
+ /**
+ *
+ * Collection of generated sequences.
+ *
+ */
+ private List> sequences;
+
+ /**
+ *
+ * List that stores the users (identified through their cookie id) to each
+ * sequence.
+ *
+ */
+ private List users;
+
+ /**
+ *
+ * List that stores the frequent users (identified through their cookie id)
+ * to each sequence.
+ *
+ */
+ private List frequentUsers;
+
+ /**
+ *
+ * Sequences for all frequent users.
+ *
+ */
+ private List>> sequencesFrequentUsers;
+
+ /**
+ *
+ * Threshold that defines how many sessions of a user are require to deem
+ * the user frequent. Note, that only sessions whose lengths is in range if
+ * {@link #minLength} and {@link #maxLength} are counted.
+ *
+ */
+ private int frequentUsersThreshold = -1;
+
+ /**
+ *
+ * Name and path of the robot filter.
+ *
+ */
+ private static final String ROBOTFILTERFILE = "misc/robotfilter.txt";
+
+ /**
+ *
+ * Field that contains a regular expression that matches all robots
+ * contained in {@link #ROBOTFILTERFILE}.
+ *
+ */
+ private String robotRegex = null;
+
+ /**
+ *
+ * Constructor. Creates a new WeblogParser with a default timeout of
+ * 3,600,000 milliseconds (1 hour).
+ *
+ */
+ public WeblogParser() {
+ this(3600000);
+ }
+
+ /**
+ *
+ * Constructor. Creates a new WeblogParser.
+ *
+ *
+ * @param timeout
+ * session timeout
+ */
+ public WeblogParser(long timeout) {
+ this.timeout = timeout;
+ }
+
+ /**
+ *
+ * Returns the generated event sequences.
+ *
+ *
+ * @return generated event sequences
+ */
+ public Collection> getSequences() {
+ return sequences;
+ }
+
+ /**
+ *
+ * Sets the session timeout.
+ *
+ *
+ * @param timeout
+ * new session timeout
+ */
+ public void setTimeout(long timeout) {
+ this.timeout = timeout;
+ }
+
+ /**
+ *
+ * Sets the minimal length of a session. All sessions that contain less
+ * events will be pruned.
+ *
+ *
+ * @param minLength
+ * new minimal length
+ */
+ public void setMinLength(int minLength) {
+ this.minLength = minLength;
+ }
+
+ /**
+ *
+ * Sets the maximal length of a session. All sessions that contain more
+ * events will be pruned.
+ *
+ *
+ * @param maxLength
+ * new maximal length
+ */
+ public void setMaxLength(int maxLength) {
+ this.maxLength = maxLength;
+ }
+
+ /**
+ *
+ * Sets the URL of the server from which this log was generated. Often
+ * required for replay generation
+ *
+ *
+ * @param url
+ * URL of the server
+ */
+ public void setUrl(String url) {
+ this.url = url;
+ }
+
+ /**
+ *
+ * Sets the threshold for frequent users.
+ *
+ *
+ * @param threshold
+ * threshold value; if the value is <1, the sessions of the
+ * frequent users will not be determined
+ */
+ public void setFrequentUserThreshold(int threshold) {
+ this.frequentUsersThreshold = threshold;
+ }
+
+ /**
+ *
+ * Returns the IDs of all frequent users.
+ *
+ *
+ * @return IDs of the frequent users
+ */
+ public List getFrequentUsers() {
+ return frequentUsers;
+ }
+
+ /**
+ *
+ * Returns the sequences of all frequent users.
+ *
+ *
+ *
+ * @return list of the sequences of all frequent users
+ */
+ public List>> getFrequentUserSequences() {
+ return sequencesFrequentUsers;
+ }
+
+ /**
+ *
+ * Parses a web log file.
+ *
+ *
+ * @param filename
+ * name and path of the log file
+ * @throws IOException
+ * thrown if there is a problem with reading the log file
+ * @throws FileNotFoundException
+ * thrown if the log file is not found
+ * @throws ParseException
+ * thrown the date format is invalid
+ */
+ public void parseFile(String filename) throws IOException,
+ FileNotFoundException, ParseException {
+ String[] lines = FileTools.getLinesFromFile(filename);
+
+ Map> cookieSessionMap = new HashMap>();
+ int lastId = -1;
+
+ SimpleDateFormat dateFormat = new SimpleDateFormat(
+ "yyyy-MM-dd HH:mm:ss");
+ loadRobotRegex();
+
+ sequences = new ArrayList>();
+ users = new ArrayList();
+
+ int lineCounter = 0;
+ for (String line : lines) {
+ lineCounter++;
+ String[] values = line.substring(1, line.length() - 1).split(
+ "\" \"");
+
+ // use cookie as session identifier
+ int cookieStart = values[0].lastIndexOf('.');
+ String cookie = values[0].substring(cookieStart + 1);
+ String dateString = values[1];
+ long timestamp = dateFormat.parse(dateString).getTime();
+ String uriString = values[2];
+ // String ref = values[3]; // referer is not yet used!
+ String agent;
+ if (values.length > 4) {
+ agent = values[4];
+ } else {
+ agent = "noagent";
+ }
+
+ List postedVars = new ArrayList();
+ if (values.length == 6) { // post vars found
+ for (String postVar : values[5].trim().split(" ")) {
+ if (!isBrokenVariable(postVar)) {
+ postedVars.add(postVar);
+ }
+ }
+ }
+ if (!isRobot(agent)) {
+ try {
+ URI uri = new URI(uriString);
+ String path = uri.getPath();
+ List getVars = extractGetVarsFromUri(uri);
+
+ WebEvent event = new WebEvent(url, path, timestamp,
+ postedVars, getVars);
+
+ // find session and add event
+ List sessionIds = cookieSessionMap.get(cookie);
+ if (sessionIds == null) {
+ sessionIds = new ArrayList();
+ // start new session
+ sessionIds.add(++lastId);
+ cookieSessionMap.put(cookie, sessionIds);
+ sequences.add(new LinkedList());
+ users.add(cookie);
+ }
+ Integer lastSessionIndex = sessionIds
+ .get(sessionIds.size() - 1);
+ List lastSession = sequences
+ .get(lastSessionIndex);
+ long lastEventTime = timestamp;
+ if (!lastSession.isEmpty()) {
+ lastEventTime = lastSession.get(lastSession.size() - 1)
+ .getTimestamp();
+ }
+ if (timestamp - lastEventTime > timeout) {
+ sessionIds.add(++lastId);
+ List newSession = new LinkedList();
+ newSession.add(event);
+ sequences.add(newSession);
+ users.add(cookie);
+ } else {
+ lastSession.add(event);
+ }
+ } catch (URISyntaxException e) {
+ Console.traceln("Ignored line " + lineCounter + ": "
+ + e.getMessage());
+ }
+ }
+ }
+ Console.traceln("" + sequences.size() + " user sequences found");
+ pruneSequences();
+ Console.traceln("" + sequences.size()
+ + " remaining after pruning of sequences shorter than "
+ + minLength);
+ Set uniqueUsers = new HashSet(users);
+ Console.traceln("" + uniqueUsers.size() + " unique users");
+ if (frequentUsersThreshold > 0) {
+ generateFrequentUserSequences(uniqueUsers);
+ }
+ }
+
+ /**
+ *
+ * Generates the frequent user sequences, according to the threshold
+ * {@link #frequentUsersThreshold}.
+ *
+ *
+ * @param uniqueUsers
+ * set with all user IDs
+ */
+ private void generateFrequentUserSequences(Set uniqueUsers) {
+ frequentUsers = new ArrayList();
+ sequencesFrequentUsers = new ArrayList>>();
+ for (String user : uniqueUsers) {
+ List tmp = new ArrayList();
+ tmp.add(user);
+ List usersCopy = new LinkedList(users);
+ usersCopy.retainAll(tmp);
+ int size = usersCopy.size();
+ if (size >= frequentUsersThreshold) {
+ frequentUsers.add(user);
+ Collection> sequencesUser = new ArrayList>();
+ for (int i = 0; i < sequences.size(); i++) {
+ if (users.get(i).equals(user)) {
+ sequencesUser.add(sequences.get(i));
+ }
+ }
+ sequencesFrequentUsers.add(sequencesUser);
+
+ }
+ }
+ Console.traceln("" + frequentUsers.size() + " users with more than "
+ + frequentUsersThreshold + " sequences");
+ }
+
+ /**
+ *
+ * Prunes sequences shorter than {@link #minLength} and longer than
+ * {@link #maxLength}.
+ *
+ */
+ private void pruneSequences() {
+ int i = 0;
+ while (i < sequences.size()) {
+ if ((sequences.get(i).size() < minLength)
+ || sequences.get(i).size() > maxLength) {
+ sequences.remove(i);
+ users.remove(i);
+ } else {
+ i++;
+ }
+ }
+
+ }
+
+ /**
+ *
+ * Reads {@link #ROBOTFILTERFILE} and creates a regular expression that
+ * matches all the robots defined in the file. The regular expression is
+ * stored in the field {@link #robotRegex}.
+ *
+ *
+ * @throws IOException
+ * thrown if there is a problem reading the robot filter
+ * @throws FileNotFoundException
+ * thrown if the robot filter is not found
+ */
+ private void loadRobotRegex() throws IOException, FileNotFoundException {
+ String[] lines = FileTools.getLinesFromFile(ROBOTFILTERFILE);
+ StringBuilder regex = new StringBuilder();
+ for (int i = 0; i < lines.length; i++) {
+ regex.append("(.*" + lines[i] + ".*)");
+ if (i != lines.length - 1) {
+ regex.append('|');
+ }
+ }
+ robotRegex = regex.toString();
+ }
+
+ /**
+ *
+ * Checks whether an agent is a robot.
+ *
+ *
+ * @param agent
+ * agent that is checked
+ * @return true, if the agent is a robot; false otherwise
+ */
+ private boolean isRobot(String agent) {
+ return agent.matches(robotRegex);
+ }
+
+ /**
+ *
+ * Parses the URI and extracts the GET variables that have been passed.
+ *
+ *
+ * @param uri
+ * URI that is parsed
+ * @return a list with all GET variables
+ * @throws URISyntaxException
+ * thrown if one of the variables seems to indicate that the
+ * request is a malicious attack on the web application
+ */
+ private List extractGetVarsFromUri(URI uri)
+ throws URISyntaxException {
+ List getVars = new ArrayList();
+ String query = uri.getQuery();
+ if (query != null) {
+ String[] paramPairs = query.split("&");
+ for (String paramPair : paramPairs) {
+ String[] paramSplit = paramPair.split("=");
+ if (!isBrokenVariable(paramSplit[0])) {
+ for (int i = 1; i < paramSplit.length; i++) {
+ checkForAttack(paramSplit[i]);
+ }
+ getVars.add(paramSplit[0]);
+ }
+ }
+ }
+ return getVars;
+ }
+
+ /**
+ *
+ * Checks if a variable is broken.Currently, the check rather imprecise and
+ * checks only if the term "and" is part of the variable name.
+ *
+ *
+ * @param var
+ * variable that is checked
+ * @return true if the variable is broken, false otherwise
+ */
+ private boolean isBrokenVariable(String var) {
+ return var.contains("and");
+ }
+
+ /**
+ *
+ * Checks if the variable name send with a request seems like an attack on the server.
+ *
+ * @param value
+ * @throws URISyntaxException
+ */
+ private void checkForAttack(String value) throws URISyntaxException {
+ if (value.contains("UNION+") || value.contains("SELECT+")) {
+ throw new URISyntaxException(value, "possible injection attack");
+ }
+ }
+}
Index: trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/plugin/php/commands/CMDloadWebSequences.java
===================================================================
--- trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/plugin/php/commands/CMDloadWebSequences.java (revision 488)
+++ trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/plugin/php/commands/CMDloadWebSequences.java (revision 488)
@@ -0,0 +1,117 @@
+package de.ugoe.cs.quest.plugin.php.commands;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.security.InvalidParameterException;
+import java.text.ParseException;
+import java.util.Collection;
+import java.util.List;
+
+import de.ugoe.cs.quest.CommandHelpers;
+import de.ugoe.cs.quest.plugin.php.WeblogParser;
+import de.ugoe.cs.quest.plugin.php.eventcore.WebEvent;
+import de.ugoe.cs.quest.ui.GlobalDataContainer;
+import de.ugoe.cs.util.console.Command;
+import de.ugoe.cs.util.console.Console;
+
+/**
+ *
+ * Command to load sessions from a web log.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class CMDloadWebSequences implements Command {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.util.console.Command#run(java.util.List)
+ */
+ @Override
+ public void run(List parameters) {
+ if (parameters.size() < 1) {
+ throw new InvalidParameterException();
+ }
+ String source;
+ String sequencesName;
+ String serverUrl = null;
+ int timeout = -1;
+ int minLength = -1;
+ int maxLength = -1;
+ boolean generateFrequentUsers = false;
+ int frequentUserThreshold = 20;
+ try {
+ source = (String) parameters.get(0);
+ sequencesName = (String) parameters.get(1);
+ if (parameters.size() >= 3) {
+ serverUrl = (String) parameters.get(2);
+ }
+ if (parameters.size() >= 6) {
+ timeout = Integer.parseInt((String) parameters.get(3));
+ minLength = Integer.parseInt((String) parameters.get(4));
+ maxLength = Integer.parseInt((String) parameters.get(5));
+ }
+ if (parameters.size() >= 8) {
+ generateFrequentUsers = Boolean
+ .parseBoolean((String) parameters.get(6));
+ frequentUserThreshold = Integer.parseInt((String) parameters
+ .get(7));
+ }
+ } catch (Exception e) {
+ throw new InvalidParameterException();
+ }
+
+ WeblogParser parser = new WeblogParser();
+ if (serverUrl != null) {
+ parser.setUrl(serverUrl);
+ }
+ if (timeout != -1) {
+ parser.setTimeout(timeout);
+ parser.setMinLength(minLength);
+ parser.setMaxLength(maxLength);
+ }
+ if (generateFrequentUsers) {
+ parser.setFrequentUserThreshold(frequentUserThreshold);
+ }
+ try {
+ parser.parseFile(source);
+ } catch (FileNotFoundException e) {
+ Console.printerrln(e.getMessage());
+ } catch (IOException e) {
+ Console.printerrln(e.getMessage());
+ } catch (ParseException e) {
+ Console.printerrln("Invalid format of date stamps.");
+ Console.printerrln(e.getMessage());
+ }
+
+ if (GlobalDataContainer.getInstance().addData(sequencesName,
+ parser.getSequences())) {
+ CommandHelpers.dataOverwritten(sequencesName);
+ }
+ if (generateFrequentUsers) {
+ List frequentUserIDs = parser.getFrequentUsers();
+ List>> frequentUserSessions = parser
+ .getFrequentUserSequences();
+ for (int i = 0; i < frequentUserIDs.size(); i++) {
+ String seqName = sequencesName + "_" + frequentUserIDs.get(i);
+ if (GlobalDataContainer.getInstance().addData(seqName,
+ frequentUserSessions.get(i))) {
+ CommandHelpers.dataOverwritten(seqName);
+ }
+ }
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.util.console.Command#help()
+ */
+ @Override
+ public void help() {
+ Console.println("Usage: loadWebSequences {} { } { }");
+ }
+
+}
Index: trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/plugin/php/eventcore/WebEvent.java
===================================================================
--- trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/plugin/php/eventcore/WebEvent.java (revision 488)
+++ trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/plugin/php/eventcore/WebEvent.java (revision 488)
@@ -0,0 +1,108 @@
+package de.ugoe.cs.quest.plugin.php.eventcore;
+
+import java.util.List;
+
+import de.ugoe.cs.quest.eventcore.ReplayableEvent;
+
+/**
+ *
+ * This class defines web events (of PHP-based web applications).
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ *
+ */
+public class WebEvent extends ReplayableEvent {
+
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * Timestamp of the event.
+ *
+ */
+ private final long timestamp;
+
+ /**
+ *
+ * Helper method that generates the type of the event based on the of the
+ * URI, the POST variables, and the GET variables.
+ *
+ *
+ * @param path
+ * path of the URI of the event
+ * @param postVars
+ * POST variables send with the event
+ * @param getVars
+ * GET variables send with the event
+ * @return type of the event
+ */
+ private final static String makeType(String path, List postVars,
+ List getVars) {
+ String type = path;
+ if (getVars != null && !getVars.isEmpty()) {
+ type += "+GET" + getVars.toString().replace(" ", "");
+ }
+ if (postVars != null && !postVars.isEmpty()) {
+ type += "+POST" + postVars.toString().replace(" ", "");
+ }
+ return type;
+ }
+
+ /**
+ *
+ * Constructor. Creates a new WebEvent.
+ *
+ *
+ * @param url
+ * URL of the server that received the event
+ * @param path
+ * path of the URI
+ * @param timestamp
+ * timestamp of when the event took place
+ * @param postVars
+ * POST variables send with the event
+ * @param getVars
+ * GET variables send with the event
+ */
+ public WebEvent(String url, String path, long timestamp,
+ List postVars, List getVars) {
+ super(makeType(path, postVars, getVars));
+ this.timestamp = timestamp;
+ super.setTarget(path);
+ addReplayEvent(new WebRequest(url, path, postVars, getVars));
+ }
+
+ /**
+ *
+ * Returns the timestamp of the event.
+ *
+ *
+ * @return timestamp of th event
+ */
+ public long getTimestamp() {
+ return timestamp;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.quest.eventcore.ReplayableEvent#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object other) {
+ return super.equals(other);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.quest.eventcore.ReplayableEvent#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return super.hashCode();
+ }
+
+}
Index: trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/plugin/php/eventcore/WebRequest.java
===================================================================
--- trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/plugin/php/eventcore/WebRequest.java (revision 488)
+++ trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/plugin/php/eventcore/WebRequest.java (revision 488)
@@ -0,0 +1,172 @@
+package de.ugoe.cs.quest.plugin.php.eventcore;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import de.ugoe.cs.quest.eventcore.IReplayable;
+
+/**
+ *
+ * Contains all information related to a web request, i.e., the path, the POST
+ * variables and the GET variables. The generated replay are for the command
+ * line tool {@code curl}. The requests do not contain correct values for the
+ * POST and GET request. Instead, only the parameters that are part of the
+ * requests are added and the values of the parameters are
+ * DATA_$PARAMNAME$_DATA, where $PARAMNAME$ is the upper case string of the
+ * parameter name. This allows test data generators to insert concrete values,
+ * as EventBench does not include a test data generator for web software.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class WebRequest implements IReplayable {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * POST variables of the web request.
+ *
+ */
+ List postVars;
+
+ /**
+ *
+ * GET variables of the web request.
+ *
+ */
+ List getVars;
+
+ /**
+ *
+ * URI of the web request.
+ *
+ */
+ String targetUri;
+
+ /**
+ *
+ * URL of the server.
+ *
+ */
+ String serverUrl;
+
+ /**
+ *
+ * Constructor. Creates a new WebRequest.
+ *
+ *
+ * @param uri
+ * URI of the request
+ * @param postVars
+ * POST variables of the request
+ * @param getVars
+ * GET variables of the request
+ */
+ public WebRequest(String url, String uri, List postVars,
+ List getVars) {
+ serverUrl = url;
+ targetUri = uri;
+ this.postVars = new ArrayList(postVars); // defensive copy
+ this.getVars = new ArrayList(getVars);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.quest.eventcore.IReplayable#getReplay()
+ */
+ @Override
+ public String getReplay() {
+ StringBuilder builder = new StringBuilder();
+ builder.append("curl");
+ if (!postVars.isEmpty()) {
+ boolean isFirstPost = true;
+ for (String postVar : postVars) {
+ if (isFirstPost) {
+ builder.append(" --data \"");
+ isFirstPost = false;
+ } else {
+ builder.append('&');
+ }
+ builder.append(postVar + "=DATA_" + postVar.toUpperCase()
+ + "_DATA");
+ }
+ builder.append('\"');
+ }
+ builder.append(' ');
+ if (serverUrl != null) {
+ builder.append(serverUrl);
+ }
+ builder.append(targetUri);
+ if (!getVars.isEmpty()) {
+ boolean isFirstGet = true;
+ for (String getVar : getVars) {
+ if (isFirstGet) {
+ builder.append('?');
+ isFirstGet = false;
+ } else {
+ builder.append('&');
+ }
+ builder.append(getVar + "=DATA_" + getVar.toUpperCase()
+ + "_DATA");
+ }
+ }
+ return builder.toString();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.quest.eventcore.IReplayable#getTarget()
+ */
+ @Override
+ public String getTarget() {
+ return targetUri;
+ }
+
+ /**
+ *
+ * Two {@link WebRequest}s are equal, if their {@link #targetUri},
+ * {@link #postVars}, and {@link #getVars} are equal.
+ *
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object other) {
+ if (this == other) {
+ return true;
+ }
+ if (other instanceof WebRequest) {
+ return targetUri.equals(((WebRequest) other).targetUri)
+ && postVars.equals(((WebRequest) other).postVars)
+ && getVars.equals(((WebRequest) other).getVars);
+ }
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ int multiplier = 17;
+ int hash = 42;
+
+ hash = multiplier * hash + targetUri.hashCode();
+ hash = multiplier * hash + postVars.hashCode();
+ hash = multiplier * hash + getVars.hashCode();
+
+ return hash;
+ }
+
+}
Index: trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/ui/GlobalDataContainer.java
===================================================================
--- trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/ui/GlobalDataContainer.java (revision 488)
+++ trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/ui/GlobalDataContainer.java (revision 488)
@@ -0,0 +1,226 @@
+package de.ugoe.cs.quest.ui;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import de.ugoe.cs.quest.SequenceInstanceOf;
+import de.ugoe.cs.quest.usageprofiles.IStochasticProcess;
+
+/**
+ *
+ * This data structure can be used by the commands to store any {@link Object}.
+ * The data is stored in a key-value map, with strings as keys.
+ *
+ *
+ * This class is implemented as a singleton, as more than one data container
+ * does not serves no purpose.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class GlobalDataContainer implements Serializable {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * Instance of the {@link GlobalDataContainer} (implemented as singleton).
+ *
+ */
+ transient private static GlobalDataContainer theInstance = null;
+
+ /**
+ *
+ * Internal storage of the data.
+ *
+ */
+ private Map dataObjects;
+
+ /**
+ *
+ * Returns the instance of the container. If it does not yet exist, the data
+ * container is created.
+ *
+ *
+ * @return instance of the container
+ */
+ public static GlobalDataContainer getInstance() {
+ if (theInstance == null) {
+ theInstance = new GlobalDataContainer();
+ }
+ return theInstance;
+ }
+
+ /**
+ *
+ * Manual serialization of the object. Necessary to guarantee the singleton
+ * property.
+ *
+ *
+ * @param s
+ * output stream for the serialization
+ * @throws IOException
+ * thrown if there is problem writing to the output stream
+ */
+ private void writeObject(ObjectOutputStream s) throws IOException {
+ s.defaultWriteObject();
+ s.writeObject(dataObjects);
+ }
+
+ /**
+ *
+ * Manual de-serialization of the object. Necessary to guarantee the
+ * singleton property.
+ *
+ * @param s
+ * input stream for the de-serialization
+ * @throws IOException
+ * thrown if there is problem reading from the input stream
+ * @throws ClassNotFoundException
+ * thrown if there is a problem reading from the input stream
+ */
+ @SuppressWarnings("unchecked")
+ private void readObject(ObjectInputStream s) throws IOException,
+ ClassNotFoundException {
+ s.defaultReadObject();
+ if (theInstance == null) {
+ theInstance = new GlobalDataContainer();
+ }
+ theInstance.dataObjects = (Map) s.readObject();
+ }
+
+ /**
+ *
+ * Manual de-serialization to guarantee the singleton property.
+ *
+ *
+ * @return instance of the container
+ */
+ private Object readResolve() {
+ return theInstance;
+ }
+
+ /**
+ *
+ * Constructor. Creates a new GlobalDataContainer. Private to guarantee the
+ * singleton property.
+ *
+ */
+ private GlobalDataContainer() {
+ dataObjects = new HashMap();
+ }
+
+ /**
+ *
+ * Adds data to the container.
+ *
+ *
+ * @param key
+ * key that identifies the data
+ * @param data
+ * data that is stored
+ * @return true, if an old entry was overwritten; false otherwise
+ */
+ public boolean addData(String key, Object data) {
+ Object previousEntry = dataObjects.put(key, data);
+ return previousEntry != null;
+ }
+
+ /**
+ *
+ * Removes data from the container.
+ *
+ *
+ * @param key
+ * key of the data to be removed
+ * @return true, if the object was removed; false if it was not present
+ */
+ public boolean removeData(String key) {
+ Object previousEntry = dataObjects.remove(key);
+ return previousEntry != null;
+ }
+
+ /**
+ *
+ * Returns the data associated with a key or {@code null} if no data is
+ * stored for the key.
+ *
+ *
+ * @param key
+ * key whose data is returned
+ * @return data associated with the key; {@code null} if no data is
+ * available
+ */
+ public Object getData(String key) {
+ return dataObjects.get(key);
+ }
+
+ /**
+ *
+ * Resets the data container, i.e., deletes all its contents.
+ *
+ */
+ public void reset() {
+ dataObjects = new HashMap();
+ }
+
+ /**
+ *
+ * Returns all keys of collections of sequences contained in the storage.
+ *
+ *
+ * @return keys of all collections of sequences contained in the storage
+ */
+ public Collection getAllSequencesNames() {
+ Collection allSequencesNames = new LinkedList();
+ for (Entry entry : dataObjects.entrySet()) {
+ if( SequenceInstanceOf.isCollectionOfSequences(entry.getValue())) {
+ allSequencesNames.add(entry.getKey());
+ }
+ }
+ return allSequencesNames;
+ }
+
+ /**
+ *
+ * Returns the keys of all {@link IStochasticProcess}s contained in the
+ * storage.
+ *
+ *
+ * @return keys of all {@link IStochasticProcess}s contained in the storage
+ */
+ public Collection getAllModelNames() {
+ Collection modelNames = new LinkedList();
+ for (Entry entry : dataObjects.entrySet()) {
+ if (entry.getValue() instanceof IStochasticProcess) {
+ modelNames.add(entry.getKey());
+ }
+ }
+ return modelNames;
+ }
+
+ /**
+ *
+ * Returns the keys of all objects contained in the storage.
+ *
+ *
+ * @return keys of all objects in the storage
+ */
+ public Collection getAllKeys() {
+ return dataObjects.keySet();
+ }
+
+}
Index: trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/ui/Runner.java
===================================================================
--- trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/ui/Runner.java (revision 488)
+++ trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/ui/Runner.java (revision 488)
@@ -0,0 +1,109 @@
+package de.ugoe.cs.quest.ui;
+
+import java.io.IOException;
+import java.util.List;
+
+import joptsimple.OptionException;
+import joptsimple.OptionParser;
+import joptsimple.OptionSet;
+import joptsimple.OptionSpec;
+import de.ugoe.cs.quest.log4j.Log4JLogger;
+import de.ugoe.cs.quest.ui.swt.MainWindow;
+import de.ugoe.cs.util.console.CommandExecuter;
+import de.ugoe.cs.util.console.Console;
+import de.ugoe.cs.util.console.TextConsole;
+
+/**
+ *
+ * Start-up class of the application.
+ *
+ *
+ * It sets up and starts the {@link Console}.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class Runner {
+
+ public enum UITYPE {
+ text, swt
+ };
+
+ public enum LOG4JTYPE {
+ enable, disable
+ }
+
+ /**
+ *
+ * Main method of the application.
+ *
+ *
+ * @param args
+ * if parameters are defined, they are interpreted as commands
+ * for the {@link Console} and executed before the user can use
+ * the console; can be used to perform batch operations
+ */
+ public static void main(String[] args) {
+ CommandExecuter.getInstance().addCommandPackage(
+ "de.ugoe.cs.quest.ui.commands");
+ CommandExecuter.getInstance().addCommandPackage(
+ "de.ugoe.cs.quest.plugin.mfc.commands");
+ CommandExecuter.getInstance().addCommandPackage(
+ "de.ugoe.cs.quest.plugin.php.commands");
+ CommandExecuter.getInstance().addCommandPackage(
+ "de.ugoe.cs.quest.plugin.guitar.commands");
+ CommandExecuter.getInstance().addCommandPackage(
+ "de.ugoe.cs.quest.plugin.jfc.commands");
+ //new Log4JLogger();
+
+ OptionParser parser = new OptionParser();
+ OptionSpec log4j = parser.accepts("log4j", "Allowed values: enable, disable").withRequiredArg()
+ .ofType(LOG4JTYPE.class).defaultsTo(LOG4JTYPE.enable);
+ OptionSpec