/src/edu/ucsb/nceas/metacat/util/SystemUtil.java - Annotate - Metacat - Ecoinformatics Redmine

metacat/src/edu/ucsb/nceas/metacat/util/SystemUtil.java @ 4481

-            daigle
+/**
  *  '$RCSfile$'
  *    Purpose: A Class that implements system utility methods
  *  Copyright: 2008 Regents of the University of California and the
  *             National Center for Ecological Analysis and Synthesis
  *    Authors: Michael Daigle
+ *
  *   '$Author$'
  *     '$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.util;
-            daigle
+import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-            daigle
+import javax.servlet.ServletContext;
 import javax.servlet.http.HttpServletRequest;
 import org.apache.log4j.Logger;
 import edu.ucsb.nceas.metacat.MetaCatVersion;
 import edu.ucsb.nceas.metacat.service.PropertyService;
 import edu.ucsb.nceas.utilities.FileUtil;
 import edu.ucsb.nceas.utilities.PropertyNotFoundException;
 public class SystemUtil {
 	private static Logger logMetacat = Logger.getLogger(SystemUtil.class);
 	private static String METACAT_SERVLET = "metacat";
 	/**
 	 * private constructor - all methods are static so there is no no need to
 	 * instantiate.
 	 */
 	private SystemUtil() {}
 	/**
 	 * Attempt to discover the server name. The name is retrieved from the http
 	 * servlet request. This is used by configuration routines before the port
 	 * has been populated in metacat.properties. it is possible the port that
 	 * the user configures might be different than the name we get here. You
 	 * should use getServerPort() instead of this method whenever possible.
+	 *
 	 * @param request
 	 *            the http servlet request we will use to find the server name
+	 *
 	 * @return a string holding the server name
 	 */
 	public static String discoverServerName(HttpServletRequest request) {
 		String serverName = request.getServerName();
 		return serverName;
+	}
 	/**
 	 * Attempt to discover the server port. The port is retrieved from the http
 	 * servlet request. This is used by configuration routines before the port
 	 * has been populated in metacat.properties. it is possible the port that
 	 * the user configures might be different than the port we get here. You
 	 * should use getServerPort() instead of this method whenever possible.
+	 *
 	 * @param request
 	 *            the http servlet request we will use to find the server port
+	 *
 	 * @return a string holding the server port
 	 */
 	public static String discoverServerPort(HttpServletRequest request) {
 		return Integer.toString(request.getServerPort());
+	}
 	/**
 	 * Attempt to discover the server ssl port. The ssl port is assumed using
 	 * the standard port. This is used by configuration routines before the port
 	 * has been populated in metacat.properties. it is possible the prot that
 	 * the user configures might be different than the port we get here. You
 	 * should use getServerSSLPort() instead of this method whenever possible.
+	 *
 	 * @param request
 	 *            the http servlet request we will use to find the server port
+	 *
 	 * @return a string holding the server ssl port
 	 */
 	public static String discoverServerSSLPort(HttpServletRequest request) {
 		String serverPort = discoverServerPort(request);
 		if (serverPort.length() == 4 && serverPort.charAt(0) == '8') {
 			return "8443";
+		}
 		return "443";
+	}
 	/**
 	 * Get the server URL which is made up of the server name + : + the http
 	 * port number. Note that if the port is 80, it is left off.
+	 *
 	 * @return string holding the server URL
 	 */
 	public static String getServerURL() throws PropertyNotFoundException {
 		String ServerURL = "http://" + PropertyService.getProperty("server.name");
 		String httpPort = PropertyService.getProperty("server.httpPort");
 		if (!httpPort.equals("80")) {
 			ServerURL += ":" + httpPort;
+		}
 		return ServerURL;
+	}
 	/**
 	 * Get the secure server URL which is made up of the server name + : + the
 	 * https port number. Note that if the port is 443, it is left off.
+	 *
 	 * @return string holding the server URL
 	 */
 	public static String getSecureServerURL() throws PropertyNotFoundException {
-            leinfelder
+		String ServerURL = "https://" + getSecureServer();
 		return ServerURL;
+	}
 	/**
 	 * Get the secure server  which is made up of the server name + : + the
 	 * https port number. Note that if the port is 443, it is left off.
 	 * NOTE: does NOT include "https://"
 	 * @see getSecureServerURL()
+	 *
 	 * @return string holding the secure server
 	 */
 	public static String getSecureServer() throws PropertyNotFoundException {
 		String server = PropertyService.getProperty("server.name");
-            daigle
+		String httpPort = PropertyService.getProperty("server.httpSSLPort");
 		if (!httpPort.equals("443")) {
-            leinfelder
+			server = server + ":" + httpPort;
             daigle
-            leinfelder
+		return server;
             daigle
 	/**
 	 * Get the CGI URL which is made up of the server URL + file separator + the
 	 * CGI directory
+	 *
 	 * @return string holding the server URL
 	 */
 	public static String getCGI_URL() throws PropertyNotFoundException{
-            daigle
+		return getContextURL()
-            daigle
+				+ PropertyService.getProperty("application.cgiDir");
+	}
 	/**
 	 * Get the server URL with the context. This is made up of the server URL +
 	 * file separator + the context
+	 *
 	 * @return string holding the server URL with context
 	 */
 	public static String getContextURL() throws PropertyNotFoundException {
 		return getServerURL() + FileUtil.getFS()
 				+ PropertyService.getProperty("application.context");
+	}
 	/**
 	 * Get the servlet URL. This is made up of the server URL with context +
 	 * file separator + the metacat servlet name
+	 *
 	 * @return string holding the servlet URL
 	 */
 	public static String getServletURL() throws PropertyNotFoundException {
 		return getContextURL() + FileUtil.getFS() + METACAT_SERVLET;
+	}
 	/**
 	 * Get the style skins URL. This is made up of the server URL with context +
 	 * file separator + "style" + file separator + "skins"
+	 *
 	 * @return string holding the style skins URL
 	 */
 	public static String getStyleSkinsURL() throws PropertyNotFoundException {
 		return getContextURL() + FileUtil.getFS() + "style" + FileUtil.getFS()
 				+ "skins";
+	}
 	/**
 	 * Get the style common URL. This is made up of the server URL with context +
 	 * file separator + "style" + file separator + "common"
+	 *
 	 * @return string holding the style common URL
 	 */
 	public static String getStyleCommonURL() throws PropertyNotFoundException {
 		return getContextURL() + FileUtil.getFS() + "style" + FileUtil.getFS()
 				+ "common";
+	}
 	/**
 	 * Get the metacat version by getting the string representation from
 	 * metacat.properties and instantiating a MetaCatVersion object
+	 *
 	 * @return a MetaCatVersion object holding metacat version information
 	 */
 	public static MetaCatVersion getMetacatVersion() throws PropertyNotFoundException {
 		String metacatVersionString =
 			PropertyService.getProperty("application.metacatVersion");
 		return new MetaCatVersion(metacatVersionString);
+	}
 	/**
-            daigle
+	 * Get the context directory. This is made up of the deployment directory + file
 	 * separator + context
             daigle
 	 * @return string holding the context directory
 	 */
 	public static String getContextDir() throws PropertyNotFoundException {
-            daigle
+		return PropertyService.getProperty("application.deployDir") + FileUtil.getFS()
-            daigle
+				+ PropertyService.getProperty("application.context");
+	}
 	/**
 	 * Attempt to discover the context for this application. This is a best
 	 * guess scenario. It is used by configuration routines before the context
 	 * has been populated in metacat.properties. You should always use
 	 * getApplicationContext() instead of this method if possible.
+	 *
 	 * @param request
 	 *            the http servlet request we will use to find the context
+	 *
 	 * @return a string holding the context
 	 */
 	public static String discoverApplicationContext(HttpServletRequest request) {
 		String contextPath = request.getContextPath();
 		if (contextPath.charAt(0) == '/') {
 			contextPath = contextPath.substring(1);
+		}
 		logMetacat.debug("contextPath: " + contextPath);
 		return contextPath;
+	}
 	/**
 	 * Get the style skins directory. This is made up of the tomcat directory
 	 * with context + file separator + "style" + file separator + "skins"
+	 *
 	 * @return string holding the style skins directory
 	 */
 	public static String getStyleSkinsDir() throws PropertyNotFoundException {
 		return getContextDir() + FileUtil.getFS() + "style" + FileUtil.getFS()
 				+ "skins";
+	}
 	/**
 	 * Get the SQL directory. This is made up of the context directory + file
 	 * separator + sql
+	 *
 	 * @return string holding the sql directory
 	 */
 	public static String getSQLDir() throws PropertyNotFoundException {
-            daigle
+		return getContextDir() + FileUtil.getFS() + "WEB-INF" + FileUtil.getFS() + "sql";
             daigle
 	/**
 	 * Get the default style URL from metacat.properties.
+	 *
 	 * @return string holding the default style URL
 	 */
 	public static String getDefaultStyleURL() throws PropertyNotFoundException {
 		return getStyleCommonURL() + FileUtil.getFS()
 				+ PropertyService.getProperty("application.default-style");
+	}
 	/**
-            daigle
+	 * Attempt to discover the deployment directory for this application. This is a
-            daigle
+	 * best guess scenario. It is used by configuration routines before the
-            daigle
+	 * deployment directory has been populated in metacat.properties.
             daigle
 	 * @param request
 	 *            the http servlet request we will use to find the tomcat directory
+	 *
-            daigle
+	 * @return a string holding the web application directory
-            daigle
+	 */
-            daigle
+	public static String discoverDeployDir(HttpServletRequest request) {
-            daigle
+		ServletContext servletContext = request.getSession()
 				.getServletContext();
 		String realPath = servletContext.getRealPath(".");
-            daigle
+		String contextPath = request.getContextPath();
 		logMetacat.debug("realPath: " + realPath);
 		logMetacat.debug("contextPath: " + contextPath);
             daigle
 		Pattern pattern = Pattern.compile(contextPath + "/\\.$");
 		Matcher matcher = pattern.matcher(realPath);
             daigle
-            daigle
+		if (matcher.find()) {
 			realPath = matcher.replaceFirst("");
+		}
-            daigle
+		return realPath;
             daigle
+}

Project

General

Profile

Metacat