| /******************************************************************************* |
| * 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.*; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.core.runtime.*; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.update.core.*; |
| import org.eclipse.update.core.model.*; |
| |
| /** |
| * ContentConsummer for a SiteFile |
| */ |
| public class SiteFileContentConsumer extends SiteContentConsumer { |
| |
| private IFeature feature; |
| private boolean closed = false; |
| |
| // recovery |
| private String oldPath; |
| private String newPath; |
| |
| // for abort |
| private List /* of SiteFilePluginContentConsumer */ |
| contentConsumers; |
| private List /*of path as String */ |
| installedFiles; |
| |
| // PERF: new instance variable |
| private SiteFileFactory archiveFactory = new SiteFileFactory(); |
| |
| /* |
| * Constructor |
| */ |
| public SiteFileContentConsumer(IFeature feature) { |
| this.feature = feature; |
| installedFiles = new ArrayList(); |
| } |
| |
| /* |
| * Returns the path in which the Feature will be installed |
| */ |
| private String getFeaturePath() throws CoreException { |
| String featurePath = null; |
| try { |
| VersionedIdentifier featureIdentifier = feature.getVersionedIdentifier(); |
| String path = Site.DEFAULT_INSTALLED_FEATURE_PATH + featureIdentifier.toString() + File.separator; |
| URL newURL = new URL(getSite().getURL(), path); |
| featurePath = newURL.getFile(); |
| } catch (MalformedURLException e) { |
| throw Utilities.newCoreException(Messages.SiteFileContentConsumer_UnableToCreateURL + e.getMessage(), e); |
| } |
| return featurePath; |
| } |
| |
| /* |
| * @see ISiteContentConsumer#open(INonPluginEntry) |
| */ |
| public IContentConsumer open(INonPluginEntry nonPluginEntry) throws CoreException { |
| return new SiteFileNonPluginContentConsumer(getFeaturePath()); |
| } |
| |
| /* |
| * @see ISiteContentConsumer#open(IPluginEntry) |
| */ |
| public IContentConsumer open(IPluginEntry pluginEntry) throws CoreException { |
| ContentConsumer cons; |
| if(pluginEntry instanceof PluginEntryModel && !((PluginEntryModel)pluginEntry).isUnpack()){ |
| // plugin can run from a jar |
| cons = new SiteFilePackedPluginContentConsumer(pluginEntry, getSite()); |
| } else{ |
| // plugin must be unpacked |
| cons = new SiteFilePluginContentConsumer(pluginEntry, getSite()); |
| } |
| addContentConsumers(cons); |
| return cons; |
| } |
| |
| /* |
| * @see ISiteContentConsumer#store(ContentReference, IProgressMonitor) |
| */ |
| public void store(ContentReference contentReference, IProgressMonitor monitor) throws CoreException { |
| |
| if (closed) { |
| UpdateCore.warn("Attempt to store in a closed SiteFileContentConsumer", new Exception()); //$NON-NLS-1$ |
| return; |
| } |
| |
| InputStream inStream = null; |
| String featurePath = getFeaturePath(); |
| String contentKey = contentReference.getIdentifier(); |
| featurePath += contentKey; |
| |
| // error recovery |
| if (featurePath.endsWith("\\"+Feature.FEATURE_XML) || featurePath.endsWith("/"+Feature.FEATURE_XML)) { //$NON-NLS-1$ //$NON-NLS-2$ |
| oldPath = featurePath.replace(File.separatorChar, '/'); |
| File localFile = new File(oldPath); |
| if (localFile.exists()) { |
| throw Utilities.newCoreException(NLS.bind(Messages.UpdateManagerUtils_FileAlreadyExists, (new Object[] { localFile })), null); |
| } |
| featurePath = ErrorRecoveryLog.getLocalRandomIdentifier(featurePath); |
| newPath = featurePath; |
| ErrorRecoveryLog.getLog().appendPath(ErrorRecoveryLog.FEATURE_ENTRY, featurePath); |
| } |
| |
| try { |
| inStream = contentReference.getInputStream(); |
| UpdateManagerUtils.copyToLocal(inStream, featurePath, null); |
| UpdateManagerUtils.checkPermissions(contentReference, featurePath); // 20305 |
| installedFiles.add(featurePath); |
| } catch (IOException e) { |
| throw Utilities.newCoreException(NLS.bind(Messages.GlobalConsumer_ErrorCreatingFile, (new String[] { featurePath })), e); |
| } finally { |
| if (inStream != null) { |
| try { |
| // close stream |
| inStream.close(); |
| } catch (IOException e) { |
| } |
| } |
| } |
| |
| } |
| |
| /* |
| * @see ISiteContentConsumer#close() |
| */ |
| public IFeatureReference close() throws CoreException { |
| |
| if (closed) |
| UpdateCore.warn("Attempt to close a closed SiteFileContentConsumer", new Exception()); //$NON-NLS-1$ |
| |
| // create a new Feature reference to be added to the site |
| SiteFeatureReference ref = new SiteFeatureReference(); |
| ref.setSite(getSite()); |
| File file = null; |
| |
| try { |
| file = new File(getFeaturePath()); |
| ref.setURL(file.toURL()); |
| } catch (MalformedURLException e) { |
| throw Utilities.newCoreException(NLS.bind(Messages.SiteFileContentConsumer_UnableToCreateURLForFile, (new String[] { file.getAbsolutePath() })), e); |
| } |
| |
| //rename file back |
| if (newPath != null) { |
| ErrorRecoveryLog.getLog().appendPath(ErrorRecoveryLog.RENAME_ENTRY, newPath); |
| boolean sucess = false; |
| File fileToRename = new File(newPath); |
| if (fileToRename.exists()) { |
| File renamedFile = new File(oldPath); |
| if (renamedFile.exists()) { |
| UpdateManagerUtils.removeFromFileSystem(renamedFile); |
| UpdateCore.warn("Removing already existing file:" + oldPath); //$NON-NLS-1$ |
| } |
| sucess = fileToRename.renameTo(renamedFile); |
| } |
| if (!sucess) { |
| String msg = NLS.bind(Messages.ContentConsumer_UnableToRename, (new String[] { newPath, oldPath })); |
| throw Utilities.newCoreException(msg, new Exception(msg)); |
| } |
| } |
| |
| // close plugin and non plugin content consumer |
| if (contentConsumers != null) { |
| Iterator iter = contentConsumers.iterator(); |
| while (iter.hasNext()) { |
| ContentConsumer element = (ContentConsumer) iter.next(); |
| element.close(); |
| } |
| } |
| contentConsumers = null; |
| |
| if (ref != null) { |
| // the feature MUST have renamed the plugins at that point |
| // (by closing the PluginContentConsumer) |
| commitPlugins(ref); |
| ref.markReadOnly(); |
| } |
| |
| closed = true; |
| return ref; |
| } |
| |
| /* |
| * @see ISiteContentConsumer#abort() |
| */ |
| public void abort() throws CoreException { |
| |
| if (closed) { |
| UpdateCore.warn("Attempt to abort a closed SiteFileContentConsumer", new Exception()); //$NON-NLS-1$ |
| return; |
| } |
| |
| //abort all plugins content consumer opened |
| if (contentConsumers != null) { |
| Iterator iter = contentConsumers.iterator(); |
| while (iter.hasNext()) { |
| Object element = iter.next(); |
| if (element instanceof SiteFilePluginContentConsumer) { |
| ((SiteFilePluginContentConsumer)element).abort(); |
| } else if (element instanceof SiteFilePackedPluginContentConsumer){ |
| ((SiteFilePackedPluginContentConsumer)element).abort(); |
| } |
| |
| } |
| } |
| contentConsumers = null; |
| boolean sucess = true; |
| |
| //Remove feature.xml first if it exists |
| if (oldPath != null) { |
| ErrorRecoveryLog.getLog().appendPath(ErrorRecoveryLog.DELETE_ENTRY, oldPath); |
| File fileToDelete = new File(oldPath); |
| if (fileToDelete.exists()) { |
| sucess = fileToDelete.delete(); |
| } |
| } |
| |
| if (!sucess) { |
| String msg = NLS.bind(Messages.SiteFileContentConsumer_unableToDelete, (new String[] { oldPath })); |
| UpdateCore.log(msg, null); |
| } else { |
| // remove the feature files; |
| Iterator iter = installedFiles.iterator(); |
| File featureFile = null; |
| while (iter.hasNext()) { |
| String path = (String) iter.next(); |
| featureFile = new File(path); |
| UpdateManagerUtils.removeFromFileSystem(featureFile); |
| } |
| |
| // remove the feature directory if empty |
| String featurePath = getFeaturePath(); |
| UpdateManagerUtils.removeEmptyDirectoriesFromFileSystem(new File(featurePath)); |
| } |
| closed = true; |
| return; |
| } |
| |
| /* |
| * commit the plugins installed as archive on the site |
| * (creates the map between the plugin id and the location of the plugin) |
| */ |
| private void commitPlugins(IFeatureReference localFeatureReference) throws CoreException { |
| |
| // get the feature |
| ((SiteFile) getSite()).addFeatureReferenceModel((SiteFeatureReferenceModel) localFeatureReference); |
| IFeature localFeature = null; |
| try { |
| localFeature = localFeatureReference.getFeature(null); |
| } catch (CoreException e) { |
| UpdateCore.warn(null, e); |
| return; |
| } |
| |
| if (localFeature == null) |
| return; |
| |
| // add the installed plugins directories as archives entry |
| ArchiveReferenceModel archive = null; |
| IPluginEntry[] pluginEntries = localFeature.getPluginEntries(); |
| for (int i = 0; i < pluginEntries.length; i++) { |
| String versionId = pluginEntries[i].getVersionedIdentifier().toString(); |
| String pluginID = Site.DEFAULT_PLUGIN_PATH + versionId + FeatureContentProvider.JAR_EXTENSION; |
| archive = archiveFactory.createArchiveReferenceModel(); |
| archive.setPath(pluginID); |
| try { |
| URL url = null; |
| if (pluginEntries[i] instanceof PluginEntryModel |
| && !((PluginEntryModel) pluginEntries[i]).isUnpack()) { |
| url = new URL(getSite().getURL(), Site.DEFAULT_PLUGIN_PATH + versionId + ".jar"); //$NON-NLS-1$ |
| } else { |
| url = new URL(getSite().getURL(), Site.DEFAULT_PLUGIN_PATH + versionId + File.separator); |
| } |
| archive.setURLString(url.toExternalForm()); |
| archive.resolve(url, null); |
| ((SiteFile) getSite()).addArchiveReferenceModel(archive); |
| } catch (MalformedURLException e) { |
| |
| String urlString = (getSite().getURL() != null) ? getSite().getURL().toExternalForm() : ""; //$NON-NLS-1$ |
| urlString += Site.DEFAULT_PLUGIN_PATH + pluginEntries[i].toString(); |
| throw Utilities.newCoreException(NLS.bind(Messages.SiteFile_UnableToCreateURL, (new String[] { urlString })), e); |
| } |
| } |
| return; |
| } |
| |
| /* |
| * Adds a SiteFilePluginContentConsumer to the list |
| */ |
| private void addContentConsumers(ContentConsumer cons) { |
| if (contentConsumers == null) |
| contentConsumers = new ArrayList(); |
| contentConsumers.add(cons); |
| } |
| |
| } |