service/simulator/java/eclipse-plugin/ServiceProviderPlugin/src/oic/simulator/serviceprovider/manager/LogManager.java

   1 package oic.simulator.serviceprovider.manager;
   2
   3 import java.util.ArrayList;
   4 import java.util.Date;
   5 import java.util.HashMap;
   6 import java.util.LinkedList;
   7
   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;
  13
  14 import org.eclipse.jface.resource.ImageDescriptor;
  15 import org.eclipse.jface.resource.ImageRegistry;
  16 import org.eclipse.swt.graphics.Image;
  17 import org.oic.simulator.ILogger;
  18 import org.oic.simulator.ILogger.Level;
  19 import org.oic.simulator.SimulatorManager;
  20 import org.osgi.framework.Bundle;
  21
  22 public class LogManager {
  23     private LinkedList<LogEntry>         entries           = new LinkedList<LogEntry>();
  24     private ArrayList<ILogUIListener>    listeners         = new ArrayList<ILogUIListener>();
  25     private LinkedList<LogEntry>         visibleEntries    = new LinkedList<LogEntry>();
  26     private HashMap<Integer, Boolean>    visibleSeverities = new HashMap<Integer, Boolean>();
  27
  28     private ILogger                      logger;
  29     private LogManagerSynchronizerThread synchronizerThread;
  30     private Thread                       threadHandle;
  31
  32     static {
  33         ImageRegistry r = Activator.getDefault().getImageRegistry();
  34         Bundle bundle = Activator.getDefault().getBundle();
  35         r.put(Constants.DEBUG_LOG, ImageDescriptor.createFromURL(bundle
  36                 .getEntry("/icons/debug_log.gif")));
  37         r.put(Constants.INFO_LOG, ImageDescriptor.createFromURL(bundle
  38                 .getEntry("/icons/info_log.gif")));
  39         r.put(Constants.WARNING_LOG, ImageDescriptor.createFromURL(bundle
  40                 .getEntry("/icons/warning_log.gif")));
  41         r.put(Constants.ERROR_LOG, ImageDescriptor.createFromURL(bundle
  42                 .getEntry("/icons/error_log.gif")));
  43         r.put(Constants.UNKNOWN_LOG, ImageDescriptor.createFromURL(bundle
  44                 .getEntry("/icons/unknown_log.gif")));
  45     }
  46
  47     public LogManager() {
  48         synchronizerThread = new LogManagerSynchronizerThread();
  49         threadHandle = new Thread(synchronizerThread);
  50         threadHandle.setName("OIC Simulator event queue");
  51         threadHandle.start();
  52
  53         // Set the logger callback with the native layer
  54         logger = new LoggerCallback();
  55         SimulatorManager.setLogger(logger);
  56     }
  57
  58     private static class LogManagerSynchronizerThread implements Runnable {
  59
  60         LinkedList<Runnable> eventQueue = new LinkedList<Runnable>();
  61
  62         @Override
  63         public void run() {
  64             while (!Thread.interrupted()) {
  65
  66                 synchronized (this) {
  67                     try {
  68                         while (eventQueue.isEmpty()) {
  69                             this.wait();
  70                             break;
  71                         }
  72                     } catch (InterruptedException e) {
  73                         return;
  74                     }
  75                 }
  76
  77                 Runnable pop;
  78                 synchronized (this) {
  79                     pop = eventQueue.pop();
  80                 }
  81                 try {
  82                     pop.run();
  83                 } catch (Exception e) {
  84                     if (e instanceof InterruptedException) {
  85                         return;
  86                     }
  87                     e.printStackTrace();
  88                 }
  89             }
  90         }
  91
  92         public void addToQueue(Runnable event) {
  93             synchronized (this) {
  94                 eventQueue.add(event);
  95                 this.notify();
  96             }
  97         }
  98     }
  99
 100     public void log(int severity, Date date, String msg) {
 101         final LogEntry logEntry = new LogEntry(severity, date, msg);
 102         synchronizerThread.addToQueue(new Runnable() {
 103             @Override
 104             public void run() {
 105                 boolean notify = false;
 106                 synchronized (entries) {
 107                     entries.add(logEntry);
 108                     Boolean showEntry = LogManager.this.visibleSeverities
 109                             .get(logEntry.getSeverity());
 110                     if (showEntry != null) {
 111                         if (showEntry) {
 112                             visibleEntries.add(logEntry);
 113                             notify = true;
 114                         }
 115                     }
 116                     if (entries.size() > Constants.LOG_SIZE) {
 117                         entries.pop();
 118                     }
 119                     if (visibleEntries.size() > Constants.LOG_SIZE) {
 120                         visibleEntries.pop();
 121                         notify = true;
 122                     }
 123                 }
 124                 if (notify) {
 125                     notifyListeners(logEntry);
 126                 }
 127             }
 128         });
 129     }
 130
 131     public void applyFilter(final HashMap<Integer, Boolean> visibleSeverities) {
 132         synchronizerThread.addToQueue(new Runnable() {
 133
 134             @Override
 135             public void run() {
 136                 LinkedList<LogEntry> newLogs = new LinkedList<LogEntry>();
 137                 synchronized (entries) {
 138                     LogManager.this.visibleSeverities = visibleSeverities;
 139                     for (LogEntry logEntry : entries) {
 140                         if (LogManager.this.visibleSeverities.get(logEntry
 141                                 .getSeverity())) {
 142                             newLogs.add(logEntry);
 143                         }
 144                     }
 145                 }
 146                 visibleEntries = newLogs;
 147                 notifyListeners();
 148             }
 149         });
 150
 151     }
 152
 153     private void notifyListeners() {
 154         for (ILogUIListener l : listeners) {
 155             l.logChanged(new ArrayList<LogEntry>(visibleEntries));
 156         }
 157     }
 158
 159     private void notifyListeners(LogEntry added) {
 160         for (ILogUIListener l : listeners) {
 161             l.logAdded(added);
 162         }
 163     }
 164
 165     public void clearLog() {
 166         synchronizerThread.addToQueue(new Runnable() {
 167
 168             @Override
 169             public void run() {
 170                 synchronized (entries) {
 171                     entries = new LinkedList<LogEntry>();
 172                     visibleEntries = new LinkedList<LogEntry>();
 173                 }
 174                 notifyListeners();
 175             }
 176         });
 177     }
 178
 179     public void removeEntry(final LogEntry element) {
 180         synchronizerThread.addToQueue(new Runnable() {
 181
 182             @Override
 183             public void run() {
 184                 synchronized (entries) {
 185                     entries.remove(element);
 186                     visibleEntries.remove(element);
 187                 }
 188                 notifyListeners();
 189             }
 190         });
 191     }
 192
 193     public ArrayList<LogEntry> getLogEntries() {
 194         synchronized (entries) {
 195             return new ArrayList<LogEntry>(entries);
 196         }
 197     }
 198
 199     public void addLogListener(final ILogUIListener listener) {
 200         synchronizerThread.addToQueue(new Runnable() {
 201             @Override
 202             public void run() {
 203                 if (!listeners.contains(listener)) {
 204                     listeners.add(listener);
 205                 }
 206             }
 207         });
 208     }
 209
 210     public void removeLogListener(final ILogUIListener listener) {
 211         synchronizerThread.addToQueue(new Runnable() {
 212             @Override
 213             public void run() {
 214                 if (!listeners.contains(listener)) {
 215                     listeners.remove(listener);
 216                 }
 217             }
 218         });
 219     }
 220
 221     public void shutdown() {
 222         threadHandle.interrupt();
 223     }
 224
 225     public static String getSeverityName(int severity) {
 226         if (severity == Level.INFO.ordinal()) {
 227             return Constants.INFO;
 228         } else if (severity == Level.WARNING.ordinal()) {
 229             return Constants.WARNING;
 230         } else if (severity == Level.ERROR.ordinal()) {
 231             return Constants.ERROR;
 232         } else if (severity == Level.DEBUG.ordinal()) {
 233             return Constants.DEBUG;
 234         } else {
 235             return Constants.UNKNOWN;
 236         }
 237     }
 238
 239     public static Image getSeverityIcon(int severity) {
 240         ImageRegistry r = Activator.getDefault().getImageRegistry();
 241         if (severity == Level.INFO.ordinal()) {
 242             return r.get(Constants.INFO_LOG);
 243         } else if (severity == Level.WARNING.ordinal()) {
 244             return r.get(Constants.WARNING_LOG);
 245         } else if (severity == Level.ERROR.ordinal()) {
 246             return r.get(Constants.ERROR_LOG);
 247         } else if (severity == Level.DEBUG.ordinal()) {
 248             return r.get(Constants.DEBUG_LOG);
 249         } else {
 250             return r.get(Constants.UNKNOWN_LOG);
 251         }
 252     }
 253 }