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

metacat/src/edu/ucsb/nceas/metacat/IdentifierManager.java @ 6662

-            jones
+/**
  *  '$RCSfile$'
  *  Copyright: 2010 Regents of the University of California and the
  *             National Center for Ecological Analysis and Synthesis
+ *
  *   '$Author: jones $'
  *     '$Date: 2010-02-03 17:58:12 -0900 (Wed, 03 Feb 2010) $'
  * '$Revision: 5211 $'
+ *
  * 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;
-            cjones
+import java.math.BigInteger;
-            jones
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
-            berkley
+import java.sql.Timestamp;
-            leinfelder
+import java.util.ArrayList;
 import java.util.Date;
 import java.util.Hashtable;
 import java.util.List;
 import java.util.Vector;
             jones
 import org.apache.log4j.Logger;
-            cjones
+import org.dataone.client.ObjectFormatCache;
 import org.dataone.service.exceptions.NotFound;
-            leinfelder
+import org.dataone.service.types.v1.AccessPolicy;
 import org.dataone.service.types.v1.AccessRule;
 import org.dataone.service.types.v1.Checksum;
 import org.dataone.service.types.v1.Identifier;
 import org.dataone.service.types.v1.NodeReference;
 import org.dataone.service.types.v1.ObjectFormat;
 import org.dataone.service.types.v1.ObjectFormatIdentifier;
 import org.dataone.service.types.v1.ObjectInfo;
 import org.dataone.service.types.v1.ObjectList;
 import org.dataone.service.types.v1.Permission;
 import org.dataone.service.types.v1.Replica;
 import org.dataone.service.types.v1.ReplicationPolicy;
 import org.dataone.service.types.v1.ReplicationStatus;
 import org.dataone.service.types.v1.Subject;
 import org.dataone.service.types.v1.SystemMetadata;
             jones
-            leinfelder
+import edu.ucsb.nceas.metacat.accesscontrol.AccessControlInterface;
 import edu.ucsb.nceas.metacat.accesscontrol.XMLAccessAccess;
 import edu.ucsb.nceas.metacat.accesscontrol.XMLAccessDAO;
-            jones
+import edu.ucsb.nceas.metacat.database.DBConnection;
 import edu.ucsb.nceas.metacat.database.DBConnectionPool;
-            berkley
+import edu.ucsb.nceas.metacat.properties.PropertyService;
-            leinfelder
+import edu.ucsb.nceas.metacat.shared.AccessException;
-            leinfelder
+import edu.ucsb.nceas.metacat.shared.ServiceException;
-            jones
+import edu.ucsb.nceas.metacat.util.DocumentUtil;
-            leinfelder
+import edu.ucsb.nceas.utilities.PropertyNotFoundException;
             jones
 /**
  * Manage the relationship between Metacat local identifiers (LocalIDs) that are
-            leinfelder
+ * codified as the (docid, rev) pair with globally unique string identifiers
-            jones
+ * (GUIDs) that are opaque strings.  This class provides methods to manage these
  * identifiers, and to search for and look up LocalIDs based on their GUID and
  * vice versa. IdentifierManager is a singleton.
+ *
  * @author Matthew Jones
  */
 public class IdentifierManager {
-            berkley
+    public static final String TYPE_SYSTEM_METADATA = "systemmetadata";
     public static final String TYPE_IDENTIFIER = "identifier";
-            jones
+    /**
      * The single instance of the manager that is always returned.
      */
     private static IdentifierManager self = null;
-            leinfelder
+    private Logger logMetacat = Logger.getLogger(IdentifierManager.class);
             jones
     /**
      * A private constructor that initializes the class when getInstance() is
      * called.
      */
-            leinfelder
+    private IdentifierManager() {}
             jones
     /**
      * Return the single instance of the manager after initializing it if it
      * wasn't previously initialized.
+     *
      * @return the single IdentifierManager instance
      */
     public static IdentifierManager getInstance()
+    {
         if (self == null) {
             self = new IdentifierManager();
+        }
         return self;
+    }
-            leinfelder
+    public SystemMetadata asSystemMetadata(Date dateUploaded, String rightsHolder,
             String checksum, String checksumAlgorithm, String originMemberNode,
             String authoritativeMemberNode, Date dateModified, String submitter,
-            leinfelder
+            String guid, String fmtidStr, BigInteger size, BigInteger serialVersion) {
-            leinfelder
+        SystemMetadata sysMeta = new SystemMetadata();
         Identifier sysMetaId = new Identifier();
         sysMetaId.setValue(guid);
         sysMeta.setIdentifier(sysMetaId);
         sysMeta.setDateUploaded(dateUploaded);
         Subject rightsHolderSubject = new Subject();
         rightsHolderSubject.setValue(rightsHolder);
         sysMeta.setRightsHolder(rightsHolderSubject);
         Checksum checksumObject = new Checksum();
         checksumObject.setValue(checksum);
-            leinfelder
+        checksumObject.setAlgorithm(checksumAlgorithm);
-            leinfelder
+        sysMeta.setChecksum(checksumObject);
         NodeReference omn = new NodeReference();
         omn.setValue(originMemberNode);
         sysMeta.setOriginMemberNode(omn);
         NodeReference amn = new NodeReference();
         amn.setValue(authoritativeMemberNode);
         sysMeta.setAuthoritativeMemberNode(amn);
         sysMeta.setDateSysMetadataModified(dateModified);
         Subject submitterSubject = new Subject();
         submitterSubject.setValue(submitter);
         sysMeta.setSubmitter(submitterSubject);
-            cjones
+        try {
-            cjones
+        	ObjectFormatIdentifier fmtid =
-            leinfelder
+        		ObjectFormatCache.getInstance().getFormat(fmtidStr).getFormatId();
         	sysMeta.setFormatId(fmtid);
-            cjones
+        } catch (NotFound nfe) {
-            cjones
+          logMetacat.error("The objectFormat " + fmtidStr +
-            cjones
+          	" is not registered. Setting the default format id.");
-            cjones
+          ObjectFormatIdentifier fmtid = new ObjectFormatIdentifier();
           fmtid.setValue("application/octet-stream");
-            leinfelder
+          sysMeta.setFormatId(fmtid);
             cjones
-            leinfelder
+        sysMeta.setSize(size);
-            leinfelder
+        sysMeta.setSerialVersion(serialVersion);
             leinfelder
         return sysMeta;
+    }
-            jones
+    /**
-            berkley
+     * return a hash of all of the info that is in the systemmetadata table
      * @param localId
      * @return
      */
     public Hashtable<String, String> getSystemMetadataInfo(String localId)
     throws McdbDocNotFoundException
+    {
         try
+        {
             AccessionNumber acc = new AccessionNumber(localId, "NONE");
             localId = acc.getDocid();
+        }
         catch(Exception e)
+        {
             //do nothing. just try the localId as it is
+        }
         Hashtable<String, String> h = new Hashtable<String, String>();
         String sql = "select guid, date_uploaded, rights_holder, checksum, checksum_algorithm, " +
-            berkley
+          "origin_member_node, authoritive_member_node, date_modified, submitter, object_format, size " +
-            berkley
+          "from systemmetadata where docid = ?";
         DBConnection dbConn = null;
         int serialNumber = -1;
         try
+        {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getDocumentInfo");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             PreparedStatement stmt = dbConn.prepareStatement(sql);
             stmt.setString(1, localId);
             ResultSet rs = stmt.executeQuery();
             if (rs.next())
+            {
                 String guid = rs.getString(1);
                 Timestamp dateUploaded = rs.getTimestamp(2);
                 String rightsHolder = rs.getString(3);
                 String checksum = rs.getString(4);
                 String checksumAlgorithm = rs.getString(5);
                 String originMemberNode = rs.getString(6);
                 String authoritativeMemberNode = rs.getString(7);
                 Timestamp dateModified = rs.getTimestamp(8);
                 String submitter = rs.getString(9);
-            berkley
+                String objectFormat = rs.getString(10);
                 long size = new Long(rs.getString(11)).longValue();
             berkley
                 h.put("guid", guid);
                 h.put("date_uploaded", new Long(dateUploaded.getTime()).toString());
                 h.put("rights_holder", rightsHolder);
                 h.put("checksum", checksum);
                 h.put("checksum_algorithm", checksumAlgorithm);
                 h.put("origin_member_node", originMemberNode);
                 h.put("authoritative_member_node", authoritativeMemberNode);
                 h.put("date_modified", new Long(dateModified.getTime()).toString());
                 h.put("submitter", submitter);
-            berkley
+                h.put("object_format", objectFormat);
                 h.put("size", new Long(size).toString());
             berkley
                 stmt.close();
+            }
             else
+            {
                 stmt.close();
                 DBConnectionPool.returnDBConnection(dbConn, serialNumber);
                 throw new McdbDocNotFoundException("2Could not find document " + localId);
+            }
+        }
         catch (SQLException e)
+        {
             e.printStackTrace();
             logMetacat.error("Error while getting system metadata info for localid " + localId + " : "
                     + e.getMessage());
+        }
         finally
+        {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
         return h;
+    }
     /**
-            leinfelder
+     * return a hash of all of the info that is in the systemmetadata table
-            leinfelder
+     * @param guid
-            leinfelder
+     * @return
-            leinfelder
+     * @throws McdbDocNotFoundException
-            leinfelder
+     */
-            leinfelder
+    public SystemMetadata getSystemMetadata(String guid)
-            leinfelder
+    	throws McdbDocNotFoundException
+    {
             leinfelder
-            leinfelder
+        SystemMetadata sysMeta = new SystemMetadata();
         String sql = "select guid, date_uploaded, rights_holder, checksum, checksum_algorithm, " +
-            leinfelder
+          "origin_member_node, authoritive_member_node, date_modified, submitter, object_format, size, " +
-            leinfelder
+          "replication_allowed, number_replicas, obsoletes, obsoleted_by, serial_version " +
-            leinfelder
+          "from systemmetadata where guid = ?";
-            leinfelder
+        DBConnection dbConn = null;
         int serialNumber = -1;
-            cjones
+        Boolean replicationAllowed = new Boolean(false);
         BigInteger numberOfReplicas = new BigInteger("-1");
-            leinfelder
+        BigInteger serialVersion = new BigInteger("-1");
-            leinfelder
+        try
+        {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getSystemMetadata");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the statement
             PreparedStatement stmt = dbConn.prepareStatement(sql);
-            leinfelder
+            stmt.setString(1, guid);
-            leinfelder
+            ResultSet rs = stmt.executeQuery();
             if (rs.next())
+            {
                 Timestamp dateUploaded = rs.getTimestamp(2);
                 String rightsHolder = rs.getString(3);
                 String checksum = rs.getString(4);
                 String checksumAlgorithm = rs.getString(5);
                 String originMemberNode = rs.getString(6);
                 String authoritativeMemberNode = rs.getString(7);
                 Timestamp dateModified = rs.getTimestamp(8);
                 String submitter = rs.getString(9);
-            cjones
+                String fmtidStr = rs.getString(10);
-            cjones
+                BigInteger size = new BigInteger(rs.getString(11));
-            cjones
+                replicationAllowed = new Boolean(rs.getBoolean(12));
-            cjones
+                numberOfReplicas = new BigInteger(rs.getString(13));
                 String obsoletes = rs.getString(14);
                 String obsoletedBy = rs.getString(15);
-            leinfelder
+                serialVersion = new BigInteger(rs.getString(16));
             leinfelder
             leinfelder
-            leinfelder
+                Identifier sysMetaId = new Identifier();
                 sysMetaId.setValue(guid);
                 sysMeta.setIdentifier(sysMetaId);
-            leinfelder
+                sysMeta.setSerialVersion(serialVersion);
-            leinfelder
+                sysMeta.setDateUploaded(dateUploaded);
                 Subject rightsHolderSubject = new Subject();
                 rightsHolderSubject.setValue(rightsHolder);
                 sysMeta.setRightsHolder(rightsHolderSubject);
                 Checksum checksumObject = new Checksum();
                 checksumObject.setValue(checksum);
-            leinfelder
+                checksumObject.setAlgorithm(checksumAlgorithm);
-            leinfelder
+                sysMeta.setChecksum(checksumObject);
-            leinfelder
+                if (originMemberNode != null) {
 	                NodeReference omn = new NodeReference();
 	                omn.setValue(originMemberNode);
 	                sysMeta.setOriginMemberNode(omn);
+                }
                 if (authoritativeMemberNode != null) {
 	                NodeReference amn = new NodeReference();
 	                amn.setValue(authoritativeMemberNode);
 	                sysMeta.setAuthoritativeMemberNode(amn);
+                }
-            leinfelder
+                sysMeta.setDateSysMetadataModified(dateModified);
                 Subject submitterSubject = new Subject();
                 submitterSubject.setValue(submitter);
                 sysMeta.setSubmitter(submitterSubject);
-            cjones
+                try {
-            cjones
+                	ObjectFormatIdentifier fmtid =
-            leinfelder
+                		ObjectFormatCache.getInstance().getFormat(fmtidStr).getFormatId();
                 	sysMeta.setFormatId(fmtid);
-            cjones
+                } catch (NotFound nfe) {
-            cjones
+                  logMetacat.error("The objectFormat " + fmtidStr +
-            cjones
+                  	" is not registered. Setting the default format id.");
-            cjones
+                  ObjectFormatIdentifier fmtid = new ObjectFormatIdentifier();
                   fmtid.setValue("application/octet-stream");
-            leinfelder
+                  sysMeta.setFormatId(fmtid);
             cjones
-            leinfelder
+                sysMeta.setSize(size);
-            leinfelder
+                if (obsoletes != null) {
 	                Identifier obsoletesId = new Identifier();
 	                obsoletesId.setValue(obsoletes);
 	                sysMeta.setObsoletes(obsoletesId);
+                }
                 if (obsoletedBy != null) {
 		            Identifier obsoletedById = new Identifier();
 		            obsoletedById.setValue(obsoletedBy);
 		            sysMeta.setObsoletedBy(obsoletedById);
+                }
-            leinfelder
+                stmt.close();
+            }
             else
+            {
                 stmt.close();
                 DBConnectionPool.returnDBConnection(dbConn, serialNumber);
-            leinfelder
+                throw new McdbDocNotFoundException("Could not find " + guid);
             leinfelder
+        }
         catch (SQLException e)
+        {
             e.printStackTrace();
-            leinfelder
+            logMetacat.error("Error while getting system metadata for guid " + guid + " : "
-            leinfelder
+                    + e.getMessage());
+        }
         finally
+        {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
             leinfelder
-            cjones
+        // populate the replication policy
-            leinfelder
+        ReplicationPolicy replicationPolicy = new ReplicationPolicy();
-            cjones
+        if ( numberOfReplicas != null  && numberOfReplicas.intValue() != -1 ) {
             replicationPolicy.setNumberReplicas(numberOfReplicas.intValue());
+        }
         if ( replicationAllowed != null ) {
             replicationPolicy.setReplicationAllowed(replicationAllowed);
+        }
-            leinfelder
+        replicationPolicy.setBlockedMemberNodeList(getReplicationPolicy(guid, "blocked"));
         replicationPolicy.setPreferredMemberNodeList(getReplicationPolicy(guid, "preferred"));
-            cjones
+		    sysMeta.setReplicationPolicy(replicationPolicy);
             leinfelder
-            cjones
+		    // look up replication status
 		    sysMeta.setReplicaList(getReplicationStatus(guid));
             leinfelder
-            cjones
+		    // look up access policy
 		    try {
 		    	sysMeta.setAccessPolicy(getAccessPolicy(guid));
 		    } catch (AccessException e) {
 		    	throw new McdbDocNotFoundException(e);
+		    }
             leinfelder
-            leinfelder
+        return sysMeta;
+    }
-            leinfelder
+    private List<NodeReference> getReplicationPolicy(String guid, String policy)
 		throws McdbDocNotFoundException {
 		List<NodeReference> nodes = new ArrayList<NodeReference>();
 		String sql = "select guid, policy, member_node " +
 			"from systemMetadataReplicationPolicy where guid = ? and policy = ?";
 	    DBConnection dbConn = null;
 	    int serialNumber = -1;
 	    try {
 	        // Get a database connection from the pool
 	        dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getReplicationPolicy");
 	        serialNumber = dbConn.getCheckOutSerialNumber();
 	        // Execute the statement
 	        PreparedStatement stmt = dbConn.prepareStatement(sql);
 	        stmt.setString(1, guid);
 	        stmt.setString(2, policy);
 	        ResultSet rs = stmt.executeQuery();
 	        while (rs.next())
+	        {
 	            String memberNode = rs.getString(3);
 	            NodeReference node = new NodeReference();
 	            node.setValue(memberNode);
 	            nodes.add(node);
+	        }
 	        stmt.close();
 	    } catch (SQLException e) {
 	        logMetacat.error("Error while getting system metadata replication policy for guid " + guid, e);
+	    }
 	    finally {
 	        // Return database connection to the pool
 	        DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+	    }
 	    return nodes;
+	}
             leinfelder
-            leinfelder
+    private List<Replica> getReplicationStatus(String guid) throws McdbDocNotFoundException {
 		List<Replica> replicas = new ArrayList<Replica>();
 		String sql = "select guid, member_node, status, date_verified " +
 			"from systemMetadataReplicationStatus where guid = ?";
 	    DBConnection dbConn = null;
 	    int serialNumber = -1;
 	    try {
 	        // Get a database connection from the pool
 	        dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getReplicas");
 	        serialNumber = dbConn.getCheckOutSerialNumber();
 	        // Execute the statement
 	        PreparedStatement stmt = dbConn.prepareStatement(sql);
 	        stmt.setString(1, guid);
 	        ResultSet rs = stmt.executeQuery();
 	        while (rs.next())
+	        {
 	            String memberNode = rs.getString(2);
 	            String status = rs.getString(3);
 	            java.sql.Date verified = rs.getDate(4);
 	            Replica replica = new Replica();
 	            NodeReference node = new NodeReference();
 	            node.setValue(memberNode);
 	            replica.setReplicaMemberNode(node);
-            leinfelder
+	            replica.setReplicationStatus(ReplicationStatus.valueOf(status));
-            leinfelder
+	            replica.setReplicaVerified(new Date(verified.getTime()));
 	            replicas.add(replica);
+	        }
 	        stmt.close();
 	    } catch (SQLException e) {
 	        logMetacat.error("Error while getting system metadata replication policy for guid " + guid, e);
+	    }
 	    finally {
 	        // Return database connection to the pool
 	        DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+	    }
 	    return replicas;
+	}
-            leinfelder
+    /**
-            berkley
+     * return information on the document with localId.  These are the fields
      * from the xml_documents table.  They can be used to contstruct metadata
      * about the object that is stored.
      * @param localId
      * @return
      * @throws McdbDocNotFoundException
      */
-            berkley
+    public Hashtable<String, Object> getDocumentInfo(String localId)
-            berkley
+        throws McdbDocNotFoundException
+    {
-            berkley
+        try
+        {
             AccessionNumber acc = new AccessionNumber(localId, "NONE");
             localId = acc.getDocid();
+        }
         catch(Exception e)
+        {
             //do nothing. just try the localId as it is
+        }
-            berkley
+        Hashtable<String, Object> h = new Hashtable<String, Object>();
-            berkley
+        String sql = "select docname, doctype, user_owner, user_updated, " +
             "server_location, rev, date_created, date_updated from " +
-            leinfelder
+            "xml_documents where docid like ?";
-            berkley
+        DBConnection dbConn = null;
         int serialNumber = -1;
         try
+        {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getDocumentInfo");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             PreparedStatement stmt = dbConn.prepareStatement(sql);
-            leinfelder
+            stmt.setString(1, localId);
-            berkley
+            ResultSet rs = stmt.executeQuery();
             if (rs.next())
+            {
                 String docname = rs.getString(1);
                 String doctype = rs.getString(2);
                 String user_owner = rs.getString(3);
                 String user_updated = rs.getString(4);
                 String server_location = rs.getString(5);
                 int rev = rs.getInt(6);
                 String date_created = rs.getString(7);
                 String date_updated = rs.getString(8);
-            cjones
+                h.put("docid", localId);
-            berkley
+                h.put("docname", docname);
                 h.put("doctype", doctype);
                 h.put("user_owner", user_owner);
                 h.put("user_updated", user_updated);
                 h.put("server_location", server_location);
                 h.put("rev", new Integer(rev).toString());
                 h.put("date_created", date_created);
                 h.put("date_updated", date_updated);
                 stmt.close();
+            }
             else
+            {
                 stmt.close();
                 DBConnectionPool.returnDBConnection(dbConn, serialNumber);
-            berkley
+                throw new McdbDocNotFoundException("2Could not find document " + localId);
             berkley
             berkley
-            berkley
+            String sql2 = "select principal_name, permission, perm_type, perm_order from xml_access " +
-            berkley
+            "where docid like '" + localId + "'";
-            leinfelder
+            logMetacat.debug("executing sql: " + sql2);
-            berkley
+            PreparedStatement stmt2 = dbConn.prepareStatement(sql2);
-            berkley
+            rs = stmt2.executeQuery();
-            berkley
+            Vector accessVector = new Vector();
-            berkley
+            while(rs.next())
             berkley
                 Hashtable accessHash = new Hashtable();
                 String principal_name = rs.getString(1);
                 String permission = rs.getString(2);
                 String permissionType = rs.getString(3);
                 String permissionOrder = rs.getString(4);
                 accessHash.put("principal_name", principal_name);
                 accessHash.put("permission", permission);
                 accessHash.put("permission_type", permissionType);
                 accessHash.put("permission_order", permissionOrder);
-            leinfelder
+                logMetacat.debug("accessHash: " + accessHash.toString());
-            berkley
+                accessVector.add(accessHash);
+            }
             h.put("access", accessVector);
             berkley
         catch (SQLException e)
+        {
-            berkley
+            e.printStackTrace();
-            berkley
+            logMetacat.error("Error while getting document info for localid " + localId + " : "
                     + e.getMessage());
+        }
         finally
+        {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
         return h;
+    }
     /**
      * return the newest rev for a given localId
      * @param localId
      * @return
      */
     public int getLatestRevForLocalId(String localId)
         throws McdbDocNotFoundException
+    {
-            berkley
+        try
+        {
             AccessionNumber acc = new AccessionNumber(localId, "NONE");
             localId = acc.getDocid();
+        }
         catch(Exception e)
+        {
             //do nothing. just try the localId as it is
+        }
-            berkley
+        int rev = 0;
-            leinfelder
+        String sql = "select rev from xml_documents where docid like ? ";
-            berkley
+        DBConnection dbConn = null;
         int serialNumber = -1;
         try
+        {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getLatestRevForLocalId");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             PreparedStatement stmt = dbConn.prepareStatement(sql);
-            leinfelder
+            stmt.setString(1, localId);
-            berkley
+            ResultSet rs = stmt.executeQuery();
             if (rs.next())
+            {
                 rev = rs.getInt(1);
                 stmt.close();
+            }
             else
+            {
                 stmt.close();
                 DBConnectionPool.returnDBConnection(dbConn, serialNumber);
-            berkley
+                throw new McdbDocNotFoundException("While trying to get the latest rev, could not find document " + localId);
             berkley
+        }
         catch (SQLException e)
+        {
             logMetacat.error("Error while looking up the guid: "
                     + e.getMessage());
+        }
         finally
+        {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
         return rev;
+    }
     /**
-            berkley
+     * return all local ids in the object store that do not have associated
-            leinfelder
+     * system metadata
-            berkley
+     */
     public List<String> getLocalIdsWithNoSystemMetadata()
+    {
         Vector<String> ids = new Vector<String>();
-            leinfelder
+        String sql = "select docid, rev from xml_documents " +
         		"where docid not in " +
         		"(select docid from identifier where guid in (select guid from systemmetadata)))";
-            berkley
+        DBConnection dbConn = null;
         int serialNumber = -1;
         try
+        {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getLocalIdsWithNoSystemMetadata");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             PreparedStatement stmt = dbConn.prepareStatement(sql);
             ResultSet rs = stmt.executeQuery();
             while (rs.next())
+            {
                 String localid = rs.getString(1);
-            berkley
+                String rev = rs.getString(2);
                 localid += "." + rev;
-            leinfelder
+                logMetacat.debug("id to add SM for: " + localid);
-            berkley
+                ids.add(localid);
+            }
             stmt.close();
+        }
         catch (SQLException e)
+        {
             logMetacat.error("Error while looking up the guid: "
                     + e.getMessage());
+        }
         finally
+        {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
         return ids;
+    }
     /**
      * return a listing of all local ids in the object store
      * @return a list of all local ids in metacat
      */
     public List<String> getAllLocalIds()
-            rnahf
+    // seems to be an unnecessary and restrictive throw -rnahf 13-Sep-2011
     //    throws Exception
             berkley
         Vector<String> ids = new Vector<String>();
         String sql = "select docid from xml_documents";
         DBConnection dbConn = null;
         int serialNumber = -1;
         try
+        {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getAllLocalIds");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             PreparedStatement stmt = dbConn.prepareStatement(sql);
             ResultSet rs = stmt.executeQuery();
             while (rs.next())
+            {
                 String localid = rs.getString(1);
                 ids.add(localid);
+            }
             stmt.close();
+        }
         catch (SQLException e)
+        {
             logMetacat.error("Error while looking up the guid: "
                     + e.getMessage());
+        }
         finally
+        {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
         return ids;
+    }
             rnahf
-            leinfelder
+    /**
-            rnahf
+     * return a listing of all guids in the object store
      * @return a list of all GUIDs in metacat
      */
     public List<String> getAllGUIDs()
+    {
         Vector<String> guids = new Vector<String>();
         String sql = "select guid from identifier";
         DBConnection dbConn = null;
         int serialNumber = -1;
         try
+        {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getAllGUIDs");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             PreparedStatement stmt = dbConn.prepareStatement(sql);
             ResultSet rs = stmt.executeQuery();
             while (rs.next())
+            {
                 String guid = rs.getString(1);
                 guids.add(guid);
+            }
             stmt.close();
+        }
         catch (SQLException e)
+        {
             logMetacat.error("Error while retrieving the guid: "
                     + e.getMessage());
+        }
         finally
+        {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
         return guids;
+    }
     /**
-            leinfelder
+     * returns a list of system metadata-only guids since the given date
      * @return a list of system ids in metacat that do not correspond to objects
      * TODO: need to check which server they are on
      */
     public List<String> getUpdatedSystemMetadataIds(Date since)
        throws Exception
+    {
         List<String> ids = new Vector<String>();
         String sql =
         	"select guid from " + TYPE_SYSTEM_METADATA +
         	" where guid not in " +
         	" (select guid from " + TYPE_IDENTIFIER + ") " +
         	" and date_modified > ?";
         DBConnection dbConn = null;
         int serialNumber = -1;
         try
+        {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getUpdatedSystemMetadataIds");
             serialNumber = dbConn.getCheckOutSerialNumber();
             leinfelder
-            leinfelder
+            // Execute the insert statement
             PreparedStatement stmt = dbConn.prepareStatement(sql);
             stmt.setDate(1, new java.sql.Date(since.getTime()));
             ResultSet rs = stmt.executeQuery();
             while (rs.next())
+            {
                 String guid = rs.getString(1);
                 ids.add(guid);
+            }
             stmt.close();
+        }
         catch (SQLException e)
+        {
             logMetacat.error("Error while looking up the updated guids: "
                     + e.getMessage());
+        }
         finally
+        {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
         return ids;
+    }
             jones
-            leinfelder
+    /**
      * returns a list of system metadata-only guids since the given date
      * @return a list of system ids in metacat that do not correspond to objects
      * TODO: need to check which server they are on
      */
     public Date getLastModifiedDate() throws Exception {
         Date maxDate = null;
             leinfelder
-            leinfelder
+        List<String> ids = new Vector<String>();
         String sql =
         	"select max(date_modified) from " + TYPE_SYSTEM_METADATA;
         DBConnection dbConn = null;
         int serialNumber = -1;
         try
+        {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getLastModifiedDate");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             PreparedStatement stmt = dbConn.prepareStatement(sql);
             ResultSet rs = stmt.executeQuery();
             if (rs.next()) {
             	maxDate = rs.getDate(1);
+            }
             stmt.close();
+        }
         catch (SQLException e)
+        {
             logMetacat.error("Error while looking up the latest update date: "
                     + e.getMessage());
+        }
         finally
+        {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
         return maxDate;
+    }
             leinfelder
-            jones
+    /**
      * Determine if an identifier exists already, returning true if so.
+     *
      * @param guid the global identifier to look up
      * @return boolean true if the identifier exists
      */
     public boolean identifierExists(String guid)
+    {
         boolean idExists = false;
         try {
             String id = getLocalId(guid);
             if (id != null) {
                 idExists = true;
+            }
         } catch (McdbDocNotFoundException e) {
-            leinfelder
+        	// try system metadata only
         	try {
-            rnahf
+        		idExists = systemMetadataExists(guid);
-            leinfelder
+            } catch (Exception e2) {
-            leinfelder
+            	idExists = false;
+            }
             jones
         return idExists;
+    }
     /**
+     *
-            berkley
+     * @param guid
      * @param rev
      * @return
      */
     public String generateLocalId(String guid, int rev)
+    {
         return generateLocalId(guid, rev, false);
+    }
             jones
     /**
      * Given a global identifier (guid), create a suitable local identifier that
      * follows Metacat's docid semantics and format (scope.id.rev), and create
      * a mapping between these two identifiers.  This effectively reserves both
      * the global and the local identifier, as they will now be present in the
      * identifier mapping table.  If the incoming guid has the syntax of a
      * Metacat docid (scope.id.rev), then simply use it.
+     *
      * @param guid the global string identifier
      * @param rev the revision number to be used in the localId
      * @return String containing the localId to be used for Metacat operations
      */
-            berkley
+    public String generateLocalId(String guid, int rev, boolean isSystemMetadata)
             jones
         String localId = "";
         boolean conformsToDocidFormat = false;
         // Check if the guid passed in is already in docid (scope.id.rev) format
         try {
             AccessionNumber acc = new AccessionNumber(guid, "NONE");
             if (new Integer(acc.getRev()).intValue() > 0) {
                 conformsToDocidFormat = true;
+            }
         } catch (NumberFormatException e) {
             // No action needed, simply detecting invalid AccessionNumbers
         } catch (AccessionNumberException e) {
             // No action needed, simply detecting invalid AccessionNumbers
         } catch (SQLException e) {
             // No action needed, simply detecting invalid AccessionNumbers
+        }
         if (conformsToDocidFormat) {
             // if it conforms, use it for both guid and localId
             localId = guid;
         } else {
             // if not, then generate a new unique localId
             localId = DocumentUtil.generateDocumentId(rev);
+        }
         // Register this new pair in the identifier mapping table
-            leinfelder
+        logMetacat.debug("creating mapping in generateLocalId");
-            berkley
+        if(!isSystemMetadata)
         { //don't do this if we're generating for system metadata
             createMapping(guid, localId);
+        }
             jones
         return localId;
+    }
             berkley
     /**
      * given a local identifer, look up the guid.  Throw McdbDocNotFoundException
-            berkley
+     * if the docid, rev is not found in the identifiers or systemmetadata tables
             berkley
      * @param docid the docid to look up
      * @param rev the revision of the docid to look up
      * @return String containing the mapped guid
      * @throws McdbDocNotFoundException if the docid, rev is not found
      */
     public String getGUID(String docid, int rev)
       throws McdbDocNotFoundException
+    {
-            leinfelder
+        logMetacat.debug("getting guid for " + docid);
-            berkley
+        String query = "select guid from identifier where docid = ? and rev = ?";
         String guid = null;
         DBConnection dbConn = null;
         int serialNumber = -1;
         try {
             // Get a database connection from the pool
-            berkley
+            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getGUID");
-            berkley
+            serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             PreparedStatement stmt = dbConn.prepareStatement(query);
             stmt.setString(1, docid);
             stmt.setInt(2, rev);
             ResultSet rs = stmt.executeQuery();
-            berkley
+            if (rs.next())
+            {
-            berkley
+                guid = rs.getString(1);
             berkley
             else
+            {
-            leinfelder
+            	throw new McdbDocNotFoundException("No guid registered for docid " + docid + "." + rev);
             berkley
             berkley
-            berkley
+        } catch (SQLException e) {
             logMetacat.error("Error while looking up the guid: "
                     + e.getMessage());
         } finally {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
         return guid;
+    }
             berkley
-            leinfelder
+    public boolean systemMetadataExists(String guid) {
-            leinfelder
+		logMetacat.debug("looking up system metadata for guid " + guid);
 		boolean exists = false;
-            leinfelder
+		String query = "select guid from systemmetadata where guid = ?";
             leinfelder
 		DBConnection dbConn = null;
 		int serialNumber = -1;
 		try {
 			// Get a database connection from the pool
 			dbConn = DBConnectionPool.getDBConnection("IdentifierManager.systemMetadataExisits");
 			serialNumber = dbConn.getCheckOutSerialNumber();
 			// Execute the insert statement
 			PreparedStatement stmt = dbConn.prepareStatement(query);
 			stmt.setString(1, guid);
 			ResultSet rs = stmt.executeQuery();
 			if (rs.next()) {
 				exists = true;
+			}
 		} catch (SQLException e) {
 			logMetacat.error("Error while looking up the system metadata: "
 					+ e.getMessage());
 		} finally {
 			// Return database connection to the pool
 			DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+		}
 		return exists;
+	}
-            berkley
+    /**
-            berkley
+     * creates a system metadata mapping and adds additional fields from sysmeta
      * to the table for quick searching.
+     *
      * @param guid the id to insert
      * @param localId the systemMetadata object to get the local id for
-            leinfelder
+     * @throws McdbDocNotFoundException
-            berkley
+     */
-            leinfelder
+    public void createSystemMetadata(SystemMetadata sysmeta) throws McdbDocNotFoundException
             berkley
-            leinfelder
+    	String guid = sysmeta.getIdentifier().getValue();
-            leinfelder
+    	// insert the record
         insertSystemMetadata(guid);
         // update with the values
-            leinfelder
+        updateSystemMetadata(sysmeta);
             berkley
             leinfelder
             berkley
     /**
-            leinfelder
+     * update a mapping
      * @param guid
      * @param localId
      */
     public void updateMapping(String guid, String localId)
+    {
-            leinfelder
+        logMetacat.debug("$$$$$$$$$$$$$$ updating mapping table");
-            berkley
+        int serialNumber = -1;
         DBConnection dbConn = null;
         try {
             // Parse the localId into scope and rev parts
             AccessionNumber acc = new AccessionNumber(localId, "NOACTION");
             String docid = acc.getDocid();
             int rev = 1;
             if(acc.getRev() != null)
+            {
               rev = (new Integer(acc.getRev()).intValue());
+            }
             // Get a database connection from the pool
             dbConn =
-            leinfelder
+                DBConnectionPool.getDBConnection("IdentifierManager.updateMapping");
-            berkley
+            serialNumber = dbConn.getCheckOutSerialNumber();
-            leinfelder
+            // Execute the update statement
-            leinfelder
+            String query = "update " + TYPE_IDENTIFIER + " set (docid, rev) = (?, ?) where guid = ?";
-            berkley
+            PreparedStatement stmt = dbConn.prepareStatement(query);
             stmt.setString(1, docid);
             stmt.setInt(2, rev);
-            leinfelder
+            stmt.setString(3, guid);
-            berkley
+            int rows = stmt.executeUpdate();
             stmt.close();
         } catch (SQLException e) {
             e.printStackTrace();
-            leinfelder
+            logMetacat.error("SQL error while updating a mapping identifier: "
-            berkley
+                    + e.getMessage());
         } catch (NumberFormatException e) {
             e.printStackTrace();
-            leinfelder
+            logMetacat.error("NumberFormat error while updating a mapping identifier: "
-            berkley
+                    + e.getMessage());
         } catch (AccessionNumberException e) {
             e.printStackTrace();
-            leinfelder
+            logMetacat.error("AccessionNumber error while updating a mapping identifier: "
-            berkley
+                    + e.getMessage());
         } finally {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
-            leinfelder
+        logMetacat.debug("done updating mapping");
             berkley
             leinfelder
     private void updateSystemMetadataFields(long dateUploaded, String rightsHolder,
-            berkley
+            String checksum, String checksumAlgorithm, String originMemberNode,
-            berkley
+            String authoritativeMemberNode, long modifiedDate, String submitter,
-            cjones
+            String guid, String objectFormat, BigInteger size, boolean replicationAllowed,
-            leinfelder
+            int numberReplicas, String obsoletes, String obsoletedBy, BigInteger serialVersion)
             berkley
         DBConnection dbConn = null;
         int serialNumber = -1;
             berkley
-            berkley
+        try {
             // Get a database connection from the pool
             dbConn =
                 DBConnectionPool.getDBConnection("IdentifierManager.createMapping");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             String query = "update " + TYPE_SYSTEM_METADATA +
                 " set (date_uploaded, rights_holder, checksum, checksum_algorithm, " +
-            berkley
+                "origin_member_node, authoritive_member_node, date_modified, " +
-            leinfelder
+                "submitter, object_format, size, replication_allowed, number_replicas, " +
                 "obsoletes, obsoleted_by, serial_version) " +
                 "= (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) where guid = ?";
-            berkley
+            PreparedStatement stmt = dbConn.prepareStatement(query);
             //data values
             stmt.setTimestamp(1, new java.sql.Timestamp(dateUploaded));
             stmt.setString(2, rightsHolder);
             stmt.setString(3, checksum);
             stmt.setString(4, checksumAlgorithm);
             stmt.setString(5, originMemberNode);
             stmt.setString(6, authoritativeMemberNode);
             stmt.setTimestamp(7, new java.sql.Timestamp(modifiedDate));
             stmt.setString(8, submitter);
-            berkley
+            stmt.setString(9, objectFormat);
-            cjones
+            stmt.setString(10, size.toString());
-            leinfelder
+            stmt.setBoolean(11, replicationAllowed);
             stmt.setInt(12, numberReplicas);
-            leinfelder
+            stmt.setString(13, obsoletes);
             stmt.setString(14, obsoletedBy);
-            leinfelder
+            stmt.setString(15, serialVersion.toString());
             leinfelder
-            berkley
+            //where clause
-            leinfelder
+            stmt.setString(16, guid);
-            leinfelder
+            logMetacat.debug("stmt: " + stmt.toString());
-            berkley
+            //execute
             int rows = stmt.executeUpdate();
             stmt.close();
         } catch (SQLException e) {
             e.printStackTrace();
-            berkley
+            logMetacat.error("insertAdditionalSystemMetadataFields: SQL error while creating a mapping to the system metadata identifier: "
-            berkley
+                    + e.getMessage());
         } catch (NumberFormatException e) {
             e.printStackTrace();
-            berkley
+            logMetacat.error("insertAdditionalSystemMetadataFields: NumberFormat error while creating a mapping to the system metadata identifier: "
-            berkley
+                    + e.getMessage());
         } finally {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
+    }
-            leinfelder
+    private void insertReplicationPolicy(String guid, String policy, List<String> memberNodes)
+    {
         DBConnection dbConn = null;
         int serialNumber = -1;
         try {
             // Get a database connection from the pool
             dbConn =
                 DBConnectionPool.getDBConnection("IdentifierManager.insertReplicationPolicy");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // remove existing values first
             String delete = "delete from systemMetadataReplicationPolicy " +
             "where guid = ? and policy = ?";
 	        PreparedStatement stmt = dbConn.prepareStatement(delete);
 	        //data values
 	        stmt.setString(1, guid);
 	        stmt.setString(2, policy);
 	        //execute
 	        int deletedCount = stmt.executeUpdate();
 	        stmt.close();
             for (String memberNode: memberNodes) {
 	            // Execute the insert statement
 	            String insert = "insert into systemMetadataReplicationPolicy " +
 	                "(guid, policy, member_node) " +
 	                "values (?, ?, ?)";
 	            PreparedStatement insertStatement = dbConn.prepareStatement(insert);
 	            //data values
 	            insertStatement.setString(1, guid);
 	            insertStatement.setString(2, policy);
 	            insertStatement.setString(3, memberNode);
 	            //execute
 	            int rows = insertStatement.executeUpdate();
 	            insertStatement.close();
+            }
         } catch (SQLException e) {
             logMetacat.error("SQL error while adding systemMetadataReplicationPolicy for: " + guid, e);
         } finally {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
+    }
     private void insertReplicationStatus(String guid, List<Replica> replicas) {
         DBConnection dbConn = null;
         int serialNumber = -1;
         try {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.insertReplicas");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // remove existing values first
             String delete = "delete from systemMetadataReplicationStatus " +
             "where guid = ?";
 	        PreparedStatement stmt = dbConn.prepareStatement(delete);
 	        //data values
 	        stmt.setString(1, guid);
 	        //execute
 	        int deletedCount = stmt.executeUpdate();
 	        stmt.close();
-            leinfelder
+	        if (replicas != null) {
 	            for (Replica replica: replicas) {
 		            // Execute the insert statement
 		            String insert = "insert into systemMetadataReplicationStatus " +
 		                "(guid, member_node, status, date_verified) " +
 		                "values (?, ?, ?, ?)";
 		            PreparedStatement insertStatement = dbConn.prepareStatement(insert);
 		            //data values
 		            String memberNode = replica.getReplicaMemberNode().getValue();
 		            String status = replica.getReplicationStatus().toString();
 		            java.sql.Date sqlDate = new java.sql.Date(replica.getReplicaVerified().getTime());
 		            insertStatement.setString(1, guid);
 		            insertStatement.setString(2, memberNode);
 		            insertStatement.setString(3, status);
 		            insertStatement.setDate(4, sqlDate);
 		            //execute
 		            int rows = insertStatement.executeUpdate();
 		            insertStatement.close();
+	            }
+	        }
-            leinfelder
+        } catch (SQLException e) {
             logMetacat.error("SQL error while adding systemMetadataReplicationStatus for: " + guid, e);
         } finally {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
+    }
-            berkley
+    /**
-            berkley
+     * Insert the system metadata fields into the db
      * @param sm
-            leinfelder
+     * @throws McdbDocNotFoundException
-            berkley
+     */
-            leinfelder
+    public void updateSystemMetadata(SystemMetadata sm) throws McdbDocNotFoundException {
             leinfelder
         Boolean replicationAllowed = false;
 		Integer numberReplicas = -1;
     	ReplicationPolicy replicationPolicy = sm.getReplicationPolicy();
     	if (replicationPolicy != null) {
     		replicationAllowed = replicationPolicy.getReplicationAllowed();
     		numberReplicas = replicationPolicy.getNumberReplicas();
     		replicationAllowed = replicationAllowed == null ? false: replicationAllowed;
     		numberReplicas = numberReplicas == null ? -1: numberReplicas;
+    	}
     	// the main systemMetadata fields
 		updateSystemMetadataFields(
-            leinfelder
+				sm.getDateUploaded() == null ? null: sm.getDateUploaded().getTime(),
 				sm.getRightsHolder() == null ? null: sm.getRightsHolder().getValue(),
 				sm.getChecksum() == null ? null: sm.getChecksum().getValue(),
-            leinfelder
+				sm.getChecksum() == null ? null: sm.getChecksum().getAlgorithm(),
-            leinfelder
+				sm.getOriginMemberNode() == null ? null: sm.getOriginMemberNode().getValue(),
 				sm.getAuthoritativeMemberNode() == null ? null: sm.getAuthoritativeMemberNode().getValue(),
 				sm.getDateSysMetadataModified() == null ? null: sm.getDateSysMetadataModified().getTime(),
 				sm.getSubmitter() == null ? null: sm.getSubmitter().getValue(),
-            cjones
+        sm.getIdentifier().getValue(),
-            leinfelder
+        sm.getFormatId() == null ? null: sm.getFormatId().getValue(),
-            cjones
+        sm.getSize(),
         replicationAllowed,
         numberReplicas,
         sm.getObsoletes() == null ? null:sm.getObsoletes().getValue(),
-            leinfelder
+        sm.getObsoletedBy() == null ? null: sm.getObsoletedBy().getValue(),
         sm.getSerialVersion()
         );
             leinfelder
         String guid = sm.getIdentifier().getValue();
-            leinfelder
+        // save replication policies
         if (replicationPolicy != null) {
 		    List<String> nodes = null;
 		    String policy = null;
-            leinfelder
+		    // check for null
 		    if (replicationPolicy.getBlockedMemberNodeList() != null) {
 			    nodes = new ArrayList<String>();
 			    policy = "blocked";
 			    for (NodeReference node: replicationPolicy.getBlockedMemberNodeList()) {
 			    	nodes.add(node.getValue());
+			    }
 			    this.insertReplicationPolicy(guid, policy, nodes);
             leinfelder
-            leinfelder
+		    if (replicationPolicy.getPreferredMemberNodeList() != null) {
 			    nodes = new ArrayList<String>();
 			    policy = "preferred";
 			    for (NodeReference node: replicationPolicy.getPreferredMemberNodeList()) {
 			    	nodes.add(node.getValue());
+			    }
 		        this.insertReplicationPolicy(guid, policy, nodes);
             leinfelder
+        }
             leinfelder
-            leinfelder
+        // save replica information
         this.insertReplicationStatus(guid, sm.getReplicaList());
-            leinfelder
+        // save access policy
         AccessPolicy accessPolicy = sm.getAccessPolicy();
         if (accessPolicy != null) {
         	try {
 				this.insertAccessPolicy(guid, accessPolicy);
 			} catch (AccessException e) {
 				throw new McdbDocNotFoundException(e);
+			}
+        }
             berkley
     /**
-            leinfelder
+     * Creates Metacat access rules and inserts them
      * @param accessPolicy
      * @throws McdbDocNotFoundException
      * @throws AccessException
      */
     private void insertAccessPolicy(String guid, AccessPolicy accessPolicy) throws McdbDocNotFoundException, AccessException {
     	List<XMLAccessDAO> accessDAOs = new ArrayList<XMLAccessDAO>();
         for (AccessRule accessRule: accessPolicy.getAllowList()) {
         	List<Subject> subjects = accessRule.getSubjectList();
         	List<Permission> permissions = accessRule.getPermissionList();
         	for (Subject subject: subjects) {
-            leinfelder
+    			XMLAccessDAO accessDAO = new XMLAccessDAO();
         		accessDAO.setPrincipalName(subject.getValue());
     			accessDAO.setGuid(guid);
     			accessDAO.setPermType(AccessControlInterface.ALLOW);
     			accessDAO.setPermOrder(AccessControlInterface.DENYFIRST);
     			for (Permission permission: permissions) {
     				Long metacatPermission = new Long(convertPermission(permission));
         			accessDAO.addPermission(metacatPermission);
+    			}
     			accessDAOs.add(accessDAO);
             leinfelder
+        }
-            leinfelder
+        // use GUID to update
         XMLAccessAccess accessController  = new XMLAccessAccess(true);
         accessController.replaceAccess(guid, accessDAOs);
             leinfelder
+    }
     /**
      * Lookup access policy from Metacat
      * @param guid
      * @return
      * @throws McdbDocNotFoundException
      * @throws AccessException
      */
     private AccessPolicy getAccessPolicy(String guid) throws McdbDocNotFoundException, AccessException {
-            leinfelder
+        AccessPolicy accessPolicy = new AccessPolicy();
-            leinfelder
+    	// use GUID to look up the access
         XMLAccessAccess accessController  = new XMLAccessAccess(true);
     	List<XMLAccessDAO> accessDAOs = accessController.getXMLAccessForDoc(guid);
-            leinfelder
+        for (XMLAccessDAO accessDAO: accessDAOs) {
-            leinfelder
+        	AccessRule accessRule = new AccessRule();
-            leinfelder
+        	Permission permission = convertPermission(accessDAO.getPermission().intValue());
         	accessRule.addPermission(permission);
         	Subject subject = new Subject();
         	subject.setValue(accessDAO.getPrincipalName());
         	accessRule.addSubject(subject);
-            leinfelder
+            accessPolicy.addAllow(accessRule);
             leinfelder
         return accessPolicy;
+    }
     public int convertPermission(Permission permission) {
     	if (permission.equals(Permission.READ)) {
     		return AccessControlInterface.READ;
+    	}
     	if (permission.equals(Permission.WRITE)) {
     		return AccessControlInterface.WRITE;
+    	}
     	if (permission.equals(Permission.CHANGE_PERMISSION)) {
     		return AccessControlInterface.CHMOD;
+    	}
 		return -1;
+    }
     public Permission convertPermission(int permission) {
     	if (permission == AccessControlInterface.READ) {
     		return Permission.READ;
+    	}
     	if (permission == AccessControlInterface.WRITE) {
     		return Permission.WRITE;
+    	}
     	if (permission == AccessControlInterface.CHMOD) {
     		return Permission.CHANGE_PERMISSION;
+    	}
 		return null;
+    }
     /**
-            leinfelder
+     * Lookup a localId given the GUID. If
      * the identifier is not found, throw an exception.
+     *
      * @param guid the global identifier to look up
      * @return String containing the corresponding LocalId
      * @throws McdbDocNotFoundException if the identifier is not found
-            berkley
+     */
-            leinfelder
+    public String getLocalId(String guid) throws McdbDocNotFoundException {
             berkley
       String db_guid = "";
       String docid = "";
       int rev = 0;
-            leinfelder
+      String query = "select guid, docid, rev from " + TYPE_IDENTIFIER + " where guid = ?";
             berkley
       DBConnection dbConn = null;
-            berkley
+      int serialNumber = -1;
-            berkley
+      try {
           // Get a database connection from the pool
           dbConn = DBConnectionPool.getDBConnection("Identifier.getLocalId");
           serialNumber = dbConn.getCheckOutSerialNumber();
           // Execute the insert statement
           PreparedStatement stmt = dbConn.prepareStatement(query);
           stmt.setString(1, guid);
           ResultSet rs = stmt.executeQuery();
           if (rs.next()) {
               db_guid = rs.getString(1);
               docid = rs.getString(2);
               rev = rs.getInt(3);
               assert(db_guid.equals(guid));
           } else {
               throw new McdbDocNotFoundException("Document not found:" + guid);
+          }
           stmt.close();
       } catch (SQLException e) {
           logMetacat.error("Error while looking up the local identifier: "
                   + e.getMessage());
       } finally {
           // Return database connection to the pool
           DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+      }
       return docid + "." + rev;
+    }
-            berkley
+    /**
-            berkley
+     * query the systemmetadata table based on the given parameters
      * @param startTime
      * @param endTime
      * @param objectFormat
      * @param replicaStatus
      * @param start
      * @param count
      * @return ObjectList
-            leinfelder
+     * @throws SQLException
      * @throws ServiceException
      * @throws PropertyNotFoundException
-            berkley
+     */
     public ObjectList querySystemMetadata(Date startTime, Date endTime,
-            leinfelder
+            ObjectFormatIdentifier objectFormatId, boolean replicaStatus, int start, int count) throws SQLException, PropertyNotFoundException, ServiceException
             berkley
         ObjectList ol = new ObjectList();
         int total = 0;
-            berkley
+        DBConnection dbConn = null;
         int serialNumber = -1;
             berkley
-            leinfelder
+        try {
-            berkley
+            String sql = "select guid, date_uploaded, rights_holder, checksum, " +
                 "checksum_algorithm, origin_member_node, authoritive_member_node, " +
-            berkley
+                "date_modified, submitter, object_format, size from systemmetadata";
             berkley
             boolean f1 = false;
             boolean f2 = false;
             boolean f3 = false;
-            leinfelder
+            if (startTime != null) {
-            berkley
+                sql += " where systemmetadata.date_modified > ?";
-            berkley
+                f1 = true;
+            }
-            leinfelder
+            if (endTime != null) {
                 if (!f1) {
-            berkley
+                    sql += " where systemmetadata.date_modified < ?";
+                }
-            leinfelder
+                else {
-            berkley
+                    sql += " and systemmetadata.date_modified < ?";
+                }
-            berkley
+                f2 = true;
+            }
-            leinfelder
+            if (objectFormatId != null) {
-            leinfelder
+                if (!f1 && !f2) {
-            berkley
+                    sql += " where object_format = ?";
+                }
-            leinfelder
+                else {
-            berkley
+                    sql += " and object_format = ?";
+                }
-            berkley
+                f3 = true;
+            }
-            leinfelder
+            if (replicaStatus) {
-            berkley
+                String currentNodeId = PropertyService.getInstance().getProperty("dataone.memberNodeId");
-            leinfelder
+                if (!f1 && !f2 && !f3) {
-            berkley
+                    sql += " where authoritive_member_node != '" + currentNodeId.trim() + "'";
+                }
-            leinfelder
+                else {
-            berkley
+                    sql += " and authoritive_member_node != '" + currentNodeId.trim() + "'";
+                }
             berkley
-            berkley
+            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.querySystemMetadata");
             serialNumber = dbConn.getCheckOutSerialNumber();
-            berkley
+            PreparedStatement stmt = dbConn.prepareStatement(sql);
-            leinfelder
+            if (f1 && f2 && f3) {
-            berkley
+                stmt.setTimestamp(1, new Timestamp(startTime.getTime()));
                 stmt.setTimestamp(2, new Timestamp(endTime.getTime()));
-            leinfelder
+                stmt.setString(3, objectFormatId.getValue());
             berkley
-            leinfelder
+            else if (f1 && f2 && !f3) {
-            berkley
+                stmt.setTimestamp(1, new Timestamp(startTime.getTime()));
                 stmt.setTimestamp(2, new Timestamp(endTime.getTime()));
+            }
-            leinfelder
+            else if (f1 && !f2 && f3) {
-            berkley
+                stmt.setTimestamp(1, new Timestamp(startTime.getTime()));
-            leinfelder
+                stmt.setString(2, objectFormatId.getValue());
             berkley
-            leinfelder
+            else if (f1 && !f2 && !f3) {
-            berkley
+                stmt.setTimestamp(1, new Timestamp(startTime.getTime()));
+            }
-            leinfelder
+            else if (!f1 && f2 && f3) {
-            berkley
+                stmt.setTimestamp(1, new Timestamp(endTime.getTime()));
-            leinfelder
+                stmt.setString(2, objectFormatId.getValue());
             berkley
-            leinfelder
+            else if (!f1 && !f2 && f3) {
-            leinfelder
+                stmt.setString(1, objectFormatId.getValue());
             berkley
-            leinfelder
+            else if (!f1 && f2 && !f3) {
-            berkley
+                stmt.setTimestamp(1, new Timestamp(endTime.getTime()));
+            }
-            leinfelder
+            //logMetacat.debug("LISTOBJECTS QUERY: " + stmt.toString());
             berkley
             ResultSet rs = stmt.executeQuery();
-            leinfelder
+            for (int i=0; i<start; i++) {
                 if (rs.next()) {
-            berkley
+                    total++;
-            leinfelder
+                } else {
-            berkley
+                    break;
+                }
             berkley
             berkley
-            berkley
+            int countIndex = 0;
-            leinfelder
+            while (rs.next()) {
-            berkley
+                total++;
-            leinfelder
+                if (countIndex >= count) {
                 	// allow unlimited (negative number for count)
                 	if (count > 0) {
                 		break;
+                	}
             berkley
             cjones
-            berkley
+                String guid = rs.getString(1);
-            leinfelder
+                //logMetacat.debug("query found doc with guid " + guid);
-            berkley
+                //Timestamp dateUploaded = rs.getTimestamp(2);
                 //String rightsHolder = rs.getString(3);
-            cjones
+                String checksum = rs.getString(4);
                 String checksumAlgorithm = rs.getString(5);
-            berkley
+                //String originMemberNode = rs.getString(6);
-            cjones
+                //String authoritiveMemberNode = rs.getString(7);
                 Timestamp dateModified = rs.getTimestamp(8);
-            berkley
+                //String submitter = rs.getString(9);
-            cjones
+                String fmtidStr = rs.getString(10);
                 String sz = rs.getString(11);
-            cjones
+                BigInteger size = new BigInteger("0");
             leinfelder
                 if (sz != null && !sz.trim().equals("")) {
-            cjones
+                    size = new BigInteger(rs.getString(11));
             berkley
             berkley
                 ObjectInfo oi = new ObjectInfo();
                 Identifier id = new Identifier();
                 id.setValue(guid);
                 oi.setIdentifier(id);
-            leinfelder
+                if (dateModified != null) {
                 	oi.setDateSysMetadataModified(new Date(dateModified.getTime()));
+                }
             berkley
                 Checksum cs = new Checksum();
                 cs.setValue(checksum);
-            leinfelder
+                try {
-            leinfelder
+                	//cs.setAlgorithm(ChecksumAlgorithm.valueOf(checksumAlgorithm));
-            leinfelder
+                    cs.setAlgorithm(checksumAlgorithm);
-            leinfelder
+                } catch (Exception e) {
-            leinfelder
+					logMetacat.error("could not parse checksum algorithm", e);
 					continue;
             leinfelder
-            berkley
+                oi.setChecksum(cs);
-            leinfelder
+                // set the format type
                 ObjectFormatIdentifier fmtid = new ObjectFormatIdentifier();
             	fmtid.setValue(fmtidStr);
-            leinfelder
+                oi.setFormatId(fmtid);
             leinfelder
 //                try {
 //	                oi.setFmtid(ObjectFormatCache.getInstance().getFormat(fmtidStr).getFmtid());
 //                } catch (NotFound e) {
 //                	logMetacat.error("could not find object format: " + fmtidStr, e);
 //                	// skip this one
 //                	continue;
 //				}
             berkley
                 oi.setSize(size);
             berkley
                 ol.addObjectInfo(oi);
                 countIndex++;
+            }
-            leinfelder
+            // expend the resultset to get the total count of possible rows
             while (rs.next()) {
-            berkley
+                total++;
+            }
+        }
             leinfelder
         finally {
-            berkley
+            // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
             berkley
         ol.setStart(start);
-            berkley
+        ol.setCount(ol.sizeObjectInfoList());
-            berkley
+        ol.setTotal(total);
         return ol;
+    }
     /**
-            leinfelder
+     * create a mapping in the identifier table
-            berkley
+     * @param guid
      * @param localId
      */
-            leinfelder
+    public void createMapping(String guid, String localId)
             berkley
             berkley
         int serialNumber = -1;
-            berkley
+        DBConnection dbConn = null;
         try {
             // Parse the localId into scope and rev parts
             AccessionNumber acc = new AccessionNumber(localId, "NOACTION");
             String docid = acc.getDocid();
-            berkley
+            int rev = 1;
-            leinfelder
+            if (acc.getRev() != null) {
-            berkley
+              rev = (new Integer(acc.getRev()).intValue());
+            }
             berkley
             // Get a database connection from the pool
-            leinfelder
+            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.createMapping");
-            berkley
+            serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
-            leinfelder
+            String query = "insert into " + TYPE_IDENTIFIER + " (guid, docid, rev) values (?, ?, ?)";
-            berkley
+            PreparedStatement stmt = dbConn.prepareStatement(query);
             stmt.setString(1, guid);
             stmt.setString(2, docid);
             stmt.setInt(3, rev);
-            leinfelder
+            logMetacat.debug("mapping query: " + stmt.toString());
-            berkley
+            int rows = stmt.executeUpdate();
             stmt.close();
         } catch (SQLException e) {
-            berkley
+            e.printStackTrace();
-            leinfelder
+            logMetacat.error("createGenericMapping: SQL error while creating a mapping to the " + TYPE_IDENTIFIER + " identifier: "
-            berkley
+                    + e.getMessage());
         } catch (NumberFormatException e) {
-            berkley
+            e.printStackTrace();
-            leinfelder
+            logMetacat.error("createGenericMapping: NumberFormat error while creating a mapping to the " + TYPE_IDENTIFIER + " identifier: "
-            berkley
+                    + e.getMessage());
         } catch (AccessionNumberException e) {
-            berkley
+            e.printStackTrace();
-            leinfelder
+            logMetacat.error("createGenericMapping: AccessionNumber error while creating a mapping to the " + TYPE_IDENTIFIER + " identifier: "
-            berkley
+                    + e.getMessage());
         } finally {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
+    }
             leinfelder
     /**
      * create the systemmetadata record
      * @param guid
      */
-            leinfelder
+    private void insertSystemMetadata(String guid)
             leinfelder
         int serialNumber = -1;
         DBConnection dbConn = null;
         try {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.insertSystemMetadata");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
-            leinfelder
+            String query = "insert into " + TYPE_SYSTEM_METADATA + " (guid) values (?)";
-            leinfelder
+            PreparedStatement stmt = dbConn.prepareStatement(query);
             stmt.setString(1, guid);
             logMetacat.debug("system metadata query: " + stmt.toString());
             int rows = stmt.executeUpdate();
             stmt.close();
         } catch (Exception e) {
             e.printStackTrace();
-            leinfelder
+            logMetacat.error("Error while creating " + TYPE_SYSTEM_METADATA + " record: " + guid, e );
-            leinfelder
+        } finally {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
+    }
             leinfelder
-            leinfelder
+    public void deleteSystemMetadata(String guid)
             leinfelder
         int serialNumber = -1;
         DBConnection dbConn = null;
-            leinfelder
+        String query = null;
         PreparedStatement stmt = null;
         int rows = 0;
-            leinfelder
+        try {
             // Get a database connection from the pool
-            leinfelder
+            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.deleteSystemMetadata");
-            leinfelder
+            serialNumber = dbConn.getCheckOutSerialNumber();
-            leinfelder
+            // remove main system metadata entry
             query = "delete from " + TYPE_SYSTEM_METADATA + " where guid = ? ";
             stmt = dbConn.prepareStatement(query);
-            leinfelder
+            stmt.setString(1, guid);
             logMetacat.debug("delete system metadata: " + stmt.toString());
-            leinfelder
+            rows = stmt.executeUpdate();
-            leinfelder
+            stmt.close();
             leinfelder
             // remove the systemMetadataReplicationPolicy
             query = "delete from systemMetadataReplicationPolicy " +
             "where guid = ?";
             stmt = dbConn.prepareStatement(query);
             stmt.setString(1, guid);
             logMetacat.debug("delete systemMetadataReplicationPolicy: " + stmt.toString());
             rows = stmt.executeUpdate();
             stmt.close();
             // remove the systemMetadataReplicationStatus
             query = "delete from systemMetadataReplicationStatus " +
             "where guid = ?";
             stmt = dbConn.prepareStatement(query);
             stmt.setString(1, guid);
             logMetacat.debug("delete systemMetadataReplicationStatus: " + stmt.toString());
             rows = stmt.executeUpdate();
             stmt.close();
             // TODO: remove the xml_access?
             // Metacat keeps "deleted" documents so we should not remove access rules.
-            leinfelder
+        } catch (Exception e) {
             e.printStackTrace();
             logMetacat.error("Error while deleting " + TYPE_SYSTEM_METADATA + " record: " + guid, e );
-            leinfelder
+            try {
 				dbConn.rollback();
 			} catch (SQLException sqle) {
 	            logMetacat.error("Error while rolling back delete for record: " + guid, sqle );
+			}
-            leinfelder
+        } finally {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
+    }
             jones

Project

General

Profile

Metacat