Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class for upgrading the database to version 1.5

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Saurabh Garg

 *

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

import java.io.InputStream;

import java.math.BigInteger;

import java.sql.SQLException;

import java.util.Map;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.xpath.XPathExpressionException;

import org.apache.commons.io.IOUtils;

import org.dataone.eml.EMLDocument;

import org.dataone.eml.EMLDocument.DistributionMetadata;

import org.dataone.service.exceptions.NotFound;

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

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

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

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

import org.dataone.service.types.v1.util.ChecksumUtil;

import org.xml.sax.SAXException;

import edu.ucsb.nceas.metacat.AccessionNumberException;

import edu.ucsb.nceas.metacat.McdbDocNotFoundException;

import edu.ucsb.nceas.metacat.McdbException;

import edu.ucsb.nceas.metacat.dataone.hazelcast.HazelcastService;

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

import edu.ucsb.nceas.utilities.ParseLSIDException;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

public class SystemMetadataFactory {

	 * use this flag if you want to update any existing system metadata values with generated content

	 */

	private static boolean updateExisting = true;

	 *

	 * @param localId

	 *            The local document identifier

	 * @param user

	 *            The user submitting the system metadata document

	 * @param groups

	 *            The groups the user belongs to

	 *

	 * @return sysMeta The system metadata object created

	 * @throws HandlerException

	 * @throws AccessControlException

			IOException, AccessionNumberException, ClassNotFoundException,

			InsufficientKarmaException, ParseLSIDException,

			PropertyNotFoundException, BaseException, NoSuchAlgorithmException,

		SystemMetadata sysMeta = null;

		// get/make the guid

		String guid = null;

		try {

			// get the guid if it exists

			guid = IdentifierManager.getInstance().getGUID(accNum.getDocid(), rev);

		} catch (McdbDocNotFoundException dnfe) {

			// otherwise create the mapping

		// look up existing system metadata if it exists

		Identifier identifier = new Identifier();

		identifier.setValue(guid);

		try {

			// TODO: if this is the case, we could return here -- what else do we gain?

			if (!updateExisting ) {

				return sysMeta;

			}

		} catch (Exception e) {

		if (sysMeta == null) {

			sysMeta = new SystemMetadata();

			sysMeta.setIdentifier(identifier);

			sysMeta.setSerialVersion(BigInteger.valueOf(1));

			sysMeta.setArchived(false);

		}

		// set the object format, fall back to defaults

			// we don't know much about this file (yet)

			fmtid = ObjectFormatCache.getInstance().getFormat("application/octet-stream").getFormatId();

		} else {

			try {

				// do we know the given format?

				fmtid = ObjectFormatCache.getInstance().getFormat(doctype).getFormatId();

			} catch (NotFound nfe) {

				// format is not registered, use default

		}

		sysMeta.setFormatId(fmtid);

		InputStream inputStream = null;

		inputStream = MetacatHandler.read(localId);

		String algorithm = "MD5";

		Checksum checksum = ChecksumUtil.checksum(inputStream, algorithm);

		File fileOnDisk = getFileOnDisk(localId);

		long fileSize = 0;

		if (fileOnDisk.exists()) {

			fileSize = fileOnDisk.length();

		}

		sysMeta.setSize(BigInteger.valueOf(fileSize));

		// submitter

		Subject submitter = new Subject();

		submitter.setValue(docInfo.get("user_updated"));

		sysMeta.setSubmitter(submitter);

		// rights holder

		Subject owner = new Subject();

		owner.setValue(docInfo.get("user_owner"));

		sysMeta.setRightsHolder(owner);

		// dates

		String createdDateString = docInfo.get("date_created");

		String updatedDateString = docInfo.get("date_updated");

		Date createdDate = DateTimeMarshaller.deserializeDateToUTC(createdDateString);

		Date updatedDate = DateTimeMarshaller.deserializeDateToUTC(updatedDateString);

		sysMeta.setDateUploaded(createdDate);

		// use current datetime

		sysMeta.setDateSysMetadataModified(Calendar.getInstance().getTime());

		// set the revision history

		String docidWithoutRev = accNum.getDocid();

		Identifier obsoletedBy = null;

		Identifier obsoletes = null;

		Vector<Integer> revisions = DBUtil.getRevListFromRevisionTable(docidWithoutRev);

		Collections.sort(revisions);

			// use the docid+rev as the guid

			String existingPid = docidWithoutRev + "." + existingRev;

				existingPid = IdentifierManager.getInstance().getGUID(docidWithoutRev, existingRev);

			} catch (McdbDocNotFoundException mdfe) {

				// we'll be defaulting to the local id

				logMetacat.warn("could not locate guid when processing revision history for localId: " + localId);

			}

				// it's the old docid, until it's not

				obsoletes = new Identifier();

				obsoletes.setValue(existingPid);

			}

			if (existingRev > rev) {

				// it's the newer docid

				obsoletedBy = new Identifier();

				obsoletedBy.setValue(existingPid);

				// only want the version just after it

				break;

			}

		}

		sysMeta.setObsoletes(obsoletes);

		if (obsoletedBy != null) {

			try {

				//obsoletedBySysMeta = HazelcastService.getInstance().getSystemMetadataMap().get(obsoletedBy);

				obsoletedBySysMeta = IdentifierManager.getInstance().getSystemMetadata(obsoletedBy.getValue());

			} catch (McdbDocNotFoundException e) {

				// ignore

			}

				obsoletedBySysMeta.setObsoletes(identifier);

				HazelcastService.getInstance().getSystemMetadataMap().put(obsoletedBy, obsoletedBySysMeta);

			}

		}

		if (obsoletes != null) {

			try {

				//obsoletesSysMeta = HazelcastService.getInstance().getSystemMetadataMap().get(obsoletes);

				obsoletesSysMeta = IdentifierManager.getInstance().getSystemMetadata(obsoletes.getValue());

			} catch (McdbDocNotFoundException e) {

				// ignore

			}

				obsoletesSysMeta.setObsoletedBy(identifier);

				HazelcastService.getInstance().getSystemMetadataMap().put(obsoletes, obsoletesSysMeta);

		}

		AccessPolicy accessPolicy = IdentifierManager.getInstance().getAccessPolicy(guid);

		// authoritative node

		NodeReference nr = new NodeReference();

		sysMeta.setAuthoritativeMemberNode(nr);

        ReplicationPolicy rp = getDefaultReplicationPolicy();

        if (rp != null) {

            sysMeta.setReplicationPolicy(rp);

        }

		// describes and describedBy information

		if (fmtid == ObjectFormatCache.getInstance().getFormat(

				"eml://ecoinformatics.org/eml-2.0.0").getFormatId()

				|| fmtid == ObjectFormatCache.getInstance().getFormat(

						"eml://ecoinformatics.org/eml-2.0.1").getFormatId()

				|| fmtid == ObjectFormatCache.getInstance().getFormat(

						"eml://ecoinformatics.org/eml-2.1.0").getFormatId()

				|| fmtid == ObjectFormatCache.getInstance().getFormat(

						"eml://ecoinformatics.org/eml-2.1.1").getFormatId()) {

			try {

				// get it again to parse the document

				logMetacat.debug("Re-reading document inputStream");

				DataoneEMLParser emlParser = DataoneEMLParser.getInstance();

		        EMLDocument emlDocument = emlParser.parseDocument(inputStream);

	            Map<Identifier, List<Identifier>> idMap = new HashMap<Identifier, List<Identifier>>();

	            List<Identifier> dataIds = new ArrayList<Identifier>();

					for (int j = 0; j < emlDocument.distributionMetadata.size(); j++) {

				        String dataDocUrl = distMetadata.url;

				        String dataDocMimeType = distMetadata.mimeType;

						if (dataDocMimeType == null) {

						// process the data

						Identifier dataGuid = new Identifier();

						// handle ecogrid, or downloadable data

						String ecogridPrefix = "ecogrid://knb/";

						if (dataDocUrl.trim().startsWith(ecogridPrefix)) {

							dataDocLocalId = dataDocUrl.substring(dataDocUrl.indexOf(ecogridPrefix) + ecogridPrefix.length());

						} else {

							// should we try downloading the remote data?

							if (downloadData) {

								InputStream dataObject = null;

								try {

									// download the data from the URL

									URL dataURL = new URL(dataDocUrl);

									// default is to download the data

									dataObject = dataConnection.getInputStream();

									String detectedContentType = dataConnection.getContentType();

									logMetacat.info("Detected content type: " + detectedContentType);

									if (detectedContentType != null) {

										// seems to be HTML from the remote location

										if (detectedContentType.contains("html")) {

											// if we are not expecting it, we skip it

											if (!dataDocMimeType.contains("html")) {

												// set to null so we don't download it

												dataObject = null;

												logMetacat.warn("Skipping remote resource, unexpected HTML content type at: " + dataDocUrl);

											}

										}

									} else {

										// if we don't know what it is, should we skip it?

										dataObject = null;

										logMetacat.warn("Skipping remote resource, unknown content type at: " + dataDocUrl);

									}

									// error with the download

									logMetacat.warn("Error downloading remote data. " + e.getMessage());

								}

								if (dataObject != null) {

									// create the local version of it

									dataDocLocalId = DocumentUtil.generateDocumentId(1);

									IdentifierManager.getInstance().createMapping(dataDocLocalId, dataDocLocalId);

									dataGuid.setValue(dataDocLocalId);

									// save it locally

									Session session = new Session();

									session.setSubject(submitter);

									MockHttpServletRequest request = new MockHttpServletRequest(null, null, null);

									MNodeService.getInstance(request).insertDataObject(dataObject, dataGuid, session);

									remoteData = true;

							}

						}

						logMetacat.debug("Data URL     : " + dataDocUrl);

						logMetacat.debug("Data mime    : " + dataDocMimeType);

						String dataDocid = null;

						int dataRev = 0;

						if (dataDocLocalId != null) {

							// look up the guid for the data

							try {

								dataDocid = DocumentUtil.getSmartDocId(dataDocLocalId);

								dataRev = DocumentUtil.getRevisionFromAccessionNumber(dataDocLocalId);

							} catch (Exception e) {

								logMetacat.warn(e.getClass().getName() + " - Problem parsing accession number for: " + dataDocLocalId + ". Message: " + e.getMessage());

								dataDocLocalId = null;

							}

						}

						if (dataDocLocalId != null) {

							// check if data system metadata exists already

							SystemMetadata dataSysMeta = null;

							String dataGuidString = null;

								} catch (Exception e) {

									// probably not in the system

									dataSysMeta = null;

							} catch (McdbDocNotFoundException nf) {

								// we didn't find it

								dataSysMeta = null;

							}

							if (dataSysMeta == null) {

								// System metadata for data doesn't exist yet, so create it

								// now look it up again

								dataGuidString = IdentifierManager.getInstance().getGUID(dataDocid, dataRev);

								// set the guid

								dataGuid.setValue(dataGuidString);

								// inherit access rules from metadata, if we don't have our own

								if (remoteData) {

									dataSysMeta.setAccessPolicy(sysMeta.getAccessPolicy());

									// TODO: use access rules defined in EML, per data file

								}

							}

								logMetacat.debug("Couldn't find format identifier for: "

												+ dataDocMimeType

												+ ". Setting it to application/octet-stream.");

								fmt.setValue("application/octet-stream");

							HazelcastService.getInstance().getSystemMetadataMap().put(dataSysMeta.getIdentifier(), dataSysMeta);

							// include as part of the ORE package

						} // end if (EML package)

					} // end for (data entities)

	            } // data entities not null

			        	if (!oreExistsFor(sysMeta.getIdentifier())) {

				            // generate the ORE map for this datapackage

				            Identifier resourceMapId = new Identifier();

				            resourceMapId.setValue(resourceMapPrefix + localId);

				            ResourceMap rm = ResourceMapFactory.getInstance().createResourceMap(resourceMapId, idMap);

				            String resourceMapXML = ResourceMapFactory.getInstance().serializeResourceMap(rm);

				            // copy most of the same system metadata as the packaging metadata

				            SystemMetadata resourceMapSysMeta = new SystemMetadata();

				            BeanUtils.copyProperties(resourceMapSysMeta, sysMeta);

				            resourceMapSysMeta.setIdentifier(resourceMapId);

				            Checksum oreChecksum = ChecksumUtil.checksum(IOUtils.toInputStream(resourceMapXML, MetaCatServlet.DEFAULT_ENCODING), "MD5");

							resourceMapSysMeta.setChecksum(oreChecksum);

				            ObjectFormatIdentifier formatId = ObjectFormatCache.getInstance().getFormat("http://www.openarchives.org/ore/terms").getFormatId();

							resourceMapSysMeta.setFormatId(formatId);

							resourceMapSysMeta.setSize(BigInteger.valueOf(sizeOfStream(IOUtils.toInputStream(resourceMapXML, MetaCatServlet.DEFAULT_ENCODING))));

							// set the revision graph

							resourceMapSysMeta.setObsoletes(null);

							resourceMapSysMeta.setObsoletedBy(null);

							// look up the resource map that this one obsoletes

							if (sysMeta.getObsoletes() != null) {

								Identifier resourceMapObsoletes = new Identifier();

								resourceMapObsoletes.setValue(resourceMapPrefix + sysMeta.getObsoletes().getValue());

								resourceMapSysMeta.setObsoletes(resourceMapObsoletes);

								SystemMetadata resourceMapObsoletesSystemMetadata = HazelcastService.getInstance().getSystemMetadataMap().get(resourceMapObsoletes);

								if (resourceMapObsoletesSystemMetadata != null) {

									resourceMapObsoletesSystemMetadata.setObsoletedBy(resourceMapId);

									HazelcastService.getInstance().getSystemMetadataMap().put(resourceMapObsoletes, resourceMapObsoletesSystemMetadata);

								}

							}

							// look up the resource map that this one is obsoletedBy

							if (sysMeta.getObsoletedBy() != null) {

								Identifier resourceMapObsoletedBy = new Identifier();

								resourceMapObsoletedBy.setValue(resourceMapPrefix + sysMeta.getObsoletedBy().getValue());

								resourceMapSysMeta.setObsoletedBy(resourceMapObsoletedBy);

								SystemMetadata resourceMapObsoletedBySystemMetadata = HazelcastService.getInstance().getSystemMetadataMap().get(resourceMapObsoletedBy);

								if (resourceMapObsoletedBySystemMetadata != null) {

									resourceMapObsoletedBySystemMetadata.setObsoletes(resourceMapId);

									HazelcastService.getInstance().getSystemMetadataMap().put(resourceMapObsoletedBy, resourceMapObsoletedBySystemMetadata);

								}

							}

							if (!IdentifierManager.getInstance().identifierExists(resourceMapId.getValue())) {

								Session session = new Session();

								session.setSubject(submitter);

								MockHttpServletRequest request = new MockHttpServletRequest(null, null, null);

								MNodeService.getInstance(request).insertDataObject(IOUtils.toInputStream(resourceMapXML, MetaCatServlet.DEFAULT_ENCODING), resourceMapId, session);

								MNodeService.getInstance(request).insertSystemMetadata(resourceMapSysMeta);

								logMetacat.info("Inserted ORE package: " + resourceMapId.getValue());

							}

				}

			} catch (ParserConfigurationException pce) {

			} catch (SAXException saxe) {

			} catch (XPathExpressionException xpee) {

			} catch (Exception e) {

		} // end if()

		return sysMeta;

	}

    /**

     * not already have it.  SystemMetadata documents themselves, are, of course,

     * exempt.  This is a utility method for migration of existing object

     * stores to DataONE where SystemMetadata is required for all objects.

     * @param idList

     * @param includeOre

     * @param downloadData

     * @throws PropertyNotFoundException

     * @throws NoSuchAlgorithmException

     * @throws AccessionNumberException

     * @throws SQLException

	 * @throws HandlerException

	 * @throws JiBXException

	 * @throws BaseException

	 * @throws ParseLSIDException

	 * @throws InsufficientKarmaException

	 * @throws ClassNotFoundException

	 * @throws IOException

	 * @throws McdbException

	 * @throws AccessException

	 * @throws AccessControlException

    public static void generateSystemMetadata(List<String> idList, boolean includeOre, boolean downloadData)

        for (String localId : idList) {

            SystemMetadata sm = null;

            //generate required system metadata fields from the document

            	sm = SystemMetadataFactory.createSystemMetadata(localId, includeOre, downloadData);

            } catch (Exception e) {

				logMetacat.error("Could not create/process system metadata for docid: " + localId, e);

				continue;

			}

            boolean exists = IdentifierManager.getInstance().systemMetadataExists(sm.getIdentifier().getValue());

            if (!exists) {

            	IdentifierManager.getInstance().insertSystemMetadata(sm);

            	logMetacat.info("Generated SystemMetadata for " + localId);

            } else {

            	IdentifierManager.getInstance().updateSystemMetadata(sm);

            	logMetacat.info("Updated SystemMetadata for " + localId);

            }

	/**

	 * @param guid of the EML/packaging object

	 * @return true if there is an ORE map for the given package

	 */

	private static boolean oreExistsFor(Identifier guid) {

		// TODO: implement call to CN.search()

		return false;

	}

	 * of MetacatHandler and into a utility when stream i/o in Metacat is

	 * evaluated.

	 *

	 * @param is The InputStream of bytes

	 *

	 * @return size The size in bytes of the input stream as a long

	 *

	 * @throws IOException

	 */

	private static long sizeOfStream(InputStream is) throws IOException {

		long size = 0;

		byte[] b = new byte[1024];

		int numread = is.read(b, 0, 1024);

		while (numread != -1) {

			size += numread;

			numread = is.read(b, 0, 1024);

		}

		return size;

	}

	private static File getFileOnDisk(String docid) throws McdbException, PropertyNotFoundException {

		DocumentImpl doc = new DocumentImpl(docid, false);

		String filepath = null;

		String filename = null;

		// deal with data or metadata cases

		if (doc.getRootNodeID() == 0) {

			// this is a data file

			filepath = PropertyService.getProperty("application.datafilepath");

		} else {

			filepath = PropertyService.getProperty("application.documentfilepath");

		}

		// ensure it is a directory path

		if (!(filepath.endsWith("/"))) {

			filepath += "/";

		}

		filename = filepath + docid;

		File documentFile = new File(filename);