Metacat

/**

 *  '$RCSfile$'

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

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author: leinfelder $'

 *     '$Date: 2012-02-07 16:53:22 -0800 (Tue, 07 Feb 2012) $'

 *

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

import java.io.ByteArrayInputStream;

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

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

import org.jibx.runtime.JiBXException;

import org.xml.sax.SAXException;

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

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

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

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

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

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

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

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

                    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 (resource.startsWith(RESOURCE_FORMATS)) {

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

                    // after the command

                    extra = parseTrailing(resource, RESOURCE_FORMATS);

                    // 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(RESOURCE_CHECKSUM)) {

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

                    // after the command

                    extra = parseTrailing(resource, RESOURCE_CHECKSUM);

                    // handle checksum requests

                    if (httpVerb == GET) {

                        checksum(extra);

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

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

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

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

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

                        logMetacat.debug("processing ping request");

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

                        // TODO: send to output	

                        status = true;

                    }

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

                    if (httpVerb == GET) {

                        listChecksumAlgorithms();

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

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

                    setObsoletedBy(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 JiBXException

     */

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

            NotAuthorized, NotFound, InvalidRequest, NotImplemented,

            JiBXException, 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 JiBXException

     */

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

            InvalidRequest, NotImplemented, IOException, JiBXException {

        Date fromDate = null;

        Date toDate = null;

        Event event = null;

        Integer start = null;

        Integer count = 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());

        }

        logMetacat.debug("calling getLogRecords");

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

                fromDate, toDate, event, 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 content type

        if (sm.getFormatId()

                .getValue()

                .trim()

                .equals(ObjectFormatCache.getInstance().getFormat("text/csv")

                        .getFormatId().getValue())) {

            response.setContentType("text/csv");

            response.setHeader("Content-Disposition",

                    "inline; filename=" + id.getValue() + ".csv");

        } else if (sm

                .getFormatId()

                .getValue()

                .trim()

                .equals(ObjectFormatCache.getInstance().getFormat("text/plain")

                        .getFormatId().getValue())) {

            response.setContentType("text/plain");

            response.setHeader("Content-Disposition",

                    "inline; filename=" + id.getValue() + ".txt");

        } else if (sm

                .getFormatId()

                .getValue()

                .trim()

                .equals(ObjectFormatCache.getInstance()

                        .getFormat("application/octet-stream").getFormatId()

                        .getValue())) {

            response.setContentType("application/octet-stream");

        } else {

            response.setContentType("text/xml");

            response.setHeader("Content-Disposition",

                    "inline; filename=" + id.getValue() + ".xml");

        }

        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 JiBXException

     */

    protected void getSystemMetadataObject(String guid) throws InvalidToken,

            ServiceFailure, NotAuthorized, NotFound, InvalidRequest,

            NotImplemented, IOException, JiBXException {

        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 JiBXException

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

     */

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

            InsufficientResources, NotImplemented, IOException, JiBXException {

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

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

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

		// style the object with a processing directive

		String stylesheet = null;

		try {

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

		} catch (PropertyNotFoundException e) {

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

					+ e.getMessage());

		}

		TypeMarshaller.marshalTypeToOutputStream(result, out, stylesheet);

	}

    /**

     * 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.setStatus(200);

        response.setContentType("text/xml");

        Identifier id = new Identifier();

        id.setValue(pid);

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

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

    }

    /**

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

     */

    private void getFormat(String fmtidStr) throws InvalidRequest,

            ServiceFailure, NotFound, InsufficientResources, NotImplemented,

            IOException, JiBXException {

        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

     * @throws IOException

     * @throws JiBXException

     */

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

            IdentifierNotUnique, NotImplemented, InvalidRequest, IOException,

            JiBXException {

        Identifier pid = null;

        String scope = null;

        String format = null;

        // gather the params

        try {

            String id = params.get("pid")[0];

            pid = new Identifier();

            pid.setValue(id);

        } catch (Exception e) {

            logMetacat.warn("pid not specified");

        }

        try {

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

        } catch (Exception e) {

            logMetacat.warn("pid not specified");

        }

        try {

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

        } catch (Exception e) {

            logMetacat.warn("pid not specified");

        }

        // call the implementation

        Identifier resultPid = CNodeService.getInstance(request)

                .reserveIdentifier(session, pid);

        OutputStream out = response.getOutputStream();

        response.setStatus(200);

        response.setContentType("text/xml");

        // send back the reserved pid

        TypeMarshaller.marshalTypeToOutputStream(resultPid, out);

    }

    /**

     * 

     * @param id

     * @throws InvalidRequest

     * @throws InvalidToken

     * @throws ServiceFailure

     * @throws NotAuthorized

     * @throws NotFound

     * @throws NotImplemented

     * @throws IOException

     * @throws JiBXException

     */

    private void resolve(String id) throws InvalidRequest, InvalidToken,

            ServiceFailure, NotAuthorized, NotFound, NotImplemented,

            IOException, JiBXException {

        Identifier pid = new Identifier();

        pid.setValue(id);

        ObjectLocationList locationList = CNodeService.getInstance(request)

                .resolve(session, pid);

        OutputStream out = response.getOutputStream();

        response.setStatus(200);

        response.setContentType("text/xml");

        TypeMarshaller.marshalTypeToOutputStream(locationList, out);

    }

    /**

     * Set the owner of a resource

     * 

     * @param id

     * @throws JiBXException

     * @throws InvalidToken

     * @throws ServiceFailure

     * @throws NotFound

     * @throws NotAuthorized

     * @throws NotImplemented

     * @throws InvalidRequest

     * @throws IOException

     * @throws IllegalAccessException

     * @throws InstantiationException

     * @throws VersionMismatch 

     */

    private void owner(String id) throws JiBXException, InvalidToken,

            ServiceFailure, NotFound, NotAuthorized, NotImplemented,

            InvalidRequest, IOException, InstantiationException,

            IllegalAccessException, VersionMismatch {

        Identifier pid = new Identifier();

        pid.setValue(id);

        long serialVersion = 0L;

        String serialVersionStr = null;

        // get the serialVersion

        try {

            serialVersionStr = params.get("serialVersion")[0];

            serialVersion = new Long(serialVersionStr).longValue();

        } catch (NullPointerException e) {

            String msg = "The 'serialVersion' must be provided as a parameter and was not.";

            logMetacat.error(msg);

            throw new InvalidRequest("4442", msg);

        }

        // get the subject

        String subjectStr = params.get("subject")[0];

        Subject subject = TypeMarshaller.unmarshalTypeFromStream(Subject.class,

                new ByteArrayInputStream(subjectStr.getBytes("UTF-8")));

        Identifier retPid = CNodeService.getInstance(request).setRightsHolder(session, pid, subject, serialVersion);

        OutputStream out = response.getOutputStream();

        response.setStatus(200);

        response.setContentType("text/xml");

        TypeMarshaller.marshalTypeToOutputStream(retPid, out);

    }