Metacat

/**

 *  '$RCSfile$'

 *  Copyright: 2000-2011 Regents of the University of California and the

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author: cjones $'

 *     '$Date: 2011-06-28 08:04:34 -0700 (Tue, 28 Jun 2011) $'

 *

 * 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.dataone;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Date;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.List;

import java.util.Timer;

import java.util.TimerTask;

import java.util.Vector;

import javax.servlet.http.HttpServletRequest;

import org.apache.log4j.Logger;

import org.dataone.service.exceptions.InvalidRequest;

import org.dataone.service.exceptions.InvalidToken;

import org.dataone.service.exceptions.NotAuthorized;

import org.dataone.service.exceptions.NotFound;

import org.dataone.service.exceptions.NotImplemented;

import org.dataone.service.exceptions.ServiceFailure;

import org.dataone.service.types.AccessPolicy;

import org.dataone.service.types.AccessRule;

import org.dataone.service.types.Event;

import org.dataone.service.types.Identifier;

import org.dataone.service.types.Group;

import org.dataone.service.types.Log;

import org.dataone.service.types.LogEntry;

import org.dataone.service.types.NodeReference;

import org.dataone.service.types.Permission;

import org.dataone.service.types.Person;

import org.dataone.service.types.Session;

import org.dataone.service.types.Subject;

import org.dataone.service.types.SystemMetadata;

import edu.ucsb.nceas.metacat.EventLog;

import edu.ucsb.nceas.metacat.IdentifierManager;

import edu.ucsb.nceas.metacat.McdbDocNotFoundException;

import edu.ucsb.nceas.metacat.McdbException;

import edu.ucsb.nceas.metacat.MetacatHandler;

import edu.ucsb.nceas.metacat.client.InsufficientKarmaException;

import edu.ucsb.nceas.metacat.properties.PropertyService;

import edu.ucsb.nceas.utilities.ParseLSIDException;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

public abstract class D1NodeService {

  private static Logger logMetacat = Logger.getLogger(D1NodeService.class);

  /* reference to the metacat handler */

  private MetacatHandler handler;

  /* parameters set in the incoming request */

  private Hashtable<String, String[]> params;

	/* Methods common to CNCore and MNCore APIs */

	/**

	 * Return the log records associated with a given event between the start and 

	 * end dates listed given a particular Subject listed in the Session

	 * 

	 * @param session - the Session object containing the credentials for the Subject

	 * @param fromDate - the start date of the desired log records

	 * @param toDate - the end date of the desired log records

	 * @param event - restrict log records of a specific event type

	 * @param start - zero based offset from the first record in the 

	 *                set of matching log records. Used to assist with 

	 *                paging the response.

	 * @param count - maximum number of log records to return in the response. 

	 *                Used to assist with paging the response.

	 * 

	 * @return the desired log records

	 * 

	 * @throws InvalidToken

	 * @throws ServiceFailure

	 * @throws NotAuthorized

	 * @throws InvalidRequest

	 * @throws NotImplemented

	 */

	public Log getLogRecords(Session session, Date fromDate, Date toDate, 

      Event event, Integer start, Integer count) throws InvalidToken, ServiceFailure,

	    NotAuthorized, InvalidRequest, NotImplemented {

		Log log = new Log();

		Vector<LogEntry> logs = new Vector<LogEntry>();

		IdentifierManager im = IdentifierManager.getInstance();

		EventLog el = EventLog.getInstance();

		if (fromDate == null) {

			logMetacat.debug("setting fromdate from null");

			fromDate = new Date(1);

		}

		if (toDate == null) {

			logMetacat.debug("setting todate from null");

			toDate = new Date();

		}

		logMetacat.debug("fromDate: " + fromDate);

		logMetacat.debug("toDate: " + toDate);

		String report = el.getReport(null, null, null, null,

				new java.sql.Timestamp(fromDate.getTime()),

				new java.sql.Timestamp(toDate.getTime()), false);

		logMetacat.debug("report: " + report);

		String logEntry = "<logEntry>";

		String endLogEntry = "</logEntry>";

		int startIndex = 0;

		int foundIndex = report.indexOf(logEntry, startIndex);

		while (foundIndex != -1) {

			// parse out each entry

			int endEntryIndex = report.indexOf(endLogEntry, foundIndex);

			String entry = report.substring(foundIndex, endEntryIndex);

			logMetacat.debug("entry: " + entry);

			startIndex = endEntryIndex + endLogEntry.length();

			foundIndex = report.indexOf(logEntry, startIndex);

			String entryId = getLogEntryField("entryid", entry);

			String ipAddress = getLogEntryField("ipAddress", entry);

			String principal = getLogEntryField("principal", entry);

			String docid = getLogEntryField("docid", entry);

			String eventS = getLogEntryField("event", entry);

			String dateLogged = getLogEntryField("dateLogged", entry);

			LogEntry le = new LogEntry();

			Event e = Event.convert(eventS);

			if (e == null) { // skip any events that are not Dataone Crud events

				continue;

			}

			le.setEvent(e);

			Identifier entryid = new Identifier();

			entryid.setValue(entryId);

			le.setEntryId(entryid);

			Identifier identifier = new Identifier();

			try {

				logMetacat.debug("converting docid '" + docid + "' to a guid.");

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

					continue;

				}

				docid = docid.substring(0, docid.lastIndexOf("."));

				identifier.setValue(im.getGUID(docid, im.getLatestRevForLocalId(docid)));

			} catch (Exception ex) { 

				// try to get the guid, if that doesn't

				// work, just use the local id

				// throw new ServiceFailure("1030",

				// "Error getting guid for localId " +

				// docid + ": " + ex.getMessage());\

				// skip it if the guid can't be found

				continue;

			}

			le.setIdentifier(identifier);

			le.setIpAddress(ipAddress);

			Calendar c = Calendar.getInstance();

			String year = dateLogged.substring(0, 4);

			String month = dateLogged.substring(5, 7);

			String date = dateLogged.substring(8, 10);

			logMetacat.debug("year: " + year + " month: " + month + " day: " + date);

			c.set(new Integer(year).intValue(), new Integer(month).intValue(),

					new Integer(date).intValue());

			Date logDate = c.getTime();

			le.setDateLogged(logDate);

			NodeReference memberNode = new NodeReference();

			memberNode.setValue(ipAddress);

			le.setMemberNode(memberNode);

			Subject princ = new Subject();

			princ.setValue(principal);

			le.setSubject(princ);

			le.setUserAgent("metacat/RESTService");

			if (event == null) {

				logs.add(le);

			}

			if (event != null

					&& e.toString().toLowerCase().trim().equals(

							event.toString().toLowerCase().trim())) {

				logs.add(le);

			}

		}

		log.setLogEntryList(logs);

		logMetacat.info("getLogRecords");

		return log;

	}

	/* End methods common to CNCore and MNCore APIs */

	/* Methods common to CNRead and MNRead APIs */

	/**

	 * Return the object identified by the given object identifier

	 * 

	 * @param session - the Session object containing the credentials for the Subject

	 * @param pid - the object identifier for the given object

	 * 

	 * TODO: The D1 Authorization API doesn't provide information on which 

	 * authentication system the Subject belongs to, and so it's not possible to

	 * discern which Person or Group is a valid KNB LDAP DN.  Fix this.

	 * 

	 * @return inputStream - the input stream of the given object

	 * 

	 * @throws InvalidToken

	 * @throws ServiceFailure

	 * @throws NotAuthorized

	 * @throws InvalidRequest

	 * @throws NotImplemented

	 */

	public InputStream get(Session session, Identifier pid) 

	  throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

	  NotImplemented, InvalidRequest {

		InputStream inputStream = null; // bytes to be returned

    handler = new MetacatHandler(new Timer());

		boolean allowed = false;

		String localId; // the metacat docid for the pid

		Subject subject = session.getSubject(); // the requesting user

		List<Group> groupList; // the user's groups

		// set the public user as a fallback

		if ( subject == null ) {

			subject.setValue("Public");

			session.setSubject(subject);

		}

		// convert groups to a string array (for handler)

		groupList = session.getSubjectList().getGroupList();

		String[] groups = new String[groupList.size()];     

		// get the local docid from Metacat

		try {

	    localId = IdentifierManager.getInstance().getLocalId(pid.getValue());

    } catch (McdbDocNotFoundException e) {

      throw new NotFound("1020", "The object specified by " + 

      		               pid.getValue() +

      		               "does not exist at this node.");

    }

    // check for authorization

		allowed = isAuthorized(session, pid, Permission.READ);

		// if the person is authorized, perform the read

		if ( allowed ) {

			for ( int i = 0; i > groupList.size(); i++ ) {

				groups[i] = groupList.get(i).getGroupName();

			}

			// get the object bytes

			// TODO: stream to file to stream conversion throughout Metacat needs to

			// be resolved

      File tmpDir;

      try

      {

          tmpDir = new File(PropertyService.getProperty("application.tempDir"));

      }

      catch(PropertyNotFoundException pnfe)

      {

          logMetacat.error("D1NodeService.get(): " +

                  "application.tmpDir not found.  Using /tmp instead.");

          tmpDir = new File("/tmp");

      }

      Date d = new Date();

      final File outputFile = new File(tmpDir, "metacat.output." + d.getTime());

      FileOutputStream dataSink;

      try {

	      dataSink = new FileOutputStream(outputFile);

	      handler.readFromMetacat(localId, null, 

            dataSink, localId, "xml",

            subject.getValue(), 

            groups, true, params);

      } catch (FileNotFoundException e) {

        throw new ServiceFailure("1020", "The object specified by " + 

            pid.getValue() +

            "could not be returned due to a file read error: " +

            e.getMessage());

      } catch (PropertyNotFoundException e) {

        throw new ServiceFailure("1020", "The object specified by " + 

            pid.getValue() +

            "could not be returned due to an internal error: " +

            e.getMessage());

      } catch (ClassNotFoundException e) {

        throw new ServiceFailure("1020", "The object specified by " + 

            pid.getValue() +

            "could not be returned due to an internal error: " +

            e.getMessage());

      } catch (IOException e) {

        throw new ServiceFailure("1020", "The object specified by " + 

            pid.getValue() +

            "could not be returned due to a file read error: " +

            e.getMessage());

      } catch (SQLException e) {

        throw new ServiceFailure("1020", "The object specified by " + 

            pid.getValue() +

            "could not be returned due to a database error: " +

            e.getMessage());

      } catch (McdbException e) {

        throw new ServiceFailure("1020", "The object specified by " + 

            pid.getValue() +

            "could not be returned due to database error: " +

            e.getMessage());

      } catch (ParseLSIDException e) {

        throw new ServiceFailure("1020", "The object specified by " + 

            pid.getValue() +

            "could not be returned due to a parse error: " +

            e.getMessage());

      } catch (InsufficientKarmaException e) {

	      // TODO Auto-generated catch block

	      e.printStackTrace();

      }

      //set a timer to clean up the temp files

      Timer t = new Timer();

      TimerTask tt = new TimerTask() {

          @Override

          public void run()

          {

              outputFile.delete();

          }

      };

      t.schedule(tt, 20000); //schedule after 20 secs

      try {

	      inputStream = new FileInputStream(outputFile);

      } catch (FileNotFoundException e) {

        throw new ServiceFailure("1020", "The object specified by " + 

          pid.getValue() +

          "could not be returned due to a file read error: " +

          e.getMessage());

      }			

		}

		// if we fail to set the input stream

		if ( inputStream == null ) {

      throw new NotFound("1020", "The object specified by " + 

                         pid.getValue() +

                         "does not exist at this node.");

		}

		return inputStream;

	}

	/**

	 * Return the system metadata for a given object

	 * 

	 * @param session - the Session object containing the credentials for the Subject

	 * @param pid - the object identifier for the given object

	 * 

	 * @return inputStream - the input stream of the given system metadata object

	 * 

	 * @throws InvalidToken

	 * @throws ServiceFailure

	 * @throws NotAuthorized

	 * @throws NotFound

	 * @throws InvalidRequest

	 * @throws NotImplemented

	 */

	public SystemMetadata getSystemMetadata(Session session, Identifier pid)

    throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,

    InvalidRequest, NotImplemented {

		if (!isAuthorized(session, pid, Permission.READ)) {

			throw new NotAuthorized("1400", Permission.READ + " not allowed on " + pid.getValue());	

		}

		SystemMetadata systemMetadata = null;

		try {

			systemMetadata = IdentifierManager.getInstance().getSystemMetadata(pid.getValue());

		} catch (McdbDocNotFoundException e) {

			throw new NotFound("1420", "No record found for: " + pid.getValue());

		}

		return systemMetadata;

  }

	/* End methods common to CNRead and MNRead APIs */

	/* Methods common to CNAuthorization and MNAuthorization APIs */

	/**

	 * Set access for a given object using the object identifier and a Subject

	 * under a given Session.

	 * 

	 * @param session - the Session object containing the credentials for the Subject

	 * @param pid - the object identifier for the given object to apply the policy

	 * @param policy - the access policy to be applied

	 * 

	 * @return true if the application of the policy succeeds

	 * @throws InvalidToken

	 * @throws ServiceFailure

	 * @throws NotFound

	 * @throws NotAuthorized

	 * @throws NotImplemented

	 * @throws InvalidRequest

	 */

	public boolean setAccessPolicy(Session session, Identifier pid, 

    AccessPolicy accessPolicy) 

	  throws InvalidToken, ServiceFailure, NotFound, NotAuthorized, 

	  NotImplemented, InvalidRequest {

		boolean success = false;

		// get the subject

		Subject subject = session.getSubject();

		// get the system metadata

		String guid = pid.getValue();

		// are we allowed to do this?

		if (!isAuthorized(session, pid, Permission.CHANGE_PERMISSION)) {

			throw new NotAuthorized("4420", "not allowed by " + subject.getValue() + " on " + guid);	

		}

		SystemMetadata systemMetadata = null;

		try {

			systemMetadata = IdentifierManager.getInstance().getSystemMetadata(guid);

		} catch (McdbDocNotFoundException e) {

			throw new NotFound("4400", "No record found for: " + guid);

		}

		// set the access policy

		systemMetadata.setAccessPolicy(accessPolicy);

		// update the metadata

		try {

			IdentifierManager.getInstance().updateSystemMetadata(systemMetadata);

			success = true;

		} catch (McdbDocNotFoundException e) {

			throw new ServiceFailure("4430", e.getMessage());

		}

		return success;

	}

	/**

	 * Test if the user identified by the provided token has authorization 

	 * for operation on the specified object.

	 * 

	 * @param session - the Session object containing the credentials for the Subject

	 * @param pid - The identifer of the resource for which access is being checked

	 * @param operation - The type of operation which is being requested for the given pid

	 *

	 * @return true if the operation is allowed

	 * 

	 * @throws ServiceFailure

	 * @throws InvalidToken

	 * @throws NotFound

	 * @throws NotAuthorized

	 * @throws NotImplemented

	 * @throws InvalidRequest

	 */

	public boolean isAuthorized(Session session, Identifier pid, Permission permission)

	  throws ServiceFailure, InvalidToken, NotFound, NotAuthorized,

	  NotImplemented, InvalidRequest {

		boolean allowed = false;

		// get the subjects from the session

		List<Subject> subjects = new ArrayList<Subject>();

		subjects.add(session.getSubject());

		for (Person p: session.getSubjectList().getPersonList()) {

			subjects.add(p.getSubject());

		}

		for (Group g: session.getSubjectList().getGroupList()) {

			subjects.add(g.getSubject());

		}

		// get the system metadata

		String guid = pid.getValue();

		SystemMetadata systemMetadata = null;

		try {

			systemMetadata = IdentifierManager.getInstance().getSystemMetadata(guid);

		} catch (McdbDocNotFoundException e) {

			throw new NotFound("1800", "No record found for: " + guid);

		}

		List<AccessRule> allows = systemMetadata.getAccessPolicy().getAllowList();

		for (AccessRule accessRule: allows) {

			for (Subject subject: subjects) {

				if (accessRule.getSubjectList().contains(subject)) {

					allowed = accessRule.getPermissionList().contains(permission);

					if (allowed) {

						break;

					}

				}

			}

		}

		// TODO: throw or return?

		if (!allowed) {

			throw new NotAuthorized("1820", permission + "not allowed on " + guid);

		}

		return allowed;

	}

	/* End methods common to CNAuthorization and MNAuthorization APIs */

	/**

	 * parse a logEntry and get the relevant field from it

	 * 

	 * @param fieldname

	 * @param entry

	 * @return

	 */

	private String getLogEntryField(String fieldname, String entry) {

		String begin = "<" + fieldname + ">";

		String end = "</" + fieldname + ">";

		// logMetacat.debug("looking for " + begin + " and " + end +

		// " in entry " + entry);

		String s = entry.substring(entry.indexOf(begin) + begin.length(), entry

				.indexOf(end));

		logMetacat.debug("entry " + fieldname + " : " + s);

		return s;

	}

  /**

   * set the params for this service from an HttpServletRequest param list

   */

  public void setParamsFromRequest(HttpServletRequest request) {

  	@SuppressWarnings("unchecked")

    Enumeration<String> paramlist = request.getParameterNames();

    while (paramlist.hasMoreElements()) {

      String name = (String) paramlist.nextElement();

      String[] value = (String[])request.getParameterValues(name);

      params.put(name, value);

    }

  }

}