/*****************************************************************************
* Java Plug-in Framework (JPF)
* Copyright (C) 2004-2007 Dmitry Olshansky
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
package org.java.plugin.tools.ant;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.MatchingTask;
import org.apache.tools.ant.types.FileSet;
import org.apache.tools.ant.util.FileUtils;
import org.java.plugin.ObjectFactory;
import org.java.plugin.PathResolver;
import org.java.plugin.registry.Identity;
import org.java.plugin.registry.ManifestInfo;
import org.java.plugin.registry.ManifestProcessingException;
import org.java.plugin.registry.PluginRegistry;
import org.java.plugin.util.IoUtil;
/**
* Base class for some JPF related ant tasks.
* @version $Id: BaseJpfTask.java,v 1.8 2007/03/03 17:16:26 ddimon Exp $
*/
public abstract class BaseJpfTask extends MatchingTask {
private static final FileUtils fileUtils = FileUtils.newFileUtils();
private final LinkedList<FileSet> fileSets = new LinkedList<FileSet>();
private File baseDir;
private boolean verbose;
private PluginRegistry registry;
private PathResolver pathResolver;
private Set<String> whiteList;
private Set<String> blackList;
/**
* @param set the set of files to be registered as manifests
*/
public void addFileset(final FileSet set) {
fileSets.add(set);
}
/**
* @param aBaseDir base directory for manifest files
*/
public final void setBaseDir(final File aBaseDir) {
this.baseDir = aBaseDir;
}
/**
* @param aVerbose <code>true</code> if detailed integrity check report
* required
*/
public final void setVerbose(final boolean aVerbose) {
this.verbose = aVerbose;
}
/**
* @param file while list file
* @throws IOException if list reading failed
*/
public final void setWhiteList(final File file) throws IOException {
whiteList = loadList(file);
}
/**
* @param file black list file
* @throws IOException if list reading failed
*/
public final void setBlackList(final File file) throws IOException {
blackList = loadList(file);
}
protected Set<String> loadList(final File file) throws IOException {
if (file == null) {
return null;
}
Set<String> result = new HashSet<String>();
BufferedReader reader = new BufferedReader(new InputStreamReader(
new FileInputStream(file), "UTF-8")); //$NON-NLS-1$
try {
String line;
while ((line = reader.readLine()) != null) {
line = line.trim();
if (line.length() > 0) {
result.add(line);
}
}
} finally {
reader.close();
}
return result;
}
protected final boolean getVerbose() {
return verbose;
}
protected final PathResolver getPathResolver() {
return pathResolver;
}
protected final PluginRegistry getRegistry() {
return registry;
}
protected Set<String> getWhiteList() {
return whiteList;
}
protected Set<String> getBlackList() {
return blackList;
}
protected final void initRegistry(final boolean usePathResolver) {
if (baseDir != null) {
if (!baseDir.isDirectory()) {
throw new BuildException("basedir " + baseDir //$NON-NLS-1$
+ " does not exist!", getLocation()); //$NON-NLS-1$
}
} else {
baseDir = getProject().getBaseDir();
}
ObjectFactory objectFactory = ObjectFactory.newInstance();
registry = objectFactory.createRegistry();
File[] manifestFiles = getIncludedFiles();
List<URL> manifestUrls = new LinkedList<URL>();
final Map<String, URL> foldersMap = new HashMap<String, URL>();
for (int i = 0; i < manifestFiles.length; i++) {
File manifestFile = manifestFiles[i];
try {
//manifestUrls[i] = IoUtil.file2url(manifestFile);
URL manifestUrl = getManifestURL(manifestFile);
if (manifestUrl == null) {
if (verbose) {
log("Skipped file: " + manifestFile); //$NON-NLS-1$
}
continue;
}
try {
if (!isManifestAccepted(manifestUrl)) {
if (verbose) {
log("Skipped URL: " + manifestUrl); //$NON-NLS-1$
}
continue;
}
} catch (ManifestProcessingException mpe) {
throw new BuildException("can't read manifest from URL " //$NON-NLS-1$
+ manifestUrl, mpe, getLocation());
}
manifestUrls.add(manifestUrl);
if (verbose) {
log("Added URL: " + manifestUrl); //$NON-NLS-1$
}
if (usePathResolver) {
/*foldersMap.put(manifestUrls[i],
IoUtil.file2url(manifestFile.getParentFile()));*/
if ("jar".equals(manifestUrl.getProtocol())) { //$NON-NLS-1$
foldersMap.put(manifestUrl.toExternalForm(),
IoUtil.file2url(manifestFile));
} else {
foldersMap.put(manifestUrl.toExternalForm(),
IoUtil.file2url(manifestFile.getParentFile()));
}
}
} catch (MalformedURLException mue) {
throw new BuildException("can't create URL for file " //$NON-NLS-1$
+ manifestFile, mue, getLocation());
}
}
final Map<String, Identity> processedPlugins;
try {
processedPlugins = registry.register(
manifestUrls.toArray(new URL[manifestUrls.size()]));
} catch (Exception e) {
throw new BuildException("can't register URLs", e, getLocation()); //$NON-NLS-1$
}
log("Registry initialized, registered manifests: " //$NON-NLS-1$
+ processedPlugins.size() + " of " + manifestUrls.size(), //$NON-NLS-1$
(processedPlugins.size() != manifestUrls.size())
? Project.MSG_WARN : Project.MSG_INFO);
if (usePathResolver) {
pathResolver = objectFactory.createPathResolver();
for (Entry<String, Identity> entry : processedPlugins.entrySet()) {
pathResolver.registerContext(entry.getValue(),
foldersMap.get(entry.getKey()));
}
if (verbose) {
log("Path resolver initialized"); //$NON-NLS-1$
}
}
}
protected File[] getIncludedFiles() {
Set<File> result = new HashSet<File>();
for (FileSet fs : fileSets) {
for (String file
: fs.getDirectoryScanner(getProject()).getIncludedFiles()) {
if (file != null) {
result.add(fileUtils.resolveFile(
fs.getDir(getProject()), file));
}
}
}
if (fileSets.isEmpty()) {
for (String file
: getDirectoryScanner(baseDir).getIncludedFiles()) {
if (file != null) {
result.add(fileUtils.resolveFile(baseDir, file));
}
}
}
return result.toArray(new File[result.size()]);
}
protected URL getManifestURL(final File file) throws MalformedURLException {
if(file.getName().endsWith(".jar") || file.getName().endsWith(".zip")) { //$NON-NLS-1$ //$NON-NLS-2$
URL url = new URL("jar:" + IoUtil.file2url(file).toExternalForm() //$NON-NLS-1$
+ "!/plugin.xml"); //$NON-NLS-1$
if (IoUtil.isResourceExists(url)) {
return url;
}
url = new URL("jar:" + IoUtil.file2url(file).toExternalForm() //$NON-NLS-1$
+ "!/plugin-fragment.xml"); //$NON-NLS-1$
if (IoUtil.isResourceExists(url)) {
return url;
}
url = new URL("jar:" + IoUtil.file2url(file).toExternalForm() //$NON-NLS-1$
+ "!/META-INF/plugin.xml"); //$NON-NLS-1$
if (IoUtil.isResourceExists(url)) {
return url;
}
url = new URL("jar:" + IoUtil.file2url(file).toExternalForm() //$NON-NLS-1$
+ "!/META-INF/plugin-fragment.xml"); //$NON-NLS-1$
if (IoUtil.isResourceExists(url)) {
return url;
}
return null;
}
return IoUtil.file2url(file);
}
protected boolean isManifestAccepted(final URL manifestUrl)
throws ManifestProcessingException {
if ((whiteList == null) && (blackList == null)) {
return true;
}
ManifestInfo manifestInfo = registry.readManifestInfo(manifestUrl);
if (whiteList != null) {
if (isPluginInList(manifestInfo, whiteList)) {
return true;
}
}
if ((blackList != null) && isPluginInList(manifestInfo, blackList)) {
return false;
}
return true;
}
private boolean isPluginInList(final ManifestInfo manifestInfo,
final Set<String> list) {
if (list.contains(manifestInfo.getId())) {
return true;
}
return list.contains(registry.makeUniqueId(manifestInfo.getId(),
manifestInfo.getVersion()));
}
}
|