| /******************************************************************************* |
| * Copyright (c) 2011 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.stem.loggers.manager; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.concurrent.CopyOnWriteArrayList; |
| |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.stem.core.logger.Logger; |
| import org.eclipse.stem.jobs.simulation.ISimulation; |
| import org.eclipse.stem.jobs.simulation.ISimulationManagerListenerSync; |
| import org.eclipse.stem.jobs.simulation.SimulationManager; |
| import org.eclipse.stem.jobs.simulation.SimulationManagerEvent; |
| import org.eclipse.stem.loggers.AsynchronousLogger; |
| import org.eclipse.stem.loggers.LOGGER_EVENTS; |
| import org.eclipse.stem.loggers.SimulationLogger; |
| |
| /** |
| * Service to manage the logging of STEM Simulations. This singleton class |
| * handles the addition and removal of loggers for the STEM runtime. The logger manager |
| * monitors the STEM simulation manager to start/stop loggers as appropriate. |
| * |
| */ |
| public class SimulationLoggerManager implements ISimulationManagerListenerSync |
| { |
| private static SimulationLoggerManager INSTANCE; |
| |
| private final Map<ISimulation, List<LoggerAdapter>> loggers = |
| new HashMap<ISimulation, List<LoggerAdapter>>(); |
| |
| private final List<ISimulationLoggerManagerListener> listeners = new CopyOnWriteArrayList<ISimulationLoggerManagerListener>(); |
| |
| private final List<SimulationLogger> autoAddedLoggers = new CopyOnWriteArrayList<SimulationLogger>(); |
| |
| private final SimulationManager simulationManager; |
| |
| public synchronized static SimulationLoggerManager getManager() |
| { |
| if (null == INSTANCE) { |
| INSTANCE = new SimulationLoggerManager(); |
| } |
| |
| return INSTANCE; |
| } |
| |
| public Collection<ISimulation> getActiveSimulations() |
| { |
| return Collections.unmodifiableCollection(loggers.keySet()); |
| } |
| |
| public void addAutoAddedLogger(SimulationLogger logger) |
| { |
| autoAddedLoggers.add(logger); |
| } |
| |
| public void removeAutoAddedLogger(SimulationLogger logger) |
| { |
| autoAddedLoggers.remove(logger); |
| } |
| |
| private SimulationLoggerManager() |
| { |
| simulationManager = SimulationManager.getManager(); |
| startup(); |
| } |
| |
| |
| void startup() |
| { |
| simulationManager.addSimulationManagerListenerSync(this); |
| fireListenerEvent(LOGGER_EVENTS.LOGGER_MANAGER_STARTED, null); |
| } |
| |
| public Collection<SimulationLogger> getLoggersForSimulation(ISimulation simulation) |
| { |
| if (simulation == null) { |
| return null; |
| } |
| List<LoggerAdapter> adapters = loggers.get(simulation); |
| |
| List<SimulationLogger> loggers2 = new ArrayList<SimulationLogger>(); |
| if (adapters != null) { |
| for (LoggerAdapter adapter : adapters) { |
| loggers2.add(adapter.getLogger()); |
| } |
| } |
| |
| return Collections.unmodifiableCollection(loggers2); |
| } |
| |
| |
| public void addListener(ISimulationLoggerManagerListener listener) |
| { |
| listeners.add(listener); |
| } |
| |
| public void removeListener(ISimulationLoggerManagerListener listener) |
| { |
| listeners.remove(listener); |
| } |
| |
| protected void fireListenerEvent(LOGGER_EVENTS event, Object[] targets) |
| { |
| for (ISimulationLoggerManagerListener listener : listeners) { |
| listener.simulationLoggerEvent(event, targets); |
| } |
| } |
| |
| |
| public void shutdown() |
| { |
| List<ISimulation> tempList = new LinkedList<ISimulation>(); |
| tempList.addAll(loggers.keySet()); |
| |
| for (ISimulation simulation : tempList) { |
| handleRemovedSimulation(simulation); |
| } |
| |
| tempList.clear(); |
| |
| fireListenerEvent(LOGGER_EVENTS.LOGGER_MANAGER_STOPPED, null); |
| listeners.clear(); |
| } |
| |
| |
| public void simulationsChangedSync(SimulationManagerEvent event) |
| { |
| for (ISimulation removedSimulation : event.getSimulationsRemoved()) { |
| handleRemovedSimulation(removedSimulation); |
| } |
| |
| if (event.getSimulationsRemoved().length > 0) { |
| fireListenerEvent(LOGGER_EVENTS.SIMULATIONS_REMOVED, event.getSimulationsRemoved()); |
| } |
| |
| for (ISimulation addedSimulation : event.getSimulationsAdded()) { |
| handleAddedSimulation(addedSimulation); |
| } |
| |
| if (event.getSimulationsAdded().length > 0) { |
| fireListenerEvent(LOGGER_EVENTS.SIMULATIONS_ADDED, event.getSimulationsAdded()); |
| } |
| |
| } |
| |
| private LoggerAdapter handleAddedLogger(ISimulation simulation, SimulationLogger logger) |
| { |
| LoggerAdapter wrapper = new LoggerAdapter(simulation, (SimulationLogger)EcoreUtil.copy(logger)); |
| wrapper.fireLoggerEvent(LOGGER_EVENTS.LOGGER_STARTED); |
| |
| if (logger instanceof AsynchronousLogger) { |
| simulation.addSimulationListener(wrapper, true); |
| } else { |
| simulation.addSimulationListenerSync(wrapper, true); |
| } |
| |
| return wrapper; |
| } |
| |
| |
| public void addLoggerToSimulation(ISimulation simulation, SimulationLogger logger) |
| { |
| if (simulation != null && logger != null) { |
| List<LoggerAdapter> simulationLoggers = loggers.get(simulation); |
| |
| if (simulationLoggers == null) { |
| return; |
| } |
| |
| LoggerAdapter adapter = handleAddedLogger(simulation, logger); |
| simulationLoggers.add(adapter); |
| |
| fireListenerEvent(LOGGER_EVENTS.SIMULATIONS_ADDED, new Object[] {adapter}); |
| |
| } |
| } |
| |
| private void handleAddedSimulation(ISimulation simulation) |
| { |
| List<LoggerAdapter> simulationLoggers = new ArrayList<LoggerAdapter>(); |
| loggers.put(simulation, simulationLoggers); |
| |
| // First add loggers defined in the underlying scenario |
| for (Logger logger : simulation.getScenario().getLoggers()) { |
| if (logger instanceof SimulationLogger) { |
| simulationLoggers.add(handleAddedLogger(simulation, (SimulationLogger)logger)); |
| } |
| } |
| |
| // Next add loggers defined to be auto-added by the manager |
| for (SimulationLogger logger : autoAddedLoggers) { |
| simulationLoggers.add(handleAddedLogger(simulation, logger)); |
| } |
| } |
| |
| private void handleRemovedSimulation(ISimulation simulation) |
| { |
| List<LoggerAdapter> simulationLoggers = loggers.get(simulation); |
| if (simulationLoggers != null) { |
| |
| synchronized (simulationLoggers) { |
| for (Iterator<LoggerAdapter> iter = simulationLoggers.iterator(); iter.hasNext(); ) { |
| LoggerAdapter wrapper = iter.next(); |
| simulation.removeSimulationListener(wrapper); |
| simulation.removeSimulationListenerSync(wrapper); |
| wrapper.fireLoggerEvent(LOGGER_EVENTS.LOGGER_STOPPED); |
| wrapper.destroy(); |
| iter.remove(); |
| } |
| } |
| |
| loggers.remove(simulation); |
| } |
| } |
| |
| } |