| 0,0 → 1,376 |
|---|
| package net.outlyer.plugins; |
| |
| /* |
| * Copyright (c) 2008, Toni Corvera. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
| * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
| * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, |
| * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
| * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
| * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| // $Id$ |
| |
| import java.io.File; |
| import java.io.FileFilter; |
| import java.io.IOException; |
| import java.net.JarURLConnection; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Enumeration; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.jar.JarEntry; |
| |
| /** |
| * Simplifies seeking plugins and abstracts their location (whether they're |
| * in a directory or inside a jar file). |
| */ |
| public class PluginLocator { |
| |
| private final List<URI> paths; |
| private final Library library; |
| private static final FileFilter jsFileFilter; |
| private boolean scanned = false; |
| private final PluginEnvironment environment; |
| |
| static { |
| jsFileFilter = new FileFilter() { |
| public boolean accept(final File pathname) { |
| return pathname.isFile() && pathname.canRead() && |
| pathname.getName().endsWith(".js"); |
| } |
| }; |
| } |
| |
| private static class Library { |
| // FIXME: Do something more elegant... |
| |
| private final HashMap<String, List<Sandbox>> byType; |
| private final HashMap<String, Sandbox> byFilename; // FIXME: Not really unique |
| private final HashMap<String, Sandbox> byName; |
| private final HashSet<Sandbox> unique; |
| |
| { |
| byType = new HashMap<String, List<Sandbox>>(); |
| byFilename = new HashMap<String, Sandbox>(); |
| byName = new HashMap<String, Sandbox>(); |
| unique = new HashSet<Sandbox>(); |
| } |
| |
| void add(final String fileName, final PluginProperties pp, final Sandbox sbox) { |
| byName.put(pp.name, sbox); |
| byFilename.put(fileName, sbox); |
| if (byType.get(pp.type) == null) { |
| byType.put(pp.type, new LinkedList<Sandbox>()); |
| } |
| byType.get(pp.type).add(sbox); |
| unique.add(sbox); |
| } |
| |
| void drop() { |
| byType.clear(); |
| byFilename.clear(); |
| byName.clear(); |
| unique.clear(); |
| } |
| } |
| |
| { |
| paths = new LinkedList<URI>(); |
| library = new Library(); |
| } |
| |
| public PluginLocator(final PluginEnvironment pe, final URI...searchPaths) { |
| if (null == searchPaths) { |
| throw new IllegalArgumentException("Can't initialise PluginLocator with no search path"); |
| } |
| for (final URI path : searchPaths) { |
| addSearchPath(path); |
| } |
| environment = pe; |
| } |
| |
| public void addSearchPath(final URI path) { |
| if (null == path) { |
| throw new IllegalArgumentException("Can't have a null path in the search paths"); |
| } |
| |
| if (path.getScheme().equals("file")) { |
| final File file = new File(path.normalize()).getAbsoluteFile(); |
| if (file.exists() && file.isDirectory() && file.canRead()) { |
| paths.add(file.toURI().normalize()); |
| } |
| } |
| else if (path.getScheme().equals("jar")) { |
| final URI normalized = path.normalize(); |
| if (!normalized.getSchemeSpecificPart().endsWith("/")) { |
| throw new IllegalArgumentException("Jar file entries must" + |
| " represent directories"); |
| } |
| // TODO: Check for existence (Class.getResource()) |
| paths.add(normalized); |
| } |
| else { |
| throw new IllegalArgumentException("Only directories or jar directories are accepted"); |
| } |
| } |
| |
| public Sandbox getFirst(final String type, final String name, final String fileName) { |
| if (null == type && null == name && null == fileName) { |
| throw new IllegalArgumentException("At least one of type, name or fileName must be non-null"); |
| } |
| if (!scanned) { |
| throw new IllegalStateException("Can't retrieve before scanning"); |
| } |
| |
| final Set<Sandbox> sf = new HashSet<Sandbox>(), |
| sn = new HashSet<Sandbox>(), |
| st = new HashSet<Sandbox>(); |
| |
| // All keys are optional but if one of them is not null and yields no |
| // results then getFirst yields no result |
| if (null != fileName) { |
| final Sandbox s = library.byFilename.get(fileName); |
| if (null == s) { |
| return null; |
| } |
| sf.add(s); |
| } |
| if (null != name) { |
| final Sandbox s = library.byName.get(name); |
| if (null == s) { |
| return null; |
| } |
| sn.add(s); |
| } |
| if (null != type) { |
| final Collection<Sandbox> byType = library.byType.get(type); |
| if (byType.isEmpty()) { |
| return null; |
| } |
| st.addAll(byType); |
| } |
| |
| Set<Sandbox> inters; |
| |
| if (null != fileName) { |
| inters = sf; |
| |
| if (null != name) { |
| assert ! sn.isEmpty(); |
| inters.retainAll(sn); |
| } |
| if (!inters.isEmpty() && null != type) { |
| assert ! st.isEmpty(); |
| inters.retainAll(st); |
| } |
| } |
| else if (null != name) { |
| assert null == fileName && sf.isEmpty(); |
| |
| inters = sn; |
| if (null != type) { |
| assert ! st.isEmpty(); |
| sn.retainAll(st); |
| } |
| } |
| else { |
| assert null != type && ! st.isEmpty(); |
| assert null == name && sn.isEmpty(); |
| assert null == fileName && sf.isEmpty(); |
| |
| inters = st; |
| } |
| |
| |
| if (inters.isEmpty()) { |
| return null; |
| } |
| |
| return inters.iterator().next(); |
| } |
| |
| public Collection<Sandbox> getAll(final String type, final String name, final String fileName) { |
| if (null == type && null == name && null == fileName) { |
| throw new IllegalArgumentException("At least one of type, name or fileName must be non-null"); |
| } |
| if (!scanned) { |
| throw new IllegalStateException("Can't retrieve before scanning"); |
| } |
| |
| final Set<Sandbox> set = new HashSet<Sandbox>(); |
| |
| if (null != fileName) { |
| final Sandbox s = library.byFilename.get(fileName); |
| if (null != s) { |
| set.add(s); |
| } |
| } |
| if (null != name) { |
| final Sandbox s = library.byName.get(name); |
| if (null != s) { |
| set.add(s); |
| } |
| } |
| if (null != type) { |
| final Collection<Sandbox> sbox = library.byType.get(type); |
| if (null != sbox) { |
| set.addAll(sbox); |
| } |
| } |
| return Collections.unmodifiableSet(set); |
| } |
| |
| public void scan() { |
| if (scanned) { |
| return; |
| } |
| if (paths.size() == 0) { // Nothing to scan |
| scanned = true; |
| return; |
| } |
| |
| for (final URI uri : paths) { |
| if (uri.getScheme().equals("file")) { |
| final File dir = new File(uri); |
| checkDirConsistency(dir); |
| scan(dir); |
| } |
| else { |
| assert uri.getScheme().equals("jar"); |
| scan(uri); |
| } |
| } |
| |
| scanned = true; |
| } |
| |
| /** |
| * Scan over a directory |
| * @param dir Directory to scan |
| */ |
| private void scan(final File dir) { |
| assert dir.isDirectory() && dir.canRead(); |
| |
| for (final File candidateFile : dir.listFiles(jsFileFilter)) { |
| final URI fileURI = candidateFile.toURI(); |
| |
| try { |
| final Sandbox sb = environment.createSandbox(fileURI); |
| |
| final PluginProperties pp = PluginEnvironment.fetchPluginProperties(fileURI); |
| if (null == pp) { |
| continue; |
| } |
| |
| if (null == pp.name) { |
| pp.name = candidateFile.getName(); |
| } |
| library.add(candidateFile.getName(), pp, sb); |
| } |
| catch (final PluginException e) { |
| continue; |
| } |
| } |
| } |
| |
| /** |
| * Scan over a directory inside a jar file |
| * @param jarUri Directory to scan |
| * @return List of plugins in directory <code>jarUri</code> |
| */ |
| private void scan(final URI jarUri) { |
| assert jarUri.getScheme().equals("jar"); |
| |
| try { |
| final JarURLConnection conn = (JarURLConnection) jarUri.toURL().openConnection(); |
| assert null != conn.getEntryName(); |
| final Enumeration<JarEntry> entries = conn.getJarFile().entries(); |
| |
| final String[] jarURIElements =jarUri.getSchemeSpecificPart().split("!"); |
| assert jarURIElements.length == 2; |
| final String jarFile = jarURIElements[0]; // = file:....jar |
| final String root = jarURIElements[1]; // = /path |
| |
| while (entries.hasMoreElements()) { |
| final JarEntry je = entries.nextElement(); |
| |
| final String url = "/"+je.getName(); |
| |
| if (url.startsWith(root) && !je.isDirectory()) { |
| // Accepted URI |
| try { |
| final URI pluginUri = new URI("jar:"+jarFile+"!"+url); |
| |
| final Sandbox sb = environment.createSandbox(pluginUri); |
| final PluginProperties pp = PluginEnvironment.fetchPluginProperties(pluginUri); |
| // JarEntry's getName() returns the full path |
| final String fileName = new File(je.getName()).getName(); |
| if (pp.name == null) { |
| pp.name = fileName; |
| } |
| library.add(fileName, pp, sb); |
| } |
| catch (final PluginException e) { |
| continue; |
| } |
| catch (final URISyntaxException e) { |
| assert false; |
| throw new IllegalStateException("Unexpected malformed " + |
| "jar URI, implementation error (?)"); |
| } |
| } |
| } |
| } |
| catch (IOException e) { |
| throw new IllegalStateException("Error reading jar file"); |
| } |
| } |
| |
| /** |
| * Throws an unchecked exception if something that, on construction, was |
| * a valid directory, is not anymore. |
| * @param dir Directory to check |
| * @throws java.lang.IllegalStateException If the <em>directory</em> is |
| * no longer a directory or can't be accessed or has ceased to exist. |
| */ |
| private static void checkDirConsistency(final File dir) |
| throws IllegalStateException { |
| if (!dir.exists() || !dir.isDirectory() || !dir.canRead()) { |
| throw new IllegalStateException("Permissions of " + dir + |
| " modified while running"); |
| } |
| } |
| |
| public Collection<Sandbox> list() { |
| scan(); |
| return Collections.unmodifiableCollection(library.unique); |
| } |
| |
| public int foundPlugins() { |
| scan(); |
| return library.unique.size(); |
| } |
| |
| } |
| Property changes: |
|---|
| Added: svn:keywords |
|---|
| +Rev Id Date |
|---|
| \ No newline at end of property |
|---|