service/simulator/java/eclipse-plugin/ClientControllerPlugin/src/oic/simulator/clientcontroller/manager/LogManager.java

   1 /*
   2  * Copyright 2015 Samsung Electronics All Rights Reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package oic.simulator.clientcontroller.manager;
  18
  19 import org.eclipse.jface.resource.ImageRegistry;
  20 import org.eclipse.swt.graphics.Image;
  21
  22 import java.util.ArrayList;
  23 import java.util.Date;
  24 import java.util.HashMap;
  25 import java.util.LinkedList;
  26
  27 import org.oic.simulator.ILogger;
  28 import org.oic.simulator.ILogger.Level;
  29 import org.oic.simulator.SimulatorManager;
  30
  31 import oic.simulator.clientcontroller.Activator;
  32 import oic.simulator.clientcontroller.listener.ILogUIListener;
  33 import oic.simulator.clientcontroller.utils.Constants;
  34 import oic.simulator.logger.LogEntry;
  35 import oic.simulator.logger.LoggerCallback;
  36
  37 /**
  38  * Class which handles the native logs, maintains log entries and updates the
  39  * UI.
  40  */
  41 public class LogManager {
  42     private LinkedList<LogEntry>         entries           = new LinkedList<LogEntry>();
  43     private ArrayList<ILogUIListener>    listeners         = new ArrayList<ILogUIListener>();
  44     private LinkedList<LogEntry>         visibleEntries    = new LinkedList<LogEntry>();
  45     private HashMap<Integer, Boolean>    visibleSeverities = new HashMap<Integer, Boolean>();
  46
  47     private ILogger                      logger;
  48     private LogManagerSynchronizerThread synchronizerThread;
  49     private Thread                       threadHandle;
  50
  51     public LogManager() {
  52         synchronizerThread = new LogManagerSynchronizerThread();
  53         threadHandle = new Thread(synchronizerThread);
  54         threadHandle.setName("OIC Simulator event queue");
  55         threadHandle.start();
  56
  57         // Set the logger callback with the native layer
  58         logger = new LoggerCallback();
  59         SimulatorManager.setLogger(logger);
  60     }
  61
  62     private static class LogManagerSynchronizerThread implements Runnable {
  63
  64         LinkedList<Runnable> eventQueue = new LinkedList<Runnable>();
  65
  66         @Override
  67         public void run() {
  68             while (!Thread.interrupted()) {
  69
  70                 synchronized (this) {
  71                     try {
  72                         while (eventQueue.isEmpty()) {
  73                             this.wait();
  74                             break;
  75                         }
  76                     } catch (InterruptedException e) {
  77                         return;
  78                     }
  79                 }
  80
  81                 Runnable pop;
  82                 synchronized (this) {
  83                     pop = eventQueue.pop();
  84                 }
  85                 try {
  86                     pop.run();
  87                 } catch (Exception e) {
  88                     if (e instanceof InterruptedException) {
  89                         return;
  90                     }
  91                     e.printStackTrace();
  92                 }
  93             }
  94         }
  95
  96         public void addToQueue(Runnable event) {
  97             synchronized (this) {
  98                 eventQueue.add(event);
  99                 this.notify();
 100             }
 101         }
 102     }
 103
 104     public void log(int severity, Date date, String msg) {
 105         final LogEntry logEntry = new LogEntry(severity, date, msg);
 106         synchronizerThread.addToQueue(new Runnable() {
 107             @Override
 108             public void run() {
 109                 boolean notify = false;
 110                 synchronized (entries) {
 111                     entries.add(logEntry);
 112                     Boolean showEntry = LogManager.this.visibleSeverities
 113                             .get(logEntry.getSeverity());
 114                     if (showEntry != null) {
 115                         if (showEntry) {
 116                             visibleEntries.add(logEntry);
 117                             notify = true;
 118                         }
 119                     }
 120                     if (entries.size() > Constants.LOG_SIZE) {
 121                         entries.pop();
 122                     }
 123                     if (visibleEntries.size() > Constants.LOG_SIZE) {
 124                         visibleEntries.pop();
 125                         notify = true;
 126                     }
 127                 }
 128                 if (notify) {
 129                     notifyListeners(logEntry);
 130                 }
 131             }
 132         });
 133     }
 134
 135     public void applyFilter(final HashMap<Integer, Boolean> visibleSeverities) {
 136         synchronizerThread.addToQueue(new Runnable() {
 137
 138             @Override
 139             public void run() {
 140                 LinkedList<LogEntry> newLogs = new LinkedList<LogEntry>();
 141                 synchronized (entries) {
 142                     LogManager.this.visibleSeverities = visibleSeverities;
 143                     for (LogEntry logEntry : entries) {
 144                         if (LogManager.this.visibleSeverities.get(logEntry
 145                                 .getSeverity())) {
 146                             newLogs.add(logEntry);
 147                         }
 148                     }
 149                 }
 150                 visibleEntries = newLogs;
 151                 notifyListeners();
 152             }
 153         });
 154
 155     }
 156
 157     private void notifyListeners() {
 158         for (ILogUIListener l : listeners) {
 159             l.logChanged(new ArrayList<LogEntry>(visibleEntries));
 160         }
 161     }
 162
 163     private void notifyListeners(LogEntry added) {
 164         for (ILogUIListener l : listeners) {
 165             l.logAdded(added);
 166         }
 167     }
 168
 169     public void clearLog() {
 170         synchronizerThread.addToQueue(new Runnable() {
 171
 172             @Override
 173             public void run() {
 174                 synchronized (entries) {
 175                     entries = new LinkedList<LogEntry>();
 176                     visibleEntries = new LinkedList<LogEntry>();
 177                 }
 178                 notifyListeners();
 179             }
 180         });
 181     }
 182
 183     public void removeEntry(final LogEntry element) {
 184         synchronizerThread.addToQueue(new Runnable() {
 185
 186             @Override
 187             public void run() {
 188                 synchronized (entries) {
 189                     entries.remove(element);
 190                     visibleEntries.remove(element);
 191                 }
 192                 notifyListeners();
 193             }
 194         });
 195     }
 196
 197     public ArrayList<LogEntry> getLogEntries() {
 198         synchronized (entries) {
 199             return new ArrayList<LogEntry>(entries);
 200         }
 201     }
 202
 203     public void addLogListener(final ILogUIListener listener) {
 204         synchronizerThread.addToQueue(new Runnable() {
 205             @Override
 206             public void run() {
 207                 if (!listeners.contains(listener)) {
 208                     listeners.add(listener);
 209                 }
 210             }
 211         });
 212     }
 213
 214     public void removeLogListener(final ILogUIListener listener) {
 215         synchronizerThread.addToQueue(new Runnable() {
 216             @Override
 217             public void run() {
 218                 if (!listeners.contains(listener)) {
 219                     listeners.remove(listener);
 220                 }
 221             }
 222         });
 223     }
 224
 225     public void shutdown() {
 226         threadHandle.interrupt();
 227     }
 228
 229     public static String getSeverityName(int severity) {
 230         if (severity == Level.INFO.ordinal()) {
 231             return Constants.INFO;
 232         } else if (severity == Level.WARNING.ordinal()) {
 233             return Constants.WARNING;
 234         } else if (severity == Level.ERROR.ordinal()) {
 235             return Constants.ERROR;
 236         } else if (severity == Level.DEBUG.ordinal()) {
 237             return Constants.DEBUG;
 238         } else {
 239             return Constants.UNKNOWN;
 240         }
 241     }
 242
 243     public static Image getSeverityIcon(int severity) {
 244         ImageRegistry r = Activator.getDefault().getImageRegistry();
 245         if (severity == Level.INFO.ordinal()) {
 246             return r.get(Constants.INFO_LOG);
 247         } else if (severity == Level.WARNING.ordinal()) {
 248             return r.get(Constants.WARNING_LOG);
 249         } else if (severity == Level.ERROR.ordinal()) {
 250             return r.get(Constants.ERROR_LOG);
 251         } else if (severity == Level.DEBUG.ordinal()) {
 252             return r.get(Constants.DEBUG_LOG);
 253         } else {
 254             return r.get(Constants.UNKNOWN_LOG);
 255         }
 256     }
 257 }