ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/i-scream/projects/cms/source/server/uk/org/iscream/cms/server/core/ConfigurationManagerServant.java

Comparing projects/cms/source/server/uk/org/iscream/cms/server/core/ConfigurationManagerServant.java (file contents):
Revision 1.5 by ajm, Wed Nov 29 21:27:08 2000 UTC vs.
Revision 1.22 by tdb, Tue Dec 11 17:52:35 2001 UTC

#	Line 1 | Line 1
1		//---PACKAGE DECLARATION---
2	<	package uk.ac.ukc.iscream.core;
2	>	package uk.org.iscream.cms.server.core;
3
4		//---IMPORTS---
5	<	import uk.ac.ukc.iscream.core.*;
5	>	import uk.org.iscream.cms.server.util.*;
6	>	import uk.org.iscream.cms.server.componentmanager.*;
7	>	import java.net.InetAddress;
8	>	import java.net.UnknownHostException;
9		import java.util.*;
10		import java.io.*;
8	–	import org.omg.CORBA.*;
9	–	import org.omg.PortableServer.*;
11
12		/**
13		* This class is essentially a Configuration factory.
#	Line 38 | Line 39 | class ConfigurationManagerServant extends Configuratio
39		/**
40		* Creates a new ConfiguratorServant
41		* This class uses the System.properties to set internal values
41	–	*
42	–	* @param rootPOARef a reference to the RootPOA
43	–	* @param logRef a reference to the Logger
42		*/
43	<	ConfigurationManagerServant(POA rootPOARef, Logger logRef) {
43	>	ConfigurationManagerServant() {
44		// assign some local variables
45	<	_rootPOARef = rootPOARef;
46	<	_logRef = logRef;
49	<	_configPath = System.getProperty("uk.ac.ukc.iscream.ConfigurationLocation");
50	<	_systemConfigFile = System.getProperty("uk.ac.ukc.iscream.SystemConfigurationFile");
45	>	_configPath = System.getProperty("uk.org.iscream.cms.server.ConfigurationLocation");
46	>	_systemConfigFile = System.getProperty("uk.org.iscream.cms.server.SystemConfigurationFile");
47
48		// load the system config
49		loadSystemConfig();
50
51		// log our status
52	<	_logRef.write(this.toString(), Logger.SYSINIT, "started");
53	<	_logRef.write(this.toString(), Logger.SYSMSG, "configuration location - " + _configPath);
54	<	_logRef.write(this.toString(), Logger.SYSMSG, "system configuration file - " + _systemConfigFile);
52	>	_logger.write(toString(), Logger.SYSINIT, "started");
53	>	_logger.write(toString(), Logger.SYSMSG, "configuration location - " + _configPath);
54	>	_logger.write(toString(), Logger.SYSMSG, "system configuration file - " + _systemConfigFile);
55		}
56
57		//---PUBLIC METHODS---
#	Line 80 | Line 76 | class ConfigurationManagerServant extends Configuratio
76		* @return the Configuration
77		*/
78		public Configuration getConfiguration(String source) {
79	<	_logRef.write(this.toString(), Logger.SYSMSG, "got request for " + source);
80	<	Configuration config = null;
79	>	_logger.write(toString(), Logger.SYSMSG, "got request for " + source);
80	>
81
82		// check to see if we need to reload the system config
83		// because it has changed
84		if (isModified(_systemConfig.getFileList(), _systemConfig.getLastModified())) {
85	<	_logRef.write(this.toString(), Logger.SYSMSG, "system config changed");
85	>	_logger.write(toString(), Logger.SYSMSG, "system config changed");
86		loadSystemConfig();
87		}
88
89	<	// we look for this entry in the systemConfig
90	<	String configFile = _systemConfig.getProperty("config." + source);
91	<	_logRef.write(this.toString(), Logger.DEBUG, "looking for config tree in - " + configFile);
92	<
93	<	// if there is an entry
94	<	if (configFile != null) {
89	>	// search config for group membership
90	>	// and obain a list of groups by name
91	>	LinkedList nameGroups = getGroupMembership(source);
92	>	// add the hosts individual config to the start of the list
93	>	nameGroups.addFirst(source);
94	>
95	>	// this list will be used to compile the groupings
96	>	LinkedList groups = new LinkedList();
97	>
98	>	// if we are dealing with a Host.<hostname> request, then we also
99	>	// want to look for ip address details, as configuration entries may relate to it
100	>	// if we can't resolve it, we don't look.
101	>	LinkedList ipGroups = null;
102	>	if (source.startsWith("Host.")) {
103	>	// hostname is after Host.
104	>	String hostname = source.substring(5);
105		try {
106	<	// get the file list of includes etc + the system config
107	<	String fileList = _systemConfigFile + ";" + getIncludedFiles(configFile, "");
108	<	_logRef.write(this.toString(), Logger.DEBUG, "config tree - " + fileList);
109	<
110	<	// build the properites here from the filelist....
111	<	StringTokenizer st = new StringTokenizer(fileList, ";");
112	<
113	<	// some holders for variables
114	<	File currentFile;
115	<	long lastModified, newLastModified;
116	<	Properties properties, prevProperties;
117	<
112	<	// the root of all configurations will be the system config
113	<	// so we need to open the properties of that
114	<	Properties defaultProperties = new Properties();
115	<	currentFile = new File(_configPath, _systemConfigFile);
116	<	lastModified = currentFile.lastModified();
117	<	defaultProperties.load(new FileInputStream(currentFile));
118	<
119	<	// This loop then iterates over the file list
120	<	// creates the properties to be passed to the
121	<	// Configuration constructor
122	<	do {
123	<	properties = new Properties(defaultProperties);
124	<	currentFile = new File(_configPath, st.nextToken());
125	<	newLastModified = currentFile.lastModified();
126	<	if (newLastModified > lastModified) {
127	<	lastModified = newLastModified;
128	<	}
129	<	properties.load(new FileInputStream(currentFile));
130	<	defaultProperties = properties;
131	<	} while (st.hasMoreTokens());
106	>	String ip = "Host." + InetAddress.getByName(hostname).getHostAddress();
107	>	ipGroups = getGroupMembership(ip);
108	>	ipGroups.addFirst(ip);
109	>	// add to our list of groups
110	>	groups.addAll(ipGroups);
111	>	} catch (UnknownHostException e) {
112	>	_logger.write(toString(), Logger.ERROR, "could not resolve hostname - " + hostname);
113	>	}
114	>	}
115	>
116	>	// add the rest of the groups to the end
117	>	groups.addAll(nameGroups);
118
119	<	// this creates the configuration, all nice, ready to be returned
120	<	ConfigurationServant ref = new ConfigurationServant(properties, fileList, lastModified, _logRef);
121	<	org.omg.CORBA.Object objRef = _rootPOARef.servant_to_reference(ref);
122	<	config = ConfigurationHelper.narrow(objRef);
123	<
124	<	} catch (Exception e) {
125	<	// not sure what to do here
126	<	System.err.println("CONFIGURATION MANAGER ERROR: " + e);
127	<	e.printStackTrace(System.out);
119	>	Iterator i = groups.iterator();
120	>	String fileList = "";
121	>	while (i.hasNext()) {
122	>	String groupName = (String) i.next();
123	>	_logger.write(toString(), Logger.DEBUG, "looking for config entry for - " + groupName);
124	>	// we look for this entry in the systemConfig
125	>	String configFile = _systemConfig.getProperty("config." + groupName);
126	>	// if there is a config entry then
127	>	if (configFile != null) {
128	>	_logger.write(toString(), Logger.DEBUG, "looking for config tree in - " + configFile);
129	>
130	>	// get the file list of includes etc + the system config
131	>	String groupFileList = null;
132	>	try {
133	>	groupFileList = getIncludedFiles(configFile, "") + ";";
134	>	} catch (Exception e) {
135	>	// not sure what to do here
136	>	// so we just log the error
137	>	_logger.write(toString(), Logger.ERROR, "ERROR - " + e);
138	>	}
139	>	if (groupFileList != null) {
140	>	fileList += groupFileList;
141	>	}
142	>	} else {
143	>	_logger.write(toString(), Logger.DEBUG, "no config entry for - " + groupName);
144		}
143	–
144	–	// if there isn't an entry for the requested config
145	–	} else {
146	–	_logRef.write(this.toString(), Logger.DEBUG, "no configured config, returning " + _systemConfigFile);
147	–	config = _systemConfig;
145		}
146	+	// add the system config as the final check
147	+	fileList = _systemConfigFile + ";" + fileList;
148	+	_logger.write(toString(), Logger.DEBUG, "config tree - " + fileList);
149
150	+	// build the configuration
151	+	Configuration config = buildConfiguration(fileList);
152	+
153		// if this is null at this point, then there will have been an error
154		return config;
155		}
#	Line 176 | Line 179 | class ConfigurationManagerServant extends Configuratio
179		}
180		return false;
181		}
182	<
182	>
183		/**
184		* Overrides the {@link java.lang.Object#toString() Object.toString()}
185		* method to provide clean logging (every class should have this).
186		*
187	+	* This uses the uk.org.iscream.cms.server.util.FormatName class
188	+	* to format the toString()
189	+	*
190		* @return the name of this class and its CVS revision
191		*/
192		public String toString() {
193	<	return this.getClass().getName() + "(" + REVISION.substring(11, REVISION.length() - 2) + ")";
193	>	return FormatName.getName(
194	>	_name,
195	>	getClass().getName(),
196	>	REVISION);
197		}
198
199		//---PRIVATE METHODS---
#	Line 261 | Line 270 | class ConfigurationManagerServant extends Configuratio
270		* local reference _systemConfig
271		*/
272		private void loadSystemConfig() {
273	<	_logRef.write(this.toString(), Logger.SYSMSG, "reloading " + _systemConfigFile);
273	>	_logger.write(this.toString(), Logger.SYSMSG, "reloading " + _systemConfigFile);
274		// get a reference to the system config and store it
275		try {
276		// create the properties for the configuration
277		File systemConfigFile = new File(_configPath, _systemConfigFile);
278	<	Properties systemConfigHolder = new Properties();
279	<	systemConfigHolder.load(new FileInputStream(systemConfigFile));
280	<
278	>	_systemConfigHolder = new Properties();
279	>	_systemConfigHolder.load(new FileInputStream(systemConfigFile));
280	>
281		// create the servant
282	<	ConfigurationServant ref = new ConfigurationServant(systemConfigHolder, _systemConfigFile, systemConfigFile.lastModified(), _logRef);
283	<	org.omg.CORBA.Object objRef = _rootPOARef.servant_to_reference(ref);
282	>	ConfigurationServant ref = new ConfigurationServant(_systemConfigHolder, _systemConfigFile, systemConfigFile.lastModified());
283	>	org.omg.CORBA.Object objRef = _refman.getRootPOA().servant_to_reference(ref);
284
285		// narrow it to a Configuration
286		_systemConfig = ConfigurationHelper.narrow(objRef);
287
288		} catch (Exception e) {
289	<	_logRef.write(this.toString(), Logger.FATAL, "ERROR: " + e.getMessage());
289	>	_logger.write(toString(), Logger.FATAL, "ERROR: " + e.getMessage());
290		}
291		}
292
293	+	/**
294	+	* Parses the system configuration file
295	+	* for group membership entries.
296	+	*
297	+	* It looks for all entries of group.<name>
298	+	* which contain the given source name
299	+	*
300	+	* @param source the source to find membership for
301	+	*
302	+	* @return the list of groups that this source is a member of
303	+	*/
304	+	private LinkedList getGroupMembership(String source) {
305	+	_logger.write(toString(), Logger.DEBUG, "searching groups for - " + source);
306	+	LinkedList groupMembership = new LinkedList();
307	+	Iterator i = new TreeSet(_systemConfigHolder.keySet()).iterator();
308	+	while(i.hasNext()) {
309	+	String key = (String) i.next();
310	+	// look for a key that's a group entry
311	+	if (key.startsWith("group.")) {
312	+	// get the list of hosts in the group
313	+	String group = _systemConfig.getProperty(key);
314	+	if(groupMatch(source, group)) {
315	+	groupMembership.add(key.substring(6));
316	+	_logger.write(toString(), Logger.DEBUG, "group match found for - " + source + " in group - " + key);
317	+	}
318	+	}
319	+	}
320	+	return groupMembership;
321	+	}
322	+
323	+	/**
324	+	* Checks that a given source is matched within the
325	+	* given list of hosts. For example:<br>
326	+	* <br>
327	+	* Given "stue5de.ukc.ac.uk"<br>
328	+	* And   "raptor.ukc.ac.uk;stue*.ukc.ac.uk<br>
329	+	* <br>
330	+	* This method would return true as there is a match.
331	+	*
332	+	* This method will also match if the source is exactly
333	+	* matched within the group of hosts (ie. no wildcard).
334	+	*
335	+	* @param source the string to look for
336	+	* @param group the group to search for a match
337	+	*
338	+	* @return if there is a match
339	+	*/
340	+	public static boolean groupMatch(String source, String group) {
341	+	StringTokenizer st = new StringTokenizer(group, ";");
342	+	// go through all the hosts in the group
343	+	while (st.hasMoreTokens()) {
344	+	String host = st.nextToken();
345	+	if(StringUtils.wildcardMatch(source, host)) {
346	+	return true;
347	+	}
348	+	}
349	+	// not had a match
350	+	return false;
351	+	}
352	+
353	+	/**
354	+	* Build the properties as a Configuration to be
355	+	* returned to the caller
356	+	*
357	+	* @param fileList the list of files to build the configuration from
358	+	*
359	+	* @return the built Configuration
360	+	*/
361	+	private Configuration buildConfiguration(String fileList) {
362	+	Configuration config = null;
363	+
364	+	// if there is an entry
365	+	if (!fileList.equals("")) {
366	+	try {
367	+
368	+	// build the properites here from the filelist....
369	+	StringTokenizer st = new StringTokenizer(fileList, ";");
370	+
371	+	// some holders for variables
372	+	File currentFile;
373	+	long lastModified = 0, newLastModified = 0;
374	+	Properties properties = null, prevProperties = null;
375	+
376	+	// the root of all configurations will be the system config
377	+	// so we need to open the properties of that
378	+	Properties defaultProperties = new Properties();
379	+
380	+	// This loop then iterates over the file list
381	+	// creates the properties to be passed to the
382	+	// Configuration constructor
383	+	while (st.hasMoreTokens()) {
384	+	properties = new Properties(defaultProperties);
385	+	currentFile = new File(_configPath, st.nextToken());
386	+	newLastModified = currentFile.lastModified();
387	+	if (newLastModified > lastModified) {
388	+	lastModified = newLastModified;
389	+	}
390	+	properties.load(new FileInputStream(currentFile));
391	+	defaultProperties = properties;
392	+	}
393	+
394	+	// this creates the configuration, all nice, ready to be returned
395	+	ConfigurationServant ref = new ConfigurationServant(properties, fileList, lastModified);
396	+	org.omg.CORBA.Object objRef = _refman.getRootPOA().servant_to_reference(ref);
397	+	config = ConfigurationHelper.narrow(objRef);
398	+	_logger.write(toString(), Logger.DEBUG, "returning built configuration");
399	+	} catch (Exception e) {
400	+	// not sure what to do here
401	+	// so we just log the error
402	+	_logger.write(toString(), Logger.ERROR, "ERROR - " + e);
403	+	}
404	+
405	+	// if there isn't an entry for the requested config
406	+	} else {
407	+	_logger.write(toString(), Logger.DEBUG, "no configured config, returning " + _systemConfigFile);
408	+	config = _systemConfig;
409	+	}
410	+	return config;
411	+	}
412	+
413		//---ACCESSOR/MUTATOR METHODS---
414
415		//---ATTRIBUTES---
416
417		/**
418	<	* Local storage of the RootPOA
418	>	* This is the friendly identifier of the
419	>	* component this class is running in.
420	>	* eg, a Filter may be called "filter1",
421	>	* If this class does not have an owning
422	>	* component,  a name from the configuration
423	>	* can be placed here.  This name could also
424	>	* be changed to null for utility classes.
425		*/
426	<	private POA _rootPOARef;
426	>	private String _name = Core.NAME;
427	>
428	>	/**
429	>	* This holds a reference to the
430	>	* system logger that is being used.
431	>	*/
432	>	private Logger _logger = ReferenceManager.getInstance().getLogger();
433
434		/**
435	<	* Local storage of the Logger
435	>	* A reference to the reference manager in use
436		*/
437	<	private Logger _logRef;
437	>	private ReferenceManager _refman = ReferenceManager.getInstance();
438
439		/**
440		* The root path to all configurations
#	Line 309 | Line 450 | class ConfigurationManagerServant extends Configuratio
450		* An instance of the system config
451		*/
452		private Configuration _systemConfig;
453	+
454	+	/**
455	+	* The system config file represented by a
456	+	* properties object.
457	+	*/
458	+	private Properties _systemConfigHolder;
459
460		//---STATIC ATTRIBUTES---
461

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines