Metacat

/**

 *  '$RCSfile$'

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

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author: cjones $'

 *     '$Date: 2011-08-31 14:36:32 -0700 (Wed, 31 Aug 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 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.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.QueryType;

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

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

import org.dataone.service.util.TypeMarshaller;

import org.jibx.runtime.JiBXException;

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

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

            // get the rest

            String extra = null;

            if (resource.lastIndexOf("/") != -1) {

                extra = resource.substring(resource.lastIndexOf("/") + 1);

            }

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

                    setAccess();

                    status = true;

                    logMetacat.debug("done setting access");

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

                    logMetacat.debug("Using 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)) {

                    // reserve the ID (in params)

                    if (httpVerb == GET) {

                    	assertRelation(extra);

                    	status = true;

                    }    

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

                    // resolve the object location

                    if (httpVerb == GET) {

                    	resolve(extra);

                    	status = true;

                    }

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

                    // set the owner

                    if (httpVerb == PUT) {

                    	owner(extra);

                    	status = true;

                    }    

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

                    // set the owner

                    if (httpVerb == PUT) {

                    	owner(extra);

                    	status = true;

                    }

                } else if (resource.startsWith(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...");

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

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

                    //handle checksum requests

                    if (httpVerb == GET) {

                        checksum(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().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 = parseDateAndConvertToGMT(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 = parseDateAndConvertToGMT(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().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().getSystemMetadata(session, id);

        //set the content type

        if(sm.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.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.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);

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

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

		Subject subject = TypeMarshaller.unmarshalTypeFromStream(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");

		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("permission")[0];

		boolean result = CNodeService.getInstance().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 boolean 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());

		boolean result = CNodeService.getInstance().registerSystemMetadata(session, guid, systemMetadata);

		response.setStatus(200);

		response.setContentType("text/xml");

		return result;

	}

    /**

     * 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 

     */

    protected void setAccess() throws JiBXException, InvalidToken, ServiceFailure, NotFound, NotAuthorized, NotImplemented, InvalidRequest, IOException, InstantiationException, IllegalAccessException {

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

        Identifier id = new Identifier();

        id.setValue(guid);

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

        AccessPolicy accessPolicy = TypeMarshaller.unmarshalTypeFromStream(AccessPolicy.class, new ByteArrayInputStream(accesspolicy.getBytes("UTF-8")));

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

    }

    /**

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

		QueryType queryType = null;

		try {

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

		} catch (Exception e) {

			logMetacat.warn("query not specified");

		}

		try {

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

			queryType = QueryType.valueOf(qt);

		} catch (Exception e) {

			logMetacat.warn("queryType not specified");

		}

    	// expecting to throw NotImplemented

		CNodeService.getInstance().search(session, queryType, query);

    }

}