001// License: GPL. For details, see LICENSE file. 002package org.openstreetmap.josm.plugins; 003 004import static org.openstreetmap.josm.tools.I18n.tr; 005 006import java.awt.Image; 007import java.awt.image.BufferedImage; 008import java.io.File; 009import java.io.FileInputStream; 010import java.io.IOException; 011import java.io.InputStream; 012import java.lang.reflect.Constructor; 013import java.lang.reflect.InvocationTargetException; 014import java.net.MalformedURLException; 015import java.net.URL; 016import java.text.MessageFormat; 017import java.util.ArrayList; 018import java.util.Collection; 019import java.util.LinkedList; 020import java.util.List; 021import java.util.Locale; 022import java.util.Map; 023import java.util.TreeMap; 024import java.util.jar.Attributes; 025import java.util.jar.JarInputStream; 026import java.util.jar.Manifest; 027 028import javax.swing.ImageIcon; 029 030import org.openstreetmap.josm.Main; 031import org.openstreetmap.josm.data.Version; 032import org.openstreetmap.josm.tools.ImageProvider; 033import org.openstreetmap.josm.tools.LanguageInfo; 034import org.openstreetmap.josm.tools.Utils; 035 036/** 037 * Encapsulate general information about a plugin. This information is available 038 * without the need of loading any class from the plugin jar file. 039 * 040 * @author imi 041 * @since 153 042 */ 043public class PluginInformation { 044 045 /** The plugin jar file. */ 046 public File file; 047 /** The plugin name. */ 048 public String name; 049 /** The lowest JOSM version required by this plugin (from plugin list). **/ 050 public int mainversion; 051 /** The lowest JOSM version required by this plugin (from locally available jar). **/ 052 public int localmainversion; 053 /** The plugin class name. */ 054 public String className; 055 /** Determines if the plugin is an old version loaded for incompatibility with latest JOSM (from plugin list) */ 056 public boolean oldmode; 057 /** The list of required plugins, separated by ';' (from plugin list). */ 058 public String requires; 059 /** The list of required plugins, separated by ';' (from locally available jar). */ 060 public String localrequires; 061 /** The plugin link (for documentation). */ 062 public String link; 063 /** The plugin description. */ 064 public String description; 065 /** Determines if the plugin must be loaded early or not. */ 066 public boolean early; 067 /** The plugin author. */ 068 public String author; 069 /** The plugin stage, determining the loading sequence order of plugins. */ 070 public int stage = 50; 071 /** The plugin version (from plugin list). **/ 072 public String version; 073 /** The plugin version (from locally available jar). **/ 074 public String localversion; 075 /** The plugin download link. */ 076 public String downloadlink; 077 /** The plugin icon path inside jar. */ 078 public String iconPath; 079 /** The plugin icon. */ 080 public ImageIcon icon; 081 /** Plugin can be loaded at any time and not just at start. */ 082 public boolean canloadatruntime; 083 /** The libraries referenced in Class-Path manifest attribute. */ 084 public List<URL> libraries = new LinkedList<>(); 085 /** All manifest attributes. */ 086 public final Map<String, String> attr = new TreeMap<>(); 087 088 private static final ImageIcon emptyIcon = new ImageIcon(new BufferedImage(24, 24, BufferedImage.TYPE_INT_ARGB)); 089 090 /** 091 * Creates a plugin information object by reading the plugin information from 092 * the manifest in the plugin jar. 093 * 094 * The plugin name is derived from the file name. 095 * 096 * @param file the plugin jar file 097 * @throws PluginException if reading the manifest fails 098 */ 099 public PluginInformation(File file) throws PluginException { 100 this(file, file.getName().substring(0, file.getName().length()-4)); 101 } 102 103 /** 104 * Creates a plugin information object for the plugin with name {@code name}. 105 * Information about the plugin is extracted from the manifest file in the plugin jar 106 * {@code file}. 107 * @param file the plugin jar 108 * @param name the plugin name 109 * @throws PluginException if reading the manifest file fails 110 */ 111 public PluginInformation(File file, String name) throws PluginException { 112 if (!PluginHandler.isValidJar(file)) { 113 throw new PluginException(name, tr("Invalid jar file ''{0}''", file)); 114 } 115 this.name = name; 116 this.file = file; 117 try ( 118 FileInputStream fis = new FileInputStream(file); 119 JarInputStream jar = new JarInputStream(fis) 120 ) { 121 Manifest manifest = jar.getManifest(); 122 if (manifest == null) 123 throw new PluginException(name, tr("The plugin file ''{0}'' does not include a Manifest.", file.toString())); 124 scanManifest(manifest, false); 125 libraries.add(0, Utils.fileToURL(file)); 126 } catch (IOException e) { 127 throw new PluginException(name, e); 128 } 129 } 130 131 /** 132 * Creates a plugin information object by reading plugin information in Manifest format 133 * from the input stream {@code manifestStream}. 134 * 135 * @param manifestStream the stream to read the manifest from 136 * @param name the plugin name 137 * @param url the download URL for the plugin 138 * @throws PluginException if the plugin information can't be read from the input stream 139 */ 140 public PluginInformation(InputStream manifestStream, String name, String url) throws PluginException { 141 this.name = name; 142 try { 143 Manifest manifest = new Manifest(); 144 manifest.read(manifestStream); 145 if (url != null) { 146 downloadlink = url; 147 } 148 scanManifest(manifest, url != null); 149 } catch (IOException e) { 150 throw new PluginException(name, e); 151 } 152 } 153 154 /** 155 * Updates the plugin information of this plugin information object with the 156 * plugin information in a plugin information object retrieved from a plugin 157 * update site. 158 * 159 * @param other the plugin information object retrieved from the update site 160 */ 161 public void updateFromPluginSite(PluginInformation other) { 162 this.mainversion = other.mainversion; 163 this.className = other.className; 164 this.requires = other.requires; 165 this.link = other.link; 166 this.description = other.description; 167 this.early = other.early; 168 this.author = other.author; 169 this.stage = other.stage; 170 this.version = other.version; 171 this.downloadlink = other.downloadlink; 172 this.icon = other.icon; 173 this.iconPath = other.iconPath; 174 this.canloadatruntime = other.canloadatruntime; 175 this.libraries = other.libraries; 176 this.attr.clear(); 177 this.attr.putAll(other.attr); 178 } 179 180 /** 181 * Updates the plugin information of this plugin information object with the 182 * plugin information in a plugin information object retrieved from a plugin jar. 183 * 184 * @param other the plugin information object retrieved from the jar file 185 * @since 5601 186 */ 187 public void updateFromJar(PluginInformation other) { 188 updateLocalInfo(other); 189 if (other.icon != null) { 190 this.icon = other.icon; 191 } 192 this.early = other.early; 193 this.className = other.className; 194 this.canloadatruntime = other.canloadatruntime; 195 this.libraries = other.libraries; 196 this.stage = other.stage; 197 this.file = other.file; 198 } 199 200 private void scanManifest(Manifest manifest, boolean oldcheck) { 201 String lang = LanguageInfo.getLanguageCodeManifest(); 202 Attributes attr = manifest.getMainAttributes(); 203 className = attr.getValue("Plugin-Class"); 204 String s = attr.getValue(lang+"Plugin-Link"); 205 if (s == null) { 206 s = attr.getValue("Plugin-Link"); 207 } 208 if (s != null) { 209 try { 210 new URL(s); 211 } catch (MalformedURLException e) { 212 Main.info(tr("Invalid URL ''{0}'' in plugin {1}", s, name)); 213 s = null; 214 } 215 } 216 link = s; 217 requires = attr.getValue("Plugin-Requires"); 218 s = attr.getValue(lang+"Plugin-Description"); 219 if (s == null) { 220 s = attr.getValue("Plugin-Description"); 221 if (s != null) { 222 try { 223 s = tr(s); 224 } catch (IllegalArgumentException e) { 225 Main.info(tr("Invalid plugin description ''{0}'' in plugin {1}", s, name)); 226 } 227 } 228 } else { 229 s = MessageFormat.format(s, (Object[]) null); 230 } 231 description = s; 232 early = Boolean.parseBoolean(attr.getValue("Plugin-Early")); 233 String stageStr = attr.getValue("Plugin-Stage"); 234 stage = stageStr == null ? 50 : Integer.parseInt(stageStr); 235 version = attr.getValue("Plugin-Version"); 236 s = attr.getValue("Plugin-Mainversion"); 237 if (s != null) { 238 try { 239 mainversion = Integer.parseInt(s); 240 } catch (NumberFormatException e) { 241 Main.warn(tr("Invalid plugin main version ''{0}'' in plugin {1}", s, name)); 242 } 243 } else { 244 Main.warn(tr("Missing plugin main version in plugin {0}", name)); 245 } 246 author = attr.getValue("Author"); 247 iconPath = attr.getValue("Plugin-Icon"); 248 if (iconPath != null) { 249 if (file != null) { 250 // extract icon from the plugin jar file 251 icon = new ImageProvider(iconPath).setArchive(file).setMaxWidth(24).setMaxHeight(24).setOptional(true).get(); 252 } else if (iconPath.startsWith("data:")) { 253 icon = new ImageProvider(iconPath).setMaxWidth(24).setMaxHeight(24).setOptional(true).get(); 254 } 255 } 256 canloadatruntime = Boolean.parseBoolean(attr.getValue("Plugin-Canloadatruntime")); 257 if (oldcheck && mainversion > Version.getInstance().getVersion()) { 258 int myv = Version.getInstance().getVersion(); 259 for (Map.Entry<Object, Object> entry : attr.entrySet()) { 260 try { 261 String key = ((Attributes.Name) entry.getKey()).toString(); 262 if (key.endsWith("_Plugin-Url")) { 263 int mv = Integer.parseInt(key.substring(0, key.length()-11)); 264 if (mv <= myv && (mv > mainversion || mainversion > myv)) { 265 String v = (String) entry.getValue(); 266 int i = v.indexOf(';'); 267 if (i > 0) { 268 downloadlink = v.substring(i+1); 269 mainversion = mv; 270 version = v.substring(0, i); 271 oldmode = true; 272 } 273 } 274 } 275 } catch (Exception e) { 276 Main.error(e); 277 } 278 } 279 } 280 281 String classPath = attr.getValue(Attributes.Name.CLASS_PATH); 282 if (classPath != null) { 283 for (String entry : classPath.split(" ")) { 284 File entryFile; 285 if (new File(entry).isAbsolute() || file == null) { 286 entryFile = new File(entry); 287 } else { 288 entryFile = new File(file.getParent(), entry); 289 } 290 291 libraries.add(Utils.fileToURL(entryFile)); 292 } 293 } 294 for (Object o : attr.keySet()) { 295 this.attr.put(o.toString(), attr.getValue(o.toString())); 296 } 297 } 298 299 /** 300 * Replies the description as HTML document, including a link to a web page with 301 * more information, provided such a link is available. 302 * 303 * @return the description as HTML document 304 */ 305 public String getDescriptionAsHtml() { 306 StringBuilder sb = new StringBuilder(128); 307 sb.append("<html><body>") 308 .append(description == null ? tr("no description available") : description); 309 if (link != null) { 310 sb.append(" <a href=\"").append(link).append("\">").append(tr("More info...")).append("</a>"); 311 } 312 if (downloadlink != null 313 && !downloadlink.startsWith("http://svn.openstreetmap.org/applications/editors/josm/dist/") 314 && !downloadlink.startsWith("https://svn.openstreetmap.org/applications/editors/josm/dist/") 315 && !downloadlink.startsWith("http://trac.openstreetmap.org/browser/applications/editors/josm/dist/") 316 && !downloadlink.startsWith("https://github.com/JOSM/")) { 317 sb.append("<p> </p><p>").append(tr("<b>Plugin provided by an external source:</b> {0}", downloadlink)).append("</p>"); 318 } 319 sb.append("</body></html>"); 320 return sb.toString(); 321 } 322 323 /** 324 * Loads and instantiates the plugin. 325 * 326 * @param klass the plugin class 327 * @return the instantiated and initialized plugin 328 * @throws PluginException if the plugin cannot be loaded or instanciated 329 */ 330 public PluginProxy load(Class<?> klass) throws PluginException { 331 try { 332 Constructor<?> c = klass.getConstructor(PluginInformation.class); 333 Object plugin = c.newInstance(this); 334 return new PluginProxy(plugin, this); 335 } catch (NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException e) { 336 throw new PluginException(name, e); 337 } 338 } 339 340 /** 341 * Loads the class of the plugin. 342 * 343 * @param classLoader the class loader to use 344 * @return the loaded class 345 * @throws PluginException if the class cannot be loaded 346 */ 347 public Class<?> loadClass(ClassLoader classLoader) throws PluginException { 348 if (className == null) 349 return null; 350 try { 351 return Class.forName(className, true, classLoader); 352 } catch (NoClassDefFoundError | ClassNotFoundException | ClassCastException e) { 353 throw new PluginException(name, e); 354 } 355 } 356 357 /** 358 * Try to find a plugin after some criterias. Extract the plugin-information 359 * from the plugin and return it. The plugin is searched in the following way: 360 *<ol> 361 *<li>first look after an MANIFEST.MF in the package org.openstreetmap.josm.plugins.<plugin name> 362 * (After removing all fancy characters from the plugin name). 363 * If found, the plugin is loaded using the bootstrap classloader.</li> 364 *<li>If not found, look for a jar file in the user specific plugin directory 365 * (~/.josm/plugins/<plugin name>.jar)</li> 366 *<li>If not found and the environment variable JOSM_RESOURCES + "/plugins/" exist, look there.</li> 367 *<li>Try for the java property josm.resources + "/plugins/" (set via java -Djosm.plugins.path=...)</li> 368 *<li>If the environment variable ALLUSERSPROFILE and APPDATA exist, look in 369 * ALLUSERSPROFILE/<the last stuff from APPDATA>/JOSM/plugins. 370 * (*sic* There is no easy way under Windows to get the All User's application 371 * directory)</li> 372 *<li>Finally, look in some typical unix paths:<ul> 373 * <li>/usr/local/share/josm/plugins/</li> 374 * <li>/usr/local/lib/josm/plugins/</li> 375 * <li>/usr/share/josm/plugins/</li> 376 * <li>/usr/lib/josm/plugins/</li></ul></li> 377 *</ol> 378 * If a plugin class or jar file is found earlier in the list but seem not to 379 * be working, an PluginException is thrown rather than continuing the search. 380 * This is so JOSM can detect broken user-provided plugins and do not go silently 381 * ignore them. 382 * 383 * The plugin is not initialized. If the plugin is a .jar file, it is not loaded 384 * (only the manifest is extracted). In the classloader-case, the class is 385 * bootstraped (e.g. static {} - declarations will run. However, nothing else is done. 386 * 387 * @param pluginName The name of the plugin (in all lowercase). E.g. "lang-de" 388 * @return Information about the plugin or <code>null</code>, if the plugin 389 * was nowhere to be found. 390 * @throws PluginException In case of broken plugins. 391 */ 392 public static PluginInformation findPlugin(String pluginName) throws PluginException { 393 String name = pluginName; 394 name = name.replaceAll("[-. ]", ""); 395 try (InputStream manifestStream = PluginInformation.class.getResourceAsStream("/org/openstreetmap/josm/plugins/"+name+"/MANIFEST.MF")) { 396 if (manifestStream != null) { 397 return new PluginInformation(manifestStream, pluginName, null); 398 } 399 } catch (IOException e) { 400 Main.warn(e); 401 } 402 403 Collection<String> locations = getPluginLocations(); 404 405 for (String s : locations) { 406 File pluginFile = new File(s, pluginName + ".jar"); 407 if (pluginFile.exists()) { 408 return new PluginInformation(pluginFile); 409 } 410 } 411 return null; 412 } 413 414 /** 415 * Returns all possible plugin locations. 416 * @return all possible plugin locations. 417 */ 418 public static Collection<String> getPluginLocations() { 419 Collection<String> locations = Main.pref.getAllPossiblePreferenceDirs(); 420 Collection<String> all = new ArrayList<>(locations.size()); 421 for (String s : locations) { 422 all.add(s+"plugins"); 423 } 424 return all; 425 } 426 427 /** 428 * Replies true if the plugin with the given information is most likely outdated with 429 * respect to the referenceVersion. 430 * 431 * @param referenceVersion the reference version. Can be null if we don't know a 432 * reference version 433 * 434 * @return true, if the plugin needs to be updated; false, otherweise 435 */ 436 public boolean isUpdateRequired(String referenceVersion) { 437 if (this.downloadlink == null) return false; 438 if (this.version == null && referenceVersion != null) 439 return true; 440 if (this.version != null && !this.version.equals(referenceVersion)) 441 return true; 442 return false; 443 } 444 445 /** 446 * Replies true if this this plugin should be updated/downloaded because either 447 * it is not available locally (its local version is null) or its local version is 448 * older than the available version on the server. 449 * 450 * @return true if the plugin should be updated 451 */ 452 public boolean isUpdateRequired() { 453 if (this.downloadlink == null) return false; 454 if (this.localversion == null) return true; 455 return isUpdateRequired(this.localversion); 456 } 457 458 protected boolean matches(String filter, String value) { 459 if (filter == null) return true; 460 if (value == null) return false; 461 return value.toLowerCase(Locale.ENGLISH).contains(filter.toLowerCase(Locale.ENGLISH)); 462 } 463 464 /** 465 * Replies true if either the name, the description, or the version match (case insensitive) 466 * one of the words in filter. Replies true if filter is null. 467 * 468 * @param filter the filter expression 469 * @return true if this plugin info matches with the filter 470 */ 471 public boolean matches(String filter) { 472 if (filter == null) return true; 473 String[] words = filter.split("\\s+"); 474 for (String word: words) { 475 if (matches(word, name) 476 || matches(word, description) 477 || matches(word, version) 478 || matches(word, localversion)) 479 return true; 480 } 481 return false; 482 } 483 484 /** 485 * Replies the name of the plugin. 486 * @return The plugin name 487 */ 488 public String getName() { 489 return name; 490 } 491 492 /** 493 * Sets the name 494 * @param name Plugin name 495 */ 496 public void setName(String name) { 497 this.name = name; 498 } 499 500 /** 501 * Replies the plugin icon, scaled to 24x24 pixels. 502 * @return the plugin icon, scaled to 24x24 pixels. 503 */ 504 public ImageIcon getScaledIcon() { 505 if (icon == null) 506 return emptyIcon; 507 return new ImageIcon(icon.getImage().getScaledInstance(24, 24, Image.SCALE_SMOOTH)); 508 } 509 510 @Override 511 public final String toString() { 512 return getName(); 513 } 514 515 private static List<String> getRequiredPlugins(String pluginList) { 516 List<String> requiredPlugins = new ArrayList<>(); 517 if (pluginList != null) { 518 for (String s : pluginList.split(";")) { 519 String plugin = s.trim(); 520 if (!plugin.isEmpty()) { 521 requiredPlugins.add(plugin); 522 } 523 } 524 } 525 return requiredPlugins; 526 } 527 528 /** 529 * Replies the list of plugins required by the up-to-date version of this plugin. 530 * @return List of plugins required. Empty if no plugin is required. 531 * @since 5601 532 */ 533 public List<String> getRequiredPlugins() { 534 return getRequiredPlugins(requires); 535 } 536 537 /** 538 * Replies the list of plugins required by the local instance of this plugin. 539 * @return List of plugins required. Empty if no plugin is required. 540 * @since 5601 541 */ 542 public List<String> getLocalRequiredPlugins() { 543 return getRequiredPlugins(localrequires); 544 } 545 546 /** 547 * Updates the local fields ({@link #localversion}, {@link #localmainversion}, {@link #localrequires}) 548 * to values contained in the up-to-date fields ({@link #version}, {@link #mainversion}, {@link #requires}) 549 * of the given PluginInformation. 550 * @param info The plugin information to get the data from. 551 * @since 5601 552 */ 553 public void updateLocalInfo(PluginInformation info) { 554 if (info != null) { 555 this.localversion = info.version; 556 this.localmainversion = info.mainversion; 557 this.localrequires = info.requires; 558 } 559 } 560}