Metacat

/**

 *  '$RCSfile$'

 *  Copyright: 2004 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *

 *   '$Author$'

 *     '$Date$'

 * '$Revision$'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat;

import org.dataone.service.types.v2.Log;

import org.dataone.service.types.v2.LogEntry;

import org.dataone.service.types.v1.NodeReference;

import org.dataone.service.types.v1.Subject;

import edu.ucsb.nceas.metacat.database.DBConnectionPool;

 * EventLog is used to intialize and store a log of events that occur in an

 * application. The events are registered with the logger as they occur, but

 * EventLog writes them to permenant storage when it is most convenient or

 * efficient. EventLog is a Singleton as there should always be only one object

 * for these logging events.

 *

 * TODO: Logging to the database needn't be synchronous with the event.

 * Instead, a separate thread can be launched that periodically sleeps and only

 * wakes periodically to see if metacat is idle.  The log event can be cached

 * and inserted later when the thread wakes and finds metacat idle.

 *

 * TODO: Write a function that archives a part of the log table to an

 * external text file so that the log table doesn't get to big.  This

 * function should be able to be called manually or on a schedule.

 *

 * TODO: Write an access function that returns an XML report for a

 * specific subset of events.  Users should be able to query on

 * principal, docid/rev, date, event, and possibly other fields.

 *

 * @author jones

 */

public class EventLog

{

     * The single instance of the event log that is always returned.

     */

    private static EventLog self = null;

     * A private constructor that initializes the class when getInstance() is

     * called.

     */

    private EventLog()

    {

    }

    /**

     * Return the single instance of the event log after initializing it if it

     * wasn't previously initialized.

     *

     * @return the single EventLog instance

     */

    public static EventLog getInstance()

    {

        if (self == null) {

            self = new EventLog();

        }

        return self;

    }

    /**

     * Log an event of interest to the application. The information logged can

     * include basic identification information about the principal or computer

     * that initiated the event.

     *

	 * @param docid the identifier of the document to which the event applies

	 * @param event the string code for the event

        // update the event information in the index

        try {

	        String localId = DocumentUtil.getSmartDocId(docid);

			int rev = DocumentUtil.getRevisionFromAccessionNumber(docid);

	        String guid = IdentifierManager.getInstance().getGUID(localId, rev);

	        Identifier pid = new Identifier();

	        pid.setValue(guid);

	        // submit for indexing

        } catch (Exception e) {

        	logMetacat.error("Could not update event index information", e);

        }

    	// update the search index for the event

        try {

	        	String docid = IdentifierManager.getInstance().getLocalId(pid.getValue());

		        List<Object> values = new ArrayList<Object>();

				values.add(eventCount);

		        Map<String, List<Object>> fields = new HashMap<String, List<Object>>();

		        fields.put(fieldName, values);

		        return fields;

        	}

        } catch (Exception e) {

    	return null;

     * Insert a single log event record to the database.

     *

     * @param logData the data to be logged when an event occurs

     */

    private void insertLogEntry(EventLogData logData)

    {

        String insertString = "insert into access_log"

        int serialNumber = -1;

        try {

            // Get a database connection from the pool

            if(userAgent != null && userAgent.length() > USERAGENTLENGTH) {

                userAgent = userAgent.substring(0, USERAGENTLENGTH);

            }

            // Execute the insert statement

            stmt.setString(1, logData.getIpAddress());

            stmt.setString(4, logData.getDocid());

            stmt.setString(5, logData.getEvent());

            stmt.setTimestamp(6, new Timestamp(new Date().getTime()));

        } catch (SQLException e) {

                    + e.getMessage());

            // Return database connection to the pool

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }

    }

    /**

     * Get a report of the log events that match a set of filters.  The

     *

     * @param ipAddress the internet protocol address for the event

	 * @param principal the principal for the event (a username, etc)

	 * @param docid the identifier of the document to which the event applies

	 * @param event the string code for the event

	 * @param endDate end of date range for query

	 * @return an XML-formatted report of the access log entries

        StringBuffer query = new StringBuffer();

//                        + ""

//                        + "event, date_logged) " + "values (" + "'"

//                        + logData.getIpAddress() + "', " + "'"

//                        + logData.getPrincipal() + "', " + "'"

//                        + logData.getDocid() + "', " + "'" + logData.getEvent()

//                        + "', " + " ? " + ")";

        if (ipAddress != null || principal != null || docid != null

                        || event != null || startDate != null || endDate != null) {

            query.append(" where ");

        }

        boolean clauseAdded = false;

        int startIndex = 0;

        int endIndex = 0;

        	for (int i = 0; i < ipAddress.length; i++) {

        		if (i > 0) {

            		query.append(", ");

        		}

        		query.append("?");

        		paramValues.add(ipAddress[i]);

        	}

        	query.append(") ");

        }

        if (principal != null) {

                query.append(" and ");

            }

        	for (int i = 0; i < principal.length; i++) {

        		if (i > 0) {

            		query.append(", ");

        		}

        		query.append("?");

        		paramValues.add(principal[i]);

        	}

        	query.append(") ");

        }

        if (docid != null) {

                query.append(" and ");

            }

        	for (int i = 0; i < docid.length; i++) {

        		if (i > 0) {

            		query.append(", ");

        		}

        		query.append("?");

        		// allow docid without revision - look up latest version

        		try {

        			fullDocid = DocumentUtil.appendRev(fullDocid);

        		} catch (Exception e) {

					// just warn about this

        			logMetacat.warn("Could not check docid for revision: " + fullDocid, e);

				}

        		paramValues.add(fullDocid);

        	query.append(") ");

        }

        if (event != null) {

                query.append(" and ");

            }

        	for (int i = 0; i < event.length; i++) {

        		if (i > 0) {

            		query.append(", ");

        		}

        		query.append("?");

        		paramValues.add(event[i]);

        	}

        	query.append(") ");

        }

        if (startDate != null) {

            if (clauseAdded) {

                query.append(" and ");

            }

            startIndex++;

        }

        if (endDate != null) {

            if (clauseAdded) {

                query.append(" and ");

            }

            query.append("date_logged < ?");

            clauseAdded = true;

            endIndex = startIndex + 1;

        }

        DBConnection dbConn = null;

        int serialNumber = -1;

        try {

            // Get a database connection from the pool

            dbConn = DBConnectionPool.getDBConnection("EventLog.getReport");

            serialNumber = dbConn.getCheckOutSerialNumber();

            int parameterIndex = 1;

            for (String val: paramValues) {

                stmt.setTimestamp(parameterIndex++, startDate);

            	stmt.setTimestamp(parameterIndex++, endDate);

            stmt.execute();

            ResultSet rs = stmt.getResultSet();

            resultDoc.append("<log>\n");

            while (rs.next()) {

                		generateXmlRecord(

                				rs.getString(1), //id

                				anonymous ? "" : rs.getString(2), //ip

                				anonymous ? "" : rs.getString(4), //principal

                                rs.getTimestamp(7)));

            resultDoc.append("</log>");

            stmt.close();

        } catch (SQLException e) {

                            + e.getMessage());

            // Return database connection to the pool

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }

        return resultDoc.toString();

     * A utility method to determine if the given docid was deleted.

     * @param docid the specified docid

     * @return true if there is a delete event for the id; false otherwise.

     */

    public boolean isDeleted(String docid) {

        boolean deleted =false;

        if(docid != null || !docid.trim().equals("")) {

            String[] docids = new String[1];

            docids[0] = docid;

            String[] events = new String[1];

            events[0]= DELETE;

            String[] ipAddress = null;

            String[] principal = null;

            Timestamp startDate = null;

            Timestamp endDate = null;

            boolean anonymous = false;

            String report =getReport(ipAddress, principal, docids,

                     events, startDate, endDate, anonymous);

            //System.out.println("the report is "+report);

            if(report != null && report.contains("<event>"+DELETE+"</event>") ){

                deleted = true;

            }

        }

        return deleted;

    }

    public Log getD1Report(String[] ipAddress, String[] principal, String[] docid,

    	NodeReference memberNode = new NodeReference();

        String nodeId = "localhost";

        try {

            nodeId = PropertyService.getProperty("dataone.nodeId");

        } catch (PropertyNotFoundException e1) {

            // TODO Auto-generated catch block

            e1.printStackTrace();

        }

        memberNode.setValue(nodeId);

        StringBuffer subQueryFrom = new StringBuffer();

        subQueryFrom.append("from access_log ");

        List<String> paramValues = new ArrayList<String>();

        if (ipAddress != null) {

            } else {

            	subQueryFrom.append(" where ");

        		if (i > 0) {

        	}

        }

        if (principal != null) {

            } else {

            	subQueryFrom.append(" where ");

        		if (i > 0) {

        	}

        }

        if (docid != null) {

            } else {

            	subQueryFrom.append(" where ");

        		if (i > 0) {

        	}

        }

       //please make sure the handling of event is just before the the startDate clause!!!

                subQueryFrom.append(" and ");

            subQueryFrom.append("?");

            String eventString = event;

            if (eventString.equals(Event.CREATE.xmlValue())) {

                isCreateEvent = true; //since the create event maps create, insert and et al, we handle it in different way

                subQueryFrom.append(",?");// for INSERT, the insert is handled by line 508

                subQueryFrom.append(",?");// for upload

                subQueryFrom.append(",?");// for UPLOAD

                subQueryFrom.append(",?");// for create

                //eventString = "insert,INSERT,upload,UPLOAD,create";

            } else {

                paramValues.add(eventString);

            }

            subQueryFrom.append(") ");

        }

            if (clauseAdded) {

            } else {

            	subQueryFrom.append(" where ");

        }

        if (endDate != null) {

            if (clauseAdded) {

            } else {

            	subQueryFrom.append(" where ");

        }

        String countSelect = "select count(*) ";

        // subquery select

        String subquerySelect = "select entryid ";

        // for selecting fields we want in the join

        String fieldSelect =

        		"select " +

        		"entryid, " +

        		"id.guid as identifier, " +

        		"ip_address, " +

        		"user_agent, " +

        		"principal, " +

        		"case " +

        		"	when event = 'insert' then 'create' " +

        		" when event = 'upload' then 'create' " +

        		" when event = 'UPLOAD' then 'create' " +

        		"end as event, " +

        		"date_logged " +

        		"from access_log al, identifier id " +

        		"where al.docid = id.docid||'.'||id.rev " +

        		"and al.entryid in ";

        logMetacat.debug("The count query is " + countQuery);

		// select the fields using paged subquery and fields join query

        String pagedSubquery = DatabaseService.getInstance().getDBAdapter().getPagedQuery(subquerySelect + subQueryFrom.toString() + orderByClause, start, count);

        String pagedQuery = fieldSelect + " ( " + pagedSubquery + " ) " + orderByClause;

        logMetacat.debug("The selection query is " + pagedQuery);

        logMetacat.debug("The startDate in the query is " + startDate);

        logMetacat.debug("The endDate in the query is " + startDate);

        int serialNumber = -1;

        try {

            // Get a database connection from the pool

            dbConn = DBConnectionPool.getDBConnection("EventLog.getD1Report");

            serialNumber = dbConn.getCheckOutSerialNumber();

            // Execute the query statement

            PreparedStatement countStmt = dbConn.prepareStatement(countQuery);

            int parameterIndex = 1;

            for (String val: paramValues) {

            	fieldsStmt.setString(parameterIndex, val);

            	parameterIndex++;

            if(isCreateEvent) {

                //handle the event mapping. If we add another event mapping, we need add a "?" in line 496

                //those values are not in the paramValues.

                countStmt.setString(parameterIndex, "insert");

                fieldsStmt.setString(parameterIndex, "insert");

                parameterIndex++;

                countStmt.setString(parameterIndex, "INSERT");

                fieldsStmt.setString(parameterIndex, "INSERT");

                parameterIndex++;

                countStmt.setString(parameterIndex, "upload");

                fieldsStmt.setString(parameterIndex, "upload");

                parameterIndex++;

                countStmt.setString(parameterIndex, "UPLOAD");

                fieldsStmt.setString(parameterIndex, "UPLOAD");

                parameterIndex++;

                countStmt.setString(parameterIndex, "create");

                fieldsStmt.setString(parameterIndex, "create");

                parameterIndex++;

            }

                fieldsStmt.setTimestamp(parameterIndex, startDate);

            	parameterIndex++;

            if (endDate != null) {

            	fieldsStmt.setTimestamp(parameterIndex, endDate);

            	parameterIndex++;

            // for the return Log list

            if (count != 0) {

                logMetacat.debug("Time to start to execute the selection query "+startTime);

	            logMetacat.debug("Time to run the selection query is "+(endTime-startTime)/1000+" seconds.");

	            //process the result and return it

	            while (rs.next()) {

	            	LogEntry logEntry = new LogEntry();

	            	logEntry.setEntryId(rs.getString(1));

	            	Identifier identifier = new Identifier();

	            	identifier.setValue(rs.getString(2));

					logEntry.setIdentifier(identifier);

	            	logEntry.setIpAddress(anonymous ? "N/A" : rs.getString(3));

	            	String userAgent = "N/A";

	            	if (rs.getString(4) != null) {

	            		userAgent = rs.getString(4);

	            	}

	            	logEntry.setUserAgent(userAgent);

	            	Subject subject = new Subject();

	            	subject.setValue(anonymous ? "N/A" : rs.getString(5));

					logEntry.setSubject(subject);

					String logEventString = rs.getString(6);

					logEntry.setNodeIdentifier(memberNode);

					logs.add(logEntry);

	            }

	            fieldsStmt.close();

	            logMetacat.debug("Time to put the query result to the log is "+(endTime2-endTime)/1000+" seconds.");

            log.setLogEntryList(logs);

		    log.setCount(logs.size());

			// get total for out query

		    int total = 0;

            logMetacat.debug("Time to start to execute the counting query "+startTime);

            logMetacat.debug("Time to run the counting query is "+(endTime-startTime)/1000+" seconds.");

            if (countRs.next()) {

            	total = countRs.getInt(1);

            }

            countStmt.close();