LogArchive


1   /*
2    * (c) Rob Gordon 2005
3    */
4   package org.oddjob.logging;
5   
6   import java.util.ArrayList  ;
7   import java.util.Collections  ;
8   import java.util.HashMap  ;
9   import java.util.Iterator  ;
10  import java.util.LinkedList  ;
11  import java.util.List  ;
12  import java.util.Map  ;
13  import java.util.Stack  ;
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   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   events = new LinkedList  ();
34      
35      /** Map of listeners to level. */
36      private final Map   /* <LogListener, LogLevel> */ listeners = new HashMap  ();
37      
38      /**
39       * Constructor.
40       * 
41       * @param maxHistory The maximum history lines.
42       */
43      public LogArchive(String   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   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   it = listeners.entrySet().iterator(); it.hasNext();) {
79                  Map.Entry   entry = (Map.Entry  ) 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   missed = new ArrayList  ();
102             int count = 0;
103             // work out what has been missed.
104             for (Iterator   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   missed = new Stack  ();
128             int count = 0;
129             // work out what messages listener has missed.
130             for (Iterator   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   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
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Free Books Free Magazines
Popular Tags