Metacat

/**

 *  '$RCSfile$'

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

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author: leinfelder $'

 *     '$Date: 2012-05-01 10:25:23 -0700 (Tue, 01 May 2012) $'

 *

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

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.text.DateFormat;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Enumeration;

import java.util.Map;

import java.util.TimeZone;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

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.mimemultipart.MultipartRequest;

import org.dataone.mimemultipart.MultipartRequestResolver;

import org.dataone.service.exceptions.BaseException;

import org.dataone.service.exceptions.IdentifierNotUnique;

import org.dataone.service.exceptions.InsufficientResources;

import org.dataone.service.exceptions.InvalidRequest;

import org.dataone.service.exceptions.InvalidSystemMetadata;

import org.dataone.service.exceptions.InvalidToken;

import org.dataone.service.exceptions.NotAuthorized;

import org.dataone.service.exceptions.NotFound;

import org.dataone.service.exceptions.NotImplemented;

import org.dataone.service.exceptions.ServiceFailure;

import org.dataone.service.exceptions.SynchronizationFailed;

import org.dataone.service.exceptions.UnsupportedType;

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

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

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

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

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

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

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

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

import org.dataone.service.util.Constants;

import org.dataone.service.util.DateTimeMarshaller;

import org.dataone.service.util.ExceptionHandler;

import org.dataone.service.util.TypeMarshaller;

import org.jibx.runtime.JiBXException;

import org.xml.sax.SAXException;

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

import edu.ucsb.nceas.metacat.properties.PropertyService;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

/**

 * MN REST service implementation handler

 * 

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

 * MNCore -- DONE

 * 		ping() - GET /d1/mn/monitor/ping

 * 		log() - GET /d1/mn/log

 * 		**getObjectStatistics() - GET /d1/mn/monitor/object

 * 		getOperationsStatistics - GET /d1/mn/monitor/event

 * 		**getStatus - GET /d1/mn/monitor/status

 * 		getCapabilities() - GET /d1/mn/ and /d1/mn/node

 * 	

 * 	MNRead -- DONE

 * 		get() - GET /d1/mn/object/PID

 * 		getSystemMetadata() - GET /d1/mn/meta/PID

 * 		describe() - HEAD /d1/mn/object/PID

 * 		getChecksum() - GET /d1/mn/checksum/PID

 * 		listObjects() - GET /d1/mn/object

 * 		synchronizationFailed() - POST /d1/mn/error

 * 	

 * 	MNAuthorization -- DONE

 * 		isAuthorized() - GET /d1/mn/isAuthorized/PID

 * 		setAccessPolicy() - PUT /d1/mn/accessRules/PID

 * 		

 * 	MNStorage - DONE

 * 		create() - POST /d1/mn/object/PID

 * 		update() - PUT /d1/mn/object/PID

 * 		delete() - DELETE /d1/mn/object/PID

 * 		archive() - PUT /d1/mn/archive/PID

 *    systemMetadataChanged() - POST /dirtySystemMetadata/PID

 * 	

 * 	MNReplication

 * 		replicate() - POST /d1/mn/replicate

 *    getReplica() - GET /d1/mn/replica

 * 

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

 * @author leinfelder

 *

 */

public class MNResourceHandler extends D1ResourceHandler{

    // MN-specific API Resources

    protected static final String RESOURCE_MONITOR = "monitor";

    protected static final String RESOURCE_REPLICATE = "replicate";

    protected static final String RESOURCE_REPLICAS = "replica";

    protected static final String RESOURCE_NODE = "node";

    protected static final String RESOURCE_ERROR = "error";

    protected static final String RESOURCE_META_CHANGED = "dirtySystemMetadata";

    // shared executor

	private static ExecutorService executor = null;

	static {

		// use a shared executor service with nThreads == one less than available processors

    	int availableProcessors = Runtime.getRuntime().availableProcessors();

        int nThreads = availableProcessors * 1;

        nThreads--;

    	executor = Executors.newFixedThreadPool(nThreads);	

	}

    /**

     * Initializes new instance by setting servlet context,request and response

     * */

    public MNResourceHandler(ServletContext servletContext,

            HttpServletRequest request, HttpServletResponse response) {

    	super(servletContext, request, response);

        logMetacat = Logger.getLogger(MNResourceHandler.class);

    }

    @Override

    protected boolean isD1Enabled() {

    	boolean enabled = false;

    	try {

			enabled = Boolean.parseBoolean(PropertyService.getProperty("dataone.mn.services.enabled"));

		} catch (PropertyNotFoundException e) {

			logMetacat.error("Could not check if DataONE is enabled: " + e.getMessage());

		}

    	return enabled;	

    }

    /**

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

        	// only service requests if we have D1 configured

        	if (!isD1Enabled()) {

        		ServiceFailure se = new ServiceFailure("0000", "DataONE services are not enabled on this node");

                serializeException(se, response.getOutputStream());

                return;

        	}

        	// get the resource

            String resource = request.getPathInfo();

            resource = resource.substring(resource.indexOf("/") + 1);

            // default to node info

            if (resource.equals("")) {

                resource = RESOURCE_NODE;

            }

            // get the rest of the path info

            String extra = null;

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

            logMetacat.debug("resource: '" + resource + "'");

            boolean status = false;

            if (resource != null) {

                if (resource.startsWith(RESOURCE_NODE)) {

                    // node response

                    node();

                    status = true;

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

                    if (httpVerb == GET) {

                    	// after the command

                        extra = parseTrailing(resource, RESOURCE_IS_AUTHORIZED);

	                	// check the access rules

	                    isAuthorized(extra);

	                    status = true;

	                    logMetacat.debug("done getting access");

                    }

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

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

                    // get

                    if (httpVerb == GET) {

                    	// after the command

                        extra = parseTrailing(resource, RESOURCE_META);

                        getSystemMetadataObject(extra);

                        status = true;

                    }

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

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

                    // after the command

                    extra = parseTrailing(resource, RESOURCE_OBJECTS);

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

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

                    if (httpVerb == GET) {

                        getObject(extra);

                        status = true;

                    } else if (httpVerb == POST) {

                    	// part of the params, not the URL

                        putObject(null, FUNCTION_NAME_INSERT);

                        status = true;

                    } else if (httpVerb == PUT) {

                        putObject(extra, FUNCTION_NAME_UPDATE);

                        status = true;

                    } else if (httpVerb == DELETE) {

                        deleteObject(extra);

                        status = true;

                    } else if (httpVerb == HEAD) {

                        describeObject(extra);

                        status = true;

                    }

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

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

                    // handle log events

                    if (httpVerb == GET) {

                        getLog();

                        status = true;

                    }

                } else if (resource.startsWith(Constants.RESOURCE_ARCHIVE)) {

                    logMetacat.debug("Using resource " + Constants.RESOURCE_ARCHIVE);

                    // handle archive events

                    if (httpVerb == PUT) {

                        extra = parseTrailing(resource, Constants.RESOURCE_ARCHIVE);

                        archive(extra);

                        status = true;

                    }

                } else if (resource.startsWith(Constants.RESOURCE_CHECKSUM)) {

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

                    // handle checksum requests

                    if (httpVerb == GET) {

                    	// after the command

                        extra = parseTrailing(resource, Constants.RESOURCE_CHECKSUM);

                        checksum(extra);

                        status = true;

                    }

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

                    // there are various parts to monitoring

                    if (httpVerb == GET) {

                    	// after the command

                        extra = parseTrailing(resource, RESOURCE_MONITOR);

                        // ping

                        if (extra.toLowerCase().equals("ping")) {

                            logMetacat.debug("processing ping request");

                            Date result = MNodeService.getInstance(request).ping();

                            // TODO: send to output	

                            status = true;

                        } else {

	                    	// health monitoring calls

	                        status = monitor(extra);

                        }

                    }

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

                	if (httpVerb == POST) {

	                    logMetacat.debug("processing replicate request");

	                    replicate();

	                    status = true;

                	}

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

	                // sync error

	                if (httpVerb == POST) {

	                    syncError();

	                    status = true;

	                }

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

                    // system metadata changed

                    if (httpVerb == POST) {

                        systemMetadataChanged();

                        status = true;

                    }

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

                    // get replica

                    if (httpVerb == GET) {

                        extra = parseTrailing(resource, RESOURCE_REPLICAS);

                        getReplica(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 as possible

        	OutputStream out = null;

			try {

				out = response.getOutputStream();

			} catch (IOException e) {

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

			}

            serializeException(be, out);

        } catch (Exception e) {

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

        }

    }

    /**

     * Handles notification of system metadata changes for the given identifier

     * 

     * @param id  the identifier for the object

     * @throws InvalidToken 

     * @throws InvalidRequest 

     * @throws NotAuthorized 

     * @throws ServiceFailure 

     * @throws NotImplemented 

     */

    private void systemMetadataChanged() 

        throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest, 

        InvalidToken {

        long serialVersion = 0L;

        String serialVersionStr = null;

        Date dateSysMetaLastModified = null;

        String dateSysMetaLastModifiedStr = null;

        Identifier pid = null;

        // mkae sure we have the multipart params

        try {

			initMultipartParams();

		} catch (Exception e1) {

			throw new ServiceFailure("1333", "Could not collect the multipart params for the request");

		}

        // get the pid

        try {

        	String id = multipartparams.get("pid").get(0);

        	pid = new Identifier();

            pid.setValue(id);            

        } catch (NullPointerException e) {

            String msg = "The 'pid' must be provided as a parameter and was not.";

            logMetacat.error(msg);

            throw new InvalidRequest("1334", msg);

        }      

        // get the serialVersion

        try {

            serialVersionStr = multipartparams.get("serialVersion").get(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("1334", msg);

        }       

        // get the dateSysMetaLastModified

        try {

            dateSysMetaLastModifiedStr = multipartparams.get("dateSysMetaLastModified").get(0);

            dateSysMetaLastModified = DateTimeMarshaller.deserializeDateToUTC(dateSysMetaLastModifiedStr);

        } catch (NullPointerException e) {

            String msg = 

                "The 'dateSysMetaLastModified' must be provided as a " + 

                "parameter and was not, or was an invalid representation of the timestamp.";

            logMetacat.error(msg);

            throw new InvalidRequest("1334", msg);

        }       

        // call the service

        MNodeService.getInstance(request).systemMetadataChanged(session, pid, serialVersion, dateSysMetaLastModified);

        response.setStatus(200);

    }

    /**

     * Checks the access policy

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

		Permission permission = null;

		try {

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

			permission = Permission.convert(perm);

		} catch (Exception e) {

			logMetacat.warn("No permission specified");

		}

		boolean result = MNodeService.getInstance(request).isAuthorized(session, pid, permission);

		response.setStatus(200);

		response.setContentType("text/xml");

		return result;

    }

    /**

     * Processes failed synchronization message

     * @throws NotImplemented

     * @throws ServiceFailure

     * @throws NotAuthorized

     * @throws InvalidRequest

     * @throws JiBXException

     * @throws IllegalAccessException 

     * @throws InstantiationException 

     * @throws IOException 

     */

    private void syncError() throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest, JiBXException, IOException, InstantiationException, IllegalAccessException {

    	SynchronizationFailed syncFailed = null;

		try {

			syncFailed = collectSynchronizationFailed();

		} catch (ParserConfigurationException e) {

			throw new ServiceFailure("2161", e.getMessage());

		} catch (SAXException e) {

			throw new ServiceFailure("2161", e.getMessage());

		}

		MNodeService.getInstance(request).synchronizationFailed(session, syncFailed);

    }

    /**

     * Handles the monitoring resources

     * @return

     * @throws NotFound

     * @throws ParseException

     * @throws NotImplemented

     * @throws ServiceFailure

     * @throws NotAuthorized

     * @throws InvalidRequest

     * @throws InsufficientResources

     * @throws UnsupportedType

     * @throws IOException

     * @throws JiBXException

     */

    private boolean monitor(String pathInfo) 

      throws NotFound, ParseException, NotImplemented, ServiceFailure, 

      NotAuthorized, InvalidRequest, InsufficientResources, UnsupportedType, 

      IOException, JiBXException {

    	logMetacat.debug("processing monitor request");

        logMetacat.debug("verb is GET");

        logMetacat.debug("pathInfo is " + pathInfo);

        if (pathInfo.toLowerCase().equals("status")) {

            logMetacat.debug("processing status request");

            // TODO: implement in MNCore

            //MNodeService.getInstance().getStatus();

            return false;

        } else if (pathInfo.toLowerCase().equals("object")) {

            logMetacat.debug("processing object request");

            Identifier pid = null;

            ObjectFormat format = null;

            if (params.containsKey("format")) {

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

                format = ObjectFormatCache.getInstance().getFormat(f);

            }

            if (params.containsKey("pid")) {

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

                pid = new Identifier();

                pid.setValue(id);

            }

            // TODO: implement in MNCore

            //ObjectStatistics objectStats = MNodeService.getInstance().getObjectStatistics(format, pid);

            return false;

        } else if (pathInfo.toLowerCase().equals("event")) {

            logMetacat.debug("processing event request");

            ObjectFormatIdentifier fmtid = null;

            String fromDateStr = null;

            Date fromDate = null;

            String toDateStr = null;

            Date toDate = null;

            String requestor = null;

            Subject subject = null;

            String eventName = null;

            Event event = null;

            if (params.containsKey("formatId")) {

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

                fmtid = ObjectFormatCache.getInstance().getFormat(f).getFormatId();

            }

            if (params.containsKey("fromDate")) {

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

                fromDate = getDateAsUTC(fromDateStr);

            }

            if (params.containsKey("toDate")) {

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

              toDate = getDateAsUTC(toDateStr);

            }

            if (params.containsKey("requestor")) {

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

            	subject = new Subject();

            	subject.setValue(requestor);

            }

            if (params.containsKey("event")) {

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

                event = Event.convert(eventName);

            }

            MonitorList monitorList = MNodeService.getInstance(request).getOperationStatistics(session, fromDate, toDate, subject, event, fmtid);

            OutputStream out = response.getOutputStream();

            response.setStatus(200);

            response.setContentType("text/xml");

            TypeMarshaller.marshalTypeToOutputStream(monitorList, out);

            return true;

        }

        return false;

    }

    /*

     * Parse an ISO8601 date string, returning a Date in UTC time if the string

     * ends in 'Z'.

     * 

     * @param fromDateStr -  the date string to be parsed

     * @return date -  the date object represented by the string

     */

    private Date getDateAsUTC(String fromDateStr)

      throws ParseException {

    	Date date = null;

    	try {

    		// try the expected date format

        // a date format for date string arguments

        DateFormat dateFormat = 

        	new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");

	      date = dateFormat.parse(fromDateStr);

    	} catch (ParseException e) {

    		// try the date with the UTC indicator

        DateFormat utcDateFormat = 

        	new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss'Z'");

        utcDateFormat.setTimeZone(TimeZone.getTimeZone("GMT-0"));

        date = utcDateFormat.parse(fromDateStr);

      }

    	return date;

    }

		/**

     * Calculate the checksum 

     * @throws NotImplemented

     * @throws JiBXException

     * @throws IOException

     * @throws InvalidToken

     * @throws ServiceFailure

     * @throws NotAuthorized

     * @throws NotFound

     * @throws InvalidRequest

     */

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

    	String checksumAlgorithm = "MD5";

        Identifier pidid = new Identifier();

        pidid.setValue(pid);

        try {

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

        } catch(Exception e) {

            //do nothing.  default to MD5

        	logMetacat.warn("No algorithm specified, using default: " + checksumAlgorithm);

        }

        logMetacat.debug("getting checksum for object " + pid + " with algorithm " + checksumAlgorithm);

        Checksum c = MNodeService.getInstance(request).getChecksum(session, pidid, checksumAlgorithm);

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

        response.setStatus(200);

        logMetacat.debug("serializing response");

        TypeMarshaller.marshalTypeToOutputStream(c, response.getOutputStream());

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

    }

	/**

     * handle the replicate action for MN

	 * @throws JiBXException 

	 * @throws FileUploadException 

	 * @throws IOException 

	 * @throws InvalidRequest 

	 * @throws ServiceFailure 

	 * @throws UnsupportedType 

	 * @throws InsufficientResources 

	 * @throws NotAuthorized 

	 * @throws NotImplemented 

	 * @throws IllegalAccessException 

	 * @throws InstantiationException 

	 * @throws InvalidToken 

     */

    private void replicate() 

        throws ServiceFailure, InvalidRequest, IOException, FileUploadException, 

        JiBXException, NotImplemented, NotAuthorized, InsufficientResources, 

        UnsupportedType, InstantiationException, IllegalAccessException, InvalidToken {

        logMetacat.debug("in POST replicate()");

        // somewhat unorthodox, but the call is asynchronous and we'd like to return this info sooner

        boolean allowed = false;

        if (session == null) {

        	String msg = "No session was provided.";

            NotAuthorized failure = new NotAuthorized("2152", msg);

        	throw failure;

        } else {

        	allowed = MNodeService.getInstance(request).isAdminAuthorized(session);

        	if (!allowed) {

        		String msg = "User is not an admin user";

                NotAuthorized failure = new NotAuthorized("2152", msg);

            	throw failure;

        	}

        }

        //parse the systemMetadata

        final SystemMetadata sysmeta = collectSystemMetadata();

        String sn = multipartparams.get("sourceNode").get(0);

        logMetacat.debug("sourceNode: " + sn);

        final NodeReference sourceNode = new NodeReference();

        sourceNode.setValue(sn);

        // run it in a thread to avoid connection timeout

        Runnable runner = new Runnable() {

			@Override

			public void run() {

				try {

			        MNodeService.getInstance(request).replicate(session, sysmeta, sourceNode);

				} catch (Exception e) {

					logMetacat.error("Error running replication: " + e.getMessage(), e);

					throw new RuntimeException(e.getMessage(), e);

				}

			}

    	};

    	// submit the task, and that's it

    	executor.submit(runner);

    	// thread was started, so we return success

        response.setStatus(200);

    }

    /**

     * Handle the getReplica action for the MN

     * @param id  the identifier for the object

     * @throws NotFound 

     * @throws ServiceFailure 

     * @throws NotImplemented 

     * @throws NotAuthorized 

     * @throws InvalidToken 

     * @throws InvalidRequest 

     */

    private void getReplica(String id) 

        throws InvalidRequest, InvalidToken, NotAuthorized, NotImplemented, 

        ServiceFailure, NotFound {

        Identifier pid = new Identifier();

        pid.setValue(id);

        OutputStream out = null;

        InputStream dataBytes = null;

        try {

            // call the service

            dataBytes = MNodeService.getInstance(request).getReplica(session, pid);

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

            response.setStatus(200);

            out = response.getOutputStream();

            // write the object to the output stream

            IOUtils.copyLarge(dataBytes, out);

        } catch (IOException e) {

            String msg = "There was an error writing the output: " + e.getMessage();

            logMetacat.error(msg);

            throw new ServiceFailure("2181", msg);

        }

    }

    /**

     * Get the Node information

     * 

     * @throws JiBXException

     * @throws IOException

     * @throws InvalidRequest 

     * @throws ServiceFailure 

     * @throws NotAuthorized 

     * @throws NotImplemented 

     */

    private void node() 

        throws JiBXException, IOException, NotImplemented, NotAuthorized, ServiceFailure, InvalidRequest {

        Node n = MNodeService.getInstance(request).getCapabilities();

        response.setContentType("text/xml");

        response.setStatus(200);

        TypeMarshaller.marshalTypeToOutputStream(n, response.getOutputStream());

    }

    /**

     * MN_crud.describe()

     * http://mule1.dataone.org/ArchitectureDocs/mn_api_crud.html#MN_crud.describe

     * @param pid

     * @throws InvalidRequest 

     * @throws NotImplemented 

     * @throws NotFound 

     * @throws NotAuthorized 

     * @throws ServiceFailure 

     * @throws InvalidToken 

     */

    private void describeObject(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, InvalidRequest

    {

        response.setContentType("text/xml");

        Identifier id = new Identifier();

        id.setValue(pid);

        DescribeResponse dr = null;

        try {

        	dr = MNodeService.getInstance(request).describe(session, id);

        } catch (BaseException e) {

        	response.setStatus(e.getCode());

        	response.addHeader("DataONE-Exception-Name", e.getClass().getName());

            response.addHeader("DataONE-Exception-DetailCode", e.getDetail_code());

            response.addHeader("DataONE-Exception-Description", e.getDescription());

            response.addHeader("DataONE-Exception-PID", id.getValue());

            return;

		}

        response.setStatus(200);

        //response.addHeader("pid", pid);

        response.addHeader("DataONE-Checksum", dr.getDataONE_Checksum().getAlgorithm() + "," + dr.getDataONE_Checksum().getValue());

        response.addHeader("Content-Length", dr.getContent_Length() + "");

        response.addHeader("Last-Modified", DateTimeMarshaller.serializeDateToUTC(dr.getLast_Modified()));

        response.addHeader("DataONE-ObjectFormat", dr.getDataONE_ObjectFormatIdentifier().getValue());

        response.addHeader("DataONE-SerialVersion", dr.getSerialVersion().toString());

    }

    /**

     * get the logs based on passed params.  Available 

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

        String pidFilter = 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());

		}

        try {

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

        } catch (Exception e) {

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

        }

        logMetacat.debug("calling getLogRecords");

        Log log = MNodeService.getInstance(request).getLogRecords(session, fromDate, toDate, event, pidFilter, 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 pid 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 getObject(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, InvalidRequest, NotImplemented, IOException, JiBXException {