/src/edu/ucsb/nceas/metacat/dataone/MNodeService.java - Annotate - Metacat - Ecoinformatics Redmine

metacat/src/edu/ucsb/nceas/metacat/dataone/MNodeService.java @ 7029

-            cjones
+/**
  *  '$RCSfile$'
  *  Copyright: 2000-2011 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;
-            cjones
+import java.io.IOException;
-            cjones
+import java.io.InputStream;
-            leinfelder
+import java.math.BigInteger;
-            cjones
+import java.security.NoSuchAlgorithmException;
-            cjones
+import java.sql.SQLException;
-            leinfelder
+import java.util.Calendar;
-            cjones
+import java.util.Date;
-            cjones
+import java.util.List;
-            leinfelder
+import java.util.Timer;
             cjones
-            leinfelder
+import javax.servlet.http.HttpServletRequest;
-            cjones
+import org.apache.commons.io.IOUtils;
-            cjones
+import org.apache.log4j.Logger;
-            cjones
+import org.dataone.client.CNode;
-            leinfelder
+import org.dataone.client.D1Client;
 import org.dataone.client.MNode;
-            leinfelder
+import org.dataone.client.auth.CertificateManager;
 import org.dataone.configuration.Settings;
-            cjones
+import org.dataone.service.exceptions.BaseException;
-            cjones
+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;
-            leinfelder
+import org.dataone.service.exceptions.SynchronizationFailed;
-            cjones
+import org.dataone.service.exceptions.UnsupportedType;
-            leinfelder
+import org.dataone.service.mn.tier1.v1.MNCore;
 import org.dataone.service.mn.tier1.v1.MNRead;
 import org.dataone.service.mn.tier2.v1.MNAuthorization;
 import org.dataone.service.mn.tier3.v1.MNStorage;
 import org.dataone.service.mn.tier4.v1.MNReplication;
 import org.dataone.service.types.v1.Checksum;
 import org.dataone.service.types.v1.Event;
 import org.dataone.service.types.v1.Group;
 import org.dataone.service.types.v1.Identifier;
 import org.dataone.service.types.v1.Log;
 import org.dataone.service.types.v1.LogEntry;
 import org.dataone.service.types.v1.MonitorInfo;
 import org.dataone.service.types.v1.MonitorList;
 import org.dataone.service.types.v1.Node;
-            cjones
+import org.dataone.service.types.v1.NodeList;
-            leinfelder
+import org.dataone.service.types.v1.NodeReference;
 import org.dataone.service.types.v1.NodeState;
 import org.dataone.service.types.v1.NodeType;
 import org.dataone.service.types.v1.ObjectFormatIdentifier;
 import org.dataone.service.types.v1.ObjectList;
 import org.dataone.service.types.v1.Permission;
 import org.dataone.service.types.v1.Ping;
-            cjones
+import org.dataone.service.types.v1.ReplicationStatus;
-            leinfelder
+import org.dataone.service.types.v1.Schedule;
 import org.dataone.service.types.v1.Service;
 import org.dataone.service.types.v1.Services;
 import org.dataone.service.types.v1.Session;
 import org.dataone.service.types.v1.Subject;
 import org.dataone.service.types.v1.Synchronization;
 import org.dataone.service.types.v1.SystemMetadata;
 import org.dataone.service.types.v1.util.ChecksumUtil;
-            jones
+import org.dataone.service.util.Constants;
             cjones
-            cjones
+import edu.ucsb.nceas.metacat.DocumentImpl;
-            cjones
+import edu.ucsb.nceas.metacat.EventLog;
-            cjones
+import edu.ucsb.nceas.metacat.IdentifierManager;
-            cjones
+import edu.ucsb.nceas.metacat.McdbDocNotFoundException;
-            leinfelder
+import edu.ucsb.nceas.metacat.MetacatHandler;
-            cjones
+import edu.ucsb.nceas.metacat.client.InsufficientKarmaException;
-            leinfelder
+import edu.ucsb.nceas.metacat.dataone.hazelcast.HazelcastService;
-            cjones
+import edu.ucsb.nceas.metacat.properties.PropertyService;
-            leinfelder
+import edu.ucsb.nceas.metacat.util.SystemUtil;
-            cjones
+import edu.ucsb.nceas.utilities.PropertyNotFoundException;
             cjones
-            cjones
+/**
  * Represents Metacat's implementation of the DataONE Member Node
  * service API. Methods implement the various MN* interfaces, and methods common
  * to both Member Node and Coordinating Node interfaces are found in the
  * D1NodeService base class.
             cjones
  * Implements:
  * MNCore.ping()
  * MNCore.getLogRecords()
  * MNCore.getObjectStatistics()
  * MNCore.getOperationStatistics()
  * MNCore.getStatus()
  * MNCore.getCapabilities()
  * MNRead.get()
  * MNRead.getSystemMetadata()
  * MNRead.describe()
  * MNRead.getChecksum()
  * MNRead.listObjects()
  * MNRead.synchronizationFailed()
  * MNAuthorization.isAuthorized()
  * MNAuthorization.setAccessPolicy()
  * MNStorage.create()
  * MNStorage.update()
  * MNStorage.delete()
  * MNReplication.replicate()
+ *
-            cjones
+ */
-            cjones
+public class MNodeService extends D1NodeService
     implements MNAuthorization, MNCore, MNRead, MNReplication, MNStorage {
             cjones
-            jones
+    /* the logger instance */
     private Logger logMetacat = null;
             cjones
     /* A reference to a remote Memeber Node */
     private MNode mn;
     /* A reference to a Coordinating Node */
     private CNode cn;
             cjones
             cjones
-            jones
+    /**
      * Singleton accessor to get an instance of MNodeService.
+     *
      * @return instance - the instance of MNodeService
      */
-            leinfelder
+    public static MNodeService getInstance(HttpServletRequest request) {
         return new MNodeService(request);
             cjones
-            jones
+    /**
      * Constructor, private for singleton access
      */
-            leinfelder
+    private MNodeService(HttpServletRequest request) {
         super(request);
-            jones
+        logMetacat = Logger.getLogger(MNodeService.class);
             leinfelder
         // set the Member Node certificate file location
         CertificateManager.getInstance().setCertificateLocation(Settings.getConfiguration().getString("D1Client.certificate.file"));
             cjones
             jones
     /**
      * Deletes an object from the Member Node, where the object is either a
      * data object or a science metadata object.
+     *
      * @param session - the Session object containing the credentials for the Subject
      * @param pid - The object identifier to be deleted
+     *
      * @return pid - the identifier of the object used for the deletion
+     *
      * @throws InvalidToken
      * @throws ServiceFailure
      * @throws NotAuthorized
      * @throws NotFound
      * @throws NotImplemented
      * @throws InvalidRequest
      */
     @Override
     public Identifier delete(Session session, Identifier pid)
-            cjones
+        throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented {
             jones
         String localId = null;
         boolean allowed = false;
-            leinfelder
+        String username = Constants.SUBJECT_PUBLIC;
-            jones
+        String[] groupnames = null;
-            leinfelder
+        if (session == null) {
         	throw new InvalidToken("1330", "No session has been provided");
         } else {
-            jones
+            username = session.getSubject().getValue();
-            leinfelder
+            if (session.getSubjectInfo() != null) {
                 List<Group> groupList = session.getSubjectInfo().getGroupList();
-            jones
+                if (groupList != null) {
                     groupnames = new String[groupList.size()];
                     for (int i = 0; i > groupList.size(); i++) {
                         groupnames[i] = groupList.get(i).getGroupName();
+                    }
+                }
+            }
+        }
         // do we have a valid pid?
         if (pid == null || pid.getValue().trim().equals("")) {
-            cjones
+            throw new ServiceFailure("1350", "The provided identifier was invalid.");
             jones
         // check for the existing identifier
         try {
             localId = IdentifierManager.getInstance().getLocalId(pid.getValue());
         } catch (McdbDocNotFoundException e) {
-            cjones
+            throw new NotFound("1340", "The object with the provided " + "identifier was not found.");
             jones
         // does the subject have DELETE (a D1 CHANGE_PERMISSION level) priveleges on the pid?
-            leinfelder
+        try {
 			allowed = isAuthorized(session, pid, Permission.CHANGE_PERMISSION);
 		} catch (InvalidRequest e) {
             throw new ServiceFailure("1350", e.getDescription());
+		}
             cjones
             jones
         if (allowed) {
             try {
                 // delete the document
                 DocumentImpl.delete(localId, username, groupnames, null);
-            leinfelder
+                EventLog.getInstance().log(request.getRemoteAddr(), request.getHeader("User-Agent"), username, localId, Event.DELETE.xmlValue());
             jones
-            leinfelder
+                // archive it
                 SystemMetadata sysMeta = HazelcastService.getInstance().getSystemMetadataMap().get(pid);
                 sysMeta.setArchived(true);
                 HazelcastService.getInstance().getSystemMetadataMap().put(pid, sysMeta);
-            leinfelder
+                // remove the system metadata for it
-            leinfelder
+                //HazelcastService.getInstance().getSystemMetadataMap().remove(pid);
             leinfelder
-            jones
+            } catch (McdbDocNotFoundException e) {
-            cjones
+                throw new NotFound("1340", "The provided identifier was invalid.");
             jones
             } catch (SQLException e) {
                 throw new ServiceFailure("1350", "There was a problem deleting the object." + "The error message was: " + e.getMessage());
             } catch (InsufficientKarmaException e) {
                 throw new NotAuthorized("1320", "The provided identity does not have " + "permission to DELETE objects on the Member Node.");
             } catch (Exception e) { // for some reason DocumentImpl throws a general Exception
                 throw new ServiceFailure("1350", "There was a problem deleting the object." + "The error message was: " + e.getMessage());
+            }
         } else {
             throw new NotAuthorized("1320", "The provided identity does not have " + "permission to DELETE objects on the Member Node.");
+        }
         return pid;
             cjones
-            jones
+    /**
      * Updates an existing object by creating a new object identified by
      * newPid on the Member Node which explicitly obsoletes the object
      * identified by pid through appropriate changes to the SystemMetadata
      * of pid and newPid
+     *
      * @param session - the Session object containing the credentials for the Subject
      * @param pid - The identifier of the object to be updated
      * @param object - the new object bytes
      * @param sysmeta - the new system metadata describing the object
+     *
      * @return newPid - the identifier of the new object
+     *
      * @throws InvalidToken
      * @throws ServiceFailure
      * @throws NotAuthorized
      * @throws NotFound
      * @throws NotImplemented
      * @throws IdentifierNotUnique
      * @throws UnsupportedType
      * @throws InsufficientResources
      * @throws InvalidSystemMetadata
      * @throws InvalidRequest
      */
     @Override
-            cjones
+    public Identifier update(Session session, Identifier pid, InputStream object,
         Identifier newPid, SystemMetadata sysmeta)
         throws InvalidToken, ServiceFailure, NotAuthorized, IdentifierNotUnique,
         UnsupportedType, InsufficientResources, NotFound,
         InvalidSystemMetadata, NotImplemented, InvalidRequest {
             cjones
-            jones
+        String localId = null;
         boolean allowed = false;
         boolean isScienceMetadata = false;
             leinfelder
         if (session == null) {
         	throw new InvalidToken("1210", "No session has been provided");
+        }
-            jones
+        Subject subject = session.getSubject();
         // do we have a valid pid?
         if (pid == null || pid.getValue().trim().equals("")) {
             throw new InvalidRequest("1202", "The provided identifier was invalid.");
             cjones
             jones
         // check for the existing identifier
         try {
             localId = IdentifierManager.getInstance().getLocalId(pid.getValue());
             cjones
-            jones
+        } catch (McdbDocNotFoundException e) {
-            cjones
+            throw new InvalidRequest("1202", "The object with the provided " +
                 "identifier was not found.");
             jones
             leinfelder
-            leinfelder
+        // set the originating node
         NodeReference originMemberNode = this.getCapabilities().getIdentifier();
         sysmeta.setOriginMemberNode(originMemberNode);
-            leinfelder
+        // set the submitter to match the certificate
         sysmeta.setSubmitter(subject);
-            leinfelder
+        // set the dates
         Date now = Calendar.getInstance().getTime();
-            cjones
+        sysmeta.setDateSysMetadataModified(now);
         sysmeta.setDateUploaded(now);
             jones
         // does the subject have WRITE ( == update) priveleges on the pid?
         allowed = isAuthorized(session, pid, Permission.WRITE);
         if (allowed) {
             leinfelder
         	// check quality of SM
         	if (sysmeta.getObsoletedBy() != null) {
         		throw new InvalidSystemMetadata("1300", "Cannot include obsoletedBy when updating object");
+        	}
         	if (sysmeta.getObsoletes() != null && !sysmeta.getObsoletes().getValue().equals(pid.getValue())) {
         		throw new InvalidSystemMetadata("1300", "The identifier provided in obsoletes does not match old Identifier");
+        	}
             jones
             // get the existing system metadata for the object
             SystemMetadata existingSysMeta = getSystemMetadata(session, pid);
             // add the newPid to the obsoletedBy list for the existing sysmeta
             existingSysMeta.setObsoletedBy(newPid);
             // then update the existing system metadata
             updateSystemMetadata(existingSysMeta);
             // prep the new system metadata, add pid to the affected lists
             sysmeta.setObsoletes(pid);
             //sysmeta.addDerivedFrom(pid);
             isScienceMetadata = isScienceMetadata(sysmeta);
             // do we have XML metadata or a data object?
             if (isScienceMetadata) {
                 // update the science metadata XML document
                 // TODO: handle non-XML metadata/data documents (like netCDF)
                 // TODO: don't put objects into memory using stream to string
                 String objectAsXML = "";
                 try {
                     objectAsXML = IOUtils.toString(object, "UTF-8");
                     localId = insertOrUpdateDocument(objectAsXML, newPid, session, "update");
                     // register the newPid and the generated localId
                     if (newPid != null) {
                         IdentifierManager.getInstance().createMapping(newPid.getValue(), localId);
+                    }
                 } catch (IOException e) {
                     String msg = "The Node is unable to create the object. " + "There was a problem converting the object to XML";
                     logMetacat.info(msg);
                     throw new ServiceFailure("1310", msg + ": " + e.getMessage());
+                }
             } else {
                 // update the data object
                 localId = insertDataObject(object, newPid, session);
+            }
             // and insert the new system metadata
             insertSystemMetadata(sysmeta);
             // log the update event
-            leinfelder
+            EventLog.getInstance().log(request.getRemoteAddr(), request.getHeader("User-Agent"), subject.getValue(), localId, Event.UPDATE.toString());
             jones
         } else {
             throw new NotAuthorized("1200", "The provided identity does not have " + "permission to UPDATE the object identified by " + pid.getValue()
                     + " on the Member Node.");
+        }
         return newPid;
             cjones
             cjones
-            jones
+    public Identifier create(Session session, Identifier pid, InputStream object, SystemMetadata sysmeta) throws InvalidToken, ServiceFailure, NotAuthorized,
             IdentifierNotUnique, UnsupportedType, InsufficientResources, InvalidSystemMetadata, NotImplemented, InvalidRequest {
             cjones
-            cjones
+        // check for null session
-            leinfelder
+        if (session == null) {
-            cjones
+          throw new InvalidToken("1110", "Session is required to WRITE to the Node.");
             leinfelder
-            leinfelder
+        // set the submitter to match the certificate
         sysmeta.setSubmitter(session.getSubject());
-            leinfelder
+        // set the originating node
         NodeReference originMemberNode = this.getCapabilities().getIdentifier();
         sysmeta.setOriginMemberNode(originMemberNode);
-            cjones
+        sysmeta.setArchived(false);
-            leinfelder
+        // set the dates
         Date now = Calendar.getInstance().getTime();
-            cjones
+        sysmeta.setDateSysMetadataModified(now);
         sysmeta.setDateUploaded(now);
             leinfelder
         // set the serial version
         sysmeta.setSerialVersion(BigInteger.ZERO);
-            leinfelder
+        // call the shared impl
-            jones
+        return super.create(session, pid, object, sysmeta);
+    }
             cjones
-            jones
+    /**
      * Called by a Coordinating Node to request that the Member Node create a
      * copy of the specified object by retrieving it from another Member
      * Node and storing it locally so that it can be made accessible to
      * the DataONE system.
+     *
      * @param session - the Session object containing the credentials for the Subject
      * @param sysmeta - Copy of the CN held system metadata for the object
      * @param sourceNode - A reference to node from which the content should be
      *                     retrieved. The reference should be resolved by
      *                     checking the CN node registry.
+     *
      * @return true if the replication succeeds
+     *
      * @throws ServiceFailure
      * @throws NotAuthorized
      * @throws NotImplemented
      * @throws UnsupportedType
      * @throws InsufficientResources
      * @throws InvalidRequest
      */
     @Override
-            cjones
+    public boolean replicate(Session session, SystemMetadata sysmeta,
             NodeReference sourceNode) throws NotImplemented, ServiceFailure,
             NotAuthorized, InvalidRequest, InsufficientResources,
             UnsupportedType {
-            cjones
+        if (session != null && sysmeta != null && sourceNode != null) {
             logMetacat.info("MNodeService.replicate() called with parameters: \n" +
                             "\tSession.Subject      = "                           +
                             session.getSubject().getValue() + "\n"                +
                             "\tSystemMetadata       = " + sysmeta.toString()      +
                             "\n" + "\tSource NodeReference ="                     +
                             sourceNode.getValue());
+        }
-            jones
+        boolean result = false;
-            cjones
+        String nodeIdStr = null;
-            cjones
+        NodeReference nodeId = null;
             cjones
-            cjones
+        // get the referenced object
         Identifier pid = sysmeta.getIdentifier();
         // get from the membernode
         // TODO: switch credentials for the server retrieval?
         this.mn = D1Client.getMN(sourceNode);
         this.cn = D1Client.getCN();
         InputStream object = null;
         Session thisNodeSession = null;
         SystemMetadata localSystemMetadata = null;
         BaseException failure = null;
-            cjones
+        String localId = null;
-            cjones
+        // TODO: check credentials
         // cannot be called by public
-            cjones
+        if (session.getSubject() == null) {
-            cjones
+            String msg = "No session was provided.";
             failure = new NotAuthorized("2152", msg);
             setReplicationStatus(thisNodeSession, pid, nodeId, ReplicationStatus.FAILED, failure);
             logMetacat.info(msg);
             return true;
+        }
-            cjones
+        // get the local node id
         try {
             nodeIdStr = PropertyService.getProperty("dataone.memberNodeId");
             nodeId = new NodeReference();
             nodeId.setValue(nodeIdStr);
             cjones
-            cjones
+        } catch (PropertyNotFoundException e1) {
-            cjones
+            String msg = "Couldn't get dataone.memberNodeId property: " + e1.getMessage();
             failure = new ServiceFailure("2151", msg);
             setReplicationStatus(thisNodeSession, pid, nodeId, ReplicationStatus.FAILED, failure);
             logMetacat.error(msg);
             return true;
             cjones
             cjones
             cjones
             jones
         try {
-            cjones
+            // do we already have a replica?
             try {
-            cjones
+                localId = IdentifierManager.getInstance().getLocalId(pid.getValue());
             cjones
-            cjones
+                String msg = "Can't read the object bytes properly, replica is invalid.";
                 ServiceFailure serviceFailure = new ServiceFailure("2151", msg);
                 // if we have a local id, get the local object
                 try {
                     object = MetacatHandler.read(localId);
                 } catch (Exception e) {
                     // let the CN know that the replication failed
                     setReplicationStatus(thisNodeSession, pid, nodeId, ReplicationStatus.FAILED, serviceFailure);
                     throw serviceFailure;
+                }
-            cjones
+            } catch (McdbDocNotFoundException e) {
-            cjones
+                logMetacat.info("No replica found. Continuing.");
             cjones
             cjones
-            cjones
+            // no local replica, get a replica
-            cjones
+            if ( object == null ) {
-            cjones
+                // session should be null to use the default certificate
                 // location set in the Certificate manager
                 object = mn.getReplica(thisNodeSession, pid);
                 logMetacat.info("MNodeService.replicate() called for identifier "
                                 + pid.getValue());
+            }
-            cjones
+        } catch (InvalidToken e) {
             String msg = "Could not retrieve object to replicate (InvalidToken): "+ e.getMessage();
             failure = new ServiceFailure("2151", msg);
             setReplicationStatus(thisNodeSession, pid, nodeId, ReplicationStatus.FAILED, failure);
             logMetacat.error(msg);
             throw new ServiceFailure("2151", msg);
             cjones
-            jones
+        } catch (NotFound e) {
-            cjones
+            String msg = "Could not retrieve object to replicate (NotFound): "+ e.getMessage();
             failure = new ServiceFailure("2151", msg);
             setReplicationStatus(thisNodeSession, pid, nodeId, ReplicationStatus.FAILED, failure);
             logMetacat.error(msg);
             throw new ServiceFailure("2151", msg);
             cjones
             jones
-            leinfelder
+        // verify checksum on the object, if supported
         if (object.markSupported()) {
-            cjones
+            Checksum givenChecksum = sysmeta.getChecksum();
             Checksum computedChecksum = null;
             try {
                 computedChecksum = ChecksumUtil.checksum(object,
                         givenChecksum.getAlgorithm());
                 object.reset();
             cjones
-            cjones
+            } catch (Exception e) {
                 String msg = "Error computing checksum on replica: "
                         + e.getMessage();
                 ServiceFailure sf = new ServiceFailure("2151", msg);
                 sf.initCause(e);
                 throw sf;
+            }
-            cjones
+            if (!givenChecksum.getValue().equals(computedChecksum.getValue())) {
                 logMetacat.debug("Given    checksum for " + pid.getValue() +
                     "is " + givenChecksum.getValue());
                 logMetacat.debug("Computed checksum for " + pid.getValue() +
                     "is " + computedChecksum.getValue());
-            cjones
+                throw new ServiceFailure("2151",
                         "Computed checksum does not match declared checksum");
+            }
             leinfelder
             cjones
-            jones
+        // add it to local store
         Identifier retPid;
         try {
-            cjones
+            // skip the MN.create -- this mutates the system metadata and we
             // dont want it to
-            cjones
+            if ( localId == null ) {
                 retPid = super.create(session, pid, object, sysmeta);
                 result = (retPid.getValue().equals(pid.getValue()));
+            }
             cjones
-            jones
+        } catch (InvalidToken e) {
-            cjones
+            String msg = "Could not save object to local store (InvalidToken): " + e.getMessage();
             failure = new ServiceFailure("2151", msg);
             setReplicationStatus(thisNodeSession, pid, nodeId, ReplicationStatus.FAILED, failure);
             logMetacat.error(msg);
             throw new ServiceFailure("2151", msg);
-            jones
+        } catch (IdentifierNotUnique e) {
-            cjones
+            String msg = "Could not save object to local store (IdentifierNotUnique): " + e.getMessage();
             failure = new ServiceFailure("2151", msg);
             setReplicationStatus(thisNodeSession, pid, nodeId, ReplicationStatus.FAILED, failure);
             logMetacat.error(msg);
             throw new ServiceFailure("2151", msg);
-            jones
+        } catch (InvalidSystemMetadata e) {
-            cjones
+            String msg = "Could not save object to local store (InvalidSystemMetadata): " + e.getMessage();
             failure = new ServiceFailure("2151", msg);
             setReplicationStatus(thisNodeSession, pid, nodeId, ReplicationStatus.FAILED, failure);
             logMetacat.error(msg);
             throw new ServiceFailure("2151", msg);
             jones
-            cjones
+        // finish by setting the replication status
         setReplicationStatus(thisNodeSession, pid, nodeId, ReplicationStatus.COMPLETED, null);
-            jones
+        return result;
             cjones
             cjones
-            jones
+    /**
      * Return the object identified by the given object identifier
+     *
      * @param session - the Session object containing the credentials for the Subject
      * @param pid - the object identifier for the given object
+     *
      * @return inputStream - the input stream of the given object
+     *
      * @throws InvalidToken
      * @throws ServiceFailure
      * @throws NotAuthorized
      * @throws InvalidRequest
      * @throws NotImplemented
      */
     @Override
-            cjones
+    public InputStream get(Session session, Identifier pid)
     throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented {
             cjones
-            jones
+        return super.get(session, pid);
             cjones
             cjones
             cjones
-            jones
+    /**
      * Returns a Checksum for the specified object using an accepted hashing algorithm
+     *
      * @param session - the Session object containing the credentials for the Subject
      * @param pid - the object identifier for the given object
      * @param algorithm -  the name of an algorithm that will be used to compute
      *                     a checksum of the bytes of the object
+     *
      * @return checksum - the checksum of the given object
+     *
      * @throws InvalidToken
      * @throws ServiceFailure
      * @throws NotAuthorized
      * @throws NotFound
      * @throws InvalidRequest
      * @throws NotImplemented
      */
     @Override
-            cjones
+    public Checksum getChecksum(Session session, Identifier pid, String algorithm)
         throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,
         InvalidRequest, NotImplemented {
             cjones
-            jones
+        Checksum checksum = null;
         InputStream inputStream = get(session, pid);
-            cjones
+        try {
-            jones
+            checksum = ChecksumUtil.checksum(inputStream, algorithm);
         } catch (NoSuchAlgorithmException e) {
             throw new ServiceFailure("1410", "The checksum for the object specified by " + pid.getValue() + "could not be returned due to an internal error: "
                     + e.getMessage());
-            cjones
+        } catch (IOException e) {
-            jones
+            throw new ServiceFailure("1410", "The checksum for the object specified by " + pid.getValue() + "could not be returned due to an internal error: "
                     + e.getMessage());
             cjones
             cjones
-            jones
+        if (checksum == null) {
             throw new ServiceFailure("1410", "The checksum for the object specified by " + pid.getValue() + "could not be returned.");
+        }
             cjones
-            jones
+        return checksum;
             cjones
             cjones
-            jones
+    /**
      * Return the system metadata for a given object
+     *
      * @param session - the Session object containing the credentials for the Subject
      * @param pid - the object identifier for the given object
+     *
      * @return inputStream - the input stream of the given system metadata object
+     *
      * @throws InvalidToken
      * @throws ServiceFailure
      * @throws NotAuthorized
      * @throws NotFound
      * @throws InvalidRequest
      * @throws NotImplemented
      */
     @Override
-            cjones
+    public SystemMetadata getSystemMetadata(Session session, Identifier pid)
         throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,
         NotImplemented {
             leinfelder
-            jones
+        return super.getSystemMetadata(session, pid);
+    }
             leinfelder
-            jones
+    /**
      * Retrieve the list of objects present on the MN that match the calling parameters
+     *
      * @param session - the Session object containing the credentials for the Subject
      * @param startTime - Specifies the beginning of the time range from which
      *                    to return object (>=)
      * @param endTime - Specifies the beginning of the time range from which
      *                  to return object (>=)
      * @param objectFormat - Restrict results to the specified object format
      * @param replicaStatus - Indicates if replicated objects should be returned in the list
      * @param start - The zero-based index of the first value, relative to the
      *                first record of the resultset that matches the parameters.
      * @param count - The maximum number of entries that should be returned in
      *                the response. The Member Node may return less entries
      *                than specified in this value.
+     *
      * @return objectList - the list of objects matching the criteria
+     *
      * @throws InvalidToken
      * @throws ServiceFailure
      * @throws NotAuthorized
      * @throws InvalidRequest
      * @throws NotImplemented
      */
     @Override
     public ObjectList listObjects(Session session, Date startTime, Date endTime, ObjectFormatIdentifier objectFormatId, Boolean replicaStatus, Integer start,
             Integer count) throws NotAuthorized, InvalidRequest, NotImplemented, ServiceFailure, InvalidToken {
             cjones
-            jones
+        ObjectList objectList = null;
             leinfelder
-            jones
+        try {
             objectList = IdentifierManager.getInstance().querySystemMetadata(startTime, endTime, objectFormatId, replicaStatus, start, count);
         } catch (Exception e) {
             throw new ServiceFailure("1580", "Error querying system metadata: " + e.getMessage());
+        }
             leinfelder
-            jones
+        return objectList;
             cjones
             cjones
-            jones
+    /**
-            jones
+     * Return a description of the node's capabilities and services.
             jones
      * @return node - the technical capabilities of the Member Node
+     *
      * @throws ServiceFailure
      * @throws NotAuthorized
      * @throws InvalidRequest
      * @throws NotImplemented
      */
     @Override
-            cjones
+    public Node getCapabilities()
         throws NotImplemented, ServiceFailure {
             cjones
-            jones
+        String nodeName = null;
         String nodeId = null;
-            jones
+        String subject = null;
-            cjones
+        String contactSubject = null;
-            jones
+        String nodeDesc = null;
-            jones
+        String nodeTypeString = null;
         NodeType nodeType = null;
-            jones
+        String mnCoreServiceVersion = null;
         String mnReadServiceVersion = null;
         String mnAuthorizationServiceVersion = null;
         String mnStorageServiceVersion = null;
         String mnReplicationServiceVersion = null;
             cjones
-            jones
+        boolean nodeSynchronize = false;
         boolean nodeReplicate = false;
         boolean mnCoreServiceAvailable = false;
         boolean mnReadServiceAvailable = false;
         boolean mnAuthorizationServiceAvailable = false;
         boolean mnStorageServiceAvailable = false;
         boolean mnReplicationServiceAvailable = false;
             cjones
-            jones
+        try {
             // get the properties of the node based on configuration information
-            jones
+            nodeName = PropertyService.getProperty("dataone.nodeName");
-            jones
+            nodeId = PropertyService.getProperty("dataone.memberNodeId");
-            jones
+            subject = PropertyService.getProperty("dataone.subject");
-            cjones
+            contactSubject = PropertyService.getProperty("dataone.contactSubject");
-            jones
+            nodeDesc = PropertyService.getProperty("dataone.nodeDescription");
-            jones
+            nodeTypeString = PropertyService.getProperty("dataone.nodeType");
             nodeType = NodeType.convert(nodeTypeString);
-            jones
+            nodeSynchronize = new Boolean(PropertyService.getProperty("dataone.nodeSynchronize")).booleanValue();
             nodeReplicate = new Boolean(PropertyService.getProperty("dataone.nodeReplicate")).booleanValue();
             mnCoreServiceVersion = PropertyService.getProperty("dataone.mnCore.serviceVersion");
             mnReadServiceVersion = PropertyService.getProperty("dataone.mnRead.serviceVersion");
             mnAuthorizationServiceVersion = PropertyService.getProperty("dataone.mnAuthorization.serviceVersion");
             mnStorageServiceVersion = PropertyService.getProperty("dataone.mnStorage.serviceVersion");
             mnReplicationServiceVersion = PropertyService.getProperty("dataone.mnReplication.serviceVersion");
             mnCoreServiceAvailable = new Boolean(PropertyService.getProperty("dataone.mnCore.serviceAvailable")).booleanValue();
             mnReadServiceAvailable = new Boolean(PropertyService.getProperty("dataone.mnRead.serviceAvailable")).booleanValue();
             mnAuthorizationServiceAvailable = new Boolean(PropertyService.getProperty("dataone.mnAuthorization.serviceAvailable")).booleanValue();
             mnStorageServiceAvailable = new Boolean(PropertyService.getProperty("dataone.mnStorage.serviceAvailable")).booleanValue();
             mnReplicationServiceAvailable = new Boolean(PropertyService.getProperty("dataone.mnReplication.serviceAvailable")).booleanValue();
-            jones
+            // Set the properties of the node based on configuration information and
             // calls to current status methods
-            leinfelder
+            String serviceName = SystemUtil.getContextURL() + "/" + PropertyService.getProperty("dataone.serviceName");
-            jones
+            Node node = new Node();
-            leinfelder
+            node.setBaseURL(serviceName + "/" + nodeTypeString);
-            jones
+            node.setDescription(nodeDesc);
             jones
-            jones
+            // set the node's health information
             node.setState(NodeState.UP);
             // set the ping response to the current value
             Ping canPing = new Ping();
             canPing.setSuccess(false);
             try {
-            leinfelder
+            	Date pingDate = ping();
                 canPing.setSuccess(pingDate != null);
             } catch (BaseException e) {
-            jones
+                e.printStackTrace();
-            leinfelder
+                // guess it can't be pinged
             jones
             cjones
-            jones
+            node.setPing(canPing);
             jones
-            jones
+            NodeReference identifier = new NodeReference();
             identifier.setValue(nodeId);
             node.setIdentifier(identifier);
-            jones
+            Subject s = new Subject();
             s.setValue(subject);
             node.addSubject(s);
-            cjones
+            Subject contact = new Subject();
             contact.setValue(contactSubject);
             node.addContactSubject(contact);
-            jones
+            node.setName(nodeName);
             node.setReplicate(nodeReplicate);
             node.setSynchronize(nodeSynchronize);
             jones
-            jones
+            // services: MNAuthorization, MNCore, MNRead, MNReplication, MNStorage
             Services services = new Services();
             jones
-            jones
+            Service sMNCore = new Service();
             sMNCore.setName("MNCore");
             sMNCore.setVersion(mnCoreServiceVersion);
             sMNCore.setAvailable(mnCoreServiceAvailable);
             jones
-            jones
+            Service sMNRead = new Service();
             sMNRead.setName("MNRead");
             sMNRead.setVersion(mnReadServiceVersion);
             sMNRead.setAvailable(mnReadServiceAvailable);
             jones
-            jones
+            Service sMNAuthorization = new Service();
             sMNAuthorization.setName("MNAuthorization");
             sMNAuthorization.setVersion(mnAuthorizationServiceVersion);
             sMNAuthorization.setAvailable(mnAuthorizationServiceAvailable);
             jones
-            jones
+            Service sMNStorage = new Service();
             sMNStorage.setName("MNStorage");
             sMNStorage.setVersion(mnStorageServiceVersion);
             sMNStorage.setAvailable(mnStorageServiceAvailable);
             jones
-            jones
+            Service sMNReplication = new Service();
             sMNReplication.setName("MNReplication");
             sMNReplication.setVersion(mnReplicationServiceVersion);
             sMNReplication.setAvailable(mnReplicationServiceAvailable);
             jones
-            jones
+            services.addService(sMNRead);
             services.addService(sMNCore);
             services.addService(sMNAuthorization);
             services.addService(sMNStorage);
             services.addService(sMNReplication);
             node.setServices(services);
             jones
-            jones
+            // Set the schedule for synchronization
             Synchronization synchronization = new Synchronization();
             Schedule schedule = new Schedule();
             Date now = new Date();
-            leinfelder
+            schedule.setYear(PropertyService.getProperty("dataone.nodeSynchronization.schedule.year"));
             schedule.setMon(PropertyService.getProperty("dataone.nodeSynchronization.schedule.mon"));
             schedule.setMday(PropertyService.getProperty("dataone.nodeSynchronization.schedule.mday"));
             schedule.setWday(PropertyService.getProperty("dataone.nodeSynchronization.schedule.wday"));
             schedule.setHour(PropertyService.getProperty("dataone.nodeSynchronization.schedule.hour"));
             schedule.setMin(PropertyService.getProperty("dataone.nodeSynchronization.schedule.min"));
             schedule.setSec(PropertyService.getProperty("dataone.nodeSynchronization.schedule.sec"));
-            jones
+            synchronization.setSchedule(schedule);
             synchronization.setLastHarvested(now);
             synchronization.setLastCompleteHarvest(now);
             node.setSynchronization(synchronization);
             jones
-            jones
+            node.setType(nodeType);
             return node;
             jones
-            jones
+        } catch (PropertyNotFoundException pnfe) {
             String msg = "MNodeService.getCapabilities(): " + "property not found: " + pnfe.getMessage();
             logMetacat.error(msg);
             throw new ServiceFailure("2162", msg);
+        }
             cjones
             cjones
-            jones
+    /**
      * Returns the number of operations that have been serviced by the node
      * over time periods of one and 24 hours.
+     *
      * @param session - the Session object containing the credentials for the Subject
      * @param period - An ISO8601 compatible DateTime range specifying the time
      *                 range for which to return operation statistics.
      * @param requestor - Limit to operations performed by given requestor identity.
      * @param event -  Enumerated value indicating the type of event being examined
      * @param format - Limit to events involving objects of the specified format
+     *
      * @return the desired log records
+     *
      * @throws InvalidToken
      * @throws ServiceFailure
      * @throws NotAuthorized
      * @throws InvalidRequest
      * @throws NotImplemented
      */
-            cjones
+    public MonitorList getOperationStatistics(Session session, Date startTime,
         Date endTime, Subject requestor, Event event, ObjectFormatIdentifier formatId)
         throws NotImplemented, ServiceFailure, NotAuthorized, InsufficientResources, UnsupportedType {
             cjones
-            jones
+        MonitorList monitorList = new MonitorList();
             cjones
-            jones
+        try {
             cjones
-            jones
+            // get log records first
             Log logs = getLogRecords(session, startTime, endTime, event, 0, null);
             cjones
-            jones
+            // TODO: aggregate by day or hour -- needs clarification
             int count = 1;
             for (LogEntry logEntry : logs.getLogEntryList()) {
                 Identifier pid = logEntry.getIdentifier();
                 Date logDate = logEntry.getDateLogged();
                 // if we are filtering by format
                 if (formatId != null) {
-            leinfelder
+                    SystemMetadata sysmeta = HazelcastService.getInstance().getSystemMetadataMap().get(pid);
-            leinfelder
+                    if (!sysmeta.getFormatId().getValue().equals(formatId.getValue())) {
-            jones
+                        // does not match
                         continue;
+                    }
+                }
                 MonitorInfo item = new MonitorInfo();
                 item.setCount(count);
                 item.setDate(new java.sql.Date(logDate.getTime()));
                 monitorList.addMonitorInfo(item);
             cjones
             jones
         } catch (Exception e) {
             e.printStackTrace();
             throw new ServiceFailure("2081", "Could not retrieve statistics: " + e.getMessage());
+        }
             cjones
-            jones
+        return monitorList;
             cjones
             cjones
-            jones
+    /**
      * A callback method used by a CN to indicate to a MN that it cannot
      * complete synchronization of the science metadata identified by pid.  Log
      * the event in the metacat event log.
+     *
      * @param session
      * @param syncFailed
+     *
      * @throws ServiceFailure
      * @throws NotAuthorized
      * @throws NotImplemented
      */
     @Override
-            leinfelder
+    public boolean synchronizationFailed(Session session, SynchronizationFailed syncFailed)
-            cjones
+        throws NotImplemented, ServiceFailure, NotAuthorized {
             cjones
-            jones
+        String localId;
             leinfelder
-            jones
+        try {
             localId = IdentifierManager.getInstance().getLocalId(syncFailed.getPid());
         } catch (McdbDocNotFoundException e) {
-            cjones
+            throw new ServiceFailure("2161", "The identifier specified by " + syncFailed.getPid() + " was not found on this node.");
             cjones
             jones
         // TODO: update the CN URL below when the CNRead.SynchronizationFailed
         // method is changed to include the URL as a parameter
         logMetacat.debug("Synchronization for the object identified by " + syncFailed.getPid() + " failed from " + syncFailed.getNodeId()
                 + " Logging the event to the Metacat EventLog as a 'syncFailed' event.");
         // TODO: use the event type enum when the SYNCHRONIZATION_FAILED event is added
-            leinfelder
+        String principal = Constants.SUBJECT_PUBLIC;
-            leinfelder
+        if (session != null && session.getSubject() != null) {
-            cjones
+          principal = session.getSubject().getValue();
             leinfelder
         try {
-            cjones
+          EventLog.getInstance().log(request.getRemoteAddr(), request.getHeader("User-Agent"), principal, localId, "synchronization_failed");
-            leinfelder
+        } catch (Exception e) {
             throw new ServiceFailure("2161", "Could not log the error for: " + syncFailed.getPid());
             leinfelder
-            jones
+        //EventLog.getInstance().log("CN URL WILL GO HERE",
         //  session.getSubject().getValue(), localId, Event.SYNCHRONIZATION_FAILED);
-            leinfelder
+        return true;
             cjones
             cjones
-            jones
+    /**
      * Essentially a get() but with different logging behavior
      */
     @Override
-            cjones
+    public InputStream getReplica(Session session, Identifier pid)
-            leinfelder
+        throws NotAuthorized, NotImplemented, ServiceFailure, InvalidToken {
             cjones
-            cjones
+        logMetacat.info("MNodeService.getReplica() called.");
-            leinfelder
+        // cannot be called by public
         if (session == null) {
         	throw new InvalidToken("2183", "No session was provided.");
+        }
-            cjones
+        logMetacat.info("MNodeService.getReplica() called with parameters: \n" +
              "\tSession.Subject      = " + session.getSubject().getValue() + "\n" +
              "\tIdentifier           = " + pid.getValue());
-            jones
+        InputStream inputStream = null; // bytes to be returned
         handler = new MetacatHandler(new Timer());
         boolean allowed = false;
         String localId; // the metacat docid for the pid
             cjones
-            jones
+        // get the local docid from Metacat
         try {
             localId = IdentifierManager.getInstance().getLocalId(pid.getValue());
         } catch (McdbDocNotFoundException e) {
-            cjones
+            throw new ServiceFailure("2181", "The object specified by " +
                     pid.getValue() + " does not exist at this node.");
             jones
             cjones
-            leinfelder
+        Subject targetNodeSubject = session.getSubject();
             leinfelder
-            leinfelder
+        // check for authorization to replicate, null session to act as this source MN
-            cjones
+        try {
-            leinfelder
+            allowed = D1Client.getCN().isNodeAuthorized(null, targetNodeSubject, pid);
-            cjones
+        } catch (InvalidToken e1) {
             throw new ServiceFailure("2181", "Could not determine if node is authorized: "
                 + e1.getMessage());
         } catch (NotFound e1) {
             throw new ServiceFailure("2181", "Could not determine if node is authorized: "
                     + e1.getMessage());
             cjones
-            cjones
+        } catch (InvalidRequest e1) {
             throw new ServiceFailure("2181", "Could not determine if node is authorized: "
                     + e1.getMessage());
+        }
-            cjones
+        logMetacat.info("Called D1Client.isNodeAuthorized(). Allowed = " + allowed +
             " for identifier " + pid.getValue());
-            jones
+        // if the person is authorized, perform the read
         if (allowed) {
             try {
-            jones
+                inputStream = MetacatHandler.read(localId);
-            jones
+            } catch (Exception e) {
-            cjones
+                throw new ServiceFailure("1020", "The object specified by " +
                     pid.getValue() + "could not be returned due to error: " + e.getMessage());
             jones
+        }
             cjones
-            jones
+        // if we fail to set the input stream
         if (inputStream == null) {
-            cjones
+            throw new ServiceFailure("2181", "The object specified by " +
                 pid.getValue() + "does not exist at this node.");
             jones
         // log the replica event
         String principal = null;
         if (session.getSubject() != null) {
             principal = session.getSubject().getValue();
+        }
-            cjones
+        EventLog.getInstance().log(request.getRemoteAddr(),
             request.getHeader("User-Agent"), principal, localId, "replicate");
             jones
         return inputStream;
+    }
-            cjones
+    /**
-            cjones
+     * A method to notify the Member Node that the authoritative copy of
-            cjones
+     * system metadata on the Coordinating Nodes has changed.
+     *
      * @param session   Session information that contains the identity of the
      *                  calling user as retrieved from the X.509 certificate
      *                  which must be traceable to the CILogon service.
      * @param serialVersion   The serialVersion of the system metadata
      * @param dateSysMetaLastModified  The time stamp for when the system metadata was changed
      * @throws NotImplemented
      * @throws ServiceFailure
      * @throws NotAuthorized
      * @throws InvalidRequest
      * @throws InvalidToken
      */
-            leinfelder
+    public boolean systemMetadataChanged(Session session, Identifier pid,
-            cjones
+        long serialVersion, Date dateSysMetaLastModified)
         throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest,
         InvalidToken {
-            cjones
+        SystemMetadata currentLocalSysMeta = null;
         SystemMetadata newSysMeta = null;
         CNode cn = D1Client.getCN();
         NodeList nodeList = null;
         Subject callingSubject = null;
         boolean allowed = false;
         // are we allowed to call this?
         callingSubject = session.getSubject();
         nodeList = cn.listNodes();
         for(Node node : nodeList.getNodeList()) {
             // must be a CN
             if ( node.getType().equals(NodeType.CN)) {
                List<Subject> subjectList = node.getSubjectList();
                // the calling subject must be in the subject list
                if ( subjectList.contains(callingSubject)) {
                    allowed = true;
+               }
+            }
+        }
         if (!allowed ) {
             String msg = "The subject identified by " + callingSubject.getValue() +
               " is not authorized to call this service.";
             throw new NotAuthorized("1331", msg);
+        }
         // compare what we have locally to what is sent in the change notification
         try {
-            leinfelder
+            currentLocalSysMeta = HazelcastService.getInstance().getSystemMetadataMap().get(pid);
         } catch (RuntimeException e) {
-            cjones
+            String msg = "SystemMetadata for pid " + pid.getValue() +
-            leinfelder
+              " couldn't be updated because it couldn't be found locally: " +
-            cjones
+              e.getMessage();
-            leinfelder
+            logMetacat.error(msg);
             ServiceFailure sf = new ServiceFailure("1333", msg);
             sf.initCause(e);
             throw sf;
             cjones
         if (currentLocalSysMeta.getSerialVersion().longValue() < serialVersion ) {
             try {
                 newSysMeta = cn.getSystemMetadata(null, pid);
             } catch (NotFound e) {
                 // huh? you just said you had it
-            leinfelder
+            	String msg = "On updating the local copy of system metadata " +
                 "for pid " + pid.getValue() +", the CN reports it is not found." +
                 " The error message was: " + e.getMessage();
                 logMetacat.error(msg);
                 ServiceFailure sf = new ServiceFailure("1333", msg);
                 sf.initCause(e);
                 throw sf;
             cjones
             leinfelder
-            cjones
+            // update the local copy of system metadata for the pid
             try {
-            leinfelder
+                HazelcastService.getInstance().getSystemMetadataMap().put(newSysMeta.getIdentifier(), newSysMeta);
-            cjones
+                logMetacat.info("Updated local copy of system metadata for pid " +
                     pid.getValue() + " after change notification from the CN.");
-            leinfelder
+            } catch (RuntimeException e) {
-            cjones
+                String msg = "SystemMetadata for pid " + pid.getValue() +
-            leinfelder
+                  " couldn't be updated: " +
-            cjones
+                  e.getMessage();
-            leinfelder
+                logMetacat.error(msg);
                 ServiceFailure sf = new ServiceFailure("1333", msg);
                 sf.initCause(e);
                 throw sf;
             cjones
+        }
-            leinfelder
+        return true;
             cjones
-            cjones
+    /*
      * Set the replication status for the object on the Coordinating Node
+     *
      * @param session - the session for the this target node
      * @param pid - the identifier of the object being updated
      * @param nodeId - the identifier of this target node
      * @param status - the replication status to set
      * @param failure - the exception to include, if any
      */
     private void setReplicationStatus(Session session, Identifier pid,
         NodeReference nodeId, ReplicationStatus status, BaseException failure)
         throws ServiceFailure, NotImplemented, NotAuthorized,
         InvalidRequest {
         // call the CN as the MN to set the replication status
         try {
             this.cn = D1Client.getCN();
             this.cn.setReplicationStatus(session, pid, nodeId,
                     status, failure);
         } catch (InvalidToken e) {
             throw new ServiceFailure("2151",
                     "Could not set the replication status on the CN (InvalidToken): " +
                     e.getMessage());
         } catch (NotFound e) {
             throw new ServiceFailure("2151",
                     "Could not set the replication status on the CN (NotFound): " +
                     e.getMessage());
+        }
+    }
             cjones

Project

General

Profile

Metacat