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.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;
  19
  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>();
  25
  26     private ILogger                      logger;
  27     private LogManagerSynchronizerThread synchronizerThread;
  28     private Thread                       threadHandle;
  29
  30     public LogManager() {
  31         synchronizerThread = new LogManagerSynchronizerThread();
  32         threadHandle = new Thread(synchronizerThread);
  33         threadHandle.setName("OIC Simulator event queue");
  34         threadHandle.start();
  35
  36         // Set the logger callback with the native layer
  37         logger = new LoggerCallback();
  38         SimulatorManager.setLogger(logger);
  39     }
  40
  41     private static class LogManagerSynchronizerThread implements Runnable {
  42
  43         LinkedList<Runnable> eventQueue = new LinkedList<Runnable>();
  44
  45         @Override
  46         public void run() {
  47             while (!Thread.interrupted()) {
  48
  49                 synchronized (this) {
  50                     try {
  51                         while (eventQueue.isEmpty()) {
  52                             this.wait();
  53                             break;
  54                         }
  55                     } catch (InterruptedException e) {
  56                         return;
  57                     }
  58                 }
  59
  60                 Runnable pop;
  61                 synchronized (this) {
  62                     pop = eventQueue.pop();
  63                 }
  64                 try {
  65                     pop.run();
  66                 } catch (Exception e) {
  67                     if (e instanceof InterruptedException) {
  68                         return;
  69                     }
  70                     e.printStackTrace();
  71                 }
  72             }
  73         }
  74
  75         public void addToQueue(Runnable event) {
  76             synchronized (this) {
  77                 eventQueue.add(event);
  78                 this.notify();
  79             }
  80         }
  81     }
  82
  83     public void log(int severity, Date date, String msg) {
  84         final LogEntry logEntry = new LogEntry(severity, date, msg);
  85         synchronizerThread.addToQueue(new Runnable() {
  86             @Override
  87             public void run() {
  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) {
  94                         if (showEntry) {
  95                             visibleEntries.add(logEntry);
  96                             notify = true;
  97                         }
  98                     }
  99                     if (entries.size() > Constants.LOG_SIZE) {
 100                         entries.pop();
 101                     }
 102                     if (visibleEntries.size() > Constants.LOG_SIZE) {
 103                         visibleEntries.pop();
 104                         notify = true;
 105                     }
 106                 }
 107                 if (notify) {
 108                     notifyListeners(logEntry);
 109                 }
 110             }
 111         });
 112     }
 113
 114     public void applyFilter(final HashMap<Integer, Boolean> visibleSeverities) {
 115         synchronizerThread.addToQueue(new Runnable() {
 116
 117             @Override
 118             public void run() {
 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
 124                                 .getSeverity())) {
 125                             newLogs.add(logEntry);
 126                         }
 127                     }
 128                 }
 129                 visibleEntries = newLogs;
 130                 notifyListeners();
 131             }
 132         });
 133
 134     }
 135
 136     private void notifyListeners() {
 137         for (ILogUIListener l : listeners) {
 138             l.logChanged(new ArrayList<LogEntry>(visibleEntries));
 139         }
 140     }
 141
 142     private void notifyListeners(LogEntry added) {
 143         for (ILogUIListener l : listeners) {
 144             l.logAdded(added);
 145         }
 146     }
 147
 148     public void clearLog() {
 149         synchronizerThread.addToQueue(new Runnable() {
 150
 151             @Override
 152             public void run() {
 153                 synchronized (entries) {
 154                     entries = new LinkedList<LogEntry>();
 155                     visibleEntries = new LinkedList<LogEntry>();
 156                 }
 157                 notifyListeners();
 158             }
 159         });
 160     }
 161
 162     public void removeEntry(final LogEntry element) {
 163         synchronizerThread.addToQueue(new Runnable() {
 164
 165             @Override
 166             public void run() {
 167                 synchronized (entries) {
 168                     entries.remove(element);
 169                     visibleEntries.remove(element);
 170                 }
 171                 notifyListeners();
 172             }
 173         });
 174     }
 175
 176     public ArrayList<LogEntry> getLogEntries() {
 177         synchronized (entries) {
 178             return new ArrayList<LogEntry>(entries);
 179         }
 180     }
 181
 182     public void addLogListener(final ILogUIListener listener) {
 183         synchronizerThread.addToQueue(new Runnable() {
 184             @Override
 185             public void run() {
 186                 if (!listeners.contains(listener)) {
 187                     listeners.add(listener);
 188                 }
 189             }
 190         });
 191     }
 192
 193     public void removeLogListener(final ILogUIListener listener) {
 194         synchronizerThread.addToQueue(new Runnable() {
 195             @Override
 196             public void run() {
 197                 if (!listeners.contains(listener)) {
 198                     listeners.remove(listener);
 199                 }
 200             }
 201         });
 202     }
 203
 204     public void shutdown() {
 205         threadHandle.interrupt();
 206     }
 207
 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;
 217         } else {
 218             return Constants.UNKNOWN;
 219         }
 220     }
 221
 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);
 232         } else {
 233             return r.get(Constants.UNKNOWN_LOG);
 234         }
 235     }
 236 }