1 package net.logAnalyzer.config;
2
3 import java.util.Enumeration;
4 import java.util.Hashtable;
5
6 import net.logAnalyzer.analysis.AnalyzerDefinition;
7 import net.logAnalyzer.analysis.LAAnalyzer;
8 import net.logAnalyzer.converters.ConverterDefinition;
9 import net.logAnalyzer.converters.LAConverter;
10 import net.logAnalyzer.converters.LiteralConverter;
11 import net.logAnalyzer.gui.LAView;
12 import net.logAnalyzer.gui.ViewDefinition;
13 import net.logAnalyzer.patternParser.PatternDefinition;
14 import net.logAnalyzer.patternParser.PatternParsingException;
15 import net.logAnalyzer.reports.LAReportRenderer;
16 import net.logAnalyzer.reports.RendererDefinition;
17
18 /***
19 * This class contains the current configuration :
20 * <ul>
21 * <li>converters used as patterns parts;</li>
22 * <li>patterns presets.</li>
23 * <li>analyzers used to analyze parsed messages;</li>
24 * <li>renderers used to render reports with analyers results;</li>
25 * <li>views displayed in the log analyzer GUI.</li>
26 * </ul>
27 *
28 * @author Karim REFEYTON
29 * @version 0.1
30 */
31 public class ConfigurationManager {
32 /***
33 * Singleton.
34 */
35 private static ConfigurationManager instance = null;
36
37 /***
38 * Hashtable of analyzers definitions.
39 */
40 private Hashtable analyzersDef = null;
41
42 /***
43 * Hashtable of converters definitions.
44 */
45 private Hashtable convertersDef = null;
46
47 /***
48 * Hashtable of patterns definitions.
49 */
50 private Hashtable patternsDef = null;
51
52 /***
53 * Hashtable of renderers definitions.
54 */
55 private Hashtable renderersDef = null;
56
57 /***
58 * Hashtable of views definitions.
59 */
60 private Hashtable viewsDef = null;
61
62 /***
63 * Creates or returns the single instance of the configuration manager.
64 *
65 * @return Singleton.
66 */
67 public static synchronized ConfigurationManager getInstance() {
68 if (instance == null) {
69 XMLConfigurationLoader loader = new XMLConfigurationLoader();
70 instance = loader.loadConfiguration();
71 }
72 return instance;
73 }
74
75 /***
76 * Default constructor.
77 *
78 * @param patternsDef
79 * Patterns definitions.
80 * @param convertersDef
81 * Converters definitions.
82 * @param analyzersDef
83 * Analyzers definitions.
84 * @param renderersDef
85 * Renderers definitions.
86 * @param viewsDef
87 * View definitions.
88 */
89 protected ConfigurationManager(Hashtable patternsDef,
90 Hashtable convertersDef, Hashtable analyzersDef,
91 Hashtable renderersDef, Hashtable viewsDef) {
92 this.patternsDef = patternsDef;
93 this.convertersDef = convertersDef;
94 this.analyzersDef = analyzersDef;
95 this.renderersDef = renderersDef;
96 this.viewsDef = viewsDef;
97 }
98
99 /***
100 * Creates an instance of the analyzer identified by the specified name.
101 *
102 * @param name
103 * Name of the analyzer.
104 * @return Instance of the analyzer.
105 * @throws PatternParsingException
106 * If unknown analyzer.
107 */
108 public final LAAnalyzer createAnalyzer(String name)
109 throws PatternParsingException {
110 AnalyzerDefinition definition = getAnalyzerDefinition(name);
111 if (definition == null) {
112 throw new NullPointerException("Unknown analyzer [" + name + "]");
113 }
114 return definition.createAnalyzerInstance();
115 }
116
117 /***
118 * Returns the specified analyzer definition.
119 *
120 * @param name
121 * Name of the analyzer to retreive.
122 * @return Analyzer definition; <tt>null</tt> if unknown.
123 */
124 public final AnalyzerDefinition getAnalyzerDefinition(String name) {
125 return (AnalyzerDefinition) analyzersDef.get(name);
126 }
127
128 /***
129 * Returns the analyzers definitions.
130 *
131 * @return Analyzers definitions.
132 */
133 public final Enumeration getAnalyzersDefinitions() {
134 return analyzersDef.elements();
135 }
136
137 /***
138 * Creates an instance of the converter identified by the specified key. I
139 *
140 * @param key
141 * Key of the converter in the Log4J pattern.
142 * @return Instance of the converter.
143 * @throws PatternParsingException
144 * If unknown converter.
145 */
146 public final LAConverter createConverter(String key)
147 throws PatternParsingException {
148 ConverterDefinition definition = (ConverterDefinition) convertersDef
149 .get(key);
150 if (definition == null) {
151 throw new PatternParsingException("Unknown converter [letter='"
152 + key + "']");
153 }
154 return definition.createConverterInstance("%" + key);
155 }
156
157 /***
158 * Creates an instance of the converter identified by the specified key and
159 * the option. Tries to found the group identified py the specified char and
160 * a grouped converter identified by the option. If not found, creates a
161 * basic converter.
162 *
163 * @param key
164 * Key of the converter in the Log4J pattern.
165 * @param option
166 * Option of the converter, or grouped converter.
167 * @return Instance of the converter.
168 * @throws PatternParsingException
169 * If unknown converter.
170 */
171 public final LAConverter createConverter(String key, String option)
172 throws PatternParsingException {
173 try {
174
175 LAConverter converter = createConverter(key + '{' + option + '}');
176 return converter;
177 } catch (PatternParsingException ppe) {
178
179 LAConverter converter = createConverter(key);
180 converter.setOption(option);
181 return converter;
182 }
183 }
184
185 /***
186 * Creates a literal converter instance to use it as a pattern parts
187 * separator.
188 *
189 * @param literal
190 * Literal for which to create a new converter.
191 * @return Instance of the converter.
192 * @throws PatternParsingException
193 * If a parsing error occures.
194 */
195 public final LAConverter createLiteralConverter(String literal)
196 throws PatternParsingException {
197 ConverterDefinition definition = (ConverterDefinition) convertersDef
198 .get(LiteralConverter.LITERAL_NAME);
199 if (definition == null) {
200 throw new PatternParsingException("Unknown converter for literal");
201 }
202 return definition.createConverterInstance(literal);
203 }
204
205 /***
206 * Returns ths class used to handle literals.
207 *
208 * @return Literals converter class.
209 * @throws PatternParsingException
210 * If a parsing error occures.
211 */
212 public final Class getLiteralClass() throws PatternParsingException {
213 ConverterDefinition definition = (ConverterDefinition) convertersDef
214 .get(LiteralConverter.LITERAL_NAME);
215 if (definition == null) {
216 throw new PatternParsingException("Unknown converter for literal");
217 }
218 return definition.getConverterClass();
219 }
220
221 /***
222 * Returns the specified converter definition.
223 *
224 * @param name
225 * Name of the converter to retrieve.
226 * @return Converter definition; <tt>null</tt> if unknown.
227 */
228 public final ConverterDefinition getConverterDefinition(String name) {
229 return (ConverterDefinition) convertersDef.get(name);
230 }
231
232 /***
233 * Returns the converters definitions.
234 *
235 * @return Converters definitions.
236 */
237 public final Enumeration getConvertersDefinitions() {
238 return convertersDef.elements();
239 }
240
241 /***
242 * Returns the pattern string associated to the specified name.
243 *
244 * @param name
245 * Pattern name.
246 * @return Pattern string; <tt>null</tt> if unknown.
247 * @throws PatternParsingException
248 * If unknown pattern.
249 */
250 public final String getPattern(String name) throws PatternParsingException {
251 PatternDefinition definition = (PatternDefinition) patternsDef
252 .get(name);
253 if (definition == null) {
254 throw new PatternParsingException("Unknown pattern [" + name + "]");
255 }
256 return definition.getPattern();
257 }
258
259 /***
260 * Returns the specified pattern definition.
261 *
262 * @param name
263 * Name of the pattern to retrieve.
264 * @return Pattern definition; <tt>null</tt> if unknown.
265 */
266 public final PatternDefinition getPatternDefinition(String name) {
267 return (PatternDefinition) patternsDef.get(name);
268 }
269
270 /***
271 * Returns the patterns definitions.
272 *
273 * @return Patterns definitions.
274 */
275 public final Enumeration getPatternsDefinitions() {
276 return patternsDef.elements();
277 }
278
279 /***
280 * Creates an instance of the renderer identified by the specified name.
281 *
282 * @param name
283 * Name of the renderer.
284 * @param analyzers
285 * Analyzers to render.
286 * @return Instance of the renderer.
287 * @throws PatternParsingException
288 * If unknown renderer.
289 */
290 public final LAReportRenderer createRenderer(String name,
291 LAAnalyzer[] analyzers) throws PatternParsingException {
292 RendererDefinition definition = (RendererDefinition) getRendererDefinition(name);
293 if (definition == null) {
294 throw new NullPointerException("Unknown renderer [" + name + "]");
295 }
296 return definition.createRendererInstance(analyzers);
297 }
298
299 /***
300 * Returns the specified renderer definition.
301 *
302 * @param name
303 * Name of the renderer to retrieve.
304 * @return Renderer definition; <tt>null</tt> if unknown.
305 */
306 public final RendererDefinition getRendererDefinition(String name) {
307 return (RendererDefinition) renderersDef.get(name);
308 }
309
310 /***
311 * Returns the renderers definitions.
312 *
313 * @return Renderers definitions.
314 */
315 public final Enumeration getRenderersDefinitions() {
316 return renderersDef.elements();
317 }
318
319 /***
320 * Creates an instance of the view identified by the specified name.
321 *
322 * @param name
323 * Name of the view.
324 * @return Instance of the view.
325 * @throws PatternParsingException
326 * If unknown renderer.
327 */
328 public final LAView createView(String name) throws PatternParsingException {
329 ViewDefinition definition = getViewsDefinition(name);
330 if (definition == null) {
331 throw new NullPointerException("Unknown view [" + name + "]");
332 }
333 return definition.createViewInstance();
334 }
335
336 /***
337 * Returns the specified view definition.
338 *
339 * @param name
340 * Name of the view to retrieve.
341 * @return View definition; <tt>null</tt> if unknown.
342 */
343 public final ViewDefinition getViewsDefinition(String name) {
344 return (ViewDefinition) viewsDef.get(name);
345 }
346
347 /***
348 * Returns the views definitions.
349 *
350 * @return Views definitions.
351 */
352 public final Enumeration getViewsDefinitions() {
353 return viewsDef.elements();
354 }
355 }