1 package oic.simulator.serviceprovider.manager;
3 import java.util.ArrayList;
5 import java.util.HashMap;
6 import java.util.LinkedList;
8 import oic.simulator.logger.LogEntry;
9 import oic.simulator.logger.LoggerCallback;
10 import oic.simulator.serviceprovider.Activator;
11 import oic.simulator.serviceprovider.listener.ILogUIListener;
12 import oic.simulator.serviceprovider.utils.Constants;
14 import org.eclipse.jface.resource.ImageRegistry;
15 import org.eclipse.swt.graphics.Image;
16 import org.oic.simulator.ILogger;
17 import org.oic.simulator.ILogger.Level;
18 import org.oic.simulator.SimulatorManager;
20 public class LogManager {
21 private LinkedList<LogEntry> entries = new LinkedList<LogEntry>();
22 private ArrayList<ILogUIListener> listeners = new ArrayList<ILogUIListener>();
23 private LinkedList<LogEntry> visibleEntries = new LinkedList<LogEntry>();
24 private HashMap<Integer, Boolean> visibleSeverities = new HashMap<Integer, Boolean>();
26 private ILogger logger;
27 private LogManagerSynchronizerThread synchronizerThread;
28 private Thread threadHandle;
31 synchronizerThread = new LogManagerSynchronizerThread();
32 threadHandle = new Thread(synchronizerThread);
33 threadHandle.setName("OIC Simulator event queue");
36 // Set the logger callback with the native layer
37 logger = new LoggerCallback();
38 SimulatorManager.setLogger(logger);
41 private static class LogManagerSynchronizerThread implements Runnable {
43 LinkedList<Runnable> eventQueue = new LinkedList<Runnable>();
47 while (!Thread.interrupted()) {
51 while (eventQueue.isEmpty()) {
55 } catch (InterruptedException e) {
62 pop = eventQueue.pop();
66 } catch (Exception e) {
67 if (e instanceof InterruptedException) {
75 public void addToQueue(Runnable event) {
77 eventQueue.add(event);
83 public void log(int severity, Date date, String msg) {
84 final LogEntry logEntry = new LogEntry(severity, date, msg);
85 synchronizerThread.addToQueue(new Runnable() {
88 boolean notify = false;
89 synchronized (entries) {
90 entries.add(logEntry);
91 Boolean showEntry = LogManager.this.visibleSeverities
92 .get(logEntry.getSeverity());
93 if (showEntry != null) {
95 visibleEntries.add(logEntry);
99 if (entries.size() > Constants.LOG_SIZE) {
102 if (visibleEntries.size() > Constants.LOG_SIZE) {
103 visibleEntries.pop();
108 notifyListeners(logEntry);
114 public void applyFilter(final HashMap<Integer, Boolean> visibleSeverities) {
115 synchronizerThread.addToQueue(new Runnable() {
119 LinkedList<LogEntry> newLogs = new LinkedList<LogEntry>();
120 synchronized (entries) {
121 LogManager.this.visibleSeverities = visibleSeverities;
122 for (LogEntry logEntry : entries) {
123 if (LogManager.this.visibleSeverities.get(logEntry
125 newLogs.add(logEntry);
129 visibleEntries = newLogs;
136 private void notifyListeners() {
137 for (ILogUIListener l : listeners) {
138 l.logChanged(new ArrayList<LogEntry>(visibleEntries));
142 private void notifyListeners(LogEntry added) {
143 for (ILogUIListener l : listeners) {
148 public void clearLog() {
149 synchronizerThread.addToQueue(new Runnable() {
153 synchronized (entries) {
154 entries = new LinkedList<LogEntry>();
155 visibleEntries = new LinkedList<LogEntry>();
162 public void removeEntry(final LogEntry element) {
163 synchronizerThread.addToQueue(new Runnable() {
167 synchronized (entries) {
168 entries.remove(element);
169 visibleEntries.remove(element);
176 public ArrayList<LogEntry> getLogEntries() {
177 synchronized (entries) {
178 return new ArrayList<LogEntry>(entries);
182 public void addLogListener(final ILogUIListener listener) {
183 synchronizerThread.addToQueue(new Runnable() {
186 if (!listeners.contains(listener)) {
187 listeners.add(listener);
193 public void removeLogListener(final ILogUIListener listener) {
194 synchronizerThread.addToQueue(new Runnable() {
197 if (!listeners.contains(listener)) {
198 listeners.remove(listener);
204 public void shutdown() {
205 threadHandle.interrupt();
208 public static String getSeverityName(int severity) {
209 if (severity == Level.INFO.ordinal()) {
210 return Constants.INFO;
211 } else if (severity == Level.WARNING.ordinal()) {
212 return Constants.WARNING;
213 } else if (severity == Level.ERROR.ordinal()) {
214 return Constants.ERROR;
215 } else if (severity == Level.DEBUG.ordinal()) {
216 return Constants.DEBUG;
218 return Constants.UNKNOWN;
222 public static Image getSeverityIcon(int severity) {
223 ImageRegistry r = Activator.getDefault().getImageRegistry();
224 if (severity == Level.INFO.ordinal()) {
225 return r.get(Constants.INFO_LOG);
226 } else if (severity == Level.WARNING.ordinal()) {
227 return r.get(Constants.WARNING_LOG);
228 } else if (severity == Level.ERROR.ordinal()) {
229 return r.get(Constants.ERROR_LOG);
230 } else if (severity == Level.DEBUG.ordinal()) {
231 return r.get(Constants.DEBUG_LOG);
233 return r.get(Constants.UNKNOWN_LOG);