/*******************************************************************************
* Copyright (c) 2003, 2007 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;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;
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.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.emf.common.util.URI;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jst.common.internal.modulecore.SingleRootUtil;
import org.eclipse.jst.j2ee.classpathdep.IClasspathDependencyConstants;
import org.eclipse.jst.j2ee.componentcore.J2EEModuleVirtualComponent;
import org.eclipse.jst.j2ee.internal.J2EEConstants;
import org.eclipse.jst.j2ee.internal.archive.operations.EARArchiveOpsResourceHandler;
import org.eclipse.jst.j2ee.internal.classpathdep.ClasspathDependencyManifestUtil;
import org.eclipse.jst.j2ee.internal.classpathdep.ClasspathDependencyVirtualComponent;
import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
import org.eclipse.jst.jee.archive.AbstractArchiveLoadAdapter;
import org.eclipse.jst.jee.archive.ArchiveModelLoadException;
import org.eclipse.jst.jee.archive.IArchive;
import org.eclipse.jst.jee.archive.IArchiveLoadAdapter;
import org.eclipse.jst.jee.archive.IArchiveResource;
import org.eclipse.jst.jee.archive.internal.ArchiveURIConverter;
import org.eclipse.jst.jee.archive.internal.ArchiveUtil;
import org.eclipse.wst.common.componentcore.UnresolveableURIException;
import org.eclipse.wst.common.componentcore.internal.ComponentResource;
import org.eclipse.wst.common.componentcore.internal.DependencyType;
import org.eclipse.wst.common.componentcore.internal.StructureEdit;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualContainer;
import org.eclipse.wst.common.componentcore.resources.IVirtualFile;
import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
import org.eclipse.wst.common.componentcore.resources.IVirtualResource;
public abstract class ComponentArchiveLoadAdapter extends AbstractArchiveLoadAdapter {
protected static final String DOT_SQLJ = ".sqlj"; //$NON-NLS-1$
protected static final String DOT_JSP = ".jsp"; //$NON-NLS-1$
protected static final String DOT_PROJECT = ".project"; //$NON-NLS-1$
protected static final String DOT_CLASSPATH = ".classpath"; //$NON-NLS-1$
protected static final String DOT_SETTINGS = ".settings"; //$NON-NLS-1$
protected static final String DOT_CVS_IGORE = ".cvsignore"; //$NON-NLS-1$
protected IVirtualComponent vComponent;
protected boolean exportSource = true;
protected boolean optimizeMembers = false;
private List<ZipFile> zipFiles = new ArrayList<ZipFile>();
private List<String> javaClasspathURIs = new ArrayList<String>();
protected boolean includeClasspathComponents = true;
protected class FilesHolder {
private Map<IPath, IArchiveResource> pathsToArchiveResources = new HashMap<IPath, IArchiveResource>();
private Map<IPath, IResource> pathsToWorkbenchResources = new HashMap<IPath, IResource>();
private Map<IResource, IPath> workbenchResourcesToPaths = new HashMap<IResource, IPath>();
private Map<IPath, java.io.File> pathsToDiskFiles = new HashMap<IPath, java.io.File>();
private Map pathsToZipEntry = new HashMap();
public void removeIFile(IFile file) {
IPath path = workbenchResourcesToPaths.get(file);
remove(path);
}
public void remove(IPath path) {
pathsToArchiveResources.remove(path);
Object resource = pathsToWorkbenchResources.remove(path);
if (resource != null) {
workbenchResourcesToPaths.remove(resource);
}
pathsToDiskFiles.remove(path);
}
public void addFile(IArchiveResource file) {
IPath path = file.getPath();
pathsToArchiveResources.put(path, file);
}
public void addFile(IArchiveResource file, java.io.File externalDiskFile) {
IPath path = file.getPath();
pathsToArchiveResources.put(path, file);
pathsToDiskFiles.put(path, externalDiskFile);
}
public void addFile(IArchiveResource file, IResource resource) {
IPath path = file.getPath();
pathsToArchiveResources.put(path, file);
pathsToWorkbenchResources.put(path, resource);
}
public InputStream getInputStream(IPath path) throws IOException, FileNotFoundException {
java.io.File diskFile = null;
if (pathsToDiskFiles.containsKey(path)) {
diskFile = pathsToDiskFiles.get(path);
} else if (pathsToWorkbenchResources.containsKey(path)) {
IResource resource = pathsToWorkbenchResources.get(path);
diskFile = new java.io.File(resource.getLocation().toOSString());
}
if (diskFile != null) {
return new FileInputStream(diskFile);
} else if (pathsToZipEntry.containsKey(path)) {
Map fileURIMap = (Map) pathsToZipEntry.get(path);
Iterator it = fileURIMap.keySet().iterator();
String sourceFileUri = ""; //$NON-NLS-1$
ZipFile zipFile = null;
// there is only one key, pair
while (it.hasNext()) {
sourceFileUri = (String) it.next();
zipFile = (ZipFile) fileURIMap.get(sourceFileUri);
}
if(zipFile != null){
ZipEntry entry = zipFile.getEntry(sourceFileUri);
InputStream in = zipFile.getInputStream(entry);
return in;
}
throw new IOException();
} else {
IArchiveResource res = getArchiveResource(path);
return ComponentArchiveLoadAdapter.this.getSuperInputStream(res);
}
}
public List<IArchiveResource> getFiles() {
return new ArrayList<IArchiveResource>(pathsToArchiveResources.values());
}
public boolean contains(IPath path) {
return pathsToArchiveResources.containsKey(path);
}
public IArchiveResource getArchiveResource(IPath path) {
return pathsToArchiveResources.get(path);
}
public void addEntry(ZipEntry entry, ZipFile zipFile, IPath runtimePath) {
IPath innerRuntimePath = runtimePath;
if (innerRuntimePath != null) {
if (!innerRuntimePath.equals("/")) //$NON-NLS-1$
innerRuntimePath = innerRuntimePath.append(entry.getName());
else
innerRuntimePath = new Path(entry.getName());
} else {
innerRuntimePath = new Path(entry.getName());
}
IArchiveResource file = createFile(innerRuntimePath);
Map<String, ZipFile> fileURIMap = new HashMap<String, ZipFile>();
fileURIMap.put(entry.getName(), zipFile);
pathsToZipEntry.put(file.getPath(), fileURIMap);
pathsToArchiveResources.put(file.getPath(), file);
}
}
protected FilesHolder filesHolder;
private IVirtualFile manifestFile = null;
public ComponentArchiveLoadAdapter(IVirtualComponent vComponent) {
this(vComponent, true);
}
public ComponentArchiveLoadAdapter(IVirtualComponent vComponent, boolean includeClasspathComponents) {
this.vComponent = vComponent;
filesHolder = new FilesHolder();
setIncludeClasspathComponents(includeClasspathComponents);
}
public void setIncludeClasspathComponents(boolean includeClasspathComponents) {
this.includeClasspathComponents = includeClasspathComponents;
if (includeClasspathComponents) {
this.manifestFile = vComponent.getRootFolder().getFile(new Path(J2EEConstants.MANIFEST_URI));
saveJavaClasspathReferences();
} else {
this.manifestFile = null;
javaClasspathURIs.clear();
}
}
@Override
public IArchiveResource getArchiveResource(IPath resourcePath) throws FileNotFoundException {
initArchiveResource(resourcePath);
return filesHolder.getArchiveResource(resourcePath);
}
@Override
public boolean containsArchiveResource(IPath path) {
initArchiveResource(path);
return filesHolder.contains(path);
}
/**
* Will lazily initialize File type ArchiveResources contained in the component structure without loading the entire
* archive. If the File can not be found, then the entire structure will be loaded.
* @param resourcePath
*/
protected void initArchiveResource(IPath resourcePath) {
if(archiveResourcesInitialized) {
//if the entire archive has been initialized, there is no need to repeat
return;
}
if(filesHolder.contains(resourcePath)){
//if the archive already knows about the resource return
return;
}
initSourceRoots();
// want to be quick if possible, so only try to load from the component structure
// if the file is not present there, then look everywhere
IVirtualFolder rootFolder = vComponent.getRootFolder();
IVirtualFile vFile = rootFolder.getFile(resourcePath);
if (vFile.exists()) {
IPath runtimePath = vFile.getRuntimePath();
if (runtimePath != null){
runtimePath = runtimePath.setDevice(null).makeRelative();
if(runtimePath.equals(resourcePath)){
boolean inJavaSrc = inJavaSrc(vFile);
if(aggregateResource(vFile, runtimePath, inJavaSrc, IArchiveResource.FILE_TYPE) != null){
return; //found the file and added it
}
}
}
}
//if it was not found above then do the full initialize
initArchiveResources();
}
protected boolean sourceRootsInitialized = false;
protected void initSourceRoots() {
if(!sourceRootsInitialized){
sourceRootsInitialized = true;
try {
IPackageFragmentRoot[] srcPkgs = J2EEProjectUtilities.getSourceContainers(vComponent.getProject());
sourceRoots = new IResource[srcPkgs.length];
for (int i = 0; i < srcPkgs.length; i++) {
sourceRoots[i] = srcPkgs[i].getCorrespondingResource();
}
inJavaSrc = false;
} catch (CoreException e) {
J2EEPlugin.logError(e);
}
}
}
protected boolean archiveResourcesInitialized = false;
protected boolean membersOptimized = false;
protected void initArchiveResources() {
if (!archiveResourcesInitialized) {
archiveResourcesInitialized = true;
if (shouldOptimize()) {
attemptOptimization();
}
if (!membersOptimized) {
aggregateSourceFiles();
aggregateClassFiles();
}
addUtilities();
}
}
protected void attemptOptimization() {
SingleRootUtil util = new SingleRootUtil(getComponent());
IContainer rootContainer = util.getSingleRoot();
if (rootContainer != null) {
try {
membersOptimized = true;
optimizeMembers(Path.EMPTY, rootContainer);
} catch (CoreException e) {
J2EEPlugin.logError(e);
}
}
}
@Override
public List<IArchiveResource> getArchiveResources() {
initArchiveResources();
return filesHolder.getFiles();
}
public IResource getWorkbenchResources(IPath path) {
return filesHolder.pathsToWorkbenchResources.get(path);
}
public File getExternalFiles(IPath path) {
return filesHolder.pathsToDiskFiles.get(path);
}
/**
* Adds library cp entries that point to class folders and have been tagged with the publish/export attribute.
*/
protected void addMappedClassFolders(final IPath targetRuntimePath) {
// retrieve all mapped class folders
if (vComponent instanceof J2EEModuleVirtualComponent) {
try {
final J2EEModuleVirtualComponent j2eeComponent = (J2EEModuleVirtualComponent) vComponent;
final IVirtualReference[] cpRefs = j2eeComponent.getJavaClasspathReferences();
for (int j = 0; j < cpRefs.length; j++) {
final IVirtualReference ref = cpRefs[j];
final IPath runtimePath = ref.getRuntimePath();
// only process mappings with the specified runtime path
if (ref.getReferencedComponent() instanceof ClasspathDependencyVirtualComponent) {
if (runtimePath.equals(targetRuntimePath) || runtimePath.equals(IClasspathDependencyConstants.WEB_INF_CLASSES_PATH)) {
final ClasspathDependencyVirtualComponent comp = (ClasspathDependencyVirtualComponent) ref.getReferencedComponent();
if (comp.isClassFolder()) {
final IContainer classFolder = comp.getClassFolder();
if (classFolder != null && classFolder.exists()) {
aggregateOutputFiles(new IResource[]{classFolder}, runtimePath.makeRelative(), classFolder.getProjectRelativePath().segmentCount());
}
}
}
}
}
} catch (CoreException e) {
J2EEPlugin.logError(e);
}
}
}
protected void saveJavaClasspathReferences() {
if (vComponent instanceof J2EEModuleVirtualComponent) {
final J2EEModuleVirtualComponent j2eeComp = (J2EEModuleVirtualComponent) vComponent;
final IVirtualReference[] refs = j2eeComp.getJavaClasspathReferences();
if (refs == null) {
return;
}
for (int i = 0; i < refs.length; i++) {
if (refs[i].getRuntimePath().equals(IClasspathDependencyConstants.RUNTIME_MAPPING_INTO_CONTAINER_PATH)) {
javaClasspathURIs.add(refs[i].getArchiveName());
}
}
}
}
protected void addUtilities() {
IVirtualReference[] components = vComponent.getReferences();
for (int i = 0; i < components.length; i++) {
IVirtualReference reference = components[i];
IVirtualComponent referencedComponent = reference.getReferencedComponent();
if (referencedComponent.isBinary() && reference.getDependencyType() == DependencyType.CONSUMES) {
java.io.File diskFile = (java.io.File) referencedComponent.getAdapter(java.io.File.class);
ZipFile zipFile;
IPath path = reference.getRuntimePath();
try {
zipFile = ArchiveUtil.newZipFile(diskFile);
zipFiles.add(zipFile);
Enumeration enumeration = zipFile.entries();
while (enumeration.hasMoreElements()) {
ZipEntry entry = (ZipEntry) enumeration.nextElement();
filesHolder.addEntry(entry, zipFile, path);
}
} catch (ZipException e) {
J2EEPlugin.logError(e);
} catch (IOException e) {
J2EEPlugin.logError(e);
}
}
}
}
/**
* This is a cache of the IResource roots for all java source folders and is
* used by {@link #inJavaSrc(IVirtualResource)}.
*/
private IResource[] sourceRoots = null;
protected void aggregateSourceFiles() {
try {
initSourceRoots();
IVirtualFolder rootFolder = vComponent.getRootFolder();
IVirtualResource[] members = rootFolder.members();
inJavaSrc = false;
aggregateFiles(members);
} catch (CoreException e) {
J2EEPlugin.logError(e);
}
}
protected void aggregateClassFiles() {
StructureEdit se = null;
try {
IPackageFragmentRoot[] sourceRoots = J2EEProjectUtilities.getSourceContainers(vComponent.getProject());
se = StructureEdit.getStructureEditForRead(vComponent.getProject());
for (int i = 0; i < sourceRoots.length; i++) {
IPath outputPath = sourceRoots[i].getRawClasspathEntry().getOutputLocation();
if (outputPath == null) {
IProject project = vComponent.getProject();
if (project.hasNature(JavaCore.NATURE_ID)) {
IJavaProject javaProject = JavaCore.create(project);
outputPath = javaProject.getOutputLocation();
}
}
if (outputPath != null) {
IContainer javaOutputContainer = outputPath.segmentCount() > 1 ? (IContainer) ResourcesPlugin.getWorkspace().getRoot().getFolder(outputPath) : (IContainer) ResourcesPlugin
.getWorkspace().getRoot().getProject(outputPath.lastSegment());
IPath runtimePath = null;
try {
ComponentResource[] componentResources = se.findResourcesBySourcePath(sourceRoots[i].getResource().getProjectRelativePath());
if (componentResources.length > 0) {
IPath tmpRuntimePath = componentResources[0].getRuntimePath();
IPath tmpSourcePath = componentResources[0].getSourcePath();
if (!tmpRuntimePath.equals(tmpSourcePath)) {
while (tmpSourcePath.segmentCount() > 0 && tmpRuntimePath.segmentCount() > 0 && tmpRuntimePath.lastSegment().equals(tmpSourcePath.lastSegment())) {
tmpRuntimePath = tmpRuntimePath.removeLastSegments(1);
tmpSourcePath = tmpSourcePath.removeLastSegments(1);
}
if (tmpRuntimePath.segmentCount() != 0) {
runtimePath = tmpRuntimePath.makeRelative();
}
}
}
} catch (UnresolveableURIException e) {
J2EEPlugin.logError(e);
}
if (null == runtimePath) {
runtimePath = new Path(""); //$NON-NLS-1$
}
aggregateOutputFiles(new IResource[] { javaOutputContainer }, runtimePath, javaOutputContainer.getProjectRelativePath().segmentCount());
}
}
} catch (CoreException e) {
J2EEPlugin.logError(e);
} finally {
if (se != null) {
se.dispose();
}
}
}
protected boolean aggregateOutputFiles(IResource[] resources, final IPath runtimePathPrefix, int outputFolderSegmentCount) throws CoreException {
boolean fileAdded = false;
for (int i = 0; i < resources.length; i++) {
IArchiveResource cFile = null;
if (!resources[i].exists()) {
continue;
}
// We have to avoid duplicates between the source and output folders
// (non-java
// resources)
IPath runtimePath = runtimePathPrefix.append(resources[i].getProjectRelativePath().removeFirstSegments(outputFolderSegmentCount));
if (runtimePath == null)
continue;
if (resources[i].getType() == IResource.FILE) {
if (!shouldInclude(runtimePath))
continue;
cFile = createFile(runtimePath);
cFile.setLastModified(getLastModified(resources[i]));
filesHolder.addFile(cFile, resources[i]);
fileAdded = true;
} else if (shouldInclude((IContainer) resources[i])) {
IResource[] nestedResources = ((IContainer) resources[i]).members();
aggregateOutputFiles(nestedResources, runtimePathPrefix, outputFolderSegmentCount);
if (!filesHolder.contains(runtimePath)) {
if (!shouldInclude(runtimePath))
continue;
cFile = createDirectory(runtimePath);
cFile.setLastModified(getLastModified(resources[i]));
filesHolder.addFile(cFile, resources[i]);
fileAdded = true;
}
}
}
return fileAdded;
}
/**
* This is used to track whether {@link #aggregateFiles(IVirtualResource[])}
* is currently within a Java Source folder.
*/
private boolean inJavaSrc = false;
protected boolean aggregateFiles(IVirtualResource[] virtualResources) throws CoreException {
boolean fileAdded = false;
for (int i = 0; i < virtualResources.length; i++) {
if (!virtualResources[i].exists()) {
continue;
}
// We have to avoid duplicates between the source and output folders
// (non-java
// resources)
IPath runtimePath = virtualResources[i].getRuntimePath();
if (runtimePath == null)
continue;
runtimePath = runtimePath.setDevice(null).makeRelative();
if (filesHolder.contains(runtimePath))
continue;
if (virtualResources[i].getType() == IVirtualResource.FILE) {
if(aggregateResource(virtualResources[i], runtimePath, inJavaSrc, IArchiveResource.FILE_TYPE) != null){
fileAdded = true;
}
} else if (shouldInclude((IVirtualContainer) virtualResources[i])) {
boolean inJavaSrcAtThisLevel = inJavaSrc;
try {
if (!inJavaSrc) {
// if not already inside a Java src dir, check again
inJavaSrc = inJavaSrc(virtualResources[i]);
}
IVirtualResource[] nestedVirtualResources = ((IVirtualContainer) virtualResources[i]).members();
aggregateFiles(nestedVirtualResources);
if (!filesHolder.contains(runtimePath)) {
if(aggregateResource(virtualResources[i], runtimePath, inJavaSrc, IArchiveResource.DIRECTORY_TYPE) != null){
fileAdded = true;
}
}
} finally {
inJavaSrc = inJavaSrcAtThisLevel;
}
}
}
return fileAdded;
}
protected IArchiveResource aggregateResource(IVirtualResource virtualResource, IPath runtimePath, boolean inJavaSrc, int archiveResourceType){
if (!shouldInclude(runtimePath)){
return null;
}
IResource resource = virtualResource.getUnderlyingResource();
// want to ignore derived resources nested within Java src
// directories; this covers the case where
// a user has nested a Java output directory within a Java src
// directory (note: should ideally be
// respecting Java src path exclusion filters)
if (inJavaSrc && resource.isDerived()) {
return null;
}
IArchiveResource cFile = null;
switch(archiveResourceType){
case IArchiveResource.FILE_TYPE:
cFile = createFile(runtimePath);
break;
case IArchiveResource.DIRECTORY_TYPE:
cFile = createDirectory(runtimePath);
break;
default:
return null;
}
cFile.setLastModified(getLastModified(resource));
filesHolder.addFile(cFile, resource);
return cFile;
}
/**
* Determines if the specified IVirtualResource maps to a IResource that is
* contained within a Java src root.
*
* @param virtualResource
* IVirtualResource to check.
* @param sourceRoots
* Current Java src roots.
* @return True if contained in a Java src root, false otherwise.
*/
protected boolean inJavaSrc(final IVirtualResource virtualResource) {
if (sourceRoots.length == 0) {
return false;
}
// all mapped resources must be associated with Java src for the
// resource to be considered in Java src
final IResource[] resources = virtualResource.getUnderlyingResources();
boolean inJavaSrc = false;
for (int i = 0; i < resources.length; i++) {
inJavaSrc = false;
for (int j = 0; j < sourceRoots.length; j++) {
if (sourceRoots[j].getFullPath().isPrefixOf(resources[i].getFullPath())) {
inJavaSrc = true;
break;
}
}
// if this one was not in Java src, can break
if (!inJavaSrc) {
break;
}
}
return inJavaSrc;
}
protected long getLastModified(IResource aResource) {
return aResource.getLocation().toFile().lastModified();
}
protected void optimizeMembers(IPath path, IContainer container) throws CoreException {
IResource[] resources;
resources = container.members();
if (resources != null) {
int size = resources.length;
for (int i = 0; i < size; i++) {
IResource resource = resources[i];
IArchiveResource cFile = null;
if (resource != null && resource.exists()) {
IPath deployPath = path.append(resource.getName());
if (filesHolder.contains(deployPath)) {
continue;
}
if (resource instanceof IContainer) {
IContainer container2 = (IContainer) resource;
cFile = createDirectory(deployPath);
optimizeMembers(deployPath, container2);
} else if ((resource instanceof IFile) && (isExportSource() || !isSource(deployPath))) {
cFile = createFile(deployPath);
}
}
if (cFile != null) {
cFile.setLastModified(getLastModified(resource));
filesHolder.addFile(cFile, resource);
}
}
}
}
public void setExportSource(boolean newExportSource) {
exportSource = newExportSource;
}
public boolean isExportSource() {
return exportSource;
}
public void setOptimize(boolean optimize) {
optimizeMembers = optimize;
}
public boolean shouldOptimize() {
return optimizeMembers;
}
public boolean shouldUpdateManifest(IArchiveResource archiveResource) {
IPath path = archiveResource.getPath();
if (includeClasspathComponents && path.equals(new Path(J2EEConstants.MANIFEST_URI)) && !javaClasspathURIs.isEmpty() && manifestFile != null
&& manifestFile.getUnderlyingFile() != null && manifestFile.getUnderlyingFile().exists()) {
return true;
}
return false;
}
protected boolean shouldInclude(IContainer aContainer) {
return true;
}
protected boolean shouldInclude(IVirtualContainer vContainer) {
IContainer iContainer = (IContainer) vContainer.getUnderlyingResource();
return shouldInclude(iContainer);
}
// TODO add a mechanism for ignoring specific file types
protected boolean shouldInclude(IPath path) {
String lastSegment = path.lastSegment();
if (null == lastSegment) {
return false;
}
if (lastSegment.endsWith(DOT_PROJECT) || lastSegment.endsWith(DOT_CLASSPATH) || lastSegment.endsWith(DOT_CVS_IGORE) || path.segment(0).startsWith(DOT_SETTINGS)) {
return false;
}
return isExportSource() || !isSource(path);
}
// TODO add a mechanism for ignoring specific file types
protected boolean isSource(IPath path) {
if (path == null)
return false;
return path.lastSegment().endsWith(JavaEEArchiveUtilities.DOT_JAVA) || path.lastSegment().endsWith(DOT_SQLJ);
}
protected void addExternalFile(IPath path, java.io.File externalDiskFile) {
IArchiveResource aFile = createFile(path);
filesHolder.addFile(aFile, externalDiskFile);
}
protected InputStream getSuperInputStream(IArchiveResource archiveResource) throws IOException, FileNotFoundException {
if (archiveResource.getType() == IArchive.ARCHIVE_TYPE) {
IArchiveLoadAdapter nestedLoadAdapter = ((IArchive)archiveResource).getLoadAdapter();
if(nestedLoadAdapter instanceof ComponentArchiveLoadAdapter){
((ComponentArchiveLoadAdapter)nestedLoadAdapter).setExportSource(isExportSource());
}
}
return super.getInputStream(archiveResource);
}
@Override
public InputStream getInputStream(IArchiveResource archiveResource) throws IOException, FileNotFoundException {
// If the MANIFEST.MF of a module component is being requested and that
// module component references
// Java build path-based components, need to dynamically update the
// manifest classpath to reflect the resolved
// contributions from the build path
if (shouldUpdateManifest(archiveResource)) {
// update the manifest classpath for the component
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ClasspathDependencyManifestUtil.updateManifestClasspath(manifestFile.getUnderlyingFile(), javaClasspathURIs, baos);
return new ByteArrayInputStream(baos.toByteArray());
}
IPath path = archiveResource.getPath();
if (filesHolder.contains(path)) {
return filesHolder.getInputStream(path);
}
IVirtualFolder rootFolder = vComponent.getRootFolder();
IVirtualResource vResource = rootFolder.findMember(path);
String filePath = null;
if (null != vResource && vResource.exists()) {
filePath = vResource.getUnderlyingResource().getLocation().toOSString();
java.io.File file = new java.io.File(filePath);
return new FileInputStream(file);
}
String eString = EARArchiveOpsResourceHandler.ARCHIVE_OPERATION_FileNotFound;
throw new FileNotFoundException(eString);
}
public IVirtualComponent getComponent() {
return vComponent;
}
protected JavaEEEMFArchiveAdapterHelper emfHelper = null;
protected void initEMFHelper() {
if (emfHelper == null) {
emfHelper = new JavaEEEMFArchiveAdapterHelper(getArchive());
emfHelper.setArchiveURIConverter(new ArchiveURIConverter(emfHelper.getArchive()) {
@Override
protected URI convertPathToURI(IPath modelObjectPath) {
// TODO find a better way to getplatformURI
IPath path = getComponent().getRootFolder().getFile(modelObjectPath).getUnderlyingFile().getFullPath();
return URI.createURI("platform:/resource/" + path.toString()); //$NON-NLS-1$
}
});
}
}
@Override
public boolean containsModelObject(IPath modelObjectPath) {
initEMFHelper();
IPath innerModelObjectPath = modelObjectPath;
if (IArchive.EMPTY_MODEL_PATH == innerModelObjectPath) {
innerModelObjectPath = getDefaultModelObjectPath();
}
return emfHelper.containsModelObject(innerModelObjectPath);
}
@Override
public Object getModelObject(IPath modelObjectPath) throws ArchiveModelLoadException {
initEMFHelper();
IPath innerModelObjectPath = modelObjectPath;
if (IArchive.EMPTY_MODEL_PATH == innerModelObjectPath) {
innerModelObjectPath = getDefaultModelObjectPath();
}
return emfHelper.getModelObject(innerModelObjectPath);
}
protected IPath getDefaultModelObjectPath() {
return new Path("/"); //$NON-NLS-1$
}
@Override
public String toString() {
int packageLength = this.getClass().getPackage().getName().length() + 1;
StringBuffer buffer = new StringBuffer(this.getClass().getName().substring(packageLength));
buffer.append(", Component: "); //$NON-NLS-1$
buffer.append(getComponent());
return buffer.toString();
}
/**
* protected IProgressMonitor monitor = null;
*
* public void setProgressMonitor(IProgressMonitor monitor){ this.monitor =
* monitor; }
*
* protected final int FILE_SAVE_WORK = 100;
*
* public FileIterator getFileIterator() throws IOException { return new
* FileIteratorImpl(getContainer().getFiles()){ protected SubProgressMonitor
* lastSubMon = null; boolean firstVisit = true;
*
* public File next() { if(firstVisit){ firstVisit = false; if(monitor !=
* null){
* monitor.beginTask(ProjectSupportResourceHandler.getString(ProjectSupportResourceHandler.Exporting_archive,
* new Object [] { getContainer().getURI() }), files.size() *
* FILE_SAVE_WORK); } } if(lastSubMon != null){ lastSubMon.done();
* lastSubMon = null; } else if(monitor != null){
* monitor.worked(FILE_SAVE_WORK); } File file = super.next(); if(monitor !=
* null){ if(file.isContainer() &&
* ComponentArchiveLoadAdapter.class.isInstance(((ContainerImpl)file).getLoadStrategy())){
* ComponentArchiveLoadAdapter ls =
* (ComponentArchiveLoadAdapter)((ContainerImpl)file).getLoadStrategy();
* lastSubMon = new SubProgressMonitor(monitor, FILE_SAVE_WORK,
* SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK);
* ls.setProgressMonitor(lastSubMon); } else {
* monitor.subTask(file.getURI()); } } return file; } }; }
*/
}