//------------------------------------------------------------------------------
// Copyright (c) 2005, 2008 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 implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.library.util;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.epf.common.utils.RestartableJob;
import org.eclipse.epf.library.ILibraryManager;
import org.eclipse.epf.library.ILibraryService;
import org.eclipse.epf.library.LibraryPlugin;
import org.eclipse.epf.library.LibraryResources;
import org.eclipse.epf.library.LibraryService;
import org.eclipse.epf.library.LibraryServiceListener;
import org.eclipse.epf.library.LibraryServiceUtil;
import org.eclipse.epf.library.events.ILibraryChangeListener;
import org.eclipse.epf.services.ILibraryPersister;
import org.eclipse.epf.uma.MethodLibrary;
import org.eclipse.epf.uma.MethodPlugin;
/**
* The class for monitor library problems.
*
* (1) Wake up regularly (say every 30 seconds)
* to schedule job if any change is registered during sleep
*
* (2) Goes to sleep again immediately after "waking up/do nothing" or
* "waking up/scheduling a job"
*
* (3) Job (finding library problems) runs to end only there is no change during run.
*
* (4) Job run is aborted (by throwing a RestartInterruptException)
* whenever a change is detected during run, and a new job scheduled
* with a delay time (say 1 second).
*
* (5) Make sure there is always at most one job running
*
* @author Weiping Lu
* @since 1.5
*/
public class LibraryProblemMonitor extends RestartableJob implements ILibraryChangeListener {
public static final String UnresolvedBasedPluginMARKER_ID = LibraryPlugin.getDefault().getId() + ".unresolvedBasePlugins"; //$NON-NLS-1$
public static final String Name = "name"; //$NON-NLS-1$
public static final String Guid = "guid"; //$NON-NLS-1$
public static final String UnresolvedBaseGuids = "unresolvedBaseGuids"; //$NON-NLS-1$
private long delay = 30000L;
private long restartDelay = 1000L;
private boolean hasChange = false;
private Thread monitorThread;
private boolean stopMonitor = false;
private MethodLibrary library;
private Map<MethodPlugin, IMarker> pluginMarkerMap = new HashMap<MethodPlugin, IMarker>();
public LibraryProblemMonitor() {
super(LibraryResources.libraryProblemMonitor);
LibraryServiceListener libServiceListener = new LibraryServiceListener() {
public void librarySet(MethodLibrary lib) {
ILibraryService libService = LibraryService.getInstance();
if (library != null && library != lib) {
ILibraryManager libMgr = libService.getLibraryManager(library);
if (libMgr != null) {
libMgr.removeListener(LibraryProblemMonitor.this);
}
}
if (lib != null && lib != library) {
ILibraryManager libMgr = libService.getLibraryManager(lib);
if (libMgr != null) {
libMgr.addListener(LibraryProblemMonitor.this);
}
kickToRun();
}
library = lib;
}
};
LibraryService.getInstance().addListener(libServiceListener);
startMonitor();
}
public void startMonitor() {
Runnable runnable = new Runnable() {
public void run() {
while (! stopMonitor) {
try {
Thread.sleep(delay);
} catch (Exception e) {
LibraryPlugin.getDefault().getLogger().logError(e);
return;
}
if (hasChange) {
hasChange = false;
guardedSchedule(0L);
}
}
}
};
stopMonitor = false;
if (monitorThread == null) {
monitorThread = new Thread(runnable);
}
monitorThread.start();
}
public void stopMonitor() {
stopMonitor = true;
}
public void libraryChanged(int option, Collection<Object> changedItems) {
if (changedItems != null && changedItems.size() > 0) {
hasChange = true;
enableToRestart();
}
}
// Update will abort and re-schedule a job if new change detected
private void update() throws RestartInterruptException {
if (localDebug) {
System.out.println("LD> update"); //$NON-NLS-1$
}
MethodLibrary lib = getLibrary();
if (lib == null) {
return;
}
checkRestartInterruptException(restartDelay);
cleanUp();
List<MethodPlugin> plugins = new ArrayList<MethodPlugin>();
plugins.addAll(lib.getMethodPlugins());
Set<MethodPlugin> pluginSet = new HashSet<MethodPlugin>(plugins);
for (MethodPlugin plugin: plugins) {
checkRestartInterruptException(restartDelay);
List<MethodPlugin> baseList = plugin.getBases();
boolean missing = false;
for (MethodPlugin base: baseList) {
checkRestartInterruptException(restartDelay);
if (! pluginSet.contains(base)) {
if (! missing) {
if (localDebug) {
System.out.println("LD> plugin: " + plugin); //$NON-NLS-1$
System.out.println("LD> " + plugin.getName() + " references unresolved bases:"); //$NON-NLS-1$ //$NON-NLS-2$
}
missing = true;
}
if (localDebug) {
System.out.println("LD> base: " + base); //$NON-NLS-1$
}
addMissingBasePluginError(plugin, base);
}
}
if (missing) {
System.out.println(""); //$NON-NLS-1$
}
}
}
private void addMissingBasePluginError(MethodPlugin plugin, MethodPlugin base) {
IMarker marker = pluginMarkerMap.get(plugin);
if (marker == null) {
Resource res = plugin.eResource();
if (res == null) {
return;
}
URI containerURI = res.getURI();
IWorkspace workspace = ResourcesPlugin.getWorkspace();
IPath path = new Path(containerURI.toFileString());
IFile file = workspace.getRoot().getFileForLocation(path);
if (file == null) {
return;
}
String location = containerURI != null ? containerURI
.toFileString() : ""; //$NON-NLS-1$
try {
marker = file.createMarker(UnresolvedBasedPluginMARKER_ID);
marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);
marker.setAttribute(Name, plugin.getName());
marker.setAttribute(Guid, plugin.getGuid());
marker.setAttribute(IMarker.LOCATION, location);
marker.setAttribute(Guid, plugin.getGuid());
} catch (CoreException e) {
IStatus status = e.getStatus();
if(status instanceof IResourceStatus && ((IResourceStatus) status).getCode() == IResourceStatus.RESOURCE_NOT_FOUND) {
// do nothing
} else {
LibraryPlugin.getDefault().getLogger().logError(e);
}
} catch(Exception e) {
LibraryPlugin.getDefault().getLogger().logError(e);
}
if (marker == null) {
return;
}
if (localDebug) {
System.out.println("LD> marker: " + marker); //$NON-NLS-1$
}
pluginMarkerMap.put(plugin, marker);
}
String unresolvedBaseGuidsValue = null;
try {
String errMsg = plugin.getName() + " " + LibraryResources.references_unresolved_base_txt; //$NON-NLS-1$
unresolvedBaseGuidsValue = (String) marker.getAttribute(UnresolvedBaseGuids);
if (unresolvedBaseGuidsValue == null || unresolvedBaseGuidsValue.length() == 0) {
unresolvedBaseGuidsValue = base.getGuid();
errMsg += ": "; //$NON-NLS-1$
} else if (unresolvedBaseGuidsValue.indexOf(base.getGuid()) < 0) {
unresolvedBaseGuidsValue += ", " + base.getGuid(); //$NON-NLS-1$
errMsg += "plugins: "; //$NON-NLS-1$
}
errMsg += unresolvedBaseGuidsValue;
marker.setAttribute(IMarker.MESSAGE, errMsg);
marker.setAttribute(UnresolvedBaseGuids, unresolvedBaseGuidsValue);
} catch (Exception e) {
LibraryPlugin.getDefault().getLogger().logError(e);
}
}
protected IStatus restartableRun(IProgressMonitor monitor) throws RestartInterruptException {
update();
return Status.OK_STATUS;
}
protected void resetToRestart() {
if (localDebug) {
System.out.println("LD> resetToRestart"); //$NON-NLS-1$
}
cleanUp();
}
private void cleanUp() {
if (pluginMarkerMap.isEmpty()) {
return;
}
for (IMarker marker: pluginMarkerMap.values()) {
try {
marker.delete();
} catch (Exception e) {
LibraryPlugin.getDefault().getLogger().logError(e);
}
}
pluginMarkerMap = new HashMap<MethodPlugin, IMarker>();
}
public void kickToRun() {
if (localDebug) {
System.out.println("LD> kickToRun"); //$NON-NLS-1$
}
enableToRestart();
guardedSchedule(0L);
}
//To do: allow a cached data to pased and return -> optimize fix of similar problems
public void fixProblem(IMarker marker) {
try {
if (marker.getType() != UnresolvedBasedPluginMARKER_ID) {
return;
}
MethodLibrary lib = getLibrary();
if (lib == null) {
return;
}
Map<String, MethodPlugin> guidToPluginMap = new HashMap<String, MethodPlugin>();
for (MethodPlugin plugin : lib.getMethodPlugins()) {
guidToPluginMap.put(plugin.getGuid(), plugin);
}
String guid = (String) marker.getAttribute(Guid); //$NON-NLS-1$
MethodPlugin plugin = guidToPluginMap.get(guid);
if (plugin == null || plugin.eResource() == null) {
return;
}
if (localDebug) {
System.out.println("LD> fixProblem, plugin: " + plugin); //$NON-NLS-1$
}
List<MethodPlugin> bases = new ArrayList<MethodPlugin>();
bases.addAll(plugin.getBases());
boolean modified = false;
for (MethodPlugin base : bases) {
if (! guidToPluginMap.containsKey(base.getGuid())) {
modified = true;
plugin.getBases().remove(base);
}
}
if (! modified) {
return;
}
Resource resource = plugin.eResource();
ILibraryPersister.FailSafeMethodLibraryPersister persister = LibraryServiceUtil
.getPersisterFor(resource).getFailSafePersister();
try {
persister.save(resource);
persister.commit();
}
catch(Exception e) {
LibraryPlugin.getDefault().getLogger().logError(e);
persister.rollback();
}
kickToRun();
} catch (Exception e) {
LibraryPlugin.getDefault().getLogger().logError(e);
}
}
public void dispose() {
stopMonitor();
cleanUp();
}
public MethodLibrary getLibrary() {
return library;
}
public void setLibrary(MethodLibrary library) {
this.library = library;
}
}