org.transitime.config

Class ConfigFileReader

java.lang.Object

org.transitime.config.ConfigFileReader

public class ConfigFileReader
extends java.lang.Object

The ConfigFile class provides a way of handling parameters that can be updated without having to restart the application. The parameters can be access efficiently so that they can be accessed in loops that are frequently executed. This class is useful for parameters that are system wide and often have a default. Such params are not best stored in a database because with a db it can be harder to see what all the values are or to copy the values from one project to another. It can also be harder to keep track of changes when such params are in a database.

An additional goal of Config is for all params to be processed when the config file is read, both at startup and when file is reread. This is important because then if there are any processing problems those problems are noticed and must be dealt with immediately (instead of them occurring in an lazy fashion, perhaps when no one is available to deal with them). But this goal would mean that the params would need to be defined in config files so they would all be dealt with at startup. For many situations want the params to be defined where they are used since that would make them easier to support. But then they wouldn't get initialized until the Java class is actually accessed.

For each parameter configured in the file the property is written as a system property if that system property is not yet defined. This way all parameters are available as system properties, even non-transitime ones such as for hibernate or logback. Java properties set on the command line take precedence since the properties are not overwritten if already set.

The params are configured in an XML or a properties file. The member processConfig() first process a file named transitime.properties if one exists in the classpath. Then files specified by the Java system property transitime.configFiles . If the file has a .xml suffix then it will be processed as XML. Otherwise it will be processed as a regular properties file. Multiple config files can be used. Each XML file should have a corresponding configuration class such as CoreConfig.java. In the XXXConfig.java class the params are specified along with default values.

Multiple threads can read parameters simultaneously. The threads should call readLock() if it is important to update the parameters in a consistent way, such as when more than a single parameter are interrelated.

Logback error logging is not used in this class so that logback can be not accessed until after the configuration is processed. In this way logback can be configured using a configuration file to set any logback Java system properties such as logback.configurationFile .

Author:

SkiBu Smith

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ConfigFileReader.ConfigException An exception for when a parameter is being read in

Constructor Summary

Constructors

Constructor and Description
ConfigFileReader()

Method Summary

Modifier and Type	Method and Description
static void	processConfig() Process the configuration file specified by a file named transitime.properties that is in the classpath.
static void	processConfig(java.lang.String fileName) Processes specified config file and overrides the config parameters accordingly.
static void	readLock() When reading config params should lock up the system so that data is consistent.
static void	readUnlock() Every time readLock() is called there needs to be a call to readUnlock().
static void	readXmlConfigFile(java.lang.String fileName) Reads the specified XML file and stores the results into a HashMap configFileData.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ConfigFileReader

public ConfigFileReader()

Method Detail

readXmlConfigFile

public static void readXmlConfigFile(java.lang.String fileName)
                              throws ConfigFileReader.ConfigException

Reads the specified XML file and stores the results into a HashMap configFileData. The file is expected to be very simple. Attributes are ignored. Only values are used. The keys for the resulting HashMap are based on the XML tags and their nesting. So if one is setting a value of 75 to a param with a key transitime.predictor.allowableDistanceFromPath the XML would look like: <transitime> <predictor> <allowableDistanceFromPath> 75.0 </allowableDistanceFromPath> </predictor> </transitime>

Parameters:

fileName -

Throws:

ConfigFileReader.ConfigException

readLock

public static void readLock()

When reading config params should lock up the system so that data is consistent. This is a good idea because even though each individual param is atomic there could be situations where multiple interdependent params are being used and don't want a write to change them between access. The expectation is that the program is event driven. When an event is processed then a single call to readLock() and readUnlock() can protect the entire code where parameters might be read. The intent is not to read lock each single access of data. Every time readLock() is called there needs to be a corresponding call to readUnlock(). Since this important the readUnlock() should be in a finally block. For example: try { readLock(); ...; // Read access the data } finally { readUnlock(); }

readUnlock

public static void readUnlock()

Every time readLock() is called there needs to be a call to readUnlock(). Since this is important the readUnlock() should be called in a finally block. See readLock() for details.

processConfig

public static void processConfig(java.lang.String fileName)
                          throws ConfigFileReader.ConfigException,
                                 ConfigValue.ConfigParamException

Processes specified config file and overrides the config parameters accordingly. This way can use an XML config file instead of -D Java properties to set configuration parameters.

Reads in data and stores it in the config objects so that it is programmatically accessible. Does a write lock so that readers will only execute when data is not being modified.

Parameters:

fileName - Name of the config file. If null then default values will be used for each parameter.

Throws:

ConfigFileReader.ConfigException

ConfigValue.ConfigParamException

processConfig

public static void processConfig()

Process the configuration file specified by a file named transitime.properties that is in the classpath. The processes configuration files specified by the Java system property transitime.configFiles. The transitime.configFiles property is a ";" separated list so can specify multiple files. The files can be either in either XML or in Java properties format.

All parameters found will be set as system properties unless the system property was already set. This way Java system properties set on the command line have precedence.

By making all read parameters Java system properties they can be used for external libraries such as for specifying hibernate or logback config files.