|
1
87 package org.codehaus.loom.components.logger;
88
89 import java.io.File  ;
90 import java.util.HashMap ;
91 import java.util.Iterator ;
92 import java.util.Map ;
93 import java.util.Properties ;
94 import javax.xml.parsers.DocumentBuilder ;
95 import javax.xml.parsers.DocumentBuilderFactory ;
96 import org.apache.avalon.framework.configuration.Configuration;
97 import org.apache.avalon.framework.container.ContainerUtil;
98 import org.apache.avalon.framework.context.Context;
99 import org.apache.avalon.framework.context.DefaultContext;
100 import org.apache.avalon.framework.logger.Logger;
101 import org.apache.avalon.phoenix.BlockContext;
102 import org.codehaus.loom.components.util.ResourceUtil;
103 import org.codehaus.loom.interfaces.LogManager;
104 import org.codehaus.spice.alchemist.logger.LoggerAlchemist;
105 import org.codehaus.spice.alchemist.configuration.ConfigurationAlchemist;
106 import org.codehaus.spice.configkit.PropertyExpander;
107 import org.codehaus.spice.configkit.ResolverFactory;
108 import org.codehaus.spice.loggerstore.LoggerStore;
109 import org.codehaus.spice.loggerstore.LoggerStoreFactory;
110 import org.codehaus.spice.loggerstore.factories.DOMLog4JLoggerStoreFactory;
111 import org.codehaus.spice.loggerstore.factories.InitialLoggerStoreFactory;
112 import org.codehaus.spice.loggerstore.factories.Jdk14LoggerStoreFactory;
113 import org.codehaus.spice.loggerstore.factories.LogKitLoggerStoreFactory;
114 import org.codehaus.spice.loggerstore.factories.PropertyLog4JLoggerStoreFactory;
115 import org.codehaus.spice.loggerstore.factories.SimpleLogKitLoggerStoreFactory;
116 import org.codehaus.spice.salt.i18n.ResourceManager;
117 import org.codehaus.spice.salt.i18n.Resources;
118 import org.codehaus.dna.AbstractLogEnabled;
119 import org.codehaus.dna.Composable;
120 import org.codehaus.dna.MissingResourceException;
121 import org.codehaus.dna.ResourceLocator;
122 import org.codehaus.dna.impl.ConfigurationUtil;
123 import org.w3c.dom.Document ;
124 import org.w3c.dom.Element ;
125 import org.w3c.dom.Node ;
126 import org.w3c.dom.NodeList ;
127 import org.xml.sax.EntityResolver ;
128
129
134 public class DefaultLogManager
135 extends AbstractLogEnabled
136 implements LogManager, Composable
137 {
138 private static final Resources REZ =
139 ResourceManager.getPackageResources( DefaultLogManager.class );
140
141 private final PropertyExpander m_expander = new PropertyExpander();
142
143 private final InitialLoggerStoreFactory m_factory = new InitialLoggerStoreFactory();
144
145
146 private File m_loomHome;
147
148
151 public void compose( ResourceLocator locator )
152 throws MissingResourceException
153 {
154 m_loomHome = (File )locator.lookup( File .class.getName() + "/home" );
155 }
156
157 private Map createLoggerManagerContext( final Map appContext )
158 {
159 final HashMap data = new HashMap ();
160 data.putAll( appContext );
161 data.put( "loom.home", m_loomHome );
162 return data;
163 }
164
165
173 private Map normaliseFilePaths( final Map data )
174 {
175 final Map map = new HashMap ();
176 map.putAll( data );
177 for( Iterator i = data.keySet().iterator(); i.hasNext(); )
178 {
179 final Object key = i.next();
180 final Object value = data.get( key );
181 if( value instanceof File )
182 {
183 final File file = (File )value;
184 final String newPath = normalisePath( file.getPath() );
185 map.put( key, newPath );
187 }
188 }
189 return map;
190 }
191
192
198 private String normalisePath( final String path )
199 {
200 return path.replace( File.separatorChar, '/' );
201 }
202
203
211 public LoggerStore
212 createHierarchy( final org.codehaus.dna.Configuration logs,
213 final File homeDirectory,
214 final File workDirectory,
215 final Map context )
216 throws Exception
217 {
218 final Map map = createLoggerManagerContext( context );
219 final Map normalisedMap = normaliseFilePaths( map );
221 if( null == logs )
222 {
223 LoggerStore store = null;
224 store = scanForLoggerConfig( "SAR-INF/log4j.properties",
225 PropertyLog4JLoggerStoreFactory.class.getName(),
226 homeDirectory,
227 workDirectory,
228 normalisedMap );
229 if( null != store )
230 {
231 return store;
232 }
233 store = scanForLoggerConfig( "SAR-INF/log4j.xml",
234 DOMLog4JLoggerStoreFactory.class.getName(),
235 homeDirectory,
236 workDirectory,
237 normalisedMap );
238 if( null != store )
239 {
240 return store;
241 }
242 store = scanForLoggerConfig( "SAR-INF/logging.properties",
243 Jdk14LoggerStoreFactory.class.getName(),
244 homeDirectory,
245 workDirectory,
246 normalisedMap );
247 if( null != store )
248 {
249 return store;
250 }
251 store = scanForLoggerConfig( "SAR-INF/excalibur-logger.xml",
252 LogKitLoggerStoreFactory.class.getName(),
253 homeDirectory,
254 workDirectory,
255 normalisedMap );
256 if( null != store )
257 {
258 return store;
259 }
260
261 final String message = "Unable to locate any logging configuration";
263 throw new IllegalStateException ( message );
264 }
265 else
266 {
267 final String version = logs.getAttribute( "version", "1.0" );
268 if( getLogger().isDebugEnabled() )
269 {
270 final String message =
271 REZ.format( "logger-create",
272 context.get( BlockContext.APP_NAME ),
273 version );
274 getLogger().debug( message );
275 }
276
277 Logger logger = LoggerAlchemist.toAvalonLogger( getLogger() );
278 if( version.equals( "1.0" ) )
279 {
280 final LoggerStoreFactory loggerManager = new SimpleLogKitLoggerStoreFactory();
281 ContainerUtil.enableLogging( loggerManager, logger );
282 final HashMap config = new HashMap ();
283 config.put( Logger.class.getName(), logger );
284 config.put( Context.class.getName(),
287 new DefaultContext( map ) );
288 config.put( Configuration.class.getName(),
289 ConfigurationAlchemist.toAvalonConfiguration( logs ) );
290 return loggerManager.createLoggerStore( config );
291 }
292 else if( version.equals( "1.1" ) )
293 {
294 final LoggerStoreFactory loggerManager = new LogKitLoggerStoreFactory();
295 ContainerUtil.enableLogging( loggerManager, logger );
296 final HashMap config = new HashMap ();
297 config.put( Logger.class.getName(), logger );
298 config.put( Context.class.getName(),
299 new DefaultContext( normalisedMap ) );
300 config.put( Configuration.class.getName(),
301 ConfigurationAlchemist.toAvalonConfiguration( logs ) );
302 return loggerManager.createLoggerStore( config );
303 }
304 else if( version.equals( "log4j" ) )
305 {
306 final LoggerStoreFactory loggerManager = new DOMLog4JLoggerStoreFactory();
307 ContainerUtil.enableLogging( loggerManager, logger );
308 final HashMap config = new HashMap ();
309 final Element element = buildLog4JConfiguration( logs );
310 m_expander.expandValues( element, normalisedMap );
311 config.put( Element .class.getName(), element );
312 return loggerManager.createLoggerStore( config );
313 }
314 else
315 {
316 final String message =
317 "Unknown logger version '" +
318 version +
319 "' in environment.xml";
320 throw new IllegalStateException ( message );
321 }
322 }
323 }
324
325 private Element
326 buildLog4JConfiguration( final org.codehaus.dna.Configuration logs )
327 {
328 final Element element = ConfigurationUtil.toElement( logs );
329 final Document document = element.getOwnerDocument();
330 final Element newElement = document.createElement(
331 "log4j:configuration" );
332 final NodeList childNodes = element.getChildNodes();
333 final int length = childNodes.getLength();
334 for( int i = 0; i < length; i++ )
335 {
336 final Node node = childNodes.item( i );
337 final Node newNode = node.cloneNode( true );
338 newElement.appendChild( newNode );
339 }
340
341 document.appendChild( newElement );
342 return newElement;
343 }
344
345 private LoggerStore scanForLoggerConfig( final String location,
346 final String classname,
347 final File homeDirectory,
348 final File workDirectory,
349 final Map context )
350 throws Exception
351 {
352 final boolean isPropertiesFile = location.endsWith( "properties" );
353 final File file =
354 ResourceUtil.getFileForResource( location,
355 homeDirectory,
356 workDirectory );
357 LoggerStore store = null;
358 if( null != file )
359 {
360 final HashMap config = new HashMap ();
361 if( isPropertiesFile )
362 {
363 final Properties properties = new Properties ();
364 properties.load( file.toURL().openStream() );
365 final Properties newProperties =
366 m_expander.expandValues( properties, context );
367 config.put( Properties .class.getName(), newProperties );
368 }
369 else if( !location.equals( "SAR-INF/excalibur-logger.xml" ) )
371 {
372 final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
373 final DocumentBuilder builder = factory.newDocumentBuilder();
374
375 final EntityResolver resolver =
377 ResolverFactory.createResolver(
378 getClass().getClassLoader() );
379 builder.setEntityResolver( resolver );
380 final Document document = builder.parse( file );
381 final Element element = document.getDocumentElement();
382 m_expander.expandValues( element, context );
383 config.put( Element .class.getName(), element );
384 }
385 else
386 {
387 config.put( LoggerStoreFactory.URL_LOCATION, file.toURL() );
388 }
389 config.put( InitialLoggerStoreFactory.INITIAL_FACTORY, classname );
390 store = m_factory.createLoggerStore( config );
391 }
392 return store;
393 }
394 }
395 |
Popular Tags |
Java API By Example, From Geeks To Geeks.