Metacat

/**

 *  '$RCSfile$'

 *  Copyright: 2003 Regents of the University of California.

 *

 *   '$Author: harris $'

 *     '$Date: 2006-02-16 13:41:30 -0800 (Thu, 16 Feb 2006) $'

 * '$Revision: 2909 $'

 *

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

import java.io.File;

import java.io.FileReader;

import java.io.PrintWriter;

import java.io.IOException;

import java.io.StringReader;

import java.io.BufferedReader;

import java.io.Reader;

import java.io.FileInputStream;

import java.io.BufferedInputStream;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.ResourceBundle;

import java.util.Random;

import java.util.StringTokenizer;

import java.util.Properties;

import java.util.PropertyResourceBundle;

import java.util.Vector;

import java.util.Map;

import java.net.MalformedURLException;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.Connection;

import java.sql.SQLException;

import java.lang.reflect.*;

import java.net.*;

import java.util.zip.*;

import javax.servlet.ServletConfig;

import javax.servlet.ServletContext;

import javax.servlet.ServletException;

import javax.servlet.ServletInputStream;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

import javax.servlet.http.HttpUtils;

import javax.servlet.ServletOutputStream;

import edu.ucsb.nceas.metacat.client.Metacat;

import edu.ucsb.nceas.metacat.client.MetacatFactory;

import edu.ucsb.nceas.metacat.client.MetacatAuthException;

import edu.ucsb.nceas.metacat.client.MetacatException;

import edu.ucsb.nceas.metacat.client.MetacatInaccessibleException;

import edu.ucsb.nceas.metacat.client.InsufficientKarmaException;

import edu.ucsb.nceas.utilities.IOUtil;

import org.apache.log4j.Logger;

import org.apache.log4j.BasicConfigurator;

import org.apache.log4j.PropertyConfigurator;

/**

 * An application that manages the registration of ecological networks using the

 * metacat technology

 */

public class SpatialQueryManager extends HttpServlet

{

  private ServletConfig config = null;

  private ServletContext context = null;

  private Properties appConfig = null;

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

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

  private static final String STYLE_DIR = "WEB-INF/";

  private String defaultStyle = null;

  private String metacatUrl = null;

  private String queryName = null;

  private String invalidRegistrationErrorPage = null;

// private EcoNetwork network;

  private String mcUser = "uid=jones,o=NCEAS,dc=ecoinformatics,dc=org";

  private String mcPass = "@mcpass@";

//	private  EconetCache cache;

  protected SpatialQueryProcessor queryProcessor;

	// this is the key val for the econet summary to be in the cache and 

	// it must be the same value as the value in the manager

//	private static String ECONET_SUMMARY_KEY = "econet_summary"; 

  private static Logger log = Logger.getLogger(SpatialQueryManager.class.getName());

  /**

   * Initialize the servlet during container startup

   */

  public void init(ServletConfig config) throws ServletException

  {

    try

    {

      super.init(config);

      this.config = config;

      this.context = config.getServletContext();

      //BasicConfigurator.configure();

      String prefix = getServletContext().getRealPath("/");

      System.out.println("SpatialQueryManager servlet context path  ####################### >>> " + prefix);

      String file = getInitParameter("log4j-init-file");

      System.out.println("SpatialQueryManager log4j-init-file  ####################### >>> " + file);

      System.out.println("SpatialQueryManager econet - metacat acct:  ####################### >>> " + mcUser);

      // if the log4j-init-file is not set, then no point in trying

      if (file != null)

      {

        PropertyConfigurator.configure(prefix + file);

      }

      try

      {

        // locate, open, and read the properties

        appConfig = new Properties();

        String dirPath = context.getRealPath(CONFIG_DIR);

        File propertyFile = new File(dirPath, CONFIG_NAME);

        FileInputStream fis = new FileInputStream(propertyFile);

				appConfig.load(fis);

				fis.close();

				defaultStyle = (String) appConfig.get("defaultStyle");

				metacatUrl = (String) appConfig.get("metacatUrl");

				System.out.println("SpatialQueryManager using metacat at url:  ####################### >>> " + metacatUrl);

				queryName = (String)appConfig.get("queryName");

				System.out.println("SpatialQueryManager query name :  ####################### >>> " + queryName);

				invalidRegistrationErrorPage = (String) appConfig.get("invalidRegistrationErrorPage");

      }

      catch(Throwable t)

      {

        throw new ServletException(t.getMessage());

      }

    }

    catch(ServletException ex) {

      throw ex;

    }

  }

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

  public void doGet(HttpServletRequest request, HttpServletResponse response)

  throws ServletException, IOException

  {

    handleGetOrPost(request, response);

  }

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

  public void doPost(HttpServletRequest request, HttpServletResponse response)

  throws ServletException, IOException

  {

    handleGetOrPost(request, response);

  }

  /**

   * Control servlet response depending on the action parameter specified

   */

  private void handleGetOrPost(HttpServletRequest request, HttpServletResponse response)

  throws ServletException, IOException

  {

    Hashtable params = getParamHash(request);

    String action = getAction(request);

      log.debug(">> action " + action);

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

      handleListAction(request, response);

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

      //handleRegisterAction(request, response);

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

      handleDeleteAction(request, response);

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

      handleDisplayDocAction(request, response);

    } else {

      handleListAction(request, response);

    }

  }

  /**

    * Reads a document from metacat and displays the information to the browser

    * @param request -- the HTTP request object

    * @param response -- the HTTP response object

    */

  private void handleDisplayDocAction(HttpServletRequest request, HttpServletResponse response)

  throws IOException

  {

    Hashtable params = getParamHash(request);

    String contextPath = request.getContextPath();

    String action = getAction(request);

    String styleSystemId = getStyleSystemId(action, defaultStyle);

    String docid = (String) getParamHash(request).get("docId");

    PrintWriter out = response.getWriter();

    ServletContext servletContext = getServletContext();

    response.setContentType ("text/html");

    if (docid != null && !docid.trim().equals(""))

    {

      try {

				String doc = null;

	//			if ( cache.recover(docid) == null ) {

					log.debug("docid in the cache is null ... going to the db");

					Metacat m = MetacatFactory.createMetacatConnection(metacatUrl);

					m.login(mcUser, mcPass);

					Reader r = m.read(docid);

					doc = IOUtil.getAsString(r, true);

					r.close();

					m.logout();

					// adding this was giving a concurrent modification exception

					//cache.admit(docid, doc);

	//			} else {

//					log.debug("docid in the cache is valid");

//					doc = (String)cache.recover(docid);

//				}

        String dirPath = context.getRealPath(CONFIG_DIR);

				XSLTransform.transform(doc, styleSystemId, out, params);

				out.close();	

      }

      catch(Exception e) { e.printStackTrace(); }

    } else {

      out.println("no such docid!");

    }

    out.close();

  }

  /**

    * Deletes a network from the registration system.  This is called by the 

    * administrator to delete a registry from metacat. There is no response to 

    * the calling device - instead details are written to the logger 

    * @param request -- the HTTP request object

    * @param response -- the HTTP response object

    */

  private void handleDeleteAction(HttpServletRequest request, HttpServletResponse response) throws IOException

  {

    Hashtable params = getParamHash(request);

    String docId = (String)params.get("docId");

    // for the Metacat.delete request to be called the password needs to be the 

    // same as the mcpass var.

    String pass = (String)params.get("password");

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

      if ( pass.equals(mcPass) ) {

        log.info(">> deleting docid: " + docId);

        // add a lookup for an issued password.

        try

        {

         Metacat m = MetacatFactory.createMetacatConnection(metacatUrl);

         log.info(mcUser + " " + mcPass);

         m.login(mcUser, mcPass);

         String resp = m.delete(docId);

         log.info(">>deletion success is: " + resp);

        }

        catch(Exception e) { e.printStackTrace(); }

      }

    else { log.fatal("attempt to delete a registry with invalid pass"); }

    }

    else { log.fatal("attempt to delete a registry with NO pass"); }

  }

  /**

    *  Display the registered networks.  This is called when a list of 

    * regestered networks is requested for display and a transformation

    * is needed.  It queries the registered networks and then transforms the 

    * network docs using XSLT and displays the networks.

    * @param request -- the HTTP request object

    * @param response -- the HTTP response object

    */

  private void handleListAction(HttpServletRequest request, HttpServletResponse response) throws IOException

  {

    Hashtable params = getParamHash(request);

    String contextPath = request.getContextPath();

    String action = getAction(request);

    String styleSystemId = getStyleSystemId(action, defaultStyle);

    //String style = (String)pathData.get(1);

    PrintWriter out = response.getWriter();

    ServletContext servletContext = getServletContext();

    response.setContentType ("text/html");

    // get the query document

    String dirPath = context.getRealPath(CONFIG_DIR);

    File queryFile = new File(dirPath, queryName);

    // Query for the documents from the server

    String queryResult = null;

    try {

      // if the cache doesnt have the summary then get it from the database

//		if ( cache.recover(ECONET_SUMMARY_KEY) == null ) {

//			log.debug("summary in the cache is null ... going to the db");

				queryResult = queryProcessor.execute();

//				cache.admit(ECONET_SUMMARY_KEY, queryResult);

//			} else {

//				log.debug("summary in the cache is valid");

//				queryResult = (String)cache.recover(ECONET_SUMMARY_KEY);

//			}

    } catch(Exception e) { e.printStackTrace(); }

    log.debug("query result >> " + queryResult);

    XSLTransform.transform(queryResult, styleSystemId, out, params);

    out.close();

  }

  /**

    *  Register the network.  This is called when the attributes of a network 

    *  are submitted to the system.

    *

    * @param request -- the HTTP request object

    * @param response -- the HTTP response object

    */

/**  private void handleRegisterAction(HttpServletRequest request, HttpServletResponse response) throws IOException

  {

    Map params = getParamHash(request);

    String contextPath = request.getContextPath();

    String action = getAction(request);

    network = new EcoNetwork((Map) params);

    // add a validation step here 

    if (network.isValid() == true)

    {

      PrintWriter out = response.getWriter();

      response.setContentType ("text/html");

        log.info("about to insert: " + network.toXML());

      String metacatResponse = insertEcoNetwork(network.toXML());

        log.info("metacat response: " + metacatResponse);

      String styleSystemId = getStyleSystemId(action, defaultStyle);

        log.info("registration system id  " + styleSystemId);

        XSLTransform.transform(metacatResponse, styleSystemId, out, (Hashtable) params);

        // clear the summary from the cache which will be recovered either next

        // time the show all docs function is called or the ttl in the cache is

        // achived.

				cache.clear();

        out.close();

    } else

    {

      //redirect somewhere

      response.sendRedirect(invalidRegistrationErrorPage);

    }

  }

**/

    /**

      * Inserts the registration document to metacat.  After the registration

      * has been processed and validated the XML representation is submitted

      * to the metacat system

      *  @param networkXML -- the xml document containing the econetwork 

      *     data represented as a java string. 

      *  @return metacatResponse -- the response from metacat

      */

/**  private String insertEcoNetwork(String networkXML)

  {

    String error = null;

    String response = null;

    try {

      Metacat m = MetacatFactory.createMetacatConnection(metacatUrl);

      log.info(mcUser + " " + mcPass);

      m.login(mcUser, mcPass);

      int i = (int) (java.lang.Math.random() * 1000);

      log.info(" inserting document: " + "econet." + i + ".1");

      response = m.insert("econet." + i + ".1", new StringReader(networkXML), null);

      log.info(" metacat response: " + response);

    }

    catch(Exception e) {

      e.printStackTrace();

    }

    return response;

  }

**/

  /**

    * Gets the "action" parameter from the http request object

    * @param request -- the http request object

    * @return action -- the action requested of this servlet 

    */

  private String getAction(HttpServletRequest request)

  throws NullPointerException

  {

    String action = (String) getParamHash(request).get("action");

      return action;

  }

  /**

     * Get the stylesheet systemid from the properties file for a given

     * action and style set.

     *

     * @param action the servlet request action

     * @param style the name of the style to be used

     * @return a String containing the system id of the stylesheet to be used

     */

  private String getStyleSystemId(String action, String style)

  throws IOException

  {

    String key = action + "." + style;

    //log.info("key >>" + key);

    String filename = (String) appConfig.get(key);

    //log.info("filename >>" + filename);

    String stylePath = context.getRealPath(STYLE_DIR);

    //log.info("stylePath>>" + stylePath);

    File xslFile = new File(stylePath, filename);

    String systemId = xslFile.getCanonicalPath();

      systemId = "file://" + systemId;

      log.info("returning systemId >> " + systemId + " for action.style: " + key);

      return systemId;

  }

  /**

    * utility function to convert the request object into a hashtable 

    * @param request -- the http request object

    * @return paramHash -- hashtable containing the name-value pairs

    */

  private Hashtable getParamHash(HttpServletRequest request)

  {

    Hashtable params = new Hashtable();

    try {

      Enumeration enum = request.getParameterNames();

      while (enum.hasMoreElements()) {

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

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

        if (values != null) {

          for (int i = 0; i < values.length; i++) {

            params.put(name, values[i]);

          }

        }

      }

    }

    catch(Exception e) {

      e.printStackTrace();

    }

    return (params);

  }

}