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.sql.ResultSet;

import java.sql.SQLException;

import java.util.Date;

import java.util.List;

import java.util.Vector;

import org.apache.log4j.Logger;

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.v2.MediaTypeProperty;

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

import edu.ucsb.nceas.utilities.access.XMLAccessDAO;

/**

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

 * 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_IDENTIFIER = "identifier";

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

     */

    private static IdentifierManager self = null;

    /**

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

     * called.

     */

    /**

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

    }

            String authoritativeMemberNode, Date dateModified, String submitter,

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

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

        	formatId.setValue(fmtidStr);

        	fmtid = ObjectFormatCache.getInstance().getFormat(formatId).getFormatId();

        } catch (BaseException nfe) {

            logMetacat.error("The objectFormat " + fmtidStr +

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

            sysMeta.setFormatId(fmtid);

        return sysMeta;

     * @param localId

     * @return

     */

    {

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

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

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

    /**

    {

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

        int serialNumber = -1;

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

        {

            // Get a database connection from the pool

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

            serialNumber = dbConn.getCheckOutSerialNumber();

            // Execute the statement

            PreparedStatement stmt = dbConn.prepareStatement(sql);

            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 obsoletes = rs.getString(14);

                String obsoletedBy = rs.getString(15);

                String media_type = rs.getString(20);

                sysMetaId.setValue(guid);

                sysMeta.setIdentifier(sysMetaId);

                Subject rightsHolderSubject = new Subject();

                rightsHolderSubject.setValue(rightsHolder);

                sysMeta.setRightsHolder(rightsHolderSubject);

                Checksum checksumObject = new Checksum();

                checksumObject.setValue(checksum);

	                NodeReference omn = new NodeReference();

	                omn.setValue(originMemberNode);

	                sysMeta.setOriginMemberNode(omn);

                }

                if (authoritativeMemberNode != null) {

	                NodeReference amn = new NodeReference();

	                amn.setValue(authoritativeMemberNode);

	                sysMeta.setAuthoritativeMemberNode(amn);

                }

	                Subject submitterSubject = new Subject();

	                submitterSubject.setValue(submitter);

	                sysMeta.setSubmitter(submitterSubject);

                }

                fmtid.setValue(fmtidStr);

            	sysMeta.setFormatId(fmtid);

	                Identifier obsoletesId = new Identifier();

	                obsoletesId.setValue(obsoletes);

	                sysMeta.setObsoletes(obsoletesId);

                }

                if (obsoletedBy != null) {

		            Identifier obsoletedById = new Identifier();

		            obsoletedById.setValue(obsoletedBy);

		            sysMeta.setObsoletedBy(obsoletedById);

                }

                    Identifier seriesId = new Identifier();

                    seriesId.setValue(series_id);

                    sysMeta.setSeriesId(seriesId);

                }

                    sysMeta.setFileName(file_name);

                }

                if(media_type != null ) {

                    MediaType mediaType = new MediaType();

                    mediaType.setName(media_type);

                    // get media type properties from another table.

                    String mediaTypePropertyQuery = "select name, value from smmediatypeproperties where guid = ?";

                    PreparedStatement stmt2 = dbConn.prepareStatement(mediaTypePropertyQuery);

                    stmt2.setString(1, guid);

                    ResultSet rs2 = stmt2.executeQuery();

                    while (rs2.next()) {

                        String name = rs2.getString(1);

                        String value = rs2.getString(2);

                        MediaTypeProperty property = new MediaTypeProperty();

                        property.setName(name);

                        property.setValue(value);

                        mediaType.addProperty(property);

                    }

                    sysMeta.setMediaType(mediaType);

                    rs2.close();

                    stmt2.close();

                }

            }

            else

            {

                stmt.close();

                DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }

        catch (SQLException e)

        {

            e.printStackTrace();

        }

        finally

        {

            // Return database connection to the pool

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }

            replicationPolicy.setNumberReplicas(numberOfReplicas.intValue());

        }

        if ( replicationAllowed != null ) {

            replicationPolicy.setReplicationAllowed(replicationAllowed);

        }

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

		    sysMeta.setReplicaList(getReplicationStatus(guid));

		    try {

		    	sysMeta.setAccessPolicy(getAccessPolicy(guid));

		    } catch (AccessException e) {

		    	throw new McdbDocNotFoundException(e);

		    }

    }

		throws McdbDocNotFoundException {

		List<NodeReference> nodes = new ArrayList<NodeReference>();

		String sql = "select guid, policy, member_node " +

	    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;

	}

		List<Replica> replicas = new ArrayList<Replica>();

		String sql = "select guid, member_node, status, date_verified " +

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

	            Replica replica = new Replica();

	            NodeReference node = new NodeReference();

	            node.setValue(memberNode);

	            replica.setReplicaMemberNode(node);

	            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 the newest rev for a given localId

     * @param localId

     * @return

     */

    public int getLatestRevForLocalId(String localId)

        throws McdbDocNotFoundException

    {

        {

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

            localId = acc.getDocid();

        }

        catch(Exception e)

        {

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

        }

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

            if (rs.next())

            {

                rev = rs.getInt(1);

                stmt.close();

            }

            else

            {

                stmt.close();

                DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }

        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;

    }

    /**

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

        		"where docid not in " +

        	sql = sql + " and server_location = ? ";

        }

        	revisionSql = revisionSql + " and server_location = ? ";

        }

        if (includeRevisions) {

        	sql = sql + " UNION ALL " + revisionSql;

        }

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

            if (serverLocation > 0) {

            	stmt.setInt(1, serverLocation);

            	if (includeRevisions) {

            		stmt.setInt(2, serverLocation);

            	}

            }

            while (rs.next())

            {

                String localid = rs.getString(1);

                localid += "." + rev;

            }

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

    //    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 list of all GUIDs in metacat

     */

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

        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;

    }

    /**

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

            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