Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that implements a metadata catalog as a java Servlet

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones, Dan Higgins, Jivka Bojilova, Chad Berkley, Matthew Perry

 *    Release: @release@

 *

 *   '$Author: perry $'

 *     '$Date: 2006-09-13 16:10:55 -0700 (Wed, 13 Sep 2006) $'

 * '$Revision: 3044 $'

 *

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

import java.io.BufferedInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.PrintWriter;

import java.io.StringReader;

import java.net.MalformedURLException;

import java.net.URL;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Timestamp;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.Properties;

import java.util.Timer;

import java.util.Vector;

import java.util.zip.ZipEntry;

import java.util.zip.ZipOutputStream;

import javax.servlet.ServletConfig;

import javax.servlet.ServletContext;

import javax.servlet.ServletException;

import javax.servlet.ServletOutputStream;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

import org.apache.log4j.Logger;

import org.apache.log4j.PropertyConfigurator;

import org.ecoinformatics.eml.EMLParser;

import com.oreilly.servlet.multipart.FilePart;

import com.oreilly.servlet.multipart.MultipartParser;

import com.oreilly.servlet.multipart.ParamPart;

import com.oreilly.servlet.multipart.Part;

import edu.ucsb.nceas.utilities.Options;

import edu.ucsb.nceas.metacat.spatial.SpatialHarvester;

import edu.ucsb.nceas.metacat.spatial.SpatialQuery;

/**

 * A metadata catalog server implemented as a Java Servlet

 *

 * <p>

 * Valid parameters are: <br>

 * action=query -- query the values of all elements and attributes and return a

 * result set of nodes <br>

 * action=squery -- structured query (see pathquery.dtd) <br>

 * action= -- export a zip format for data packadge <br>

 * action=read -- read any metadata/data file from Metacat and from Internet

 * <br>

 * action=insert -- insert an XML document into the database store <br>

 * action=update -- update an XML document that is in the database store <br>

 * action=delete -- delete an XML document from the database store <br>

 * action=validate -- vallidate the xml contained in valtext <br>

 * doctype -- document type list returned by the query (publicID) <br>

 * qformat=xml -- display resultset from query in XML <br>

 * qformat=html -- display resultset from query in HTML <br>

 * qformat=zip -- zip resultset from query <br>

 * docid=34 -- display the document with the document ID number 34 <br>

 * doctext -- XML text of the document to load into the database <br>

 * acltext -- XML access text for a document to load into the database <br>

 * dtdtext -- XML DTD text for a new DTD to load into Metacat XML Catalog <br>

 * query -- actual query text (to go with 'action=query' or 'action=squery')

 * <br>

 * valtext -- XML text to be validated <br>

 * action=getaccesscontrol -- retrieve acl info for Metacat document <br>

 * action=getdoctypes -- retrieve all doctypes (publicID) <br>

 * action=getdtdschema -- retrieve a DTD or Schema file <br>

 * action=getdataguide -- retrieve a Data Guide <br>

 * action=getprincipals -- retrieve a list of principals in XML <br>

 * datadoc -- data document name (id) <br>

 * action=getlog -- get a report of events that have occurred in the system<br>

 * ipAddress --  filter on one or more IP addresses<br>

 * principal -- filter on one or more principals (LDAP DN syntax)<br>

 * docid -- filter on one or more document identifiers (with revision)<br>

 * event -- filter on event type (e.g., read, insert, update, delete)<br>

 * start -- filter out events before the start date-time<br>

 * end -- filter out events before the end date-time<br>

 * <p>

 * The particular combination of parameters that are valid for each particular

 * action value is quite specific. This documentation will be reorganized to

 * reflect this information.

 */

public class MetaCatServlet extends HttpServlet

{

    private static Hashtable sessionHash = new Hashtable();

    private Timer timer = null;

    // Constants -- these should be final in a servlet

    private static final String PROLOG = "<?xml version=\"1.0\"?>";

    private static final String SUCCESS = "<success>";

    private static final String SUCCESSCLOSE = "</success>";

    private static final String ERROR = "<error>";

    private static final String ERRORCLOSE = "</error>";

    public static final String SCHEMALOCATIONKEYWORD = ":schemaLocation";

    public static final String NONAMESPACELOCATION = ":noNamespaceSchemaLocation";

    public static final String NAMESPACEKEYWORD = "xmlns";

    public static final String EML2KEYWORD = ":eml";

    public static final String XMLFORMAT = "xml";

    private static final String CONFIG_DIR = "WEB-INF";

    private static final String CONFIG_NAME = "metacat.properties"; 

    /**

     * Initialize the servlet by creating appropriate database connections

     */

    public void init(ServletConfig config) throws ServletException

    {

        try {

            super.init(config);

            ServletContext context = config.getServletContext();

            // Initialize the properties file for our options

            String dirPath = context.getRealPath(CONFIG_DIR);

            File propertyFile = new File(dirPath, CONFIG_NAME);

            String LOG_CONFIG_NAME = dirPath + "/log4j.properties";

            PropertyConfigurator.configureAndWatch(LOG_CONFIG_NAME);

            Options options = null;

            try {

                options = Options.initialize(propertyFile);

                MetaCatUtil.printMessage("Options configured: "

                        + options.getOption("configured"));

            } catch (IOException ioe) {

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

                logMetacat.error("Error in loading options: "

                        + ioe.getMessage());

            }

            MetaCatUtil util = new MetaCatUtil();

            //initialize DBConnection pool

            DBConnectionPool connPool = DBConnectionPool.getInstance();

            // Index the paths specified in the metacat.properties

            checkIndexPaths();

            // initiate the indexing Queue

            IndexingQueue.getInstance();

            // start the IndexingThread if indexingTimerTaskTime more than 0. 

            // It will index all the documents not yet indexed in the database             

            int indexingTimerTaskTime = Integer.parseInt(MetaCatUtil.getOption("indexingTimerTaskTime"));

            if(indexingTimerTaskTime > 0){

            	timer = new Timer();

            	timer.schedule(new IndexingTimerTask(), 0, indexingTimerTaskTime);

            }

            // read the config files: 

            Vector skins = MetaCatUtil.getOptionList(MetaCatUtil.getOption("skinconfigfiles"));

            String skinName, skinDirPath = null;

            File skinPropertyFile = null;

            for (int i = 0; i < skins.size(); i++) {

            	skinName = (String) skins.elementAt(i);

                skinDirPath = context.getRealPath(CONFIG_DIR + "/skin.configs/" + skinName);

                skinPropertyFile = new File(skinDirPath, skinName + ".properties"); 

                Properties skinOption = null;

                try	{

                	skinOption = new Properties();

                    FileInputStream fis = new FileInputStream(skinPropertyFile);

                    skinOption.load(fis);

                    fis.close();

                } catch (IOException ioe) {

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

                    logMetacat.error("Error in loading options for skin " + "skinName" +" : "

                            + ioe.getMessage());

                }                

                MetaCatUtil.skinconfigs.put(skinName, skinOption);

            }

            /*

             *  If spatial option is turned on and set to regenerate the

             *  spatial cache on restart, trigger the harvester 

             */

            if ( MetaCatUtil.getOption("runSpatialOption").equals("true") &&

                 MetaCatUtil.getOption("regenerateCacheOnRestart").equals("true") ) {

                // Begin timer

                long before = System.currentTimeMillis();

                // regenerate the entire spatial cache

                // may be expensive with many documents

                SpatialHarvester sh = new SpatialHarvester();

                sh.regenerate();

                sh.destroy();

                // End timer

                long after = System.currentTimeMillis();

                MetaCatUtil.printMessage(" ------ Spatial Harvester Time  " + (after - before) + "ms");

	    } else {

                MetaCatUtil.printMessage(" \n **** Spatial cache is not set to regenerate on restart");

            }

            MetaCatUtil.printMessage("Metacat (" + Version.getVersion()

                               + ") initialized.");

        } catch (ServletException ex) {

            throw ex;

        } catch (SQLException e) {

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

            logMetacat.error("Error in MetacatServlet.init: "

                    + e.getMessage());

        }

    }

    /**

     * Close all db connections from the pool

     */

    public void destroy()

    {

        // Close all db connection

        System.out.println("Destroying MetacatServlet");

        timer.cancel();

        IndexingQueue.getInstance().setMetacatRunning(false);

        DBConnectionPool.release();

    }

    /** Handle "GET" method requests from HTTP clients */

    public void doGet(HttpServletRequest request, HttpServletResponse response)

            throws ServletException, IOException

    {

        // Process the data and send back the response

        handleGetOrPost(request, response);

    }

    /** Handle "POST" method requests from HTTP clients */

    public void doPost(HttpServletRequest request, HttpServletResponse response)

            throws ServletException, IOException

    {

        // Process the data and send back the response

        handleGetOrPost(request, response);

    }

    /**

     * Index the paths specified in the metacat.properties

     */

    private void checkIndexPaths() {

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

        MetaCatUtil.pathsForIndexing

            = MetaCatUtil.getOptionList(MetaCatUtil.getOption("indexPaths"));

        if (MetaCatUtil.pathsForIndexing != null) {

            MetaCatUtil.printMessage("Indexing paths specified in metacat.properties....");

            DBConnection conn = null;

            int serialNumber = -1;

            PreparedStatement pstmt = null;

            PreparedStatement pstmt1 = null;

            ResultSet rs = null;

            for (int i = 0; i < MetaCatUtil.pathsForIndexing.size(); i++) {

                logMetacat.debug("Checking if '"

                           + (String) MetaCatUtil.pathsForIndexing.elementAt(i)

                           + "' is indexed.... ");

                try {

                    //check out DBConnection

                    conn = DBConnectionPool.

                        getDBConnection("MetaCatServlet.checkIndexPaths");

                    serialNumber = conn.getCheckOutSerialNumber();

                    pstmt = conn.prepareStatement(

                        "SELECT * FROM xml_path_index " + "WHERE path = ?");

                    pstmt.setString(1, (String) MetaCatUtil.pathsForIndexing

                                    .elementAt(i));

                    pstmt.execute();

                    rs = pstmt.getResultSet();

                    if (!rs.next()) {

                        logMetacat.debug(".....not indexed yet.");

                        rs.close();

                        pstmt.close();

                        conn.increaseUsageCount(1);

                        logMetacat.debug(

                              "Inserting following path in xml_path_index: "

                              + (String)MetaCatUtil.pathsForIndexing

                                                   .elementAt(i));

   			if(((String)MetaCatUtil.pathsForIndexing.elementAt(i)).indexOf("@")<0){ 

                        	pstmt = conn.prepareStatement("SELECT DISTINCT n.docid, "

                              		+ "n.nodedata, n.nodedatanumerical, n.parentnodeid"

                              		+ " FROM xml_nodes n, xml_index i WHERE"

                              		+ " i.path = ? and n.parentnodeid=i.nodeid and"

                              		+ " n.nodetype LIKE 'TEXT' order by n.parentnodeid");

			} else {

                        	pstmt = conn.prepareStatement("SELECT DISTINCT n.docid, "

                              		+ "n.nodedata, n.nodedatanumerical, n.parentnodeid"

                              		+ " FROM xml_nodes n, xml_index i WHERE"

                              		+ " i.path = ? and n.nodeid=i.nodeid and"

                              		+ " n.nodetype LIKE 'ATTRIBUTE' order by n.parentnodeid");

			}

                        pstmt.setString(1, (String) MetaCatUtil.

                                        pathsForIndexing.elementAt(i));

                        pstmt.execute();

                        rs = pstmt.getResultSet();

                        int count = 0;

                        logMetacat.debug(

                                       "Executed the select statement for: "

                                       + (String) MetaCatUtil.pathsForIndexing

                                         .elementAt(i));

                        try {

                            while (rs.next()) {

                                String docid = rs.getString(1);

                                String nodedata = rs.getString(2);

                                float nodedatanumerical = rs.getFloat(3);

                                int parentnodeid = rs.getInt(4);

                                if (!nodedata.trim().equals("")) {

                                    pstmt1 = conn.prepareStatement(

                                        "INSERT INTO xml_path_index"

                                        + " (docid, path, nodedata, "

                                        + "nodedatanumerical, parentnodeid)"

                                        + " VALUES (?, ?, ?, ?, ?)");

                                    pstmt1.setString(1, docid);

                                    pstmt1.setString(2, (String) MetaCatUtil.

                                                pathsForIndexing.elementAt(i));

                                    pstmt1.setString(3, nodedata);

                                    pstmt1.setFloat(4, nodedatanumerical);

                                    pstmt1.setInt(5, parentnodeid);

                                    pstmt1.execute();

                                    pstmt1.close();

                                    count++;

                                }

                            }

                        }

                        catch (Exception e) {

                            System.out.println("Exception:" + e.getMessage());

                            e.printStackTrace();

                        }

                        rs.close();

                        pstmt.close();

                        conn.increaseUsageCount(1);

                        logMetacat.info("Indexed " + count

                                + " records from xml_nodes for '"

                                + (String) MetaCatUtil.pathsForIndexing.elementAt(i)

                                + "'");

                    } else {

                    	logMetacat.debug(".....already indexed.");

                    }

                    rs.close();

                    pstmt.close();

                    conn.increaseUsageCount(1);

                } catch (Exception e) {

                    logMetacat.error("Error in MetaCatServlet.checkIndexPaths: "

                                             + e.getMessage());

                }finally {

                    //check in DBonnection

                    DBConnectionPool.returnDBConnection(conn, serialNumber);

                }

            }

            MetaCatUtil.printMessage("Path Indexing Completed");

        }

    }    

    /**

     * Control servlet response depending on the action parameter specified

     */

    private void handleGetOrPost(HttpServletRequest request,

            HttpServletResponse response) throws ServletException, IOException

    {

        MetaCatUtil util = new MetaCatUtil();

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

        /*

         * logMetacat.debug("Connection pool size: "

         * +connPool.getSizeOfDBConnectionPool(),10);

         * logMetacat.debug("Free DBConnection number: "

         */

        //If all DBConnection in the pool are free and DBConnection pool

        //size is greater than initial value, shrink the connection pool

        //size to initial value

        DBConnectionPool.shrinkDBConnectionPoolSize();

        //Debug message to print out the method which have a busy DBConnection

        try {

            DBConnectionPool pool = DBConnectionPool.getInstance();

            pool.printMethodNameHavingBusyDBConnection();

        } catch (SQLException e) {

            logMetacat.error("Error in MetacatServlet.handleGetOrPost: "

                    + e.getMessage());

            e.printStackTrace();

        }

        String ctype = request.getContentType();

        if (ctype != null && ctype.startsWith("multipart/form-data")) {

            handleMultipartForm(request, response);

        } else {

            String name = null;

            String[] value = null;

            String[] docid = new String[3];

            Hashtable params = new Hashtable();

            Enumeration paramlist = request.getParameterNames();

            while (paramlist.hasMoreElements()) {

                name = (String) paramlist.nextElement();

                value = request.getParameterValues(name);

                // Decode the docid and mouse click information

                if (name.endsWith(".y")) {

                    docid[0] = name.substring(0, name.length() - 2);

                    params.put("docid", docid);

                    name = "ypos";

                }

                if (name.endsWith(".x")) {

                    name = "xpos";

                }

                params.put(name, value);

            }

            //handle param is emptpy

            if (params.isEmpty() || params == null) { return; }

            //if the user clicked on the input images, decode which image

            //was clicked then set the action.

            if(params.get("action") == null){

                PrintWriter out = response.getWriter();

                response.setContentType("text/xml");

                out.println("<?xml version=\"1.0\"?>");

                out.println("<error>");

                out.println("Action not specified");

                out.println("</error>");

                out.close();

                return;

            }

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

            logMetacat.info("Action is: " + action);

            // This block handles session management for the servlet

            // by looking up the current session information for all actions

            // other than "login" and "logout"

            String username = null;

            String password = null;

            String[] groupnames = null;

            String sess_id = null;

            name = null;

            // handle login action

            if (action.equals("login")) {

                PrintWriter out = response.getWriter();

                handleLoginAction(out, params, request, response);

                out.close();

                // handle logout action

            }   else if (action.equals("logout")) {

                PrintWriter out = response.getWriter();

                handleLogoutAction(out, params, request, response);

                out.close();

                // handle shrink DBConnection request

            } else if (action.equals("shrink")) {

                PrintWriter out = response.getWriter();

                boolean success = false;

                //If all DBConnection in the pool are free and DBConnection

                // pool

                //size is greater than initial value, shrink the connection

                // pool

                //size to initial value

                success = DBConnectionPool.shrinkConnectionPoolSize();

                if (success) {

                    //if successfully shrink the pool size to initial value

                    out.println("DBConnection Pool shrunk successfully.");

                }//if

                else {

                    out.println("DBConnection pool not shrunk successfully.");

                }

                //close out put

                out.close();

                // aware of session expiration on every request

            } else {

                HttpSession sess = request.getSession(true);

                if (sess.isNew() && !params.containsKey("sessionid")) {

                    // session expired or has not been stored b/w user requests

                    logMetacat.info(

                            "The session is new or no sessionid is assigned. The user is public");

                    username = "public";

                    sess.setAttribute("username", username);

                } else {

                    logMetacat.info("The session is either old or "

                            + "has sessionid parameter");

                    try {

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

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

                            logMetacat.info("in has sessionid "

                                    + sess_id);

                            if (sessionHash.containsKey(sess_id)) {

                                logMetacat.info("find the id "

                                        + sess_id + " in hash table");

                                sess = (HttpSession) sessionHash.get(sess_id);

                            }

                        } else {

                            // we already store the session in login, so we

                            // don't need here

                            /*

                             * logMetacat.info("in no sessionid

                             * parameter ", 40); sess_id =

                             * (String)sess.getId();

                             * logMetacat.info("storing the session id "

                             * + sess_id + " which has username " +

                             * sess.getAttribute("username") + " into session

                             * hash in handleGetOrPost method", 35);

                             */

                        }

                    } catch (IllegalStateException ise) {

                        logMetacat.error(

                                "Error in handleGetOrPost: this shouldn't "

                                + "happen: the session should be valid: "

                                + ise.getMessage());

                    }

                    username = (String) sess.getAttribute("username");

                    logMetacat.info("The user name from session is: "

                            + username);

                    password = (String) sess.getAttribute("password");

                    groupnames = (String[]) sess.getAttribute("groupnames");

                    name = (String) sess.getAttribute("name");

                }

                //make user user username should be public

                if (username == null || (username.trim().equals(""))) {

                    username = "public";

                }

                logMetacat.info("The user is : " + username);

            }

            // Now that we know the session is valid, we can delegate the

            // request

            // to a particular action handler

            if (action.equals("query")) {

                PrintWriter out = response.getWriter();

                handleQuery(out, params, response, username, groupnames,

                        sess_id);

                out.close();

            } else if (action.equals("squery")) {

                PrintWriter out = response.getWriter();

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

                    handleSQuery(out, params, response, username, groupnames,

                            sess_id);

                    out.close();

                } else {

                    out.println(

                            "Illegal action squery without \"query\" parameter");

                    out.close();

                }

            } else if ( action.trim().equals("spatial_query")) {

              logMetacat.debug("******************* SPATIAL QUERY ********************");

              PrintWriter out = response.getWriter();

              handleSpatialQuery(out, params, response, username, groupnames, sess_id);

              out.close();

            } else if (action.equals("export")) {

                handleExportAction(params, response, username,

                        groupnames, password);

            } else if (action.equals("read")) {

                handleReadAction(params, request, response, username, password,

                        groupnames);

            } else if (action.equals("readinlinedata")) {

                handleReadInlineDataAction(params, request, response, username,

                        password, groupnames);

            } else if (action.equals("insert") || action.equals("update")) {

                PrintWriter out = response.getWriter();

                if ((username != null) && !username.equals("public")) {

                    handleInsertOrUpdateAction(request, response,

                            out, params, username, groupnames);

                } else {

                    response.setContentType("text/xml");

                    out.println("<?xml version=\"1.0\"?>");

                    out.println("<error>");

                    out.println("Permission denied for user " + username + " "

                            + action);

                    out.println("</error>");

                }

                out.close();

            } else if (action.equals("delete")) {

                PrintWriter out = response.getWriter();

                if ((username != null) && !username.equals("public")) {

                    handleDeleteAction(out, params, request, response, username,

                            groupnames);

                } else {

                    response.setContentType("text/xml");

                    out.println("<?xml version=\"1.0\"?>");

                    out.println("<error>");

                    out.println("Permission denied for " + action);

                    out.println("</error>");

                }

                out.close();

            } else if (action.equals("validate")) {

                PrintWriter out = response.getWriter();

                handleValidateAction(out, params);

                out.close();

            } else if (action.equals("setaccess")) {

                PrintWriter out = response.getWriter();

                handleSetAccessAction(out, params, username);

                out.close();

            } else if (action.equals("getaccesscontrol")) {

                PrintWriter out = response.getWriter();

                handleGetAccessControlAction(out, params, response, username,

                        groupnames);

                out.close();

            } else if (action.equals("getprincipals")) {

                PrintWriter out = response.getWriter();

                handleGetPrincipalsAction(out, username, password);

                out.close();

            } else if (action.equals("getdoctypes")) {

                PrintWriter out = response.getWriter();

                handleGetDoctypesAction(out, params, response);

                out.close();

            } else if (action.equals("getdtdschema")) {

                PrintWriter out = response.getWriter();

                handleGetDTDSchemaAction(out, params, response);

                out.close();

            } else if (action.equals("getlastdocid")) {

                PrintWriter out = response.getWriter();

                handleGetMaxDocidAction(out, params, response);

                out.close();

            } else if (action.equals("getrevisionanddoctype")) {

                PrintWriter out = response.getWriter();

                handleGetRevisionAndDocTypeAction(out, params);

                out.close();

            } else if (action.equals("getversion")) {

                response.setContentType("text/xml");

                PrintWriter out = response.getWriter();

                out.println(Version.getVersionAsXml());

                out.close();

            } else if (action.equals("getlog")) {

                handleGetLogAction(params, request, response, username, groupnames);

            } else if (action.equals("getloggedinuserinfo")) {

                PrintWriter out = response.getWriter();

                response.setContentType("text/xml");

                out.println("<?xml version=\"1.0\"?>");

                out.println("\n<user>\n");

                out.println("\n<username>\n");

                out.println(username);

                out.println("\n</username>\n");

                if(name!=null){

                	out.println("\n<name>\n");

                	out.println(name);

                	out.println("\n</name>\n");

                }

                if(MetaCatUtil.isAdministrator(username, groupnames)){

                	out.println("<isAdministrator></isAdministrator>\n");	

                }

                if(MetaCatUtil.isModerator(username, groupnames)){

                	out.println("<isModerator></isModerator>\n");	

                }

                out.println("\n</user>\n");

                out.close();

            } else if (action.equals("buildindex")) {

                handleBuildIndexAction(params, request, response, username, groupnames);

            } else if (action.equals("login") || action.equals("logout")) {

                /*

            } else if (action.equals("protocoltest")) {

                String testURL = "metacat://dev.nceas.ucsb.edu/NCEAS.897766.9";

                try {

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

                } catch (Throwable t) {

                }

                String phandler = System

                        .getProperty("java.protocol.handler.pkgs");

                response.setContentType("text/html");

                PrintWriter out = response.getWriter();

                out.println("<body bgcolor=\"white\">");

                out.println("<p>Handler property: <code>" + phandler

                        + "</code></p>");

                out.println("<p>Starting test for:<br>");

                out.println("    " + testURL + "</p>");

                try {

                    URL u = new URL(testURL);

                    out.println("<pre>");

                    out.println("Protocol: " + u.getProtocol());

                    out.println("    Host: " + u.getHost());

                    out.println("    Port: " + u.getPort());

                    out.println("    Path: " + u.getPath());

                    out.println("     Ref: " + u.getRef());

                    String pquery = u.getQuery();

                    out.println("   Query: " + pquery);

                    out.println("  Params: ");

                    if (pquery != null) {

                        Hashtable qparams = MetaCatUtil.parseQuery(u.getQuery());

                        for (Enumeration en = qparams.keys(); en

                                .hasMoreElements();) {

                            String pname = (String) en.nextElement();

                            String pvalue = (String) qparams.get(pname);

                            out.println("    " + pname + ": " + pvalue);

                        }

                    }

                    out.println("</pre>");

                    out.println("</body>");

                    out.close();

                } catch (MalformedURLException mue) {

                    System.out.println(

                            "bad url from MetacatServlet.handleGetOrPost");

                    out.println(mue.getMessage());

                    mue.printStackTrace(out);

                    out.close();

                }

                */

            } else {

                PrintWriter out = response.getWriter();

                out.println("<?xml version=\"1.0\"?>");

                out.println("<error>");

                out.println(

                     "Error: action not registered.  Please report this error.");

                out.println("</error>");

                out.close();

            }

            //util.closeConnections();

            // Close the stream to the client

            //out.close();

        }

    }

    /////////////////////////////// METACAT SPATIAL ///////////////////////////

    /**

     * handles all spatial queries -- these queries may include any of the 

     * queries supported by the WFS / WMS standards

     * 

     * handleSQuery(out, params, response, username, groupnames,

     *                        sess_id);

     */

    private void handleSpatialQuery(PrintWriter out, Hashtable params, 

                                    HttpServletResponse response,

                                    String username, String[] groupnames, 

                                    String sess_id) {

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

	if ( !MetaCatUtil.getOption("runSpatialOption").equals("true") ) {

        	response.setContentType("text/html");

        	out.println("<html> Metacat Spatial Option is turned off <html>");

        	out.close();

		return ;

	}		

        /* 

         * Perform spatial query against spatial cache

         */

        Float _xmax = Float.parseFloat( ((String[]) params.get("XMAX"))[0] );

        Float _ymax = Float.parseFloat( ((String[]) params.get("YMAX"))[0] );

        Float _xmin = Float.parseFloat( ((String[]) params.get("XMIN"))[0] );

        Float _ymin = Float.parseFloat( ((String[]) params.get("YMIN"))[0] );

        SpatialQuery sq = new SpatialQuery();

        Vector docids = sq.filterByBbox( _xmin, _ymin, _xmax, _ymax );

        logMetacat.info(" --- Spatial Query completed. Passing on the SQuery handler");

        /*

         * Create an squery based on vector of matching docids

         */

        String [] docidArray = new String[docids.size()];

        docids.toArray(docidArray);

        String squery = DocumentIdQuery.createDocidQuery( docidArray );

        /*

         * Pass to squery handler

         */

        String[] queryArray = new String[1];

        queryArray[0] = squery;

        params.put("query", queryArray);

        // qformat

        String[] qformatArray = new String[1];

        try {

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

            qformatArray[0] = _skin;

        } catch (java.lang.NullPointerException e) {

            // should be "default" but keep this for backwards compatibility with knp site

            logMetacat.warn("No SKIN specified for metacat actions=spatial_query... defaulting to 'knp' skin !\n");

            qformatArray[0] = "knp";

        }

        params.put("qformat", qformatArray);

        // change the action

        String[] actionArray = new String[1];

        actionArray[0] = "squery";

        params.put("action", actionArray);

        handleSQuery(out, params, response, username, groupnames, sess_id);

  }

    /**

     * Create a metacat squery for spatial data coordinates.

     */

    private String createSpatialQuery(float _xmin, float _ymin, float _xmax, float _ymax) {

	StringBuffer sb = new StringBuffer();

	sb.append("<pathquery version=\"1.2\">");

	sb.append("<querytitle>Untitled-Search-3</querytitle>");

	sb.append("<returndoctype>-//ecoinformatics.org//eml-dataset-2.0.0beta4//EN</returndoctype>");

	sb.append("<returndoctype>-//ecoinformatics.org//eml-dataset-2.0.0beta6//EN</returndoctype>");

	sb.append("<returndoctype>-//NCEAS//eml-dataset-2.0//EN</returndoctype>");

	sb.append("<returndoctype>-//NCEAS//resource//EN</returndoctype>");

	sb.append("<returndoctype>eml://ecoinformatics.org/eml-2.0.0</returndoctype>");

	sb.append("<returndoctype>eml://ecoinformatics.org/eml-2.0.1</returndoctype>");

	sb.append("<returndoctype>metadata</returndoctype>");

	sb.append("<returnfield>dataset/title</returnfield>");

	sb.append("<returnfield>originator/individualName/surName</returnfield>");

	sb.append("<returnfield>originator/individualName/givenName</returnfield>");

	sb.append("<returnfield>originator/organizationName</returnfield>");

	sb.append("<returnfield>creator/individualName/surName</returnfield>");