Metacat

/**

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

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

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.Hashtable;

import javax.servlet.ServletConfig;

import javax.servlet.ServletContext;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.PropertyConfigurator;

import edu.ucsb.nceas.metacat.database.DBConnectionPool;

import edu.ucsb.nceas.metacat.database.DatabaseService;

import edu.ucsb.nceas.metacat.plugin.MetacatHandlerPluginManager;

import edu.ucsb.nceas.metacat.properties.SkinPropertyService;

import edu.ucsb.nceas.metacat.shared.MetacatUtilException;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

 * A metadata catalog server implemented as a Java Servlet

 *

 * action=login

 *     username

 *     password

 *     qformat

 * action=logout

 *     qformat

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

 *     meta_file_id --

 *     returndoctype --

 *     filterdoctype --

 *     returnfield --

 *     owner --

 *     site --

 *     operator --

 *     casesensitive --

 *     searchmode --

 *     anyfield --

 *     ymax --

 *     xmin --

 *     ymin --

 *     skin --

 *     pagesize --

 *     pagestart --

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

 *     query --

 *     pagesize --

 *     pagestart --

 * action=export -- export a zip format for data packadge

 *     docid --

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

 *     archiveEntryName --

 *     docid --

 *     qformat --

 *     metadatadocid --

 * action=readinlinedata -- read inline data only

 *     inlinedataid

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

 *     qformat --

 *     docid --

 *     doctext --

 *     dtdtext --

 * action=insertmultipart -- insert an xml document into the database using multipart encoding

 *     qformat --

 *     docid --

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

 *     qformat --

 *     docid --

 *     doctext --

 *     dtdtext --

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

 *     docid --

 * action=validate -- validate the xml contained in valtext

 *     valtext --

 *     docid --

 * action=setaccess -- change access permissions for a user on a document.

 *     docid --

 *     principal --

 *     permission --

 *     permType --

 *     permOrder --

 * action=getaccesscontrol -- retrieve acl info for Metacat document

 *     docid --

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

 * action=getalldocids -- retrieves a list of all docids registered with the system

 *     scope --

 * action=getlastdocid --

 *     scope --

 *     username --

 * action=isregistered -- checks to see if the provided docid is registered

 *     docid --

 * action=getdtdschema -- retrieve a DTD or Schema file

 *     doctype --

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

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

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

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

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

 *     start -- filter out events before the start date-time

 *     end -- filter out events before the end date-time

 * action=getloggedinuserinfo -- get user info for the currently logged in user

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

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

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

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

 *     start -- filter out events before the start date-time

 *     end -- filter out events before the end date-time

 *                  extra connections are no longer being used.

 *     docid --

 * action=refreshServices --

 *                            registers it with the scheduling engine and creates a row

 *                            in the scheduled_job table.  Note that this may be

 *                            extracted into a separate servlet.

 *     delay -- The amount of time from now before the workflow should be run.  The

 *              delay can be expressed in number of seconds, minutes, hours and days,

 *              for instance 30s, 2h, etc.

 *     starttime -- The time that the workflow should first run.  If both are provided

 *                  this takes precedence over delay.  The time should be expressed as:

 *                  MM/dd/yyyy HH:mm:ss with the timezone assumed to be that of the OS.

 *     endtime -- The time when the workflow should end. The time should be expressed as:

 *                  MM/dd/yyyy HH:mm:ss with the timezone assumed to be that of the OS.

 *     intervalvalue -- The numeric value of the interval between runs

 *     intervalunit -- The unit of the interval between runs.  Can be s, m, h, d for

 *                     seconds, minutes, hours and days respectively

 *     workflowid -- The lsid of the workflow that we want to schedule.  This workflow

 *                   must already exist in the database.

 *     karid -- The karid for the workflow that we want to schedule.

 *     workflowname -- The name of the workflow.

 *     forwardto -- If provided, forward to this page when processing is done.

 *     qformat -- If provided, render results using the stylesheets associated with

 *                this skin.  Default is xml.

 * action=unscheduleWorkflow -- Unschedule a workflow.  Unscheduling a workflow

 *                            removes it from the scheduling engine and changes the

 *                            status in the scheduled_job table to " unscheduled.  Note

 *                            that this may be extracted into a separate servlet.

 *     forwardto -- If provided, forward to this page when processing is done.

 *     qformat -- If provided, render results using the stylesheets associated with

 *                this skin.  Default is xml.

 * action=rescheduleWorkflow -- Unschedule a workflow.  Rescheduling a workflow

 *                            registers it with the scheduling engine and changes the

 *                            status in the scheduled_job table to " scheduled.  Note

 *                            that this may be extracted into a separate servlet.

 *     forwardto -- If provided, forward to this page when processing is done.

 *     qformat -- If provided, render results using the stylesheets associated with

 *                this skin.  Default is xml.

 * action=deleteScheduledWorkflow -- Delete a workflow.  Deleting a workflow

 *                            removes it from the scheduling engine and changes the

 *                            status in the scheduled_job table to " deleted.  Note

 *                            that this may be extracted into a separate servlet.

 *     forwardto -- If provided, forward to this page when processing is done.

 *     qformat -- If provided, render results using the stylesheets associated with

 *                this skin.  Default is xml.

 *     pid -- the id of the document which will be rebuilt slor index.

 * action=reindexall -- rebuild the solr index for all objects in the systemmetadata table.

 * Here are some of the common parameters for actions

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

 *     qformat=xml -- display resultset from query in XML

 *     qformat=html -- display resultset from query in HTML

 *     qformat=zip -- zip resultset from query

 *     docid=34 -- display the document with the document ID number 34

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

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

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

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

 *     valtext -- XML text to be validated

 *     scope --can limit the query by the scope of the id

 *     docid --the docid to check

 *     datadoc -- data document name (id)

	private static final long serialVersionUID = 1L;

	private Timer timer = null;

    private static boolean _fullyInitialized = false;

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

    public static final String NONAMESPACELOCATION = ":noNamespaceSchemaLocation";

    public static final String EML2KEYWORD = ":eml";

    private static final String TRUE  = "true";

     * Initialize the servlet by creating appropriate database connections

     */

    	try {

    		}

            ServiceService serviceService = ServiceService.getInstance(context);

            ServiceService.registerService("SessionService", SessionService.getInstance());

            // Check to see if the user has requested to bypass configuration

    		// If both are false then stop the initialization

        		"Service problem while intializing MetaCat Servlet: " + se.getMessage();

        	String errorMessage = "Metacat utility problem while intializing MetaCat Servlet: "

        		+ mue.getMessage();

	/**

	 * Initialize the remainder of the servlet. This is the part that can only

	 * be initialized after metacat properties have been configured

	 *

	 * @param context

	 *            the servlet context of MetaCatServlet

	 */

	public void initSecondHalf(ServletContext context) throws ServletException {

			ServiceService.registerService("DatabaseService", DatabaseService.getInstance());

			DBConnectionPool connPool = DBConnectionPool.getInstance();

			// Before Metacat 1.8.1, metacat uses tag RELEASE_EML_2_0_1_UPDATE_6 as eml

			// schema, which accidentily points to wrong version of eml-resource.xsd.

				boolean success = correct.run();

				if (success) {

			// 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(PropertyService

					.getProperty("database.indexingTimerTaskTime"));

			int delayTime = Integer.parseInt(PropertyService

					.getProperty("database.indexingInitialDelay"));

			if (indexingTimerTaskTime > 0) {

				timer = new Timer();

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

			}

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

			 * cache on restart, trigger the harvester regeneratation method

			 */

					PropertyService.getProperty("spatial.regenerateCacheOnRestart").equals("true")) {

				long before = System.currentTimeMillis();

				// this may be expensive with many documents

				SpatialHarvester sh = new SpatialHarvester();

				sh.regenerate();

				sh.destroy();

				// After running the first time, we want to to set

				// regenerateCacheOnRestart to false

				// so that it does not regenerate the cache every time tomcat is

				// restarted

				// End timer

				long after = System.currentTimeMillis();

			} else {

			// Set up the replication log file by setting the "replication.logfile.name"

			// system property and reconfiguring the log4j property configurator.

			String replicationLogPath = PropertyService.getProperty("replication.logdir")

				+ FileUtil.getFS() + ReplicationService.REPLICATION_LOG_FILE_NAME;

			if (FileUtil.getFileStatus(replicationLogPath) == FileUtil.DOES_NOT_EXIST) {

				FileUtil.createFile(replicationLogPath);

			}

			}

			System.setProperty("replication.logfile.name", replicationLogPath);

			PropertyConfigurator.configureAndWatch(LOG_CONFIG_NAME);

			// initialize the plugins

			MetacatHandlerPluginManager.getInstance();

			// initialize the HazelcastService

			ServiceService.registerService("HazelcastService", HazelcastService.getInstance());

			String errorMessage = "SQL problem while intializing MetaCat Servlet: "

					+ e.getMessage();

		} catch (IOException ie) {

			String errorMessage = "IO problem while intializing MetaCat Servlet: "

					+ ie.getMessage();

		} catch (GeneralPropertyException gpe) {

			String errorMessage = "Could not retrieve property while intializing MetaCat Servlet: "

					+ gpe.getMessage();

			String errorMessage = "Service problem while intializing MetaCat Servlet: "

				+ se.getMessage();

        	String errorMessage = "Utility problem while intializing MetaCat Servlet: "

        		+ ue.getMessage();

        }

	 */

    	ServiceService.stopAllServices();

    }

    public void doGet(HttpServletRequest request, HttpServletResponse response)

        handleGetOrPost(request, response);

    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)

        handleGetOrPost(request, response);

    }

	 */

    	logMetacat.debug("MetaCatServlet.checkIndexPaths - starting....");

    	if(!EnabledQueryEngines.getInstance().isEnabled(EnabledQueryEngines.PATHQUERYENGINE)) {

    		logMetacat.info("MetaCatServlet.checkIndexPaths - the pathquery is disabled and it does nothing for checking path_index");

            return;

        }

    	logMetacat.debug("MetaCatServlet.checkIndexPaths - after checking is the pathquery enabled or not...");

        Vector<String> pathsForIndexing = null;

        try {

        	pathsForIndexing = SystemUtil.getPathsForIndexing();

            int serialNumber = -1;

            PreparedStatement pstmt = null;

            PreparedStatement pstmt1 = null;

            ResultSet rs = null;

                    //check out DBConnection

                    conn = DBConnectionPool.

                    rs = pstmt.getResultSet();

                        pstmt.close();

                        conn.increaseUsageCount(1);

                        if(pathIndex.indexOf("@")<0){

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

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

                        } else {

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

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

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

                        }

                        rs = pstmt.getResultSet();

                            while (rs.next()) {

                                String nodedata = rs.getString(2);

                                float nodedatanumerical = rs.getFloat(3);

                                int parentnodeid = rs.getInt(5);

                                    pstmt1 = conn.prepareStatement(

                                            + " (docid, path, nodedata, "

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

                                    pstmt1.setFloat(4, nodedatanumerical);

                                    pstmt1.setInt(6, parentnodeid);

                                    pstmt1.close();

                            }

                        }

                        pstmt.close();

                        conn.increaseUsageCount(1);

                    pstmt.close();

                    conn.increaseUsageCount(1);

                    //check in DBonnection

                    DBConnectionPool.returnDBConnection(conn, serialNumber);

                }

	 */

			HttpServletResponse response) throws ServletException, IOException {

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

			logMetacat.debug("null requestEncoding, setting to application default: " + DEFAULT_ENCODING);

			request.setCharacterEncoding(DEFAULT_ENCODING);

		}

		HttpSession httpSession = request.getSession(false);

		if (httpSession != null) {

		// configured. If not then forward to the administration servlet

				RequestUtil.forwardRequest(request, response, "/admin?action=configure", null);

				return;

			} catch (MetacatUtilException mue) {

				logMetacat.error("MetacatServlet.handleGetOrPost - utility error when forwarding to " +

						"configuration screen: " + mue.getMessage());

				throw new ServletException("MetacatServlet.handleGetOrPost - utility error when forwarding to " +

						"configuration screen: " + mue.getMessage());

			}

		}

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

		}

		try {

			String ctype = request.getContentType();

			        return;

			    }

			}

			String[] value = null;

			String[] docid = new String[3];

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

			// "action" syntax

			// These URLs are of the form:

			// e.g., http://localhost:8180/metacat/metacat/test.1.1/knb

			if (pathInfo != null) {

				String[] path = pathInfo.split("/");

				if (path.length > 1) {

					String docidToRead = path[1];

					String docs[] = new String[1];

					docs[0] = docidToRead;

					String skin = null;

					if (path.length > 2) {

						skin = path[2];