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