Metacat

/**

 *  '$RCSfile$'

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

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author$'

 *     '$Date$'

 *

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

import java.io.IOException;

import java.io.InputStream;

import java.sql.SQLException;

import java.util.Calendar;

import java.util.Date;

import java.util.HashMap;

import java.util.Vector;

import org.apache.log4j.Logger;

import org.dataone.cn.batch.utils.TypeMarshaller;

import org.dataone.service.cn.CNCore;

import org.dataone.service.exceptions.IdentifierNotUnique;

import org.dataone.service.exceptions.InsufficientResources;

import org.dataone.service.exceptions.InvalidRequest;

import org.dataone.service.exceptions.InvalidSystemMetadata;

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.exceptions.UnsupportedType;

import org.dataone.service.types.Event;

import org.dataone.service.types.Identifier;

import org.dataone.service.types.Log;

import org.dataone.service.types.LogEntry;

import org.dataone.service.types.NodeList;

import org.dataone.service.types.NodeReference;

import org.dataone.service.types.ObjectFormat;

import org.dataone.service.types.ObjectFormatIdentifier;

import org.dataone.service.types.ObjectFormatList;

import org.dataone.service.types.Session;

import org.dataone.service.types.Subject;

import org.dataone.service.types.SystemMetadata;

import org.jibx.runtime.JiBXException;

import edu.ucsb.nceas.metacat.DBUtil;

import edu.ucsb.nceas.metacat.DocumentImpl;

import edu.ucsb.nceas.metacat.EventLog;

import edu.ucsb.nceas.metacat.IdentifierManager;

import edu.ucsb.nceas.metacat.McdbException;

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

import edu.ucsb.nceas.metacat.replication.ForceReplicationSystemMetadataHandler;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

/**

 * 

 * Implements DataONE CNCore services for Metacat. 

 * 

 * @author leinfelder

 */

public class CNCoreImpl implements CNCore

{

  private static CNCoreImpl instance = null;

  private Logger logMetacat = null;

  /* The scope of the object formats docid used as the metacat identifier */

  private final String OBJECT_FORMAT_DOCID = "OBJECT_FORMAT_LIST.1";

  /* The revision of the object formats document */

  private int rev;

  /* The separator of the object formats document */

  private String separator = ".";

  /* The accession number of the object formats document */

  private String accNumber = null;

  /* The list of object formats */

  private ObjectFormatList objectFormatList = null;

  /* the searchable map of object formats */

  private static HashMap<String, ObjectFormat> objectFormatMap;

  /**

   * singleton accessor

   */

  public static CNCoreImpl getInstance() 

  {

    if (instance == null) {

      instance = new CNCoreImpl();

    }

    return instance;

  }

  /**

   * Constructor, private for singleton access

   */

  private CNCoreImpl() {

    logMetacat = Logger.getLogger(CNCoreImpl.class);

  }

    /**

     * register System Metadata without data/metadata object

     */

	  @Override

    public boolean registerSystemMetadata(Session session, Identifier guid,

      SystemMetadata sysmeta) throws NotImplemented, NotAuthorized,

      ServiceFailure, InvalidRequest, InvalidSystemMetadata {

	  	// TODO: control who can call this?

      if (session == null) {

          //TODO: many of the thrown exceptions do not use the correct error codes

          //check these against the docs and correct them

          throw new NotAuthorized("4861", "No Session - could not authorize to registration." +

                  "  If you are not logged in, please do so and retry the request.");

      }

      // verify that guid == SystemMetadata.getIdentifier()

      logMetacat.debug("Comparing guid|sysmeta_guid: " + guid.getValue() + "|" + sysmeta.getIdentifier().getValue());

      if (!guid.getValue().equals(sysmeta.getIdentifier().getValue())) {

          throw new InvalidRequest("4863", 

              "GUID in method call (" + guid.getValue() + ") does not match GUID in system metadata (" +

              sysmeta.getIdentifier().getValue() + ").");

      }

      logMetacat.debug("Checking if identifier exists...");

      // Check that the identifier does not already exist

      IdentifierManager im = IdentifierManager.getInstance();

      if (im.identifierExists(guid.getValue())) {

          throw new InvalidRequest("4863", 

              "GUID is already in use by an existing object.");

      }

      // insert the system metadata into the object store

      logMetacat.debug("Starting to insert SystemMetadata...");

      sysmeta.setDateSysMetadataModified(new Date());

      try {

		    IdentifierManager.getInstance().createSystemMetadata(sysmeta);

		    IdentifierManager.getInstance().updateSystemMetadata(sysmeta);

		    // force replication of this record

		    ForceReplicationSystemMetadataHandler forceReplication = 

		    	new ForceReplicationSystemMetadataHandler(guid.getValue(), null);

	    } catch (Exception e) {

          throw new ServiceFailure("4862", "Error inserting system metadata: " + e.getClass() + ": " + e.getMessage());

	    }

      logMetacat.debug("Returning from registerSystemMetadata");

      EventLog.getInstance().log(null, session.getSubject().getValue(), guid.getValue(), "registerSystemMetadata");

      return true;

    }

	@Override

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

			Event event) throws InvalidToken, InvalidRequest, ServiceFailure,

			NotAuthorized, 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;

	}

	/**

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

	}

  /**

   * Return the object format based on the given object format identifier

   * @param fmtid - the object format identifier to look up

   * @return objectFormat - the desired object format

   */

  @Override

	public ObjectFormat getFormat(ObjectFormatIdentifier fmtid) 

	  throws InvalidRequest, ServiceFailure, NotFound, InsufficientResources, 

	  NotImplemented {

  	logMetacat.debug("CNCoreImpl.getFormat() called.");

    ObjectFormat objectFormat = null;

    // look up the format in the object format map

	    objectFormat = getObjectFormatMap().get(fmtid.getValue());

	    // refresh the object format list if the format is null

	    if ( objectFormat == null ) {

	    	getCachedList();

	      objectFormat = getObjectFormatMap().get(fmtid.getValue());

	      // the object format isn't registered

	      if ( objectFormat == null ) {

		      throw new NotFound("4848", "The format specified by " + fmtid.getValue() + 

	        " does not exist at this node.");

	      }

	    }

  	return objectFormat;

	}

	@Override

	public NodeList listNodes() throws NotImplemented, ServiceFailure {

		// TODO Auto-generated method stub

		return null;

	}

	/**

	 * Return the list of object formats registered from the Coordinating Node.

	 * @return objectFormatList -  the list of object formats

	 */

	@Override

  public ObjectFormatList listFormats() throws InvalidRequest, ServiceFailure,

    NotFound, InsufficientResources, NotImplemented {

		try {

	    objectFormatList = getInstance().getCachedList();

		} catch (ServiceFailure sfe) {

    	throw sfe;

		} catch (NotFound nfe) {

    	throw nfe;

		}

		return objectFormatList;

  }

	@Override

	public Identifier create(Session arg0, Identifier arg1, InputStream arg2,

			SystemMetadata arg3) throws InvalidToken, ServiceFailure,

			NotAuthorized, IdentifierNotUnique, UnsupportedType,

			InsufficientResources, InvalidSystemMetadata, NotImplemented,

			InvalidRequest {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	public Identifier reserveIdentifier(Session arg0, Identifier arg1,

			String arg2, String arg3) throws InvalidToken, ServiceFailure,

			NotAuthorized, IdentifierNotUnique, NotImplemented, InvalidRequest {

		// TODO Auto-generated method stub

		return null;

	}

  /*

   * Return the hash containing the fmtid and format mapping

   * 

   * @return objectFormatMap - the hash of fmtid/format pairs

   */

  private HashMap<String, ObjectFormat> getObjectFormatMap() {

  	if ( objectFormatMap == null ) {

  		objectFormatMap = new HashMap<String, ObjectFormat>();

  	}

  	return objectFormatMap;

  }

  /**

   * Get the object format list cached in Metacat

   */

  private ObjectFormatList getCachedList()

    throws NotFound, ServiceFailure {

  	ObjectFormatList objectFormatList = null;

    try {

      // reset the accession number separator in case it is 

      // different than the default

      try {

        separator = PropertyService.getProperty("document.accNumSeparator");

      } catch ( PropertyNotFoundException pnfe ) {

        // use the default separator, but log the issue

        logMetacat.debug("There was a problem finding the document " +

          "separator property. The error message was: " + pnfe.getMessage());

      }

      // get the latest accession number if it is in Metacat

      this.rev = 

        DBUtil.getLatestRevisionInDocumentTable(this.OBJECT_FORMAT_DOCID);

      if ( this.rev != -1 ) {

        this.accNumber = this.OBJECT_FORMAT_DOCID + 

                         this.separator + 

                         this.rev;

        DocumentImpl objectFormatsDocument = new DocumentImpl(accNumber, false);

        ByteArrayInputStream bais = 

          new ByteArrayInputStream(objectFormatsDocument.toString().getBytes());

        // deserialize the object format list

        try {

        	objectFormatList = 

        		TypeMarshaller.unmarshalTypeFromStream(ObjectFormatList.class, bais);

        } catch (IOException e) {

        	throw new ServiceFailure("4841", "Unexpected exception from the service - " + 

        		e.getClass() + ": " + e.getMessage());

        } catch (InstantiationException e) {

         	throw new ServiceFailure("4841", "Unexpected exception from the service - " + 

        		e.getClass() + ": " + e.getMessage());

        } catch (IllegalAccessException e) {

         	throw new ServiceFailure("4841", "Unexpected exception from the service - " + 

        		e.getClass() + ": " + e.getMessage());

        } catch (JiBXException e) {

         	throw new ServiceFailure("4841", "Unexpected exception from the service - " + 

        		e.getClass() + ": " + e.getMessage());

        }

      } else {

        throw new NotFound("4843", "The object formats collection could not " +

        	"be found at this node.");

      }

    } catch ( SQLException sqle ) {      

     	throw new ServiceFailure("4841", "Unexpected exception from the service - " + 

      		sqle.getClass() + ": " + sqle.getMessage());

    } catch (McdbException mcdbe) {      

     	throw new ServiceFailure("4841", "Unexpected exception from the service - " + 

     			mcdbe.getClass() + ": " + mcdbe.getMessage());

    }

    // index the object format list based on the format identifier string

    int listSize = objectFormatList.sizeObjectFormats();

    for (int i = 0; i < listSize; i++ ) {

      ObjectFormat objectFormat = 

        objectFormatList.getObjectFormat(i);

      String identifier = objectFormat.getFmtid().getValue();

      getObjectFormatMap().put(identifier, objectFormat);

    }

    return objectFormatList;

  }

}

			CNCoreImpl.getInstance().registerSystemMetadata(session, guid, sysmeta);

	    objectFormatList = CNCoreImpl.getInstance().listFormats();

				CNCoreImpl.getInstance().getFormat(fmtid).getFmtid().getValue();

	    	CNCoreImpl.getInstance().getFormat(fmtid);

import edu.ucsb.nceas.metacat.dataone.CNCoreImpl;

	      ObjectFormatList objectFormatList = CNCoreImpl.getInstance().listFormats();

	      ObjectFormat objectFormat = CNCoreImpl.getInstance().getFormat(fmtid);

			boolean result = CNCoreImpl.getInstance().registerSystemMetadata(