plugins/org.eclipse.jst.j2ee/j2eecreation/org/eclipse/jst/j2ee/internal/componentcore/JavaEEBinaryComponentHelper.java - gerrit/jeetools/webtools.javaee - Git at Google

 package org.eclipse.jst.j2ee.internal.componentcore;

 import java.io.File;
 import java.io.IOException;
 import java.util.HashSet;
 import java.util.Hashtable;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 import java.util.zip.ZipException;

 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.jst.j2ee.commonarchivecore.internal.Archive;
 import org.eclipse.jst.j2ee.componentcore.J2EEModuleVirtualArchiveComponent;
 import org.eclipse.jst.j2ee.internal.J2EEConstants;
 import org.eclipse.jst.j2ee.internal.archive.JavaEEArchiveUtilities;
 import org.eclipse.jst.j2ee.internal.componentcore.EnterpriseBinaryComponentHelper.IReferenceCountedArchive;
 import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
 import org.eclipse.jst.javaee.applicationclient.ApplicationClient;
 import org.eclipse.jst.javaee.applicationclient.ApplicationclientFactory;
 import org.eclipse.jst.javaee.core.DisplayName;
 import org.eclipse.jst.javaee.core.JavaeeFactory;
 import org.eclipse.jst.javaee.ejb.EJBJar;
 import org.eclipse.jst.javaee.ejb.EjbFactory;
 import org.eclipse.jst.javaee.jca.Connector;
 import org.eclipse.jst.javaee.jca.JcaFactory;
 import org.eclipse.jst.javaee.web.WebApp;
 import org.eclipse.jst.javaee.web.WebFactory;
 import org.eclipse.jst.jee.archive.ArchiveModelLoadException;
 import org.eclipse.jst.jee.archive.ArchiveOpenFailureException;
 import org.eclipse.jst.jee.archive.ArchiveOptions;
 import org.eclipse.jst.jee.archive.IArchive;
 import org.eclipse.jst.jee.archive.IArchiveFactory;
 import org.eclipse.jst.jee.archive.IArchiveLoadAdapter;
 import org.eclipse.jst.jee.archive.internal.ArchiveFactoryImpl;
 import org.eclipse.jst.jee.util.internal.JavaEEQuickPeek;
 import org.eclipse.wst.common.componentcore.ComponentCore;
 import org.eclipse.wst.common.componentcore.internal.BinaryComponentHelper;
 import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
 import org.eclipse.wst.common.componentcore.resources.IVirtualReference;

 public class JavaEEBinaryComponentHelper extends BinaryComponentHelper {

 	private IArchive archive;
 	private EnterpriseBinaryComponentHelper legacyBinaryHelper;
 	private boolean descriminateMainClass = true;
 	private int localArchiveAccessCount = 0;
 	private boolean refineForJavaEE = true;

 	public boolean shouldRefineForJavaEE() {
 		return refineForJavaEE;
 	}

 	public void setRefineForJavaEE(boolean refineForJavaEE) {
 		this.refineForJavaEE = refineForJavaEE;
 	}

 	public static JavaEEQuickPeek getJavaEEQuickPeek(IPath filesystemPath) {
 		IArchive archive = null;
 		try {
 			try {
 				archive = JavaEEArchiveUtilities.INSTANCE.openArchive(filesystemPath);
 			} catch( ArchiveOpenFailureException fail) {}
 			if (archive == null) {
 				return new JavaEEQuickPeek(null);
 			}
 			JavaEEQuickPeek qp = JavaEEArchiveUtilities.INSTANCE.getJavaEEQuickPeek(archive);
 			return qp;
 		} finally {
 			if (null != archive) {
 				new ArchiveFactoryImpl().closeArchive(archive);
 			}
 		}
 	}

 	public static JavaEEQuickPeek getJavaEEQuickPeek(IVirtualComponent aBinaryComponent) {
 		JavaEEBinaryComponentHelper helper = null;
 		try {
 			helper = new JavaEEBinaryComponentHelper(aBinaryComponent);
 			IArchive archive = helper.getArchive();
 			if (archive == null) {
 				return new JavaEEQuickPeek(null);
 			}
 			JavaEEQuickPeek qp = JavaEEArchiveUtilities.INSTANCE.getJavaEEQuickPeek(archive);
 			return qp;
 		} finally {
 			if (helper != null) {
 				helper.dispose();
 			}
 		}
 	}

 	public static void openArchiveAsUtility(IVirtualComponent aBinaryComponent) {
 		openArchive(aBinaryComponent, false, false);
 	}

 	public static void openArchive(IVirtualComponent aBinaryComponent, boolean refineForJavaEE, boolean descriminateMainClass) {
 		JavaEEBinaryComponentHelper helper = null;
 		try {
 			helper = new JavaEEBinaryComponentHelper(aBinaryComponent);
 			helper.setDescriminateMainClass(descriminateMainClass);
 			try {
 				helper.openArchive();
 			} catch (ArchiveOpenFailureException e) {
 				logError(e);
 			}
 		} finally {
 			if (helper != null) {
 				helper.dispose();
 			}
 		}
 	}

 	public static void openArchive(IVirtualComponent aBinaryComponent, boolean descriminateMainClass) {
 		openArchive(aBinaryComponent, true, descriminateMainClass);
 	}

 	public JavaEEBinaryComponentHelper(IVirtualComponent aBinaryComponent) {
 		super(aBinaryComponent);
 	}

 	public IPath getAbsolutePath() {
 		IArchiveLoadAdapter loadAdapter = null;
 		if(getArchive().getArchiveOptions().hasOption(JavaEEArchiveUtilities.WRAPPED_LOAD_ADAPTER)){
 			loadAdapter = (IArchiveLoadAdapter)getArchive().getArchiveOptions().getOption(JavaEEArchiveUtilities.WRAPPED_LOAD_ADAPTER);
 		} else {
 			loadAdapter = (IArchiveLoadAdapter)getArchive().getArchiveOptions().getOption(ArchiveOptions.LOAD_ADAPTER);
 		}
 		return ((JavaEEBinaryComponentLoadAdapter) loadAdapter).getArchivePath();
 	}

 	@Override
 	public EObject getPrimaryRootObject() {
 		JavaEEQuickPeek qp = JavaEEArchiveUtilities.INSTANCE.getJavaEEQuickPeek(getArchive());
 		IPath ddPath = null;
 		switch (qp.getType()) {
 		case JavaEEQuickPeek.APPLICATION_CLIENT_TYPE:
 			ddPath = new Path(J2EEConstants.APP_CLIENT_DD_URI);
 			break;
 		case JavaEEQuickPeek.EJB_TYPE:
 			ddPath = new Path(J2EEConstants.EJBJAR_DD_URI);
 			break;
 		case JavaEEQuickPeek.WEB_TYPE:
 			ddPath = new Path(J2EEConstants.WEBAPP_DD_URI);
 			break;
 		case JavaEEQuickPeek.CONNECTOR_TYPE:
 			ddPath = new Path(J2EEConstants.RAR_DD_URI);
 			break;
 		case JavaEEQuickPeek.WEBFRAGMENT_TYPE:
 			ddPath = new Path(J2EEConstants.WEBFRAGMENT_DD_URI);
 			break;
 		}
 		if (ddPath != null) {
 			if (getArchive().containsArchiveResource(ddPath)) {
 				try {
 					return (EObject) getArchive().getModelObject(ddPath);
 				} catch (ArchiveModelLoadException e) {
 					J2EEPlugin.logError(e);
 				}
 			} else {
 				String displayName = getComponent().getName();
 				//because this component is binary, its project must be the EAR.
 				IVirtualComponent earComponent = ComponentCore.createComponent(getComponent().getProject());
 				IVirtualReference [] refs = earComponent.getReferences();
 				for(IVirtualReference ref:refs){
 					if(ref.getReferencedComponent().equals(getComponent())){
 						displayName = ref.getArchiveName();
 						break;
 					}
 				}
 				DisplayName dn = JavaeeFactory.eINSTANCE.createDisplayName();
 				dn.setValue(displayName);
 				EObject root = null;
 				switch (qp.getType()) {
 				case JavaEEQuickPeek.APPLICATION_CLIENT_TYPE:
 					ApplicationClient applicationClient = ApplicationclientFactory.eINSTANCE.createApplicationClient();
 					applicationClient.getDisplayNames().add(dn);
 					root = (EObject) applicationClient;
 					break;
 				case JavaEEQuickPeek.EJB_TYPE:
 					EJBJar ejbJar = EjbFactory.eINSTANCE.createEJBJar();
 					ejbJar.getDisplayNames().add(dn);
 					root = (EObject) ejbJar;
 					break;
 				case JavaEEQuickPeek.WEB_TYPE:
 					WebApp webApp = WebFactory.eINSTANCE.createWebApp();
 					webApp.getDisplayNames().add(dn);
 					root = (EObject) webApp;
 					break;
 				case JavaEEQuickPeek.CONNECTOR_TYPE:
 					Connector connector = JcaFactory.eINSTANCE.createConnector();
 					connector.getDisplayNames().add(dn);
 					root = (EObject) connector;
 					break;
 				}
 				return root;
 			}
 		}
 		return null;
 	}

 	@Override
 	public Resource getResource(URI uri) {
 		IPath path = new Path(uri.toString());
 		try {
 			IArchiveLoadAdapter loadAdapter = null;
 			if(getArchive().getArchiveOptions().hasOption(JavaEEArchiveUtilities.WRAPPED_LOAD_ADAPTER)){
 				loadAdapter = (IArchiveLoadAdapter)getArchive().getArchiveOptions().getOption(JavaEEArchiveUtilities.WRAPPED_LOAD_ADAPTER);
 			} else {
 				loadAdapter = (IArchiveLoadAdapter)getArchive().getArchiveOptions().getOption(ArchiveOptions.LOAD_ADAPTER);
 			}
 			EObject modelRoot = (EObject)((JavaEEBinaryComponentLoadAdapter) loadAdapter).getModelObject(path);
 			return modelRoot.eResource();
 		} catch (ArchiveModelLoadException e) {
 			J2EEPlugin.logError(e);
 		}
 		return null;
 	}

 	public IArchive accessArchive() {
 		IArchive archive = getArchive();
 		if (null != archive) {
 			ArchiveCache cache = ArchiveCache.getInstance();
 			cache.accessArchive(archive);
 			synchronized (this) {
 				localArchiveAccessCount++;
 			}
 		}
 		return archive;
 	}

 	protected void safeReleaseArchive(IArchive archive){
 		int count = 0;
 		synchronized(this){
 			count = localArchiveAccessCount;
 		}
 		if(count > 0){
 			releaseArchive(archive);
 		}
 	}

 	public void releaseArchive(IArchive archive) {
 		if (archive != this.archive) {
 			throw new RuntimeException("The IArchive parameter must be the same IArchive retrieved from accessArchive"); //$NON-NLS-1$
 		}
 		if (null != archive) {
 			ArchiveCache cache = ArchiveCache.getInstance();
 			cache.releaseArchive(archive);
 			synchronized (this) {
 				localArchiveAccessCount--;
 			}
 		}
 	}

 	private int preSwapAccessCount = 0;
 	protected void preFileSwap(){
 		int count = 0;
 		synchronized (this) {
 			preSwapAccessCount = localArchiveAccessCount;
 			count = preSwapAccessCount;
 		}
 		while (count > 0){
 			count --;
 			releaseArchive(archive);
 		}
 	}

 	protected void postFileSwap() {
 		int count = 0;
 		synchronized (this) {
 			count = preSwapAccessCount;
 			preSwapAccessCount = 0;
 		}
 		while(count > 0){
 			count --;
 			accessArchive();
 		}
 	}

 	public Archive accessLegacyArchive() {
 		if(legacyBinaryHelper == null){
 			JavaEEQuickPeek qp = getJavaEEQuickPeek(getComponent());
 			switch (qp.getType()) {
 			case JavaEEQuickPeek.APPLICATION_CLIENT_TYPE:
 				legacyBinaryHelper = new AppClientBinaryComponentHelper(getComponent()){
 					@Override
 					protected void aboutToClose() {
 						safeReleaseArchive(JavaEEBinaryComponentHelper.this.archive);
 					}
 					@Override
 					protected void preCleanupAfterTempSave(String uri, File original, File destinationFile) {
 						preFileSwap();
 					}
 					@Override
 					protected void postCleanupAfterTempSave(String uri, File original, File destinationFile) {
 						postFileSwap();
 					}
 				};
 				break;
 			case JavaEEQuickPeek.EJB_TYPE:
 				legacyBinaryHelper = new EJBBinaryComponentHelper(getComponent()){
 					@Override
 					protected void aboutToClose() {
 						safeReleaseArchive(JavaEEBinaryComponentHelper.this.archive);
 					}
 					@Override
 					protected void preCleanupAfterTempSave(String uri, File original, File destinationFile) {
 						preFileSwap();
 					}
 					@Override
 					protected void postCleanupAfterTempSave(String uri, File original, File destinationFile) {
 						postFileSwap();
 					}
 				};
 				break;
 			case JavaEEQuickPeek.WEB_TYPE:
 				legacyBinaryHelper = new WebBinaryComponentHelper(getComponent()){
 					@Override
 					protected void aboutToClose() {
 						safeReleaseArchive(JavaEEBinaryComponentHelper.this.archive);
 					}
 					@Override
 					protected void preCleanupAfterTempSave(String uri, File original, File destinationFile) {
 						preFileSwap();
 					}
 					@Override
 					protected void postCleanupAfterTempSave(String uri, File original, File destinationFile) {
 						postFileSwap();
 					}
 				};
 				break;
 			case JavaEEQuickPeek.CONNECTOR_TYPE:
 				legacyBinaryHelper = new JCABinaryComponentHelper(getComponent()){
 					@Override
 					protected void aboutToClose() {
 						safeReleaseArchive(JavaEEBinaryComponentHelper.this.archive);
 					}
 					@Override
 					protected void preCleanupAfterTempSave(String uri, File original, File destinationFile) {
 						preFileSwap();
 					}
 					@Override
 					protected void postCleanupAfterTempSave(String uri, File original, File destinationFile) {
 						postFileSwap();
 					}
 				};
 				break;
 			default: //utility jar
 				legacyBinaryHelper = new UtilityBinaryComponentHelper(getComponent()){
 					@Override
 					protected void aboutToClose() {
 						safeReleaseArchive(JavaEEBinaryComponentHelper.this.archive);
 					}
 					@Override
 					protected void preCleanupAfterTempSave(String uri, File original, File destinationFile) {
 						preFileSwap();
 					}
 					@Override
 					protected void postCleanupAfterTempSave(String uri, File original, File destinationFile) {
 						postFileSwap();
 					}
 				};
 				break;
 			}
 		}
 		accessArchive();
 		Archive legacyArchive = legacyBinaryHelper.accessArchive();
 		return legacyArchive;
 	}

 	@Override
 	public void dispose() {
 		super.dispose();
 		int count = 0;
 		synchronized (this) {
 			count = localArchiveAccessCount;
 		}
 		if (count > 0 && archive != null) {
 			ArchiveCache cache = ArchiveCache.getInstance();
 			for (int i = 0; i < count; i++) {
 				cache.releaseArchive(archive);
 				synchronized (this) {
 					localArchiveAccessCount--;
 				}
 			}
 		}
 		if(legacyBinaryHelper != null){
 			IReferenceCountedArchive legacyArchive = legacyBinaryHelper.archive;
 			if(legacyArchive != null){
 				legacyArchive.forceClose();
 			}
 		}
 	}

 	protected IArchive getArchive() {
 		if (archive == null) {
 			archive = getUniqueArchive();
 		}
 		return archive;
 	}

 	protected IArchive getUniqueArchive() {
 		try {
 			return openArchive();
 		} catch (ArchiveOpenFailureException e) {
 			logError(e);
 		}
 		return null;
 	}

 	static class LRUMap extends LinkedHashMap {
 		private static final long serialVersionUID = 1L;

 		private int fMaxSize;

 		LRUMap(int maxSize) {
 			super();
 			fMaxSize = maxSize;
 		}

 		@Override
 		protected boolean removeEldestEntry(Entry eldest) {
 			return size() > fMaxSize;
 		}
 	}

 	static LRUMap loggedBadPaths = new LRUMap(1000);

 	/**
 	 * This is to suppress excessive logging of for the same missing archive.
 	 * Now each missing archive will only be logged once.
 	 *
 	 * @param e
 	 */
 	static void logError(ArchiveOpenFailureException e) {
 		IPath archivePath = e.getArchivePath();
 		if (archivePath != null) {
 			if (loggedBadPaths.containsKey(archivePath)) {
 				// only log an error for a specific archive path once.
 				return;
 			}
 			loggedBadPaths.put(archivePath, archivePath);
 		}
 		J2EEPlugin.logError(e);
 	}


 	protected IArchive openArchive() throws ArchiveOpenFailureException {
 		ArchiveCache cache = ArchiveCache.getInstance();
 		IArchive archive = cache.getArchive(getComponent());
 		if (archive == null) {
 			archive = cache.openArchive(this);
 		}
 		if (archive != null) {
 			cache.accessArchive(archive);
 			synchronized (this) {
 				localArchiveAccessCount++;
 			}
 		}
 		return archive;
 	}

 	public static void clearDisconnectedArchivesInEAR(IVirtualComponent earComponent) {
 		ArchiveCache.getInstance().clearDisconnectedArchivesInEAR(earComponent);
 	}

 	public static void clearAllArchivesInProject(IProject earProject) {
 		ArchiveCache.getInstance().clearAllArchivesInProject(earProject);
 	}

 	public void setDescriminateMainClass(boolean archiveOption) {
 		descriminateMainClass = archiveOption;
 	}

 	public boolean shouldDescriminateMainClass() {
 		return descriminateMainClass;
 	}

 	/**
 	 * This cache manages IArchives across all
 	 * {@link JavaEEBinaryComponentHelper} instances. If multiple
 	 * {@link JavaEEBinaryComponentHelper} instances exist for the same
 	 * underlying archive file (e.g. a jar file on disk) all will use the exact
 	 * same IArchive instance. Care needs to be taken in managing the opening
 	 * and closing of this IArchive which should only be done through internal
 	 * methods within {@link JavaEEBinaryComponentHelper}
 	 */
 	private static class ArchiveCache {

 		private static class ArchiveCacheInstanceHolder {
 			private static ArchiveCache instance = new ArchiveCache();
 		}

 		public static ArchiveCache getInstance() {
 			return ArchiveCacheInstanceHolder.instance;
 		}

 		protected Map<IVirtualComponent, IArchive> componentsToArchives = new Hashtable<IVirtualComponent, IArchive>();

 		protected Map<IArchive, Integer> archiveAccessCount = new Hashtable<IArchive, Integer>();

 		public synchronized void accessArchive(IArchive archive) {
 			Integer count = archiveAccessCount.get(archive);
 			if(count != null) {
 				Integer newCount = new Integer(count.intValue() + 1);
 				archiveAccessCount.put(archive, newCount);
 				if (newCount.intValue() == 1) {
 					JavaEEBinaryComponentLoadAdapter binaryAdapter = null;
 					if (archive.getArchiveOptions().hasOption(JavaEEArchiveUtilities.WRAPPED_LOAD_ADAPTER)) {
 						binaryAdapter = (JavaEEBinaryComponentLoadAdapter) archive.getArchiveOptions().getOption(JavaEEArchiveUtilities.WRAPPED_LOAD_ADAPTER);
 					} else {
 						binaryAdapter = (JavaEEBinaryComponentLoadAdapter) archive.getArchiveOptions().getOption(ArchiveOptions.LOAD_ADAPTER);
 					}
 					if (!binaryAdapter.isPhysicallyOpen()) {
 						try {
 							binaryAdapter.physicallyOpen();
 						} catch (ZipException e) {
 							J2EEPlugin.logError(e);
 						} catch (IOException e) {
 							J2EEPlugin.logError(e);
 						}
 					}
 				}
 			}
 		}

 		public synchronized void releaseArchive(IArchive archive) {
 			Integer count = archiveAccessCount.get(archive);
 			if(count != null) {
 				Integer newCount = new Integer(count.intValue() - 1);
 				archiveAccessCount.put(archive, newCount);
 				if (newCount.intValue() == 0) {
 					JavaEEBinaryComponentLoadAdapter binaryAdapter = null;
 					if (archive.getArchiveOptions().hasOption(JavaEEArchiveUtilities.WRAPPED_LOAD_ADAPTER)) {
 						binaryAdapter = (JavaEEBinaryComponentLoadAdapter) archive.getArchiveOptions().getOption(JavaEEArchiveUtilities.WRAPPED_LOAD_ADAPTER);
 					} else {
 						binaryAdapter = (JavaEEBinaryComponentLoadAdapter) archive.getArchiveOptions().getOption(ArchiveOptions.LOAD_ADAPTER);
 					}
 					if (binaryAdapter.isPhysicallyOpen()) {
 						binaryAdapter.physicallyClose();
 					}
 				}
 			}
 		}

 		public synchronized IArchive getArchive(IVirtualComponent component) {
 			IArchive archive = componentsToArchives.get(component);
 			return archive;
 		}

 		public synchronized void clearDisconnectedArchivesInEAR(IVirtualComponent earComponent) {
 			if (componentsToArchives.isEmpty()) {
 				return;
 			}
 			Set<IVirtualComponent> liveBinaryComponnts = new HashSet<IVirtualComponent>();
 			IVirtualReference[] refs = earComponent.getReferences();
 			IVirtualComponent component = null;
 			for (int i = 0; i < refs.length; i++) {
 				component = refs[i].getReferencedComponent();
 				if (component.isBinary()) {
 					liveBinaryComponnts.add(component);
 				}
 			}
 			clearArchivesInProject(earComponent.getProject(), liveBinaryComponnts);
 		}

 		public synchronized void clearAllArchivesInProject(IProject earProject) {
 			if (componentsToArchives.isEmpty()) {
 				return;
 			}
 			clearArchivesInProject(earProject, null);
 		}

 		private void clearArchivesInProject(IProject earProject, Set excludeSet) {
 			Iterator iterator = componentsToArchives.entrySet().iterator();
 			IVirtualComponent component = null;
 			IArchive archive = null;
 			while (iterator.hasNext()) {
 				Map.Entry entry = (Map.Entry) iterator.next();
 				component = (IVirtualComponent) entry.getKey();
 				if (component.getProject().equals(earProject) && (excludeSet == null || !excludeSet.contains(component))) {
 					archive = (IArchive) entry.getValue();
 					IArchiveFactory.INSTANCE.closeArchive(archive);
 					iterator.remove();
 					archiveAccessCount.remove(archive);
 				}
 			}
 		}

 		public synchronized IArchive openArchive(JavaEEBinaryComponentHelper helper) throws ArchiveOpenFailureException {
 			IArchive archive;
 			if (helper.getComponent().isBinary()) {
 				if (helper.shouldRefineForJavaEE()) {
 					archive = JavaEEArchiveUtilities.INSTANCE.openBinaryArchive(helper.getComponent(), helper.shouldDescriminateMainClass());
 				} else {
 					J2EEModuleVirtualArchiveComponent archiveComponent = (J2EEModuleVirtualArchiveComponent) helper.getComponent();
 					JavaEEBinaryComponentLoadAdapter loadAdapter = new JavaEEBinaryComponentLoadAdapter(archiveComponent);
 					ArchiveOptions archiveOptions = new ArchiveOptions();
 					archiveOptions.setOption(ArchiveOptions.LOAD_ADAPTER, loadAdapter);
 					archiveOptions.setOption(ArchiveOptions.ARCHIVE_PATH, loadAdapter.getArchivePath());
 					archiveOptions.setOption(JavaEEArchiveUtilities.DISCRIMINATE_JAVA_EE, Boolean.FALSE);
 					archive = JavaEEArchiveUtilities.INSTANCE.openArchive(archiveOptions);
 				}
 			} else {
 				archive = JavaEEArchiveUtilities.INSTANCE.openArchive(helper.getComponent());
 			}
 			componentsToArchives.put(helper.getComponent(), archive);
 			archiveAccessCount.put(archive, new Integer(0));
 			return archive;
 		}
 	}

 }
	package org.eclipse.jst.j2ee.internal.componentcore;

	import java.io.File;
	import java.io.IOException;
	import java.util.HashSet;
	import java.util.Hashtable;
	import java.util.Iterator;
	import java.util.LinkedHashMap;
	import java.util.Map;
	import java.util.Map.Entry;
	import java.util.Set;
	import java.util.zip.ZipException;

	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.emf.common.util.URI;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.resource.Resource;
	import org.eclipse.jst.j2ee.commonarchivecore.internal.Archive;
	import org.eclipse.jst.j2ee.componentcore.J2EEModuleVirtualArchiveComponent;
	import org.eclipse.jst.j2ee.internal.J2EEConstants;
	import org.eclipse.jst.j2ee.internal.archive.JavaEEArchiveUtilities;
	import org.eclipse.jst.j2ee.internal.componentcore.EnterpriseBinaryComponentHelper.IReferenceCountedArchive;
	import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
	import org.eclipse.jst.javaee.applicationclient.ApplicationClient;
	import org.eclipse.jst.javaee.applicationclient.ApplicationclientFactory;
	import org.eclipse.jst.javaee.core.DisplayName;
	import org.eclipse.jst.javaee.core.JavaeeFactory;
	import org.eclipse.jst.javaee.ejb.EJBJar;
	import org.eclipse.jst.javaee.ejb.EjbFactory;
	import org.eclipse.jst.javaee.jca.Connector;
	import org.eclipse.jst.javaee.jca.JcaFactory;
	import org.eclipse.jst.javaee.web.WebApp;
	import org.eclipse.jst.javaee.web.WebFactory;
	import org.eclipse.jst.jee.archive.ArchiveModelLoadException;
	import org.eclipse.jst.jee.archive.ArchiveOpenFailureException;
	import org.eclipse.jst.jee.archive.ArchiveOptions;
	import org.eclipse.jst.jee.archive.IArchive;
	import org.eclipse.jst.jee.archive.IArchiveFactory;
	import org.eclipse.jst.jee.archive.IArchiveLoadAdapter;
	import org.eclipse.jst.jee.archive.internal.ArchiveFactoryImpl;
	import org.eclipse.jst.jee.util.internal.JavaEEQuickPeek;
	import org.eclipse.wst.common.componentcore.ComponentCore;
	import org.eclipse.wst.common.componentcore.internal.BinaryComponentHelper;
	import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
	import org.eclipse.wst.common.componentcore.resources.IVirtualReference;

	public class JavaEEBinaryComponentHelper extends BinaryComponentHelper {

	private IArchive archive;
	private EnterpriseBinaryComponentHelper legacyBinaryHelper;
	private boolean descriminateMainClass = true;
	private int localArchiveAccessCount = 0;
	private boolean refineForJavaEE = true;

	public boolean shouldRefineForJavaEE() {
	return refineForJavaEE;
	}

	public void setRefineForJavaEE(boolean refineForJavaEE) {
	this.refineForJavaEE = refineForJavaEE;
	}

	public static JavaEEQuickPeek getJavaEEQuickPeek(IPath filesystemPath) {
	IArchive archive = null;
	try {
	try {
	archive = JavaEEArchiveUtilities.INSTANCE.openArchive(filesystemPath);
	} catch( ArchiveOpenFailureException fail) {}
	if (archive == null) {
	return new JavaEEQuickPeek(null);
	}
	JavaEEQuickPeek qp = JavaEEArchiveUtilities.INSTANCE.getJavaEEQuickPeek(archive);
	return qp;
	} finally {
	if (null != archive) {
	new ArchiveFactoryImpl().closeArchive(archive);
	}
	}
	}

	public static JavaEEQuickPeek getJavaEEQuickPeek(IVirtualComponent aBinaryComponent) {
	JavaEEBinaryComponentHelper helper = null;
	try {
	helper = new JavaEEBinaryComponentHelper(aBinaryComponent);
	IArchive archive = helper.getArchive();
	if (archive == null) {
	return new JavaEEQuickPeek(null);
	}
	JavaEEQuickPeek qp = JavaEEArchiveUtilities.INSTANCE.getJavaEEQuickPeek(archive);
	return qp;
	} finally {
	if (helper != null) {
	helper.dispose();
	}
	}
	}

	public static void openArchiveAsUtility(IVirtualComponent aBinaryComponent) {
	openArchive(aBinaryComponent, false, false);
	}

	public static void openArchive(IVirtualComponent aBinaryComponent, boolean refineForJavaEE, boolean descriminateMainClass) {
	JavaEEBinaryComponentHelper helper = null;
	try {
	helper = new JavaEEBinaryComponentHelper(aBinaryComponent);
	helper.setDescriminateMainClass(descriminateMainClass);
	try {
	helper.openArchive();
	} catch (ArchiveOpenFailureException e) {
	logError(e);
	}
	} finally {
	if (helper != null) {
	helper.dispose();
	}
	}
	}

	public static void openArchive(IVirtualComponent aBinaryComponent, boolean descriminateMainClass) {
	openArchive(aBinaryComponent, true, descriminateMainClass);
	}

	public JavaEEBinaryComponentHelper(IVirtualComponent aBinaryComponent) {
	super(aBinaryComponent);
	}

	public IPath getAbsolutePath() {
	IArchiveLoadAdapter loadAdapter = null;
	if(getArchive().getArchiveOptions().hasOption(JavaEEArchiveUtilities.WRAPPED_LOAD_ADAPTER)){
	loadAdapter = (IArchiveLoadAdapter)getArchive().getArchiveOptions().getOption(JavaEEArchiveUtilities.WRAPPED_LOAD_ADAPTER);
	} else {
	loadAdapter = (IArchiveLoadAdapter)getArchive().getArchiveOptions().getOption(ArchiveOptions.LOAD_ADAPTER);
	}
	return ((JavaEEBinaryComponentLoadAdapter) loadAdapter).getArchivePath();
	}

	@Override
	public EObject getPrimaryRootObject() {
	JavaEEQuickPeek qp = JavaEEArchiveUtilities.INSTANCE.getJavaEEQuickPeek(getArchive());
	IPath ddPath = null;
	switch (qp.getType()) {
	case JavaEEQuickPeek.APPLICATION_CLIENT_TYPE:
	ddPath = new Path(J2EEConstants.APP_CLIENT_DD_URI);
	break;
	case JavaEEQuickPeek.EJB_TYPE:
	ddPath = new Path(J2EEConstants.EJBJAR_DD_URI);
	break;
	case JavaEEQuickPeek.WEB_TYPE:
	ddPath = new Path(J2EEConstants.WEBAPP_DD_URI);
	break;
	case JavaEEQuickPeek.CONNECTOR_TYPE:
	ddPath = new Path(J2EEConstants.RAR_DD_URI);
	break;
	case JavaEEQuickPeek.WEBFRAGMENT_TYPE:
	ddPath = new Path(J2EEConstants.WEBFRAGMENT_DD_URI);
	break;
	}
	if (ddPath != null) {
	if (getArchive().containsArchiveResource(ddPath)) {
	try {
	return (EObject) getArchive().getModelObject(ddPath);
	} catch (ArchiveModelLoadException e) {
	J2EEPlugin.logError(e);
	}
	} else {
	String displayName = getComponent().getName();
	//because this component is binary, its project must be the EAR.
	IVirtualComponent earComponent = ComponentCore.createComponent(getComponent().getProject());
	IVirtualReference [] refs = earComponent.getReferences();
	for(IVirtualReference ref:refs){
	if(ref.getReferencedComponent().equals(getComponent())){
	displayName = ref.getArchiveName();
	break;
	}
	}
	DisplayName dn = JavaeeFactory.eINSTANCE.createDisplayName();
	dn.setValue(displayName);
	EObject root = null;
	switch (qp.getType()) {
	case JavaEEQuickPeek.APPLICATION_CLIENT_TYPE:
	ApplicationClient applicationClient = ApplicationclientFactory.eINSTANCE.createApplicationClient();
	applicationClient.getDisplayNames().add(dn);
	root = (EObject) applicationClient;
	break;
	case JavaEEQuickPeek.EJB_TYPE:
	EJBJar ejbJar = EjbFactory.eINSTANCE.createEJBJar();
	ejbJar.getDisplayNames().add(dn);
	root = (EObject) ejbJar;
	break;
	case JavaEEQuickPeek.WEB_TYPE:
	WebApp webApp = WebFactory.eINSTANCE.createWebApp();
	webApp.getDisplayNames().add(dn);
	root = (EObject) webApp;
	break;
	case JavaEEQuickPeek.CONNECTOR_TYPE:
	Connector connector = JcaFactory.eINSTANCE.createConnector();
	connector.getDisplayNames().add(dn);
	root = (EObject) connector;
	break;
	}
	return root;
	}
	}
	return null;
	}

	@Override
	public Resource getResource(URI uri) {
	IPath path = new Path(uri.toString());
	try {
	IArchiveLoadAdapter loadAdapter = null;
	if(getArchive().getArchiveOptions().hasOption(JavaEEArchiveUtilities.WRAPPED_LOAD_ADAPTER)){
	loadAdapter = (IArchiveLoadAdapter)getArchive().getArchiveOptions().getOption(JavaEEArchiveUtilities.WRAPPED_LOAD_ADAPTER);
	} else {
	loadAdapter = (IArchiveLoadAdapter)getArchive().getArchiveOptions().getOption(ArchiveOptions.LOAD_ADAPTER);
	}
	EObject modelRoot = (EObject)((JavaEEBinaryComponentLoadAdapter) loadAdapter).getModelObject(path);
	return modelRoot.eResource();
	} catch (ArchiveModelLoadException e) {
	J2EEPlugin.logError(e);
	}
	return null;
	}

	public IArchive accessArchive() {
	IArchive archive = getArchive();
	if (null != archive) {
	ArchiveCache cache = ArchiveCache.getInstance();
	cache.accessArchive(archive);
	synchronized (this) {
	localArchiveAccessCount++;
	}
	}
	return archive;
	}

	protected void safeReleaseArchive(IArchive archive){
	int count = 0;
	synchronized(this){
	count = localArchiveAccessCount;
	}
	if(count > 0){
	releaseArchive(archive);
	}
	}

	public void releaseArchive(IArchive archive) {
	if (archive != this.archive) {
	throw new RuntimeException("The IArchive parameter must be the same IArchive retrieved from accessArchive"); //$NON-NLS-1$
	}
	if (null != archive) {
	ArchiveCache cache = ArchiveCache.getInstance();
	cache.releaseArchive(archive);
	synchronized (this) {
	localArchiveAccessCount--;
	}
	}
	}

	private int preSwapAccessCount = 0;
	protected void preFileSwap(){
	int count = 0;
	synchronized (this) {
	preSwapAccessCount = localArchiveAccessCount;
	count = preSwapAccessCount;
	}
	while (count > 0){
	count --;
	releaseArchive(archive);
	}
	}

	protected void postFileSwap() {
	int count = 0;
	synchronized (this) {
	count = preSwapAccessCount;
	preSwapAccessCount = 0;
	}
	while(count > 0){
	count --;
	accessArchive();
	}
	}

	public Archive accessLegacyArchive() {
	if(legacyBinaryHelper == null){
	JavaEEQuickPeek qp = getJavaEEQuickPeek(getComponent());
	switch (qp.getType()) {
	case JavaEEQuickPeek.APPLICATION_CLIENT_TYPE:
	legacyBinaryHelper = new AppClientBinaryComponentHelper(getComponent()){
	@Override
	protected void aboutToClose() {
	safeReleaseArchive(JavaEEBinaryComponentHelper.this.archive);
	}
	@Override
	protected void preCleanupAfterTempSave(String uri, File original, File destinationFile) {
	preFileSwap();
	}
	@Override
	protected void postCleanupAfterTempSave(String uri, File original, File destinationFile) {
	postFileSwap();
	}
	};
	break;
	case JavaEEQuickPeek.EJB_TYPE:
	legacyBinaryHelper = new EJBBinaryComponentHelper(getComponent()){
	@Override
	protected void aboutToClose() {
	safeReleaseArchive(JavaEEBinaryComponentHelper.this.archive);
	}
	@Override
	protected void preCleanupAfterTempSave(String uri, File original, File destinationFile) {
	preFileSwap();
	}
	@Override
	protected void postCleanupAfterTempSave(String uri, File original, File destinationFile) {
	postFileSwap();
	}
	};
	break;
	case JavaEEQuickPeek.WEB_TYPE:
	legacyBinaryHelper = new WebBinaryComponentHelper(getComponent()){
	@Override
	protected void aboutToClose() {
	safeReleaseArchive(JavaEEBinaryComponentHelper.this.archive);
	}
	@Override
	protected void preCleanupAfterTempSave(String uri, File original, File destinationFile) {
	preFileSwap();
	}
	@Override
	protected void postCleanupAfterTempSave(String uri, File original, File destinationFile) {
	postFileSwap();
	}
	};
	break;
	case JavaEEQuickPeek.CONNECTOR_TYPE:
	legacyBinaryHelper = new JCABinaryComponentHelper(getComponent()){
	@Override
	protected void aboutToClose() {
	safeReleaseArchive(JavaEEBinaryComponentHelper.this.archive);
	}
	@Override
	protected void preCleanupAfterTempSave(String uri, File original, File destinationFile) {
	preFileSwap();
	}
	@Override
	protected void postCleanupAfterTempSave(String uri, File original, File destinationFile) {
	postFileSwap();
	}
	};
	break;
	default: //utility jar
	legacyBinaryHelper = new UtilityBinaryComponentHelper(getComponent()){
	@Override
	protected void aboutToClose() {
	safeReleaseArchive(JavaEEBinaryComponentHelper.this.archive);
	}
	@Override
	protected void preCleanupAfterTempSave(String uri, File original, File destinationFile) {
	preFileSwap();
	}
	@Override
	protected void postCleanupAfterTempSave(String uri, File original, File destinationFile) {
	postFileSwap();
	}
	};
	break;
	}
	}
	accessArchive();
	Archive legacyArchive = legacyBinaryHelper.accessArchive();
	return legacyArchive;
	}

	@Override
	public void dispose() {
	super.dispose();
	int count = 0;
	synchronized (this) {
	count = localArchiveAccessCount;
	}
	if (count > 0 && archive != null) {
	ArchiveCache cache = ArchiveCache.getInstance();
	for (int i = 0; i < count; i++) {
	cache.releaseArchive(archive);
	synchronized (this) {
	localArchiveAccessCount--;
	}
	}
	}
	if(legacyBinaryHelper != null){
	IReferenceCountedArchive legacyArchive = legacyBinaryHelper.archive;
	if(legacyArchive != null){
	legacyArchive.forceClose();
	}
	}
	}

	protected IArchive getArchive() {
	if (archive == null) {
	archive = getUniqueArchive();
	}
	return archive;
	}

	protected IArchive getUniqueArchive() {
	try {
	return openArchive();
	} catch (ArchiveOpenFailureException e) {
	logError(e);
	}
	return null;
	}

	static class LRUMap extends LinkedHashMap {
	private static final long serialVersionUID = 1L;

	private int fMaxSize;

	LRUMap(int maxSize) {
	super();
	fMaxSize = maxSize;
	}

	@Override
	protected boolean removeEldestEntry(Entry eldest) {
	return size() > fMaxSize;
	}
	}

	static LRUMap loggedBadPaths = new LRUMap(1000);

	/**
	* This is to suppress excessive logging of for the same missing archive.
	* Now each missing archive will only be logged once.
	*
	* @param e
	*/
	static void logError(ArchiveOpenFailureException e) {
	IPath archivePath = e.getArchivePath();
	if (archivePath != null) {
	if (loggedBadPaths.containsKey(archivePath)) {
	// only log an error for a specific archive path once.
	return;
	}
	loggedBadPaths.put(archivePath, archivePath);
	}
	J2EEPlugin.logError(e);
	}


	protected IArchive openArchive() throws ArchiveOpenFailureException {
	ArchiveCache cache = ArchiveCache.getInstance();
	IArchive archive = cache.getArchive(getComponent());
	if (archive == null) {
	archive = cache.openArchive(this);
	}
	if (archive != null) {
	cache.accessArchive(archive);
	synchronized (this) {
	localArchiveAccessCount++;
	}
	}
	return archive;
	}

	public static void clearDisconnectedArchivesInEAR(IVirtualComponent earComponent) {
	ArchiveCache.getInstance().clearDisconnectedArchivesInEAR(earComponent);
	}

	public static void clearAllArchivesInProject(IProject earProject) {
	ArchiveCache.getInstance().clearAllArchivesInProject(earProject);
	}

	public void setDescriminateMainClass(boolean archiveOption) {
	descriminateMainClass = archiveOption;
	}

	public boolean shouldDescriminateMainClass() {
	return descriminateMainClass;
	}

	/**
	* This cache manages IArchives across all
	* {@link JavaEEBinaryComponentHelper} instances. If multiple
	* {@link JavaEEBinaryComponentHelper} instances exist for the same
	* underlying archive file (e.g. a jar file on disk) all will use the exact
	* same IArchive instance. Care needs to be taken in managing the opening
	* and closing of this IArchive which should only be done through internal
	* methods within {@link JavaEEBinaryComponentHelper}
	*/
	private static class ArchiveCache {

	private static class ArchiveCacheInstanceHolder {
	private static ArchiveCache instance = new ArchiveCache();
	}

	public static ArchiveCache getInstance() {
	return ArchiveCacheInstanceHolder.instance;
	}

	protected Map<IVirtualComponent, IArchive> componentsToArchives = new Hashtable<IVirtualComponent, IArchive>();

	protected Map<IArchive, Integer> archiveAccessCount = new Hashtable<IArchive, Integer>();

	public synchronized void accessArchive(IArchive archive) {
	Integer count = archiveAccessCount.get(archive);
	if(count != null) {
	Integer newCount = new Integer(count.intValue() + 1);
	archiveAccessCount.put(archive, newCount);
	if (newCount.intValue() == 1) {
	JavaEEBinaryComponentLoadAdapter binaryAdapter = null;
	if (archive.getArchiveOptions().hasOption(JavaEEArchiveUtilities.WRAPPED_LOAD_ADAPTER)) {
	binaryAdapter = (JavaEEBinaryComponentLoadAdapter) archive.getArchiveOptions().getOption(JavaEEArchiveUtilities.WRAPPED_LOAD_ADAPTER);
	} else {
	binaryAdapter = (JavaEEBinaryComponentLoadAdapter) archive.getArchiveOptions().getOption(ArchiveOptions.LOAD_ADAPTER);
	}
	if (!binaryAdapter.isPhysicallyOpen()) {
	try {
	binaryAdapter.physicallyOpen();
	} catch (ZipException e) {
	J2EEPlugin.logError(e);
	} catch (IOException e) {
	J2EEPlugin.logError(e);
	}
	}
	}
	}
	}

	public synchronized void releaseArchive(IArchive archive) {
	Integer count = archiveAccessCount.get(archive);
	if(count != null) {
	Integer newCount = new Integer(count.intValue() - 1);
	archiveAccessCount.put(archive, newCount);
	if (newCount.intValue() == 0) {
	JavaEEBinaryComponentLoadAdapter binaryAdapter = null;
	if (archive.getArchiveOptions().hasOption(JavaEEArchiveUtilities.WRAPPED_LOAD_ADAPTER)) {
	binaryAdapter = (JavaEEBinaryComponentLoadAdapter) archive.getArchiveOptions().getOption(JavaEEArchiveUtilities.WRAPPED_LOAD_ADAPTER);
	} else {
	binaryAdapter = (JavaEEBinaryComponentLoadAdapter) archive.getArchiveOptions().getOption(ArchiveOptions.LOAD_ADAPTER);
	}
	if (binaryAdapter.isPhysicallyOpen()) {
	binaryAdapter.physicallyClose();
	}
	}
	}
	}

	public synchronized IArchive getArchive(IVirtualComponent component) {
	IArchive archive = componentsToArchives.get(component);
	return archive;
	}

	public synchronized void clearDisconnectedArchivesInEAR(IVirtualComponent earComponent) {
	if (componentsToArchives.isEmpty()) {
	return;
	}
	Set<IVirtualComponent> liveBinaryComponnts = new HashSet<IVirtualComponent>();
	IVirtualReference[] refs = earComponent.getReferences();
	IVirtualComponent component = null;
	for (int i = 0; i < refs.length; i++) {
	component = refs[i].getReferencedComponent();
	if (component.isBinary()) {
	liveBinaryComponnts.add(component);
	}
	}
	clearArchivesInProject(earComponent.getProject(), liveBinaryComponnts);
	}

	public synchronized void clearAllArchivesInProject(IProject earProject) {
	if (componentsToArchives.isEmpty()) {
	return;
	}
	clearArchivesInProject(earProject, null);
	}

	private void clearArchivesInProject(IProject earProject, Set excludeSet) {
	Iterator iterator = componentsToArchives.entrySet().iterator();
	IVirtualComponent component = null;
	IArchive archive = null;
	while (iterator.hasNext()) {
	Map.Entry entry = (Map.Entry) iterator.next();
	component = (IVirtualComponent) entry.getKey();
	if (component.getProject().equals(earProject) && (excludeSet == null \|\| !excludeSet.contains(component))) {
	archive = (IArchive) entry.getValue();
	IArchiveFactory.INSTANCE.closeArchive(archive);
	iterator.remove();
	archiveAccessCount.remove(archive);
	}
	}
	}

	public synchronized IArchive openArchive(JavaEEBinaryComponentHelper helper) throws ArchiveOpenFailureException {
	IArchive archive;
	if (helper.getComponent().isBinary()) {
	if (helper.shouldRefineForJavaEE()) {
	archive = JavaEEArchiveUtilities.INSTANCE.openBinaryArchive(helper.getComponent(), helper.shouldDescriminateMainClass());
	} else {
	J2EEModuleVirtualArchiveComponent archiveComponent = (J2EEModuleVirtualArchiveComponent) helper.getComponent();
	JavaEEBinaryComponentLoadAdapter loadAdapter = new JavaEEBinaryComponentLoadAdapter(archiveComponent);
	ArchiveOptions archiveOptions = new ArchiveOptions();
	archiveOptions.setOption(ArchiveOptions.LOAD_ADAPTER, loadAdapter);
	archiveOptions.setOption(ArchiveOptions.ARCHIVE_PATH, loadAdapter.getArchivePath());
	archiveOptions.setOption(JavaEEArchiveUtilities.DISCRIMINATE_JAVA_EE, Boolean.FALSE);
	archive = JavaEEArchiveUtilities.INSTANCE.openArchive(archiveOptions);
	}
	} else {
	archive = JavaEEArchiveUtilities.INSTANCE.openArchive(helper.getComponent());
	}
	componentsToArchives.put(helper.getComponent(), archive);
	archiveAccessCount.put(archive, new Integer(0));
	return archive;
	}
	}

	}