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.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.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, "create");

      } 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 {

		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 {

		return null;

	}

	/**

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

		return null;

	}

  /**

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

		return true;

	}

  /**

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

  }

}