Metacat

/**

 *  '$RCSfile$'

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

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author: leinfelder $'

 *     '$Date: 2011-06-30 15:05:43 -0700 (Thu, 30 Jun 2011) $'

 *

 * 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.io.PrintWriter;

import java.util.Date;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Timer;

import javax.servlet.ServletContext;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.io.IOUtils;

import org.apache.log4j.Logger;

import org.dataone.client.ObjectFormatCache;

import org.dataone.client.auth.CertificateManager;

import org.dataone.mimemultipart.MultipartRequest;

import org.dataone.mimemultipart.MultipartRequestResolver;

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.types.AccessPolicy;

import org.dataone.service.types.Checksum;

import org.dataone.service.types.Event;

import org.dataone.service.types.Identifier;

import org.dataone.service.types.Log;

import org.dataone.service.types.ObjectFormat;

import org.dataone.service.types.ObjectFormatIdentifier;

import org.dataone.service.types.ObjectFormatList;

import org.dataone.service.types.ObjectLocationList;

import org.dataone.service.types.Permission;

import org.dataone.service.types.Subject;

import org.dataone.service.types.SystemMetadata;

import org.jibx.runtime.BindingDirectory;

import org.jibx.runtime.IBindingFactory;

import org.jibx.runtime.IUnmarshallingContext;

import org.jibx.runtime.JiBXException;

import edu.ucsb.nceas.metacat.IdentifierManager;

import edu.ucsb.nceas.metacat.MetacatHandler;

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

/**

 * 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() - Not exposed

		updateReplicationMetadata() - New method?

		setReplicationPolicy() - Not exposed

	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"; //remove from super

    protected static final String RESOURCE_RESOLVE = "resolve";

    protected static final String RESOURCE_ASSERT_RELATION = "assertRelation";

    protected static final String RESOURCE_OWNER = "owner";

    protected static final String RESOURCE_NOTIFY = "notify";

    protected static final String RESOURCE_META_REPLICATION = "meta/replication";

    protected static final String RESOURCE_META_POLICY = "meta/policy";

    public CNResourceHandler(ServletContext servletContext,

			HttpServletRequest request, HttpServletResponse response) {

		super(servletContext, request, response);

        logMetacat = Logger.getLogger(CNResourceHandler.class);

	}

	/**

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

     * 

     * @param httpVerb (GET, POST, PUT or DELETE)

     */

    public void handle(byte httpVerb) {

        try {

            //substring off the "d1/cn/" part of the url

        	String resourcePrefix = RESOURCE_BASE_URL + "/cn/";

            String resource = request.getServletPath();

            resource = resource.substring(resource.indexOf(resourcePrefix) + resourcePrefix.length());

            resource = resource.trim();

            logMetacat.debug("handling verb " + httpVerb + " request with resource '" + resource + "'");

            boolean status = false;

            // load session from certificate in request

            // TODO: move to superclass

            session = CertificateManager.getInstance().getSession(request);

            if (resource != null) {

                params = new Hashtable<String, String[]>();

                initParams();

                Timer timer = new Timer();

                handler = new MetacatHandler(timer);

                if (resource.equals(RESOURCE_ACCESS_RULES) && httpVerb == PUT) {

                    logMetacat.debug("Setting access policy");

                    setaccess();

                    status = true;

                    logMetacat.debug("done setting access");

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

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

                    String objectId = request.getPathInfo();

                    if (objectId != null && objectId.length() > 1) {

                        objectId = request.getPathInfo().substring(1);

                    }

                    // get

                    if (httpVerb == GET) {

                        getSystemMetadataObject(objectId);

                        status = true;

                    }

                    // post to register system metadata

                    if (httpVerb == POST) {

                    	registerSystemMetadata(objectId);

                    	status = true;

                    }

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

                    // reserve the ID (in params)

                    if (httpVerb == POST) {

                    	reserve();

                    	status = true;

                    }

                } else if (resource.equals(RESOURCE_ASSERT_RELATION)) {

                	String objectId = request.getPathInfo();

                    if (objectId != null && objectId.length() > 1) {

                        objectId = request.getPathInfo().substring(1);

                    }

                    // reserve the ID (in params)

                    if (httpVerb == GET) {

                    	assertRelation(objectId);

                    	status = true;

                    }    

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

                	String objectId = request.getPathInfo();

                    if (objectId != null && objectId.length() > 1) {

                        objectId = request.getPathInfo().substring(1);

                    }

                    // resolve the object location

                    if (httpVerb == GET) {

                    	resolve(objectId);

                    	status = true;

                    }

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

                	String objectId = request.getPathInfo();

                    if (objectId != null && objectId.length() > 1) {

                        objectId = request.getPathInfo().substring(1);

                    }

                    // set the owner

                    if (httpVerb == PUT) {

                    	owner(objectId);

                    	status = true;

                    }    

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

                	String objectId = request.getPathInfo();

                    if (objectId != null && objectId.length() > 1) {

                        objectId = request.getPathInfo().substring(1);

                    }

                    // set the owner

                    if (httpVerb == PUT) {

                    	owner(objectId);

                    	status = true;

                    }

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

                	String objectId = request.getPathInfo();

                    if (objectId != null && objectId.length() > 1) {

                        objectId = request.getPathInfo().substring(1);

                    }

                    // authorized?

                    if (httpVerb == GET) {

                    	isAuthorized(objectId);

                    	status = true;

                    }    

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

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

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

                    String objectId = request.getPathInfo();

                    if (objectId != null && objectId.length() > 1) {

                        objectId = request.getPathInfo().substring(1);

                    }

                    else {

                        objectId = null;

                    }

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

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

                    if (httpVerb == GET) {

                        getObject(objectId);

                        status = true;

                    } else if (httpVerb == POST) {

                        putObject(objectId, FUNCTION_NAME_INSERT);

                        status = true;

                    } else if (httpVerb == PUT) {

                    	// TODO: this is not applicable for CN

                        putObject(objectId, FUNCTION_NAME_UPDATE);

                        status = true;

                    }

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

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

                  // check for a format identifier

                  String fmtid = request.getPathInfo();

                  if (fmtid != null && fmtid.length() > 1 ) {

                  	fmtid = request.getPathInfo().substring(1);

                  } else {

                  	fmtid = null;

                  }

                  // handle each verb

                  if (httpVerb == GET) {

                  	if (fmtid == null) {

                  		// list the formats collection

                  		listFormats();

                  	} else {

                  		// get the specified format

                  		getFormat(fmtid);

                  	}

                  	status = true;

                  }

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

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

                    //handle log events

                    if (httpVerb == GET) {

                        getLog();

                        status = true;

                    }

                } else if (resource.equals(RESOURCE_CHECKSUM)) {

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

                    //handle checksum requests

                    if (httpVerb == GET) {

                        String guid = request.getPathInfo();

                        if (guid != null && guid.length() > 1)

                            guid = request.getPathInfo().substring(1); //trim the slash

                        Identifier guidid = new Identifier();

                        guidid.setValue(guid);

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

                        try {

                            Checksum c = CNodeService.getInstance().getChecksum(session, guidid);

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

                            response.setStatus(200);

                            logMetacat.debug("serializing response");

                            serializeServiceType(Checksum.class, c, response.getOutputStream());

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

                        }

                        catch(NotAuthorized na)

                        {

                            na.setDetail_code("1400");

                            serializeException(na, response.getOutputStream());

                        }

                        catch(NotFound nf)

                        {

                            nf.setDetail_code("1420");

                            serializeException(nf, response.getOutputStream());

                        }

                        catch(InvalidRequest ir)

                        {

                            ir.setDetail_code("1402");

                            serializeException(ir, response.getOutputStream());

                        }

                        catch(ServiceFailure sf)

                        {

                            sf.setDetail_code("1410");

                            serializeException(sf, response.getOutputStream());

                        }

                        catch(InvalidToken it)

                        {

                            it.setDetail_code("1430");

                            serializeException(it, response.getOutputStream());

                        }

                        status = true;

                    }

                } 

                if (!status) {

                    response.setStatus(400);

                    printError("Incorrect parameters!", response);

                }

            } else {

                response.setStatus(400);

                printError("Incorrect resource!", response);

            }

        } catch (BaseException be) {

        	// report Exceptions as clearly as possible

        	OutputStream out = null;

			try {

				out = response.getOutputStream();

			} catch (IOException e) {

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

			}

            serializeException(be, out);

        } catch (Exception e) {

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

        }

    }

	/**

     * get the logs from the CrudService 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

     */

    private void getLog()

    {

        OutputStream out = null;

        try

        {

            out = response.getOutputStream();

            response.setStatus(200);

            response.setContentType("text/xml");

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

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

            Date fromDate = null;

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

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

            Date toDate = null;

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

            Event event = null;

            if(fromDateS != null)

            {

                //fromDate = dateFormat.parse(fromDateS);

                fromDate = parseDateAndConvertToGMT(fromDateS);

            }

            if(toDateS != null)

            {

                //toDate = dateFormat.parse(toDateS);

                toDate = parseDateAndConvertToGMT(toDateS);

            }

            if(eventS != null)

            {

                event = Event.convert(eventS);

            }

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

            Integer start = null;

            Integer count = null;

            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 count start: " + e.getMessage());

			}

            logMetacat.debug("calling crudservice.getLogRecords");

            Log log = CNodeService.getInstance().getLogRecords(session, fromDate, toDate, event, start, count);

            serializeServiceType(Log.class, log, out);

        }

        catch(Exception e)

        {

            String msg = "Could not get logs from CrudService: " + e.getClass() + ": " + e.getMessage();

            response.setStatus(500);

            ServiceFailure sf = new ServiceFailure("1490", msg);

            logMetacat.error(msg);

            e.printStackTrace();

            serializeException(sf, out);

        }

    }

    /**

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

     * @param guid ID of data object to be read

     */

    protected void getObject(String guid) {

        OutputStream out = null;

        try {

            out = response.getOutputStream();

            response.setStatus(200);

            if(guid != null)

            { //get a specific document                

                Identifier id = new Identifier();

                id.setValue(guid);

                try

                {

                    SystemMetadata sm = CNodeService.getInstance().getSystemMetadata(session, id);

                    //set the content type

                    if(sm.getObjectFormat().getFmtid().getValue().trim().equals(

                    		ObjectFormatCache.getInstance().getFormat("text/csv").getFmtid().getValue()))

                    {

                        response.setContentType("text/csv");

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

                    }

                    else if(sm.getObjectFormat().getFmtid().getValue().trim().equals(

                    		ObjectFormatCache.getInstance().getFormat("text/plain").getFmtid().getValue()))

                    {

                        response.setContentType("text/plain");

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

                    } 

                    else if(sm.getObjectFormat().getFmtid().getValue().trim().equals(

                    		ObjectFormatCache.getInstance().getFormat("application/octet-stream").getFmtid().getValue()))

                    {

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

                    }

                    else

                    {

                        response.setContentType("text/xml");

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

                    }

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

                    IOUtils.copyLarge(data, response.getOutputStream());

                }

                catch(InvalidToken it)

                {

                    response.setStatus(500);

                    serializeException(it, out); 

                }

                catch(ServiceFailure sf)

                {

                    response.setStatus(500);

                    serializeException(sf, out); 

                }

                catch(NotAuthorized na)

                {

                    response.setStatus(500);

                    serializeException(na, out); 

                }

                catch(NotFound nf)

                {

                    response.setStatus(500);

                    serializeException(nf, out); 

                }

                catch(NotImplemented ni)

                {

                    response.setStatus(500);

                    serializeException(ni, out); 

                }

                catch(Exception e)

                {

                    response.setStatus(500);

                    logMetacat.error("Error with Crud.get().  " +

                            "If this is an 'Exception producing data' error, " +

                            "go to CrudService.get() for better debugging.  " +

                            "Here's the error: " + e.getClass() + ": " + e.getMessage());

                    e.printStackTrace();

                    ServiceFailure sf = new ServiceFailure("1030", 

                            "IO Error in D1ResourceHandler.getObject: " + e.getClass() + ": " + e.getMessage());

                    serializeException(sf, out); 

                }

            }

        } catch (IOException e) {

            e.printStackTrace();

            response.setStatus(500);

            ServiceFailure sf = new ServiceFailure("1030", 

                    "IO Error in D1ResourceHandler.getObject: " + e.getMessage());

            serializeException(sf, out); 

        } catch(NumberFormatException ne) {

            response.setStatus(500);

            InvalidRequest ir = new InvalidRequest("1030", "Invalid format for parameter: " + ne.getMessage());

            serializeException(ir, out);

        } catch (Exception e) {

            e.printStackTrace();

            response.setStatus(500);

            ServiceFailure sf = new ServiceFailure("1030", 

                    "Exception " + e.getClass().getName() + " raised while handling listObjects request: " + 

                    e.getMessage());

            serializeException(sf, out);

        }

    }

    /**

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

     * @param guid ID of data object to be read

     */

    protected void getSystemMetadataObject(String guid) {

        OutputStream out = null;

        try {

            response.setContentType("text/xml");

            response.setStatus(200);

            out = response.getOutputStream();

            Identifier id = new Identifier();

            id.setValue(guid);

            SystemMetadata sysmeta = CNodeService.getInstance().getSystemMetadata(session, id);

            // Serialize and write it to the output stream

            try {

                //TODO: look at the efficiency of this method.  The system metadata

                //is read from metacat (in CrudService) as xml, then serialized

                //to a SystemMetadat object, then returned here, then serizlized

                //back to XML to be sent to the response.

                serializeServiceType(SystemMetadata.class, sysmeta, out);

            } catch (JiBXException e) {

                throw new ServiceFailure("1190", "Failed to serialize SystemMetadata: " + e.getMessage());

            }

        } catch (BaseException e) {

            response.setStatus(500);

                serializeException(e, out);

        } catch (IOException e) {

            response.setStatus(500);

            ServiceFailure sf = new ServiceFailure("1030", 

                    "IO Error in D1ResourceHandler.getSystemMetadataObject: " + e.getMessage());

            serializeException(sf, out);

        } finally {

            IOUtils.closeQuietly(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 IOException

     */

    protected void putObject(String pid, String action) {

        logMetacat.debug("putObject with pid " + pid);

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

        OutputStream out = null;

        try {

            out = response.getOutputStream();

            response.setStatus(200);

            response.setContentType("text/xml");

        } catch (IOException e1) {

            logMetacat.error("Could not get the output stream for writing in putObject");

        }

        try {

            // Read the incoming data from its Mime Multipart encoding

            logMetacat.debug("Disassembling MIME multipart form");

            InputStream object = null;

            InputStream sysmeta = null;

            Map<String, List<String>> multipartparams;

            try

            {

                //String req = IOUtils.toString(request.getInputStream());

                //logMetacat.debug("request: " + req);

                //InputStream reqStr = IOUtils.toInputStream(req);

                InputStream reqStr = request.getInputStream();

                //handle MMP inputs

                File tmpDir = getTempDirectory();

                File tmpSMFile = new File(tmpDir + 

                        ".sysmeta." + new Date().getTime() + ".tmp");

                logMetacat.debug("temp dir: " + tmpDir.getAbsolutePath());

                MultipartRequestResolver mrr = new MultipartRequestResolver(

                        tmpDir.getAbsolutePath(), 1000000000, 0);

                MultipartRequest mr = mrr.resolveMultipart(request);

                logMetacat.debug("resolved multipart request");

                Map<String, File> files = mr.getMultipartFiles();

                if(files == null)

                {

                    throw new ServiceFailure("1202", "create/update must have multipart files with names 'object' and 'sysmeta'");

                }

                logMetacat.debug("got multipart files");

                if(files.keySet() == null)

                {

                    logMetacat.error("No file keys in MMP request.");

                    throw new ServiceFailure("1202", "No file keys found in MMP.  " +

                            "create/update must have multipart files with names 'object' and 'sysmeta'");

                }

		// for logging purposes, dump out the key-value pairs that constitute the request

		// 3 types exist: request params, multipart params, and multipart files

                Iterator it = files.keySet().iterator();

                logMetacat.debug("iterating through request parts: " + it);

                while(it.hasNext())

                {

                    String key = (String)it.next();

                    logMetacat.debug("files key: " + key);

                    logMetacat.debug("files value: " + files.get(key));

                }

                multipartparams = mr.getMultipartParameters();

                it = multipartparams.keySet().iterator();

                while(it.hasNext())

                {

                    String key = (String)it.next();

                    logMetacat.debug("multipartparams key: " + key);

                    logMetacat.debug("multipartparams value: " + multipartparams.get(key));

                }

                it = params.keySet().iterator();

                while(it.hasNext())

                {

                    String key = (String)it.next();

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

                    logMetacat.debug("param value: " + params.get(key));

                }

		logMetacat.debug("done iterating the request...");

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

		if (smFile == null) 

		    throw new InvalidRequest("1102", "Missing the required file-part 'sysmeta' from the multipart request.");

                logMetacat.debug("smFile: " + smFile.getAbsolutePath());

                sysmeta = new FileInputStream(smFile);

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

		if (objFile == null) 

		    throw new InvalidRequest("1102", "Missing the required file-part 'object' from the multipart request.");

                logMetacat.debug("objectfile: " + objFile.getAbsolutePath());

                object = new FileInputStream(objFile);

                /*String obj = IOUtils.toString(object);

                String sm = IOUtils.toString(sysmeta);

                logMetacat.debug("object: " + obj);

                logMetacat.debug("sm: " + sm);

                object = IOUtils.toInputStream(obj);

                sysmeta = IOUtils.toInputStream(sm);*/

            }

            catch(org.apache.commons.fileupload.FileUploadException fue)

            {

                throw new ServiceFailure("1202", "Could not upload MMP files: " + fue.getMessage());

            }

            catch(IOException ioe)

            {

                throw new ServiceFailure("1202", 

                        "IOException when processing Mime Multipart: " + ioe.getMessage());

            }

            catch(Exception e)

            {

                throw new ServiceFailure("1202", "Error handling MMP upload: " + e.getClass() + ": " + e.getMessage());

            }

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

                // Check if the objectId exists

                IdentifierManager im = IdentifierManager.getInstance();

                if (im.identifierExists(pid)) {

                    throw new IdentifierNotUnique("1000", "Identifier is already in use: " + pid);

                }

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

                IBindingFactory bfact =

                    BindingDirectory.getFactory(SystemMetadata.class);

                IUnmarshallingContext uctx = bfact.createUnmarshallingContext();

                SystemMetadata smd = (SystemMetadata) uctx.unmarshalDocument(sysmeta, null);

                Identifier id = new Identifier();

                id.setValue(pid);

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

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

                serializeServiceType(Identifier.class, rId, out);

            } else {

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

            }

            //clean up the MMP files

            //parts.get("systemmetadata").delete();

            //parts.get("object").delete();

        } catch (NotAuthorized e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (InvalidToken e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (ServiceFailure e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (IdentifierNotUnique e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (UnsupportedType e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (InsufficientResources e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (InvalidSystemMetadata e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (NotImplemented e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (InvalidRequest e) {

            response.setStatus(500);

            serializeException(e, out);

        } /*catch (MessagingException e) {

            ServiceFailure sf = new ServiceFailure("1000", e.getMessage());

            serializeException(sf, out);

        } catch (IOException e) {

            response.setStatus(500);

            ServiceFailure sf = new ServiceFailure("1000", e.getMessage());

            serializeException(sf, out);

        }*/ catch (JiBXException e) {

            response.setStatus(500);

            e.printStackTrace(System.out);

            InvalidSystemMetadata ism = new InvalidSystemMetadata("1080", e.getMessage());

            serializeException(ism, out);

        }

    }

    /**

     * List the object formats registered with the system

     */

		private void listFormats() {

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

      // get the response output stream

      OutputStream out = null;

      try {

	      out = response.getOutputStream();

	      response.setStatus(200);

	      response.setContentType("text/xml");

      } catch (IOException ioe) {

      	logMetacat.error("Could not get the output stream for writing" +

      	  "in D1ResourceHandler.listFormats()");

      }

      // get the object format list

      try {

	      ObjectFormatList objectFormatList = CNodeService.getInstance().listFormats();

	      serializeServiceType(ObjectFormatList.class, objectFormatList, out);

      } catch (InvalidRequest e) {

      	response.setStatus(200);

      	serializeException(e, out);

      } catch (ServiceFailure e) {

      	response.setStatus(501);

      	serializeException(e, out);

      } catch (NotFound e) {

      	response.setStatus(200);

      	serializeException(e, out);

      } catch (InsufficientResources e) {

      	response.setStatus(200);

      	serializeException(e, out);

      } catch (NotImplemented e) {

      	response.setStatus(200);

      	serializeException(e, out);

      } catch (JiBXException jibxe) {

      	response.setStatus(501);

      	ServiceFailure e = 

      		new ServiceFailure("4841", "Unexpected exception from the service - " + 

        	                   jibxe.getClass() + ": " + jibxe.getMessage());

      	serializeException(e, out);

      }

    }

		/**

     * Return the requested object format

     * 

     * @param fmtidStr the requested format identifier as a string

     */

    private void getFormat(String fmtidStr) {

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

      // get the response output stream

      OutputStream out = null;

      try {

	      out = response.getOutputStream();

	      response.setStatus(200);

	      response.setContentType("text/xml");