Java tutorial
/* The contents of this file are subject to the license and copyright terms * detailed in the license directory at the root of the source tree (also * available online at http://fedora-commons.org/license/). */ package org.fcrepo.server.management; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.UnsupportedEncodingException; import java.net.URI; import java.net.URISyntaxException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Comparator; import java.util.Date; import java.util.HashMap; import java.util.Hashtable; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import java.util.regex.Pattern; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import org.apache.commons.betwixt.XMLUtils; import org.apache.commons.io.IOUtils; import org.fcrepo.common.Constants; import org.fcrepo.common.PID; import org.fcrepo.common.rdf.SimpleURIReference; import org.fcrepo.server.Context; import org.fcrepo.server.RecoveryContext; import org.fcrepo.server.Server; import org.fcrepo.server.errors.DatastreamLockedException; import org.fcrepo.server.errors.DatastreamNotFoundException; import org.fcrepo.server.errors.GeneralException; import org.fcrepo.server.errors.InvalidStateException; import org.fcrepo.server.errors.InvalidXMLNameException; import org.fcrepo.server.errors.ObjectLockedException; import org.fcrepo.server.errors.ObjectNotFoundException; import org.fcrepo.server.errors.ObjectNotInLowlevelStorageException; import org.fcrepo.server.errors.ServerException; import org.fcrepo.server.errors.StreamReadException; import org.fcrepo.server.errors.StreamWriteException; import org.fcrepo.server.errors.ValidationException; import org.fcrepo.server.errors.authorization.AuthzException; import org.fcrepo.server.security.Authorization; import org.fcrepo.server.storage.ContentManagerParams; import org.fcrepo.server.storage.DOManager; import org.fcrepo.server.storage.DOReader; import org.fcrepo.server.storage.DOWriter; import org.fcrepo.server.storage.ExternalContentManager; import org.fcrepo.server.storage.types.AuditRecord; import org.fcrepo.server.storage.types.Datastream; import org.fcrepo.server.storage.types.DatastreamManagedContent; import org.fcrepo.server.storage.types.DatastreamReferencedContent; import org.fcrepo.server.storage.types.DatastreamXMLMetadata; import org.fcrepo.server.storage.types.MIMETypedStream; import org.fcrepo.server.storage.types.RelationshipTuple; import org.fcrepo.server.storage.types.Validation; import org.fcrepo.server.storage.types.XMLDatastreamProcessor; import org.fcrepo.server.utilities.DCFields; import org.fcrepo.server.utilities.StreamUtility; import org.fcrepo.server.validation.ValidationConstants; import org.fcrepo.server.validation.ValidationUtility; import org.fcrepo.server.validation.ecm.EcmValidator; import org.fcrepo.utilities.DateUtility; import org.jrdf.graph.URIReference; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.w3c.dom.Document; import com.sun.org.apache.xml.internal.serialize.OutputFormat; import com.sun.org.apache.xml.internal.serialize.XMLSerializer; /** * Implements API-M without regard to the transport/messaging protocol. * * @author Chris Wilper * @version $Id$ */ public class DefaultManagement implements Constants, Management, ManagementDelegate { private static final Logger logger = LoggerFactory.getLogger(DefaultManagement.class); private final Authorization m_authz; private final DOManager m_manager; private final ExternalContentManager m_contentManager; private final int m_uploadStorageMinutes; private int m_lastId; private final File m_tempDir; private final Hashtable<String, Long> m_uploadStartTime; private long m_lastPurgeInMillis = System.currentTimeMillis(); private final long m_purgeDelayInMillis; private final EcmValidator ecmValidator; // FCREPO-765: move to Admin module private static final String xmlHeader = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"; /** * @param purgeDelayInMillis milliseconds to delay before removing * old uploaded files * @author Frederic Buffet & Tommy Bourdin (Atos Worldline) * @date August 1, 2008 */ public DefaultManagement(Authorization authz, DOManager doMgr, ExternalContentManager ecMgr, int uploadMinutes, int lastId, File tempDir, Hashtable<String, Long> uploadStartTime, long purgeDelayInMillis) { m_authz = authz; m_manager = doMgr; m_contentManager = ecMgr; m_uploadStorageMinutes = uploadMinutes; m_lastId = lastId; m_tempDir = tempDir; m_uploadStartTime = uploadStartTime; m_purgeDelayInMillis = purgeDelayInMillis; ecmValidator = new EcmValidator(doMgr, m_contentManager); //TODO, this should be controllable with the fcfg } @Override public String ingest(Context context, InputStream serialization, String logMessage, String format, String encoding, String pid) throws ServerException { DOWriter w = null; String objPid = null; try { logger.debug("Entered ingest"); w = m_manager.getIngestWriter(Server.USE_DEFINITIVE_STORE, context, serialization, format, encoding, pid); objPid = w.GetObjectPID(); m_authz.enforceIngest(context, objPid, format, encoding); // Only create an audit record if there is a log message to capture if (logMessage != null && !logMessage.equals("")) { Date nowUTC = Server.getCurrentDate(context); addAuditRecord(context, w, "ingest", "", logMessage, nowUTC); } w.commit(logMessage); return objPid; } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed ingest("); logMsg.append("objectXML"); logMsg.append(", format: ").append(format); logMsg.append(", encoding: ").append(encoding); logMsg.append(", pid : ").append(objPid); logMsg.append(", logMessage: ").append(logMessage); logMsg.append(")"); logger.info(logMsg.toString()); } finishModification(w, "ingest"); } } private void finishModification(DOWriter w, String method) throws ServerException { if (w != null) { m_manager.releaseWriter(w); } if (logger.isDebugEnabled()) { logger.debug("Exiting " + method); Runtime r = Runtime.getRuntime(); logger.debug("Memory: " + r.freeMemory() + " bytes free of " + r.totalMemory() + " available."); } } @Override public Date modifyObject(Context context, String pid, String state, String label, String ownerId, String logMessage, Date lastModifiedDate) throws ServerException { DOWriter w = null; try { logger.debug("Entered modifyObject"); m_authz.enforceModifyObject(context, pid, state, ownerId); checkObjectLabel(label); w = m_manager.getWriter(Server.USE_DEFINITIVE_STORE, context, pid); // if provided, check request lastModifiedDate against the object, // rejecting the request if the object's mod date is more recent. if (lastModifiedDate != null) { if (lastModifiedDate.before(w.getLastModDate())) { String objDate = DateUtility.convertDateToXSDString(w.getLastModDate()); String reqDate = DateUtility.convertDateToXSDString(lastModifiedDate); String msg = String.format( "%s lastModifiedDate (%s) " + "is more recent than the " + "request (%s)", pid, objDate, reqDate); throw new ObjectLockedException(msg); } } if (state != null && !state.equals("")) { if (!state.equals("A") && !state.equals("D") && !state.equals("I")) { throw new InvalidStateException( "The object state of \"" + state + "\" is invalid. The allowed values for state are: " + " A (active), D (deleted), and I (inactive)."); } w.setState(state); } if (label != null) { w.setLabel(label); } if (ownerId != null) { w.setOwnerId(ownerId); } // Update audit trail Date nowUTC = Server.getCurrentDate(context); addAuditRecord(context, w, "modifyObject", "", logMessage, nowUTC); w.commit(logMessage); return w.getLastModDate(); } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed modifyObject("); logMsg.append("pid: ").append(pid); logMsg.append(", state: ").append(state); logMsg.append(", label: ").append(label); logMsg.append(", ownderId: ").append(ownerId); logMsg.append(", logMessage: ").append(logMessage); logMsg.append(")"); logger.info(logMsg.toString()); } finishModification(w, "modifyObject"); } } @Override public InputStream getObjectXML(Context context, String pid, String encoding) throws ServerException { try { logger.debug("Entered getObjectXML"); m_authz.enforceGetObjectXML(context, pid, encoding); DOReader reader = m_manager.getReader(Server.USE_DEFINITIVE_STORE, context, pid); InputStream instream = reader.GetObjectXML(); return instream; } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed getObjectXML("); logMsg.append("pid: ").append(pid); logMsg.append(", encoding: ").append(encoding); logMsg.append(")"); logger.info(logMsg.toString()); } logger.debug("Exiting getObjectXML"); } } @Override public InputStream export(Context context, String pid, String format, String exportContext, String encoding) throws ServerException { try { logger.debug("Entered export"); m_authz.enforceExport(context, pid, format, exportContext, encoding); DOReader reader = m_manager.getReader(Server.USE_DEFINITIVE_STORE, context, pid); InputStream instream = reader.Export(format, exportContext); return instream; } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed export("); logMsg.append("pid: ").append(pid); logMsg.append(", format: ").append(format); logMsg.append(", exportContext: ").append(exportContext); logMsg.append(", encoding: ").append(encoding); logMsg.append(")"); logger.info(logMsg.toString()); } logger.debug("Exiting export"); } } @Override public Date purgeObject(Context context, String pid, String logMessage) throws ServerException { /* if (force) { throw new GeneralException("Forced object removal is not " + "yet supported."); } */ DOWriter w = null; try { logger.debug("Entered purgeObject"); m_authz.enforcePurgeObject(context, pid); w = m_manager.getWriter(Server.USE_DEFINITIVE_STORE, context, pid); w.remove(); w.commit(logMessage); Date serverDate = Server.getCurrentDate(context); return serverDate; } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed purgeObject("); logMsg.append("pid: ").append(pid); logMsg.append(", logMessage: ").append(logMessage); logMsg.append(")"); logger.info(logMsg.toString()); } finishModification(w, "purgeObject"); } } @Override public String addDatastream(Context context, String pid, String dsID, String[] altIDs, String dsLabel, boolean versionable, String MIMEType, String formatURI, String dsLocation, String controlGroup, String dsState, String checksumType, String checksum, String logMessage) throws ServerException { logger.debug("Entered addDatastream"); // empty MIME types are allowed. assume they meant "" if they provide it // as null. if (MIMEType == null) { MIMEType = ""; } // empty altIDs are allowed. assume they meant String[0] if they provide // it as null. if (altIDs == null) { altIDs = new String[0]; } // If the datastream ID is not specified directly, see // if we can get it from the RecoveryContext if (dsID == null && context instanceof RecoveryContext) { RecoveryContext rContext = (RecoveryContext) context; dsID = rContext.getRecoveryValue(Constants.RECOVERY.DATASTREAM_ID.uri); if (dsID != null) { logger.debug("Using new dsID from recovery context"); } } // check for valid xml name for datastream ID if (dsID != null) { if (!XMLUtils.isWellFormedXMLName(dsID)) { throw new InvalidXMLNameException("Invalid syntax for datastream ID. " + "The datastream ID of \"" + dsID + "\" is" + "not a valid XML Name"); } } if (dsID != null && (dsID.equals("AUDIT") || dsID.equals("FEDORA-AUDITTRAIL"))) { throw new GeneralException("Creation of a datastream with an" + " identifier of 'AUDIT' or 'FEDORA-AUDITTRAIL' is not permitted."); } DOWriter w = null; try { m_authz.enforceAddDatastream(context, pid, dsID, altIDs, MIMEType, formatURI, dsLocation, controlGroup, dsState, checksumType, checksum); checkDatastreamID(dsID); checkDatastreamLabel(dsLabel); w = m_manager.getWriter(Server.USE_DEFINITIVE_STORE, context, pid); Datastream ds; if (controlGroup.equals("X")) { ds = new DatastreamXMLMetadata(); ds.DSInfoType = ""; // field is now deprecated try { InputStream in; MIMETypedStream mimeTypedStream = null; if (dsLocation.startsWith(DatastreamManagedContent.UPLOADED_SCHEME)) { in = getTempStream(dsLocation); } else { ContentManagerParams params = new ContentManagerParams(dsLocation); params.setContext(context); mimeTypedStream = m_contentManager.getExternalContent(params); in = mimeTypedStream.getStream(); } // set and validate the content DatastreamXMLMetadata dsm = (DatastreamXMLMetadata) ds; dsm.xmlContent = getEmbeddableXML(in); dsm.DSSize = dsm.xmlContent.length; ValidationUtility.validateReservedDatastream(PID.getInstance(pid), dsID, dsm); if (mimeTypedStream != null) { mimeTypedStream.close(); } } catch (Exception e) { String extraInfo; if (e.getMessage() == null) { extraInfo = ""; } else { extraInfo = " : " + e.getMessage(); } throw new GeneralException("Error with " + dsLocation + extraInfo); } } else if (controlGroup.equals("M")) { ds = new DatastreamManagedContent(); ds.DSInfoType = "DATA"; ds.DSLocationType = Datastream.DS_LOCATION_TYPE_URL; } else if (controlGroup.equals("R") || controlGroup.equals("E")) { ds = new DatastreamReferencedContent(); ds.DSInfoType = "DATA"; ds.DSLocationType = Datastream.DS_LOCATION_TYPE_URL; } else { throw new GeneralException("Invalid control group: " + controlGroup); } ds.isNew = true; ds.DSControlGrp = controlGroup; ds.DSVersionable = versionable; if (!dsState.equals("A") && !dsState.equals("D") && !dsState.equals("I")) { throw new InvalidStateException( "The datastream state of \"" + dsState + "\" is invalid. The allowed values for state are: " + " A (active), D (deleted), and I (inactive)."); } ds.DSState = dsState; // set new datastream id if not provided... if (dsID == null || dsID.length() == 0) { ds.DatastreamID = w.newDatastreamID(); } else { if (dsID.indexOf(" ") != -1) { throw new GeneralException("Datastream ids cannot contain spaces."); } if (dsID.indexOf("+") != -1) { throw new GeneralException("Datastream ids cannot contain plusses."); } if (dsID.indexOf(":") != -1) { throw new GeneralException("Datastream ids cannot contain colons."); } if (w.GetDatastream(dsID, null) != null) { throw new GeneralException("A datastream already exists with ID: " + dsID); } else { ds.DatastreamID = dsID; } } // add version level attributes and // create new ds version id ... ds.DSVersionID = ds.DatastreamID + ".0"; ds.DSLabel = dsLabel; ds.DSLocation = dsLocation; if (dsLocation != null) { ValidationUtility.validateURL(dsLocation, ds.DSControlGrp); } ds.DSFormatURI = formatURI; ds.DatastreamAltIDs = altIDs; ds.DSMIME = MIMEType; ds.DSChecksumType = Datastream.validateChecksumType(checksumType); // M reserved datastream validation (X done above) if (controlGroup.equals("M")) { ValidationUtility.validateReservedDatastream(PID.getInstance(pid), dsID, ds); } if (checksum != null && checksumType != null) { String check = ds.getChecksum(); if (!checksum.equals(check)) { throw new ValidationException("Checksum Mismatch: " + check); } } // Update audit trail Date nowUTC = Server.getCurrentDate(context); addAuditRecord(context, w, "addDatastream", ds.DatastreamID, logMessage, nowUTC); // Commit the updates ds.DSCreateDT = nowUTC; w.addDatastream(ds, true); w.commit("Added a new datastream"); return ds.DatastreamID; } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed addDatastream("); logMsg.append("pid: ").append(pid); logMsg.append(", dsID: ").append(dsID); appendAltIDs(logMsg, altIDs); logMsg.append(", dsLabel: ").append(dsLabel); logMsg.append(", versionable: ").append(versionable); logMsg.append(", MIMEType: ").append(MIMEType); logMsg.append(", formatURI: ").append(formatURI); logMsg.append(", dsLocation: ").append(dsLocation); logMsg.append(", controlGroup: ").append(controlGroup); logMsg.append(", dsState: ").append(dsState); logMsg.append(", checksumType: ").append(checksumType); logMsg.append(", checksum: ").append(checksum); logMsg.append(", logMessage: ").append(logMessage); logMsg.append(")"); logger.info(logMsg.toString()); } finishModification(w, "addDatastream"); } } @Override public Date modifyDatastreamByReference(Context context, String pid, String datastreamId, String[] altIDs, String dsLabel, String mimeType, String formatURI, String dsLocation, String checksumType, String checksum, String logMessage, Date lastModifiedDate) throws ServerException { // check for valid xml name for datastream ID if (datastreamId != null) { if (!XMLUtils.isWellFormedXMLName(datastreamId)) { throw new InvalidXMLNameException("Invalid syntax for " + "datastream ID. The datastream ID of \"" + datastreamId + "\" is not a valid XML Name"); } } if (datastreamId.equals("AUDIT") || datastreamId.equals("FEDORA-AUDITTRAIL")) { throw new GeneralException( "Modification of the system-controlled AUDIT" + " datastream is not permitted."); } DOWriter w = null; try { logger.debug("Entered modifyDatastreamByReference"); m_authz.enforceModifyDatastreamByReference(context, pid, datastreamId, altIDs, mimeType, formatURI, dsLocation, checksumType, checksum); checkDatastreamLabel(dsLabel); w = m_manager.getWriter(Server.USE_DEFINITIVE_STORE, context, pid); org.fcrepo.server.storage.types.Datastream orig = w.GetDatastream(datastreamId, null); if (orig == null) { throw new DatastreamNotFoundException( "Object " + pid + " has no datastream " + datastreamId + " to modify"); } // if provided, check request lastModifiedDate against the datastream, // rejecting the request if the datastream's mod date is more recent. if (lastModifiedDate != null) { if (lastModifiedDate.before(orig.DSCreateDT)) { String dsDate = DateUtility.convertDateToXSDString(w.getLastModDate()); String reqDate = DateUtility.convertDateToXSDString(lastModifiedDate); String msg = String.format( "%s/%s lastModifiedDate (%s) " + "is more recent than the " + "request (%s)", pid, datastreamId, dsDate, reqDate); throw new DatastreamLockedException(msg); } } Date nowUTC; // variable for ds modified date // some forbidden scenarios... if (orig.DSControlGrp.equals("X")) { throw new GeneralException("Inline XML datastreams must be modified by value, not by reference."); } if (orig.DSState.equals("D")) { throw new GeneralException("Changing attributes on deleted datastreams is forbidden."); } // A NULL INPUT PARM MEANS NO CHANGE TO DS ATTRIBUTE... // if input parms are null, the ds attribute should not be changed, // so set the parm values to the existing values in the datastream. if (dsLabel == null) { dsLabel = orig.DSLabel; } if (mimeType == null) { mimeType = orig.DSMIME; } if (formatURI == null) { formatURI = orig.DSFormatURI; } if (altIDs == null) { altIDs = orig.DatastreamAltIDs; } if (checksumType == null) { checksumType = orig.DSChecksumType; } else { checksumType = Datastream.validateChecksumType(checksumType); } // In cases where an empty attribute value is not allowed, then // NULL or EMPTY PARM means no change to ds attribute... if (dsLocation == null || dsLocation.equals("")) { if (orig.DSControlGrp.equals("M")) { // if managed content location is unspecified, // cause a copy of the prior content to be made at // commit-time dsLocation = DatastreamManagedContent.COPY_SCHEME + orig.DSLocation; } else { dsLocation = orig.DSLocation; } } else { ValidationUtility.validateURL(dsLocation, orig.DSControlGrp); } // if "force" is false and the mime type changed, validate the // original datastream with respect to any disseminators it is // involved in, and keep a record of that information for later // (so we can determine whether the mime type change would cause // data contract invalidation) // Map oldValidationReports = null; // if ( !mimeType.equals(orig.DSMIME) && !force) { // oldValidationReports = getAllBindingMapValidationReports( // context, w, datastreamId); // } // instantiate the right class of datastream // (inline xml "X" datastreams have already been rejected) Datastream newds; if (orig.DSControlGrp.equals("M")) { newds = new DatastreamManagedContent(); } else { newds = new DatastreamReferencedContent(); } // update ds attributes that are common to all versions... // first, those that cannot be changed by client... newds.DatastreamID = orig.DatastreamID; newds.DSControlGrp = orig.DSControlGrp; newds.DSInfoType = orig.DSInfoType; // next, those that can be changed by client... newds.DSState = orig.DSState; newds.DSVersionable = orig.DSVersionable; // update ds version-level attributes, and // make sure ds gets a new version id newds.DSVersionID = w.newDatastreamID(datastreamId); newds.DSLabel = dsLabel; newds.DSMIME = mimeType; newds.DSFormatURI = formatURI; newds.DatastreamAltIDs = altIDs; nowUTC = Server.getCurrentDate(context); newds.DSCreateDT = nowUTC; // newds.DSSize will be computed later newds.DSLocation = dsLocation; newds.DSLocationType = Datastream.DS_LOCATION_TYPE_URL; newds.DSChecksumType = checksumType; // validate reserved datastreams (type M and X) unless unchanged: if (!newds.DSLocation.startsWith(DatastreamManagedContent.COPY_SCHEME) && !newds.DSLocation.equals(orig.DSLocation)) { ValidationUtility.validateReservedDatastream(PID.getInstance(pid), datastreamId, newds); } // next, add the datastream via the object writer w.addDatastream(newds, orig.DSVersionable); // if a checksum is passed in verify that the checksum computed for // the datastream // matches the one that is passed in. if (checksum != null) { if (checksumType == null) { newds.DSChecksumType = orig.DSChecksumType; } String check = newds.getChecksum(); if (!checksum.equals(check)) { throw new ValidationException("Checksum Mismatch: " + check); } } // Update audit trail addAuditRecord(context, w, "modifyDatastreamByReference", newds.DatastreamID, logMessage, nowUTC); // if all went ok, check if we need to validate, then commit. // if (oldValidationReports != null) { // mime changed and // force=false // rejectMimeChangeIfCausedInvalidation( // oldValidationReports, // getAllBindingMapValidationReports(context, // w, // datastreamId)); // } w.commit(logMessage); return nowUTC; } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed modifyDatastreamByReference("); logMsg.append("pid: ").append(pid); logMsg.append(", datastreamId: ").append(datastreamId); appendAltIDs(logMsg, altIDs); logMsg.append(", dsLabel: ").append(dsLabel); logMsg.append(", mimeType: ").append(mimeType); logMsg.append(", formatURI: ").append(formatURI); logMsg.append(", dsLocation: ").append(dsLocation); logMsg.append(", checksumType: ").append(checksumType); logMsg.append(", checksum: ").append(checksum); logMsg.append(", logMessage: ").append(logMessage); logMsg.append(")"); logger.info(logMsg.toString()); } finishModification(w, "modifyDatastreamByReference"); } } @Override public Date modifyDatastreamByValue(Context context, String pid, String datastreamId, String[] altIDs, String dsLabel, String mimeType, String formatURI, InputStream dsContent, String checksumType, String checksum, String logMessage, Date lastModifiedDate) throws ServerException { // check for valid xml name for datastream ID if (datastreamId != null) { if (!XMLUtils.isWellFormedXMLName(datastreamId)) { throw new InvalidXMLNameException("Invalid syntax for " + "datastream ID. The datastream ID of \"" + datastreamId + "\" is not a valid XML Name"); } } if (datastreamId.equals("AUDIT") || datastreamId.equals("FEDORA-AUDITTRAIL")) { throw new GeneralException( "Modification of the system-controlled AUDIT" + " datastream is not permitted."); } DOWriter w = null; try { logger.debug("Entered modifyDatastreamByValue"); m_authz.enforceModifyDatastreamByValue(context, pid, datastreamId, altIDs, mimeType, formatURI, checksumType, checksum); checkDatastreamLabel(dsLabel); w = m_manager.getWriter(Server.USE_DEFINITIVE_STORE, context, pid); Datastream orig = w.GetDatastream(datastreamId, null); if (orig == null) { throw new DatastreamNotFoundException( "Object " + pid + " has no datastream " + datastreamId + " to modify"); } XMLDatastreamProcessor origxml = new XMLDatastreamProcessor(orig); // if provided, check request lastModifiedDate against the datastream, // rejecting the request if the datastream's mod date is more recent. if (lastModifiedDate != null) { if (lastModifiedDate.before(orig.DSCreateDT)) { String dsDate = DateUtility.convertDateToXSDString(w.getLastModDate()); String reqDate = DateUtility.convertDateToXSDString(lastModifiedDate); String msg = String.format( "%s/%s lastModifiedDate (%s) " + "is more recent than the " + "request (%s)", pid, datastreamId, dsDate, reqDate); throw new DatastreamLockedException(msg); } } // some forbidden scenarios... if (orig.DSState.equals("D")) { throw new GeneralException("Changing attributes on deleted datastreams is forbidden."); } if (!orig.DSControlGrp.equals("X") && !orig.DSControlGrp.equals("M")) { throw new GeneralException("Only content of inline XML and managed content" + " datastreams may be modified by value.\n" + "Use modifyDatastreamByReference instead."); } // A NULL INPUT PARM MEANS NO CHANGE TO DS ATTRIBUTE... // if input parms are null, the ds attribute should not be changed, // so set the parm values to the existing values in the datastream. if (dsLabel == null) { dsLabel = orig.DSLabel; } if (mimeType == null) { mimeType = orig.DSMIME; } if (formatURI == null) { formatURI = orig.DSFormatURI; } if (altIDs == null) { altIDs = orig.DatastreamAltIDs; } if (checksumType == null) { checksumType = orig.DSChecksumType; } else { checksumType = Datastream.validateChecksumType(checksumType); } if (dsContent != null && "DC".equals(datastreamId)) { DCFields audited = new DCFields(dsContent); try { dsContent = new ByteArrayInputStream(audited.getAsXML(pid).getBytes("UTF-8")); } catch (UnsupportedEncodingException uee) { // safely ignore... we know UTF-8 works } } // create new datastream (version) based on existing one XMLDatastreamProcessor newdsxml = origxml.newVersion(); Datastream newds = newdsxml.getDatastream(); newdsxml.setDSMDClass(origxml.getDSMDClass()); if (dsContent == null) { // If the dsContent input stream parm is null, // that means "do not change the content". // Accordingly, here we just make a copy of the old content. newdsxml.setXMLContent(origxml.getXMLContent()); } else { // set and validate the content newdsxml.setXMLContent(getEmbeddableXML(dsContent)); ValidationUtility.validateReservedDatastream(PID.getInstance(pid), orig.DatastreamID, newds); } // update ds attributes that are common to all versions... // first, those that cannot be changed by client... newds.DatastreamID = orig.DatastreamID; newds.DSControlGrp = orig.DSControlGrp; newds.DSInfoType = orig.DSInfoType; // next, those that can be changed by client... newds.DSState = orig.DSState; newds.DSVersionable = orig.DSVersionable; // update ds version level attributes, and // make sure ds gets a new version id newds.DSVersionID = w.newDatastreamID(datastreamId); newds.DSLabel = dsLabel; newds.DatastreamAltIDs = altIDs; newds.DSMIME = mimeType; newds.DSFormatURI = formatURI; Date nowUTC = Server.getCurrentDate(context); newds.DSCreateDT = nowUTC; newds.DSChecksumType = checksumType; // next, add the datastream via the object writer w.addDatastream(newds, orig.DSVersionable); // if a checksum is passed in verify that the checksum computed for // the datastream // matches the one that is passed in. if (checksum != null) { String check = newds.getChecksum(); if (!checksum.equals(check)) { throw new ValidationException("Checksum Mismatch: " + check); } } // Update audit trail addAuditRecord(context, w, "modifyDatastreamByValue", newds.DatastreamID, logMessage, nowUTC); w.commit(logMessage); return nowUTC; } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed modifyDatastreamByValue("); logMsg.append("pid: ").append(pid); logMsg.append(", datastreamId: ").append(datastreamId); appendAltIDs(logMsg, altIDs); logMsg.append(", dsLabel: ").append(dsLabel); logMsg.append(", mimeType: ").append(mimeType); logMsg.append(", formatURI: ").append(formatURI); logMsg.append(", dsContent "); logMsg.append(", checksumType: ").append(checksumType); logMsg.append(", checksum: ").append(checksum); logMsg.append(", logMessage: ").append(logMessage); logMsg.append(")"); logger.info(logMsg.toString()); } finishModification(w, "modifyDatastreamByValue"); } } @Override public Date[] purgeDatastream(Context context, String pid, String datastreamID, Date startDT, Date endDT, String logMessage) throws ServerException { /* if (force) { throw new GeneralException("Forced datastream removal is not " + "yet supported."); } */ DOWriter w = null; try { logger.debug("Entered purgeDatastream"); m_authz.enforcePurgeDatastream(context, pid, datastreamID, endDT); w = m_manager.getWriter(Server.USE_DEFINITIVE_STORE, context, pid); Date[] deletedDates = w.removeDatastream(datastreamID, startDT, endDT); // check if there's at least one version with this id... if (w.GetDatastream(datastreamID, null) == null) { // if deleting would result in no versions remaining, // only continue if there are no disseminators that use // this datastream. // to do this, we must look through all versions of every // disseminator, regardless of state ArrayList<String> usedList = new ArrayList<String>(); if (datastreamID.equals("DC")) { usedList.add("The default disseminator"); } if (usedList.size() > 0) { StringBuffer msg = new StringBuffer(); msg.append("Cannot purge entire datastream because it\n"); msg.append("is used by the following disseminators:"); for (int i = 0; i < usedList.size(); i++) { msg.append("\n - " + usedList.get(i)); } throw new GeneralException(msg.toString()); } } // add an explanation of what happened to the user-supplied message. if (logMessage == null) { logMessage = ""; } else { logMessage += " . . . "; } logMessage += getPurgeLogMessage("datastream", datastreamID, startDT, endDT, deletedDates); // Update audit trail Date nowUTC = Server.getCurrentDate(context); addAuditRecord(context, w, "purgeDatastream", datastreamID, logMessage, nowUTC); // It looks like all went ok, so commit w.commit(logMessage); // ... then give the response return deletedDates; } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed purgeDatastream("); logMsg.append("pid: ").append(pid); logMsg.append(", datastreamID: ").append(datastreamID); logMsg.append(", startDT: ").append(startDT); logMsg.append(", endDT: ").append(endDT); logMsg.append(", logMessage: ").append(logMessage); logMsg.append(")"); logger.info(logMsg.toString()); } finishModification(w, "purgeDatastream"); } } private String getPurgeLogMessage(String kindaThing, String id, Date start, Date end, Date[] deletedDates) { SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"); StringBuffer buf = new StringBuffer(); buf.append("Purged "); buf.append(kindaThing); buf.append(" (ID="); buf.append(id); buf.append("), versions ranging from "); if (start == null) { buf.append("the beginning of time"); } else { buf.append(formatter.format(start)); } buf.append(" to "); if (end == null) { buf.append("the end of time"); } else { buf.append(formatter.format(end)); } buf.append(". This resulted in the permanent removal of "); buf.append(deletedDates.length + " "); buf.append(kindaThing); buf.append(" version(s) ("); for (int i = 0; i < deletedDates.length; i++) { if (i > 0) { buf.append(", "); } buf.append(formatter.format(deletedDates[i])); } buf.append(") and all associated audit records."); return buf.toString(); } @Override public Datastream getDatastream(Context context, String pid, String datastreamID, Date asOfDateTime) throws ServerException { try { logger.debug("Entered getDatastream"); m_authz.enforceGetDatastream(context, pid, datastreamID, asOfDateTime); DOReader r = m_manager.getReader(Server.GLOBAL_CHOICE, context, pid); return r.GetDatastream(datastreamID, asOfDateTime); } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed getDatastream("); logMsg.append("pid: ").append(pid); logMsg.append(", datastreamID: ").append(datastreamID); logMsg.append(", asOfDateTime: ").append(asOfDateTime); logMsg.append(")"); logger.info(logMsg.toString()); } logger.debug("Exiting getDatastream"); } } @Override public Datastream[] getDatastreams(Context context, String pid, Date asOfDateTime, String state) throws ServerException { try { logger.debug("Entered getDatastreams"); m_authz.enforceGetDatastreams(context, pid, asOfDateTime, state); DOReader r = m_manager.getReader(Server.GLOBAL_CHOICE, context, pid); return r.GetDatastreams(asOfDateTime, state); } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed getDatastreams("); logMsg.append("pid: ").append(pid); logMsg.append(", asOfDateTime: ").append(asOfDateTime); logMsg.append(", state: ").append(state); logMsg.append(")"); logger.info(logMsg.toString()); } logger.debug("Exiting getDatastreams"); } } @Override public Datastream[] getDatastreamHistory(Context context, String pid, String datastreamID) throws ServerException { try { logger.debug("Entered getDatastreamHistory"); m_authz.enforceGetDatastreamHistory(context, pid, datastreamID); DOReader r = m_manager.getReader(Server.GLOBAL_CHOICE, context, pid); Date[] versionDates = r.getDatastreamVersions(datastreamID); Datastream[] versions = new Datastream[versionDates.length]; for (int i = 0; i < versionDates.length; i++) { versions[i] = r.GetDatastream(datastreamID, versionDates[i]); } // sort, ascending Arrays.sort(versions, new DatastreamDateComparator()); // reverse it (make it descend, so most recent date is element 0) Datastream[] out = new Datastream[versions.length]; for (int i = 0; i < versions.length; i++) { out[i] = versions[versions.length - 1 - i]; } return out; } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed getDatastreamHistory("); logMsg.append("pid: ").append(pid); logMsg.append(", datastreamID: ").append(datastreamID); logMsg.append(")"); logger.info(logMsg.toString()); } logger.debug("Exiting getDatastreamHistory"); } } public class DatastreamDateComparator implements Comparator<Object> { @Override public int compare(Object o1, Object o2) { long ms1 = ((Datastream) o1).DSCreateDT.getTime(); long ms2 = ((Datastream) o1).DSCreateDT.getTime(); if (ms1 < ms2) { return -1; } if (ms1 > ms2) { return 1; } return 0; } } @Override public String[] getNextPID(Context context, int numPIDs, String namespace) throws ServerException { try { logger.debug("Entered getNextPID"); m_authz.enforceGetNextPid(context, namespace, numPIDs); String[] pidList = null; // If the pidList is in the RecoveryContext, just reserve them // rather than generating new ones. if (context instanceof RecoveryContext) { RecoveryContext rContext = (RecoveryContext) context; pidList = rContext.getRecoveryValues(Constants.RECOVERY.PID_LIST.uri); if (pidList != null && pidList.length > 0) { logger.debug("Reserving and returning PID_LIST " + "from recovery context"); m_manager.reservePIDs(pidList); } } if (pidList == null || pidList.length == 0) { pidList = m_manager.getNextPID(numPIDs, namespace); } return pidList; } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed getNextPID("); logMsg.append("numPIDs: ").append(numPIDs); logMsg.append(", namespace: ").append(namespace); logMsg.append(")"); logger.info(logMsg.toString()); } logger.debug("Exiting getNextPID"); } } @Override public String putTempStream(Context context, InputStream in) throws StreamWriteException, AuthzException { m_authz.enforceUpload(context); // first clean up after old stuff purgeUploadedFiles(); // then generate an id String id = Integer.toString(getNextTempId(context)); // and attempt to save the stream File outFile = new File(m_tempDir, "" + id); FileOutputStream out = null; try { out = new FileOutputStream(outFile); StreamUtility.pipeStream(in, out, 32768); } catch (Exception e) { if (out != null) { try { out.close(); } catch (Exception ex) { } outFile.delete(); } throw new StreamWriteException("Error writing temp stream", e); } // if we got this far w/o an exception, add to hash with current time // and return the identifier-that-looks-like-a-url long now = System.currentTimeMillis(); m_uploadStartTime.put(id, new Long(now)); return DatastreamManagedContent.UPLOADED_SCHEME + id; } private synchronized int getNextTempId(Context context) { int recoveryId = -1; // If the RecoveryContext has an uploaded://n url, use n. if (context instanceof RecoveryContext) { RecoveryContext rContext = (RecoveryContext) context; String uploadURL = rContext.getRecoveryValue(Constants.RECOVERY.UPLOAD_ID.uri); if (uploadURL != null) { try { String n = uploadURL.substring(11); recoveryId = Integer.parseInt(n); } catch (Exception e) { throw new IllegalArgumentException( "Unable to parse UPLOAD_ID " + "from recovery context: '" + uploadURL + "'"); } } } if (recoveryId == -1) { m_lastId++; } else { m_lastId = recoveryId; } return m_lastId; } @Override public InputStream getTempStream(String id) throws StreamReadException { // it should come in starting with "uploaded://" if (id.startsWith(DatastreamManagedContent.UPLOADED_SCHEME) || id.length() < 12) { String internalId = id.substring(11); if (m_uploadStartTime.get(internalId) != null) { // found... return inputstream try { return new FileInputStream(new File(m_tempDir, internalId)); } catch (Exception e) { throw new StreamReadException(e.getMessage()); } } else { throw new StreamReadException("Id specified, '" + id + "', does not match an existing file."); } } else { throw new StreamReadException("Invalid id syntax '" + id + "'."); } } @Override public Date setDatastreamState(Context context, String pid, String datastreamID, String dsState, String logMessage) throws ServerException { DOWriter w = null; try { logger.debug("Entered setDatastreamState"); m_authz.enforceSetDatastreamState(context, pid, datastreamID, dsState); w = m_manager.getWriter(Server.USE_DEFINITIVE_STORE, context, pid); if (!dsState.equals("A") && !dsState.equals("D") && !dsState.equals("I")) { throw new InvalidStateException( "The datastream state of \"" + dsState + "\" is invalid. The allowed values for state are: " + " A (active), D (deleted), and I (inactive)."); } w.setDatastreamState(datastreamID, dsState); // Update audit trail Date nowUTC = Server.getCurrentDate(context); addAuditRecord(context, w, "setDatastreamState", datastreamID, logMessage, nowUTC); // if all went ok, commit w.commit(logMessage); return nowUTC; } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed setDatastreamState("); logMsg.append("pid: ").append(pid); logMsg.append(", datastreamID: ").append(datastreamID); logMsg.append(", dsState: ").append(dsState); logMsg.append(", logMessage: ").append(logMessage); logMsg.append(")"); logger.info(logMsg.toString()); } finishModification(w, "setDatastreamState"); } } @Override public Date setDatastreamVersionable(Context context, String pid, String datastreamID, boolean versionable, String logMessage) throws ServerException { DOWriter w = null; try { logger.debug("Entered setDatastreamVersionable"); m_authz.enforceSetDatastreamVersionable(context, pid, datastreamID, versionable); w = m_manager.getWriter(Server.USE_DEFINITIVE_STORE, context, pid); w.setDatastreamVersionable(datastreamID, versionable); // Update audit trail Date nowUTC = Server.getCurrentDate(context); addAuditRecord(context, w, "setDatastreamVersionable", datastreamID, logMessage, nowUTC); // if all went ok, commit w.commit(logMessage); return nowUTC; } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed setDatastreamVersionable("); logMsg.append("pid: ").append(pid); logMsg.append(", datastreamID: ").append(datastreamID); logMsg.append(", versionable: ").append(versionable); logMsg.append(", logMessage: ").append(logMessage); logMsg.append(")"); logger.info(logMsg.toString()); } finishModification(w, "setDatastreamVersionable"); } } @Override public String compareDatastreamChecksum(Context context, String pid, String datastreamID, Date versionDate) throws ServerException { DOReader r = null; try { logger.debug("Entered compareDatastreamChecksum"); m_authz.enforceCompareDatastreamChecksum(context, pid, datastreamID, versionDate); logger.debug("Getting Reader"); r = m_manager.getReader(Server.USE_DEFINITIVE_STORE, context, pid); logger.debug("Getting datastream:" + datastreamID + "date: " + versionDate); Datastream ds = r.GetDatastream(datastreamID, versionDate); logger.debug("Got Datastream, comparing checksum"); boolean check = ds.compareChecksum(); logger.debug("compared checksum = " + check); return check ? ds.getChecksum() : "Checksum validation error"; } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed compareDatastreamChecksum("); logMsg.append("pid: ").append(pid); logMsg.append(", datastreamID: ").append(datastreamID); logMsg.append(", versionDate: ").append(versionDate); logMsg.append(")"); logger.info(logMsg.toString()); } logger.debug("Exiting compareDatastreamChecksum"); } } /** * Get a byte array containing an xml chunk that is safe to embed in another * UTF-8 xml document. * <p> * This will ensure that the xml is: * <ul> * <li> well-formed. If not, an exception will be raised.</li> * <li> encoded in UTF-8. It will be converted otherwise.</li> * <li> devoid of processing instructions. These will be stripped if * present.</li> * <li> devoid of DOCTYPE declarations. These will be stripped if present.</li> * <li> devoid of internal entity references. These will be expanded if * present.</li> * </ul> * </p> */ private byte[] getEmbeddableXML(InputStream in) throws GeneralException { return getXML(in, false); } private byte[] getXML(InputStream in, boolean includeXMLDeclaration) throws GeneralException { // parse with xerces and re-serialize the fixed xml to a byte array try { ByteArrayOutputStream out = new ByteArrayOutputStream(); OutputFormat fmt = new OutputFormat("XML", "UTF-8", true); fmt.setIndent(2); fmt.setLineWidth(120); fmt.setPreserveSpace(false); fmt.setOmitXMLDeclaration(!includeXMLDeclaration); fmt.setOmitDocumentType(true); XMLSerializer ser = new XMLSerializer(out, fmt); DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setNamespaceAware(true); DocumentBuilder builder = factory.newDocumentBuilder(); Document doc = builder.parse(in); ser.serialize(doc); return out.toByteArray(); } catch (Exception e) { String message = e.getMessage(); if (message == null) { message = ""; } throw new GeneralException("XML was not well-formed. " + message, e); } } private void checkDatastreamID(String id) throws ValidationException { checkString(id, "Datastream id", ValidationConstants.DATASTREAM_ID_MAXLEN, ValidationConstants.DATASTREAM_ID_BADCHARS); } private void checkDatastreamLabel(String label) throws ValidationException { checkString(label, "Datastream label", ValidationConstants.DATASTREAM_LABEL_MAXLEN, null); } private void checkObjectLabel(String label) throws ValidationException { checkString(label, "Object label", ValidationConstants.OBJECT_LABEL_MAXLEN, null); } private void checkString(String string, String kind, int maxLen, char[] badChars) throws ValidationException { if (string != null) { if (string.length() > maxLen) { throw new ValidationException( kind + " is too long. Maximum " + "length is " + maxLen + " characters."); } else if (badChars != null) { for (char c : badChars) { if (string.indexOf(c) != -1) { throw new ValidationException( kind + " contains a " + "'" + c + "', but that character is not " + "allowed."); } } } } } // helper class to get pid from subject and to get URI form of subject // subject can either be a pid or an info:fedora/ uri private static class SubjectProcessor { private static Pattern pidRegex = Pattern .compile("^([A-Za-z0-9]|-|\\.)+:(([A-Za-z0-9])|-|\\.|~|_|(%[0-9A-F]{2}))+$"); static String getSubjectAsUri(String subject) { // if we weren't given a pid, assume it's a URI if (!isPid(subject)) { return subject; } // otherwise return URI from the pid logger.warn("Relationships API methods: the 'pid' (" + subject + ") form of a relationship's subject is deprecated. Please specify the subject using the " + Constants.FEDORA.uri + " uri scheme."); return PID.toURI(subject); } static String getSubjectPID(String subject) throws ServerException { if (isPid(subject)) { return subject; } // check for info:uri scheme if (subject.startsWith(Constants.FEDORA.uri)) { // pid is everything after the first / to the 2nd / or to the end of the string return subject.split("/", 3)[1]; } else { throw new GeneralException("Subject URI must be in the " + Constants.FEDORA.uri + " scheme."); } } private static boolean isPid(String subject) { return pidRegex.matcher(subject).matches(); } } @Override public RelationshipTuple[] getRelationships(Context context, String subject, String relationship) throws ServerException { DOReader r = null; String pid = null; try { logger.debug("Entered getRelationships"); pid = SubjectProcessor.getSubjectPID(subject); m_authz.enforceGetRelationships(context, pid, relationship); r = m_manager.getReader(Server.USE_DEFINITIVE_STORE, context, pid); logger.debug("Getting Relationships: pid = " + pid + " predicate = " + relationship); try { URIReference pred = null; if (relationship != null) { pred = new SimpleURIReference(new URI(relationship)); } URIReference subj = null; if (subject != null) { subj = new SimpleURIReference(new URI(SubjectProcessor.getSubjectAsUri(subject))); } Set<RelationshipTuple> tuples = r.getRelationships(subj, pred, null); return tuples.toArray(new RelationshipTuple[tuples.size()]); } catch (URISyntaxException e) { throw new GeneralException("Relationship must be a URI", e); } } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed getRelationships("); logMsg.append("pid: ").append(pid); logMsg.append(", relationship: ").append(relationship); logMsg.append(")"); logger.info(logMsg.toString()); } logger.debug("Exiting getRelationships"); } } @Override public boolean addRelationship(Context context, String subject, String relationship, String object, boolean isLiteral, String datatype) throws ServerException { DOWriter w = null; String pid = null; try { logger.debug("Entered addRelationship"); pid = SubjectProcessor.getSubjectPID(subject); m_authz.enforceAddRelationship(context, pid, relationship, object, isLiteral, datatype); w = m_manager.getWriter(Server.USE_DEFINITIVE_STORE, context, pid); boolean added = w.addRelationship(SubjectProcessor.getSubjectAsUri(subject), relationship, object, isLiteral, datatype); // if all went ok, commit if (added) { w.commit(null); } return added; } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed addRelationship("); logMsg.append("pid: ").append(pid); logMsg.append(", relationship: ").append(relationship); logMsg.append(", object: ").append(object); logMsg.append(", isLiteral: ").append(isLiteral); logMsg.append(", datatype: ").append(datatype); logMsg.append(")"); logger.info(logMsg.toString()); } finishModification(w, "addRelationship"); } } @Override public boolean purgeRelationship(Context context, String subject, String relationship, String object, boolean isLiteral, String datatype) throws ServerException { DOWriter w = null; String pid = null; try { logger.debug("Entered purgeRelationship"); pid = SubjectProcessor.getSubjectPID(subject); m_authz.enforcePurgeRelationship(context, pid, relationship, object, isLiteral, datatype); w = m_manager.getWriter(Server.USE_DEFINITIVE_STORE, context, pid); boolean purged = w.purgeRelationship(SubjectProcessor.getSubjectAsUri(subject), relationship, object, isLiteral, datatype); // if all went ok, commit if (purged) { w.commit(null); } return purged; } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed purgeRelationship("); logMsg.append("pid: ").append(pid); logMsg.append(", relationship: ").append(relationship); logMsg.append(", object: ").append(object); logMsg.append(", isLiteral: ").append(isLiteral); logMsg.append(", datatype: ").append(datatype); logMsg.append(")"); logger.info(logMsg.toString()); } finishModification(w, "purgeRelationship"); } } /** * Validate the object against the datacontracts from the objects content model. This method just delegates the validation * to EcmValidator * * @param context the call context * @param pid the pid of the object to validate * @param asOfDateTime the datetime to get to object as * @return The result of the validation * @see org.fcrepo.server.validation.ecm.EcmValidator */ @Override public Validation validate(Context context, String pid, Date asOfDateTime) throws ServerException { try { logger.debug("Entered validate"); m_authz.enforceValidate(context, pid, asOfDateTime); return ecmValidator.validate(context, pid, asOfDateTime); } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed validate("); logMsg.append("pid: ").append(pid); logMsg.append(", asOfDateTime: ").append(asOfDateTime); logMsg.append(")"); logger.info(logMsg.toString()); } logger.debug("Exiting validate"); } } /** * Creates a new audit record and adds it to the digital object audit trail. */ private void addAuditRecord(Context context, DOWriter w, String action, String componentID, String justification, Date nowUTC) throws ServerException { AuditRecord audit = new AuditRecord(); audit.id = w.newAuditRecordID(); audit.processType = "Fedora API-M"; audit.action = action; audit.componentID = componentID; audit.responsibility = context.getSubjectValue(Constants.SUBJECT.LOGIN_ID.uri); audit.date = nowUTC; audit.justification = justification; w.getAuditRecords().add(audit); } /** * Appends alt IDs to the log message. */ private static void appendAltIDs(StringBuilder logMsg, String[] altIDs) { logMsg.append(", altIDs: "); if (altIDs == null) { logMsg.append("null"); } else { for (String altID : altIDs) { logMsg.append("'").append(altID).append("'"); } } } /** * Deletes expired uploaded files. * <p/> * This method is called for each upload. But we respect a minimim delay * between two purges. This delay is given by m_purgeDelayInMillis. */ private void purgeUploadedFiles() { long currentTimeMillis = System.currentTimeMillis(); // Do purge if purge delay is past before last purge // ------------------------------------------------- long nextPurgeInMillis = this.m_lastPurgeInMillis + this.m_purgeDelayInMillis; if (nextPurgeInMillis < currentTimeMillis) { this.m_lastPurgeInMillis = currentTimeMillis; // Compute limit file time to purged // --------------------------------- long minStartTime = currentTimeMillis - (this.m_uploadStorageMinutes * 60000); // List files to purge and remove filename to map // This operation is synchronized to be thread-safe // ------------------------------------------------ List<String> removeList = new ArrayList<String>(); synchronized (this.m_uploadStartTime) { for (Entry<String, Long> entry : m_uploadStartTime.entrySet()) { String filename = entry.getKey(); long startTime = entry.getValue().longValue(); if (startTime < minStartTime) { removeList.add(filename); } } for (String filename : removeList) { this.m_uploadStartTime.remove(filename); } } // Delete file to purged // This operation is out of synchronised block for performances // ------------------------------------------------------------ for (int i = 0; i < removeList.size(); i++) { String id = removeList.get(i); File file = new File(this.m_tempDir, id); if (file.exists()) { if (file.delete()) { logger.info("Removed uploaded file '" + id + "' because it expired."); } else { logger.warn("Could not remove expired uploaded file '" + id + "'. Check permissions in " + m_tempDir.getPath() + " directory."); } } } } } /********************************************************************************** * Administrative methods - see FCREPO-765 * * These methods are used for administrative/utility/migration functions. * * They are defined in DefaultManagement but are not present in Management - * there is no commitment to providing these methods in the future. * * These methods should be migrated to an Administration module (and API). * **********************************************************************************/ /** * Migrate the datastream from one control group to another, returning list of versions migrated. * Only supports migration from X (inline) to M (managed content). Returns an array of date/times of the * datastream versions migrated (empty if datastream already had the desired control group). Throws * ObjectNotFoundException/DatastreamNotFoundException if object or datastream does not exist. * * @param context * @param pid * @param dsID * @param controlGroup - new Control Group for datastream * @param ignoreAlreadyDone - if true don't return an error if datastream already has desired control group * @param addXMLHeader - add an XML header declaring UTF-8 character encoding to datastream content * @param reformat - reformat the XML (in the same format as used for inline XML) * @param setMIMETypeCharset - add charset declaration (UTF-8) to the MIMEType, and add text/xml MIMEType if no MIMEType is set * @return array of versions migrated * @throws ServerException */ public Date[] modifyDatastreamControlGroup(Context context, String pid, String dsID, String controlGroup, boolean addXMLHeader, boolean reformat, boolean setMIMETypeCharset) throws ServerException { DOWriter w = null; try { logger.debug("Entered modifyDatastreamControlGroup"); // FIXME: see FCREPO-765 - add proper auth when migrating this to an Admin module, for now use same permissions as reloading policies m_authz.enforceReloadPolicies(context); if (!controlGroup.equals("M")) throw new GeneralException( "Invalid target controlGroup " + controlGroup + ". Only \"M\" is currently supported"); try { w = m_manager.getWriter(false, context, pid); } catch (ObjectNotInLowlevelStorageException e) { throw new ObjectNotFoundException("Object " + pid + " does not exist."); } Datastream currentDS = w.GetDatastream(dsID, null); if (currentDS == null) { throw new DatastreamNotFoundException("Datastream " + dsID + " not found"); } if (currentDS.DSControlGrp.equals("X")) { // take a copy of the existing datastream versions Date[] versions = w.getDatastreamVersions(dsID); Map<Date, Datastream> copyDS = new HashMap<Date, Datastream>(); for (Date version : versions) { Datastream d = w.GetDatastream(dsID, version); copyDS.put(version, d.copy()); } // purge the existing datastream (all versions) w.removeDatastream(dsID, null, null); // add back each datastream version in reverse order as managed content // (order might not strictly be necessary) Arrays.sort(versions); for (int i = versions.length - 1; i >= 0; i--) { // get a managed content copy of this datastream version DatastreamXMLMetadata existing = (DatastreamXMLMetadata) copyDS.get(versions[i]); DatastreamManagedContent newDS = new DatastreamManagedContent(); existing.copy(newDS); // X control group will have been copied over by above, reset it newDS.DSControlGrp = controlGroup; // probably not necessary, but just in case... newDS.DSLocation = null; newDS.DSLocationType = null; // add character encoding to mime type (will always be UTF-8 as it has come from X datastream in FOXML) if (setMIMETypeCharset) { if (newDS.DSMIME != null && !newDS.DSMIME.equals("") & !newDS.DSMIME.contains("charset=")) { newDS.DSMIME = newDS.DSMIME + "; charset=UTF-8"; } else { newDS.DSMIME = "text/xml; charset=UTF-8"; } } byte[] byteContent; // Note: use getContentStream() rather than getting bytes directly, as this is how // X datastreams are disseminated (we want the M content to be identical on // dissemination) if (reformat) { byteContent = this.getXML(existing.getContentStream(), addXMLHeader); } else { // add just the XML header declaring encoding, if requested if (addXMLHeader) { byte[] header; try { header = xmlHeader.getBytes("UTF-8"); } catch (UnsupportedEncodingException e) { // should never happen throw new RuntimeException(e); } byte[] existingContent; try { existingContent = IOUtils.toByteArray(existing.getContentStream()); } catch (IOException e) { throw new GeneralException("Error reading existing content from X datastream", e); } byteContent = Arrays.copyOf(header, header.length + existingContent.length); System.arraycopy(existing.xmlContent, 0, byteContent, header.length, existingContent.length); } else { try { byteContent = IOUtils.toByteArray(existing.getContentStream()); } catch (IOException e) { throw new GeneralException("Error reading existing content from X datastream", e); } } } // add the content stream MIMETypedStream content = new MIMETypedStream(null, new ByteArrayInputStream(byteContent), null, byteContent.length); newDS.putContentStream(content); // checksum only needs recalc if we added a header // note getChecksum() caters for checksum type set to disabled if (addXMLHeader) { logger.debug("Recalculating checksum. Type=" + newDS.DSChecksumType + " Existing checksum: " + newDS.DSChecksum != null ? newDS.DSChecksum : "none"); // forces computation rather than return existing newDS.DSChecksum = Datastream.CHECKSUM_NONE; newDS.DSChecksum = newDS.getChecksum(); logger.debug("New checksum: " + newDS.DSChecksum); logger.debug("Testing new checksum, response is {}", newDS.compareChecksum()); } w.addDatastream(newDS, true); } Date nowUTC = Server.getCurrentDate(context); String logMessage = "Modified datastream control group for " + pid + " " + dsID + " from " + currentDS.DSControlGrp + " to " + controlGroup; addAuditRecord(context, w, "modifyDatastreamControlGroup", dsID, logMessage, nowUTC); w.commit(logMessage); return versions; } else { // existing control group is not X if (currentDS.DSControlGrp.equals("M")) { // nothing modified return new Date[0]; } else { throw new GeneralException("Original control group must be X, it is " + currentDS.DSControlGrp); } } } finally { // Logger completion if (logger.isInfoEnabled()) { StringBuilder logMsg = new StringBuilder("Completed modifyDatastreamControlGroup("); logMsg.append("pid: ").append(pid); logMsg.append(", datastream: ").append(dsID); logMsg.append(", new control group: ").append(controlGroup); logMsg.append(", add XML header: ").append(addXMLHeader); logMsg.append(", set MIMEType charset: ").append(setMIMETypeCharset); logMsg.append(")"); logger.info(logMsg.toString()); } finishModification(w, "modifyDatastreamControlGroup"); } } }