/ - Diff - Metacat - Ecoinformatics Redmine

« Previous | Next »

Revision 4795

Added by daigle almost 16 years ago

Allow for backup properties to be written to context based subdirectory of the external configuration directory. This allow multiple instances of metacat to be run side by side.

     application.knbSiteURL=http://knb.ecoinformatics.org
     application.backupDir=
     application.windowsBackupBaseDir=C:\\Program Files
     application.linuxBackupBaseDir=/var/metacat
     application.linuxBackupBaseDir=/var
     application.datafilepath=/var/metacat/data
     application.inlinedatafilepath=/var/metacat/inline-data
     application.documentfilepath=/var/metacat/documents

     package edu.ucsb.nceas.metacat.service;
     import java.util.Hashtable;
     import javax.servlet.ServletContext;
     import org.apache.log4j.Logger;
     import edu.ucsb.nceas.metacat.util.SystemUtil;
     public class ServiceService {
     	private static ServiceService serviceService = null;
-...
     	private static final String SKIN_DIR = "/style/skins";
     	private static String REAL_SKIN_DIR = "";
     	private static String REAL_APPLICATION_CONTEXT = null;
     	private static Logger logMetacat = Logger.getLogger(ServiceService.class);
     	private static Hashtable<String, BaseService> serviceList = new Hashtable<String, BaseService>();
-...
     	private ServiceService(ServletContext servletContext) {
     		REAL_CONFIG_DIR = servletContext.getRealPath(CONFIG_DIR);
     		REAL_SKIN_DIR = servletContext.getRealPath(SKIN_DIR);
     		REAL_APPLICATION_CONTEXT = SystemUtil.discoverApplicationContext(servletContext);
+    	}
     	/**
-...
     		return REAL_SKIN_DIR;
+    	}
     	/**
     	 * Get the servlet context name
     	 * @return a string holding the context name
     	 */
     	public static String getRealApplicationContext() throws ServiceException {
     		if (REAL_APPLICATION_CONTEXT == null) {
     			throw new ServiceException("Application context name is null");
+    		}
     		return REAL_APPLICATION_CONTEXT;
+    	}
+    }

     	private static boolean bypassAlreadyChecked = false;
     	private static String recommendedExternalDir = null;
     	private static String mainPropertiesFilePath = null;
     	private static SortedProperties mainProperties = null;
-...
     	 * @param servletContext the context we will use to get relative paths
     	 */
     	private PropertyService() throws ServiceException {
     		try {
     			initialize();
     		} catch (GeneralPropertyException gpe) {
     			throw new ServiceException("Properties problem while initializing " +
     					"PropertyService: " + gpe.getMessage());
     		} catch (IOException ioe) {
     			throw new ServiceException("I/O Problem while initializing " +
     					"PropertyService: " + ioe.getMessage());
+    		}
     		initialize();
+    	}
     	/**
-...
+    	}
     	protected void doRefresh() throws ServiceException {
     		try {
     			initialize();
     		} catch (IOException ioe) {
     			throw new ServiceException("Could not refresh SkinPropertyService due to"
     					+ " I/O error: " + ioe.getMessage());
     		} catch (GeneralPropertyException gpe) {
     			throw new ServiceException("Could not refresh SkinPropertyService due to"
     					+ " property error: " + gpe.getMessage());
+    		}
     		initialize();
+    	}
     	/**
-...
+    	 *
     	 * @param servletContext the context we will use to get relative paths
     	 */
     	private void initialize()
     			throws IOException, GeneralPropertyException, ServiceException {
     	private void initialize() throws ServiceException {
     		logMetacat.debug("Initializing PropertyService");
-...
     		} else {
     			configDir = ServiceService.getRealConfigDir();
+    		}
     		try {
     			// mainProperties will hold the primary configuration values for
     			// metacat.
     			mainPropertiesFilePath = configDir + FileUtil.getFS() + MAIN_CONFIG_NAME;
     			mainProperties = new SortedProperties(mainPropertiesFilePath);
     			mainProperties.load();
     		// mainProperties will hold the primary configuration values for metacat.
     		mainPropertiesFilePath = configDir + FileUtil.getFS() + MAIN_CONFIG_NAME;
     		mainProperties = new SortedProperties(mainPropertiesFilePath);
     		mainProperties.load();
     		try {
     			// mainMetaData holds configuration information about main properties.
     			// This is primarily used to display input fields on the configuration
     			// page. The information is retrieved from an xml metadata file
     			propertiesMetaDataFilePath = configDir + FileUtil.getFS() + MAIN_CONFIG_NAME + ".metadata.xml";
     			// mainMetaData holds configuration information about main
     			// properties. This is primarily used to display input fields on
     			// the configuration page. The information is retrieved from an
     			// xml metadata file
     			propertiesMetaDataFilePath =
     				configDir + FileUtil.getFS() + MAIN_CONFIG_NAME + ".metadata.xml";
     			mainMetaData = new PropertiesMetaData(propertiesMetaDataFilePath);
     			// authMetaData holds configuration information about organization level
     			// properties.  This is primarily used to display input fields on
     			// the auth configuration page. The information is retrieved
     			// authMetaData holds configuration information about organization
     			// level
     			// properties. This is primarily used to display input fields on
     			// the auth configuration page. The information is retrieved
     			// from an xml metadata file dedicated just to auth properties.
     			authMetaDataFilePath = configDir + FileUtil.getFS() + AUTH_CONFIG_NAME + ".metadata.xml";
     			authMetaDataFilePath =
     				configDir + FileUtil.getFS() + AUTH_CONFIG_NAME + ".metadata.xml";
     			authMetaData = new PropertiesMetaData(authMetaDataFilePath);
     		} catch (TransformerException te) {
     			throw new GeneralPropertyException(te.getMessage());
+    		}
     		String backupBasePath = getProperty("application.backupDir");
     		// If the backupBasePath does not exist in metacat.properties, see if we can discover it.
     		if (backupBasePath == null || backupBasePath.equals("")) {
     			backupBasePath = SystemUtil.discoverExternalBaseDir();
+    		}
     		// if backupBasePath is still null, no reason to initialize the backup properties. The
     		// system will need to prompt the user for the backup properties and reinitialize
     		// PropertyService.
     		if (backupBasePath != null && !backupBasePath.equals("")) {
     			setProperty("application.backupDir", backupBasePath);
     			String recommendedExternalDir = SystemUtil.discoverExternalDir();
     			setRecommendedExternalDir(recommendedExternalDir);
     			String backupDirPath = backupBasePath + FileUtil.getFS() + ".metacat";
     			String backupPath = getProperty("application.backupDir");
     			if ((backupPath == null || backupPath.equals("")) && recommendedExternalDir != null) {
     				String realApplicationContext =
     					ServiceService.getRealApplicationContext();
     				backupPath =
     					recommendedExternalDir + FileUtil.getFS() + "." + realApplicationContext;
+    			}
     			// The mainBackupProperties hold properties that were backed up the
     			// last time the application was configured. On disk, the file will
     			// look like a smaller version of metacat.properties. It is stored
     			// in the data storage directory outside the application
     			// directories.
     			mainBackupPropertiesFilePath =
     				backupDirPath + FileUtil.getFS() + MAIN_CONFIG_NAME + ".backup";
     			mainBackupProperties = new SortedProperties(mainBackupPropertiesFilePath);
     			mainBackupProperties.load();
     			// if backupPath is still null, no reason to initialize the
     			// backup properties. The system will need to prompt the user for
     			// the backup properties and reinitialize PropertyService.
     			if (backupPath != null && !backupPath.equals("")) {
     				setProperty("application.backupDir", backupPath);
     			// The authBackupProperties hold properties that were backed up the
     			// last time the auth was configured. On disk, the file will
     			// look like a smaller version of metacat.properties. It is stored
     			// in the data storage directory outside the application
     			// directories.
     			authBackupPropertiesFilePath =
     				backupDirPath + FileUtil.getFS() + AUTH_CONFIG_NAME + ".backup";
     			authBackupProperties = new SortedProperties(authBackupPropertiesFilePath);
     			authBackupProperties.load();
+    		}
     				// The mainBackupProperties hold properties that were backed up
     				// the last time the application was configured. On disk, the
     				// file will look like a smaller version of metacat.properties.
     				// It is stored in the data storage directory outside the
     				// application directories.
     				mainBackupPropertiesFilePath =
     					backupPath + FileUtil.getFS() + MAIN_CONFIG_NAME + ".backup";
     				mainBackupProperties = new SortedProperties(mainBackupPropertiesFilePath);
     				mainBackupProperties.load();
     				// The authBackupProperties hold properties that were backed up
     				// the last time the auth was configured. On disk, the file
     				// will look like a smaller version of metacat.properties. It
     				// is stored in the data storage directory outside the
     				// application directories.
     				authBackupPropertiesFilePath =
     					backupPath + FileUtil.getFS() + AUTH_CONFIG_NAME + ".backup";
     				authBackupProperties = new SortedProperties(authBackupPropertiesFilePath);
     				authBackupProperties.load();
+    			}
     		} catch (TransformerException te) {
     			throw new ServiceException("Transform problem while loading properties: "
     					+ te.getMessage());
     		} catch (IOException ioe) {
     			throw new ServiceException("I/O problem while loading properties: "
     					+ ioe.getMessage());
     		} catch (GeneralPropertyException gpe) {
     			throw new ServiceException("General properties problem while loading properties: "
     					+ gpe.getMessage());
     		} catch (UtilException ue) {
     			throw new ServiceException("Utilities problem while loading properties: "
     					+ ue.getMessage());
+    		}
+    	}
     	/**
-...
     			PropertyService.setPropertyNoPersist(propertyName, newValue.trim());
+    		}
+    	}
     	/**
     	 * Sets the recommended external directory.  This is populated during initialization
     	 * time using the SystemUtil.discoverExternalDir() method.  This directory will be used to
     	 * suggest external user directories when the user configures metacat for the first time.
+    	 *
     	 */
     	public static void setRecommendedExternalDir(String extBaseDir) {
     		recommendedExternalDir = extBaseDir;
+    	}
     	/**
     	 * Returns the recommended external base directory.  This is populated during initialization
     	 * time using the SystemUtil.discoverExternalBaseDir() method.  This directory will be used to
     	 * suggest external user directories when the user configures metacat for the first time.
+    	 *
     	 * @return a String holding the recommended external directory
     	 */
     	public static String getRecommendedExternalDir() {
     		return recommendedExternalDir;
+    	}
+    }

     		logMetacat.debug("Initializing SkinService");
     		BACKUP_DIR = PropertyService.getProperty("application.backupDir")
     				+ FileUtil.getFS() + ".metacat";
     		BACKUP_DIR = PropertyService.getProperty("application.backupDir");
     		skinNames = SkinUtil.getSkinNames();

     import edu.ucsb.nceas.metacat.MetaCatVersion;
     import edu.ucsb.nceas.metacat.service.PropertyService;
     import edu.ucsb.nceas.metacat.service.ServiceException;
     import edu.ucsb.nceas.metacat.service.ServiceService;
     import edu.ucsb.nceas.utilities.FileUtil;
     import edu.ucsb.nceas.utilities.PropertyNotFoundException;
-...
     	 * 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
     	 * @param servletContext
     	 *            the servlet context we will use to find the application context
+    	 *
     	 * @return a string holding the context
     	 */
     	public static String discoverApplicationContext(HttpServletRequest request) {
     		String contextPath = request.getContextPath();
     	public static String discoverApplicationContext(ServletContext servletContext) {
     		String applicationContext = "";
     		String realPath = servletContext.getRealPath("/");
     		if (contextPath.charAt(0) == '/') {
     			contextPath = contextPath.substring(1);
     		if (realPath.charAt(realPath.length() - 1) == '/') {
     			realPath = realPath.substring(0, realPath.length() - 1);
+    		}
     		logMetacat.debug("contextPath: " + contextPath);
     		int lastSlashIndex = realPath.lastIndexOf('/');
     		if (lastSlashIndex != -1) {
     			applicationContext = realPath.substring(lastSlashIndex + 1);
+    		}
     		logMetacat.debug("application context: " + applicationContext);
     		return contextPath;
     		return applicationContext;
+    	}
     	/**
-...
     	 * the directory:
+    	 *
     	 * -- 1) Look for a saved backup location file in the user home dir - Is there a file named
     	 *       <user_home>/.metacat/backup-location for the user that started tomcat? if so, does
     	 *       it contain a single line which is a readable directory?  This directory was the backup
     	 *       directory used during a previous install.  Return that directory.
     	 * -- 2) Look for an existing hidden (.metacat) directory in a default system directory.  Get
     	 *       <user_home>/metacat/.<application_context>/backup-location for the user that started
     	 *       tomcat? if so, does it contain a single line which is a readable directory?  This
     	 *       directory was the backup directory used during a previous install.  Return that directory.
     	 * -- 2) Otherwise, look for an existing hidden (.<application_context>) directory in a default system directory.  Get
     	 *       the default base directory for the OS.  (See application.windowsBackupBaseDir and
     	 *       application.linuxBackupBaseDir in metacat.properties.)  If a directory called
     	 *       <base_dir>/metacat/.metacat exists, return <base_dir>/metacat.
     	 * -- 3) Look for an existing hidden (.metacat) directory in the user directory. If a directory
     	 *       called <user_dir>/.metacat exists for the user that started tomcat, return <user_dir>.
     	 * -- 4) Is the <base_dir> writable by the user that started tomcat?  If so, return <base_dir>
     	 * -- 5) Does the <user_home> exist?  If so, return <user_home>
     	 * -- 6) Otherwise, return null
     	 *       <base_dir>/metacat/.<application_context> exists, return <base_dir>/metacat.
     	 * -- 3) Otherwise, look for an existing hidden (.metacat) directory in the user directory. If a directory
     	 *       called <user_dir>/metacat/.<application_context> exists for the user that started tomcat,
     	 *       return <user_dir>/metacat.
     	 * -- 4) Otherwise, look for an existing metacat directory in a default system directory.  Get
     	 *       the default base directory for the OS.  (See application.windowsBackupBaseDir and
     	 *       application.linuxBackupBaseDir in metacat.properties.)  If a directory called
     	 *       <base_dir>/metacat exists, return <base_dir>/metacat.
     	 * -- 5) Otherwise, look for an existing metacat directory in the user directory. If a directory
     	 *       called <user_dir>/metacat/ exists for the user that started tomcat, return <user_dir>/metacat.
     	 * -- 6) Otherwise, is the <base_dir> writable by the user that started tomcat?  If so, return
     	 *       <base_dir>/metacat
     	 * -- 7) Does the <user_home> exist?  If so, return <user_home>/metacat
     	 * -- 8) Otherwise, return null
+    	 *
     	 * @return a string holding the backup directory path
     	 */
     	public static String discoverExternalBaseDir() throws PropertyNotFoundException {
     		String userHomeDir = getUserHomeDir();
     		String defaultBaseDir = "";
     	public static String discoverExternalDir() throws UtilException {
     		String applicationContext = null;
     		try {
     			// Check if there is a file at <user_home>/.metacat/backup-location.  If so, it
     			applicationContext = ServiceService.getRealApplicationContext();
     			// Check if there is a file at <user_home>/<application_context>/backup-location.  If so, it
     			// should contain one line that is a file that points to a writable directory.
     			// If that is true, use that value as the external dir.
     			String storedBackupFileLoc = getUserHomeDir() + FileUtil.getFS() + ".metacat"
     			String storedBackupFileLoc = getUserHomeDir() + FileUtil.getFS() + "." + applicationContext
     					+ FileUtil.getFS() + "backup-location";
     			if (FileUtil.getFileStatus(storedBackupFileLoc) >= FileUtil.EXISTS_READABLE) {
     				String storedBackupDirLoc = FileUtil.readFileToString(storedBackupFileLoc);
-...
     					return storedBackupDirLoc;
+    				}
+    			}
     			// Set the default location using the os
     			String systemDir = "";
     			if (getOsClass() == WIN_OS) {
     				systemDir = PropertyService.getProperty("application.windowsBackupBaseDir");
     			} else {
     				systemDir = PropertyService.getProperty("application.linuxBackupBaseDir");
+    			}
     			String systemMetacatDir = systemDir + FileUtil.getFS() + "metacat";
     			String systemBackupDir = systemMetacatDir + FileUtil.getFS() + "."
     					+ applicationContext;
     			String userHomeDir = getUserHomeDir();
     			String userHomeMetacatDir = userHomeDir + FileUtil.getFS() + "metacat";
     			String userHomeBackupDir = userHomeMetacatDir + FileUtil.getFS() + "." + applicationContext;
     			// If <system_dir>/metacat/.<application_context> exists writable,
     			// return <system_dir>/metacat
     			if ((FileUtil.getFileStatus(systemBackupDir) >= FileUtil.EXISTS_READ_WRITABLE)) {
     				return systemMetacatDir;
+    			}
     			// Otherwise if <user_dir>/metacat/.<application_context> exists writable, return
     			// <user_dir>/metacat
     			if ((FileUtil.getFileStatus(userHomeBackupDir) >= FileUtil.EXISTS_READ_WRITABLE)) {
     				return userHomeMetacatDir;
+    			}
     			// Otherwise if <system_dir>/metacat exists writable, create
     			// <system_dir>/metacat/.<application_context> and return <system_dir>/metacat
     			if ((FileUtil.getFileStatus(systemMetacatDir) >= FileUtil.EXISTS_READ_WRITABLE)) {
     				// go ahead and create the backup hidden dir
     				FileUtil.createDirectory(systemBackupDir);
     				return systemMetacatDir;
+    			}
     			// Otherwise if <user_dir>/metacat exists writable, create
     			// <user_dir>/metacat/.<application_context> and return <user_dir>/metacat
     			if ((FileUtil.getFileStatus(userHomeMetacatDir) >= FileUtil.EXISTS_READ_WRITABLE)) {
     				// go ahead and create the backup hidden dir
     				FileUtil.createDirectory(userHomeBackupDir);
     				return userHomeMetacatDir;
+    			}
     			// Otherwise if <system_dir> exists, create
     			// <system_dir>/metacat/.<application_context> and return <system_dir>/metacat
     			if ((FileUtil.getFileStatus(systemDir) >= FileUtil.EXISTS_READ_WRITABLE)) {
     				// go ahead and create the backup hidden dir
     				FileUtil.createDirectory(systemBackupDir);
     				return systemMetacatDir;
+    			}
     			// Otherwise if <user_dir> exists, return <user_dir> create
     			// <user_dir>/metacat/.<application_context> and return <user_dir>/metacat
     			if ((FileUtil.getFileStatus(userHomeDir) >= FileUtil.EXISTS_READ_WRITABLE)) {
     				// go ahead and create the backup hidden dir
     				FileUtil.createDirectory(userHomeBackupDir);
     				return userHomeMetacatDir;
+    			}
     		} catch (IOException ioe) {
     			logMetacat.warn("Could not read stored backup location: " + ioe.getMessage());
     			logMetacat.warn("I/O proplem finding backup location: " + ioe.getMessage());
     		} catch (ServiceException se) {
     			logMetacat.warn("Could not get real application context: " + se.getMessage());
     		} catch (PropertyNotFoundException pnfe) {
     			logMetacat.warn("Could not get default backup base dir property: "
     					+ pnfe.getMessage());
+    		}
     		// Set the default location using the os
     		if (getOsClass() == WIN_OS) {
     			defaultBaseDir = PropertyService.getProperty("application.windowsBackupBaseDir");
     		} else {
     			defaultBaseDir = PropertyService.getProperty("application.linuxBackupBaseDir");
+    		}
     		String defaultBackupDir = defaultBaseDir + FileUtil.getFS() + "metacat";
     		String defaultBackupHiddenDir = defaultBackupDir + FileUtil.getFS() + ".metacat";
     		String userHomeBackupHiddenDir = userHomeDir + FileUtil.getFS() + ".metacat";
     		// If <base_dir>/metacat/.metacat exists, return <base_dir>
     		if ((FileUtil.getFileStatus(defaultBackupHiddenDir) >= FileUtil.EXISTS_READ_WRITABLE)) {
     			return defaultBaseDir;
+    		}
     		// Otherwise if <user_dir>/.metacat exists, return <user_dir>
     		if ((FileUtil.getFileStatus(userHomeBackupHiddenDir) >= FileUtil.EXISTS_READ_WRITABLE)) {
     			return userHomeDir;
+    		}
     		// Otherwise if <base_dir>/metacat exists, return <base_dir>
     		if ((FileUtil.getFileStatus(defaultBaseDir) >= FileUtil.EXISTS_READ_WRITABLE)) {
     			return defaultBaseDir;
+    		}
     		// Otherwise if <user_dir> exists, return <user_dir>
     		if ((FileUtil.getFileStatus(userHomeDir) >= FileUtil.EXISTS_READ_WRITABLE)) {
     			return userHomeDir;
+    		}
     		// Otherwise, return userHomeDir
     		return null;
-...
     	/**
     	 * Store the location of the backup file location into a file at
     	 * <user_home>/.metacat/backup-location
     	 * <user_home>/<application_dir>/backup-location
+    	 *
     	 * @param externalDir the backup file location.
     	 */
     	public static void storeExternalDirLocation(String externalDir) {
     		if (getUserHomeDir() != null) {
     			String storedBackupLocDir = getUserHomeDir() + FileUtil.getFS() + ".metacat";
     			String storedBackupLocFile = storedBackupLocDir + FileUtil.getFS() + "backup-location";
     			String applicationContext = null;
     			String storedBackupLocDir = null;
     			String storedBackupLocFile = null;
     			try {
     				applicationContext = ServiceService.getRealApplicationContext();
     				storedBackupLocDir = getUserHomeDir() + FileUtil.getFS() + "."
     						+ applicationContext;
     				storedBackupLocFile = storedBackupLocDir + FileUtil.getFS()
     						+ "backup-location";
     				FileUtil.createDirectory(storedBackupLocDir);
     				FileUtil.writeFile(storedBackupLocFile, externalDir);
     			} catch (IOException ioe) {
     				logMetacat.error("I/O error while trying to write stored backup directory: "
     								+ storedBackupLocFile + " : " + ioe.getMessage());
     							+ storedBackupLocFile + " : " + ioe.getMessage());
     			} catch (ServiceException se) {
     				logMetacat.error("Could not get real application directory while trying to write "
     							+ "stored backup directory: "+ storedBackupLocFile + " : " + se.getMessage());
+    			}
     		} else {
     			logMetacat.warn("Could not write out stored backup directory."

     import edu.ucsb.nceas.dbadapter.AbstractDatabase;
     import edu.ucsb.nceas.metacat.DBSAXHandler;
     import edu.ucsb.nceas.metacat.MetaCatServlet;
     import edu.ucsb.nceas.metacat.NodeRecord;
     import edu.ucsb.nceas.metacat.service.PropertyService;
     import edu.ucsb.nceas.metacat.service.ServiceException;
-...
         public static AbstractDatabase dbAdapter;
         public static Vector pathsForIndexing;
         public static Vector<String> pathsForIndexing;
         private static boolean debug = true;
         private static boolean debugErrorDisplayed = false;
         private static Logger logMetacat = Logger.getLogger(MetacatUtil.class);
-...
     	 * @return false if the application.backupDir property does not point to a
     	 *         writable directory.
     	 */
     	public static boolean isBackupDirConfigured() throws PropertyNotFoundException {
     	public static boolean isBackupDirConfigured() throws UtilException, PropertyNotFoundException {
     		String backupDir = PropertyService.getProperty("application.backupDir");
     		if (backupDir == null) {
     		if (backupDir == null || backupDir.equals("")) {
     			return false;
+    		}
     		if (FileUtil.getFileStatus(backupDir) < FileUtil.EXISTS_READ_WRITABLE) {
     			return false;
+    		}
+    		}
     		return true;
+    	}
-...
     			// Get the most likely backup files.  If these cannot be found, we
     			// cannot do the configuration bypass.
     			String backupDir = SystemUtil.discoverExternalBaseDir();
     			if (backupDir == null) {
     			String ExternalBaseDir = SystemUtil.discoverExternalDir();
     			if (ExternalBaseDir == null) {
     				logMetacat.error("bypassConfiguration: Could not find backup directory.");
     				// could not find backup files ... force the configuration
     				return false;
+    			}
     			PropertyService.setProperty("application.backupDir", backupDir);
     			String realContext = ServiceService.getRealApplicationContext();
     			PropertyService.setRecommendedExternalDir(ExternalBaseDir);
     			PropertyService.setProperty("application.backupDir",
     					ExternalBaseDir + FileUtil.getFS() + "." + realContext);
     			// Refresh the property service and skin property service.  This will pick up
     			// the backup directory and populate backup properties in caches.

     import edu.ucsb.nceas.metacat.DBVersion;
     import edu.ucsb.nceas.metacat.MetaCatVersion;
     import edu.ucsb.nceas.metacat.service.PropertyService;
     import edu.ucsb.nceas.metacat.service.ServiceException;
     import edu.ucsb.nceas.metacat.service.ServiceService;
     import edu.ucsb.nceas.metacat.util.RequestUtil;
     import edu.ucsb.nceas.metacat.util.SystemUtil;
-...
     				PropertiesMetaData metadata = PropertyService.getMainMetaData();
     				request.setAttribute("metadata", metadata);
     				String externalDir = PropertyService.getProperty("application.backupDir");
     				String externalDir = PropertyService.getRecommendedExternalDir();
     				if (externalDir == null) {
     					throw new AdminException("Could not initialize property configuration"
     									+ "page since application.backupDir was null");
     					throw new AdminException("Could not initialize property configuration "
     									+ "page recommended application backup directory was null");
+    				}
     				// Attempt to discover the following properties.  These will show
     				// up in the configuration fields if nothing else is provided.
     				PropertyService.setPropertyNoPersist("application.context",
     						SystemUtil.discoverApplicationContext(request));
     						ServiceService.getRealApplicationContext());
     				PropertyService.setPropertyNoPersist("server.name", SystemUtil
     						.discoverServerName(request));
     				PropertyService.setPropertyNoPersist("server.httpPort", SystemUtil
-...
     			} catch (IOException ioe) {
     				throw new AdminException("IO problem while initializing "
     						+ "system properties page:" + ioe.getMessage());
     			} catch (ServiceException se) {
     				throw new AdminException("Service problem while initializing "
     						+ "system properties page:" + se.getMessage());
     			} catch (ServletException se) {
     				throw new AdminException("problem forwarding request while "
     						+ "initializing system properties page: " + se.getMessage());

     import edu.ucsb.nceas.metacat.service.ServiceService;
     import edu.ucsb.nceas.metacat.util.RequestUtil;
     import edu.ucsb.nceas.metacat.util.SystemUtil;
     import edu.ucsb.nceas.metacat.util.UtilException;
     import edu.ucsb.nceas.utilities.FileUtil;
     import edu.ucsb.nceas.utilities.PropertyNotFoundException;
     import edu.ucsb.nceas.utilities.GeneralPropertyException;
     /**
-...
     			// the web form for configuring metacat
     			try {
     				String backupBaseDir = SystemUtil.discoverExternalBaseDir();
     				String backupBaseDir = SystemUtil.discoverExternalDir();
     				logMetacat.debug("Backup dir discovered as: " + backupBaseDir);
     				String backupDirStatus = getBackupDirStatus(backupBaseDir);
     				logMetacat.debug("Status of discovered backup dir: " + backupDirStatus);
-...
     			} catch (ServletException se) {
     				throw new AdminException("Problem forwarding request while "
     						+ "initializing backup configuration page: " + se.getMessage());
     			} catch (PropertyNotFoundException pnfe) {
     			} catch (UtilException ue) {
     				throw new AdminException("Problem discovering backup directory while "
     						+ "initializing backup configuration page: " + pnfe.getMessage());
     						+ "initializing backup configuration page: " + ue.getMessage());
+    			}
     		} else {
     			// The configuration form is being submitted and needs to be
-...
     			Vector<String> processingErrors = new Vector<String>();
     			Vector<String> validationErrors = new Vector<String>();
     			String backupDir = request.getParameter("backup-dir");
     			String hiddenBackupDir = backupDir + FileUtil.getFS() + ".metacat";
     			// Validate that the options provided are legitimate.
     			validationErrors.addAll(validateOptions(request));
     			String backupDir = null;
     			String realApplicationContext = null;
     			String hiddenBackupDir = null;
     			if (validationErrors.size() == 0) {
     				try {
     					backupDir = request.getParameter("backup-dir");
     					realApplicationContext = ServiceService.getRealApplicationContext();
     					hiddenBackupDir =
     						backupDir + FileUtil.getFS() + "." + realApplicationContext;
     					FileUtil.createDirectory(hiddenBackupDir);
     					PropertyService.setProperty("application.backupDir", backupDir);
     					ServiceService.refreshService("PropertyService");
     					PropertyService.setRecommendedExternalDir(backupDir);
     					ServiceService.refreshService("SkinPropertyService");
     					SystemUtil.storeExternalDirLocation(backupDir);
     				} catch (IOException ue) {

Also available in: Unified diff

Project

General

Profile

Metacat

Revision 4795

Added by daigle almost 16 years ago