Metacat

<!-- CN REST Servlet -->

    <servlet>

      <servlet-name>CNRestServlet</servlet-name>

      <servlet-class>edu.ucsb.nceas.metacat.restservice.CNRestServlet</servlet-class>

      <init-param>

        <param-name>debug</param-name>

        <param-value>1</param-value>

      </init-param>

      <init-param>

        <param-name>listings</param-name>

        <param-value>true</param-value>

      </init-param>

      <load-on-startup>15</load-on-startup>

    </servlet>    

	<!-- CN REST services -->

	<!-- CNCore-->

	<servlet-mapping>

		<servlet-name>CNRestServlet</servlet-name>

		<url-pattern>/d1/cn/object/*</url-pattern>

	</servlet-mapping>

	<servlet-mapping>

		<servlet-name>CNRestServlet</servlet-name>

		<url-pattern>/d1/cn/formats/*</url-pattern>

	</servlet-mapping>

	<servlet-mapping>

		<servlet-name>CNRestServlet</servlet-name>

		<url-pattern>/d1/cn/log/*</url-pattern>

	</servlet-mapping>

	<servlet-mapping>

		<servlet-name>CNRestServlet</servlet-name>

		<url-pattern>/d1/cn/reserve/*</url-pattern>

	</servlet-mapping>

	<servlet-mapping>

		<servlet-name>CNRestServlet</servlet-name>

		<url-pattern>/d1/cn/meta/*</url-pattern>

	</servlet-mapping>

	<!-- CNRead-->

	<servlet-mapping>

		<servlet-name>CNRestServlet</servlet-name>

		<url-pattern>/d1/cn/resolve/*</url-pattern>

	</servlet-mapping>

	<servlet-mapping>

		<servlet-name>CNRestServlet</servlet-name>

		<url-pattern>/d1/cn/assertRelation/*</url-pattern>

	</servlet-mapping>

	<servlet-mapping>

		<servlet-name>CNRestServlet</servlet-name>

		<url-pattern>/d1/cn/checksum/*</url-pattern>

	</servlet-mapping>

	<!-- CNAuthorization -->

	<servlet-mapping>

		<servlet-name>CNRestServlet</servlet-name>

		<url-pattern>/d1/cn/owner/*</url-pattern>

	</servlet-mapping>

	<servlet-mapping>

		<servlet-name>CNRestServlet</servlet-name>

		<url-pattern>/d1/cn/isAuthorized/*</url-pattern>

	</servlet-mapping>

	<servlet-mapping>

		<servlet-name>CNRestServlet</servlet-name>

		<url-pattern>/d1/cn/accessRules/*</url-pattern>

	</servlet-mapping>

	<!-- CNReplication -->

	<servlet-mapping>

		<servlet-name>CNRestServlet</servlet-name>

		<url-pattern>/d1/cn/notify/*</url-pattern>

	</servlet-mapping>

	<servlet-mapping>

		<servlet-name>CNRestServlet</servlet-name>

		<url-pattern>/d1/cn/meta/replication/*</url-pattern>

	</servlet-mapping>

	<servlet-mapping>

		<servlet-name>CNRestServlet</servlet-name>

		<url-pattern>/d1/cn/meta/policy/*</url-pattern>

	</servlet-mapping>

/**

 *  '$RCSfile$'

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

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author$'

 *     '$Date$'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.restservice;

import java.io.IOException;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

/**

 * Routes CN REST service requests to the appropriate handler

 *  

 */

public class CNRestServlet extends RestServlet {

	/**

	 * Provide a CNResourceHandler subclass of ResourceHandler

	 */

	@Override

    protected ResourceHandler createHandler(HttpServletRequest request, HttpServletResponse response) 

    	throws ServletException, IOException {

        return new CNResourceHandler(getServletContext(), request, response);

    }

}

/**

 *  '$RCSfile$'

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

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author$'

 *     '$Date$'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.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.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.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 ResourceHandler {

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

                    	asserRelation(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 ResourceHandler.getObject: " + e.getClass() + ": " + e.getMessage());

                    serializeException(sf, out); 

                }

            }

        } catch (IOException e) {

            e.printStackTrace();

            response.setStatus(500);

            ServiceFailure sf = new ServiceFailure("1030", 

                    "IO Error in ResourceHandler.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

     */

    private 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 ResourceHandler.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("ResourceHandler: 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 ResourceHandler.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");

      } catch (IOException ioe) {

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

      	  "in ResourceHandler.listFormats()");

      }

      ObjectFormatIdentifier fmtid = new ObjectFormatIdentifier();

      fmtid.setValue(fmtidStr);

      try {

      	// get the specified object format

	      ObjectFormat objectFormat = CNodeService.getInstance().getFormat(fmtid);

	      serializeServiceType(ObjectFormat.class, objectFormat, 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) {

      	ServiceFailure e = 

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

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

      	serializeException(e, out);

      }

    }

    /**

     * Reserve the given Identifier

     * @throws InvalidToken

     * @throws ServiceFailure

     * @throws NotAuthorized

     * @throws IdentifierNotUnique

     * @throws NotImplemented

     * @throws InvalidRequest

     * @throws IOException 

     */

    private void reserve() throws InvalidToken, ServiceFailure, NotAuthorized, IdentifierNotUnique, NotImplemented, InvalidRequest, IOException {

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

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

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

		Identifier pid = new Identifier();

		pid.setValue(id);

		Identifier retPid = CNodeService.getInstance().reserveIdentifier(session, pid, scope, format);

		OutputStream out = response.getOutputStream();

		response.setStatus(200);

		response.setContentType("text/xml");

		try {

			serializeServiceType(Identifier.class, retPid, out);

		} catch (JiBXException e) {

	      throw new ServiceFailure("4210", 

	      				"Unexpected exception from the service - " + 

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

		}

    }

    private void resolve(String id) throws InvalidRequest, InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, IOException {

		Identifier pid = new Identifier();

		pid.setValue(id);

		ObjectLocationList locationList = CNodeService.getInstance().resolve(session, pid);

	    OutputStream out = response.getOutputStream();

		response.setStatus(200);

		response.setContentType("text/xml");

		try {

			serializeServiceType(ObjectLocationList.class, locationList, out);

		} catch (JiBXException e) {

	      throw new ServiceFailure("4150", 

	      				"Unexpected exception from the service - " + 

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

		}

    }

    private boolean asserRelation(String id) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, InvalidRequest, NotImplemented {

		Identifier pidOfSubject = new Identifier();

		pidOfSubject.setValue(id);

		Identifier pidOfObject = new Identifier();

		String relationship;

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

		String objPid = params.get("pidOfObject")[0];

		pidOfObject.setValue(objPid);

		boolean result = CNodeService.getInstance().assertRelation(session, pidOfSubject, relationship, pidOfObject);

		response.setStatus(200);

		response.setContentType("text/xml");

		return result;

    }

    private void owner(String id) throws JiBXException, InvalidToken, ServiceFailure, NotFound, NotAuthorized, NotImplemented, InvalidRequest, IOException {

		Identifier pid = new Identifier();

		pid.setValue(id);

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

		Subject subject = (Subject) deserializeServiceType(Subject.class, new ByteArrayInputStream(subjectStr.getBytes("UTF-8")));

		Identifier retPid = CNodeService.getInstance().setOwner(session, pid, subject);

		OutputStream out = response.getOutputStream();

		response.setStatus(200);

		response.setContentType("text/xml");

		try {

			serializeServiceType(Identifier.class, retPid, out);

		} catch (JiBXException e) {

	      throw new ServiceFailure("4490", 

	      				"Unexpected exception from the service - " + 

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

		}

    }

    private boolean isAuthorized(String id) throws ServiceFailure, InvalidToken, NotFound, NotAuthorized, NotImplemented, InvalidRequest {

		Identifier pid = new Identifier();

		pid.setValue(id);

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

		boolean result = CNodeService.getInstance().isAuthorized(session, pid, Permission.valueOf(permission));

		response.setStatus(200);

		response.setContentType("text/xml");

		return result;

    }

    /**

     * Register System Metadata without data or metadata object

     * @param pid identifier for System Metadata entry

     */

    protected void registerSystemMetadata(String pid) {

		logMetacat.debug("Entering registerSystemMetadata: " + pid);

		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 sysmeta = null;

			Map<String, List<String>> multipartparams;

			try {

				// handle MMP inputs

				File tmpDir = getTempDirectory();

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

							"register meta must have multipart file with name '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.  "

									+ "register meta must have multipart file with name '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);

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

			}

			// 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 systemMetadata = (SystemMetadata) uctx

					.unmarshalDocument(sysmeta, null);

			Identifier guid = new Identifier();

			guid.setValue(pid);

			logMetacat.debug("registering system metadata with pid "

					+ guid.getValue());

			boolean result = CNodeService.getInstance().registerSystemMetadata(

					session, guid, systemMetadata);

			serializeServiceType(Boolean.class, result, out);

		} catch (NotAuthorized 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 (NotImplemented e) {

			response.setStatus(500);

			serializeException(e, out);

		} catch (InvalidRequest e) {

			response.setStatus(500);

			serializeException(e, out);

		} catch (JiBXException e) {

			response.setStatus(500);

			e.printStackTrace(System.out);

			InvalidSystemMetadata ism = new InvalidSystemMetadata("1080", e

					.getMessage());

			serializeException(ism, out);

		} catch (InvalidSystemMetadata e) {

			serializeException(e, out);

    }

	}

}