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

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

-            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;
-            cjones
+import org.dataone.service.exceptions.InvalidSystemMetadata;
-            cjones
+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.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;
+	}
             berkley
     /**
      * 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
+     */
-            leinfelder
+    public List<String> getLocalIdsWithNoSystemMetadata(boolean includeRevisions)
             berkley
         Vector<String> ids = new Vector<String>();
-            leinfelder
+        String sql = "select docid, rev from xml_documents " +
         		"where docid not in " +
-            leinfelder
+        		"(select docid from identifier where guid in (select guid from systemmetadata))";
             leinfelder
-            leinfelder
+        String revisionSql = "select docid, rev from xml_revisions " +
-            leinfelder
+				"where docid not in " +
-            leinfelder
+				"(select docid from identifier where guid in (select guid from systemmetadata))";
             leinfelder
         if (includeRevisions) {
         	sql = sql + " UNION ALL " + revisionSql;
+        }
-            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
-            cjones
+     * @throws SQLException
-            cjones
+     * @throws InvalidSystemMetadata
-            berkley
+     */
-            cjones
+    public void createSystemMetadata(SystemMetadata sysmeta)
-            cjones
+        throws McdbDocNotFoundException, SQLException, InvalidSystemMetadata {
-            leinfelder
+    	String guid = sysmeta.getIdentifier().getValue();
-            leinfelder
+    	// insert the record
         insertSystemMetadata(guid);
         // update with the values
-            leinfelder
+        updateSystemMetadata(sysmeta);
             cjones
             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,
-            cjones
+        String checksum, String checksumAlgorithm, String originMemberNode,
         String authoritativeMemberNode, long modifiedDate, String submitter,
         String guid, String objectFormat, BigInteger size, boolean archived,
         boolean replicationAllowed, int numberReplicas, String obsoletes,
         String obsoletedBy, BigInteger serialVersion) throws SQLException  {
-            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, archived, replication_allowed, number_replicas, " +
-            leinfelder
+                "obsoletes, obsoleted_by, serial_version) " +
-            leinfelder
+                "= (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) 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, archived);
             stmt.setBoolean(12, replicationAllowed);
             stmt.setInt(13, numberReplicas);
             stmt.setString(14, obsoletes);
             stmt.setString(15, obsoletedBy);
             stmt.setString(16, serialVersion.toString());
             leinfelder
-            berkley
+            //where clause
-            leinfelder
+            stmt.setString(17, guid);
-            leinfelder
+            logMetacat.debug("stmt: " + stmt.toString());
-            berkley
+            //execute
             int rows = stmt.executeUpdate();
             stmt.close();
             cjones
-            berkley
+        } catch (SQLException e) {
-            leinfelder
+            logMetacat.error("updateSystemMetadataFields: SQL error while updating system metadata: "
-            berkley
+                    + e.getMessage());
-            cjones
+            throw e;
-            berkley
+        } 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
-            cjones
+     * @throws SQLException
-            cjones
+     * @throws InvalidSystemMetadata
-            berkley
+     */
-            cjones
+    public void updateSystemMetadata(SystemMetadata sm)
-            cjones
+      throws McdbDocNotFoundException, SQLException, InvalidSystemMetadata {
             leinfelder
-            cjones
+      Boolean replicationAllowed = false;
 		  Integer numberReplicas = -1;
-            leinfelder
+    	ReplicationPolicy replicationPolicy = sm.getReplicationPolicy();
     	if (replicationPolicy != null) {
     		replicationAllowed = replicationPolicy.getReplicationAllowed();
     		numberReplicas = replicationPolicy.getNumberReplicas();
     		replicationAllowed = replicationAllowed == null ? false: replicationAllowed;
     		numberReplicas = numberReplicas == null ? -1: numberReplicas;
+    	}
             cjones
-            leinfelder
+    	// the main systemMetadata fields
-            cjones
+		  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(),
 		    sm.getFormatId() == null ? null: sm.getFormatId().getValue(),
 		    sm.getSize(),
 		    sm.getArchived() == null ? false: sm.getArchived(),
 		    replicationAllowed,
 		    numberReplicas,
 		    sm.getObsoletes() == null ? null:sm.getObsoletes().getValue(),
 		    sm.getObsoletedBy() == null ? null: sm.getObsoletedBy().getValue(),
 		    sm.getSerialVersion()
-            leinfelder
+        );
             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 {
-            leinfelder
+    	// check for the existing permOrder so that we remain compatible with it (DataONE does not care)
         XMLAccessAccess accessController  = new XMLAccessAccess();
 		String existingPermOrder = AccessControlInterface.ALLOWFIRST;
         Vector<XMLAccessDAO> existingAccess = accessController.getXMLAccessForDoc(guid);
         if (existingAccess != null && existingAccess.size() > 0) {
         	existingPermOrder = existingAccess.get(0).getPermOrder();
+        }
-            leinfelder
+    	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);
-            leinfelder
+				accessDAO.setPermOrder(existingPermOrder);
     			if (permissions != null) {
 	    			for (Permission permission: permissions) {
 	    				Long metacatPermission = new Long(convertPermission(permission));
 	        			accessDAO.addPermission(metacatPermission);
+	    			}
             leinfelder
     			accessDAOs.add(accessDAO);
             leinfelder
+        }
-            leinfelder
+        // remove all existing allow records
         accessController.deleteXMLAccessForDoc(guid, AccessControlInterface.ALLOW);
         // add the ones we can for this guid
         accessController.insertAccess(guid, accessDAOs);
             leinfelder
             leinfelder
             leinfelder
     /**
      * Lookup access policy from Metacat
      * @param guid
      * @return
      * @throws McdbDocNotFoundException
      * @throws AccessException
      */
-            leinfelder
+    public AccessPolicy getAccessPolicy(String guid) throws McdbDocNotFoundException, AccessException {
-            leinfelder
+        AccessPolicy accessPolicy = new AccessPolicy();
-            leinfelder
+    	// use GUID to look up the access
-            leinfelder
+        XMLAccessAccess accessController  = new XMLAccessAccess();
-            leinfelder
+        List<XMLAccessDAO> accessDAOs = accessController.getXMLAccessForDoc(guid);
-            leinfelder
+        for (XMLAccessDAO accessDAO: accessDAOs) {
-            leinfelder
+        	// only add allow rule
         	if (accessDAO.getPermType().equals(AccessControlInterface.ALLOW)) {
 	        	AccessRule accessRule = new AccessRule();
 	        	List <Permission> permissions = convertPermission(accessDAO.getPermission().intValue());
 	        	accessRule.setPermissionList(permissions);
 	        	Subject subject = new Subject();
 	        	subject.setValue(accessDAO.getPrincipalName());
 	        	accessRule.addSubject(subject);
 	            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;
+    }
-            leinfelder
+    public List<Permission> convertPermission(int permission) {
             leinfelder
-            leinfelder
+    	List<Permission> permissions = new ArrayList<Permission>();
-            leinfelder
+    	if (permission == AccessControlInterface.ALL) {
-            leinfelder
+    		permissions.add(Permission.READ);
     		permissions.add(Permission.WRITE);
-            leinfelder
+    		permissions.add(Permission.CHANGE_PERMISSION);
-            leinfelder
+    		return permissions;
             leinfelder
             leinfelder
     	if ((permission & AccessControlInterface.CHMOD) == AccessControlInterface.CHMOD) {
-            leinfelder
+    		permissions.add(Permission.CHANGE_PERMISSION);
             leinfelder
-            leinfelder
+    	if ((permission & AccessControlInterface.READ) == AccessControlInterface.READ) {
-            leinfelder
+    		permissions.add(Permission.READ);
             leinfelder
     	if ((permission & AccessControlInterface.WRITE) == AccessControlInterface.WRITE) {
-            leinfelder
+    		permissions.add(Permission.WRITE);
             leinfelder
             leinfelder
 		return permissions;
             leinfelder
     /**
-            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
+     */
-            cjones
+    public ObjectList querySystemMetadata(Date startTime, Date endTime,
         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;
             cjones
-            leinfelder
+        try {
-            cjones
+            String sql = "select guid, date_uploaded, rights_holder, checksum, "
                     + "checksum_algorithm, origin_member_node, authoritive_member_node, "
                     + "date_modified, submitter, object_format, size from systemmetadata";
-            berkley
+            boolean f1 = false;
             boolean f2 = false;
             boolean f3 = false;
             cjones
-            leinfelder
+            if (startTime != null) {
-            cjones
+                sql += " where systemmetadata.date_modified >= ?";
-            berkley
+                f1 = true;
+            }
             cjones
-            leinfelder
+            if (endTime != null) {
                 if (!f1) {
-            berkley
+                    sql += " where systemmetadata.date_modified < ?";
-            cjones
+                } else {
-            berkley
+                    sql += " and systemmetadata.date_modified < ?";
+                }
-            berkley
+                f2 = true;
+            }
             cjones
-            leinfelder
+            if (objectFormatId != null) {
-            leinfelder
+                if (!f1 && !f2) {
-            berkley
+                    sql += " where object_format = ?";
-            cjones
+                } else {
-            berkley
+                    sql += " and object_format = ?";
+                }
-            berkley
+                f3 = true;
+            }
             cjones
-            leinfelder
+            if (replicaStatus) {
-            berkley
+                String currentNodeId = PropertyService.getInstance().getProperty("dataone.memberNodeId");
-            leinfelder
+                if (!f1 && !f2 && !f3) {
-            cjones
+                    sql += " where authoritive_member_node != '" +
                         currentNodeId.trim() + "'";
                 } else {
                     sql += " and authoritive_member_node != '" +
                         currentNodeId.trim() + "'";
             berkley
             berkley
             cjones
-            berkley
+            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.querySystemMetadata");
             serialNumber = dbConn.getCheckOutSerialNumber();
-            berkley
+            PreparedStatement stmt = dbConn.prepareStatement(sql);
             cjones
-            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());
-            cjones
+            } else if (f1 && f2 && !f3) {
-            berkley
+                stmt.setTimestamp(1, new Timestamp(startTime.getTime()));
                 stmt.setTimestamp(2, new Timestamp(endTime.getTime()));
-            cjones
+            } else if (f1 && !f2 && f3) {
-            berkley
+                stmt.setTimestamp(1, new Timestamp(startTime.getTime()));
-            leinfelder
+                stmt.setString(2, objectFormatId.getValue());
-            cjones
+            } else if (f1 && !f2 && !f3) {
-            berkley
+                stmt.setTimestamp(1, new Timestamp(startTime.getTime()));
-            cjones
+            } else if (!f1 && f2 && f3) {
-            berkley
+                stmt.setTimestamp(1, new Timestamp(endTime.getTime()));
-            leinfelder
+                stmt.setString(2, objectFormatId.getValue());
-            cjones
+            } else if (!f1 && !f2 && f3) {
-            leinfelder
+                stmt.setString(1, objectFormatId.getValue());
-            cjones
+            } else if (!f1 && f2 && !f3) {
-            berkley
+                stmt.setTimestamp(1, new Timestamp(endTime.getTime()));
+            }
             cjones
             // logMetacat.debug("LISTOBJECTS QUERY: " + stmt.toString());
-            berkley
+            ResultSet rs = stmt.executeQuery();
-            cjones
+            for (int i = 0; i < start; i++) {
-            leinfelder
+                if (rs.next()) {
-            berkley
+                    total++;
-            leinfelder
+                } else {
-            berkley
+                    break;
+                }
             berkley
             cjones
-            berkley
+            int countIndex = 0;
             cjones
             while (rs.next()) {
-            berkley
+                total++;
-            leinfelder
+                if (countIndex >= count) {
-            cjones
+                    // allow unlimited (negative number for count)
                     if (count > 0) {
                         break;
+                    }
             berkley
             cjones
-            berkley
+                String guid = rs.getString(1);
-            cjones
+                // logMetacat.debug("query found doc with guid " + guid);
                 // Timestamp dateUploaded = rs.getTimestamp(2);
                 // String rightsHolder = rs.getString(3);
-            cjones
+                String checksum = rs.getString(4);
                 String checksumAlgorithm = rs.getString(5);
-            cjones
+                // String originMemberNode = rs.getString(6);
                 // String authoritiveMemberNode = rs.getString(7);
-            cjones
+                Timestamp dateModified = rs.getTimestamp(8);
-            cjones
+                // String submitter = rs.getString(9);
-            cjones
+                String fmtidStr = rs.getString(10);
                 String sz = rs.getString(11);
-            cjones
+                BigInteger size = new BigInteger("0");
             cjones
-            leinfelder
+                if (sz != null && !sz.trim().equals("")) {
-            cjones
+                    size = new BigInteger(rs.getString(11));
             berkley
             cjones
-            berkley
+                ObjectInfo oi = new ObjectInfo();
             cjones
-            berkley
+                Identifier id = new Identifier();
                 id.setValue(guid);
                 oi.setIdentifier(id);
             cjones
-            leinfelder
+                if (dateModified != null) {
-            cjones
+                    oi.setDateSysMetadataModified(new Date(dateModified.getTime()));
             leinfelder
             cjones
-            berkley
+                Checksum cs = new Checksum();
                 cs.setValue(checksum);
-            leinfelder
+                try {
-            cjones
+                    // cs.setAlgorithm(ChecksumAlgorithm.valueOf(checksumAlgorithm));
-            leinfelder
+                    cs.setAlgorithm(checksumAlgorithm);
-            leinfelder
+                } catch (Exception e) {
-            cjones
+                    logMetacat.error("could not parse checksum algorithm", e);
                     continue;
+                }
-            berkley
+                oi.setChecksum(cs);
             cjones
-            leinfelder
+                // set the format type
                 ObjectFormatIdentifier fmtid = new ObjectFormatIdentifier();
-            cjones
+                fmtid.setValue(fmtidStr);
-            leinfelder
+                oi.setFormatId(fmtid);
             cjones
-            berkley
+                oi.setSize(size);
             cjones
-            cjones
+                // when requested count == 0, return an empty object list
                 if (count != 0) {
                     ol.addObjectInfo(oi);
+                }
-            berkley
+                countIndex++;
+            }
             cjones
-            leinfelder
+            // expend the resultset to get the total count of possible rows
-            cjones
+            while (rs.next()) {
-            berkley
+                total++;
+            }
+        }
             cjones
-            leinfelder
+        finally {
-            berkley
+            // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
             cjones
-            berkley
+        ol.setStart(start);
-            berkley
+        ol.setCount(ol.sizeObjectInfoList());
-            berkley
+        ol.setTotal(total);
             cjones
-            berkley
+        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();
-            leinfelder
+            // TODO: remove the access?
-            leinfelder
+            // 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);
+        }
+    }
             leinfelder
     public void updateAuthoritativeMemberNodeId(String existingMemberNodeId, String newMemberNodeId)
+    {
         DBConnection dbConn = null;
         int serialNumber = -1;
         try {
             // Get a database connection from the pool
             dbConn = DBConnectionPool.getDBConnection("IdentifierManager.updateAuthoritativeMemberNodeId");
             serialNumber = dbConn.getCheckOutSerialNumber();
             // Execute the insert statement
             String query = "update " + TYPE_SYSTEM_METADATA +
                 " set authoritive_member_node = ? " +
                 " where authoritive_member_node = ?";
             PreparedStatement stmt = dbConn.prepareStatement(query);
             //data values
             stmt.setString(1, newMemberNodeId);
             stmt.setString(2, existingMemberNodeId);
             logMetacat.debug("stmt: " + stmt.toString());
             //execute
             int rows = stmt.executeUpdate();
             stmt.close();
         } catch (SQLException e) {
             e.printStackTrace();
             logMetacat.error("updateSystemMetadataFields: SQL error while updating system metadata: "
                     + e.getMessage());
         } catch (NumberFormatException e) {
             e.printStackTrace();
             logMetacat.error("updateSystemMetadataFields: NumberFormat error while updating system metadata: "
                     + e.getMessage());
         } finally {
             // Return database connection to the pool
             DBConnectionPool.returnDBConnection(dbConn, serialNumber);
+        }
+    }
             jones

Project

General

Profile

Metacat