/ - Diff - Metacat - Ecoinformatics Redmine

« Previous | Next »

Revision 4711

Added by daigle about 16 years ago

Remove org configuration methods since they are not used. Get the backup configuration directories when doing a bypass. Implement the refresh method.

     import org.apache.log4j.Logger;
     import edu.ucsb.nceas.metacat.util.OrganizationUtil;
     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.GeneralPropertyException;
-...
     	public static final String BYPASSED = "bypassed";
     	private static final String MAIN_CONFIG_NAME = "metacat.properties";
     	private static final String ORG_CONFIG_NAME = "org.properties";
     	private static final String AUTH_CONFIG_NAME = "auth.properties";
     	private static boolean bypassAlreadyChecked = false;
-...
     	private static String propertiesMetaDataFilePath = null;
     	private static PropertiesMetaData mainMetaData = null;
     	private static String orgBackupPropertiesFilePath = null;
     	private static SortedProperties orgBackupProperties = null;
     	private static String orgMetaDataFilePath = null;
     	private static PropertiesMetaData orgMetaData = null;
     	private static String authBackupPropertiesFilePath = null;
     	private static SortedProperties authBackupProperties = null;
-...
+    	 *
     	 * @param servletContext the context we will use to get relative paths
     	 */
     	private PropertyService(String configDir) throws ServiceException {
     	private PropertyService() throws ServiceException {
     		try {
     			initialize(configDir);
     			initialize();
     		} catch (GeneralPropertyException gpe) {
     			throw new ServiceException("Properties problem while initializing " +
     					"PropertyService: " + gpe.getMessage());
-...
     	 * @param servletContext the context we will use to get relative paths
     	 * @return the single instance of PropertyService
     	 */
     	public static PropertyService getInstance(String configDir) throws ServiceException {
     	public static PropertyService getInstance() throws ServiceException {
     		if (propertyService == null) {
     			propertyService = new PropertyService(configDir);
     			propertyService = new PropertyService();
+    		}
     		return propertyService;
+    	}
     	public boolean refreshable() {
     		return false;
     		return true;
+    	}
     	protected void doRefresh() {
     		return;
     	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());
+    		}
+    	}
     	/**
-...
+    	 *
     	 * @param servletContext the context we will use to get relative paths
     	 */
     	public void initialize(String configDir)
     			throws IOException, GeneralPropertyException {
     	private void initialize()
     			throws IOException, GeneralPropertyException, ServiceException {
     		logMetacat.debug("Initializing PropertyService");
     		String configDir = ServiceService.getRealConfigDir();
     		// mainProperties will hold the primary configuration values for metacat.
     		mainPropertiesFilePath = configDir + FileUtil.getFS() + MAIN_CONFIG_NAME;
     		if (mainProperties == null) {
     			mainProperties = new SortedProperties(mainPropertiesFilePath);
     			mainProperties.load();
+    		}
     		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";
     			if (mainMetaData == null) {
     				mainMetaData = new PropertiesMetaData(propertiesMetaDataFilePath);
+    			}
     			mainMetaData = new PropertiesMetaData(propertiesMetaDataFilePath);
     			// orgMetaData holds configuration information about organization level
     			// properties.  This is primarily used to display input fields on
     			// the organization configuration page. The information is retrieved
     			// from an xml metadata file dedicated just to organization properties.
     			orgMetaDataFilePath = configDir + FileUtil.getFS() + ORG_CONFIG_NAME + ".metadata.xml";
     			if (orgMetaData == null) {
     				orgMetaData = new PropertiesMetaData(orgMetaDataFilePath);
+    			}
     			// 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";
     			if (authMetaData == null) {
     				authMetaData = new PropertiesMetaData(authMetaDataFilePath);
+    			}
     			authMetaData = new PropertiesMetaData(authMetaDataFilePath);
     		} catch (TransformerException te) {
     			throw new GeneralPropertyException(te.getMessage());
+    		}
     		String backupDirPath = getBackupDir();
     		String backupDirPath = getProperty("application.backupDir") + FileUtil.getFS() + ".metacat";
     		// 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";
     		if (mainBackupProperties == null) {
     			mainBackupProperties =
     				new SortedProperties(mainBackupPropertiesFilePath);
     			mainBackupProperties.load();
+    		}
     		mainBackupProperties = new SortedProperties(mainBackupPropertiesFilePath);
     		mainBackupProperties.load();
     		// The orgBackupProperties hold properties that were backed up the
     		// last time the organizations were 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.
     		orgBackupPropertiesFilePath = backupDirPath + FileUtil.getFS() +  ORG_CONFIG_NAME + ".backup";
     		if (orgBackupProperties == null) {
     			orgBackupProperties =
     				new SortedProperties(orgBackupPropertiesFilePath);
     			orgBackupProperties.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 = backupDirPath + FileUtil.getFS() +  AUTH_CONFIG_NAME + ".backup";
     		if (authBackupProperties == null) {
     			authBackupProperties =
     				new SortedProperties(authBackupPropertiesFilePath);
     			authBackupProperties.load();
+    		}
     		authBackupProperties = new SortedProperties(authBackupPropertiesFilePath);
     		authBackupProperties.load();
+    	}
     	/**
-...
+    	}
     	/**
     	 * Get the organizational backup properties file. These are configurable
     	 * properties that are stored outside the metacat install directories so
     	 * the user does not need to re-enter all the configuration information
     	 * every time they do an upgrade.
+    	 *
     	 * @return a SortedProperties object with the backup properties
     	 */
     	public static SortedProperties getOrgBackupProperties() {
     		return orgBackupProperties;
+    	}
     	/**
     	 * Get the auth backup properties file. These are configurable
     	 * properties that are stored outside the metacat install directories so
     	 * the user does not need to re-enter all the configuration information
-...
+    	}
     	/**
     	 * Get the organization properties metadata. This is retrieved from an xml
     	 * file that describes the attributes of configurable properties.
+    	 *
     	 * @return a PropertiesMetaData object with the organization properties
     	 *         metadata
     	 */
     	public static PropertiesMetaData getOrgMetaData() {
     		return orgMetaData;
+    	}
     	/**
     	 * Get the auth properties metadata. This is retrieved from an xml
     	 * file that describes the attributes of configurable properties.
+    	 *
-...
     	/**
     	 * Writes out backup configurable properties to a file.
     	 */
     	public static void persistOrgBackupProperties(ServletContext servletContext)
     			throws GeneralPropertyException {
     		// Use the metadata to extract configurable properties from the
     		// overall properties list, and store those properties.
     		try {
     			SortedProperties backupProperties =
     				new SortedProperties(orgBackupPropertiesFilePath);
     			// Populate the backup properties for organization properties using
     			// the associated metadata file
     			PropertiesMetaData orgMetadata = new PropertiesMetaData(orgMetaDataFilePath);
     			// We do the same thing here for organization specific properies
     			// with the addition that we need to iterate through all available
     			// organizations.  For instance, a metadata section that defines a
     			// property as "organization.base" will be entered into the metacat.properties
     			// file with a key of "organization.base.NCEAS" for the NCEAS organization.
     			// This will be repeated for all available organizations.
     			Set<String> orgKeySet = orgMetadata.getKeys();
     			for (String orgName : OrganizationUtil.getOrganizations()) {
     				for (String propertyKey : orgKeySet) {
     					String orgPropertyKey = propertyKey + "." + orgName;
     					backupProperties.addProperty(orgPropertyKey, getProperty(orgPropertyKey));
+    				}
+    			}
     			// store the properties to file
     			backupProperties.store();
     			orgBackupProperties =
     				new SortedProperties(orgBackupPropertiesFilePath);
     			orgBackupProperties.load();
     		} catch (TransformerException te) {
     			throw new GeneralPropertyException("Could not transform backup properties xml: "
     					+ te.getMessage());
     		} catch (IOException ioe) {
     			throw new GeneralPropertyException("Could not backup configurable properties: "
     					+ ioe.getMessage());
     		} catch (UtilException ue) {
     			throw new GeneralPropertyException("Could not get organizations: " + ue.getMessage());
+    		}
+    	}
     	/**
     	 * Writes out backup configurable properties to a file.
     	 */
     	public static void persistAuthBackupProperties(ServletContext servletContext)
     			throws GeneralPropertyException {
-...
     					+ ioe.getMessage());
+    		}
+    	}
     	/**
     	 * Gets the backup properties directory
+    	 *
     	 * @return a string which holds the name of the backup directory. returns
     	 *         null if directory could not be created.
     	 */
     	public static String getBackupDir() {
     		return SystemUtil.discoverExternalDir() + FileUtil.getFS() + ".metacat";
+    	}
     	/**
     	 * Reports whether properties are fully configured.
-...
     	 * @return a boolean that is true if properties are not unconfigured and
     	 *         false otherwise
     	 */
     	public static boolean arePropertiesConfigured() throws UtilException {
     	public static boolean arePropertiesConfigured() throws UtilException {
     		try {
     			return !PropertyService.getProperty("configutil.propertiesConfigured").equals(
     					PropertyService.UNCONFIGURED);
     			String propertiesConfigured = PropertyService.getProperty("configutil.propertiesConfigured");
     			if (propertiesConfigured != null && !propertiesConfigured.equals(UNCONFIGURED)) {
     				return true;
+    			}
     			return false;
     		} catch (PropertyNotFoundException pnfe) {
     			throw new UtilException("Could not determine if properties are configured: "
     					+ pnfe.getMessage());
-...
+    	}
     	/**
     	 * Determine if the system is configured to bypass configuration. If so, the
     	 * system will look for backup configuration files at startup time and use
     	 * those to configure metacat. The bypass options should only be set by
     	 * developers. Production code should never bypass confguration.
+    	 *
     	 * @return true if dev.runConfiguration is set to true in metacat.properties
     	 *         and we have not already checked for bypass, false otherwise.
     	 */
     	public static boolean doBypass() throws PropertyNotFoundException {
     		// We only want to go through the check once to see if we want to
     		// bypass the configuration.  We don't want to run through all of
     		// this every time  we hit metacat.
     		if (bypassAlreadyChecked) {
     			logMetacat.debug("bypassConfiguration not performing full bypass check.  Bypass set to false");
     			return false;
+    		}
     		// check how dev.runConfiguration is set in metacat.properties
     		String strRunConfiguration = PropertyService.getProperty("dev.runConfiguration");
     		boolean runConfiguration = Boolean.parseBoolean(strRunConfiguration);
     		logMetacat.debug("bypassConfiguration: dev.runConfiguration property set to: " + strRunConfiguration);
     		// if the dev.runConfiguration is true, return false here.
     		if (runConfiguration) {
     			bypassAlreadyChecked = true;
     			return false;
+    		}
     		return true;
+    	}
     	/**
     	 * Reports whether the metacat configuration utility should be run.
     	 * Returns false if
     	 *   -- dev.runConfiguration=false and
-...
     	 * @return a boolean that is false if dev.runConfiguration is false and
     	 * the backup properties file exists.
     	 */
     	public static boolean bypassConfiguration() {
     		boolean bypass = false;
     		// We only want to go through the check once to see if we want to
     		// bypass the configuration.  We don't want to run through all of
     		// this every time  we hit metacat.
     		if (bypassAlreadyChecked) {
     			logMetacat.debug("bypassConfiguration not performing full bypass check.  Bypass set to " + bypass);
     			return bypass;
+    		}
     	public static void bypassConfiguration() throws ServiceException {
     		try {
     			// check how dev.runConfiguration is set in metacat.properties
     			String strRunConfiguration = PropertyService.getProperty("dev.runConfiguration");
     			bypass = !(Boolean.parseBoolean(strRunConfiguration));
     			logMetacat.debug("bypassConfiguration: dev.runConfiguration property set to: " + strRunConfiguration);
     			// if the dev.runConfiguration is true, return false here.
     			if (!bypass) {
     				bypassAlreadyChecked = true;
     				return false;
+    			}
     			boolean doBypass = doBypass();
     			if (!doBypass) {
     				throw new ServiceException(
     						"Attempting to do bypass when system is not configured for it.");
+    			}
     			// The system is bypassing the configuration utility. We need to
     			// get the backup properties and replace existing properties with
     			// backup values.  We do this for main and org properties.
-...
     				String value = mainBackupProperties.getProperty(backupPropertyName);
     				setPropertyNoPersist(backupPropertyName, value);
+    			}
     //			SortedProperties orgBackupProperties = getOrgBackupProperties();
     //			Vector<String> orgBackupPropertyNames =
     //				orgBackupProperties.getPropertyNames();
     //			for (String orgBackupPropertyName : orgBackupPropertyNames) {
     //				String value = orgBackupProperties.getProperty(orgBackupPropertyName);
     //				setPropertyNoPersist(orgBackupPropertyName, value);
     //			}
     			logMetacat.debug("bypassConfiguration: setting auth backup properties.");
     			SortedProperties authBackupProperties = getAuthBackupProperties();
-...
     			logMetacat.debug("bypassConfiguration: setting configutil sections to true.");
     			setPropertyNoPersist("configutil.propertiesConfigured", "true");
     			setPropertyNoPersist("configutil.authConfigured", "true");
     //			setPropertyNoPersist("configutil.organizationsConfigured", "true");
     			setPropertyNoPersist("configutil.skinsConfigured", "true");
     			setPropertyNoPersist("configutil.databaseConfigured", "true");
     			setPropertyNoPersist("configutil.geoserverConfigured", "bypassed");
-...
+    		}
     		bypassAlreadyChecked = true;
     		return bypass;
+    	}
     	/**

Also available in: Unified diff

Project

General

Profile

Metacat

Revision 4711

Added by daigle about 16 years ago