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 org.dataone.client.MNode;

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.mn.tier1.v1.MNRead;

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

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

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

import org.dataone.service.types.v1.Checksum;

import org.dataone.service.types.v1.ChecksumAlgorithm;

import org.dataone.service.types.v1.DescribeResponse;

import org.dataone.service.types.v1.Event;

import org.dataone.service.types.v1.Group;

import org.dataone.service.types.v1.Identifier;

import org.dataone.service.types.v1.Log;

import org.dataone.service.types.v1.LogEntry;

import org.dataone.service.types.v1.MonitorInfo;

import org.dataone.service.types.v1.MonitorList;

import org.dataone.service.types.v1.Node;

import org.dataone.service.types.v1.NodeHealth;

import org.dataone.service.types.v1.NodeReference;

import org.dataone.service.types.v1.NodeState;

import org.dataone.service.types.v1.NodeType;

import org.dataone.service.types.v1.ObjectFormat;

import org.dataone.service.types.v1.ObjectFormatIdentifier;

import org.dataone.service.types.v1.ObjectList;

import org.dataone.service.types.v1.Permission;

import org.dataone.service.types.v1.Ping;

import org.dataone.service.types.v1.Schedule;

import org.dataone.service.types.v1.Service;

import org.dataone.service.types.v1.Services;

import org.dataone.service.types.v1.Session;

import org.dataone.service.types.v1.Status;

import org.dataone.service.types.v1.Subject;

import org.dataone.service.types.v1.Synchronization;

import org.dataone.service.types.v1.SystemMetadata;

import org.dataone.service.types.v1.util.ChecksumUtil;

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

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

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.

 * Implements:

 * MNCore.ping()

 * MNCore.getLogRecords()

 * MNCore.getObjectStatistics()

 * MNCore.getOperationStatistics()

 * MNCore.getStatus()

 * MNCore.getCapabilities()

 * MNRead.get()

 * MNRead.getSystemMetadata()

 * MNRead.describe()

 * MNRead.getChecksum()

 * MNRead.listObjects()

 * MNRead.synchronizationFailed()

 * MNAuthorization.isAuthorized()

 * MNAuthorization.setAccessPolicy()

 * MNStorage.create()

 * MNStorage.update()

 * MNStorage.delete()

 * MNReplication.replicate()

 *

public class MNodeService extends D1NodeService implements MNAuthorization,

  MNCore, MNRead, MNReplication, MNStorage {

  /* the logger instance */

  private Logger logMetacat = null;

  /**

   *

   * @return instance - the instance of MNodeService

    return instance;

  }

  /**

   * Constructor, private for singleton access

   */

  }

   * 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

   */

    NotImplemented, InvalidRequest {

    boolean allowed = false;

    String[] groupnames = null;

    if (session != null ) {

    	username = session.getSubject().getValue();

    	if (session.getSubjectList() != null) {

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

    		if (groupList != null) {

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

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

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

    			}

    		}

    	}

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

    } catch (McdbDocNotFoundException e) {

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

    }

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

        EventLog.getInstance().log(metacatUrl, username, localId, Event.DELETE.toString());

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

      } catch (SQLException e) {

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

      } 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." +

      }

    } else {

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

  }

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

    Identifier newPid, SystemMetadata sysmeta)

    UnsupportedType, InsufficientResources, NotFound, InvalidSystemMetadata,

    NotImplemented, InvalidRequest {

	// check if the pid has been reserved

	try {

		boolean hasReservation = D1Client.getCN().hasReservation(session, pid);

		if (!hasReservation) {

			throw new NotAuthorized("", "No reservation for pid: " + pid.getValue());

		}

	} catch (NotFound e) {

		// okay to continue

	}

    boolean allowed = false;

    boolean isScienceMetadata = false;

    Subject subject = session.getSubject();

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

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

    try {

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

        "identifier was not found.");

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

      // get the existing system metadata for the object

      SystemMetadata existingSysMeta = getSystemMetadata(session, pid);

      // then update the existing system metadata

      updateSystemMetadata(existingSysMeta);

      // prep the new system metadata, add pid to the affected lists

      //sysmeta.addDerivedFrom(pid);

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

          }

        } catch (IOException e) {

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

        }

      } else {

        // update the data object

        localId = insertDataObject(object, newPid, session);

      }

      // log the update event

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

      "permission to UPDATE the object identified by " +

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

    }

  public Identifier create(Session session, Identifier pid,

			InputStream object, SystemMetadata sysmeta) throws InvalidToken,

			ServiceFailure, NotAuthorized, IdentifierNotUnique,

			UnsupportedType, InsufficientResources, InvalidSystemMetadata,

			NotImplemented, InvalidRequest {

		try {

			boolean hasReservation = D1Client.getCN().hasReservation(session, pid);

			if (!hasReservation) {

				throw new NotAuthorized("", "No reservation for pid: " + pid.getValue());

			}

		} catch (NotFound e) {

			// okay to continue

		}

		return super.create(session, pid, object, sysmeta);

	}

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

    NodeReference sourceNode)

    throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest,

    InsufficientResources, UnsupportedType {

    // TODO: check credentials

    // get the referenced object

    Identifier pid = sysmeta.getIdentifier();

    // get from the membernode

    // TODO: switch credentials for the server retrieval?

    MNode mn = D1Client.getMN(sourceNode);

    InputStream object = null;

	try {

		object = mn.get(session, pid);

	} catch (InvalidToken e) {

		e.printStackTrace();

		throw new ServiceFailure("2151", "Could not retrieve object to replicate (InvalidToken): " + e.getMessage());

	} catch (NotFound e) {

		e.printStackTrace();

		throw new ServiceFailure("2151", "Could not retrieve object to replicate (NotFound): " + e.getMessage());

	}

    // add it to local store

	Identifier retPid;

	try {

		retPid = create(session, pid, object, sysmeta);

		result = (retPid.getValue().equals(pid.getValue()));

	} catch (InvalidToken e) {

		e.printStackTrace();

		throw new ServiceFailure("2151", "Could not save object to local store (InvalidToken): " + e.getMessage());

	} catch (IdentifierNotUnique e) {

		e.printStackTrace();

		throw new ServiceFailure("2151", "Could not save object to local store (IdentifierNotUnique): " + e.getMessage());

	} catch (InvalidSystemMetadata e) {

		e.printStackTrace();

		throw new ServiceFailure("2151", "Could not save object to local store (InvalidSystemMetadata): " + e.getMessage());

	}

    return result;

  /**

   * This method provides a lighter weight mechanism than

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

   * properties of the referenced object.

   *

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

    throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,

    NotImplemented, InvalidRequest {

    }

    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 =

    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

   */

    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

   */

    throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,

    InvalidRequest, NotImplemented {

    try {

      checksum =

    } catch (NoSuchAlgorithmException e) {

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

    }

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

        pid.getValue() +

        "could not be returned.");

    }

  }

   * 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

   */

      throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,

      InvalidRequest, NotImplemented {

  }

   * 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

   */

    InvalidToken {

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

		throw new ServiceFailure("1580", "Error querying system metadata: " + e.getMessage());

	}

    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

   */

      ServiceFailure, InvalidRequest {

  	String nodeName = null;

    String nodeId = null;

    String nodeUrl = null;

    String nodeDesc = null;

    String nodeType = null;

    String mnReadServiceVersion = null;

    String mnAuthorizationServiceVersion = null;

    String mnStorageServiceVersion = null;

    String mnReplicationServiceVersion = null;

    boolean nodeReplicate = false;

    boolean mnReadServiceAvailable = false;

    boolean mnAuthorizationServiceAvailable = false;

    boolean mnStorageServiceAvailable = false;

    boolean mnReplicationServiceAvailable = false;

    {

      nodeName = PropertyService.getProperty("dataone.nodeName");

      nodeUrl = SystemUtil.getContextURL() + "/d1/";

      nodeDesc = PropertyService.getProperty("dataone.nodeDescription");

      nodeType = PropertyService.getProperty("dataone.nodeType");

      	new Boolean(PropertyService.getProperty(

      		"dataone.nodeSynchronize")).booleanValue();

      nodeReplicate =

      	new Boolean(PropertyService.getProperty(

      		"dataone.nodeReplicate")).booleanValue();

      mnCoreServiceAvailable = new Boolean(

      	PropertyService.getProperty(

      	PropertyService.getProperty(

      	PropertyService.getProperty(

      	PropertyService.getProperty(

        logMetacat.error("MNodeService.getCapabilities(): " +

          "property not found: " + pnfe.getMessage());

    }

    // calls to current status methods

	  node.setDescription(nodeDesc);

	  // set the node's health information

	  health.setState(state);

	  // set the ping response to the current value

	  Ping canPing = new Ping();

	  canPing.setSuccess(false);

	  try {

	    canPing.setSuccess(ping());

    } catch (InsufficientResources e) {

	    e.printStackTrace();

    } catch (UnsupportedType e) {

	    e.printStackTrace();

    }

	  health.setPing(canPing);

	  // TODO: getStatus() should be consulted here when it's implemented

	  Status nodeStatus = new Status();

	  nodeStatus.setSuccess(true);

	  nodeStatus.setDateChecked(new Date());

	  health.setStatus(nodeStatus);