package monitor;


import java.io.InputStream;
import java.io.ObjectInputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import org.apache.log4j.spi.LoggingEvent;

public class LogDatabase {

    private String password;
    private int port;
    private String url;
    private String database;
    private String table;
    private String user;
    private Connection connection;

    LogDatabase()
    {

    }

    /**
     * A helper function to quickly set all of the main details in 1 go.
     * @param user The user name for the database server.
     * @param password The password for the database server.
     * @param url The url for the database server.
     * @param database The database that stores the logging events.
     * @param table The table that stores the logging events.
     * @param port The port that the database server listens on.
     */
    public void setDetails(String user, String password, String url, String database, String table, int port)
    {
        this.setDatabase(database);
        this.setPassword(password);
        this.setPort(port);
        this.setUrl(url);
        this.setTable(table);
        this.setUser(user);
    }

    /**
     * Connects to the database, using parameters that have already been defined.
     */
    public void connect()
    {
	try
	{
	    Class.forName("com.mysql.jdbc.Driver").newInstance();
	    String connectString = "jdbc:mysql://" + this.url + "/" + this.database + "?user=" + this.user + "&password=" +this.password;
	    this.connection = DriverManager.getConnection(connectString);
	}
	catch(Exception e)
	{
            System.out.println(e.getMessage());
	}
    }

    /**
     * Gets all logging events from the server. these can be filtered with the filter fuctions.
     * @return An arraylist of the logging events.
     */
    public ArrayList<LoggingEvent> getLogEvents(String logger, String message, String level)
    {
	try
	{
	    QueryBuilder builder = new QueryBuilder();
            builder.setAllColumns(true);
            builder.setTable(this.table);
            if(!message.equals(""))
                builder.addLike("message", message);
            if(!logger.equals(""))
                builder.addEquals("logger", logger);
            if(!level.equals(""))
                builder.addEquals("level", level);
	    ResultSet rs = builder.executeStatement(this.connection);
            return readResults(rs);
	}
	catch(Exception e)
	{
	    System.out.println(e.getMessage());
	}
        //if there was an error then just return null
	return null;
    }


    /**
     * Generates an arraylist from a result set.
     * @param rs The result set to be read.
     * @return An array list containing the logging event objects.
     */
    private ArrayList<LoggingEvent> readResults(ResultSet rs)
    {
        try
        {
            InputStream is = null;
            ObjectInputStream ois = null;
            ArrayList<LoggingEvent> events = new ArrayList<LoggingEvent>();
            while(rs.next())
            {
                is = rs.getBlob("event").getBinaryStream();
                ois = new ObjectInputStream(is);
                LoggingEvent e = (LoggingEvent)ois.readObject();
                events.add(e);
                System.out.println(e.getMessage());
            }
            return events;
        }
        catch(Exception e)
        {
            System.out.println(e.getMessage());
        }
        return null;
    }

    public void storeEvent(LoggingEvent event) throws SQLException
    {
        String prepared = "insert into " + this.table + " (event, message, logger, level, timeStamp) values(?,?,?, ?, ?)";
	PreparedStatement statement = connection.prepareStatement(prepared);
	statement.setObject(1, event);
	statement.setString(2, event.getRenderedMessage());
	statement.setString(3, event.getLoggerName());
	statement.setString(4, event.getLevel().toString());
	statement.setLong(5, event.getTimeStamp());
        statement.execute();
    }


    /**
     * @return the password
     */
    public String getPassword() {
        return password;
    }

    /**
     * @param password the password to set
     */
    public void setPassword(String password) {
        this.password = password;
    }

    /**
     * @return the port
     */
    public int getPort() {
        return port;
    }

    /**
     * @param port the port to set
     */
    public void setPort(int port) {
        this.port = port;
    }

    /**
     * @return the url
     */
    public String getUrl() {
        return url;
    }

    /**
     * @param url the url to set
     */
    public void setUrl(String url) {
        this.url = url;
    }

    /**
     * @return the database
     */
    public String getDatabase() {
        return database;
    }

    /**
     * @param database the database to set
     */
    public void setDatabase(String database) {
        this.database = database;
    }

    /**
     * @return the table
     */
    public String getTable() {
        return table;
    }

    /**
     * @param table the table to set
     */
    public void setTable(String table) {
        this.table = table;
    }

    /**
     * @return the user
     */
    public String getUser() {
        return user;
    }

    /**
     * @param user the user to set
     */
    public void setUser(String user) {
        this.user = user;
    }
}



package monitor;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.*;


public class QueryBuilder {

    private String table;
    private ArrayList<String> parameters;
    private HashMap<String, String> equals;
    private HashMap<String, String> like;
    private boolean allColumns;
    public QueryBuilder()
    {
        this.like = new HashMap<String, String>();
        this.equals = new HashMap<String, String>();
        this.parameters = new ArrayList<String>();
    }

    public String getStatementString()
    {
        StringBuilder statement = new StringBuilder();
        String operation = "select";
        String from = "from " + this.getTable();

        statement.append(operation);
        statement.append(" ");
        statement.append(this.getParameterString());
        statement.append(" ");
        statement.append(from);
        statement.append(" ");
        statement.append(this.getWhereString());
        return statement.toString();
    }

    private String getParameterString()
    {
        StringBuilder parametersString = new StringBuilder();
        if(this.isAllColumns())
            parametersString.append("*");
        else
        {
            for(int i = 0; i < this.getParameters().size(); i++)
            {
                if(i != 0)
                    parametersString.append(",");
                parametersString.append(this.getParameters().get(i));
            }
        }
        return parametersString.toString();
    }

    private String getWhereString()
    {
        StringBuilder statement = new StringBuilder();
        if(this.like.size() + this.equals.size() != 0)
        {
            statement.append(" where ");
            statement.append(" ");
            statement.append(this.getEqualsString(equals));
            if(this.equals.size() != 0 && this.like.size() != 0){
                statement.append(" and ");
            }
            else{
                statement.append(" ");
            }
            statement.append(this.getLikeString(this.like));
        }
        return statement.toString();
    }

    private String getLikeString(HashMap<String, String> parameters)
    {
        StringBuilder output = new StringBuilder();
        String[] likeKeys = this.like.keySet().toArray(new String[like.keySet().size()]);
        for(int i = 0; i < like.keySet().size(); i++)
        {
            if(i != 0)
                output.append(" and ");
            output.append(likeKeys[i]);
            output.append(" like ");
            output.append(" '%").append(getLike().get(likeKeys[i])).append("%'");
        }
        return output.toString();
    }

    private String getEqualsString(HashMap<String, String> parameters)
    {
        StringBuilder output = new StringBuilder();
        String[] equalsKeys = (String[]) this.equals.keySet().toArray(new String[equals.keySet().size()]);
        for(int i = 0; i < equals.keySet().size(); i++)
        {
            if(i != 0)
                output.append(" and ");
            output.append(equalsKeys[i]);
            output.append(" = ");
            output.append(" '").append(getEquals().get(equalsKeys[i])).append("'");
        }
        return output.toString();
    }


    public ResultSet executeStatement(Connection connection)
    {
        try{
        Statement statement = connection.createStatement();
        return statement.executeQuery(this.getStatementString());
        }
        catch(Exception e)
        {
            System.out.println(this.getStatementString());
            System.out.println(e.getMessage());
        }
        return null;
    }

    public void addLike(String column, String value)
    {
        this.getLike().put(column, value);
    }

    public void addEquals(String column, String value)
    {
        this.getEquals().put(column, value);
    }

    public void addParameter(String parameter)
    {
        this.getParameters().add(parameter);
    }

    /**
     * @return the table
     */
    public String getTable() {
        return table;
    }

    /**
     * @param table the table to set
     */
    public void setTable(String table) {
        this.table = table;
    }

    /**
     * @return the parameters
     */
    public ArrayList<String> getParameters() {
        return parameters;
    }

    /**
     * @param parameters the parameters to set
     */
    public void setParameters(ArrayList<String> parameters) {
        this.parameters = parameters;
    }

    /**
     * @return the equals
     */
    public HashMap<String, String> getEquals() {
        return equals;
    }

    /**
     * @param equals the equals to set
     */
    public void setEquals(HashMap<String, String> equals) {
        this.equals = equals;
    }

    /**
     * @return the like
     */
    public HashMap<String, String> getLike() {
        return like;
    }

    /**
     * @param like the like to set
     */
    public void setLike(HashMap<String, String> like) {
        this.like = like;
    }

    /**
     * @return the allColumns
     */
    public boolean isAllColumns() {
        return allColumns;
    }

    /**
     * @param allColumns the allColumns to set
     */
    public void setAllColumns(boolean allColumns) {
        this.allColumns = allColumns;
    }


}


/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package monitor;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Iterator;
import javax.servlet.ServletConfig;
import javax.servlet.http.*;
import org.apache.log4j.spi.LoggingEvent;
public class Log extends HttpServlet
{
    private LogDatabase DB;

    public void init()
    {
        this.DB = new LogDatabase();
        ServletConfig config = this.getServletConfig();
        String user = config.getInitParameter("user");
        String table = config.getInitParameter("table");
        String password = config.getInitParameter("password");
        String url = config.getInitParameter("url");
        String database = config.getInitParameter("database");
        //add a port thing, too lazy right now
        this.DB.setDetails(user, password, url, database, table, 8084);
        this.DB.connect();
    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)
    {
        PrintWriter writer = null;
	try
	{
            ObjectInputStream is = new ObjectInputStream(request.getInputStream());
            LoggingEvent e = (LoggingEvent) is.readObject();
            writer = response.getWriter();
            System.out.println(e.getRenderedMessage());
            this.DB.storeEvent(e);


	}
	catch(Exception e)
	{
            writer.write(e.getMessage());
	}
    }

    public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException
    {
        ServletConfig config = this.getServletConfig();
        String logger = request.getParameter("logger");
        String level = request.getParameter("level");
        String message = request.getParameter("message");
        ArrayList<LoggingEvent> events = this.DB.getLogEvents(logger, message, level);
        response.setContentType("application/octet-stream");
        ObjectOutputStream stream = new ObjectOutputStream(response.getOutputStream());
        stream.writeObject(events);

    }
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package monitor;

import java.util.*;
import javax.servlet.http.*;
import org.apache.log4j.spi.*;
import javax.servlet.*;
import java.io.*;
import org.apache.log4j.*;
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;
//import org.apache.xerces.parsers.*;
import org.w3c.dom.*;
import java.lang.Long;

//Most of the html stuff in here is quite roughly done. normally id be sane and use a library but I dont know what you wanted so i figured id do it this way.
//in most projects like this i would have created a seperate servlet to act as a rest service, but in the case of this one ive made it so that the get request
//passes a "service" parameter to determine what to send back.
public class Demo extends HttpServlet{

    private LogDatabase DB;

    public Demo()
    {

    }

    public void doGet(HttpServletRequest request, HttpServletResponse response)
    {
	PrintWriter writer = null;
	try
	{
	    writer = response.getWriter();
	}
	catch(Exception e)
	{
	    System.out.println(e.getMessage());
	}
	if(request.getParameter("service") == null)
	{
	    writer.write(this.getPage());
	    return;
	}
	if(request.getParameter("service").equals("update"))
	{
	    String logger = request.getParameter("logger");
	    String level = request.getParameter("level");
	    response.setContentType("text/xml");
	    response.setHeader("Cache-Control", "no-cache");
	    response.setHeader("Pragma", "no-cache");

	    try{
                Document document = null;

                {
                    String filter = request.getParameter("filter");
                    document = this.getXML(DB.getLogEvents(level.toString(), logger, filter));
                }
                Source source = new DOMSource(document);
                Result result = new StreamResult(response.getWriter());
                Transformer xformer = TransformerFactory.newInstance().newTransformer();
                xformer.transform(source, result);
	    }
	    catch(Exception e)
	    {
		System.out.println(e.getMessage());
	    }
            return;
	}
	else
	if(request.getParameter("service").equals("delete"))
	{

	}
    }

    /**
       All of the init stuff goes in here. the connection details are read from the web.xml config file.
     **/
    public void init()
    {
	this.DB = new LogDatabase();
	ServletConfig config = getServletConfig();
	String user = config.getInitParameter("user");
	String password = config.getInitParameter("password");
	String url = config.getInitParameter("url");
	String table = config.getInitParameter("table");
	String database = config.getInitParameter("database");
	this.DB.setDetails(table, user, password, url, database, 8084);
	this.DB.connect();
    }

    /**

     **/
    public String getSearchForm()
    {
	StringBuffer output = new StringBuffer();
	output.append("<form id = 'SearchForm'>");
	output.append("<table>");
	output.append(getTextSearchRow());
	output.append(getLevelRow());
	output.append(getNumberOfResultsRow());
	output.append(getLoggerRow());
	output.append(getUpdateButton());
	output.append("</table>");
	output.append("</form>");
	return output.toString();
    }

    public String getUpdateButton()
    {
	StringBuffer output = new StringBuffer();
	output.append("<tr>");
	output.append("<td>");
	output.append("<input type = 'button' onClick = 'updateValues()' value='update'/>");
	output.append("</td>");
	output.append("</tr>");
	return output.toString();
    }

    public String getRow(String data1, String data2)
    {
	StringBuffer output = new StringBuffer();
	output.append("<tr>");
	output.append("<td>");
	output.append(data1);
	output.append("</td>");
	output.append("<td>");
	output.append(data2);
	output.append("</td>");
	output.append("</tr>");
	return output.toString();
    }

    public String getNumberOfResultsRow()
    {
	return getRow("Maximum Results", "<input type = 'text' name = 'numberResults' id = 'numberResults'");
    }

    public String getTextSearchRow()
    {
	return getRow("Search", "<input type = 'text' name = 'search' id = 'search'");
    }

    public String getLevelRow()
    {
	return getRow("Level", getLevelOptions());
    }

    public String getLoggerRow()
    {
	return getRow("Logger", "<input type = 'text' name = 'logger' id = 'loggerEntry'");
    }

    public String getLevelOptions()
    {
	StringBuffer options = new StringBuffer();
	options.append("<select id = 'levelSelect' name = 'levelSelect'>");
	options.append("<option>DEBUG</option>");
	options.append("<option>WARN</option>");
	options.append("<option>INFO</option>");
	options.append("<option>ERROR</option>");
	options.append("<option>ALL</option>");
	options.append("</select>");
	return options.toString();
    }

    public String getResultsXml()
    {
	String output = new String();
	return output;
    }

    public String getPage()
    {
	StringBuffer page = new StringBuffer();
	page.append("<html>");
	page.append("<head>");
	page.append("<script type = 'text/javascript' src = 'Demo.js'></script>");

	page.append("</head>");
	page.append("<body onload='init()'>");
	page.append("<div id = 'Events'>");
	page.append("</div>");
	page.append(this.getSearchForm());
	page.append("</body>");
	page.append("<html>");
	return page.toString();
    }



    public Document getXML(ArrayList<LoggingEvent> events) throws ParserConfigurationException
    {
	DocumentBuilderFactory dbfac = DocumentBuilderFactory.newInstance();
        DocumentBuilder docBuilder = dbfac.newDocumentBuilder();
        Document document = docBuilder.newDocument();

	Element root = document.createElement("Events");
	for(LoggingEvent e : events)
	{
	    System.out.println("looping");
	    root.appendChild(this.getLoggingEventXml(e, document));
	}
	document.appendChild(root);
	return document;
    }


    public Element getLoggingEventXml(LoggingEvent event, Document document)
    {
	Element root = document.createElement("Event");

	Element logger = document.createElement("Logger");
	Text loggerText = document.createTextNode(event.getLoggerName());
	logger.appendChild(loggerText);
	Element message = document.createElement("Message");
	Text messageText = document.createTextNode(event.getMessage().toString());
	message.appendChild(messageText);
	Element level = document.createElement("Level");
	Text levelText = document.createTextNode(event.getLevel().toString());
	level.appendChild(levelText);
	Element time = document.createElement("Time");
	Text timeText = document.createTextNode(new Long(event.getTimeStamp()).toString());
	time.appendChild(timeText);


	root.appendChild(time);
	root.appendChild(logger);
	root.appendChild(message);
	root.appendChild(level);
        System.out.println("fsdfd");
	return root;
    }
}