Metacat

/**

 *  '$RCSfile$'

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

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author: cjones $'

 *     '$Date: 2011-11-04 14:19:37 -0700 (Fri, 04 Nov 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.util.Date;

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

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

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

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

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

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;

/**

 * 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 /replicationNotifications/PID

		updateReplicationMetadata() - PUT /replicationMetadata/PID

		setReplicationPolicy() - PUT /replicationPolicies/PID

		isNodeAuthorized() - GET /replicationAuthorizations/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_ASSERT_RELATION = "assertRelation";

    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 {

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

                    	status = true;

                    }

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

                    // reserve the ID (in params)

                    if (httpVerb == POST) {

                    	reserve();

                    	status = true;

                    }

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

                	// after the command

                    extra = parseTrailing(resource, RESOURCE_ASSERT_RELATION);

                    // reserve the ID (in params)

                    if (httpVerb == GET) {

                    	assertRelation(extra);

                    	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 {

                    		query();

                    	}

                        status = true;

                    } else if (httpVerb == POST) {

                        putObject(extra, FUNCTION_NAME_INSERT);

                        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;

                } 

                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 pid, String action) throws ServiceFailure, InvalidRequest, IdentifierNotUnique, JiBXException, InvalidToken, NotAuthorized, UnsupportedType, InsufficientResources, InvalidSystemMetadata, NotImplemented, IOException, InstantiationException, IllegalAccessException {

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

        // Read the incoming data from its Mime Multipart encoding

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

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

            Identifier id = new Identifier();

            id.setValue(pid);

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

            Identifier rId = CNodeService.getInstance(request).create(session, id, 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");

      TypeMarshaller.marshalTypeToOutputStream(objectFormatList, out);

    }

		/**

     * Return the requested object format

     * 

     * @param fmtidStr the requested format identifier as a string

		 * @throws NotImplemented 

		 * @throws InsufficientResources 

		 * @throws NotFound 

		 * @throws ServiceFailure 

		 * @throws InvalidRequest 

		 * @throws IOException 

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

		boolean result = CNodeService.getInstance(request).reserveIdentifier(session, pid);

		OutputStream out = response.getOutputStream();

		response.setStatus(200);

		response.setContentType("text/xml");

		// nothing to send back

    }

    /**

     * 

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

    }

    /**

     * Assert that a relationship exists between two resources

     * @param id

     * @return

     * @throws InvalidToken

     * @throws ServiceFailure

     * @throws NotAuthorized

     * @throws NotFound

     * @throws InvalidRequest

     * @throws NotImplemented

     */

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

		Identifier pidOfSubject = new Identifier();

		pidOfSubject.setValue(id);

		String relationship = null;

		try {

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

		} catch (Exception e) {

			logMetacat.warn("relationship not specified");

		}

		Identifier pidOfObject = new Identifier();

		try {

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

			pidOfObject.setValue(objPid);

		} catch (Exception e) {

			logMetacat.warn("pidOfObject not specified");

		}

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

		response.setStatus(200);

		response.setContentType("text/xml");

		return result;

    }

    /**

     * 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 

     */

    private void owner(String id) 

        throws JiBXException, InvalidToken, ServiceFailure, 

        NotFound, NotAuthorized, NotImplemented, InvalidRequest, IOException, 

        InstantiationException, IllegalAccessException {

        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).setOwner(session, pid, subject, serialVersion);

		    OutputStream out = response.getOutputStream();

		    response.setStatus(200);

		    response.setContentType("text/xml");

		    TypeMarshaller.marshalTypeToOutputStream(retPid, out);		

    }

    /**

     * Processes the authorization check for given id

     * @param id

     * @return

     * @throws ServiceFailure

     * @throws InvalidToken

     * @throws NotFound

     * @throws NotAuthorized

     * @throws NotImplemented

     * @throws InvalidRequest

     */

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

		Identifier pid = new Identifier();

		pid.setValue(id);

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

		boolean result = CNodeService.getInstance(request).isAuthorized(session, pid, Permission.convert(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

     * @throws JiBXException 

     * @throws FileUploadException 

     * @throws IOException 

     * @throws InvalidRequest 

     * @throws ServiceFailure 

     * @throws InvalidSystemMetadata 

     * @throws NotAuthorized 

     * @throws NotImplemented 

     * @throws IllegalAccessException 

     * @throws InstantiationException 

     */

    protected Identifier registerSystemMetadata(String pid) throws ServiceFailure, InvalidRequest, IOException, FileUploadException, JiBXException, NotImplemented, NotAuthorized, InvalidSystemMetadata, InstantiationException, IllegalAccessException {

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

		// get the system metadata from the request

		SystemMetadata systemMetadata = collectSystemMetadata();

		Identifier guid = new Identifier();

		guid.setValue(pid);

		logMetacat.debug("registering system metadata with pid " + guid.getValue());

		Identifier retGuid = CNodeService.getInstance(request).registerSystemMetadata(session, guid, systemMetadata);

		response.setStatus(200);

		response.setContentType("text/xml");

		return retGuid;

	}

    /**

     * set the access perms on a document

     * @throws JiBXException 

     * @throws InvalidRequest 

     * @throws NotImplemented 

     * @throws NotAuthorized 

     * @throws NotFound 

     * @throws ServiceFailure 

     * @throws InvalidToken 

     * @throws IllegalAccessException 

     * @throws InstantiationException 

     * @throws IOException 

     * @throws SAXException 

     * @throws ParserConfigurationException 

     */

    protected void setAccess(String pid) 

        throws JiBXException, InvalidToken, ServiceFailure, NotFound, 

        NotAuthorized, NotImplemented, InvalidRequest, IOException, 

        InstantiationException, IllegalAccessException, ParserConfigurationException, 

        SAXException {

        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("4402", msg);

        }

        Identifier id = new Identifier();

        id.setValue(pid);

        AccessPolicy accessPolicy = collectAccessPolicy();

        CNodeService.getInstance(request).setAccessPolicy(session, id, accessPolicy, serialVersion);

    }

    /**

     *	Pass to the CN search service

     *

     * @throws NotImplemented 

     * @throws InvalidRequest 

     * @throws NotAuthorized 

     * @throws ServiceFailure 

     * @throws InvalidToken 

     * @throws Exception

     */

    private void query() 

        throws InvalidToken, ServiceFailure, NotAuthorized, InvalidRequest, NotImplemented {

    	  String query = null;

		    String queryType = null;

		    try {

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

		    } catch (Exception e) {

		    	logMetacat.warn("query not specified");