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