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

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

-            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;
-            cjones
+import java.security.NoSuchAlgorithmException;
-            cjones
+import java.sql.SQLException;
-            cjones
+import java.text.SimpleDateFormat;
-            cjones
+import java.util.Date;
-            cjones
+import java.util.List;
-            leinfelder
+import java.util.Timer;
             cjones
-            cjones
+import org.apache.commons.io.IOUtils;
-            cjones
+import org.apache.log4j.Logger;
-            leinfelder
+import org.dataone.client.D1Client;
 import org.dataone.client.MNode;
-            leinfelder
+import org.dataone.service.util.Constants;
-            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.DescribeResponse;
 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;
 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;
 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;
             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;
-            cjones
+import edu.ucsb.nceas.metacat.database.DBConnection;
 import edu.ucsb.nceas.metacat.database.DBConnectionPool;
-            cjones
+import edu.ucsb.nceas.metacat.properties.PropertyService;
 import edu.ucsb.nceas.metacat.util.SystemUtil;
 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
+ */
 public class MNodeService extends D1NodeService implements MNAuthorization,
   MNCore, MNRead, MNReplication, MNStorage {
-            cjones
+  /* the instance of the MNodeService object */
-            cjones
+  private static MNodeService instance = null;
   /* the logger instance */
   private Logger logMetacat = null;
   /**
-            cjones
+   * Singleton accessor to get an instance of MNodeService.
+   *
    * @return instance - the instance of MNodeService
-            cjones
+   */
-            cjones
+  public static MNodeService getInstance() {
-            cjones
+    if (instance == null) {
             cjones
-            cjones
+      instance = new MNodeService();
             cjones
             cjones
     return instance;
+  }
   /**
    * Constructor, private for singleton access
    */
-            cjones
+  private MNodeService() {
-            cjones
+    super();
-            cjones
+    logMetacat = Logger.getLogger(MNodeService.class);
+  }
-            cjones
+  /**
    * 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
    */
-            jones
+  @Override
-            cjones
+  public Identifier delete(Session session, Identifier pid)
-            cjones
+    throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,
     NotImplemented, InvalidRequest {
-            cjones
+    String localId = null;
     boolean allowed = false;
-            leinfelder
+    String username = Constants.PUBLIC_SUBJECT;
     String[] groupnames = null;
     if (session != null ) {
     	username = session.getSubject().getValue();
     	if (session.getSubjectList() != null) {
     		List<Group> groupList = session.getSubjectList().getGroupList();
     		if (groupList != null) {
     			groupnames = new String[groupList.size()];
     			for (int i = 0; i > groupList.size(); i++ ) {
     				groupnames[i] = groupList.get(i).getGroupName();
+    			}
+    		}
+    	}
             cjones
             cjones
     // do we have a valid pid?
     if ( pid == null || pid.getValue().trim().equals("") ) {
       throw new InvalidRequest("1322", "The provided identifier was invalid.");
+    }
     // check for the existing identifier
     try {
-            leinfelder
+      localId = IdentifierManager.getInstance().getLocalId(pid.getValue());
             cjones
     } catch (McdbDocNotFoundException e) {
       throw new InvalidRequest("1322", "The object with the provided " +
-            cjones
+        "identifier was not found.");
             cjones
+    }
     // does the subject have DELETE (a D1 CHANGE_PERMISSION level) priveleges on the pid?
     allowed = isAuthorized(session, pid, Permission.CHANGE_PERMISSION);
     if ( allowed ) {
       try {
         // delete the document
-            leinfelder
+        DocumentImpl.delete(localId, username, groupnames, null);
-            leinfelder
+        EventLog.getInstance().log(metacatUrl, username, localId, Event.DELETE.xmlValue());
             cjones
-            cjones
+      } catch (McdbDocNotFoundException e) {
         throw new InvalidRequest("1322", "The provided identifier was invalid.");
       } catch (SQLException e) {
         throw new ServiceFailure("1350", "There was a problem deleting the object." +
-            cjones
+          "The error message was: " + e.getMessage());
             cjones
       } 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." +
-            cjones
+            "The error message was: " + e.getMessage());
             cjones
+      }
     } else {
-            cjones
+      throw new NotAuthorized("1320", "The provided identity does not have " +
       "permission to DELETE objects on the Member Node.");
             cjones
             cjones
-            cjones
+    return pid;
+  }
             cjones
             cjones
-            cjones
+  /**
    * 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
+   *
-            cjones
+   * @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
-            cjones
+   */
-            jones
+  @Override
-            cjones
+  public Identifier update(Session session, Identifier pid, InputStream object,
     Identifier newPid, SystemMetadata sysmeta)
-            cjones
+    throws InvalidToken, ServiceFailure, NotAuthorized, IdentifierNotUnique,
     UnsupportedType, InsufficientResources, NotFound, InvalidSystemMetadata,
     NotImplemented, InvalidRequest {
             leinfelder
 	// check if the pid has been reserved
 	try {
 		boolean hasReservation = D1Client.getCN().hasReservation(session, pid);
 		if (!hasReservation) {
 			throw new NotAuthorized("", "No reservation for pid: " + pid.getValue());
+		}
 	} catch (NotFound e) {
 		// okay to continue
+	}
             cjones
-            cjones
+    String localId = null;
     boolean allowed = false;
     boolean isScienceMetadata = false;
     Subject subject = session.getSubject();
             leinfelder
-            cjones
+    // do we have a valid pid?
     if ( pid == null || pid.getValue().trim().equals("") ) {
       throw new InvalidRequest("1202", "The provided identifier was invalid.");
             cjones
             cjones
             cjones
-            cjones
+    // check for the existing identifier
     try {
-            leinfelder
+      localId = IdentifierManager.getInstance().getLocalId(pid.getValue());
             cjones
-            cjones
+    } catch (McdbDocNotFoundException e) {
       throw new InvalidRequest("1202", "The object with the provided " +
         "identifier was not found.");
             cjones
             cjones
             cjones
-            cjones
+    // does the subject have WRITE ( == update) priveleges on the pid?
     allowed = isAuthorized(session, pid, Permission.WRITE);
             cjones
-            cjones
+    if ( allowed ) {
       // get the existing system metadata for the object
       SystemMetadata existingSysMeta = getSystemMetadata(session, pid);
-            cjones
+      // add the newPid to the obsoletedBy list for the existing sysmeta
-            leinfelder
+      existingSysMeta.setObsoletedBy(newPid);
             cjones
       // then update the existing system metadata
       updateSystemMetadata(existingSysMeta);
             cjones
       // prep the new system metadata, add pid to the affected lists
-            leinfelder
+      sysmeta.setObsoletes(pid);
       //sysmeta.addDerivedFrom(pid);
             cjones
       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 ) {
-            leinfelder
+        	  IdentifierManager.getInstance().createMapping(newPid.getValue(), localId);
             cjones
+          }
         } catch (IOException e) {
           String msg = "The Node is unable to create the object. " +
-            cjones
+          "There was a problem converting the object to XML";
-            cjones
+          logMetacat.info(msg);
-            cjones
+          throw new ServiceFailure("1310", msg + ": " + e.getMessage());
             cjones
+        }
       } else {
         // update the data object
         localId = insertDataObject(object, newPid, session);
+      }
             cjones
       // and insert the new system metadata
       insertSystemMetadata(sysmeta);
-            cjones
+      // log the update event
-            cjones
+      EventLog.getInstance().log(metacatUrl, subject.getValue(), localId, "update");
-            cjones
+    } else {
       throw new NotAuthorized("1200", "The provided identity does not have " +
       "permission to UPDATE the object identified by " +
       pid.getValue() + " on the Member Node.");
+    }
             cjones
-            cjones
+    return newPid;
             cjones
             leinfelder
   public Identifier create(Session session, Identifier pid,
 			InputStream object, SystemMetadata sysmeta) throws InvalidToken,
 			ServiceFailure, NotAuthorized, IdentifierNotUnique,
 			UnsupportedType, InsufficientResources, InvalidSystemMetadata,
 			NotImplemented, InvalidRequest {
             cjones
-            leinfelder
+		// check if the pid has been reserved
 		try {
 			boolean hasReservation = D1Client.getCN().hasReservation(session, pid);
 			if (!hasReservation) {
 				throw new NotAuthorized("", "No reservation for pid: " + pid.getValue());
+			}
 		} catch (NotFound e) {
 			// okay to continue
+		}
 		return super.create(session, pid, object, sysmeta);
+	}
-            cjones
+  /**
    * 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.
+   *
-            cjones
+   * @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
-            cjones
+   */
-            jones
+  @Override
-            cjones
+  public boolean replicate(Session session, SystemMetadata sysmeta,
     NodeReference sourceNode)
     throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest,
     InsufficientResources, UnsupportedType {
             cjones
-            leinfelder
+    boolean result = false;
     // TODO: check credentials
     // get the referenced object
     Identifier pid = sysmeta.getIdentifier();
     // get from the membernode
     // TODO: switch credentials for the server retrieval?
     MNode mn = D1Client.getMN(sourceNode);
     InputStream object = null;
 	try {
 		object = mn.get(session, pid);
 	} catch (InvalidToken e) {
 		e.printStackTrace();
 		throw new ServiceFailure("2151", "Could not retrieve object to replicate (InvalidToken): " + e.getMessage());
 	} catch (NotFound e) {
 		e.printStackTrace();
 		throw new ServiceFailure("2151", "Could not retrieve object to replicate (NotFound): " + e.getMessage());
+	}
     // add it to local store
 	Identifier retPid;
 	try {
 		retPid = create(session, pid, object, sysmeta);
 		result = (retPid.getValue().equals(pid.getValue()));
 	} catch (InvalidToken e) {
 		e.printStackTrace();
 		throw new ServiceFailure("2151", "Could not save object to local store (InvalidToken): " + e.getMessage());
 	} catch (IdentifierNotUnique e) {
 		e.printStackTrace();
 		throw new ServiceFailure("2151", "Could not save object to local store (IdentifierNotUnique): " + e.getMessage());
 	} catch (InvalidSystemMetadata e) {
 		e.printStackTrace();
 		throw new ServiceFailure("2151", "Could not save object to local store (InvalidSystemMetadata): " + e.getMessage());
+	}
     return result;
             cjones
             cjones
   /**
    * This method provides a lighter weight mechanism than
    * MN_read.getSystemMetadata() for a client to determine basic
    * properties of the referenced object.
+   *
-            cjones
+   * @param session - the Session object containing the credentials for the Subject
    * @param pid - the identifier of the object to be described
+   *
    * @return describeResponse - A set of values providing a basic description
    *                            of the object.
+   *
    * @throws InvalidToken
    * @throws ServiceFailure
    * @throws NotAuthorized
    * @throws NotFound
    * @throws NotImplemented
    * @throws InvalidRequest
-            cjones
+   */
-            jones
+  @Override
-            cjones
+  public DescribeResponse describe(Session session, Identifier pid)
     throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,
     NotImplemented, InvalidRequest {
             cjones
-            cjones
+    if(session == null) {
-            cjones
+      throw new InvalidToken("1370", "The session object is null");
+    }
     if(pid == null || pid.getValue().trim().equals(""))
+    {
       throw new InvalidRequest("1362", "The object identifier is null. " +
         "A valid identifier is required.");
+    }
     SystemMetadata sysmeta = getSystemMetadata(session, pid);
     DescribeResponse describeResponse =
-            cjones
+      new DescribeResponse(sysmeta.getFmtid(),
-            cjones
+      sysmeta.getSize(), sysmeta.getDateSysMetadataModified(), sysmeta.getChecksum());
     return describeResponse;
             cjones
             cjones
             cjones
-            cjones
+  /**
    * 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
    */
-            cjones
+  @Override
-            cjones
+  public InputStream get(Session session, Identifier pid)
     throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,
     NotImplemented, InvalidRequest {
     return super.get(session, pid);
+  }
             cjones
-            cjones
+  /**
    * 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
    */
-            jones
+  @Override
-            cjones
+  public Checksum getChecksum(Session session, Identifier pid, String algorithm)
     throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,
     InvalidRequest, NotImplemented {
             cjones
-            cjones
+    Checksum checksum = null;
             cjones
-            cjones
+    InputStream inputStream = get(session, pid);
     try {
       checksum =
-            leinfelder
+    	  ChecksumUtil.checksum(inputStream, algorithm);
             cjones
     } catch (NoSuchAlgorithmException e) {
-            cjones
+      throw new ServiceFailure("1410", "The checksum for the object specified by " +
         pid.getValue() +
         "could not be returned due to an internal error: " +
         e.getMessage());
     } catch (IOException 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
-            cjones
+    if ( checksum == null ) {
       throw new ServiceFailure("1410", "The checksum for the object specified by " +
         pid.getValue() +
         "could not be returned.");
+    }
-            cjones
+    return checksum;
+  }
             cjones
-            cjones
+  /**
    * 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
    */
-            cjones
+  @Override
-            cjones
+  public SystemMetadata getSystemMetadata(Session session, Identifier pid)
       throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,
       InvalidRequest, NotImplemented {
             cjones
-            cjones
+    return super.getSystemMetadata(session, pid);
+  }
             cjones
-            cjones
+  /**
    * 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
    */
-            jones
+  @Override
-            cjones
+  public ObjectList listObjects(Session session, Date startTime, Date endTime,
-            leinfelder
+    ObjectFormatIdentifier objectFormatId, Boolean replicaStatus, Integer start, Integer count)
-            cjones
+    throws NotAuthorized, InvalidRequest, NotImplemented, ServiceFailure,
     InvalidToken {
             cjones
-            cjones
+    ObjectList objectList = null;
-            leinfelder
+    try {
 	    objectList = IdentifierManager.getInstance().querySystemMetadata(startTime, endTime,
-            leinfelder
+	        objectFormatId, replicaStatus, start, count);
-            leinfelder
+    } catch (Exception e) {
 		throw new ServiceFailure("1580", "Error querying system metadata: " + e.getMessage());
+	}
             cjones
     return objectList;
+  }
             cjones
-            cjones
+  /**
    * Retrieve the list of objects present on the MN that match the calling parameters
+   *
    * @return node - the technical capabilities of the Member Node
+   *
    * @throws ServiceFailure
    * @throws NotAuthorized
    * @throws InvalidRequest
    * @throws NotImplemented
    */
-            jones
+  @Override
-            cjones
+  public Node getCapabilities() throws NotImplemented, NotAuthorized,
       ServiceFailure, InvalidRequest {
             cjones
   	String nodeName = null;
     String nodeId = null;
     String nodeUrl = null;
     String nodeDesc = null;
     String nodeType = null;
-            cjones
+    String mnCoreServiceVersion = null;
     String mnReadServiceVersion = null;
     String mnAuthorizationServiceVersion = null;
     String mnStorageServiceVersion = null;
     String mnReplicationServiceVersion = null;
             cjones
-            cjones
+    boolean nodeSynchronize = false;
     boolean nodeReplicate = false;
-            cjones
+    boolean mnCoreServiceAvailable = false;
     boolean mnReadServiceAvailable = false;
     boolean mnAuthorizationServiceAvailable = false;
     boolean mnStorageServiceAvailable = false;
     boolean mnReplicationServiceAvailable = false;
-            cjones
+    try
+    {
-            cjones
+    	// get the properties of the node based on configuration information
-            cjones
+      nodeId = PropertyService.getProperty("dataone.memberNodeId");
       nodeName = PropertyService.getProperty("dataone.nodeName");
       nodeUrl = SystemUtil.getContextURL() + "/d1/";
       nodeDesc = PropertyService.getProperty("dataone.nodeDescription");
       nodeType = PropertyService.getProperty("dataone.nodeType");
-            cjones
+      nodeSynchronize =
       	new Boolean(PropertyService.getProperty(
       		"dataone.nodeSynchronize")).booleanValue();
       nodeReplicate =
       	new Boolean(PropertyService.getProperty(
       		"dataone.nodeReplicate")).booleanValue();
-            cjones
+      mnCoreServiceVersion =
-            cjones
+      	PropertyService.getProperty("dataone.mnCore.serviceVersion");
-            cjones
+      mnReadServiceVersion =
-            cjones
+      	PropertyService.getProperty("dataone.mnRead.serviceVersion");
-            cjones
+      mnAuthorizationServiceVersion =
-            cjones
+      	PropertyService.getProperty("dataone.mnAuthorization.serviceVersion");
-            cjones
+      mnStorageServiceVersion =
-            cjones
+      	PropertyService.getProperty("dataone.mnStorage.serviceVersion");
-            cjones
+      mnReplicationServiceVersion =
-            cjones
+      	PropertyService.getProperty("dataone.mnReplication.serviceVersion");
             cjones
       mnCoreServiceAvailable = new Boolean(
-            cjones
+      	PropertyService.getProperty("dataone.mnCore.serviceAvailable")).booleanValue();
-            cjones
+      mnReadServiceAvailable =  new Boolean(
       	PropertyService.getProperty(
-            cjones
+      		"dataone.mnRead.serviceAvailable")).booleanValue();
-            cjones
+      mnAuthorizationServiceAvailable =  new Boolean(
       	PropertyService.getProperty(
-            cjones
+      		"dataone.mnAuthorization.serviceAvailable")).booleanValue();
-            cjones
+      mnStorageServiceAvailable =  new Boolean(
       	PropertyService.getProperty(
-            cjones
+      	  "dataone.mnStorage.serviceAvailable")).booleanValue();
-            cjones
+      mnReplicationServiceAvailable =  new Boolean(
       	PropertyService.getProperty(
-            cjones
+      	  "dataone.mnReplication.serviceAvailable")).booleanValue();
             cjones
-            cjones
+    } catch(PropertyNotFoundException pnfe) {
         logMetacat.error("MNodeService.getCapabilities(): " +
           "property not found: " + pnfe.getMessage());
+    }
-            cjones
+  	// Set the properties of the node based on configuration information and
     // calls to current status methods
-            leinfelder
+	  Node node = new Node();
-            cjones
+	  node.setBaseURL(metacatUrl + "/" + nodeType);
 	  node.setDescription(nodeDesc);
             cjones
 	  // set the node's health information
 	  NodeState state = NodeState.UP;
-            leinfelder
+	  node.setState(state);
-            cjones
+	  // set the ping response to the current value
 	  Ping canPing = new Ping();
 	  canPing.setSuccess(false);
 	  try {
 	    canPing.setSuccess(ping());
     } catch (InsufficientResources e) {
 	    e.printStackTrace();
     } catch (UnsupportedType e) {
 	    e.printStackTrace();
+    }
-            leinfelder
+	  node.setPing(canPing);
             cjones
-            leinfelder
+	  NodeReference identifier = new NodeReference();
-            cjones
+	  identifier.setValue(nodeId);
-            leinfelder
+	  node.setIdentifier(identifier);
-            cjones
+	  node.setName(nodeName + " -- WAR version WARVERSION");
-            cjones
+	  node.setReplicate(new Boolean(nodeReplicate).booleanValue());
 	  node.setSynchronize(new Boolean(nodeSynchronize).booleanValue());
-            leinfelder
+	  // services: MNAuthorization, MNCore, MNRead, MNReplication, MNStorage
 	  Services services = new Services();
             cjones
 	  Service sMNCore = new Service();
 	  sMNCore.setName("MNCore");
 	  sMNCore.setVersion(mnCoreServiceVersion);
 	  sMNCore.setAvailable(mnCoreServiceAvailable);
-            leinfelder
+	  Service sMNRead = new Service();
 	  sMNRead.setName("MNRead");
-            cjones
+	  sMNRead.setVersion(mnReadServiceVersion);
-            cjones
+	  sMNRead.setAvailable(mnReadServiceAvailable);
             cjones
-            leinfelder
+	  Service sMNAuthorization = new Service();
 	  sMNAuthorization.setName("MNAuthorization");
-            cjones
+	  sMNAuthorization.setVersion(mnAuthorizationServiceVersion);
-            cjones
+	  sMNAuthorization.setAvailable(mnAuthorizationServiceAvailable);
             cjones
-            leinfelder
+	  Service sMNStorage = new Service();
 	  sMNStorage.setName("MNStorage");
-            cjones
+	  sMNStorage.setVersion(mnStorageServiceVersion);
-            cjones
+	  sMNStorage.setAvailable(mnStorageServiceAvailable);
             cjones
-            leinfelder
+	  Service sMNReplication = new Service();
 	  sMNReplication.setName("MNReplication");
-            cjones
+	  sMNReplication.setVersion(mnReplicationServiceVersion);
-            cjones
+	  sMNReplication.setAvailable(mnReplicationServiceAvailable);
             cjones
-            leinfelder
+	  services.addService(sMNRead);
 	  services.addService(sMNCore);
 	  services.addService(sMNAuthorization);
 	  services.addService(sMNStorage);
 	  services.addService(sMNReplication);
-            cjones
+	  node.setServices(services);
             cjones
-            cjones
+	  // TODO: Determine the synchronization info without mock values
-            leinfelder
+	  Synchronization synchronization = new Synchronization();
-            cjones
+	  Schedule schedule = new Schedule();
 	  Date now = new Date();
 	  schedule.setYear(new SimpleDateFormat("yyyy").format(now));
 	  schedule.setMon(new SimpleDateFormat("MM").format(now));
 	  schedule.setMday(new SimpleDateFormat("dd").format(now));
 	  schedule.setWday(new SimpleDateFormat("dd").format(now));
 	  schedule.setHour(new SimpleDateFormat("HH").format(now));
 	  schedule.setMin(new SimpleDateFormat("mm").format(now));
 	  schedule.setSec(new SimpleDateFormat("ss").format(now));
 	  synchronization.setSchedule(schedule);
 	  synchronization.setLastHarvested(now);
 	  synchronization.setLastCompleteHarvest(now);
-            cjones
+	  node.setSynchronization(synchronization);
-            leinfelder
+	  node.setSynchronize(false);
 	  node.setType(NodeType.MN);
 	  return node;
             cjones
             cjones
-            cjones
+  /**
    * 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
    */
-            jones
+  @Override
-            cjones
+  public MonitorList getOperationStatistics(Session session, Date startTime,
   		Date endTime, Subject requestor, Event event, ObjectFormatIdentifier formatId)
-            cjones
+    throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest,
     InsufficientResources, UnsupportedType {
             cjones
-            leinfelder
+	  MonitorList monitorList = new MonitorList();
 	  try {
 		  // get log records first
 		  Log logs = getLogRecords(session, startTime, endTime, event, 0, null);
 		  // 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) {
 				  SystemMetadata sysmeta = IdentifierManager.getInstance().getSystemMetadata(pid.getValue());
-            cjones
+				  if (!sysmeta.getFmtid().getValue().equals(formatId.getValue())) {
-            leinfelder
+					  // does not match
 					  continue;
+				  }
+			  }
 			  MonitorInfo item = new MonitorInfo();
 			  item.setCount(count);
 			  item.setDate(new java.sql.Date(logDate.getTime()));
 			  monitorList.addMonitorInfo(item);
+		  }
 	} catch (Exception e) {
 		e.printStackTrace();
 		throw new ServiceFailure("2081", "Could not retrieve statistics: " + e.getMessage());
+	}
 	return monitorList;
             cjones
             cjones
   /**
    * Low level “are you alive” operation. A valid ping response is
    * indicated by a HTTP status of 200.
+   *
    * @return true if the service is alive
+   *
-            cjones
+   * @throws InvalidToken
    * @throws ServiceFailure
    * @throws NotAuthorized
    * @throws InvalidRequest
    * @throws NotImplemented
-            cjones
+   */
-            jones
+  @Override
-            cjones
+  public boolean ping()
     throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest,
     InsufficientResources, UnsupportedType {
             cjones
-            cjones
+    // test if we can get a database connection
     boolean alive = false;
     int serialNumber = -1;
     DBConnection dbConn = null;
     try {
       dbConn = DBConnectionPool
       .getDBConnection("MNodeService.ping");
       serialNumber = dbConn.getCheckOutSerialNumber();
       alive = true;
     } catch (SQLException e) {
       return alive;
     } finally {
       // Return the database connection
       DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+    }
     return alive;
             cjones
             cjones
-            cjones
+  /**
    * A callback method used by a CN to indicate to a MN that it cannot
-            cjones
+   * complete synchronization of the science metadata identified by pid.  Log
    * the event in the metacat event log.
             cjones
    * @param session
    * @param syncFailed
             cjones
    * @throws ServiceFailure
    * @throws NotAuthorized
    * @throws InvalidRequest
    * @throws NotImplemented
-            cjones
+   */
-            jones
+  @Override
-            cjones
+  public void synchronizationFailed(Session session, SynchronizationFailed syncFailed)
       throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest {
             cjones
-            cjones
+    String localId;
     try {
-            leinfelder
+      localId = IdentifierManager.getInstance().getLocalId(syncFailed.getPid());
-            cjones
+    } catch (McdbDocNotFoundException e) {
-            leinfelder
+      throw new InvalidRequest("2163", "The identifier specified by " +
-            leinfelder
+          syncFailed.getPid() +
-            cjones
+          " was not found on this node.");
             cjones
+    }
-            cjones
+    // TODO: update the CN URL below when the CNRead.SynchronizationFailed
-            cjones
+    // method is changed to include the URL as a parameter
     logMetacat.debug("Synchronization for the object identified by " +
-            leinfelder
+      syncFailed.getPid() +
-            cjones
+      " failed from " +
-            cjones
+      syncFailed.getNodeId() +
-            cjones
+      " Logging the event to the Metacat EventLog as a 'syncFailed' event.");
-            cjones
+    // TODO: use the event type enum when the SYNCHRONIZATION_FAILED event is added
-            cjones
+    EventLog.getInstance().log(syncFailed.getNodeId(),
-            cjones
+      session.getSubject().getValue(), localId, "synchronization_failed");
     //EventLog.getInstance().log("CN URL WILL GO HERE",
     //  session.getSubject().getValue(), localId, Event.SYNCHRONIZATION_FAILED);
             cjones
             cjones
             leinfelder
-            cjones
+  /**
-            jones
+   * Essentially a get() but with different logging behavior
-            cjones
+   */
-            jones
+	@Override
-            cjones
+  public InputStream getReplica(Session session, Identifier pid)
     throws InvalidRequest, InvalidToken, NotAuthorized, NotImplemented,
     ServiceFailure, NotFound {
             leinfelder
 		InputStream inputStream = null; // bytes to be returned
 	    handler = new MetacatHandler(new Timer());
 	    boolean allowed = false;
 	    String localId; // the metacat docid for the pid
 	    // get the local docid from Metacat
 	    try {
 	      localId = IdentifierManager.getInstance().getLocalId(pid.getValue());
 	    } catch (McdbDocNotFoundException e) {
 	      throw new NotFound("1020", "The object specified by " +
 	                         pid.getValue() +
 	                         " does not exist at this node.");
+	    }
-            leinfelder
+	    Node node = this.getCapabilities();
 	    Subject targetNodeSubject = node.getSubject(0);
             leinfelder
-            leinfelder
+		// check for authorization to replicate
-            leinfelder
+	    allowed = D1Client.getCN().isReplicationAuthorized(session, targetNodeSubject , pid, Permission.REPLICATE);
             leinfelder
-            leinfelder
+	    // if the person is authorized, perform the read
 	    if (allowed) {
 	      try {
 	        inputStream = handler.read(localId);
 	      } catch (Exception e) {
 	        throw new ServiceFailure("1020", "The object specified by " +
 	            pid.getValue() +
 	            "could not be returned due to error: " +
 	            e.getMessage());
+	      }
+	    }
             cjones
-            leinfelder
+	    // if we fail to set the input stream
 	    if ( inputStream == null ) {
 	      throw new NotFound("1020", "The object specified by " +
 	                         pid.getValue() +
 	                         "does not exist at this node.");
+	    }
 		// log the replica event
-            leinfelder
+	    String principal = null;
-            leinfelder
+	    if (session.getSubject() != null) {
 	    	principal = session.getSubject().getValue();
+	    }
 	    EventLog.getInstance().log(null, principal, localId, "getreplica");
 	    return inputStream;
             cjones
             cjones

Project

General

Profile

Metacat