/*******************************************************************************
* Copyright (c) 2000, 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 API and implementation
*******************************************************************************/
package org.eclipse.update.internal.core;
import org.eclipse.update.core.FeatureContentProvider;
import java.io.*;
import java.net.URL;
import java.util.*;
import org.eclipse.core.runtime.*;
import org.eclipse.osgi.signedcontent.SignedContentFactory;
import org.eclipse.osgi.util.NLS;
import org.eclipse.update.core.*;
import org.eclipse.update.internal.jarprocessor.JarProcessor;
import org.eclipse.update.internal.jarprocessor.Utils;
import org.eclipse.update.internal.security.JarVerifier;
import org.eclipse.update.internal.verifier.CertVerifier;
/**
* Content Provider of a Feature Package
*/
public class FeaturePackagedContentProvider extends FeatureContentProvider {
private ContentReference localManifest = null;
private ContentReference[] localFeatureFiles = new ContentReference[0];
private IVerifier jarVerifier = null;
private ExtendedSite siteModel = null;
private boolean continueOnError;
/*
* filter for file with .jar
*/
public static final FilenameFilter filter = new FilenameFilter() {
public boolean accept(File dir, String name) {
return name.endsWith(FeatureContentProvider.JAR_EXTENSION);
}
};
/*
* Constructor
*/
public FeaturePackagedContentProvider(URL url, ISite site) {
super(url);
if (site instanceof ExtendedSite) {
this.siteModel = (ExtendedSite) site;
}
}
/*
* Returns a new verifier for each top-level install
* (if the verifier has a parent, return the verifier
* otherwise reinitialize)
*/
public IVerifier getVerifier() throws CoreException {
SignedContentFactory factory = UpdateCore.getPlugin().getSignedContentFactory();
if (jarVerifier == null || jarVerifier.getParent() == null) {
if (factory != null)
jarVerifier = new CertVerifier(UpdateCore.getPlugin().getSignedContentFactory());
else
jarVerifier = new JarVerifier();
return jarVerifier;
}
// re-init will be done if the parent changes
return jarVerifier;
}
/*
* @see IFeatureContentProvider#getFeatureManifestReference()
*/
public ContentReference getFeatureManifestReference(InstallMonitor monitor) throws CoreException {
// check to see if we already have local copy of the manifest
if (localManifest != null)
return localManifest;
ContentReference[] featureArchiveReference = getFeatureEntryArchiveReferences(monitor);
JarContentReference featureJarReference = null;
try {
// force feature archive to local.
// This content provider always assumes exactly 1 archive file (index [0])
featureJarReference = (JarContentReference) asLocalReference(featureArchiveReference[0], null);
// we need to unpack archive locally for UI browser references to be resolved correctly
localFeatureFiles = featureJarReference.unpack(getWorkingDirectory(), null, monitor);
} catch (IOException e) {
throw errorRetrieving(Feature.FEATURE_XML, featureJarReference, e);
}
// find the manifest in the unpacked feature files
for (int i = 0; i < localFeatureFiles.length; i++) {
if (localFeatureFiles[i].getIdentifier().equals(Feature.FEATURE_XML)) {
localManifest = localFeatureFiles[i];
// cache reference to manifest
return localManifest;
}
}
// the manifest has not been found
String[] values = new String[] { Feature.FEATURE_XML, getURL().toExternalForm()};
throw Utilities.newCoreException(NLS.bind(Messages.FeaturePackagedContentProvider_NoManifestFile, values), new Exception());
}
/*
* @see IFeatureContentProvider#getArchiveReferences()
*/
public ContentReference[] getArchiveReferences(InstallMonitor monitor) throws CoreException {
IPluginEntry[] entries = getFeature().getPluginEntries();
INonPluginEntry[] nonEntries = getFeature().getNonPluginEntries();
List listAllContentRef = new ArrayList();
ContentReference[] allContentRef = new ContentReference[0];
// feature
listAllContentRef.addAll(Arrays.asList(getFeatureEntryArchiveReferences(monitor)));
// plugins
for (int i = 0; i < entries.length; i++) {
listAllContentRef.addAll(Arrays.asList(getPluginEntryArchiveReferences(entries[i], monitor)));
}
// non plugins
for (int i = 0; i < nonEntries.length; i++) {
listAllContentRef.addAll(Arrays.asList(getNonPluginEntryArchiveReferences(nonEntries[i], monitor)));
}
// transform List in Array
if (listAllContentRef.size() > 0) {
allContentRef = new ContentReference[listAllContentRef.size()];
listAllContentRef.toArray(allContentRef);
}
return allContentRef;
}
/*
* @see IFeatureContentProvider#getFeatureEntryArchiveReferences()
*/
public ContentReference[] getFeatureEntryArchiveReferences(InstallMonitor monitor) throws CoreException {
//1 jar file <-> 1 feature
// we will return the JAR file
ContentReference[] references = new ContentReference[1];
ContentReference currentReference = null;
String archiveID = null;
try {
archiveID = (getFeature() != null) ? getFeature().getVersionedIdentifier().toString() : ""; //$NON-NLS-1$
currentReference = new JarContentReference(archiveID, getURL());
currentReference = asLocalReference(currentReference, monitor);
references[0] = currentReference;
} catch (IOException e) {
references[0] = continueOnErrorOrRethrow(archiveID, e);
}
return references;
}
/*
* @see IFeatureContentProvider#getPluginEntryArchiveReferences(IPluginEntry)
*/
public ContentReference[] getPluginEntryArchiveReferences(IPluginEntry pluginEntry, InstallMonitor monitor) throws CoreException {
// 1 plugin <-> 1 jar
// we return the JAR file
ContentReference[] references = new ContentReference[1];
String archiveID = getPathID(pluginEntry);
ISite site = (getFeature() == null) ? null : getFeature().getSite();
ISiteContentProvider siteContentProvider = (site == null) ? null : site.getSiteContentProvider();
URL url = (siteContentProvider == null) ? null : siteContentProvider.getArchiveReference(archiveID);
try {
references[0] = retrieveLocalJar(new JarContentReference(archiveID, url), monitor);
} catch (IOException e) {
references[0] = continueOnErrorOrRethrow(archiveID, e);
}
return references;
}
private ContentReference retrieveLocalJar(JarContentReference reference, InstallMonitor monitor) throws IOException, CoreException {
//If the site does not support pack200, just get the jar as normal
if(siteModel == null || !siteModel.supportsPack200() || !JarProcessor.canPerformUnpack()) {
ContentReference contentReference = null;
try {
contentReference = asLocalReference(reference, monitor);
}
catch (FileNotFoundException e) {
contentReference = continueOnErrorOrRethrow(reference.getIdentifier(), e);
}
catch (IOException e) {
contentReference = continueOnErrorOrRethrow(reference.getIdentifier(), e);
}
catch (CoreException e) {
contentReference = continueOnErrorOrRethrow(reference.getIdentifier(), e);
}
return contentReference;
}
ContentReference packedRef = null;
String key = reference.toString();
Object jarLock = LockManager.getLock(key);
synchronized (jarLock) {
//do we have this jar already?
File localFile = Utilities.lookupLocalFile(key);
if (localFile != null) {
// check if the cached file is still valid (no newer version on server)
if (UpdateManagerUtils.isSameTimestamp(reference.asURL(), localFile.lastModified())) {
LockManager.returnLock(key);
return reference.createContentReference(reference.getIdentifier(), localFile);
}
}
try {
//don't have jar, check for pack.gz
URL packGZURL = new URL(reference.asURL().toExternalForm() + ".pack.gz"); //$NON-NLS-1$
packedRef = asLocalReference(new JarContentReference(reference.getIdentifier(), packGZURL), monitor);
} catch (IOException e) {
//no pack.gz
} catch (CoreException e){
//no pack.gz
}
}
if (packedRef == null) {
//no pack.gz on server, get normal jar
ContentReference contentReference = null;
try {
contentReference = asLocalReference(reference, monitor);
}
catch (FileNotFoundException e) {
contentReference = continueOnErrorOrRethrow(reference.getIdentifier(), e);
}
catch (IOException e) {
contentReference = continueOnErrorOrRethrow(reference.getIdentifier(), e);
}
catch (CoreException e) {
contentReference = continueOnErrorOrRethrow(reference.getIdentifier(), e);
}
return contentReference;
}
boolean success = false;
synchronized (jarLock) {
String packed = packedRef.toString();
Object packedLock = LockManager.getLock(packed);
synchronized (packedLock) {
try {
File tempFile = packedRef.asFile();
long timeStamp = tempFile.lastModified();
JarProcessor processor = JarProcessor.getUnpackProcessor(null);
processor.setWorkingDirectory(tempFile.getParent());
File packedFile = new File(tempFile.toString() + Utils.PACKED_SUFFIX);
tempFile.renameTo(packedFile);
if (monitor != null) {
monitor.saveState();
monitor.subTask(Messages.JarContentReference_Unpacking + " " + reference.getIdentifier() + Utils.PACKED_SUFFIX); //$NON-NLS-1$
monitor.showCopyDetails(false);
}
//unpacking the jar will strip the ".pack.gz" and leave us back with the original filename
try {
processor.processJar(packedFile);
} catch (Throwable e) {
//something is wrong unpacking
}
if(tempFile.exists() && tempFile.length() > 0){
success = true;
tempFile.setLastModified(timeStamp);
Utilities.mapLocalFile(key, tempFile);
UpdateCore.getPlugin().getUpdateSession().markVisited(reference.asURL());
}
} finally {
LockManager.returnLock(packed);
LockManager.returnLock(key);
if(monitor != null)
monitor.restoreState();
}
}
}
if(!success){
//Something went wrong with the unpack, get the normal jar.
ContentReference contentReference = null;
try {
contentReference = asLocalReference(reference, monitor);
}
catch (FileNotFoundException e) {
contentReference = continueOnErrorOrRethrow(reference.getIdentifier(), e);
}
catch (IOException e) {
contentReference = continueOnErrorOrRethrow(reference.getIdentifier(), e);
}
catch (CoreException e) {
contentReference = continueOnErrorOrRethrow(reference.getIdentifier(), e);
}
return contentReference;
}
return packedRef;
}
/*
* @see IFeatureContentProvider#getNonPluginEntryArchiveReferences(INonPluginEntry)
*/
public ContentReference[] getNonPluginEntryArchiveReferences(INonPluginEntry nonPluginEntry, InstallMonitor monitor) throws CoreException {
// archive = feature/<id>_<ver>/<file>
String archiveID = Site.DEFAULT_FEATURE_PATH + ((getFeature() != null) ? getFeature().getVersionedIdentifier().toString() : ""); //$NON-NLS-1$
archiveID += "/" + nonPluginEntry.getIdentifier(); //$NON-NLS-1$
ContentReference[] references = new ContentReference[1];
ContentReference currentReference = null;
try {
ISite site = (getFeature() == null) ? null : getFeature().getSite();
ISiteContentProvider siteContentProvider = (site == null) ? null : site.getSiteContentProvider();
URL url = (siteContentProvider == null) ? null : siteContentProvider.getArchiveReference(archiveID);
currentReference = new ContentReference(nonPluginEntry.getIdentifier(), url);
currentReference = asLocalReference(currentReference, monitor);
references[0] = currentReference;
} catch (IOException e) {
references[0] = continueOnErrorOrRethrow(archiveID, e);
}
return references;
}
/*
* @see IFeatureContentProvider#getFeatureEntryContentReferences()
*/
public ContentReference[] getFeatureEntryContentReferences(InstallMonitor monitor) throws CoreException {
return localFeatureFiles; // return cached feature references
// Note: assumes this content provider is always called first to
// get the feature manifest. This forces the feature files
// to be unpacked and caches the references
}
/*
* @see IFeatureContentProvider#getPluginEntryContentReferences(IPluginEntry)
*/
public ContentReference[] getPluginEntryContentReferences(IPluginEntry pluginEntry, InstallMonitor monitor) throws CoreException {
ContentReference[] references = getPluginEntryArchiveReferences(pluginEntry, monitor);
ContentReference[] pluginReferences = new ContentReference[0];
try {
if (references[0] instanceof JarContentReference) {
JarContentReference localRef = (JarContentReference) asLocalReference(references[0], monitor);
pluginReferences = localRef.peek(null, monitor);
} else {
// return the list of all subdirectories
List files = getFiles(references[0].asFile());
pluginReferences = new ContentReference[files.size()];
for (int i = 0; i < pluginReferences.length; i++) {
File currentFile = (File) files.get(i);
pluginReferences[i] = new ContentReference(null, currentFile.toURL());
}
}
//[20866] we did not preserve executable bit
validatePermissions(pluginReferences);
} catch (IOException e) {
throw errorRetrieving(pluginEntry.getVersionedIdentifier().toString(), references[0], e);
}
return pluginReferences;
}
/*
* return all the files under the directory
*/
private List getFiles(File dir) throws IOException {
List result = new ArrayList();
if (!dir.isDirectory())
throw new IOException(NLS.bind(Messages.FeaturePackagedContentProvider_InvalidDirectory, (new String[] { dir.getPath() })));
File[] files = dir.listFiles();
if (files != null) // be careful since it can be null
for (int i = 0; i < files.length; ++i) {
if (files[i].isDirectory()) {
result.addAll(getFiles(files[i]));
} else {
result.add(files[i]);
}
}
return result;
}
/*
*
*/
private CoreException errorRetrieving(String obj, ContentReference archive, Exception e) {
String[] values = new String[] { obj };
return Utilities.newCoreException(NLS.bind(Messages.FeaturePackagedContentProvider_ErrorRetrieving, values), e);
}
public void setContinueOnError(boolean continueOnError) {
this.continueOnError = continueOnError;
}
/**
* This method is used for when a core exception is detected, so, if its decided to rethrow, then
* a core exception odes not have to be recreated.
*
* @param archiveID id of the archive file
* @param CoreException
* @return NullReference if its decided not to continue
* @throws CoreException
*/
/*private ContentReference continueOrErrorOrRethrow(String archiveID, CoreException coreException) throws CoreException {
ContentReference reference = null;
if (continueOnError) {
// this ContentReference without a file or URL is purely a
// "missing jar" reference.
reference = new NullContentReference(archiveID);
String msg = " ContinueOnError: The following ID was not found, so was skipped, and is not on miror site: " + archiveID; //$NON-NLS-1$
String id = UpdateCore.getPlugin().getBundle().getSymbolicName();
IStatus status = new Status(IStatus.WARNING, id , 0, msg, null);
UpdateCore.log(status);
}
else {
throw coreException;
}
return reference;
}*/
private ContentReference continueOnErrorOrRethrow(String archiveID, Exception e) throws CoreException {
ContentReference reference = null;
if (continueOnError) {
// this ContentReference without a file or URL is purely a
// "missing jar" reference.
reference = new NullContentReference(archiveID);
String msg = " ContinueOnError: The following ID was not found, so was skipped, and is not on miror site: " + archiveID; //$NON-NLS-1$
String id = UpdateCore.getPlugin().getBundle().getSymbolicName();
IStatus status = new Status(IStatus.WARNING, id , 0, msg, null);
UpdateCore.log(status);
}
else {
throw errorRetrieving(archiveID, reference, e);
}
return reference;
}
}