Metacat

/**

 *  '$RCSfile$'

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

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author: leinfelder $'

 *     '$Date: 2013-05-23 10:20:40 -0700 (Thu, 23 May 2013) $'

 *

 * 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.client.formats.ObjectFormatInfo;

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.types.v1_1.QueryEngineDescription;

import org.dataone.service.types.v1_1.QueryEngineList;

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.common.query.stream.ContentTypeInputStream;

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

    protected static final String RESOURCE_GENERATE_ID = "generate";

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

        nThreads = Math.max(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;

                    }

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

	                logMetacat.debug("Using resource " + RESOURCE_QUERY);

	                // after the command

	                extra = parseTrailing(resource, RESOURCE_QUERY);

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

	                String engine = null;

	                String query = null;

	                if (extra != null) {

		                // get the engine

		                int engineIndex = extra.length();

		                if (extra.indexOf("/") > -1) {

		                	engineIndex = extra.indexOf("/");

		                }

		                engine = extra.substring(0, engineIndex);

		                logMetacat.debug("query engine: " + engine);

		                // get the query if it is there

		                query = extra.substring(engineIndex, extra.length());

		                if (query != null && query.length() == 0) {

		                	query = null;

		                } else {

		                	if (query.startsWith("/")) {

		                		query = query.substring(1);

		                    }

		                }

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

	                }

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

	                if (httpVerb == GET) {

	                    doQuery(engine, query);

	                    status = true;

	                }

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

                	// generate an id

                    if (httpVerb == POST) {

                        generateIdentifier();

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

        }

    }

    private void doQuery(String engine, String query) {

		OutputStream out = null;

    	try {

    		// NOTE: we set the session explicitly for the MNode instance since these methods do not provide a parameter			

	    	if (engine == null) {

	    		// just looking for list of engines

	    		MNodeService mnode = MNodeService.getInstance(request);

    			mnode.setSession(session);

	    		QueryEngineList qel = mnode.listQueryEngines();

	    		response.setContentType("text/xml");

	            response.setStatus(200);

	            out = response.getOutputStream();

	            TypeMarshaller.marshalTypeToOutputStream(qel, out);

	            return;

	    	} else {

	    		if (query != null) {

	    			MNodeService mnode = MNodeService.getInstance(request);

	    			mnode.setSession(session);

	    			InputStream stream = mnode.query(engine, query);

	    			// set the content-type if we have it from the implementation

	    			if (stream instanceof ContentTypeInputStream) {

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

		    			//response.setContentType("text/xml");

	    				response.setContentType(((ContentTypeInputStream) stream).getContentType());

	    			}

	                response.setStatus(200);

	                out = response.getOutputStream();

	                // write the results to the output stream

	                IOUtils.copyLarge(stream, out);

	                return;

	    		} else {

	    			MNodeService mnode = MNodeService.getInstance(request);

	    			mnode.setSession(session);

	    			QueryEngineDescription qed = mnode.getQueryEngineDescription(engine);

	    			response.setContentType("text/xml");

		            response.setStatus(200);

		            out = response.getOutputStream();

		            TypeMarshaller.marshalTypeToOutputStream(qed, out);

		            return;

	    		}

	    	}

    	} catch (BaseException be) {

        	// report Exceptions as clearly as possible

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

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

    }

    /**

     * Handles identifier generation calls

     * 

     * @throws InvalidRequest 

     * @throws NotImplemented 

     * @throws NotAuthorized 

     * @throws ServiceFailure 

     * @throws InvalidToken 

     * @throws IOException 

     * @throws JiBXException 

     */

    private void generateIdentifier() throws InvalidToken, ServiceFailure, NotAuthorized, NotImplemented, InvalidRequest, IOException, JiBXException {

        // make 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 scheme

		String scheme = null;

        try {

        	scheme = multipartparams.get("scheme").get(0);	           

        } catch (NullPointerException e) {

            String msg = "The 'scheme' parameter was not provided, using default";

            logMetacat.warn(msg);

        }

        // get the fragment

		String fragment = null;

        try {

        	fragment = multipartparams.get("fragment").get(0);	           

        } catch (NullPointerException e) {

            String msg = "The 'fragment' parameter was not provided, using default";

            logMetacat.warn(msg);

        }

        // call the service

        Identifier identifier = MNodeService.getInstance(request).generateIdentifier(session, scheme, fragment);

        response.setStatus(200);

        response.setContentType("text/xml");

        OutputStream out = response.getOutputStream();

        TypeMarshaller.marshalTypeToOutputStream(identifier, out);

    }

    /**

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

    	try {

    		checksumAlgorithm = PropertyService.getProperty("dataone.checksumAlgorithm.default");

        } catch(Exception e) {

        	logMetacat.warn("Could not lookup configured default checksum algorithm, using: " + checksumAlgorithm);

        }    

        Identifier pidid = new Identifier();

        pidid.setValue(pid);

        try {

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

        } catch(Exception e) {

            //do nothing.  use the default

        	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;