KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > oddjob > logging > LogArchive


1 /*
2  * (c) Rob Gordon 2005
3  */
4 package org.oddjob.logging;
5
6 import java.util.ArrayList JavaDoc;
7 import java.util.Collections JavaDoc;
8 import java.util.HashMap JavaDoc;
9 import java.util.Iterator JavaDoc;
10 import java.util.LinkedList JavaDoc;
11 import java.util.List JavaDoc;
12 import java.util.Map JavaDoc;
13 import java.util.Stack JavaDoc;
14
15 import org.apache.log4j.Logger;
16
17 /**
18  * A log archive. This archives events and supports listeners.
19  *
20  * @author Rob Gordon
21  */
22 public class LogArchive {
23     private static final Logger logger = Logger.getLogger(LogArchive.class);
24     
25     /** Maximum archived lines */
26     private final int maxHistory;
27
28     private final String JavaDoc archive;
29     
30     /** Archives are stored as a linked list with new message at the beginning
31      * (first) and old messages at the end (last).
32      */
33     private final LinkedList JavaDoc events = new LinkedList JavaDoc();
34     
35     /** Map of listeners to level. */
36     private final Map JavaDoc /* <LogListener, LogLevel> */ listeners = new HashMap JavaDoc();
37     
38     /**
39      * Constructor.
40      *
41      * @param maxHistory The maximum history lines.
42      */
43     public LogArchive(String JavaDoc archive, int maxHistory) {
44         this.archive = archive;
45         this.maxHistory = maxHistory;
46     }
47     
48     /**
49      * Get the last message number in this archive.
50      *
51      * @return The last message number.
52      */
53     public long getLastMessageNumber() {
54         synchronized (events) {
55             if (events.size() == 0) {
56                 return -1;
57             }
58             LogEvent logEvent = (LogEvent) events.getFirst();
59             return logEvent.getNumber();
60         }
61     }
62
63     /**
64      * Add an event to this archive.
65      *
66      * @param level The level.
67      * @param line The message.
68      */
69     public void addEvent(LogLevel level, String JavaDoc line) {
70         synchronized (events) {
71             LogEvent event = new LogEvent(archive, getLastMessageNumber() + 1, level,
72                     line);
73             events.addFirst(event);
74             while (events.size() > maxHistory) {
75                 events.removeLast();
76             }
77             // send event to listeners
78 for (Iterator JavaDoc it = listeners.entrySet().iterator(); it.hasNext();) {
79                 Map.Entry JavaDoc entry = (Map.Entry JavaDoc) it.next();
80                 LogListener listener = (LogListener) entry.getKey();
81                 LogLevel listenerLevel = (LogLevel) entry.getValue();
82                 if (level.isLessThan(listenerLevel)) {
83                     continue;
84                 }
85                 listener.logEvent(event);
86             }
87         }
88     }
89     
90     /**
91      * Retrieve events from the archive. The most recent events are retrieved
92      * first.
93      *
94      * @param from From message number
95      * @param max The maximum number to retreive.
96      *
97      * @return The events.
98      */
99     public LogEvent[] retieveEvents(long from, int max) {
100         synchronized (events) {
101             List JavaDoc missed = new ArrayList JavaDoc();
102             int count = 0;
103             // work out what has been missed.
104 for (Iterator JavaDoc it = events.iterator(); it.hasNext() && count < max; count++) {
105                 LogEvent event = (LogEvent) it.next();
106                 if (event.getNumber() == from) {
107                     break;
108                 }
109                 missed.add(event);
110             }
111             Collections.reverse(missed);
112             return (LogEvent[]) missed.toArray(new LogEvent[0]);
113         }
114     }
115     
116     /**
117      * Add a listener.
118      *
119      * @param l The listener.
120      * @param level The level.
121      * @param last The last message number this listener requires.
122      * @param history The maximum lines this listener requires.
123      */
124     public void addListener(LogListener l,
125             LogLevel level, long last, int history) {
126         synchronized (events) {
127             Stack JavaDoc missed = new Stack JavaDoc();
128             int count = 0;
129             // work out what messages listener has missed.
130 for (Iterator JavaDoc it = events.iterator(); it.hasNext() && count < history; count++) {
131                 LogEvent event = (LogEvent) it.next();
132                 if (event.getNumber() == last) {
133                     break;
134                 }
135                 if (event.getLevel().isLessThan(level)) {
136                     continue;
137                 }
138                 missed.push(event);
139             }
140             // send missed messages
141 while (!missed.empty()) {
142                 LogEvent event = (LogEvent) missed.pop();
143                 l.logEvent(event);
144             }
145             listeners.put(l, level);
146         }
147     }
148
149     /**
150      * Remove a listener.
151      *
152      * @param l The listener.
153      */
154     public boolean removeListener(LogListener l) {
155         synchronized (events) {
156             return !(listeners.remove(l) == null);
157         }
158     }
159
160     /**
161      * Get the archive name.
162      *
163      * @return The arcchive name.
164      */
165     public String JavaDoc getArchive() {
166         return archive;
167     }
168     
169     /**
170      * Get the naximum number archive history lines supported.
171      *
172      * @return The number of lines.
173      */
174     public int getMaxHistory() {
175         return maxHistory;
176     }
177
178 }
179
Popular Tags