| /*************************************************************************************************** |
| * Copyright (c) 2003, 2004 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.jst.j2ee.internal.archive.operations; |
| |
| |
| |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.core.resources.IContainer; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.emf.ecore.EPackage; |
| import org.eclipse.emf.ecore.resource.Resource.Factory.Registry; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.Archive; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.CommonarchivePackage; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.EARFile; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.File; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.ArchiveRuntimeException; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.OpenFailureException; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveOptions; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.LoadStrategy; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.LoadStrategyImpl; |
| import org.eclipse.jst.j2ee.internal.common.impl.J2EEResourceFactoryRegistry; |
| import org.eclipse.jst.j2ee.internal.earcreation.EAREditModel; |
| import org.eclipse.jst.j2ee.internal.earcreation.EARNatureRuntime; |
| import org.eclipse.jst.j2ee.internal.earcreation.modulemap.UtilityJARMapping; |
| import org.eclipse.jst.j2ee.internal.project.J2EEModuleNature; |
| import org.eclipse.jst.j2ee.internal.project.J2EENature; |
| import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities; |
| import org.eclipse.jst.j2ee.internal.servertarget.IServerTargetConstants; |
| import org.eclipse.wst.common.internal.emfworkbench.WorkbenchResourceHelper; |
| |
| import org.eclipse.jem.util.logger.proxy.Logger; |
| import org.eclipse.jem.util.emf.workbench.WorkbenchURIConverter; |
| |
| public class EARProjectLoadStrategyImpl extends LoadStrategyImpl implements IJ2EEImportExportConstants { |
| protected ArrayList filesList; |
| protected IProject project; |
| protected EARFile earFile; |
| protected boolean exportSource = false; |
| protected WorkbenchURIConverter earURIConverter; |
| protected List jarMergers; |
| protected boolean mergeDependentJars = true; |
| protected boolean includeProjectMetaFiles = false; |
| |
| /** |
| * EARProjectSaveStrategyImpl constructor comment. |
| */ |
| public EARProjectLoadStrategyImpl(IProject aProject) { |
| super(); |
| project = aProject; |
| filesList = new ArrayList(); |
| } |
| |
| /** |
| * For each module project in this ear project, add a module file the list of files in the EAR |
| */ |
| public void addModulesToFiles() { |
| Map moduleProjects = getEARNature().getModuleProjects(); |
| //Next get all the absolute paths of the modules |
| |
| //Make a set of all the files collected thus far; if the uri of a module collides with an |
| // existing file, |
| //Then remove that file and give the ModuleFile precedence - |
| //ensure there is a workbench validation that checks for this collision |
| //TODO |
| Map existingFiles = getFilesListMapped(); |
| |
| Iterator it = moduleProjects.entrySet().iterator(); |
| while (it.hasNext()) { |
| Map.Entry entry = (Map.Entry) it.next(); |
| String uri = (String) entry.getKey(); |
| J2EENature nature = (J2EENature) entry.getValue(); |
| if (nature == null) |
| continue; |
| try { |
| Archive moduleFile = ((J2EEModuleNature) nature).asArchive(exportSource); |
| if( moduleFile == null ) |
| continue; |
| moduleFile.setURI(uri); |
| setIncludeProjectMetaFiles(moduleFile); |
| if (existingFiles.containsKey(uri)) |
| filesList.remove(existingFiles.get(uri)); |
| filesList.add(moduleFile); |
| if ((moduleFile.isEJBJarFile() || moduleFile.isApplicationClientFile()) && isMergeDependentJars()) |
| mergeDependentJars(moduleFile, nature.getProject()); |
| } catch (OpenFailureException oe) { |
| //this was causing problems in import when a project |
| //does not have a dd |
| //String message = ResourceHandler.getString("UNABLE_TO_LOAD_MODULE_ERROR_",new |
| // Object[] {uri,getProject().getName(),oe.getConcatenatedMessages()}); |
| // //$NON-NLS-1$ |
| //throw new ArchiveRuntimeException(message, oe); |
| } catch (RuntimeException runtime) { |
| String message = EARArchiveOpsResourceHandler.getString("UNABLE_TO_LOAD_MODULE_ERROR_", new Object[]{uri, getProject().getName(), runtime.toString()}); //$NON-NLS-1$ |
| throw new ArchiveRuntimeException(message, runtime); |
| } |
| } |
| } |
| |
| protected void setIncludeProjectMetaFiles(Archive anArchive) { |
| LoadStrategy strategy = anArchive.getLoadStrategy(); |
| if (strategy instanceof J2EELoadStrategyImpl) |
| ((J2EELoadStrategyImpl) strategy).setIncludeProjectMetaFiles(includeProjectMetaFiles); |
| } |
| |
| /** |
| * For each loose utility JAR project in this ear project, add an Archive to the list of files |
| * in the EAR |
| */ |
| public void addLooseUtilityJARsToFiles() { |
| EAREditModel editModel = null; |
| try { |
| editModel = getEARNature().getEarEditModelForRead(this); |
| List utilMaps = editModel.getUtilityJARMappings(); |
| |
| Map existingFiles = getFilesListMapped(); |
| for (int i = 0; i < utilMaps.size(); i++) { |
| UtilityJARMapping map = (UtilityJARMapping) utilMaps.get(i); |
| String uri = map.getUri(); |
| String projectName = map.getProjectName(); |
| try { |
| Archive utilJAR = J2EEProjectUtilities.asArchive(uri, projectName, exportSource); |
| if (utilJAR == null) |
| continue; |
| setIncludeProjectMetaFiles(utilJAR); |
| if (existingFiles.containsKey(uri)) |
| filesList.remove(existingFiles.get(uri)); |
| filesList.add(utilJAR); |
| } catch (OpenFailureException oe) { |
| String message = EARArchiveOpsResourceHandler.getString("UNABLE_TO_LOAD_MODULE_ERROR_", new Object[]{uri, getProject().getName(), oe.getConcatenatedMessages()}); //$NON-NLS-1$ |
| org.eclipse.jem.util.logger.proxy.Logger.getLogger().logTrace(message); |
| } |
| } |
| } finally { |
| if (editModel != null) |
| editModel.releaseAccess(this); |
| } |
| } |
| |
| public void close() { |
| super.close(); |
| if (jarMergers == null) |
| return; |
| |
| for (int i = 0; i < jarMergers.size(); i++) { |
| ((DependentJarExportMerger) jarMergers.get(i)).release(); |
| } |
| } |
| |
| /** |
| * @see com.ibm.etools.archive.LoadStrategy |
| */ |
| public boolean contains(String uri) { |
| |
| try { |
| EARNatureRuntime.getRuntime(project); |
| return project.getFile(uri).exists(); //$NON-NLS-1$ |
| } catch (Exception e) { |
| throw new ArchiveRuntimeException(e.getMessage(), e); |
| } |
| } |
| |
| /* should never get called outside of runtime */ |
| protected boolean primContains(String uri) { |
| return false; |
| } |
| |
| public EARFile getEARFile() { |
| return (EARFile) getContainer(); |
| } |
| |
| protected EARNatureRuntime getEARNature() { |
| return EARNatureRuntime.getRuntime(project); |
| } |
| |
| /** |
| * save method comment. |
| */ |
| public WorkbenchURIConverter getEARURIConverter() { |
| EARNatureRuntime enr = EARNatureRuntime.getRuntime(project); |
| if (enr == null) |
| return null; |
| earURIConverter = (WorkbenchURIConverter) (enr.getResourceSet().getURIConverter()); |
| return earURIConverter; |
| } |
| |
| /** |
| * @see com.ibm.etools.archive.LoadStrategy |
| */ |
| public IFile getFileForURI(String uri) throws FileNotFoundException { |
| |
| try { |
| if (earURIConverter == null) |
| getEARURIConverter(); |
| IResource rfile = earURIConverter.getInputContainer().findMember(uri); |
| return (IFile) rfile; |
| } catch (Exception e) { |
| |
| String errorString = EARArchiveOpsResourceHandler.getString("ARCHIVE_OPERATION_FileNotFound") + uri; //$NON-NLS-1$ |
| throw new FileNotFoundException(errorString); |
| } |
| } |
| |
| /** |
| * @see com.ibm.etools.archive.LoadStrategy |
| */ |
| public java.util.List getFiles() { |
| |
| filesList.clear(); |
| try { |
| filesList = getFiles(java.util.Arrays.asList(project.members())); |
| addModulesToFiles(); |
| addLooseUtilityJARsToFiles(); |
| } catch (Exception exc) { |
| throw new ArchiveRuntimeException(EARArchiveOpsResourceHandler.getString("ARCHIVE_OPERATION_FilesFromProject"), exc); //$NON-NLS-1$ |
| } |
| return filesList; |
| } |
| |
| protected long getLastModified(IResource aResource) { |
| return aResource.getLocation().toFile().lastModified(); |
| } |
| |
| /** |
| * @see com.ibm.etools.archive.LoadStrategy |
| */ |
| private java.util.ArrayList getFiles(List projectResources) throws Exception { |
| if (projectResources.isEmpty()) { |
| return filesList; |
| } |
| Iterator iterator = projectResources.iterator(); |
| while (iterator.hasNext()) { |
| IResource res = (IResource) (iterator.next()); |
| if ((res.getType() == IResource.FILE)) { |
| if (isServerTargetFile(res)) |
| continue; |
| if (isProjectMetaFile(res) && !includeProjectMetaFiles) |
| continue; |
| if (isProjectSupportFile(res)) |
| continue; |
| File cFile = createFile(res.getProjectRelativePath().toString()); |
| cFile.setLastModified(getLastModified(res)); |
| if (cFile.isArchive()) |
| ((Archive) cFile).getOptions().setIsReadOnly(true); |
| |
| filesList.add(cFile); |
| } else { |
| getFiles(java.util.Arrays.asList(((IContainer) res).members())); |
| } |
| } |
| return filesList; |
| } |
| |
| protected boolean isProjectSupportFile(IResource res) { |
| //return (res.getProjectRelativePath().toString().equals(PROJECT_RUNTIME_URI) || res.getProjectRelativePath().toString().equals(J2EE_SETTING_URI)); |
| return (res.getProjectRelativePath().toString().equals(PROJECT_RUNTIME_URI)); |
| } |
| |
| protected boolean isProjectMetaFile(IResource res) { |
| return (res.getProjectRelativePath().toString().equals(EAREditModel.MODULE_MAP_URI) || res.getProjectRelativePath().toString().equals(PROJECT_FILE_URI)); |
| } |
| |
| protected boolean isServerTargetFile(IResource res) { |
| return res.getProjectRelativePath().toString().endsWith(IServerTargetConstants.SERVER_FILE_NAME); |
| } |
| |
| protected Map getFilesListMapped() { |
| Map existingFiles = new HashMap(); |
| for (int i = 0; i < filesList.size(); i++) { |
| existingFiles.put(((File) filesList.get(i)).getURI(), filesList.get(i)); |
| } |
| return existingFiles; |
| } |
| |
| /** |
| * @see com.ibm.etools.archive.LoadStrategy |
| */ |
| public java.io.InputStream getInputStream(String uri) throws java.io.IOException, java.io.FileNotFoundException { |
| |
| IFile file = getFileForURI(uri); |
| if (!(file == null) && (file.exists())) { |
| try { |
| return file.getContents(true); |
| } catch (CoreException e) { |
| String errorString = EARArchiveOpsResourceHandler.getString("ARCHIVE_OPERATION_FileContents");//$NON-NLS-1$ |
| throw new IOException(errorString); |
| } |
| |
| } |
| String eString = EARArchiveOpsResourceHandler.getString("ARCHIVE_OPERATION_FileNotFound");//$NON-NLS-1$ |
| throw new FileNotFoundException(eString); |
| } |
| |
| protected List getJarMergers() { |
| if (jarMergers == null) |
| jarMergers = new ArrayList(); |
| |
| return jarMergers; |
| } |
| |
| /** |
| * Insert the method's description here. Creation date: (8/28/2001 5:02:59 PM) |
| * |
| * @return org.eclipse.core.resources.IProject |
| */ |
| public org.eclipse.core.resources.IProject getProject() { |
| return project; |
| } |
| |
| public boolean isClassLoaderNeeded() { |
| return false; |
| } |
| |
| /** |
| * Insert the method's description here. Creation date: (6/29/2001 12:51:40 PM) |
| * |
| * @return boolean |
| */ |
| public boolean isExportSource() { |
| return exportSource; |
| } |
| |
| /** |
| * Insert the method's description here. Creation date: (8/28/2001 5:50:40 PM) |
| * |
| * @return boolean |
| */ |
| public boolean isMergeDependentJars() { |
| return mergeDependentJars; |
| } |
| |
| protected void mergeDependentJars(Archive moduleFile, IProject aProject) { |
| DependentJarExportMerger merger = new DependentJarExportMerger(moduleFile, aProject, isExportSource()); |
| getJarMergers().add(merger); |
| merger.merge(); |
| } |
| |
| /** |
| * Insert the method's description here. Creation date: (6/29/2001 12:51:40 PM) |
| * |
| * @param newExportSource |
| * boolean |
| */ |
| public void setExportSource(boolean newExportSource) { |
| exportSource = newExportSource; |
| } |
| |
| /** |
| * Insert the method's description here. Creation date: (8/28/2001 5:50:40 PM) |
| * |
| * @param newMergeDependentJars |
| * boolean |
| */ |
| public void setMergeDependentJars(boolean newMergeDependentJars) { |
| mergeDependentJars = newMergeDependentJars; |
| } |
| |
| /** |
| * Insert the method's description here. Creation date: (11/08/00 5:20:53 PM) |
| * |
| * @param newProject |
| * com.ibm.itp.core.api.resources.IProject |
| */ |
| public void setProject(IProject newProject) { |
| project = newProject; |
| } |
| |
| /** |
| * Returns the includeProjectMetaFiles. |
| * |
| * @return boolean |
| */ |
| public boolean shouldIncludeProjectMetaFiles() { |
| return includeProjectMetaFiles; |
| } |
| |
| |
| /** |
| * Sets the includeProjectMetaFiles. |
| * |
| * @param includeProjectMetaFiles |
| * The includeProjectMetaFiles to set |
| */ |
| public void setIncludeProjectMetaFiles(boolean includeProjectMetaFiles) { |
| this.includeProjectMetaFiles = includeProjectMetaFiles; |
| } |
| |
| /** |
| * @see com.ibm.etools.archive.impl.LoadStrategyImpl#openNestedArchive(String) |
| */ |
| protected Archive openNestedArchive(String uri) { |
| IFile aFile = project.getFile(uri); |
| if (aFile == null || !aFile.exists()) |
| return null; |
| java.io.File ioFile = aFile.getLocation().toFile(); |
| Archive result = null; |
| try { |
| LoadStrategy lStrat = getArchiveFactory().createLoadStrategy(ioFile.getAbsolutePath()); |
| ArchiveOptions opts = getEARFile().getOptions().cloneWith(lStrat); |
| result = ((CommonarchivePackage) EPackage.Registry.INSTANCE.getEPackage(CommonarchivePackage.eNS_URI)).getCommonarchiveFactory().openArchive(opts, uri); |
| } catch (OpenFailureException ex) { |
| Logger.getLogger().logError(ex); |
| } catch (IOException ex) { |
| Logger.getLogger().logError(ex); |
| } |
| return result; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jst.j2ee.internal.internal.commonarchivecore.strategy.LoadStrategyImpl#initializeResourceSet() |
| */ |
| protected void initializeResourceSet() { |
| resourceSet = WorkbenchResourceHelper.getResourceSet(project); |
| } |
| |
| /* |
| * Overrode from super to bypass SAX |
| */ |
| protected Registry createResourceFactoryRegistry() { |
| return new J2EEResourceFactoryRegistry(); |
| } |
| |
| } |
