plugins/org.eclipse.jst.j2ee.web/webproject/org/eclipse/jst/j2ee/internal/web/classpath/WebAppLibrariesStore.java

package org.eclipse.jst.j2ee.internal.web.classpath;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jst.j2ee.internal.web.plugin.WebPlugin;

public class WebAppLibrariesStore {

	private static final String WEB_LIBRARIES_CACHE = "webLibrariesCache.index"; //$NON-NLS-1$
	private static Map<String, RestoreState> restoreStateMap;
	private static Map<String, RestoreState> saveStateMap = new HashMap<String, RestoreState>();

	static class RestoreState implements Serializable {
		private static final long serialVersionUID = 5565856269776724522L;
		transient boolean needToVerify;
		List<String> pathStrings;
		transient List<IPath> paths;

		private void writeObject(java.io.ObjectOutputStream out) throws IOException {
			pathStrings = new ArrayList<String>(paths.size());
			for (IPath p : paths) {
				pathStrings.add(p.toString());
			}
			out.defaultWriteObject();
		}

		private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
			in.defaultReadObject();
			needToVerify = true;
			paths = new ArrayList<IPath>(pathStrings.size());
			for (String s : pathStrings) {
				paths.add(new Path(s));
			}
		}

		@Override
		public boolean equals(Object o) {
			if (this == o) {
				return true;
			} else if (o == null) {
				return false;
			} else if (o instanceof RestoreState) {
				RestoreState other = (RestoreState) o;
				if (paths == null) {
					return other.paths == null;
				}
				return paths.equals(other.paths);
			}
			return false;
		}

		@Override
		public int hashCode() {
			if (paths == null) {
				return 11;
			}
			return paths.hashCode();
		}
	}

	static {
		IPath stateLocation = WebPlugin.getDefault().getStateLocation();
		java.io.File file = stateLocation.append(WEB_LIBRARIES_CACHE).toFile();
		try{
			if (file.exists()) {
				FileInputStream fIn = null;
				boolean deleteCache = true;
				try {
					fIn = new FileInputStream(file);
					BufferedInputStream bIn = new BufferedInputStream(fIn);
					ObjectInputStream oIn = new ObjectInputStream(bIn);
					restoreStateMap = (HashMap<String, RestoreState>) oIn.readObject();
					oIn.close();
					
					//it is unfortunate this is necessary, but without iterating over the map
					//and explicitly testing each value, class cast exceptions may occur later
					//best to check them all now and recover
					Iterator<Entry<String, RestoreState>> iterator = restoreStateMap.entrySet().iterator();
					while(iterator.hasNext()){
						Entry<String, RestoreState> next = iterator.next();
						String s = next.getKey();
						RestoreState rs = next.getValue();
						if(s == null || rs == null){
							//may throw ClassCastException
						}
					}
					deleteCache = false;
				} catch (FileNotFoundException e) {
					WebPlugin.logError(e);
				} catch (IOException e) {
					WebPlugin.logError(e);
				} catch (ClassNotFoundException e) {
					WebPlugin.logError(e);
				} catch (ClassCastException e) {
					WebPlugin.logError(e);
				} finally {
					if (fIn != null) {
						try {
							fIn.close();
						} catch (IOException e) {
							WebPlugin.logError(e);
						}
					}
					if (deleteCache) {
						restoreStateMap = new HashMap<String, RestoreState>();
						file.delete();
					}
				}
			}
		} catch (Throwable e){
			try{
				WebPlugin.logError(e);
				file.delete();
			} catch (Exception e2){
				//eat it
			}
			restoreStateMap = new HashMap<String, RestoreState>();
		} finally {
			if(restoreStateMap == null) {
				restoreStateMap = new HashMap<String, RestoreState>();
			}
		}
		
	}

	public static RestoreState getRestoreState(String projectName) {
		RestoreState restoreState = null;
		synchronized (restoreStateMap) {
			restoreState = restoreStateMap.get(projectName);
		}
		if (restoreState != null) {
			synchronized (saveStateMap) {
				saveStateMap.put(projectName, restoreState);
			}
		}
		return restoreState;
	}

	static void flush(String projectName) {
		synchronized (restoreStateMap) {
			restoreStateMap.remove(projectName);
		}
		synchronized (saveStateMap) {
			saveStateMap.remove(projectName);
		}
	}
	
	private static class PersistJob extends Job {

		public PersistJob() {
			super("Persist Web App Libraries State"); //$NON-NLS-1$
			setSystem(true);
			setRule(null);
		}

		@Override
		protected IStatus run(IProgressMonitor monitor) {
			SafeRunner.run(new ISafeRunnable() {
				public void run() throws Exception {
					persist();
				}

				public void handleException(Throwable exception) {
					WebPlugin.logError(exception);
				}
			});
			return Status.OK_STATUS;
		}
	}

	private static int persistDelay = 60000; // 1 minute
	private static PersistJob persistJob = new PersistJob();

	static void saveState(String projectName, List<IPath> paths) {
		RestoreState toSave = new RestoreState();
		toSave.paths = paths;

		boolean scheduleJob = false;

		synchronized (saveStateMap) {
			RestoreState previous = saveStateMap.get(projectName);
			if (null == previous || !previous.equals(toSave)) {
				saveStateMap.put(projectName, toSave);
				scheduleJob = true;
			}
		}
		if (scheduleJob) {
			synchronized (restoreStateMap) {
				// if it changed, do not load it from the cache again
				restoreStateMap.remove(projectName);
			}
			persistJob.schedule(persistDelay);
		}
	}

	private static void persist() {
		synchronized (saveStateMap) {
			IPath stateLocation = WebPlugin.getDefault().getStateLocation();
			java.io.File file = stateLocation.append(WEB_LIBRARIES_CACHE).toFile();
			FileOutputStream fOut = null;
			try {
				fOut = new FileOutputStream(file);
				BufferedOutputStream bOut = new BufferedOutputStream(fOut);
				ObjectOutputStream oOut = new ObjectOutputStream(bOut);
				oOut.writeObject(saveStateMap);
				oOut.close();
			} catch (FileNotFoundException e) {
				WebPlugin.logError(e);
			} catch (IOException e) {
				WebPlugin.logError(e);
			} finally {
				if (fOut != null) {
					try {
						fOut.close();
					} catch (IOException e) {
						WebPlugin.logError(e);
					}
				}
			}
		}
	}

}