/ - Diff - Metacat - Ecoinformatics Redmine

                 SessionService sessionService = SessionService.getInstance();
                 logMetacat.debug("SessionService singleton created " + sessionService);
                 // Check if the servlet was configured, and if not stop the
                 // initialization and skip to the configuration web form when
                 // metacat is called
                 if (!MetaCatUtil.isMetacatConfigured()) {
         		// Check to see if the user has requested to bypass configuration
                 // (dev option) and check see if metacat has been configured.
         		// If both are false then stop the initialization
                 if (!MetaCatUtil.bypassConfiguration() && !MetaCatUtil.isMetacatConfigured()) {
                 	return;
+                }
-...
     			SessionService.touchSession(httpSession.getId());
+    		}
     		// Each time metacat is called, see if it has been configured,
     		// and if not, then forward to the administration servlet
     		// Each time metacat is called, check to see if metacat has been
     		// configured. If not then forward to the administration servlet
     		if (!MetaCatUtil.isMetacatConfigured()) {
     			RequestUtil.forwardRequest(request, response, "/admin?action=configure");
     			return;

     	private static final String MAIN_CONFIG_NAME = "metacat.properties";
     	private static final String ORG_CONFIG_NAME = "org.properties";
     	private static boolean bypassAlreadyChecked = false;
     	private static String mainPropertiesFilePath = null;
     	private static SortedProperties mainProperties = null;
-...
     	public static void persistProperties() throws GeneralPropertyException {
     		mainProperties.store();
+    	}
     	/**
     	 * Get the main backup properties file. These are configurable properties that
     	 * are stored outside the metacat install directories so the user does not
-...
+    	}
     	/**
     	 * Reports whether the metacat configuration utility should be run.
     	 * Returns false if
     	 *   -- dev.runConfiguration=false and
     	 *   -- backup properties file exists
     	 * Note that dev.runConfiguration should only be set to false when
     	 * reinstalling the same version of the application in developement.
+    	 *
     	 * @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) {
     			return bypass;
+    		}
     		try {
     			// check how dev.runConfiguration is set in metacat.properties
     			String strRunConfiguration = PropertyService.getProperty("dev.runConfiguration");
     			bypass = !(Boolean.parseBoolean(strRunConfiguration));
     			// if the deb.runConfiguration is true, return false here.
     			if (!bypass) {
     				bypassAlreadyChecked = true;
     				return false;
+    			}
     			// 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.
     			SortedProperties mainBackupProperties = getMainBackupProperties();
     			Vector<String> backupPropertyNames =
     				mainBackupProperties.getPropertyNames();
     			for (String backupPropertyName : backupPropertyNames) {
     				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);
+    			}
     			setPropertyNoPersist("configutil.propertiesConfigured", "true");
     			setPropertyNoPersist("configutil.ldapConfigured", "true");
     			setPropertyNoPersist("configutil.skinsConfigured", "true");
     			setPropertyNoPersist("configutil.databaseConfigured", "true");
     			persistProperties();
     		} catch (PropertyNotFoundException pnfe) {
     			logMetacat.error("Could not find property: " + pnfe.getMessage());
     		} catch (GeneralPropertyException gpe) {
     			logMetacat.error("General property error: " + gpe.getMessage());
+    		}
     		bypassAlreadyChecked = true;
     		return bypass;
+    	}
     	/**
     	 * Take input from the user in an HTTP request about an property to be changed
     	 * and update the metacat property file with that new value if it has
     	 * changed from the value that was originally set.

     	private static SkinPropertyService skinService = null;
     	private static boolean bypassAlreadyChecked = false;
     	private static String SKIN_DIR = null;
     	private static String BACKUP_DIR = null;
-...
     			SkinPropertyService.setPropertyNoPersist(skinName, propertyName, newValue);
+    		}
+    	}
     	/**
     	 * Reports whether the metacat configuration utility should be run.
     	 * Returns false if
     	 *   -- dev.runConfiguration=false and
     	 *   -- backup properties file exists
     	 * Note that dev.runConfiguration should only be set to false when
     	 * reinstalling the same version of the application in developement.
+    	 *
     	 * @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) {
     			return bypass;
+    		}
     		try {
     			// check how dev.runConfiguration is set in metacat.properties
     			String strRunConfiguration = PropertyService.getProperty("dev.runConfiguration");
     			bypass = !(Boolean.parseBoolean(strRunConfiguration));
     			// if the deb.runConfiguration is true, return false here.
     			if (!bypass) {
     				bypassAlreadyChecked = true;
     				return false;
+    			}
     			// 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.
     			for (String skinName : skinNames) {
     				SortedProperties backupProperties = getBackupProperties(skinName);
     				Vector<String> backupPropertyNames =
     					backupProperties.getPropertyNames();
     				for (String backupPropertyName : backupPropertyNames) {
     					String value = backupProperties.getProperty(backupPropertyName);
     					backupProperties.setPropertyNoPersist(backupPropertyName, value);
+    				}
     				backupProperties.store();
+    			}
     		} catch (PropertyNotFoundException pnfe) {
     			logMetacat.error("Could not find property: " + pnfe.getMessage());
     		} catch (GeneralPropertyException gpe) {
     			logMetacat.error("General property error: " + gpe.getMessage());
+    		}
     		bypassAlreadyChecked = true;
     		return bypass;
+    	}
+    }

     import edu.ucsb.nceas.metacat.DBSAXHandler;
     import edu.ucsb.nceas.metacat.MetaCatServlet;
     import edu.ucsb.nceas.metacat.service.PropertyService;
     import edu.ucsb.nceas.metacat.service.SkinPropertyService;
     import edu.ucsb.nceas.utilities.PropertyNotFoundException;
     import edu.ucsb.nceas.utilities.FileUtil;
     /**
      * A suite of utility classes for the metadata catalog server
-...
     		return metacatConfigured;
+    	}
     	/**
     	 * Reports whether the metacat configuration utility should be run.
     	 * Returns false if
     	 *   -- dev.runConfiguration=false and
     	 *   -- backup properties file exists
     	 * Note that dev.runConfiguration should only be set to false when
     	 * reinstalling the same version of the application in developement.
+    	 *
     	 * @return a boolean that is false if dev.runConfiguration is false and
     	 * the backup properties file exists.
     	 */
     	public static boolean bypassConfiguration() {
     		// we use the bypassConfiguration() method in Property service
     		// to determine if bypass is necessary.  if it is, we call the
     		// similar method in SkinPropertyService.  Both of these calls
     		// make sure backup properties get persisted to active properties.
     		boolean bypass = PropertyService.bypassConfiguration();
     		if (bypass) {
     			SkinPropertyService.bypassConfiguration();
+    		}
     		return bypass;
+    	}
+    }

src/edu/ucsb/nceas/metacat/admin/PropertiesAdmin.java
107	107	.discoverServerPort(request));
108	108	PropertyService.setPropertyNoPersist("server.httpSSLPort",
109	109	SystemUtil.discoverServerSSLPort(request));
	110	// TODO MCD change this to handle deploy dir
110	111	PropertyService.setPropertyNoPersist("application.tomcatDir",
111	112	SystemUtil.discoverTomcatDir(request));
112	113

Project

General

Profile

Metacat

Revision 4154

Added by daigle over 16 years ago