/ - Diff - Metacat - Ecoinformatics Redmine

     <html>
     <head>
     <title>Untitled Document</title>
     <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
     </head>
     <body bgcolor="#FFFFFF" text="#000000">
     <form name="form1" method="post" action="../../../metacat">
       <p>action
         <input type="text" name="action">
       </p>
       <p>qformat
         <input type="text" name="qformat">
       </p>
       <p>query
         <textarea name="dataquery" rows="20" cols="80"></textarea>
       </p>
       <p>
         <input type="submit" name="Submit" value="Submit">
       </p>
     </form>
     </body>
     </html>

     #turn on or off the query result cache
     database.queryCacheOn=true
     ######## Datamanager section              #######################################
     datamanager.adapter=PostgresAdapter
     datamanager.implementation=edu.ucsb.nceas.metacat.dataquery.PostgresDatabaseConnectionPool
     datamanager.server=localhost
     datamanager.database=datamanager
     datamanager.user=datamanager
     datamanager.password=datamanager
     datamanager.maxconnections=10
     datamanager.endpoint.query=http://ecogrid.ecoinformatics.org/knb/services/QueryService
     datamanager.endpoint.authentication=http://ecogrid.ecoinformatics.org/knb/services/AuthenticationService
     datamanager.endpoint.put=http://ecogrid.ecoinformatics.org/knb/services/PutService
     datamanager.endpoint.identifier=http://ecogrid.ecoinformatics.org/knb/services/IdentificationService
     datamanager.srb.endpoint=
     datamanager.srb.machinename=
     ######## LDAP ##############################################
     auth.class=edu.ucsb.nceas.metacat.AuthLdap

     import java.io.FileInputStream;
     import java.io.FileReader;
     import java.io.IOException;
     import java.io.OutputStreamWriter;
     import java.io.PrintWriter;
     import java.io.StringReader;
     import java.io.Writer;
     import java.net.MalformedURLException;
     import java.net.URL;
     import java.sql.PreparedStatement;
-...
     import org.apache.log4j.PropertyConfigurator;
     import org.ecoinformatics.eml.EMLParser;
     import au.com.bytecode.opencsv.CSVWriter;
     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.metacat.dataquery.DataQuery;
     import edu.ucsb.nceas.metacat.service.PropertyService;
     import edu.ucsb.nceas.metacat.service.ServiceException;
     import edu.ucsb.nceas.metacat.service.SessionService;
-...
     							sess_id);
     					out.close();
     				} else if (action.equals("export")) {
+    				}
     				else if (action.trim().equals("dataquery")) {
     					logMetacat
     							.debug("******************* DATA QUERY ********************");
     					handleDataquery(params, response);
+    				}
     				else if (action.equals("export")) {
     					handleExportAction(params, response, username, groupnames, password);
     				} else if (action.equals("read")) {
     					handleReadAction(params, request, response, username, password,
-...
+    		}
+    	}
     	private void handleDataquery(
     			Hashtable<String, String[]> params,
                 HttpServletResponse response) throws PropertyNotFoundException, IOException {
     		DataQuery dq = new DataQuery();
         	String dataqueryXML = ((String[])params.get("dataquery"))[0];
         	ResultSet rs = null;
     		try {
     			rs = dq.executeQuery(dataqueryXML);
     		} catch (Exception e) {
     			//probably need to do something here
     			e.printStackTrace();
     			return;
+    		}
     		//process the result set
     		String qformat = "csv";
     		String[] temp = params.get("qformat");
     		if (temp != null && temp.length > 0) {
     			qformat = temp[0];
+    		}
     		String fileName = "query-results." + qformat;
     		//get the results as csv file
     		if (qformat != null && qformat.equalsIgnoreCase("csv")) {
     			response.setContentType("text/csv");
     			//response.setContentType("application/csv");
     	        response.setHeader("Content-Disposition", "attachment; filename=" + fileName);
     			Writer writer = new OutputStreamWriter(response.getOutputStream());
     			CSVWriter csv = new CSVWriter(writer, CSVWriter.DEFAULT_SEPARATOR, CSVWriter.NO_QUOTE_CHARACTER);
     			try {
     				csv.writeAll(rs, true);
     				csv.flush();
     				response.flushBuffer();
     				rs.close();
     			} catch (SQLException e) {
     				e.printStackTrace();
+    			}
     			return;
+    		}
+    	}
         // ///////////////////////////// METACAT SPATIAL ///////////////////////////
         /**

     /**
      *  '$RCSfile$'
      *  Copyright: 2008 Regents of the University of California and the
      *             National Center for Ecological Analysis and Synthesis
+     *
      * Author: Benjamin Leinfelder
      * '$Date:  $'
      * '$Revision:  $'
+     *
      * 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.dataquery;
     import java.sql.ResultSet;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import org.ecoinformatics.datamanager.DataManager;
     import org.ecoinformatics.datamanager.database.DatabaseConnectionPoolInterface;
     import org.ecoinformatics.datamanager.database.Query;
     import org.ecoinformatics.datamanager.database.Union;
     import org.ecoinformatics.datamanager.dataquery.DataquerySpecification;
     import org.ecoinformatics.datamanager.download.EcogridEndPointInterface;
     /**
      * Class to query data
      */
     public class DataQuery {
     	private static Log log = LogFactory.getLog(DataQuery.class);
     	private EcogridEndPointInterface endPointInfo;
     	private DatabaseConnectionPoolInterface connectionPool;
     	private DataManager dataManager;
     	private String parserName = "org.apache.xerces.parsers.SAXParser";
     	/**
     	 * empty constructor to initialize query
     	 */
     	public DataQuery() {
     		// initialize the necessary parts
     		endPointInfo = new ConfigurableEcogridEndPoint();
     		connectionPool = new PostgresDatabaseConnectionPool();
     		dataManager =
     			DataManager.getInstance(connectionPool, connectionPool.getDBAdapterName());
+    	}
     	public ResultSet executeQuery(String xml) throws Exception {
     		// parse the query
     		DataquerySpecification specification =
     			new DataquerySpecification(xml, parserName, connectionPool, endPointInfo);
     		// get the results
     		ResultSet resultset = null;
     		Union union = specification.getUnion();
     		if (union != null) {
     			resultset =
     				dataManager.selectData(
     						union,
     						specification.getDataPackages());
     		} else {
     			Query query = specification.getQuery();
     			resultset =
     				dataManager.selectData(
     						query,
     						specification.getDataPackages());
+    		}
     		return resultset;
+    	}
+    }

     /**
      *    '$RCSfile: PostgresDatabaseConnectionPool.java,v $'
+     *
      *     '$Author: leinfelder $'
      *       '$Date: 2007/10/19 18:50:11 $'
      *   '$Revision: 1.1 $'
+     *
      *  For Details: http://ecoinformatics.org
+     *
      * Copyright (c) 2007 The Regents of the University of California.
      * All rights reserved.
+     *
      * Permission is hereby granted, without written agreement and without
      * license or royalty fees, to use, copy, modify, and distribute this
      * software and its documentation for any purpose, provided that the
      * above copyright notice and the following two paragraphs appear in
      * all copies of this software.
+     *
      * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
      * FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
      * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
      * IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY
      * OF SUCH DAMAGE.
+     *
      * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
      * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
      * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
      * PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY
      * OF CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT,
      * UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
      */
     package edu.ucsb.nceas.metacat.dataquery;
     import java.sql.Connection;
     import java.sql.SQLException;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import org.ecoinformatics.datamanager.database.ConnectionNotAvailableException;
     import org.ecoinformatics.datamanager.database.DatabaseConnectionPoolInterface;
     import org.postgresql.jdbc3.Jdbc3PoolingDataSource;
     import edu.ucsb.nceas.metacat.service.PropertyService;
     import edu.ucsb.nceas.utilities.PropertyNotFoundException;
     /**
      * This class implements DataConnetionPoolInterface to provide a connection for
      * testing. Database information in this class will be read from property file.
+     *
      * @author tao
+     *
      */
     public class PostgresDatabaseConnectionPool implements
     		DatabaseConnectionPoolInterface {
     	public static Log log = LogFactory.getLog(PostgresDatabaseConnectionPool.class);
     	/* Configuration properties file */
     	private static String serverName = null;
     	private static String databaseName = null;
     	private static String user = null;
     	private static String password = null;
     	private static int maxConnections = 0;
     	private static String databaseAdapterName = null;
     	private static Jdbc3PoolingDataSource source = null;
     	private static int connCount = 0;
     	/**
     	 * Constructor. Loading database parameter from property file
+    	 *
     	 */
     	public PostgresDatabaseConnectionPool() {
     		try {
     			loadOptions();
+    		}
     		catch (PropertyNotFoundException e) {
     			log.error(e.getMessage());
     			e.printStackTrace();
+    		}
     		initPool();
+    	}
     	private static void initPool() {
     		source = new Jdbc3PoolingDataSource();
     		//source.setDataSourceName(databaseAdapterName);
     		source.setServerName(serverName);
     		source.setDatabaseName(databaseName);
     		source.setUser(user);
     		source.setPassword(password);
     		source.setMaxConnections(maxConnections);
+    	}
     	/**
     	 * Loads Data Manager options from a configuration file.
     	 * @throws PropertyNotFoundException
     	 */
     	private static void loadOptions() throws PropertyNotFoundException {
     		serverName = PropertyService.getProperty("datamanager.server");
     		databaseName = PropertyService.getProperty("datamanager.database");
     		user = PropertyService.getProperty("datamanager.user");
     		password = PropertyService.getProperty("datamanager.password");
     		maxConnections =
     			Integer.parseInt(
     				PropertyService.getProperty("datamanager.maxconnections"));
     		databaseAdapterName = PropertyService.getProperty("datamanager.adapter");
+    	}
     	/**
     	 * Get dabase adpater name.
+    	 *
     	 * @return database adapter name
     	 */
     	public String getDBAdapterName() {
     		return databaseAdapterName;
+    	}
     	/**
     	 * Gets a database connection from the pool
+    	 *
     	 * @return checked out connection
     	 * @throws SQLException
     	 */
     	public Connection getConnection() throws SQLException,
     			ConnectionNotAvailableException {
     		Connection connection = null;
     		try {
     			connection = source.getConnection();
     			connCount++;
     		} catch (SQLException e) {
     			System.err.println("SQLException: " + e.getMessage());
     			throw (e);
+    		}
     		return connection;
+    	}
     	/**
     	 * Returns checked out dabase connection to the pool
+    	 *
     	 * @param conn
     	 *            Connection needs to be returned.
     	 * @return indicator if the connection was returned successfully
     	 */
     	public boolean returnConnection(Connection conn) {
     		boolean success = false;
     		try {
     			conn.close();
     			success = true;
     			connCount--;
     		} catch (Exception e) {
     			success = false;
+    		}
     		//log.debug(Thread.currentThread().getName() + ": connection count=" + connCount);
     		return success;
+    	}
     	public static void main(String arg[]) {
     		PostgresDatabaseConnectionPool pool = new PostgresDatabaseConnectionPool();
     		try {
     			Connection conn = pool.getConnection();
     			log.debug("conn=" + conn);
     			conn.close();
     		} catch (SQLException e) {
     			// TODO Auto-generated catch block
     			e.printStackTrace();
     		} catch (ConnectionNotAvailableException e) {
     			// TODO Auto-generated catch block
     			e.printStackTrace();
+    		}
+    	}
+    }

     /**
      *    '$RCSfile: ConfigurableEcogridEndPoint.java,v $'
+     *
      *     '$Author: leinfelder $'
      *       '$Date: 2008/06/20 17:47:12 $'
      *   '$Revision: 1.1 $'
+     *
      *  For Details: http://ecoinformatics.org
+     *
      * Copyright (c) 2007 The Regents of the University of California.
      * All rights reserved.
+     *
      * Permission is hereby granted, without written agreement and without
      * license or royalty fees, to use, copy, modify, and distribute this
      * software and its documentation for any purpose, provided that the
      * above copyright notice and the following two paragraphs appear in
      * all copies of this software.
+     *
      * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
      * FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
      * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
      * IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY
      * OF SUCH DAMAGE.
+     *
      * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
      * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
      * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
      * PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY
      * OF CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT,
      * UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
      */
     package edu.ucsb.nceas.metacat.dataquery;
     import org.ecoinformatics.datamanager.download.EcogridEndPointInterface;
     import edu.ucsb.nceas.metacat.service.PropertyService;
     import edu.ucsb.nceas.utilities.PropertyNotFoundException;
     /**
      * This class implements EcogridEndPointInterface and is configurable using a properties file.
      * Should be useful for switching to remote endpoints etc.
+     *
      * @author leinfelder
+     *
      */
     public class ConfigurableEcogridEndPoint implements EcogridEndPointInterface
+    {
     	private String metacatEcogridEndPoint = null;
     	private String metacatEcogridAuthEndPoint = null;
     	private String metacatEcogridPutEndPoint = null;
     	private String metacatEcogridIdentifierEndPoint = null;
     	private String srbEcogridEndPoint = null;
     	private String srbMachineName = null;
     	public ConfigurableEcogridEndPoint() {
     		try {
     			metacatEcogridEndPoint 				= PropertyService.getProperty("datamanager.endpoint.query");
     			metacatEcogridAuthEndPoint 			= PropertyService.getProperty("datamanager.endpoint.authentication");
     			metacatEcogridPutEndPoint 			= PropertyService.getProperty("datamanager.endpoint.put");
     			metacatEcogridIdentifierEndPoint 	= PropertyService.getProperty("datamanager.endpoint.identifier");
     			srbEcogridEndPoint 					= PropertyService.getProperty("datamanager.srb.endpoint");
     			srbMachineName 						= PropertyService.getProperty("datamanager.srb.machinename");
     		} catch (PropertyNotFoundException e) {
     			e.printStackTrace();
+    		}
+    	}
     	 /**
     	    * Gets the end point which Metacat implements ecogrid interface.
     	    * This end point will be used to handle ecogrid protocol
+            *
     	    * @return end point url string
     	    */
     	   public String getMetacatEcogridEndPoint()
+    	   {
     		   return metacatEcogridEndPoint;
+    	   }
     	   public String getMetacatEcogridAuthEndPoint()
+    	   {
     		   return metacatEcogridAuthEndPoint;
+    	   }
     	   public String getMetacatEcogridPutEndPoint()
+    	   {
     		   return metacatEcogridPutEndPoint;
+    	   }
     	   public String getMetacatEcogridIdentifierEndPoint()
+    	   {
     			return metacatEcogridIdentifierEndPoint;
+    		}
     	   /**
     	    * Gets the end point which SRB implements ecogrid interface.
     	    * This end point will be used to handle srb protocol.
+            *
     	    * @return end point url string
     	    */
     	   public String getSRBEcogridEndPoint()
+    	   {
     		   return srbEcogridEndPoint;
+    	   }
     	   /**
     	    * Gets the machine name which srb protocol will be used.
     	    * The default value for this class is "srb-mcat.sdsc.edu".
+            *
     	    * @return the machine name of srb server
     	    */
     	   public String getSRBMachineName()
+    	   {
     		   return srbMachineName;
+    	   }
+    }

Project

General

Profile

Metacat

Revision 4221

Added by ben leinfelder over 16 years ago