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 15:54:03 -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.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.PrintWriter;

import java.io.StringReader;

import java.io.UnsupportedEncodingException;

import java.text.DateFormat;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.List;

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.io.IOUtils;

import org.apache.log4j.Logger;

import org.dataone.client.ObjectFormatCache;

import org.dataone.client.auth.CertificateManager;

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

import org.dataone.service.types.Checksum;

import org.dataone.service.types.DescribeResponse;

import org.dataone.service.types.Event;

import org.dataone.service.types.Identifier;

import org.dataone.service.types.Log;

import org.dataone.service.types.MonitorList;

import org.dataone.service.types.Node;

import org.dataone.service.types.NodeList;

import org.dataone.service.types.NodeReference;

import org.dataone.service.types.ObjectFormat;

import org.dataone.service.types.ObjectList;

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

/**

 * 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

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

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

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

 * 	

 * 	MNReplication

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

 * 

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

 * @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_NODE = "node";

    protected static final String RESOURCE_ERROR = "error";

    /**

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

    }

    /**

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

        logMetacat = Logger.getLogger(MNResourceHandler.class);

        try {

            String resourcePrefix = RESOURCE_BASE_URL + "/mn/";

        	String resource = request.getServletPath();

            if (resource.endsWith(resourcePrefix)) {

                resource = RESOURCE_NODE;

            }

            else {

            	// remove prefix

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

                resource = resource.trim();

            }

            System.out.println("handling verb " + httpVerb + " request with resource '" + resource + "'");

            System.out.println("resource: '" + resource + "'");

            boolean status = false;

            // load session from certificate in request

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

            if (resource != null) {

                //resource = request.getServletPath().substring(1);

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

                initParams();

                Timer timer = new Timer();

                handler = new MetacatHandler(timer);

                if (resource.equals(RESOURCE_NODE)) {

                    // node response

                    node();

                    status = true;

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

                    if (httpVerb == POST) {

	                	// set the access rules

	                    setaccess();

	                    status = true;

	                    System.out.println("done setting access");

                    }

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

                    if (httpVerb == GET) {

	                	// check the access rules

                    	String objectId = request.getPathInfo();

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

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

                        }

	                    isAuthorized(objectId);

	                    status = true;

	                    System.out.println("done getting access");

                    }

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

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

                    }

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

                    System.out.println("Using resource 'object'");

                    String objectId = request.getPathInfo();

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

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

                    } else {

                        objectId = null;

                    }

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

                        putObject(objectId, FUNCTION_NAME_UPDATE);

                        status = true;

                    } else if (httpVerb == DELETE) {

                        deleteObject(objectId);

                        status = true;

                    } else if (httpVerb == HEAD) {

                        describeObject(objectId);

                        status = true;

                    }

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

                    System.out.println("Using resource 'log'");

                    // handle log events

                    if (httpVerb == GET) {

                        getLog();

                        status = true;

                    }

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

                    System.out.println("Using resource 'checksum'");

                    // handle checksum requests

                    if (httpVerb == GET) {

                        checksum();

                        status = true;

                    }

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

                    // there are various parts to monitoring

                    if (httpVerb == GET) {

                    	// health monitoring calls

                        monitor();

                    }

                    status = true;

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

                	if (httpVerb == POST) {

	                    System.out.println("processing replicate request");

	                    replicate();

	                    status = true;

                	}

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

	                // sync error

	                if (httpVerb == POST) {

	                    syncError();

	                    status = true;

	                }

                }

                if (!status) {

                    response.setStatus(400);

                    printError("Incorrect parameters!", response);

                }

            } else {

                response.setStatus(400);

                printError("Incorrect resource!", response);

            }

        } 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) {

            logMetacat.error(e.getClass() + ": " + e.getMessage());

            System.out.println("Error handle(): " + e.getClass() + ": " + e.getMessage());

            e.printStackTrace();

        }

    }

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

			permission = Permission.valueOf(perm);

		} catch (Exception e) {

			logMetacat.warn("No permission specified");

		}

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

		response.setStatus(200);

		response.setContentType("text/xml");

		return result;

    }

    private void syncError() throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest, UnsupportedEncodingException, JiBXException {

    	SynchronizationFailed syncFailed = null;

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

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

            syncFailed = (SynchronizationFailed) deserializeServiceType(SynchronizationFailed.class, new ByteArrayInputStream(message.getBytes("UTF-8")));

        }

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

    }

    private boolean monitor() throws NotFound, ParseException, NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest, InsufficientResources, UnsupportedType, IOException, JiBXException {

    	System.out.println("processing monitor request");

        String pathInfo = request.getPathInfo();

        System.out.println("verb is GET");

        System.out.println("pathInfo is " + pathInfo);

        pathInfo = pathInfo.substring(1);

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

            System.out.println("processing ping request");

            boolean result = MNodeService.getInstance().ping();

            return result;

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

            System.out.println("processing status request");

            // TODO: implement in MNCore

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

            return false;

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

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

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

            System.out.println("processing event request");

            ObjectFormat format = null;

            Integer period = null;

            String requestor = null;

            Subject subject = null;

            String eventName = null;

            Event event = null;

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

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

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

            }

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

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

                period = Integer.valueOf(t);

            }

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

            }

            MonitorList monitorList = MNodeService.getInstance().getOperationStatistics(session, period, subject, event, format);

            OutputStream out = response.getOutputStream();

            response.setStatus(200);

            response.setContentType("text/xml");

            serializeServiceType(MonitorList.class, monitorList, out);

        }

        return true;

    }

    private void checksum() throws NotImplemented, JiBXException, IOException {

    	String checksumAlgorithm = "MD5";

        String guid = request.getPathInfo();

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

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

        }

        Identifier guidid = new Identifier();

        guidid.setValue(guid);

        try {

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

        } catch(Exception e) {

            //do nothing.  default to MD5

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

        }

        System.out.println("getting checksum for object " + guid + " with algorithm " + checksumAlgorithm);

        try {

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

            System.out.println("got checksum " + c.getValue());

            response.setStatus(200);

            System.out.println("serializing response");

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

            System.out.println("done serializing response.");

        }

        catch(NotAuthorized na)

        {

            na.setDetail_code("1400");

            serializeException(na, response.getOutputStream());

        }

        catch(NotFound nf)

        {

            nf.setDetail_code("1420");

            serializeException(nf, response.getOutputStream());

        }

        catch(InvalidRequest ir)

        {

            ir.setDetail_code("1402");

            serializeException(ir, response.getOutputStream());

        }

        catch(ServiceFailure sf)

        {

            sf.setDetail_code("1410");

            serializeException(sf, response.getOutputStream());

        }

        catch(InvalidToken it)

        {

            it.setDetail_code("1430");

            serializeException(it, response.getOutputStream());

        }

    }

	/**

     * handle the replicate action for MN

	 * @throws Exception 

     */

    private void replicate() throws Exception {

        System.out.println("in POST replicate()");

        File tmpDir = getTempDirectory();

        System.out.println("temp dir: " + tmpDir.getAbsolutePath());

        MultipartRequestResolver mrr = new MultipartRequestResolver(

                tmpDir.getAbsolutePath(), 1000000000, 0);

        MultipartRequest mr = mrr.resolveMultipart(request);

        Map<String, File> files = mr.getMultipartFiles();

        Iterator keys = files.keySet().iterator();

        while(keys.hasNext()) {

            String key = (String)keys.next();

            System.out.println("files key: " + key);

            System.out.println("files value: " + files.get(key));

        }

        Map<String, List<String>> params = mr.getMultipartParameters();

        keys = params.keySet().iterator();

        while(keys.hasNext()) {

            String key = (String)keys.next();

            System.out.println("params key: " + key);

            System.out.println("params value: " + params.get(key));

        }

        // File f = files.get("sysmeta");

        // the files are not being keyed by the part name, but rather the filename

        File f = files.get(files.keySet().iterator().next());

        System.out.println("file: " + f.getAbsolutePath());

        FileInputStream fis = new FileInputStream(f);

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

        System.out.println("sourceNode: " + sn);

        NodeReference sourceNode = (NodeReference) deserializeServiceType(NodeReference.class, new ByteArrayInputStream(sn.getBytes("UTF-8")));

        //parse the systemMetadata

        SystemMetadata sysmeta = (SystemMetadata) deserializeServiceType(SystemMetadata.class, fis);

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

        response.setStatus(200);

    }

    /**

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

        NodeList nl = new NodeList();

        nl.addNode(n);

        response.setContentType("text/xml");

        response.setStatus(200);

        serializeServiceType(NodeList.class, nl, response.getOutputStream());

    }

    /**

     * MN_crud.describe()

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

     * @param guid

     */

    private void describeObject(String guid)

    {

        Logger logMetacat = Logger.getLogger(MNResourceHandler.class);

        OutputStream out = null;

        try

        {

            out = response.getOutputStream();

        }

        catch(Exception e)

        {

            logMetacat.error("Error getting output stream in describeObject: " + e.getClass() + ": " + e.getMessage());

            return;

        }

        response.setStatus(200);

        response.setContentType("text/xml");

        Identifier id = new Identifier();

        id.setValue(guid);

        try

        {

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

            DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss.SZ");

            response.addHeader("guid", guid);

            response.addHeader("checksum", dr.getDataONE_Checksum().getValue());

            response.addHeader("checksum_algorithm", dr.getDataONE_Checksum().getAlgorithm().name());

            response.addHeader("content_length", dr.getContent_Length() + "");

            response.addHeader("last_modified", dateFormat.format(dr.getLast_Modified()));

            response.addHeader("format", dr.getDataONE_ObjectFormat().toString());

        }

        catch(InvalidRequest ir)

        {

            serializeException(ir, out);

        }

        catch(NotImplemented ni)

        {

            serializeException(ni, out);

        }

        catch(NotAuthorized na)

        {

            serializeException(na, out);

        }

        catch(ServiceFailure sf)

        {

            serializeException(sf, out);

        }

        catch(NotFound nf)

        {

            serializeException(nf, out);

        }

        catch(InvalidToken it)

        {

            serializeException(it, out);

        }

    }

    /**

     * get the logs based on passed params.  Available 

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

     * for more info

     */

    private void getLog()

    {

        OutputStream out = null;

        try {

            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 = MNodeService.getInstance().getLogRecords(session, fromDate, toDate, event, start, count);

            out = response.getOutputStream();

            response.setStatus(200);

            response.setContentType("text/xml");

            serializeServiceType(Log.class, log, out);

        }

        catch(Exception e) {

            String msg = "Could not get logs: " + e.getClass() + ": " + e.getMessage();

            response.setStatus(500);

            ServiceFailure sf = new ServiceFailure("1490", msg);

            logMetacat.error(msg);

            e.printStackTrace();

            serializeException(sf, out);

        }

    }

    /**

     * Implements REST version of DataONE CRUD API --> get

     * @param guid ID of data object to be read

     */

    protected void getObject(String guid) {

        OutputStream out = null;

        try {

            out = response.getOutputStream();

            response.setStatus(200);

            if(guid != null)

            { //get a specific document                

                Identifier id = new Identifier();

                id.setValue(guid);

                try

                {

                    SystemMetadata sm = MNodeService.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 = MNodeService.getInstance().get(session, id);

                    IOUtils.copyLarge(data, response.getOutputStream());

                }

                catch(InvalidToken it)

                {

                    response.setStatus(500);

                    serializeException(it, out); 

                }

                catch(ServiceFailure sf)

                {

                    response.setStatus(500);

                    serializeException(sf, out); 

                }

                catch(NotAuthorized na)

                {

                    response.setStatus(500);

                    serializeException(na, out); 

                }

                catch(NotFound nf)

                {

                    response.setStatus(500);

                    serializeException(nf, out); 

                }

                catch(NotImplemented ni)

                {

                    response.setStatus(500);

                    serializeException(ni, out); 

                }

                catch(Exception e)

                {

                    response.setStatus(500);

                    System.out.println("Error with Crud.get().  " +

                            "If this is an 'Exception producing data' error, " +

                            "go to CrudService.get() for better debugging.  " +

                            "Here's the error: " + e.getClass() + ": " + e.getMessage());

                    e.printStackTrace();

                    ServiceFailure sf = new ServiceFailure("1030", 

                            "IO Error in getObject: " + e.getClass() + ": " + e.getMessage());

                    serializeException(sf, out); 

                }

            }

            else

            { //call listObjects with specified params

                Date startTime = null;

                Date endTime = null;

                ObjectFormat objectFormat = null;

                boolean replicaStatus = false;

                int start = 0;

                //TODO: make the max count into a const

                int count = 1000;

                Enumeration paramlist = request.getParameterNames();

                while (paramlist.hasMoreElements()) 

                { //parse the params and make the crud call

                    String name = (String) paramlist.nextElement();

                    String[] value = (String[])request.getParameterValues(name);

                    /*for(int i=0; i<value.length; i++)

                    {

                        System.out.println("name: " + name + " value: " + value[i]);

                    }*/

                    if(name.equals("startTime") && value != null)

                    {

                        try

                        {

                          //startTime = dateFormat.parse(value[0]);

                            startTime = parseDateAndConvertToGMT(value[0]);

                        }

                        catch(Exception e)

                        {  //if we can't parse it, just don't use the startTime param

                            System.out.println("Could not parse startTime: " + value[0]);

                            startTime = null;

                        }

                    }

                    else if(name.equals("endTime") && value != null)

                    {

                        try

                        {

                          //endTime = dateFormat.parse(value[0]);

                            endTime = parseDateAndConvertToGMT(value[0]);

                        }

                        catch(Exception e)

                        {  //if we can't parse it, just don't use the endTime param

                            System.out.println("Could not parse endTime: " + value[0]);

                            endTime = null;

                        }

                    }

                    else if(name.equals("objectFormat") && value != null) 

                    {

                        objectFormat = ObjectFormatCache.getInstance().getFormat(value[0]);

                    }

                    else if(name.equals("replicaStatus") && value != null)

                    {

                        if(value != null && 

                           value.length > 0 && 

                           (value[0].equals("true") || value[0].equals("TRUE") || value[0].equals("YES")))

                        {

                            replicaStatus = true;

                        }

                    }

                    else if(name.equals("start") && value != null)

                    {

                        start = new Integer(value[0]).intValue();

                    }

                    else if(name.equals("count") && value != null)

                    {

                        count = new Integer(value[0]).intValue();

                    }

                }

                //make the crud call

                System.out.println("session: " + session + " startTime: " + startTime +

                        " endtime: " + endTime + " objectFormat: " + 

                        objectFormat + " replicaStatus: " + replicaStatus + 

                        " start: " + start + " count: " + count);

                ObjectList ol = MNodeService.getInstance().listObjects(session, startTime, endTime, 

                        objectFormat, replicaStatus, start, count);

                StringReader sr = new StringReader(ol.toString());                

                out = response.getOutputStream();  

                response.setStatus(200);