Metacat

/**

 *  '$RCSfile$'

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

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author: tao $'

 *     '$Date: 2016-11-28 11:40:33 -0800 (Mon, 28 Nov 2016) $'

 *

 * 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.restservice.v1;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.Date;

import java.util.Enumeration;

import java.util.Map;

import javax.servlet.ServletContext;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.xml.parsers.ParserConfigurationException;

import org.apache.commons.fileupload.FileUploadException;

import org.apache.commons.io.IOUtils;

import org.apache.log4j.Logger;

import org.dataone.client.v2.formats.ObjectFormatInfo;

import org.dataone.exceptions.MarshallingException;

import org.dataone.service.exceptions.BaseException;

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.UnsupportedType;

import org.dataone.service.exceptions.VersionMismatch;

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

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

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

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

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

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

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

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.ObjectFormatList;

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

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

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 org.dataone.service.util.Constants;

import org.dataone.service.util.DateTimeMarshaller;

import org.dataone.service.util.EncodingUtilities;

import org.dataone.service.util.ExceptionHandler;

import org.dataone.service.util.TypeMarshaller;

import org.xml.sax.SAXException;

import edu.ucsb.nceas.metacat.dataone.v1.CNodeService;

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

import edu.ucsb.nceas.metacat.restservice.D1HttpRequest;

import edu.ucsb.nceas.metacat.restservice.D1ResourceHandler;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

/**

 * CN REST service implementation handler

 * 

 * ****************** CNCore -- DONE create() - POST /d1/cn/object/PID

 * listFormats() - GET /d1/cn/formats getFormat() - GET /d1/cn/formats/FMTID

 * getLogRecords - GET /d1/cn/log reserveIdentifier() - POST /d1/cn/reserve

 * listNodes() - Not implemented registerSystemMetadata() - POST /d1/meta/PID

 * 

 * CNRead -- DONE get() - GET /d1/cn/object/PID getSystemMetadata() - GET

 * /d1/cn/meta/PID resolve() - GET /d1/cn/resolve/PID assertRelation() - GET

 * /d1/cn/assertRelation/PID getChecksum() - GET /d1/cn/checksum search() - Not

 * implemented in Metacat

 * 

 * CNAuthorization setOwner() - PUT /d1/cn/owner/PID isAuthorized() - GET

 * /d1/cn/isAuthorized/PID setAccessPolicy() - POST /d1/cn/accessRules

 * 

 * CNIdentity - not implemented at all on Metacat

 * 

 * CNReplication setReplicationStatus() - PUT /replicaNotifications/PID

 * updateReplicationMetadata() - PUT /replicaMetadata/PID setReplicationPolicy()

 * - PUT /replicaPolicies/PID isNodeAuthorized() - GET

 * /replicaAuthorizations/PID

 * 

 * CNRegister -- not implemented at all in Metacat ******************

 * 

 * @author leinfelder

 * 

 */

public class CNResourceHandler extends D1ResourceHandler {

    /** CN-specific operations **/

    protected static final String RESOURCE_RESERVE = "reserve";

    protected static final String RESOURCE_FORMATS = "formats";

    protected static final String RESOURCE_RESOLVE = "resolve";

    protected static final String RESOURCE_OWNER = "owner";

    protected static final String RESOURCE_REPLICATION_POLICY = "replicaPolicies";

    protected static final String RESOURCE_REPLICATION_META = "replicaMetadata";

    protected static final String RESOURCE_REPLICATION_AUTHORIZED = "replicaAuthorizations";

    protected static final String RESOURCE_REPLICATION_NOTIFY = "replicaNotifications";

    public CNResourceHandler(ServletContext servletContext,

            HttpServletRequest request, HttpServletResponse response) {

        super(servletContext, request, response);

        logMetacat = Logger.getLogger(CNResourceHandler.class);

    }

    /**

     * This function is called from REST API servlet and handles each request to

     * the servlet

     * 

     * @param httpVerb

     *            (GET, POST, PUT or DELETE)

     */

    @Override

    public void handle(byte httpVerb) {

        // prepare the handler

        super.handle(httpVerb);

        try {

        	// only service requests if we have D1 configured

        	if (!isD1Enabled()) {

        		ServiceFailure se = new ServiceFailure("0000", "DataONE services are not enabled on this node");

                serializeException(se, response.getOutputStream());

                return;

        	}

            // get the resource

            String resource = request.getPathInfo();

            resource = resource.substring(resource.indexOf("/") + 1);

            // for the rest of the resouce

            String extra = null;

            logMetacat.debug("handling verb " + httpVerb

                    + " request with resource '" + resource + "'");

            boolean status = false;

            if (resource != null) {

                if (resource.startsWith(RESOURCE_ACCESS_RULES)

                        && httpVerb == PUT) {

                    logMetacat.debug("Setting access policy");

                    // after the command

                    extra = parseTrailing(resource, RESOURCE_ACCESS_RULES);

                    extra = decode(extra);

                    setAccess(extra);

                    status = true;

                    logMetacat.debug("done setting access");

                } else if (resource.startsWith(RESOURCE_META)) {

                    logMetacat.debug("Using resource: " + RESOURCE_META);

                    // after the command

                    extra = parseTrailing(resource, RESOURCE_META);

                    extra = decode(extra);

                    // get

                    if (httpVerb == GET) {

                        getSystemMetadataObject(extra);

                        status = true;

                    }

                    // post to register system metadata

                    if (httpVerb == POST) {

                        registerSystemMetadata();

                        status = true;

                    }

                } else if (resource.startsWith(RESOURCE_RESERVE)) {

                    // reserve the ID (in params)

                    if (httpVerb == POST) {

                        reserve();

                        status = true;

                    }

                } else if (resource.startsWith(RESOURCE_RESOLVE)) {

                    // after the command

                    extra = parseTrailing(resource, RESOURCE_RESOLVE);

                    extra = decode(extra);

                    // resolve the object location

                    if (httpVerb == GET) {

                        resolve(extra);

                        status = true;

                    }

                } else if (resource.startsWith(RESOURCE_OWNER)) {

                    // after the command

                    extra = parseTrailing(resource, RESOURCE_OWNER);

                    extra = decode(extra);

                    // set the owner

                    if (httpVerb == PUT) {

                        owner(extra);

                        status = true;

                    }

                } else if (resource.startsWith(RESOURCE_IS_AUTHORIZED)) {

                    // after the command

                    extra = parseTrailing(resource, RESOURCE_IS_AUTHORIZED);

                    extra = decode(extra);

                    // authorized?

                    if (httpVerb == GET) {

                        isAuthorized(extra);

                        status = true;

                    }

                } else if (resource.startsWith(RESOURCE_OBJECTS)) {

                    logMetacat.debug("Using resource 'object'");

                    logMetacat

                            .debug("D1 Rest: Starting resource processing...");

                    // after the command

                    extra = parseTrailing(resource, RESOURCE_OBJECTS);

                    extra = decode(extra);

                    logMetacat.debug("objectId: " + extra);

                    logMetacat.debug("verb:" + httpVerb);

                    if (httpVerb == GET) {

                        if (extra != null) {

                            getObject(extra);

                        } else {

                            listObjects();

                        }

                        status = true;

                    } else if (httpVerb == POST) {

                        putObject(FUNCTION_NAME_INSERT);

                        status = true;

                    } else if (httpVerb == HEAD) {

                        describeObject(extra);

                        status = true;

                    } else if (httpVerb == DELETE) {

                        deleteObject(extra);

                        status = true;

                    } 

                } else if (resource.startsWith(RESOURCE_FORMATS)) {

                    logMetacat.debug("Using resource: " + RESOURCE_FORMATS);

                    // after the command

                    extra = parseTrailing(resource, RESOURCE_FORMATS);

                    extra = decode(extra);

                    // handle each verb

                    if (httpVerb == GET) {

                        if (extra == null) {

                            // list the formats collection

                            listFormats();

                        } else {

                            // get the specified format

                            getFormat(extra);

                        }

                        status = true;

                    }

                } else if (resource.startsWith(RESOURCE_LOG)) {

                    logMetacat.debug("Using resource: " + RESOURCE_LOG);

                    // handle log events

                    if (httpVerb == GET) {

                        getLog();

                        status = true;

                    }

                } else if (resource.startsWith(Constants.RESOURCE_ARCHIVE)) {

                    logMetacat.debug("Using resource " + Constants.RESOURCE_ARCHIVE);

                    // handle archive events

                    if (httpVerb == PUT) {

                        extra = parseTrailing(resource, Constants.RESOURCE_ARCHIVE);

                        extra = decode(extra);

                        archive(extra);

                        status = true;

                    }

                } else if (resource.startsWith(Constants.RESOURCE_CHECKSUM)) {

                    logMetacat.debug("Using resource: " + Constants.RESOURCE_CHECKSUM);

                    // after the command

                    extra = parseTrailing(resource, Constants.RESOURCE_CHECKSUM);

                    extra = decode(extra);

                    // handle checksum requests

                    if (httpVerb == GET) {

                    	if (extra != null && extra.length() > 0) {

	                        checksum(extra);

	                        status = true;

                    	} else {

                    		listChecksumAlgorithms();

                    		status = true;

                    	}

                    }

                } else if (resource.startsWith(RESOURCE_REPLICATION_POLICY)

                        && httpVerb == PUT) {

                    logMetacat.debug("Using resource: "

                            + RESOURCE_REPLICATION_POLICY);

                    // get the trailing pid

                    extra = parseTrailing(resource, RESOURCE_REPLICATION_POLICY);

                    extra = decode(extra);

                    setReplicationPolicy(extra);

                    status = true;

                } else if (resource.startsWith(RESOURCE_REPLICATION_META)

                        && httpVerb == PUT) {

                    logMetacat.debug("Using resource: "

                            + RESOURCE_REPLICATION_META);

                    // get the trailing pid

                    extra = parseTrailing(resource, RESOURCE_REPLICATION_META);

                    extra = decode(extra);

                    updateReplicationMetadata(extra);

                    status = true;

                } else if (resource.startsWith(RESOURCE_REPLICATION_NOTIFY)

                        && httpVerb == PUT) {

                    logMetacat.debug("Using resource: "

                            + RESOURCE_REPLICATION_NOTIFY);

                    // get the trailing pid

                    extra = parseTrailing(resource, RESOURCE_REPLICATION_NOTIFY);

                    extra = decode(extra);

                    setReplicationStatus(extra);

                    status = true;

                } else if (resource.startsWith(RESOURCE_REPLICATION_AUTHORIZED)

                        && httpVerb == GET) {

                    logMetacat.debug("Using resource: "

                            + RESOURCE_REPLICATION_AUTHORIZED);

                    // get the trailing pid

                    extra = parseTrailing(resource,

                            RESOURCE_REPLICATION_AUTHORIZED);

                    extra = decode(extra);

                    isNodeAuthorized(extra);

                    status = true;

                } else if (resource.startsWith(Constants.RESOURCE_MONITOR_PING)) {

                    if (httpVerb == GET) {

                    	// after the command

                        extra = parseTrailing(resource, Constants.RESOURCE_MONITOR_PING);

                        extra = decode(extra);

                        logMetacat.debug("processing ping request");

                        Date result = CNodeService.getInstance(request).ping();

                        // TODO: send to output	

                        status = true;

                    }

                } else if (resource.startsWith(Constants.RESOURCE_META_OBSOLETEDBY)

                        && httpVerb == PUT) {

                    logMetacat.debug("Using resource: "

                            + Constants.RESOURCE_META_OBSOLETEDBY);

                    // get the trailing pid

                    extra = parseTrailing(resource, Constants.RESOURCE_META_OBSOLETEDBY);

                    extra = decode(extra);

                    setObsoletedBy(extra);

                    status = true;

                } else if (resource.startsWith(Constants.RESOURCE_REPLICATION_DELETE_REPLICA)

                        && httpVerb == PUT) {

                    logMetacat.debug("Using resource: "

                            + Constants.RESOURCE_REPLICATION_DELETE_REPLICA);

                    // get the trailing pid

                    extra = parseTrailing(resource, Constants.RESOURCE_REPLICATION_DELETE_REPLICA);

                    extra = decode(extra);

                    deleteReplica(extra);

                    status = true;

                }

                if (!status) {

                    throw new ServiceFailure("0000", "Unknown error, status = "

                            + status);

                }

            } else {

                throw new InvalidRequest("0000", "No resource matched for "

                        + resource);

            }

        } catch (BaseException be) {

            // report Exceptions as clearly and generically as possible

            OutputStream out = null;

            try {

                out = response.getOutputStream();

            } catch (IOException ioe) {

                logMetacat.error("Could not get output stream from response",

                        ioe);

            }

            serializeException(be, out);

        } catch (Exception e) {

            // report Exceptions as clearly and generically as possible

            logMetacat.error(e.getClass() + ": " + e.getMessage(), e);

            OutputStream out = null;

            try {

                out = response.getOutputStream();

            } catch (IOException ioe) {

                logMetacat.error("Could not get output stream from response",

                        ioe);

            }

            ServiceFailure se = new ServiceFailure("0000", e.getMessage());

            serializeException(se, out);

        }

    }

    /**

     * Get the checksum for the given guid

     * 

     * @param guid

     * @throws NotImplemented

     * @throws InvalidRequest

     * @throws NotFound

     * @throws NotAuthorized

     * @throws ServiceFailure

     * @throws InvalidToken

     * @throws IOException

     * @throws MarshallingException

     */

    private void checksum(String guid) throws InvalidToken, ServiceFailure,

            NotAuthorized, NotFound, InvalidRequest, NotImplemented,

            MarshallingException, IOException {

        Identifier guidid = new Identifier();

        guidid.setValue(guid);

        logMetacat.debug("getting checksum for object " + guid);

        Checksum c = CNodeService.getInstance(request).getChecksum(session,

                guidid);

        logMetacat.debug("got checksum " + c.getValue());

        response.setStatus(200);

        logMetacat.debug("serializing response");

        TypeMarshaller.marshalTypeToOutputStream(c, response.getOutputStream());

        logMetacat.debug("done serializing response.");

    }

    /**

     * get the logs based on passed params. Available params are token,

     * fromDate, toDate, event. See

     * http://mule1.dataone.org/ArchitectureDocs/mn_api_crud

     * .html#MN_crud.getLogRecords for more info

     * 

     * @throws NotImplemented

     * @throws InvalidRequest

     * @throws NotAuthorized

     * @throws ServiceFailure

     * @throws InvalidToken

     * @throws IOException

     * @throws MarshallingException

     * @throws InsufficientResources 

     */

    private void getLog() throws InvalidToken, ServiceFailure, NotAuthorized,

            InvalidRequest, NotImplemented, IOException, MarshallingException, InsufficientResources {

        Date fromDate = null;

        Date toDate = null;

        Event event = null;

        Integer start = null;

        Integer count = null;

        String pidFilter = null;

        try {

            String fromDateS = params.get("fromDate")[0];

            logMetacat.debug("param fromDateS: " + fromDateS);

            fromDate = DateTimeMarshaller.deserializeDateToUTC(fromDateS);

        } catch (Exception e) {

            logMetacat.warn("Could not parse fromDate: " + e.getMessage());

        }

        try {

            String toDateS = params.get("toDate")[0];

            logMetacat.debug("param toDateS: " + toDateS);

            toDate = DateTimeMarshaller.deserializeDateToUTC(toDateS);

        } catch (Exception e) {

            logMetacat.warn("Could not parse toDate: " + e.getMessage());

        }

        try {

            String eventS = params.get("event")[0];

            event = Event.convert(eventS);

        } catch (Exception e) {

            logMetacat.warn("Could not parse event: " + e.getMessage());

        }

        logMetacat.debug("fromDate: " + fromDate + " toDate: " + toDate);

        try {

            start = Integer.parseInt(params.get("start")[0]);

        } catch (Exception e) {

            logMetacat.warn("Could not parse start: " + e.getMessage());

        }

        try {

            count = Integer.parseInt(params.get("count")[0]);

        } catch (Exception e) {

            logMetacat.warn("Could not parse count: " + e.getMessage());

        }

        try {

            pidFilter = params.get("pidFilter")[0];

        } catch (Exception e) {

            logMetacat.warn("Could not parse pidFilter: " + e.getMessage());

        }

        logMetacat.debug("calling getLogRecords");

        Log log = CNodeService.getInstance(request).getLogRecords(session,

                fromDate, toDate, event, pidFilter, start, count);

        OutputStream out = response.getOutputStream();

        response.setStatus(200);

        response.setContentType("text/xml");

        TypeMarshaller.marshalTypeToOutputStream(log, out);

    }

    /**

     * Implements REST version of DataONE CRUD API --> get

     * 

     * @param guid

     *            ID of data object to be read

     * @throws NotImplemented

     * @throws InvalidRequest

     * @throws NotFound

     * @throws NotAuthorized

     * @throws ServiceFailure

     * @throws InvalidToken

     * @throws IOException

     */

    protected void getObject(String guid) throws InvalidToken, ServiceFailure,

            NotAuthorized, NotFound, InvalidRequest, NotImplemented,

            IOException {

        Identifier id = new Identifier();

        id.setValue(guid);

        SystemMetadata sm = CNodeService.getInstance(request)

                .getSystemMetadata(session, id);

        // set the headers for the content

        String mimeType = ObjectFormatInfo.instance().getMimeType(sm.getFormatId().getValue());

        if (mimeType == null) {

        	mimeType = "application/octet-stream";

        }

        String extension = ObjectFormatInfo.instance().getExtension(sm.getFormatId().getValue());

        String filename = id.getValue();

        if (extension != null && filename != null && !filename.endsWith(extension)) {

        	filename = id.getValue() + extension;

        }

        response.setContentType(mimeType);

        response.setHeader("Content-Disposition", "inline; filename=" + filename);

        InputStream data = CNodeService.getInstance(request).get(session, id);

        OutputStream out = response.getOutputStream();

        response.setStatus(200);

        IOUtils.copyLarge(data, out);

    }

    /**

     * Implements REST version of DataONE CRUD API --> getSystemMetadata

     * 

     * @param guid

     *            ID of data object to be read

     * @throws NotImplemented

     * @throws InvalidRequest

     * @throws NotFound

     * @throws NotAuthorized

     * @throws ServiceFailure

     * @throws InvalidToken

     * @throws IOException

     * @throws MarshallingException

     */

    protected void getSystemMetadataObject(String guid) throws InvalidToken,

            ServiceFailure, NotAuthorized, NotFound, InvalidRequest,

            NotImplemented, IOException, MarshallingException {

        Identifier id = new Identifier();

        id.setValue(guid);

        SystemMetadata sysmeta = CNodeService.getInstance(request)

                .getSystemMetadata(session, id);

        response.setContentType("text/xml");

        response.setStatus(200);

        OutputStream out = response.getOutputStream();

        // Serialize and write it to the output stream

        TypeMarshaller.marshalTypeToOutputStream(sysmeta, out);

    }

    /**

     * Earthgrid API > Put Service >Put Function : calls MetacatHandler >

     * handleInsertOrUpdateAction

     * 

     * @param guid

     *            - ID of data object to be inserted or updated. If action is

     *            update, the pid is the existing pid. If insert, the pid is the

     *            new one

     * @throws InvalidRequest

     * @throws ServiceFailure

     * @throws IdentifierNotUnique

     * @throws MarshallingException

     * @throws NotImplemented

     * @throws InvalidSystemMetadata

     * @throws InsufficientResources

     * @throws UnsupportedType

     * @throws NotAuthorized

     * @throws InvalidToken

     * @throws IOException

     * @throws IllegalAccessException

     * @throws InstantiationException

     */

    protected void putObject(String action) throws ServiceFailure,

            InvalidRequest, IdentifierNotUnique, MarshallingException, InvalidToken,

            NotAuthorized, UnsupportedType, InsufficientResources,

            InvalidSystemMetadata, NotImplemented, IOException,

            InstantiationException, IllegalAccessException {

        // Read the incoming data from its Mime Multipart encoding

        Map<String, File> files = collectMultipartFiles();

	    // get the encoded pid string from the body and make the object

        String pidString = multipartparams.get("pid").get(0);

        Identifier pid = new Identifier();

        pid.setValue(pidString);

        logMetacat.debug("putObject: " + pid.getValue() + "/" + action);

        InputStream object = null;

        InputStream sysmeta = null;

        File smFile = files.get("sysmeta");

        sysmeta = new FileInputStream(smFile);

        File objFile = files.get("object");

        object = new FileInputStream(objFile);

        if (action.equals(FUNCTION_NAME_INSERT)) { // handle inserts

            logMetacat.debug("Commence creation...");

            SystemMetadata smd = TypeMarshaller.unmarshalTypeFromStream(

                    SystemMetadata.class, sysmeta);

            logMetacat.debug("creating object with pid " + pid.getValue());

            Identifier rId = CNodeService.getInstance(request).create(session, pid, object, smd);

            OutputStream out = response.getOutputStream();

            response.setStatus(200);

            response.setContentType("text/xml");

            TypeMarshaller.marshalTypeToOutputStream(rId, out);

        } else {

            throw new InvalidRequest("1000", "Operation must be create.");

        }

    }

    /**

     * List the object formats registered with the system

     * 

     * @throws NotImplemented

     * @throws InsufficientResources

     * @throws NotFound

     * @throws ServiceFailure

     * @throws InvalidRequest

     * @throws IOException

     * @throws MarshallingException

     */

    private void listFormats() throws InvalidRequest, ServiceFailure, NotFound,

            InsufficientResources, NotImplemented, IOException, MarshallingException {

        logMetacat.debug("Entering listFormats()");

        ObjectFormatList objectFormatList = CNodeService.getInstance(request)

                .listFormats();

        // get the response output stream

        OutputStream out = response.getOutputStream();

        response.setStatus(200);

        response.setContentType("text/xml");

        // style the object with a processing directive

        String stylesheet = null;

        try {

            stylesheet = PropertyService.getProperty("dataone.types.xsl.v1");

        } catch (PropertyNotFoundException e) {

            logMetacat.warn("Could not locate DataONE types XSLT: "

                    + e.getMessage());

        }

        TypeMarshaller.marshalTypeToOutputStream(objectFormatList, out,

                stylesheet);

    }

    private void listChecksumAlgorithms() throws IOException, ServiceFailure,

			NotImplemented, MarshallingException {

		logMetacat.debug("Entering listFormats()");

		ChecksumAlgorithmList result = CNodeService.getInstance(request).listChecksumAlgorithms();

		// get the response output stream

		OutputStream out = response.getOutputStream();

		response.setStatus(200);

		response.setContentType("text/xml");

		TypeMarshaller.marshalTypeToOutputStream(result, out);

	}

    /**

     * http://mule1.dataone.org/ArchitectureDocs-current/apis/CN_APIs.html#CNRead.describe

     * @param pid

     * @throws InvalidToken

     * @throws ServiceFailure

     * @throws NotAuthorized

     * @throws NotFound

     * @throws NotImplemented

     * @throws InvalidRequest

     */

    private void describeObject(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, InvalidRequest

    {

        response.setContentType("text/xml");

        Identifier id = new Identifier();

        id.setValue(pid);

        DescribeResponse dr = null;

        try {

            dr = CNodeService.getInstance(request).describe(session, id);

        } catch (BaseException e) {

        	response.setStatus(e.getCode());

        	response.addHeader("DataONE-Exception-Name", e.getClass().getName());

            response.addHeader("DataONE-Exception-DetailCode", e.getDetail_code());

            response.addHeader("DataONE-Exception-Description", e.getDescription());

            response.addHeader("DataONE-Exception-PID", id.getValue());

            return;

		}

        response.setStatus(200);

        //response.addHeader("pid", pid);

        response.addHeader("DataONE-Checksum", dr.getDataONE_Checksum().getAlgorithm() + "," + dr.getDataONE_Checksum().getValue());

        response.addHeader("Content-Length", dr.getContent_Length() + "");

        response.addHeader("Last-Modified", DateTimeMarshaller.serializeDateToUTC(dr.getLast_Modified()));

        response.addHeader("DataONE-ObjectFormat", dr.getDataONE_ObjectFormatIdentifier().getValue());

        response.addHeader("DataONE-SerialVersion", dr.getSerialVersion().toString());

    }

    /**

     * Handle delete 

     * @param pid ID of data object to be deleted

     * @throws IOException

     * @throws InvalidRequest 

     * @throws NotImplemented 

     * @throws NotFound 

     * @throws NotAuthorized 

     * @throws ServiceFailure 

     * @throws InvalidToken 

     * @throws MarshallingException 

     */

    private void deleteObject(String pid) throws IOException, InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, InvalidRequest, MarshallingException 

    {

        OutputStream out = response.getOutputStream();

        response.setStatus(200);

        response.setContentType("text/xml");

        Identifier id = new Identifier();

        id.setValue(pid);

        logMetacat.debug("Calling delete for identifier " + pid);

        CNodeService.getInstance(request).delete(session, id);

        TypeMarshaller.marshalTypeToOutputStream(id, out);

    }

    /**

     * Archives the given pid

     * @param pid

     * @throws InvalidToken

     * @throws ServiceFailure

     * @throws NotAuthorized

     * @throws NotFound

     * @throws NotImplemented

     * @throws IOException

     * @throws MarshallingException

     * @throws InvalidRequest 

     */

    private void archive(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, IOException, MarshallingException, InvalidRequest {

        OutputStream out = response.getOutputStream();

        response.setStatus(200);

        response.setContentType("text/xml");

        Identifier id = new Identifier();

        id.setValue(pid);

        logMetacat.debug("Calling archive");

        CNodeService.getInstance(request).archive(session, id);

        TypeMarshaller.marshalTypeToOutputStream(id, out);

    }

    /**

     * Return the requested object format

     * 

     * @param fmtidStr

     *            the requested format identifier as a string

     * @throws NotImplemented

     * @throws InsufficientResources

     * @throws NotFound

     * @throws ServiceFailure

     * @throws InvalidRequest

     * @throws IOException

     * @throws MarshallingException

     */

    private void getFormat(String fmtidStr) throws InvalidRequest,

            ServiceFailure, NotFound, InsufficientResources, NotImplemented,

            IOException, MarshallingException {

        logMetacat.debug("Entering listFormats()");

        ObjectFormatIdentifier fmtid = new ObjectFormatIdentifier();

        fmtid.setValue(fmtidStr);

        // get the specified object format

        ObjectFormat objectFormat = CNodeService.getInstance(request)

                .getFormat(fmtid);

        OutputStream out = response.getOutputStream();

        response.setStatus(200);

        response.setContentType("text/xml");

        TypeMarshaller.marshalTypeToOutputStream(objectFormat, out);

    }

    /**

     * Reserve the given Identifier

     * 

     * @throws InvalidToken

     * @throws ServiceFailure

     * @throws NotAuthorized

     * @throws IdentifierNotUnique

     * @throws NotImplemented

     * @throws InvalidRequest

     */

    private void reserve() 

        throws InvalidToken, ServiceFailure, NotAuthorized, IdentifierNotUnique, 

        NotImplemented, InvalidRequest {

        Identifier pid = null;

        String scope = null;

        String format = null;

        // Parse the params out of the multipart form data

        logMetacat.debug("Parsing reserve parameters from the mime multipart entity");

        try {

            collectMultipartParams();

        } catch (FileUploadException e1) {

            String msg = "FileUploadException: Couldn't parse the mime multipart information: " +

            e1.getMessage();

            logMetacat.debug(msg);

            throw new ServiceFailure("4210", msg);

        } catch (IOException e1) {

            String msg = "IOException: Couldn't parse the mime multipart information: " +

            e1.getMessage();

            logMetacat.debug(msg);

            throw new ServiceFailure("4210", msg);

        } catch (Exception e1) {

            String msg = "Exception: Couldn't parse the mime multipart information: " +

            e1.getMessage();

            logMetacat.debug(msg);

            throw new ServiceFailure("4210", msg);

        }

        // gather the params

        try {

            String id = multipartparams.get("pid").get(0);