1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.log4j;
19
20 import org.apache.log4j.helpers.LogLog;
21 import org.apache.log4j.or.ObjectRenderer;
22 import org.apache.log4j.or.RendererMap;
23 import org.apache.log4j.plugins.Plugin;
24 import org.apache.log4j.plugins.PluginRegistry;
25 import org.apache.log4j.scheduler.Scheduler;
26 import org.apache.log4j.spi.ErrorItem;
27 import org.apache.log4j.spi.HierarchyEventListener;
28 import org.apache.log4j.spi.LoggerEventListener;
29 import org.apache.log4j.spi.LoggerFactory;
30 import org.apache.log4j.spi.LoggerRepository;
31 import org.apache.log4j.spi.LoggerRepositoryEventListener;
32 import org.apache.log4j.spi.LoggerRepositoryEx;
33 import org.apache.log4j.spi.RendererSupport;
34 import org.apache.log4j.xml.UnrecognizedElementHandler;
35 import org.apache.log4j.xml.DOMConfigurator;
36 import org.w3c.dom.Element;
37
38 import java.util.ArrayList;
39 import java.util.Enumeration;
40 import java.util.HashMap;
41 import java.util.Hashtable;
42 import java.util.List;
43 import java.util.Map;
44 import java.util.Properties;
45 import java.util.Vector;
46
47
48
49
50
51
52
53 public final class LoggerRepositoryExImpl
54 implements LoggerRepositoryEx,
55 RendererSupport,
56 UnrecognizedElementHandler {
57
58
59
60
61 private final LoggerRepository repo;
62
63
64
65
66
67 private LoggerFactory loggerFactory;
68
69
70
71
72 private final RendererSupport rendererSupport;
73
74
75
76
77 private final ArrayList repositoryEventListeners = new ArrayList();
78
79
80
81 private final Map loggerEventListeners = new HashMap();
82
83
84
85 private String name;
86
87
88
89 private PluginRegistry pluginRegistry;
90
91
92
93 private final Map properties = new Hashtable();
94
95
96
97 private Scheduler scheduler;
98
99
100
101
102 private Map objectMap = new HashMap();
103
104
105
106
107
108 private List errorList = new Vector();
109
110
111
112
113 private boolean pristine = true;
114
115
116
117
118
119
120
121 public LoggerRepositoryExImpl(final LoggerRepository repository) {
122 super();
123 if (repository == null) {
124 throw new NullPointerException("repository");
125 }
126 repo = repository;
127 if (repository instanceof RendererSupport) {
128 rendererSupport = (RendererSupport) repository;
129 } else {
130 rendererSupport = new RendererSupportImpl();
131 }
132 }
133
134
135
136
137
138
139
140 public void addLoggerRepositoryEventListener(
141 final LoggerRepositoryEventListener listener) {
142 synchronized (repositoryEventListeners) {
143 if (repositoryEventListeners.contains(listener)) {
144 LogLog.warn(
145 "Ignoring attempt to add a previously "
146 + "registered LoggerRepositoryEventListener.");
147 } else {
148 repositoryEventListeners.add(listener);
149 }
150 }
151 }
152
153
154
155
156
157
158 public void removeLoggerRepositoryEventListener(
159 final LoggerRepositoryEventListener listener) {
160 synchronized (repositoryEventListeners) {
161 if (!repositoryEventListeners.contains(listener)) {
162 LogLog.warn(
163 "Ignoring attempt to remove a "
164 + "non-registered LoggerRepositoryEventListener.");
165 } else {
166 repositoryEventListeners.remove(listener);
167 }
168 }
169 }
170
171
172
173
174
175
176 public void addLoggerEventListener(final LoggerEventListener listener) {
177 synchronized (loggerEventListeners) {
178 if (loggerEventListeners.get(listener) != null) {
179 LogLog.warn(
180 "Ignoring attempt to add a previously registerd LoggerEventListener.");
181 } else {
182 HierarchyEventListenerProxy proxy =
183 new HierarchyEventListenerProxy(listener);
184 loggerEventListeners.put(listener, proxy);
185 repo.addHierarchyEventListener(proxy);
186 }
187 }
188 }
189
190
191
192
193
194
195
196 public
197 void addHierarchyEventListener(final HierarchyEventListener listener) {
198 repo.addHierarchyEventListener(listener);
199 }
200
201
202
203
204
205
206 public void removeLoggerEventListener(final LoggerEventListener listener) {
207 synchronized (loggerEventListeners) {
208 HierarchyEventListenerProxy proxy =
209 (HierarchyEventListenerProxy) loggerEventListeners.get(listener);
210 if (proxy == null) {
211 LogLog.warn(
212 "Ignoring attempt to remove a non-registered LoggerEventListener.");
213 } else {
214 loggerEventListeners.remove(listener);
215 proxy.disable();
216 }
217 }
218 }
219
220
221
222
223
224 public void emitNoAppenderWarning(final Category cat) {
225 repo.emitNoAppenderWarning(cat);
226 }
227
228
229
230
231
232
233
234
235 public Logger exists(final String loggerName) {
236 return repo.exists(loggerName);
237 }
238
239
240
241
242
243 public String getName() {
244 return name;
245 }
246
247
248
249
250
251
252
253 public void setName(final String repoName) {
254 if (name == null) {
255 name = repoName;
256 } else if (!name.equals(repoName)) {
257 throw new IllegalStateException(
258 "Repository [" + name + "] cannot be renamed as [" + repoName + "].");
259 }
260 }
261
262
263
264
265 public Map getProperties() {
266 return properties;
267 }
268
269
270
271
272 public String getProperty(final String key) {
273 return (String) properties.get(key);
274 }
275
276
277
278
279
280
281
282 public void setProperty(final String key,
283 final String value) {
284 properties.put(key, value);
285 }
286
287
288
289
290
291 public void setThreshold(final String levelStr) {
292 repo.setThreshold(levelStr);
293 }
294
295
296
297
298
299
300
301 public void setThreshold(final Level l) {
302 repo.setThreshold(l);
303 }
304
305
306
307
308 public PluginRegistry getPluginRegistry() {
309 if (pluginRegistry == null) {
310 pluginRegistry = new PluginRegistry(this);
311 }
312 return pluginRegistry;
313 }
314
315
316
317
318
319
320
321
322 public void fireAddAppenderEvent(final Category logger,
323 final Appender appender) {
324 repo.fireAddAppenderEvent(logger, appender);
325 }
326
327
328
329
330
331
332
333
334 public void fireRemoveAppenderEvent(final Category logger,
335 final Appender appender) {
336 if (repo instanceof Hierarchy) {
337 ((Hierarchy) repo).fireRemoveAppenderEvent(logger, appender);
338 }
339 }
340
341
342
343
344
345
346
347 public void fireLevelChangedEvent(final Logger logger) {
348 }
349
350
351
352
353
354
355
356 public void fireConfigurationChangedEvent() {
357 }
358
359
360
361
362
363
364
365 public Level getThreshold() {
366 return repo.getThreshold();
367 }
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382 public Logger getLogger(final String loggerName) {
383 return repo.getLogger(loggerName);
384 }
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400 public Logger getLogger(final String loggerName,
401 final LoggerFactory factory) {
402 return repo.getLogger(loggerName, factory);
403 }
404
405
406
407
408
409
410
411
412
413 public Enumeration getCurrentLoggers() {
414 return repo.getCurrentLoggers();
415 }
416
417
418
419
420
421 public List getErrorList() {
422 return errorList;
423 }
424
425
426
427
428
429 public void addErrorItem(final ErrorItem errorItem) {
430 getErrorList().add(errorItem);
431 }
432
433
434
435
436
437
438 public Enumeration getCurrentCategories() {
439 return repo.getCurrentCategories();
440 }
441
442
443
444
445
446 public RendererMap getRendererMap() {
447 return rendererSupport.getRendererMap();
448 }
449
450
451
452
453
454
455
456 public Logger getRootLogger() {
457 return repo.getRootLogger();
458 }
459
460
461
462
463
464
465
466
467
468 public boolean isDisabled(final int level) {
469 return repo.isDisabled(level);
470 }
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486 public void resetConfiguration() {
487 repo.resetConfiguration();
488 }
489
490
491
492
493
494
495 public void setRenderer(final Class renderedClass,
496 final ObjectRenderer renderer) {
497 rendererSupport.setRenderer(renderedClass, renderer);
498 }
499
500
501
502
503 public boolean isPristine() {
504 return pristine;
505 }
506
507
508
509
510 public void setPristine(final boolean state) {
511 pristine = state;
512 }
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529 public void shutdown() {
530 repo.shutdown();
531 }
532
533
534
535
536
537
538
539 public Scheduler getScheduler() {
540 if (scheduler == null) {
541 scheduler = new Scheduler();
542 scheduler.setDaemon(true);
543 scheduler.start();
544 }
545 return scheduler;
546 }
547
548
549
550
551
552
553 public void putObject(final String key,
554 final Object value) {
555 objectMap.put(key, value);
556 }
557
558
559
560
561
562
563 public Object getObject(final String key) {
564 return objectMap.get(key);
565 }
566
567
568
569
570
571 public void setLoggerFactory(final LoggerFactory factory) {
572 if (factory == null) {
573 throw new NullPointerException();
574 }
575 this.loggerFactory = factory;
576 }
577
578
579
580
581
582 public LoggerFactory getLoggerFactory() {
583 return loggerFactory;
584 }
585
586
587 public boolean parseUnrecognizedElement(
588 final Element element,
589 final Properties props) throws Exception {
590 if ("plugin".equals(element.getNodeName())) {
591 Object instance =
592 DOMConfigurator.parseElement(element, props, Plugin.class);
593 if (instance instanceof Plugin) {
594 Plugin plugin = (Plugin) instance;
595 String pluginName = DOMConfigurator.subst(element.getAttribute("name"), props);
596 if (pluginName.length() > 0) {
597 plugin.setName(pluginName);
598 }
599 getPluginRegistry().addPlugin(plugin);
600 plugin.setLoggerRepository(this);
601
602 LogLog.debug("Pushing plugin on to the object stack.");
603 plugin.activateOptions();
604 return true;
605 }
606 }
607 return false;
608 }
609
610
611
612
613
614
615
616 private static final class RendererSupportImpl implements RendererSupport {
617
618
619
620 private final RendererMap renderers = new RendererMap();
621
622
623
624
625 public RendererSupportImpl() {
626 super();
627 }
628
629
630 public RendererMap getRendererMap() {
631 return renderers;
632 }
633
634
635 public void setRenderer(final Class renderedClass,
636 final ObjectRenderer renderer) {
637 renderers.put(renderedClass, renderer);
638 }
639 }
640
641
642
643
644
645 private static final class HierarchyEventListenerProxy
646 implements HierarchyEventListener {
647
648
649
650 private LoggerEventListener listener;
651
652
653
654
655
656 public HierarchyEventListenerProxy(final LoggerEventListener l) {
657 super();
658 if (l == null) {
659 throw new NullPointerException("l");
660 }
661 listener = l;
662 }
663
664
665 public void addAppenderEvent(final Category cat,
666 final Appender appender) {
667 if (isEnabled() && cat instanceof Logger) {
668 listener.appenderAddedEvent((Logger) cat, appender);
669 }
670 }
671
672
673 public void removeAppenderEvent(final Category cat,
674 final Appender appender) {
675 if (isEnabled() && cat instanceof Logger) {
676 listener.appenderRemovedEvent((Logger) cat, appender);
677 }
678 }
679
680
681
682
683
684 public synchronized void disable() {
685 listener = null;
686 }
687
688
689
690
691
692 private synchronized boolean isEnabled() {
693 return listener != null;
694 }
695 }
696
697 }