Metacat

/**

 *  '$RCSfile$'

 *  Copyright: 2000-2011 Regents of the University of California and the

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author:  $'

 *     '$Date:  $'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.dataone;

import java.io.IOException;

import java.io.InputStream;

import java.security.NoSuchAlgorithmException;

import java.sql.SQLException;

import java.util.Date;

import java.util.List;

import org.apache.commons.io.IOUtils;

import org.apache.log4j.Logger;

import org.dataone.service.exceptions.IdentifierNotUnique;

import org.dataone.service.exceptions.InsufficientResources;

import org.dataone.service.exceptions.InvalidRequest;

import org.dataone.service.exceptions.InvalidSystemMetadata;

import org.dataone.service.exceptions.InvalidToken;

import org.dataone.service.exceptions.NotAuthorized;

import org.dataone.service.exceptions.NotFound;

import org.dataone.service.exceptions.NotImplemented;

import org.dataone.service.exceptions.ServiceFailure;

import org.dataone.service.exceptions.SynchronizationFailed;

import org.dataone.service.exceptions.UnsupportedType;

import org.dataone.service.mn.tier1.MNCore;

import org.dataone.service.mn.tier1.MNRead;

import org.dataone.service.mn.tier2.MNAuthorization;

import org.dataone.service.mn.tier3.MNStorage;

import org.dataone.service.mn.tier4.MNReplication;

import org.dataone.service.types.AccessPolicy;

import org.dataone.service.types.Checksum;

import org.dataone.service.types.ChecksumAlgorithm;

import org.dataone.service.types.DescribeResponse;

import org.dataone.service.types.Event;

import org.dataone.service.types.Group;

import org.dataone.service.types.Identifier;

import org.dataone.service.types.Log;

import org.dataone.service.types.MonitorList;

import org.dataone.service.types.Node;

import org.dataone.service.types.NodeReference;

import org.dataone.service.types.ObjectFormat;

import org.dataone.service.types.ObjectList;

import org.dataone.service.types.Permission;

import org.dataone.service.types.Session;

import org.dataone.service.types.Subject;

import org.dataone.service.types.SystemMetadata;

import org.dataone.service.types.util.ServiceTypeUtil;

import edu.ucsb.nceas.metacat.DocumentImpl;

import edu.ucsb.nceas.metacat.EventLog;

import edu.ucsb.nceas.metacat.IdentifierManager;

import edu.ucsb.nceas.metacat.McdbDocNotFoundException;

import edu.ucsb.nceas.metacat.client.InsufficientKarmaException;

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.utilities.PropertyNotFoundException;

/**

 * Represents Metacat's implementation of the DataONE Member Node 

 * service API. Methods implement the various MN* interfaces, and methods common

 * to both Member Node and Coordinating Node interfaces are found in the

 * D1NodeService base class.

 */

public class MNodeService extends D1NodeService implements MNAuthorization,

  MNCore, MNRead, MNReplication, MNStorage {

  /* the instance of the MNodeService object */

  private static MNodeService instance = null;

  /* the logger instance */

  private Logger logMetacat = null;

  /**

   * Singleton accessor to get an instance of MNodeService.

   * 

   * @return instance - the instance of MNodeService

   */

  public static MNodeService getInstance() {

    if (instance == null) {

      instance = new MNodeService();

    }

    return instance;

  }

  /**

   * Constructor, private for singleton access

   */

  private MNodeService() {

    super();

    logMetacat = Logger.getLogger(MNodeService.class);

  }

  /**

   * Deletes an object from the Member Node, where the object is either a 

   * data object or a science metadata object.

   * 

   * @param session - the Session object containing the credentials for the Subject

   * @param pid - The object identifier to be deleted

   * 

   * @return pid - the identifier of the object used for the deletion

   * 

   * @throws InvalidToken

   * @throws ServiceFailure

   * @throws NotAuthorized

   * @throws NotFound

   * @throws NotImplemented

   * @throws InvalidRequest

   */

  @Override

  public Identifier delete(Session session, Identifier pid) 

    throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

    NotImplemented, InvalidRequest {

    String localId = null;

    boolean allowed = false;

    Subject subject = session.getSubject();

    List<Group> groupList = session.getSubjectList().getGroupList();

    String[] groups = new String[groupList.size()];

    IdentifierManager im = IdentifierManager.getInstance();

    // put the group names into a string array

    if( session != null ) {

      for ( int i = 0; i > groupList.size(); i++ ) {

        groups[i] = groupList.get(i).getGroupName();

      }

    }

    // be sure the user is authenticated for delete()

    if (subject.getValue() == null || 

        subject.getValue().toLowerCase().equals("public") ) {

      throw new NotAuthorized("1320", "The provided identity does not have " +

        "permission to DELETE objects on the Member Node.");

    }

    // do we have a valid pid?

    if ( pid == null || pid.getValue().trim().equals("") ) {

      throw new InvalidRequest("1322", "The provided identifier was invalid.");

    }

    // check for the existing identifier

    try {

      localId = im.getLocalId(pid.getValue());

    } catch (McdbDocNotFoundException e) {

      throw new InvalidRequest("1322", "The object with the provided " +

        "identifier was not found.");

    }

    // does the subject have DELETE (a D1 CHANGE_PERMISSION level) priveleges on the pid?

    allowed = isAuthorized(session, pid, Permission.CHANGE_PERMISSION);

    if ( allowed ) {

      try {

        // delete the document

        DocumentImpl.delete(localId, subject.getValue(), groups, null);

        EventLog.getInstance().log(metacatUrl, subject.getValue(), localId, "delete");

      } catch (McdbDocNotFoundException e) {

        throw new InvalidRequest("1322", "The provided identifier was invalid.");

      } catch (SQLException e) {

        throw new ServiceFailure("1350", "There was a problem deleting the object." +

          "The error message was: " + e.getMessage());

      } catch (InsufficientKarmaException e) {

        throw new NotAuthorized("1320", "The provided identity does not have " +

        "permission to DELETE objects on the Member Node.");

      } catch (Exception e) { // for some reason DocumentImpl throws a general Exception

        throw new ServiceFailure("1350", "There was a problem deleting the object." +

            "The error message was: " + e.getMessage());

      }

    } else {

      throw new NotAuthorized("1320", "The provided identity does not have " +

      "permission to DELETE objects on the Member Node.");

    }

    return pid;

  }

  /**

   * Updates an existing object by creating a new object identified by 

   * newPid on the Member Node which explicitly obsoletes the object 

   * identified by pid through appropriate changes to the SystemMetadata 

   * of pid and newPid

   * 

   * @param session - the Session object containing the credentials for the Subject

   * @param pid - The identifier of the object to be updated

   * @param object - the new object bytes

   * @param sysmeta - the new system metadata describing the object

   * 

   * @return newPid - the identifier of the new object

   * 

   * @throws InvalidToken

   * @throws ServiceFailure

   * @throws NotAuthorized

   * @throws NotFound

   * @throws NotImplemented

   * @throws IdentifierNotUnique

   * @throws UnsupportedType

   * @throws InsufficientResources

   * @throws InvalidSystemMetadata

   * @throws InvalidRequest

   */

  @Override

  public Identifier update(Session session, Identifier pid, InputStream object,

    Identifier newPid, SystemMetadata sysmeta) 

    throws InvalidToken, ServiceFailure, NotAuthorized, IdentifierNotUnique, 

    UnsupportedType, InsufficientResources, NotFound, InvalidSystemMetadata, 

    NotImplemented, InvalidRequest {

    String localId = null;

    boolean allowed = false;

    boolean isScienceMetadata = false;

    Subject subject = session.getSubject();

    List<Group> groupList = session.getSubjectList().getGroupList();

    String[] groups = new String[groupList.size()];

    IdentifierManager im = IdentifierManager.getInstance();

    // put the group names into a string array

    if( session != null ) {

      for ( int i = 0; i > groupList.size(); i++ ) {

        groups[i] = groupList.get(i).getGroupName();

      }

    }

    // be sure the user is authenticated for update()

    if (subject.getValue() == null || 

        subject.getValue().toLowerCase().equals("public") ) {

      throw new NotAuthorized("1200", "The provided identity does not have " +

        "permission to UPDATE objects on the Member Node.");

    }

    // do we have a valid pid?

    if ( pid == null || pid.getValue().trim().equals("") ) {

      throw new InvalidRequest("1202", "The provided identifier was invalid.");

    }

    // check for the existing identifier

    try {

      localId = im.getLocalId(pid.getValue());

    } catch (McdbDocNotFoundException e) {

      throw new InvalidRequest("1202", "The object with the provided " +

        "identifier was not found.");

    }

    // does the subject have WRITE ( == update) priveleges on the pid?

    allowed = isAuthorized(session, pid, Permission.WRITE);

    if ( allowed ) {

      // get the existing system metadata for the object

      SystemMetadata existingSysMeta = getSystemMetadata(session, pid);

      // add the obsoleted pid to the obsoletedBy list

      List<Identifier> obsoletedList = existingSysMeta.getObsoletedByList();

      obsoletedList.add(pid);

      existingSysMeta.setObsoletedByList(obsoletedList);

      // then update the existing system metadata

      updateSystemMetadata(existingSysMeta);

      // prep the new system metadata, add pid to the obsoletes list

      sysmeta.addObsolete(pid);

      // and insert the new system metadata

      insertSystemMetadata(sysmeta);

      isScienceMetadata = isScienceMetadata(sysmeta);

      // do we have XML metadata or a data object?

      if ( isScienceMetadata ) {

        // update the science metadata XML document

        // TODO: handle non-XML metadata/data documents (like netCDF)

        // TODO: don't put objects into memory using stream to string

        String objectAsXML = "";

        try {

          objectAsXML = IOUtils.toString(object, "UTF-8");

          localId = insertOrUpdateDocument(objectAsXML, newPid, session, "update");

          // register the newPid and the generated localId

          if ( newPid != null ) {

            im.createMapping(newPid.getValue(), localId);

          }

        } catch (IOException e) {

          String msg = "The Node is unable to create the object. " +

          "There was a problem converting the object to XML";

          logMetacat.info(msg);

          throw new ServiceFailure("1310", msg + ": " + e.getMessage());

        }

      } else {

        // update the data object

        localId = insertDataObject(object, newPid, session);

        // register the newPid and the generated localId

        if ( newPid != null ) {

          im.createMapping(newPid.getValue(), localId);

        }

      }

      // log the update event

      EventLog.getInstance().log(metacatUrl, subject.getValue(), localId, "update");

    } else {

      throw new NotAuthorized("1200", "The provided identity does not have " +

      "permission to UPDATE the object identified by " +

      pid.getValue() + " on the Member Node.");

    }

    return pid;

  }

  /**

   * Called by a Coordinating Node to request that the Member Node create a 

   * copy of the specified object by retrieving it from another Member 

   * Node and storing it locally so that it can be made accessible to 

   * the DataONE system.

   * 

   * @param session - the Session object containing the credentials for the Subject

   * @param sysmeta - Copy of the CN held system metadata for the object

   * @param sourceNode - A reference to node from which the content should be 

   *                     retrieved. The reference should be resolved by 

   *                     checking the CN node registry.

   * 

   * @return true if the replication succeeds

   * 

   * @throws ServiceFailure

   * @throws NotAuthorized

   * @throws NotImplemented

   * @throws UnsupportedType

   * @throws InsufficientResources

   * @throws InvalidRequest

   */

  @Override

  public boolean replicate(Session session, SystemMetadata sysmeta, 

    NodeReference sourceNode)

    throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest,

    InsufficientResources, UnsupportedType {

    return false;

  }

  /**

   * This method provides a lighter weight mechanism than 

   * MN_read.getSystemMetadata() for a client to determine basic 

   * properties of the referenced object.

   * 

   * @param session - the Session object containing the credentials for the Subject

   * @param pid - the identifier of the object to be described

   * 

   * @return describeResponse - A set of values providing a basic description 

   *                            of the object.

   * 

   * @throws InvalidToken

   * @throws ServiceFailure

   * @throws NotAuthorized

   * @throws NotFound

   * @throws NotImplemented

   * @throws InvalidRequest

   */

  @Override

  public DescribeResponse describe(Session session, Identifier pid)

    throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,

    NotImplemented, InvalidRequest {

    if(session == null) {

      throw new InvalidToken("1370", "The session object is null");

    }

    if(pid == null || pid.getValue().trim().equals(""))

    {

      throw new InvalidRequest("1362", "The object identifier is null. " +

        "A valid identifier is required.");

    }

    SystemMetadata sysmeta = getSystemMetadata(session, pid);

    DescribeResponse describeResponse = 

      new DescribeResponse(sysmeta.getObjectFormat(), 

      sysmeta.getSize(), sysmeta.getDateSysMetadataModified(), sysmeta.getChecksum());

    return describeResponse;

  }

  /**

   * Return the object identified by the given object identifier

   * 

   * @param session - the Session object containing the credentials for the Subject

   * @param pid - the object identifier for the given object

   * 

   * @return inputStream - the input stream of the given object

   * 

   * @throws InvalidToken

   * @throws ServiceFailure

   * @throws NotAuthorized

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  @Override

  public InputStream get(Session session, Identifier pid) 

    throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

    NotImplemented, InvalidRequest {

    return super.get(session, pid);

  }

  /**

   * Returns a Checksum for the specified object using an accepted hashing algorithm

   * 

   * @param session - the Session object containing the credentials for the Subject

   * @param pid - the object identifier for the given object

   * @param algorithm -  the name of an algorithm that will be used to compute 

   *                     a checksum of the bytes of the object

   * 

   * @return checksum - the checksum of the given object

   * 

   * @throws InvalidToken

   * @throws ServiceFailure

   * @throws NotAuthorized

   * @throws NotFound

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  @Override

  public Checksum getChecksum(Session session, Identifier pid, String algorithm)

    throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,

    InvalidRequest, NotImplemented {

    Checksum checksum = null;

    InputStream inputStream = get(session, pid);

    try {

      checksum = 

        ServiceTypeUtil.checksum(inputStream, ChecksumAlgorithm.convert(algorithm));

    } catch (NoSuchAlgorithmException e) {

      throw new ServiceFailure("1410", "The checksum for the object specified by " + 

        pid.getValue() +

        "could not be returned due to an internal error: " +

        e.getMessage());

    } catch (IOException e) {

      throw new ServiceFailure("1410", "The checksum for the object specified by " + 

        pid.getValue() +

        "could not be returned due to an internal error: " +

        e.getMessage());

    }

    if ( checksum == null ) {

      throw new ServiceFailure("1410", "The checksum for the object specified by " + 

        pid.getValue() +

        "could not be returned.");

    }

    return checksum;

  }

  /**

   * Return the system metadata for a given object

   * 

   * @param session - the Session object containing the credentials for the Subject

   * @param pid - the object identifier for the given object

   * 

   * @return inputStream - the input stream of the given system metadata object

   * 

   * @throws InvalidToken

   * @throws ServiceFailure

   * @throws NotAuthorized

   * @throws NotFound

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  @Override

  public SystemMetadata getSystemMetadata(Session session, Identifier pid)

      throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,

      InvalidRequest, NotImplemented {

    return super.getSystemMetadata(session, pid);

  }

  /**

   * Retrieve the list of objects present on the MN that match the calling parameters

   * 

   * @param session - the Session object containing the credentials for the Subject

   * @param startTime - Specifies the beginning of the time range from which 

   *                    to return object (>=)

   * @param endTime - Specifies the beginning of the time range from which 

   *                  to return object (>=)

   * @param objectFormat - Restrict results to the specified object format

   * @param replicaStatus - Indicates if replicated objects should be returned in the list

   * @param start - The zero-based index of the first value, relative to the 

   *                first record of the resultset that matches the parameters.

   * @param count - The maximum number of entries that should be returned in 

   *                the response. The Member Node may return less entries 

   *                than specified in this value.

   * 

   * @return objectList - the list of objects matching the criteria

   * 

   * @throws InvalidToken

   * @throws ServiceFailure

   * @throws NotAuthorized

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  @Override

  public ObjectList listObjects(Session session, Date startTime, Date endTime,

    ObjectFormat objectFormat, Boolean replicaStatus, Integer start, Integer count)

    throws NotAuthorized, InvalidRequest, NotImplemented, ServiceFailure,

    InvalidToken {

    ObjectList objectList = null;

    objectList = IdentifierManager.getInstance().querySystemMetadata(startTime, endTime,

        objectFormat, replicaStatus, start, count);

    if ( objectList == null ) {

      throw new ServiceFailure("1580", "The object list was null.");

    }

    return objectList;

  }

  /**

   * Retrieve the list of objects present on the MN that match the calling parameters

   * 

   * @return node - the technical capabilities of the Member Node

   * 

   * @throws ServiceFailure

   * @throws NotAuthorized

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  @Override

  public Node getCapabilities() throws NotImplemented, NotAuthorized,

      ServiceFailure, InvalidRequest {

		throw new NotImplemented("2160", "getCapabilities() not yet implemented");

  }

  /**

   * Returns the number of operations that have been serviced by the node 

   * over time periods of one and 24 hours.

   * 

   * @param session - the Session object containing the credentials for the Subject

   * @param period - An ISO8601 compatible DateTime range specifying the time 

   *                 range for which to return operation statistics.

   * @param requestor - Limit to operations performed by given requestor identity.

   * @param event -  Enumerated value indicating the type of event being examined

   * @param format - Limit to events involving objects of the specified format

   * 

   * @return the desired log records

   * 

   * @throws InvalidToken

   * @throws ServiceFailure

   * @throws NotAuthorized

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  @Override

  public MonitorList getOperationStatistics(Session session, Integer period,

    Subject requestor, Event event, ObjectFormat format) 

    throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest, 

    InsufficientResources, UnsupportedType {

		throw new NotImplemented("2080", "getOperationsStatistics not yet implemented");

  }

  /**

   * Low level “are you alive” operation. A valid ping response is 

   * indicated by a HTTP status of 200.

   * 

   * @return true if the service is alive

   * 

   * @throws InvalidToken

   * @throws ServiceFailure

   * @throws NotAuthorized

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  @Override

  public boolean ping() 

    throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest, 

    InsufficientResources, UnsupportedType {

    // test if we can get a database connection

    boolean alive = false;

    int serialNumber = -1;

    DBConnection dbConn = null;

    try {

      dbConn = DBConnectionPool

      .getDBConnection("MNodeService.ping");

      serialNumber = dbConn.getCheckOutSerialNumber();

      alive = true;

    } catch (SQLException e) {

      return alive;

    } finally {

      // Return the database connection

      DBConnectionPool.returnDBConnection(dbConn, serialNumber);

    }

    return alive;

  }

  /**

   * A callback method used by a CN to indicate to a MN that it cannot 

   * complete synchronization of the science metadata identified by pid.  Log

   * the event in the metacat event log.

   * 

   * @param session

   * @param syncFailed

   * 

   * @throws ServiceFailure

   * @throws NotAuthorized

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  @Override

  public void synchronizationFailed(Session session, SynchronizationFailed syncFailed)

      throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest {

    String localId;

    try {

      localId = IdentifierManager.getInstance().getLocalId(syncFailed.getPid().getValue());

    } catch (McdbDocNotFoundException e) {

      throw new ServiceFailure("2161", "The identifier specified by " +

          syncFailed.getPid().getValue() + 

          " was not found on this node.");

    }

    // TODO: update the CN URL below when the CNRead.SynchronizationFailed

    // method is changed to include the URL as a parameter

    logMetacat.debug("Synchronization for the object identified by " +

      syncFailed.getPid().getValue() + 

      " failed from " +

      "CN URL WILL GO HERE." +

      " Logging the event to the Metacat EventLog as a 'syncFailed' event.");

    EventLog.getInstance().log("CN URL WILL GO HERE", 

        session.getSubject().getValue(), localId, "syncFailed");

  }

}