Metacat

/**

 *  '$RCSfile$'

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

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author: leinfelder $'

 *     '$Date: 2011-06-30 16:31:53 -0700 (Thu, 30 Jun 2011) $'

 *

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

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

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

 * (at your option) any later version.

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

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

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

 */

package edu.ucsb.nceas.metacat.restservice;

import java.io.ByteArrayInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.PrintWriter;

import java.io.UnsupportedEncodingException;

import java.util.Date;

import java.util.Hashtable;

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.fileupload.FileUploadException;

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.service.exceptions.BaseException;

import org.dataone.service.exceptions.IdentifierNotUnique;

import org.dataone.service.exceptions.InsufficientResources;

import org.dataone.service.exceptions.InvalidRequest;

import org.dataone.service.exceptions.InvalidSystemMetadata;

import org.dataone.service.exceptions.InvalidToken;

import org.dataone.service.exceptions.NotAuthorized;

import org.dataone.service.exceptions.NotFound;

import org.dataone.service.exceptions.NotImplemented;

import org.dataone.service.exceptions.ServiceFailure;

import org.dataone.service.exceptions.UnsupportedType;

import org.dataone.service.types.AccessPolicy;

import org.dataone.service.types.Checksum;

import org.dataone.service.types.Event;

import org.dataone.service.types.Identifier;

import org.dataone.service.types.Log;

import org.dataone.service.types.ObjectFormat;

import org.dataone.service.types.ObjectFormatIdentifier;

import org.dataone.service.types.ObjectFormatList;

import org.dataone.service.types.ObjectLocationList;

import org.dataone.service.types.Permission;

import org.dataone.service.types.Subject;

import org.dataone.service.types.SystemMetadata;

import org.jibx.runtime.JiBXException;

import edu.ucsb.nceas.metacat.MetacatHandler;

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

/**

 * CN REST service implementation handler

 * 

 * ******************

 	CNCore -- DONE

		create() - POST /d1/cn/object/PID

		listFormats() - GET /d1/cn/formats

		getFormat() - GET /d1/cn/formats/FMTID

		getLogRecords - GET /d1/cn/log

		reserveIdentifier() - POST /d1/cn/reserve

		listNodes() - Not implemented

		registerSystemMetadata() - POST /d1/meta/PID

	CNRead -- DONE

		get() - GET /d1/cn/object/PID

		getSystemMetadata() - GET /d1/cn/meta/PID

		resolve() - GET /d1/cn/resolve/PID

		assertRelation() - GET /d1/cn/assertRelation/PID

		getChecksum() - GET /d1/cn/checksum

		search() - Not implemented in Metacat

	CNAuthorization

		setOwner() - PUT /d1/cn/owner/PID

		isAuthorized() - GET /d1/cn/isAuthorized/PID

		setAccessPolicy() - POST /d1/cn/accessRules

	CNIdentity - not implemented at all on Metacat

	CNReplication

		setReplicationStatus() - Not exposed

		updateReplicationMetadata() - New method?

		setReplicationPolicy() - Not exposed

	CNRegister -- not implemented at all in Metacat

 * ******************

 * @author leinfelder

 *

 */

public class CNResourceHandler extends D1ResourceHandler {

	/** CN-specific operations **/

    protected static final String RESOURCE_RESERVE = "reserve";

    protected static final String RESOURCE_FORMATS = "formats"; //remove from super

    protected static final String RESOURCE_RESOLVE = "resolve";

    protected static final String RESOURCE_ASSERT_RELATION = "assertRelation";

    protected static final String RESOURCE_OWNER = "owner";

    protected static final String RESOURCE_NOTIFY = "notify";

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

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

    public CNResourceHandler(ServletContext servletContext,

			HttpServletRequest request, HttpServletResponse response) {

		super(servletContext, request, response);

        logMetacat = Logger.getLogger(CNResourceHandler.class);

	}

	/**

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

     * 

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

     */

    public void handle(byte httpVerb) {

        try {

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

        	String resourcePrefix = RESOURCE_BASE_URL + "/cn/";

            String resource = request.getServletPath();

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

            resource = resource.trim();

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

            boolean status = false;

            // load session from certificate in request

            // TODO: move to superclass

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

            if (resource != null) {

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

                initParams();

                Timer timer = new Timer();

                handler = new MetacatHandler(timer);

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

                    logMetacat.debug("Setting access policy");

                    setAccess();

                    status = true;

                    logMetacat.debug("done setting access");

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

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

                    String objectId = request.getPathInfo();

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

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

                    }

                    // get

                    if (httpVerb == GET) {

                        getSystemMetadataObject(objectId);

                        status = true;

                    }

                    // post to register system metadata

                    if (httpVerb == POST) {

                    	registerSystemMetadata(objectId);

                    	status = true;

                    }

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

                    // reserve the ID (in params)

                    if (httpVerb == POST) {

                    	reserve();

                    	status = true;

                    }

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

                	String objectId = request.getPathInfo();

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

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

                    }

                    // reserve the ID (in params)

                    if (httpVerb == GET) {

                    	assertRelation(objectId);

                    	status = true;

                    }    

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

                	String objectId = request.getPathInfo();

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

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

                    }

                    // resolve the object location

                    if (httpVerb == GET) {

                    	resolve(objectId);

                    	status = true;

                    }

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

                	String objectId = request.getPathInfo();

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

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

                    }

                    // set the owner

                    if (httpVerb == PUT) {

                    	owner(objectId);

                    	status = true;

                    }    

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

                	String objectId = request.getPathInfo();

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

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

                    }

                    // set the owner

                    if (httpVerb == PUT) {

                    	owner(objectId);

                    	status = true;

                    }

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

                	String objectId = request.getPathInfo();

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

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

                    }

                    // authorized?

                    if (httpVerb == GET) {

                    	isAuthorized(objectId);

                    	status = true;

                    }    

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

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

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

                    String objectId = request.getPathInfo();

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

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

                    }

                    else {

                        objectId = null;

                    }

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

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

                    if (httpVerb == GET) {

                        getObject(objectId);

                        status = true;

                    } else if (httpVerb == POST) {

                        putObject(objectId, FUNCTION_NAME_INSERT);

                        status = true;

                    } else if (httpVerb == PUT) {

                    	// TODO: this is not applicable for CN

                        putObject(objectId, FUNCTION_NAME_UPDATE);

                        status = true;

                    }

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

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

                  // check for a format identifier

                  String fmtid = request.getPathInfo();

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

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

                  } else {

                  	fmtid = null;

                  }

                  // handle each verb

                  if (httpVerb == GET) {

                  	if (fmtid == null) {

                  		// list the formats collection

                  		listFormats();

                  	} else {

                  		// get the specified format

                  		getFormat(fmtid);

                  	}

                  	status = true;

                  }

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

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

                    //handle log events

                    if (httpVerb == GET) {

                        getLog();

                        status = true;

                    }

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

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

                    //handle checksum requests

                    if (httpVerb == GET) {

                        String guid = request.getPathInfo();

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

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

                        }

                        checksum(guid);

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

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

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

    }

	/**

     * 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

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

            System.out.println("param fromDateS: " + fromDateS);

            fromDate = parseDateAndConvertToGMT(fromDateS);

        } catch (Exception e) {

        	logMetacat.warn("Could not parse fromDate: " + e.getMessage());

        }

        try {

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

            System.out.println("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());

		}

        System.out.println("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());

		}

        System.out.println("calling getLogRecords");

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

        OutputStream out = response.getOutputStream();

        response.setStatus(200);

        response.setContentType("text/xml");

        serializeServiceType(Log.class, 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 {

        if (guid != null) { //get a specific document                

            Identifier id = new Identifier();

            id.setValue(guid);

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

            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

       serializeServiceType(SystemMetadata.class, 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 

     */

    protected void putObject(String pid, String action) throws ServiceFailure, InvalidRequest, IdentifierNotUnique, JiBXException, InvalidToken, NotAuthorized, UnsupportedType, InsufficientResources, InvalidSystemMetadata, NotImplemented, IOException {

        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 = (SystemMetadata) deserializeServiceType(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");

            serializeServiceType(Identifier.class, 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");

      serializeServiceType(ObjectFormatList.class, 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");

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

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

		serializeServiceType(Identifier.class, retPid, out);

    }

    /**

     * 

     * @param id

     * @throws InvalidRequest

     * @throws InvalidToken

     * @throws ServiceFailure

     * @throws NotAuthorized

     * @throws NotFound

     * @throws NotImplemented

     * @throws IOException

     * @throws JiBXException 

     */

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

		Identifier pid = new Identifier();

		pid.setValue(id);

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

	    OutputStream out = response.getOutputStream();

		response.setStatus(200);

		response.setContentType("text/xml");

		serializeServiceType(ObjectLocationList.class, 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

     */

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

		serializeServiceType(Identifier.class, 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.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

     * @throws JiBXException 

     * @throws FileUploadException 

     * @throws IOException 

     * @throws InvalidRequest 

     * @throws ServiceFailure 

     * @throws InvalidSystemMetadata 

     * @throws NotAuthorized 

     * @throws NotImplemented 

     */

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

		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 UnsupportedEncodingException 

     * @throws InvalidRequest 

     * @throws NotImplemented 

     * @throws NotAuthorized 

     * @throws NotFound 

     * @throws ServiceFailure 

     * @throws InvalidToken 

     */

    protected void setAccess() throws UnsupportedEncodingException, JiBXException, InvalidToken, ServiceFailure, NotFound, NotAuthorized, NotImplemented, InvalidRequest {

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

        Identifier id = new Identifier();

        id.setValue(guid);

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

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

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

    }

    /**

     * Earthgrid API > Query Service > Query Function : translates ecogrid query document to metacat query 

     * then calls DBQuery > createResultDocument function and then again translate resultset to ecogrid resultset

     * 

     * NOTE:

     *      This is the only method that uses EcoGrid classes for its implementation.  

     *      It does so because it takes an EcoGrid Query as input, and outputs an

     *      EcoGrid ResultSet document.  These documents are parsed by the auto-generated

     *      EcoGrid classes from axis, and so we link to them here rather than re-inventing them.

     *      This creates a circular dependency, because the Metacat classes are needed

     *      to build the EcoGrid implementation, and the EcoGrid jars are needed to build this query()

     *      method.  This circularity could be resolved by moving the EcoGrid classes

     *      to Metacat directly.  As we transition away from EcoGrid SOAP methods in

     *      favor of these REST interfaces, this circular dependency can be eliminated.

     *        

     * @throws Exception

     */

    private void query() throws Exception {

        /*  This block commented out because of the EcoGrid circular dependency.

         *  For now, query will not be supported until the circularity can be

         *  resolved, probably by moving the ecogrid query syntax transformers

         *  directly into the Metacat codebase.  MBJ 2010-02-03

        try {

            EcogridQueryParser parser = new EcogridQueryParser(request

                    .getReader());

            parser.parseXML();

            QueryType queryType = parser.getEcogridQuery();

            EcogridJavaToMetacatJavaQueryTransformer queryTransformer = 

                new EcogridJavaToMetacatJavaQueryTransformer();

            QuerySpecification metacatQuery = queryTransformer

                    .transform(queryType);

            DBQuery metacat = new DBQuery();

            boolean useXMLIndex = (new Boolean(PropertyService

                    .getProperty("database.usexmlindex"))).booleanValue();

            String xmlquery = "query"; // we don't care the query in resultset,

            // the query can be anything

            PrintWriter out = null; // we don't want metacat result, so set out null

            // parameter: queryspecification, user, group, usingIndexOrNot

            StringBuffer result = metacat.createResultDocument(xmlquery,

                    metacatQuery, out, username, groupNames, useXMLIndex);

            // create result set transfer       

            String saxparser = PropertyService.getProperty("xml.saxparser");

            MetacatResultsetParser metacatResultsetParser = new MetacatResultsetParser(

                    new StringReader(result.toString()), saxparser, queryType

                            .getNamespace().get_value());

            ResultsetType records = metacatResultsetParser.getEcogridResult();

            System.out

                    .println(EcogridResultsetTransformer.toXMLString(records));

            response.setContentType("text/xml");

            out = response.getWriter();

            out.print(EcogridResultsetTransformer.toXMLString(records));

        } catch (Exception e) {

            e.printStackTrace();

        }*/

        response.setContentType("text/xml");

        response.setStatus(501);

        PrintWriter out = response.getWriter();

        out.print("<error>Query operation not yet supported by Metacat.</error>");

        out.close();

    }

}