Metacat

/**

 *  '$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;

import java.math.BigInteger;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Timestamp;

import java.util.ArrayList;

import java.util.Date;

import java.util.Hashtable;

import java.util.List;

import java.util.Vector;

import org.apache.log4j.Logger;

import org.dataone.client.ObjectFormatCache;

import org.dataone.service.exceptions.NotFound;

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;

import edu.ucsb.nceas.metacat.accesscontrol.AccessControlInterface;

import edu.ucsb.nceas.metacat.accesscontrol.XMLAccessAccess;

import edu.ucsb.nceas.metacat.accesscontrol.XMLAccessDAO;

import edu.ucsb.nceas.metacat.database.DBConnection;

import edu.ucsb.nceas.metacat.database.DBConnectionPool;

import edu.ucsb.nceas.metacat.properties.PropertyService;

import edu.ucsb.nceas.metacat.shared.AccessException;

import edu.ucsb.nceas.metacat.shared.ServiceException;

import edu.ucsb.nceas.metacat.util.DocumentUtil;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

/**

 * Manage the relationship between Metacat local identifiers (LocalIDs) that are

 * codified as the (docid, rev) pair with globally unique string identifiers

 * (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 {

    public static final String TYPE_SYSTEM_METADATA = "systemmetadata";

    public static final String TYPE_IDENTIFIER = "identifier";

    /**

     * The single instance of the manager that is always returned.

     */

    private static IdentifierManager self = null;

    private Logger logMetacat = Logger.getLogger(IdentifierManager.class);

    /**

     * A private constructor that initializes the class when getInstance() is

     * called.

     */

    private IdentifierManager() {}

    /**

     * 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;

    }

    public SystemMetadata asSystemMetadata(Date dateUploaded, String rightsHolder,

            String checksum, String checksumAlgorithm, String originMemberNode,

            String authoritativeMemberNode, Date dateModified, String submitter, 

            String guid, String fmtidStr, BigInteger size, BigInteger serialVersion) {

        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);

        checksumObject.setAlgorithm(checksumAlgorithm);

        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);

        try {

        	ObjectFormatIdentifier fmtid = 

        		ObjectFormatCache.getInstance().getFormat(fmtidStr).getFormatId();

        	sysMeta.setFormatId(fmtid);

        } catch (NotFound nfe) {

          logMetacat.error("The objectFormat " + fmtidStr +

          	" is not registered. Setting the default format id.");

          ObjectFormatIdentifier fmtid = new ObjectFormatIdentifier();

          fmtid.setValue("application/octet-stream");

          sysMeta.setFormatId(fmtid);

        }

        sysMeta.setSize(size);

        sysMeta.setSerialVersion(serialVersion);

        return sysMeta;

    }

    /**

     * 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, " +

          "origin_member_node, authoritive_member_node, date_modified, submitter, object_format, size " +

          "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);

                String objectFormat = rs.getString(10);

                long size = new Long(rs.getString(11)).longValue();

                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);

                h.put("object_format", objectFormat);

                h.put("size", new Long(size).toString());

                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;

    }

    /**

     * return a hash of all of the info that is in the systemmetadata table

     * @param guid

     * @return

     * @throws McdbDocNotFoundException 

     */

    public SystemMetadata getSystemMetadata(String guid)

    	throws McdbDocNotFoundException

    {

        SystemMetadata sysMeta = new SystemMetadata();

        String sql = "select guid, date_uploaded, rights_holder, checksum, checksum_algorithm, " +

          "origin_member_node, authoritive_member_node, date_modified, submitter, object_format, size, " +

          "replication_allowed, number_replicas, obsoletes, obsoleted_by, serial_version " +

          "from systemmetadata where guid = ?";

        DBConnection dbConn = null;

        int serialNumber = -1;

        Boolean replicationAllowed = new Boolean(false);

        BigInteger numberOfReplicas = new BigInteger("-1");

        BigInteger serialVersion = new BigInteger("-1");

        try 

        {

            // Get a database connection from the pool

            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getSystemMetadata");

            serialNumber = dbConn.getCheckOutSerialNumber();

            // Execute the statement

            PreparedStatement stmt = dbConn.prepareStatement(sql);

            stmt.setString(1, guid);

            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);

                String fmtidStr = rs.getString(10);

                BigInteger size = new BigInteger(rs.getString(11));

                replicationAllowed = new Boolean(rs.getBoolean(12));

                numberOfReplicas = new BigInteger(rs.getString(13));

                String obsoletes = rs.getString(14);

                String obsoletedBy = rs.getString(15);

                serialVersion = new BigInteger(rs.getString(16));

                Identifier sysMetaId = new Identifier();

                sysMetaId.setValue(guid);

                sysMeta.setIdentifier(sysMetaId);

                sysMeta.setSerialVersion(serialVersion);

                sysMeta.setDateUploaded(dateUploaded);

                Subject rightsHolderSubject = new Subject();

                rightsHolderSubject.setValue(rightsHolder);

                sysMeta.setRightsHolder(rightsHolderSubject);

                Checksum checksumObject = new Checksum();

                checksumObject.setValue(checksum);

                checksumObject.setAlgorithm(checksumAlgorithm);

                sysMeta.setChecksum(checksumObject);

                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);

                }

                sysMeta.setDateSysMetadataModified(dateModified);

                Subject submitterSubject = new Subject();

                submitterSubject.setValue(submitter);

                sysMeta.setSubmitter(submitterSubject);

                try {

                	ObjectFormatIdentifier fmtid = 

                		ObjectFormatCache.getInstance().getFormat(fmtidStr).getFormatId();

                	sysMeta.setFormatId(fmtid);

                } catch (NotFound nfe) {

                  logMetacat.error("The objectFormat " + fmtidStr +

                  	" is not registered. Setting the default format id.");

                  ObjectFormatIdentifier fmtid = new ObjectFormatIdentifier();

                  fmtid.setValue("application/octet-stream");

                  sysMeta.setFormatId(fmtid);

                }

                sysMeta.setSize(size);

                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);

                }

                stmt.close();

            } 

            else

            {

                stmt.close();

                DBConnectionPool.returnDBConnection(dbConn, serialNumber);

                throw new McdbDocNotFoundException("Could not find " + guid);

            }

        } 

        catch (SQLException e) 

        {

            e.printStackTrace();

            logMetacat.error("Error while getting system metadata for guid " + guid + " : "  

                    + e.getMessage());

        } 

        finally 

        {

            // Return database connection to the pool

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }

        // populate the replication policy

        ReplicationPolicy replicationPolicy = new ReplicationPolicy();

        if ( numberOfReplicas != null  && numberOfReplicas.intValue() != -1 ) {

            replicationPolicy.setNumberReplicas(numberOfReplicas.intValue());

        }

        if ( replicationAllowed != null ) {

            replicationPolicy.setReplicationAllowed(replicationAllowed);

        }

        replicationPolicy.setBlockedMemberNodeList(getReplicationPolicy(guid, "blocked"));

        replicationPolicy.setPreferredMemberNodeList(getReplicationPolicy(guid, "preferred"));

		    sysMeta.setReplicationPolicy(replicationPolicy);

		    // look up replication status

		    sysMeta.setReplicaList(getReplicationStatus(guid));

		    // look up access policy

		    try {

		    	sysMeta.setAccessPolicy(getAccessPolicy(guid));

		    } catch (AccessException e) {

		    	throw new McdbDocNotFoundException(e);

		    }

        return sysMeta;

    }

    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;

	}

    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);

	            replica.setReplicationStatus(ReplicationStatus.valueOf(status));

	            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;

	}

    /**

     * 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

     */

    public Hashtable<String, Object> getDocumentInfo(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, Object> h = new Hashtable<String, Object>();

        String sql = "select docname, doctype, user_owner, user_updated, " +

            "server_location, rev, date_created, date_updated from " + 

            "xml_documents where docid like '" + localId + "'";

        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);

            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);

                h.put("docid", localId);

                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);

                throw new McdbDocNotFoundException("2Could not find document " + localId);

            }

            String sql2 = "select principal_name, permission, perm_type, perm_order from xml_access " +

            "where docid like '" + localId + "'";

            logMetacat.debug("executing sql: " + sql2);

            PreparedStatement stmt2 = dbConn.prepareStatement(sql2);

            rs = stmt2.executeQuery();

            Vector accessVector = new Vector();

            while(rs.next())

            {

                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);

                logMetacat.debug("accessHash: " + accessHash.toString());

                accessVector.add(accessHash);

            }

            h.put("access", accessVector);

        } 

        catch (SQLException e) 

        {

            e.printStackTrace();

            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

    {

        try

        {

            AccessionNumber acc = new AccessionNumber(localId, "NONE");

            localId = acc.getDocid();

        }

        catch(Exception e)

        {

            //do nothing. just try the localId as it is

        }

        int rev = 0;

        String sql = "select rev from xml_documents where docid like '" + localId + "'";

        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);

            ResultSet rs = stmt.executeQuery();

            if (rs.next()) 

            {

                rev = rs.getInt(1);

                stmt.close();

            } 

            else

            {

                stmt.close();

                DBConnectionPool.returnDBConnection(dbConn, serialNumber);

                throw new McdbDocNotFoundException("While trying to get the latest rev, could not find document " + localId);

            }

        } 

        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;

    }

    /**

     * return all local ids in the object store that do not have associated

     * system metadata

     */

    public List<String> getLocalIdsWithNoSystemMetadata()

    {

        Vector<String> ids = new Vector<String>();

        String sql = "select docid, rev from xml_documents " +

        		"where docid not in " +

        		"(select docid from identifier where guid in (select guid from systemmetadata)))";

        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);

                String rev = rs.getString(2);

                localid += "." + rev;

                logMetacat.debug("id to add SM for: " + localid);

                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()

    // seems to be an unnecessary and restrictive throw -rnahf 13-Sep-2011

    //    throws Exception

    {

        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;

    }

    /**

     * 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;

    }

    /**

     * 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();

            // 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;

    }

    /**

     * 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;

        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;

    }

    /**

     * 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) {

        	// try system metadata only

        	try {

        		idExists = systemMetadataExists(guid);

            } catch (Exception e2) {

            	idExists = false;

            }

        }

        return idExists;

    }

    /**

     * 

     * @param guid

     * @param rev

     * @return

     */

    public String generateLocalId(String guid, int rev)

    {

        return generateLocalId(guid, rev, false);

    }

    /**

     * 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