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

Last change on this file since 14104 was 13993, checked in by Don-vip, 6 years ago

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