source: josm/trunk/src/org/openstreetmap/josm/plugins/PluginInformation.java @ 14186

Last change on this file since 14186 was 14186, checked in by Don-vip, 6 months ago

see #16682 - add new plugin property Minimum-Java-Version

  • Property svn:eol-style set to native
File size: 22.5 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.plugins;
3
4import static org.openstreetmap.josm.tools.I18n.tr;
5
6import java.io.File;
7import java.io.IOException;
8import java.io.InputStream;
9import java.lang.reflect.Constructor;
10import java.net.URL;
11import java.nio.file.Files;
12import java.nio.file.InvalidPathException;
13import java.text.MessageFormat;
14import java.util.ArrayList;
15import java.util.Collection;
16import java.util.LinkedList;
17import java.util.List;
18import java.util.Locale;
19import java.util.Map;
20import java.util.Optional;
21import java.util.TreeMap;
22import java.util.jar.Attributes;
23import java.util.jar.JarInputStream;
24import java.util.jar.Manifest;
25
26import javax.swing.ImageIcon;
27
28import org.openstreetmap.josm.data.Preferences;
29import org.openstreetmap.josm.data.Version;
30import org.openstreetmap.josm.tools.ImageProvider;
31import org.openstreetmap.josm.tools.LanguageInfo;
32import org.openstreetmap.josm.tools.Logging;
33import org.openstreetmap.josm.tools.Utils;
34
35/**
36 * Encapsulate general information about a plugin. This information is available
37 * without the need of loading any class from the plugin jar file.
38 *
39 * @author imi
40 * @since 153
41 */
42public class PluginInformation {
43
44    /** The plugin jar file. */
45    public File file;
46    /** The plugin name. */
47    public String name;
48    /** The lowest JOSM version required by this plugin (from plugin list). **/
49    public int mainversion;
50    /** The lowest JOSM version required by this plugin (from locally available jar). **/
51    public int localmainversion;
52    /** The lowest Java version required by this plugin (from plugin list). **/
53    public int minjavaversion;
54    /** The lowest Java version required by this plugin (from locally available jar). **/
55    public int localminjavaversion;
56    /** The plugin class name. */
57    public String className;
58    /** Determines if the plugin is an old version loaded for incompatibility with latest JOSM (from plugin list) */
59    public boolean oldmode;
60    /** The list of required plugins, separated by ';' (from plugin list). */
61    public String requires;
62    /** The list of required plugins, separated by ';' (from locally available jar). */
63    public String localrequires;
64    /** The plugin link (for documentation). */
65    public String link;
66    /** The plugin description. */
67    public String description;
68    /** Determines if the plugin must be loaded early or not. */
69    public boolean early;
70    /** The plugin author. */
71    public String author;
72    /** The plugin stage, determining the loading sequence order of plugins. */
73    public int stage = 50;
74    /** The plugin version (from plugin list). **/
75    public String version;
76    /** The plugin version (from locally available jar). **/
77    public String localversion;
78    /** The plugin download link. */
79    public String downloadlink;
80    /** The plugin icon path inside jar. */
81    public String iconPath;
82    /** The plugin icon. */
83    private ImageProvider icon;
84    /** Plugin can be loaded at any time and not just at start. */
85    public boolean canloadatruntime;
86    /** The libraries referenced in Class-Path manifest attribute. */
87    public List<URL> libraries = new LinkedList<>();
88    /** All manifest attributes. */
89    public final Map<String, String> attr = new TreeMap<>();
90    /** Invalid manifest entries */
91    final List<String> invalidManifestEntries = new ArrayList<>();
92    /** Empty icon for these plugins which have none */
93    private static final ImageIcon emptyIcon = ImageProvider.getEmpty(ImageProvider.ImageSizes.LARGEICON);
94
95    /**
96     * Creates a plugin information object by reading the plugin information from
97     * the manifest in the plugin jar.
98     *
99     * The plugin name is derived from the file name.
100     *
101     * @param file the plugin jar file
102     * @throws PluginException if reading the manifest fails
103     */
104    public PluginInformation(File file) throws PluginException {
105        this(file, file.getName().substring(0, file.getName().length()-4));
106    }
107
108    /**
109     * Creates a plugin information object for the plugin with name {@code name}.
110     * Information about the plugin is extracted from the manifest file in the plugin jar
111     * {@code file}.
112     * @param file the plugin jar
113     * @param name the plugin name
114     * @throws PluginException if reading the manifest file fails
115     */
116    public PluginInformation(File file, String name) throws PluginException {
117        if (!PluginHandler.isValidJar(file)) {
118            throw new PluginException(tr("Invalid jar file ''{0}''", file));
119        }
120        this.name = name;
121        this.file = file;
122        try (
123            InputStream fis = Files.newInputStream(file.toPath());
124            JarInputStream jar = new JarInputStream(fis)
125        ) {
126            Manifest manifest = jar.getManifest();
127            if (manifest == null)
128                throw new PluginException(tr("The plugin file ''{0}'' does not include a Manifest.", file.toString()));
129            scanManifest(manifest, false);
130            libraries.add(0, Utils.fileToURL(file));
131        } catch (IOException | InvalidPathException e) {
132            throw new PluginException(name, e);
133        }
134    }
135
136    /**
137     * Creates a plugin information object by reading plugin information in Manifest format
138     * from the input stream {@code manifestStream}.
139     *
140     * @param manifestStream the stream to read the manifest from
141     * @param name the plugin name
142     * @param url the download URL for the plugin
143     * @throws PluginException if the plugin information can't be read from the input stream
144     */
145    public PluginInformation(InputStream manifestStream, String name, String url) throws PluginException {
146        this.name = name;
147        try {
148            Manifest manifest = new Manifest();
149            manifest.read(manifestStream);
150            if (url != null) {
151                downloadlink = url;
152            }
153            scanManifest(manifest, url != null);
154        } catch (IOException e) {
155            throw new PluginException(name, e);
156        }
157    }
158
159    /**
160     * Updates the plugin information of this plugin information object with the
161     * plugin information in a plugin information object retrieved from a plugin
162     * update site.
163     *
164     * @param other the plugin information object retrieved from the update site
165     */
166    public void updateFromPluginSite(PluginInformation other) {
167        this.mainversion = other.mainversion;
168        this.minjavaversion = other.minjavaversion;
169        this.className = other.className;
170        this.requires = other.requires;
171        this.link = other.link;
172        this.description = other.description;
173        this.early = other.early;
174        this.author = other.author;
175        this.stage = other.stage;
176        this.version = other.version;
177        this.downloadlink = other.downloadlink;
178        this.icon = other.icon;
179        this.iconPath = other.iconPath;
180        this.canloadatruntime = other.canloadatruntime;
181        this.libraries = other.libraries;
182        this.attr.clear();
183        this.attr.putAll(other.attr);
184        this.invalidManifestEntries.clear();
185        this.invalidManifestEntries.addAll(other.invalidManifestEntries);
186    }
187
188    /**
189     * Updates the plugin information of this plugin information object with the
190     * plugin information in a plugin information object retrieved from a plugin jar.
191     *
192     * @param other the plugin information object retrieved from the jar file
193     * @since 5601
194     */
195    public void updateFromJar(PluginInformation other) {
196        updateLocalInfo(other);
197        if (other.icon != null) {
198            this.icon = other.icon;
199        }
200        this.early = other.early;
201        this.className = other.className;
202        this.canloadatruntime = other.canloadatruntime;
203        this.libraries = other.libraries;
204        this.stage = other.stage;
205        this.file = other.file;
206    }
207
208    private void scanManifest(Manifest manifest, boolean oldcheck) {
209        String lang = LanguageInfo.getLanguageCodeManifest();
210        Attributes attr = manifest.getMainAttributes();
211        className = attr.getValue("Plugin-Class");
212        String s = Optional.ofNullable(attr.getValue(lang+"Plugin-Link")).orElseGet(() -> attr.getValue("Plugin-Link"));
213        if (s != null && !Utils.isValidUrl(s)) {
214            Logging.info(tr("Invalid URL ''{0}'' in plugin {1}", s, name));
215            s = null;
216        }
217        link = s;
218        requires = attr.getValue("Plugin-Requires");
219        s = attr.getValue(lang+"Plugin-Description");
220        if (s == null) {
221            s = attr.getValue("Plugin-Description");
222            if (s != null) {
223                try {
224                    s = tr(s);
225                } catch (IllegalArgumentException e) {
226                    Logging.debug(e);
227                    Logging.info(tr("Invalid plugin description ''{0}'' in plugin {1}", s, name));
228                }
229            }
230        } else {
231            s = MessageFormat.format(s, (Object[]) null);
232        }
233        description = s;
234        early = Boolean.parseBoolean(attr.getValue("Plugin-Early"));
235        String stageStr = attr.getValue("Plugin-Stage");
236        stage = stageStr == null ? 50 : Integer.parseInt(stageStr);
237        version = attr.getValue("Plugin-Version");
238        s = attr.getValue("Plugin-Mainversion");
239        if (s != null) {
240            try {
241                mainversion = Integer.parseInt(s);
242            } catch (NumberFormatException e) {
243                Logging.warn(tr("Invalid plugin main version ''{0}'' in plugin {1}", s, name));
244                Logging.trace(e);
245            }
246        } else {
247            Logging.warn(tr("Missing plugin main version in plugin {0}", name));
248        }
249        s = attr.getValue("Minimum-Java-Version");
250        if (s != null) {
251            try {
252                minjavaversion = Integer.parseInt(s);
253            } catch (NumberFormatException e) {
254                Logging.warn(tr("Invalid Java version ''{0}'' in plugin {1}", s, name));
255                Logging.trace(e);
256            }
257        }
258        author = attr.getValue("Author");
259        iconPath = attr.getValue("Plugin-Icon");
260        if (iconPath != null) {
261            if (file != null) {
262                // extract icon from the plugin jar file
263                icon = new ImageProvider(iconPath).setArchive(file).setMaxSize(ImageProvider.ImageSizes.LARGEICON).setOptional(true);
264            } else if (iconPath.startsWith("data:")) {
265                icon = new ImageProvider(iconPath).setMaxSize(ImageProvider.ImageSizes.LARGEICON).setOptional(true);
266            }
267        }
268        canloadatruntime = Boolean.parseBoolean(attr.getValue("Plugin-Canloadatruntime"));
269        int myv = Version.getInstance().getVersion();
270        for (Map.Entry<Object, Object> entry : attr.entrySet()) {
271            String key = ((Attributes.Name) entry.getKey()).toString();
272            if (key.endsWith("_Plugin-Url")) {
273                try {
274                    int mv = Integer.parseInt(key.substring(0, key.length()-11));
275                    String v = (String) entry.getValue();
276                    int i = v.indexOf(';');
277                    if (i <= 0) {
278                        invalidManifestEntries.add(key);
279                    } else if (oldcheck &&
280                        mv <= myv && (mv > mainversion || mainversion > myv)) {
281                        downloadlink = v.substring(i+1);
282                        mainversion = mv;
283                        version = v.substring(0, i);
284                        oldmode = true;
285                    }
286                } catch (NumberFormatException | IndexOutOfBoundsException e) {
287                    invalidManifestEntries.add(key);
288                    Logging.error(e);
289                }
290            }
291        }
292
293        String classPath = attr.getValue(Attributes.Name.CLASS_PATH);
294        if (classPath != null) {
295            for (String entry : classPath.split(" ")) {
296                File entryFile;
297                if (new File(entry).isAbsolute() || file == null) {
298                    entryFile = new File(entry);
299                } else {
300                    entryFile = new File(file.getParent(), entry);
301                }
302
303                libraries.add(Utils.fileToURL(entryFile));
304            }
305        }
306        for (Object o : attr.keySet()) {
307            this.attr.put(o.toString(), attr.getValue(o.toString()));
308        }
309    }
310
311    /**
312     * Replies the description as HTML document, including a link to a web page with
313     * more information, provided such a link is available.
314     *
315     * @return the description as HTML document
316     */
317    public String getDescriptionAsHtml() {
318        StringBuilder sb = new StringBuilder(128);
319        sb.append("<html><body>")
320          .append(description == null ? tr("no description available") : Utils.escapeReservedCharactersHTML(description));
321        if (link != null) {
322            sb.append(" <a href=\"").append(link).append("\">").append(tr("More info...")).append("</a>");
323        }
324        if (downloadlink != null
325                && !downloadlink.startsWith("http://svn.openstreetmap.org/applications/editors/josm/dist/")
326                && !downloadlink.startsWith("https://svn.openstreetmap.org/applications/editors/josm/dist/")
327                && !downloadlink.startsWith("http://trac.openstreetmap.org/browser/applications/editors/josm/dist/")
328                && !downloadlink.startsWith("https://github.com/JOSM/")) {
329            sb.append("<p>&nbsp;</p><p>").append(tr("<b>Plugin provided by an external source:</b> {0}", downloadlink)).append("</p>");
330        }
331        sb.append("</body></html>");
332        return sb.toString();
333    }
334
335    /**
336     * Loads and instantiates the plugin.
337     *
338     * @param klass the plugin class
339     * @param classLoader the class loader for the plugin
340     * @return the instantiated and initialized plugin
341     * @throws PluginException if the plugin cannot be loaded or instanciated
342     * @since 12322
343     */
344    public PluginProxy load(Class<?> klass, PluginClassLoader classLoader) throws PluginException {
345        try {
346            Constructor<?> c = klass.getConstructor(PluginInformation.class);
347            Object plugin = c.newInstance(this);
348            return new PluginProxy(plugin, this, classLoader);
349        } catch (ReflectiveOperationException e) {
350            throw new PluginException(name, e);
351        }
352    }
353
354    /**
355     * Loads the class of the plugin.
356     *
357     * @param classLoader the class loader to use
358     * @return the loaded class
359     * @throws PluginException if the class cannot be loaded
360     */
361    public Class<?> loadClass(ClassLoader classLoader) throws PluginException {
362        if (className == null)
363            return null;
364        try {
365            return Class.forName(className, true, classLoader);
366        } catch (NoClassDefFoundError | ClassNotFoundException | ClassCastException e) {
367            throw new PluginException(name, e);
368        }
369    }
370
371    /**
372     * Try to find a plugin after some criterias. Extract the plugin-information
373     * from the plugin and return it. The plugin is searched in the following way:
374     *<ol>
375     *<li>first look after an MANIFEST.MF in the package org.openstreetmap.josm.plugins.&lt;plugin name&gt;
376     *    (After removing all fancy characters from the plugin name).
377     *    If found, the plugin is loaded using the bootstrap classloader.</li>
378     *<li>If not found, look for a jar file in the user specific plugin directory
379     *    (~/.josm/plugins/&lt;plugin name&gt;.jar)</li>
380     *<li>If not found and the environment variable JOSM_RESOURCES + "/plugins/" exist, look there.</li>
381     *<li>Try for the java property josm.resources + "/plugins/" (set via java -Djosm.plugins.path=...)</li>
382     *<li>If the environment variable ALLUSERSPROFILE and APPDATA exist, look in
383     *    ALLUSERSPROFILE/&lt;the last stuff from APPDATA&gt;/JOSM/plugins.
384     *    (*sic* There is no easy way under Windows to get the All User's application
385     *    directory)</li>
386     *<li>Finally, look in some typical unix paths:<ul>
387     *    <li>/usr/local/share/josm/plugins/</li>
388     *    <li>/usr/local/lib/josm/plugins/</li>
389     *    <li>/usr/share/josm/plugins/</li>
390     *    <li>/usr/lib/josm/plugins/</li></ul></li>
391     *</ol>
392     * If a plugin class or jar file is found earlier in the list but seem not to
393     * be working, an PluginException is thrown rather than continuing the search.
394     * This is so JOSM can detect broken user-provided plugins and do not go silently
395     * ignore them.
396     *
397     * The plugin is not initialized. If the plugin is a .jar file, it is not loaded
398     * (only the manifest is extracted). In the classloader-case, the class is
399     * bootstraped (e.g. static {} - declarations will run. However, nothing else is done.
400     *
401     * @param pluginName The name of the plugin (in all lowercase). E.g. "lang-de"
402     * @return Information about the plugin or <code>null</code>, if the plugin
403     *         was nowhere to be found.
404     * @throws PluginException In case of broken plugins.
405     */
406    public static PluginInformation findPlugin(String pluginName) throws PluginException {
407        String name = pluginName;
408        name = name.replaceAll("[-. ]", "");
409        try (InputStream manifestStream = PluginInformation.class.getResourceAsStream("/org/openstreetmap/josm/plugins/"+name+"/MANIFEST.MF")) {
410            if (manifestStream != null) {
411                return new PluginInformation(manifestStream, pluginName, null);
412            }
413        } catch (IOException e) {
414            Logging.warn(e);
415        }
416
417        Collection<String> locations = getPluginLocations();
418
419        for (String s : locations) {
420            File pluginFile = new File(s, pluginName + ".jar");
421            if (pluginFile.exists()) {
422                return new PluginInformation(pluginFile);
423            }
424        }
425        return null;
426    }
427
428    /**
429     * Returns all possible plugin locations.
430     * @return all possible plugin locations.
431     */
432    public static Collection<String> getPluginLocations() {
433        Collection<String> locations = Preferences.getAllPossiblePreferenceDirs();
434        Collection<String> all = new ArrayList<>(locations.size());
435        for (String s : locations) {
436            all.add(s+"plugins");
437        }
438        return all;
439    }
440
441    /**
442     * Replies true if the plugin with the given information is most likely outdated with
443     * respect to the referenceVersion.
444     *
445     * @param referenceVersion the reference version. Can be null if we don't know a
446     * reference version
447     *
448     * @return true, if the plugin needs to be updated; false, otherweise
449     */
450    public boolean isUpdateRequired(String referenceVersion) {
451        if (this.downloadlink == null) return false;
452        if (this.version == null && referenceVersion != null)
453            return true;
454        return this.version != null && !this.version.equals(referenceVersion);
455    }
456
457    /**
458     * Replies true if this this plugin should be updated/downloaded because either
459     * it is not available locally (its local version is null) or its local version is
460     * older than the available version on the server.
461     *
462     * @return true if the plugin should be updated
463     */
464    public boolean isUpdateRequired() {
465        if (this.downloadlink == null) return false;
466        if (this.localversion == null) return true;
467        return isUpdateRequired(this.localversion);
468    }
469
470    protected boolean matches(String filter, String value) {
471        if (filter == null) return true;
472        if (value == null) return false;
473        return value.toLowerCase(Locale.ENGLISH).contains(filter.toLowerCase(Locale.ENGLISH));
474    }
475
476    /**
477     * Replies true if either the name, the description, or the version match (case insensitive)
478     * one of the words in filter. Replies true if filter is null.
479     *
480     * @param filter the filter expression
481     * @return true if this plugin info matches with the filter
482     */
483    public boolean matches(String filter) {
484        if (filter == null) return true;
485        String[] words = filter.split("\\s+");
486        for (String word: words) {
487            if (matches(word, name)
488                    || matches(word, description)
489                    || matches(word, version)
490                    || matches(word, localversion))
491                return true;
492        }
493        return false;
494    }
495
496    /**
497     * Replies the name of the plugin.
498     * @return The plugin name
499     */
500    public String getName() {
501        return name;
502    }
503
504    /**
505     * Sets the name
506     * @param name Plugin name
507     */
508    public void setName(String name) {
509        this.name = name;
510    }
511
512    /**
513     * Replies the plugin icon, scaled to LARGE_ICON size.
514     * @return the plugin icon, scaled to LARGE_ICON size.
515     */
516    public ImageIcon getScaledIcon() {
517        ImageIcon img = (icon != null) ? icon.get() : null;
518        if (img == null)
519            return emptyIcon;
520        return img;
521    }
522
523    @Override
524    public final String toString() {
525        return getName();
526    }
527
528    private static List<String> getRequiredPlugins(String pluginList) {
529        List<String> requiredPlugins = new ArrayList<>();
530        if (pluginList != null) {
531            for (String s : pluginList.split(";")) {
532                String plugin = s.trim();
533                if (!plugin.isEmpty()) {
534                    requiredPlugins.add(plugin);
535                }
536            }
537        }
538        return requiredPlugins;
539    }
540
541    /**
542     * Replies the list of plugins required by the up-to-date version of this plugin.
543     * @return List of plugins required. Empty if no plugin is required.
544     * @since 5601
545     */
546    public List<String> getRequiredPlugins() {
547        return getRequiredPlugins(requires);
548    }
549
550    /**
551     * Replies the list of plugins required by the local instance of this plugin.
552     * @return List of plugins required. Empty if no plugin is required.
553     * @since 5601
554     */
555    public List<String> getLocalRequiredPlugins() {
556        return getRequiredPlugins(localrequires);
557    }
558
559    /**
560     * Updates the local fields
561     * ({@link #localversion}, {@link #localmainversion}, {@link #localminjavaversion}, {@link #localrequires})
562     * to values contained in the up-to-date fields
563     * ({@link #version}, {@link #mainversion}, {@link #minjavaversion}, {@link #requires})
564     * of the given PluginInformation.
565     * @param info The plugin information to get the data from.
566     * @since 5601
567     */
568    public void updateLocalInfo(PluginInformation info) {
569        if (info != null) {
570            this.localversion = info.version;
571            this.localmainversion = info.mainversion;
572            this.localminjavaversion = info.minjavaversion;
573            this.localrequires = info.requires;
574        }
575    }
576}
Note: See TracBrowser for help on using the repository browser.