src/jalview/bin/Cache.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.bin;
  22
  23 import java.awt.Color;
  24 import java.io.BufferedReader;
  25 import java.io.FileInputStream;
  26 import java.io.FileOutputStream;
  27 import java.io.InputStream;
  28 import java.io.InputStreamReader;
  29 import java.net.URL;
  30 import java.text.DateFormat;
  31 import java.text.SimpleDateFormat;
  32 import java.util.Collections;
  33 import java.util.Date;
  34 import java.util.Enumeration;
  35 import java.util.Locale;
  36 import java.util.Properties;
  37 import java.util.StringTokenizer;
  38 import java.util.TreeSet;
  39
  40 import org.apache.log4j.ConsoleAppender;
  41 import org.apache.log4j.Level;
  42 import org.apache.log4j.Logger;
  43 import org.apache.log4j.SimpleLayout;
  44
  45 import jalview.bin.ApplicationSingletonProvider.ApplicationSingletonI;
  46 import jalview.datamodel.PDBEntry;
  47 import jalview.gui.UserDefinedColours;
  48 import jalview.schemes.ColourSchemeLoader;
  49 import jalview.schemes.ColourSchemes;
  50 import jalview.schemes.UserColourScheme;
  51 import jalview.structure.StructureImportSettings;
  52 import jalview.urls.IdOrgSettings;
  53 import jalview.util.ColorUtils;
  54 import jalview.util.Platform;
  55 import jalview.ws.sifts.SiftsSettings;
  56
  57 /**
  58  * Stores and retrieves Jalview Application Properties Lists and fields within
  59  * list entries are separated by '|' symbols unless otherwise stated (|) clauses
  60  * are alternative values for a tag. <br>
  61  * <br>
  62  * Current properties include:
  63  * <ul>
  64  * <br>
  65  * logs.Axis.Level - one of the stringified Levels for log4j controlling the
  66  * logging level for axis (used for web services) <br>
  67  * </li>
  68  * <li>logs.Castor.Level - one of the stringified Levels for log4j controlling
  69  * the logging level for castor (used for serialization) <br>
  70  * </li>
  71  * <li>logs.Jalview.Level - Cache.log stringified level. <br>
  72  * </li>
  73  * <li>SCREEN_WIDTH</li>
  74  * <li>SCREEN_HEIGHT</li>
  75  * <li>SCREEN_Y=285</li>
  76  * <li>SCREEN_X=371</li>
  77  * <li>SHOW_FULLSCREEN boolean</li>
  78  * <li>FONT_NAME java font name for alignment text display</li>
  79  * <li>FONT_SIZE size of displayed alignment text</li>
  80  * <li>FONT_STYLE style of font displayed (sequence labels are always
  81  * italic)</li>
  82  * <li>GAP_SYMBOL character to treat as gap symbol (usually -,.,' ')</li>
  83  * <li>LAST_DIRECTORY last directory for browsing alignment</li>
  84  * <li>USER_DEFINED_COLOURS list of user defined colour scheme files</li>
  85  * <li>SHOW_FULL_ID show id with '/start-end' numbers appended</li>
  86  * <li>SHOW_IDENTITY show percentage identity annotation</li>
  87  * <li>SHOW_QUALITY show alignment quality annotation</li>
  88  * <li>SHOW_ANNOTATIONS show alignment annotation rows</li>
  89  * <li>SHOW_CONSERVATION show alignment conservation annotation</li>
  90  * <li>SORT_ANNOTATIONS currently either SEQUENCE_AND_LABEL or
  91  * LABEL_AND_SEQUENCE</li>
  92  * <li>SHOW_AUTOCALC_ABOVE true to show autocalculated annotations above
  93  * sequence annotations</li>
  94  * <li>CENTRE_COLUMN_LABELS centre the labels at each column in a displayed
  95  * annotation row</li>
  96  * <li>DEFAULT_COLOUR default colour scheme to apply for a new alignment</li>
  97  * <li>DEFAULT_FILE_FORMAT file format used to save</li>
  98  * <li>STARTUP_FILE file loaded on startup (may be a fully qualified url)</li>
  99  * <li>SHOW_STARTUP_FILE flag to control loading of startup file</li>
 100  * <li>VERSION the version of the jalview build</li>
 101  * <li>BUILD_DATE date of this build</li>
 102  * <li>LATEST_VERSION the latest jalview version advertised on the
 103  * www.jalview.org</li>
 104  * <li>PIR_MODELLER boolean indicating if PIR files are written with MODELLER
 105  * descriptions</li>
 106  * <li>(FASTA,MSF,PILEUP,CLUSTAL,BLC,PIR,PFAM)_JVSUFFIX boolean for adding jv
 107  * suffix to file</li>
 108  * <li>RECENT_URL list of recently retrieved URLs</li>
 109  * <li>RECENT_FILE list of recently opened files</li>
 110  * <li>USE_PROXY flag for whether a http proxy is to be used</li>
 111  * <li>PROXY_SERVER the proxy</li>
 112  * <li>PROXY_PORT</li>
 113  * <li>NOQUESTIONNAIRES true to prevent jalview from checking the questionnaire
 114  * service</li>
 115  * <li>QUESTIONNAIRE last questionnaire:responder id string from questionnaire
 116  * service</li>
 117  * <li>USAGESTATS (false - user prompted) Enable google analytics tracker for
 118  * collecting usage statistics</li>
 119  * <li>SHOW_OVERVIEW boolean for overview window display</li>
 120  * <li>ANTI_ALIAS boolean for smooth fonts</li>
 121  * <li>RIGHT_ALIGN_IDS boolean</li>
 122  * <li>AUTO_CALC_CONSENSUS boolean for automatic recalculation of consensus</li>
 123  * <li>PAD_GAPS boolean</li>
 124  * <li>ID_ITALICS boolean</li>
 125  * <li>SHOW_JV_SUFFIX</li>
 126  * <li>WRAP_ALIGNMENT</li>
 127  * <li>EPS_RENDERING (Prompt each time|Lineart|Text) default for EPS rendering
 128  * style check</li>
 129  * <li>SORT_ALIGNMENT (No sort|Id|Pairwise Identity)</li>
 130  * <li>SEQUENCE_LINKS list of name|URL pairs for opening a url with
 131  * $SEQUENCE_ID$</li>
 132  * <li>STORED_LINKS list of name|url pairs which user has entered but are not
 133  * currently used
 134  * <li>DEFAULT_LINK name of single url to be used when user double clicks a
 135  * sequence id (must be in SEQUENCE_LINKS or STORED_LINKS)
 136  * <li>GROUP_LINKS list of name|URL[|&lt;separator&gt;] tuples - see
 137  * jalview.utils.GroupURLLink for more info</li>
 138  * <li>DEFAULT_BROWSER for unix</li>
 139  * <li>SHOW_MEMUSAGE boolean show memory usage and warning indicator on desktop
 140  * (false)</li>
 141  * <li>VERSION_CHECK (true) check for the latest release version from
 142  * www.jalview.org (or the alias given by the www.jalview.org property)</li>
 143  * <li>SHOW_NPFEATS_TOOLTIP (true) show non-positional features in the Sequence
 144  * ID tooltip</li>
 145  * <li>SHOW_DBREFS_TOOLTIP (true) show Database Cross References in the Sequence
 146  * ID tooltip</li>
 147  * <li>SHOW_UNCONSERVED (false) only render unconserved residues - conserved
 148  * displayed as '.'</li>
 149  * <li>SORT_BY_TREE (false) sort the current alignment view according to the
 150  * order of a newly displayed tree</li>
 151  * <li>DBFETCH_USEPICR (false) use PICR to recover valid DB references from
 152  * sequence ID strings before attempting retrieval from any datasource</li>
 153  * <li>SHOW_GROUP_CONSENSUS (false) Show consensus annotation for groups in the
 154  * alignment.</li>
 155  * <li>SHOW_GROUP_CONSERVATION (false) Show conservation annotation for groups
 156  * in the alignment.</li>
 157  * <li>SHOW_CONSENSUS_HISTOGRAM (false) Show consensus annotation row's
 158  * histogram.</li>
 159  * <li>SHOW_CONSENSUS_LOGO (false) Show consensus annotation row's sequence
 160  * logo.</li>
 161  * <li>NORMALISE_CONSENSUS_LOGO (false) Show consensus annotation row's sequence
 162  * logo normalised to row height rather than histogram height.</li>
 163  * <li>FOLLOW_SELECTIONS (true) Controls whether a new alignment view should
 164  * respond to selections made in other alignments containing the same sequences.
 165  * </li>
 166  * <li>JWS2HOSTURLS comma-separated list of URLs to try for JABAWS services</li>
 167  * <li>SHOW_WSDISCOVERY_ERRORS (true) Controls if the web service URL discovery
 168  * warning dialog box is displayed.</li>
 169  * <li>ANNOTATIONCOLOUR_MIN (orange) Shade used for minimum value of annotation
 170  * when shading by annotation</li>
 171  * <li>ANNOTATIONCOLOUR_MAX (red) Shade used for maximum value of annotation
 172  * when shading by annotation</li>
 173  * <li>www.jalview.org (http://www.jalview.org) a property enabling all HTTP
 174  * requests to be redirected to a mirror of http://www.jalview.org</li>
 175  * <li>FIGURE_AUTOIDWIDTH (false) Expand the left hand column of an exported
 176  * alignment figure to accommodate even the longest sequence ID or annotation
 177  * label.</li>
 178  * <li>FIGURE_FIXEDIDWIDTH Specifies the width to use for the left-hand column
 179  * when exporting an alignment as a figure (setting FIGURE_AUTOIDWIDTH to true
 180  * will override this).</li>
 181  * <li>STRUCT_FROM_PDB (false) derive secondary structure annotation from PDB
 182  * record</li>
 183  * <li>USE_RNAVIEW (false) use RNAViewer to derive secondary structure</li>
 184  * <li>ADD_SS_ANN (false) add secondary structure annotation to alignment
 185  * display</li>
 186  * <li>ADD_TEMPFACT_ANN (false) add Temperature Factor annotation to alignment
 187  * display</li>
 188  * <li>STRUCTURE_DISPLAY choose from JMOL (default) or CHIMERA for 3D structure
 189  * display</li>
 190  * <li>CHIMERA_PATH specify full path to Chimera program (if non-standard)</li>
 191  * <li>ID_ORG_HOSTURL location of jalview service providing identifiers.org urls
 192  * </li>
 193  *
 194  * </ul>
 195  * Deprecated settings:
 196  * <ul>
 197  * *
 198  * <li>DISCOVERY_START - Boolean - controls if discovery services are queried on
 199  * startup (JWS1 services only)</li>
 200  * <li>DISCOVERY_URLS - comma separated list of Discovery Service endpoints.
 201  * (JWS1 services only)</li>
 202  * <li>SHOW_JWS1_SERVICES (true) enable or disable the original Jalview 2
 203  * services in the desktop GUI</li>
 204  * <li>ENABLE_RSBS_EDITOR (false for 2.7 release) enable or disable RSBS editing
 205  * panel in web service preferences</li>
 206  * </ul>
 207  *
 208  * @author $author$
 209  * @version $Revision$
 210  */
 211 public class Cache implements ApplicationSingletonI
 212 {
 213
 214   private Cache()
 215   {
 216     // private singleton
 217   }
 218
 219   /**
 220    * In Java, this will be a static field instance, which will be
 221    * application-specific; in JavaScript it will be an applet-specific instance
 222    * tied to the applet's ThreadGroup.
 223    *
 224    * @return
 225    */
 226   public static Cache getInstance()
 227   {
 228     return (Cache) ApplicationSingletonProvider.getInstance(Cache.class);
 229   }
 230
 231   /**
 232    * property giving log4j level for CASTOR loggers
 233    */
 234   public static final String CASTORLOGLEVEL = "logs.Castor.level";
 235
 236   /**
 237    * property giving log4j level for AXIS loggers
 238    */
 239   public static final String AXISLOGLEVEL = "logs.Axis.level";
 240
 241   /**
 242    * property giving log4j level for Jalview Log
 243    */
 244   public static final String JALVIEWLOGLEVEL = "logs.Jalview.level";
 245
 246   /**
 247    * Sifts settings
 248    */
 249   public static final String DEFAULT_SIFTS_DOWNLOAD_DIR = Platform.getUserPath(".sifts_downloads/");
 250
 251   private final static String DEFAULT_CACHE_THRESHOLD_IN_DAYS = "2";
 252
 253   private final static String DEFAULT_FAIL_SAFE_PID_THRESHOLD = "30";
 254
 255   /**
 256    * Identifiers.org download settings
 257    */
 258   private static final String ID_ORG_FILE = Platform.getUserPath(".identifiers.org.ids.json");
 259
 260   /**
 261    * Allowed values are PDB or mmCIF
 262    */
 263   private final static String PDB_DOWNLOAD_FORMAT = PDBEntry.Type.MMCIF
 264           .toString();
 265
 266   private final static String DEFAULT_PDB_FILE_PARSER = StructureImportSettings.StructureParser.JMOL_PARSER
 267           .toString();
 268
 269   /*
 270    * a date formatter using a fixed (rather than the user's) locale;
 271    * this ensures that date properties can be written and re-read successfully
 272    * even if the user changes their locale setting
 273    */
 274   private static final DateFormat date_format = SimpleDateFormat
 275           .getDateTimeInstance(SimpleDateFormat.MEDIUM,
 276                   SimpleDateFormat.MEDIUM, Locale.UK);
 277
 278   /**
 279    * Initialises the Jalview Application Log
 280    */
 281   public static Logger log;
 282
 283   /** Jalview Properties */
 284   private Properties applicationProperties = new Properties()
 285   {
 286     // override results in properties output in alphabetical order
 287     @Override
 288     public synchronized Enumeration<Object> keys()
 289     {
 290       return Collections.enumeration(new TreeSet<>(super.keySet()));
 291     }
 292   };
 293
 294   /** Default file is ~/.jalview_properties */
 295   static String propertiesFile;
 296
 297   private static boolean propsAreReadOnly = Platform.isJS();
 298
 299   private final static String JS_PROPERTY_PREFIX = "jalview_";
 300
 301   public static void initLogger()
 302   {
 303     if (log != null)
 304     {
 305       return;
 306     }
 307     try
 308     {
 309       // TODO: redirect stdout and stderr here in order to grab the output of
 310       // the log
 311
 312       ConsoleAppender ap = new ConsoleAppender(new SimpleLayout(),
 313               "System.err");
 314       ap.setName("JalviewLogger");
 315       org.apache.log4j.Logger.getRootLogger().addAppender(ap); // catch all for
 316       // log output
 317       Logger laxis = Logger.getLogger("org.apache.axis");
 318       Logger lcastor = Logger.getLogger("org.exolab.castor");
 319       jalview.bin.Cache.log = Logger.getLogger("jalview.bin.Jalview");
 320
 321       laxis.setLevel(Level.toLevel(
 322               Cache.getDefault("logs.Axis.Level", Level.INFO.toString())));
 323       lcastor.setLevel(Level.toLevel(Cache.getDefault("logs.Castor.Level",
 324               Level.INFO.toString())));
 325       lcastor = Logger.getLogger("org.exolab.castor.xml");
 326       lcastor.setLevel(Level.toLevel(Cache.getDefault("logs.Castor.Level",
 327               Level.INFO.toString())));
 328       // lcastor = Logger.getLogger("org.exolab.castor.xml.Marshaller");
 329       // lcastor.setLevel(Level.toLevel(Cache.getDefault("logs.Castor.Level",
 330       // Level.INFO.toString())));
 331       jalview.bin.Cache.log.setLevel(Level.toLevel(Cache
 332               .getDefault("logs.Jalview.level", Level.INFO.toString())));
 333       // laxis.addAppender(ap);
 334       // lcastor.addAppender(ap);
 335       // jalview.bin.Cache.log.addAppender(ap);
 336       // Tell the user that debug is enabled
 337       jalview.bin.Cache.log.debug("Jalview Debugging Output Follows.");
 338     } catch (Exception ex)
 339     {
 340       System.err.println("Problems initializing the log4j system\n");
 341       ex.printStackTrace(System.err);
 342     }
 343   }
 344
 345   /**
 346    * Loads properties from the given properties file. Any existing properties
 347    * are first cleared.
 348    */
 349   public static void loadProperties(String propsFile)
 350   {
 351
 352     getInstance().loadPropertiesImpl(propsFile);
 353
 354   }
 355
 356   private void loadPropertiesImpl(String propsFile)
 357   {
 358
 359     propertiesFile = propsFile;
 360     if (propsFile == null && !propsAreReadOnly)
 361     {
 362       propertiesFile = Platform.getUserPath(".jalview_properties");
 363     }
 364     else
 365     {
 366       // don't corrupt the file we've been given.
 367       propsAreReadOnly = true;
 368     }
 369
 370     if (propertiesFile == null)
 371     { // BH 2019
 372       Platform.readInfoProperties(JS_PROPERTY_PREFIX,
 373               applicationProperties);
 374     }
 375     else
 376     {
 377       try
 378       {
 379         InputStream fis;
 380         try
 381         {
 382           fis = new java.net.URL(propertiesFile).openStream();
 383           System.out.println(
 384                   "Loading jalview properties from : " + propertiesFile);
 385           System.out.println(
 386                   "Disabling Jalview writing to user's local properties file.");
 387           propsAreReadOnly = true;
 388
 389         } catch (Exception ex)
 390         {
 391           fis = null;
 392         }
 393         if (fis == null)
 394         {
 395           fis = new FileInputStream(propertiesFile);
 396         }
 397         applicationProperties.clear();
 398         applicationProperties.load(fis);
 399
 400         // remove any old build properties
 401
 402         deleteBuildProperties();
 403         fis.close();
 404       } catch (Exception ex)
 405       {
 406         System.out.println("Error reading properties file: " + ex);
 407       }
 408     }
 409     if (getDefault("USE_PROXY", false))
 410     {
 411       String proxyServer = getDefault("PROXY_SERVER", ""),
 412               proxyPort = getDefault("PROXY_PORT", "8080");
 413
 414       System.out.println("Using proxyServer: " + proxyServer
 415               + " proxyPort: " + proxyPort);
 416
 417       System.setProperty("http.proxyHost", proxyServer);
 418       System.setProperty("http.proxyPort", proxyPort);
 419     }
 420
 421     // LOAD THE AUTHORS FROM THE authors.props file
 422     String authorDetails = resolveResourceURLFor("/authors.props");
 423
 424     try
 425     {
 426       if (authorDetails != null)
 427       {
 428         URL localJarFileURL = new URL(authorDetails);
 429         InputStream in = localJarFileURL.openStream();
 430         applicationProperties.load(in);
 431         in.close();
 432       }
 433     } catch (Exception ex)
 434     {
 435       System.out.println("Error reading author details: " + ex);
 436       authorDetails = null;
 437     }
 438     if (authorDetails == null)
 439     {
 440       applicationProperties.remove("AUTHORS");
 441       applicationProperties.remove("AUTHORFNAMES");
 442       applicationProperties.remove("YEAR");
 443     }
 444
 445     loadBuildProperties(false);
 446
 447     SiftsSettings
 448             .setMapWithSifts(Cache.getDefault("MAP_WITH_SIFTS", false));
 449
 450     SiftsSettings.setSiftDownloadDirectory(jalview.bin.Cache
 451             .getDefault("sifts_download_dir", DEFAULT_SIFTS_DOWNLOAD_DIR));
 452
 453     SiftsSettings.setFailSafePIDThreshold(
 454             jalview.bin.Cache.getDefault("sifts_fail_safe_pid_threshold",
 455                     DEFAULT_FAIL_SAFE_PID_THRESHOLD));
 456
 457     SiftsSettings.setCacheThresholdInDays(
 458             jalview.bin.Cache.getDefault("sifts_cache_threshold_in_days",
 459                     DEFAULT_CACHE_THRESHOLD_IN_DAYS));
 460
 461     IdOrgSettings.setUrl(getDefault("ID_ORG_HOSTURL",
 462             "http://www.jalview.org/services/identifiers"));
 463     IdOrgSettings.setDownloadLocation(ID_ORG_FILE);
 464
 465     StructureImportSettings.setDefaultStructureFileFormat(jalview.bin.Cache
 466             .getDefault("PDB_DOWNLOAD_FORMAT", PDB_DOWNLOAD_FORMAT));
 467     StructureImportSettings
 468             .setDefaultPDBFileParser(DEFAULT_PDB_FILE_PARSER);
 469     // StructureImportSettings
 470     // .setDefaultPDBFileParser(jalview.bin.Cache.getDefault(
 471     // "DEFAULT_PDB_FILE_PARSER", DEFAULT_PDB_FILE_PARSER));
 472
 473     String jnlpVersion = System.getProperty("jalview.version");
 474
 475     // jnlpVersion will be null if a latest version check for the channel needs
 476     // to
 477     // be done
 478     // Dont do this check if running in headless mode
 479
 480     if (jnlpVersion == null && getDefault("VERSION_CHECK", true)
 481             && (System.getProperty("java.awt.headless") == null || System
 482                     .getProperty("java.awt.headless").equals("false")))
 483     {
 484       new Thread()
 485       {
 486         @Override
 487         public void run()
 488         {
 489           String orgtimeout = System
 490                   .getProperty("sun.net.client.defaultConnectTimeout");
 491           if (orgtimeout == null)
 492           {
 493             orgtimeout = "30";
 494             System.out.println("# INFO: Setting default net timeout to "
 495                     + orgtimeout + " seconds.");
 496           }
 497           String remoteVersion = null;
 498           try
 499           {
 500             System.setProperty("sun.net.client.defaultConnectTimeout",
 501                     "5000");
 502             java.net.URL url = new java.net.URL(Cache
 503                     .getDefault("www.jalview.org", "http://www.jalview.org")
 504                     + "/webstart/jalview.jnlp");
 505             BufferedReader in = new BufferedReader(
 506                     new InputStreamReader(url.openStream()));
 507             String line = null;
 508             while ((line = in.readLine()) != null)
 509             {
 510               if (line.indexOf("jalview.version") == -1)
 511               {
 512                 continue;
 513               }
 514
 515               line = line.substring(line.indexOf("value=") + 7);
 516               line = line.substring(0, line.lastIndexOf("\""));
 517               remoteVersion = line;
 518               break;
 519             }
 520           } catch (Exception ex)
 521           {
 522             System.out.println(
 523                     "Non-fatal exception when checking version at www.jalview.org :");
 524             System.out.println(ex);
 525             remoteVersion = getProperty("VERSION");
 526           }
 527           System.setProperty("sun.net.client.defaultConnectTimeout",
 528                   orgtimeout);
 529
 530           setProperty("LATEST_VERSION", remoteVersion);
 531         }
 532       }.start();
 533     }
 534     else
 535     {
 536       if (jnlpVersion != null)
 537       {
 538         setProperty("LATEST_VERSION", jnlpVersion);
 539       }
 540       else
 541       {
 542         applicationProperties.remove("LATEST_VERSION");
 543       }
 544     }
 545
 546     // LOAD USERDEFINED COLOURS
 547     Cache.initUserColourSchemes(getProperty("USER_DEFINED_COLOURS"));
 548     jalview.io.PIRFile.useModellerOutput = Cache.getDefault("PIR_MODELLER",
 549             false);
 550   }
 551
 552   /**
 553    * construct a resource URL for the given absolute resource pathname
 554    *
 555    * @param resourcePath
 556    * @return
 557    */
 558   private static String resolveResourceURLFor(String resourcePath)
 559   {
 560     String url = null;
 561     if (Platform.isJS() || !Cache.class.getProtectionDomain()
 562             .getCodeSource().getLocation().toString().endsWith(".jar"))
 563     {
 564       try
 565       {
 566         url = Cache.class.getResource(resourcePath).toString();
 567       } catch (Exception ex)
 568       {
 569         System.err.println("Failed to resolve resource " + resourcePath
 570                 + ": " + ex.getMessage());
 571       }
 572     }
 573     else
 574     {
 575       url = "jar:".concat(Cache.class.getProtectionDomain().getCodeSource()
 576               .getLocation().toString().concat("!" + resourcePath));
 577     }
 578     return url;
 579   }
 580
 581   public void loadBuildProperties(boolean reportVersion)
 582   {
 583     String codeInstallation = getProperty("INSTALLATION");
 584     boolean printVersion = codeInstallation == null;
 585
 586     /*
 587      * read build properties - from the Jalview jar for a Java distribution,
 588      * or from codebase file in test or JalviewJS context
 589      */
 590     try
 591     {
 592       String buildDetails = resolveResourceURLFor("/.build_properties");
 593       URL localJarFileURL = new URL(buildDetails);
 594       InputStream in = localJarFileURL.openStream();
 595       applicationProperties.load(in);
 596       in.close();
 597     } catch (Exception ex)
 598     {
 599       System.out.println("Error reading build details: " + ex);
 600       applicationProperties.remove("VERSION");
 601     }
 602     String codeVersion = getProperty("VERSION");
 603     codeInstallation = getProperty("INSTALLATION");
 604
 605     if (codeVersion == null)
 606     {
 607       // THIS SHOULD ONLY BE THE CASE WHEN TESTING!!
 608       codeVersion = "Test";
 609       codeInstallation = "";
 610     }
 611     else
 612     {
 613       codeInstallation = " (" + codeInstallation + ")";
 614     }
 615     setProperty("VERSION", codeVersion);
 616     new BuildDetails(codeVersion, null, codeInstallation);
 617     if (printVersion && reportVersion)
 618     {
 619       System.out.println(
 620               "Jalview Version: " + codeVersion + codeInstallation);
 621     }
 622   }
 623
 624   private void deleteBuildProperties()
 625   {
 626     applicationProperties.remove("LATEST_VERSION");
 627     applicationProperties.remove("VERSION");
 628     applicationProperties.remove("AUTHORS");
 629     applicationProperties.remove("AUTHORFNAMES");
 630     applicationProperties.remove("YEAR");
 631     applicationProperties.remove("BUILD_DATE");
 632     applicationProperties.remove("INSTALLATION");
 633   }
 634
 635   /**
 636    * Gets Jalview application property of given key. Returns null if key not
 637    * found
 638    *
 639    * @param key
 640    *          Name of property
 641    *
 642    * @return Property value
 643    */
 644   public static String getProperty(String key)
 645   {
 646     String prop = getInstance().applicationProperties.getProperty(key);
 647     // if (prop == null && Platform.isJS())
 648     // {
 649     // prop = applicationProperties.getProperty(Platform.getUniqueAppletID()
 650     // + "_" + JS_PROPERTY_PREFIX + key);
 651     // }
 652     return prop;
 653   }
 654
 655   /**
 656    * These methods are used when checking if the saved preference is different
 657    * to the default setting
 658    */
 659
 660   public static boolean getDefault(String property, boolean def)
 661   {
 662     String string = getProperty(property);
 663     if (string != null)
 664     {
 665       def = Boolean.valueOf(string).booleanValue();
 666     }
 667
 668     return def;
 669   }
 670
 671   public static int getDefault(String property, int def)
 672   {
 673     String string = getProperty(property);
 674     if (string != null)
 675     {
 676       try
 677       {
 678         def = Integer.parseInt(string);
 679       } catch (NumberFormatException e)
 680       {
 681         System.out.println("Error parsing int property '" + property
 682                 + "' with value '" + string + "'");
 683       }
 684     }
 685
 686     return def;
 687   }
 688
 689   /**
 690    * Answers the value of the given property, or the supplied default value if
 691    * the property is not set
 692    */
 693   public static String getDefault(String property, String def)
 694   {
 695     String value = getProperty(property);
 696     return value == null ? def : value;
 697   }
 698
 699   /**
 700    * Stores property in the file "HOME_DIR/.jalview_properties"
 701    *
 702    * @param key
 703    *          Name of object
 704    * @param obj
 705    *          String value of property
 706    *
 707    * @return previous value of property (or null)
 708    */
 709   public static Object setProperty(String key, String obj)
 710   {
 711     return getInstance().setPropertyImpl(key, obj, true);
 712   }
 713
 714   /**
 715    * Removes the specified property from the jalview properties file
 716    *
 717    * @param key
 718    */
 719   public static void removeProperty(String key)
 720   {
 721     getInstance().removePropertyImpl(key, true);
 722   }
 723
 724   /**
 725    * Removes the named property for the running application, without saving the
 726    * properties file
 727    *
 728    * BH noting that ColourMenuHelper calls this. If the intent is to save, then
 729    * simply chanet that call to removeProperty(key).
 730    *
 731    * @param key
 732    */
 733   public static void removePropertyNoSave(String key)
 734   {
 735
 736     getInstance().
 737
 738             removePropertyImpl(key, false);
 739   }
 740
 741   /**
 742    * Removes the named property, and optionally saves the current properties to
 743    * file
 744    *
 745    * @param key
 746    * @param andSave
 747    */
 748   private void removePropertyImpl(String key, boolean andSave)
 749   {
 750     applicationProperties.remove(key);
 751     if (andSave)
 752       saveProperties();
 753   }
 754
 755   /**
 756    * save the properties to the jalview properties path
 757    */
 758   public static void saveProperties()
 759   {
 760     getInstance().savePropertiesImpl();
 761   }
 762
 763   /**
 764    * save the properties to the jalview properties path
 765    */
 766   private void savePropertiesImpl()
 767
 768   {
 769     if (!propsAreReadOnly)
 770     {
 771       try
 772       {
 773         FileOutputStream out = new FileOutputStream(propertiesFile);
 774         applicationProperties.store(out, "---JalviewX Properties File---");
 775         out.close();
 776       } catch (Exception ex)
 777       {
 778         System.out.println("Error saving properties: " + ex);
 779       }
 780     }
 781   }
 782
 783   /**
 784    * internal vamsas class discovery state
 785    */
 786   private static int vamsasJarsArePresent = -1;
 787
 788   /**
 789    * Searches for vamsas client classes on class path.
 790    *
 791    * @return true if vamsas client is present on classpath
 792    */
 793   public static boolean vamsasJarsPresent()
 794   {
 795     if (vamsasJarsArePresent == -1)
 796     {
 797       try
 798       {
 799         if (jalview.jbgui.GDesktop.class.getClassLoader()
 800                 .loadClass("uk.ac.vamsas.client.VorbaId") != null)
 801         {
 802           jalview.bin.Cache.log.debug(
 803                   "Found Vamsas Classes (uk.ac..vamsas.client.VorbaId can be loaded)");
 804           vamsasJarsArePresent = 1;
 805           Logger lvclient = Logger.getLogger("uk.ac.vamsas");
 806           lvclient.setLevel(Level.toLevel(Cache
 807                   .getDefault("logs.Vamsas.Level", Level.INFO.toString())));
 808
 809           lvclient.addAppender(log.getAppender("JalviewLogger"));
 810           // Tell the user that debug is enabled
 811           lvclient.debug("Jalview Vamsas Client Debugging Output Follows.");
 812         }
 813       } catch (Exception e)
 814       {
 815         vamsasJarsArePresent = 0;
 816         jalview.bin.Cache.log.debug("Vamsas Classes are not present");
 817       }
 818     }
 819     return (vamsasJarsArePresent > 0);
 820   }
 821
 822   /**
 823    * internal vamsas class discovery state
 824    */
 825   private static int groovyJarsArePresent = -1;
 826
 827   /**
 828    * Searches for vamsas client classes on class path.
 829    *
 830    * @return true if vamsas client is present on classpath
 831    */
 832   public static boolean groovyJarsPresent()
 833   {
 834     if (groovyJarsArePresent == -1)
 835     {
 836       try
 837       {
 838         if (Cache.class.getClassLoader()
 839                 .loadClass("groovy.lang.GroovyObject") != null)
 840         {
 841           jalview.bin.Cache.log.debug(
 842                   "Found Groovy (groovy.lang.GroovyObject can be loaded)");
 843           groovyJarsArePresent = 1;
 844           Logger lgclient = Logger.getLogger("groovy");
 845           lgclient.setLevel(Level.toLevel(Cache
 846                   .getDefault("logs.Groovy.Level", Level.INFO.toString())));
 847
 848           lgclient.addAppender(log.getAppender("JalviewLogger"));
 849           // Tell the user that debug is enabled
 850           lgclient.debug("Jalview Groovy Client Debugging Output Follows.");
 851         }
 852       } catch (Error e)
 853       {
 854         groovyJarsArePresent = 0;
 855         jalview.bin.Cache.log.debug("Groovy Classes are not present", e);
 856       } catch (Exception e)
 857       {
 858         groovyJarsArePresent = 0;
 859         jalview.bin.Cache.log.debug("Groovy Classes are not present");
 860       }
 861     }
 862     return (groovyJarsArePresent > 0);
 863   }
 864
 865   /**
 866    * GA tracker object - actually JGoogleAnalyticsTracker null if tracking not
 867    * enabled.
 868    */
 869   protected static Object tracker = null;
 870
 871   protected static Class trackerfocus = null;
 872
 873   protected static Class jgoogleanalyticstracker = null;
 874
 875   /**
 876    * Initialise the google tracker if it is not done already.
 877    */
 878   public static void initGoogleTracker()
 879   {
 880     if (tracker == null)
 881     {
 882       if (jgoogleanalyticstracker == null)
 883       {
 884         // try to get the tracker class
 885         try
 886         {
 887           jgoogleanalyticstracker = Cache.class.getClassLoader().loadClass(
 888                   "com.boxysystems.jgoogleanalytics.JGoogleAnalyticsTracker");
 889           trackerfocus = Cache.class.getClassLoader()
 890                   .loadClass("com.boxysystems.jgoogleanalytics.FocusPoint");
 891         } catch (Exception e)
 892         {
 893           log.debug(
 894                   "com.boxysystems.jgoogleanalytics package is not present - tracking not enabled.");
 895           tracker = null;
 896           jgoogleanalyticstracker = null;
 897           trackerfocus = null;
 898           return;
 899         }
 900       }
 901       // now initialise tracker
 902       Exception re = null, ex = null;
 903       Error err = null;
 904       String vrs = "No Version Accessible";
 905       try
 906       {
 907         // Google analytics tracking code for Library Finder
 908         tracker = jgoogleanalyticstracker
 909                 .getConstructor(new Class[]
 910                 { String.class, String.class, String.class })
 911                 .newInstance(new Object[]
 912                 { "Jalview Desktop",
 913                     (vrs = jalview.bin.Cache.getProperty("VERSION") + "_"
 914                             + jalview.bin.Cache.getDefault("BUILD_DATE",
 915                                     "unknown")),
 916                     "UA-9060947-1" });
 917         jgoogleanalyticstracker
 918                 .getMethod("trackAsynchronously", new Class[]
 919                 { trackerfocus })
 920                 .invoke(tracker, new Object[]
 921                 { trackerfocus.getConstructor(new Class[] { String.class })
 922                         .newInstance(new Object[]
 923                         { "Application Started." }) });
 924       } catch (RuntimeException e)
 925       {
 926         re = e;
 927       } catch (Exception e)
 928       {
 929         ex = e;
 930       } catch (Error e)
 931       {
 932         err = e;
 933       }
 934       if (re != null || ex != null || err != null)
 935       {
 936         if (log != null)
 937         {
 938           if (re != null)
 939           {
 940             log.debug("Caught runtime exception in googletracker init:",
 941                     re);
 942           }
 943           if (ex != null)
 944           {
 945             log.warn(
 946                     "Failed to initialise GoogleTracker for Jalview Desktop with version "
 947                             + vrs,
 948                     ex);
 949           }
 950           if (err != null)
 951           {
 952             log.error(
 953                     "Whilst initing GoogleTracker for Jalview Desktop version "
 954                             + vrs,
 955                     err);
 956           }
 957         }
 958         else
 959         {
 960           if (re != null)
 961           {
 962             System.err.println(
 963                     "Debug: Caught runtime exception in googletracker init:"
 964                             + vrs);
 965             re.printStackTrace();
 966           }
 967           if (ex != null)
 968           {
 969             System.err.println(
 970                     "Warning:  Failed to initialise GoogleTracker for Jalview Desktop with version "
 971                             + vrs);
 972             ex.printStackTrace();
 973           }
 974
 975           if (err != null)
 976           {
 977             System.err.println(
 978                     "ERROR: Whilst initing GoogleTracker for Jalview Desktop version "
 979                             + vrs);
 980             err.printStackTrace();
 981           }
 982         }
 983       }
 984       else
 985       {
 986         log.debug("Successfully initialised tracker.");
 987       }
 988     }
 989   }
 990
 991   /**
 992    * get the user's default colour if available
 993    *
 994    * @param property
 995    * @param defcolour
 996    * @return
 997    */
 998   public static Color getDefaultColour(String property, Color defcolour)
 999   {
1000     String colprop = getProperty(property);
1001     if (colprop == null)
1002     {
1003       return defcolour;
1004     }
1005     Color col = ColorUtils.parseColourString(colprop);
1006     if (col == null)
1007     {
1008       log.warn("Couldn't parse '" + colprop + "' as a colour for "
1009               + property);
1010     }
1011     return (col == null) ? defcolour : col;
1012   }
1013
1014   /**
1015    * store a colour as a Jalview user default property
1016    *
1017    * @param property
1018    * @param colour
1019    */
1020   public static void setColourPropertyNoSave(String property, Color colour)
1021   {
1022     setPropertyNoSave(property, jalview.util.Format.getHexString(colour));
1023   }
1024
1025   /**
1026    * Stores a formatted date in a jalview property, using a fixed locale.
1027    *
1028    * @param propertyName
1029    * @param date
1030    * @return the formatted date string
1031    */
1032   public static String setDateProperty(String propertyName, Date date)
1033   {
1034     String formatted = date_format.format(date);
1035     setProperty(propertyName, formatted);
1036     return formatted;
1037   }
1038
1039   /**
1040    * Reads a date stored in a Jalview property, parses it (using a fixed locale
1041    * format) and returns as a Date, or null if parsing fails
1042    *
1043    * @param propertyName
1044    * @return
1045    *
1046    */
1047   public static Date getDateProperty(String propertyName)
1048   {
1049     String val = getProperty(propertyName);
1050
1051     if (val != null)
1052     {
1053       try
1054       {
1055         if ((val = val.trim()).indexOf(",") < 0 && val.indexOf("-") >= 0 && val.indexOf(" ") == val.lastIndexOf(" ")) {
1056           val = val.replace(" ",", ").replace('-',' ');
1057         }
1058         Date date =  date_format.parse(val);
1059         return date;
1060       } catch (Exception ex)
1061       {
1062         System.err.println("Invalid or corrupt date in property '"
1063                 + propertyName + "' : value was '" + val + "'");
1064       }
1065     }
1066     return null;
1067   }
1068
1069   /**
1070    * get and parse a property as an integer. send any parsing problems to
1071    * System.err
1072    *
1073    * @param property
1074    * @return null or Integer
1075    */
1076   public static Integer getIntegerProperty(String property)
1077   {
1078     String val = getProperty(property);
1079     if (val != null && (val = val.trim()).length() > 0)
1080     {
1081       try
1082       {
1083         return Integer.valueOf(val);
1084       } catch (NumberFormatException x)
1085       {
1086         System.err.println("Invalid integer in property '" + property
1087                 + "' (value was '" + val + "')");
1088       }
1089     }
1090     return null;
1091   }
1092
1093   /**
1094    * Set the specified value, or remove it if null or empty. Does not save the
1095    * properties file.
1096    *
1097    * @param propName
1098    * @param value
1099    */
1100   public static void setOrRemove(String propName, String value)
1101   {
1102     if (propName == null)
1103     {
1104       return;
1105     }
1106     if (value == null || value.trim().length() < 1)
1107     {
1108       getInstance().applicationProperties.remove(propName);
1109     }
1110     else
1111     {
1112       getInstance().applicationProperties.setProperty(propName, value);
1113     }
1114   }
1115
1116   /**
1117    * Loads in user colour schemes from files.
1118    *
1119    * @param files
1120    *          a '|'-delimited list of file paths
1121    */
1122   public static void initUserColourSchemes(String files)
1123   {
1124     if (files == null || files.length() == 0)
1125     {
1126       return;
1127     }
1128
1129     // In case colours can't be loaded, we'll remove them
1130     // from the default list here.
1131     StringBuffer coloursFound = new StringBuffer();
1132     StringTokenizer st = new StringTokenizer(files, "|");
1133     while (st.hasMoreElements())
1134     {
1135       String file = st.nextToken();
1136       try
1137       {
1138         UserColourScheme ucs = ColourSchemeLoader.loadColourScheme(file);
1139         if (ucs != null)
1140         {
1141           if (coloursFound.length() > 0)
1142           {
1143             coloursFound.append("|");
1144           }
1145           coloursFound.append(file);
1146           ColourSchemes.getInstance().registerColourScheme(ucs);
1147         }
1148       } catch (Exception ex)
1149       {
1150         System.out.println("Error loading User ColourFile\n" + ex);
1151       }
1152     }
1153     if (!files.equals(coloursFound.toString()))
1154     {
1155       if (coloursFound.toString().length() > 1)
1156       {
1157         setProperty(UserDefinedColours.USER_DEFINED_COLOURS,
1158                 coloursFound.toString());
1159       }
1160       else
1161       {
1162         getInstance().applicationProperties
1163                 .remove(UserDefinedColours.USER_DEFINED_COLOURS);
1164       }
1165     }
1166   }
1167
1168   /**
1169    * Initial logging information helper for various versions output
1170    *
1171    * @param prefix
1172    * @param value
1173    * @param defaultValue
1174    */
1175   private static void appendIfNotNull(StringBuilder sb, String prefix,
1176           String value, String suffix, String defaultValue)
1177   {
1178     if (value == null && defaultValue == null)
1179     {
1180       return;
1181     }
1182     String line = prefix + (value != null ? value : defaultValue) + suffix;
1183     sb.append(line);
1184   }
1185
1186   /**
1187    *
1188    * @return Jalview version, build details and JVM platform version for console
1189    */
1190   public static String getVersionDetailsForConsole()
1191   {
1192     StringBuilder sb = new StringBuilder();
1193     sb.append("Jalview Version: "
1194             + jalview.bin.Cache.getDefault("VERSION", "TEST"));
1195     sb.append("\n");
1196     sb.append("Jalview Installation: "
1197             + jalview.bin.Cache.getDefault("INSTALLATION", "unknown"));
1198     sb.append("\n");
1199     sb.append("Build Date: "
1200             + jalview.bin.Cache.getDefault("BUILD_DATE", "unknown"));
1201     sb.append("\n");
1202     sb.append("Java version: " + System.getProperty("java.version"));
1203     sb.append("\n");
1204     sb.append(System.getProperty("os.arch") + " "
1205             + System.getProperty("os.name") + " "
1206             + System.getProperty("os.version"));
1207     sb.append("\n");
1208     appendIfNotNull(sb, "Install4j version: ",
1209             System.getProperty("sys.install4jVersion"), "\n", null);
1210     appendIfNotNull(sb, "Install4j template version: ",
1211             System.getProperty("installer_template_version"), "\n", null);
1212     appendIfNotNull(sb, "Launcher version: ",
1213             System.getProperty("launcher_version"), "\n", null);
1214     if (jalview.bin.Cache.getDefault("VERSION", "TEST")
1215             .equals("DEVELOPMENT"))
1216     {
1217       appendIfNotNull(sb, "Getdown appdir: ",
1218               System.getProperty("getdownappdir"), "\n", null);
1219       appendIfNotNull(sb, "Java home: ", System.getProperty("java.home"),
1220               "\n", "unknown");
1221     }
1222     return sb.toString();
1223   }
1224
1225   /**
1226    *
1227    * @return build details as reported in splashscreen
1228    */
1229   public static String getBuildDetailsForSplash()
1230   {
1231     // consider returning more human friendly info
1232     // eg 'built from Source' or update channel
1233     return jalview.bin.Cache.getDefault("INSTALLATION", "unknown");
1234   }
1235
1236   /**
1237    *
1238    * For AppletParams and Preferences ok_actionPerformed and
1239    * startupFileTextfield_mouseClicked
1240    *
1241    * Sets a property value for the running application, without saving it to the
1242    * properties file
1243    *
1244    * @param key
1245    * @param obj
1246    */
1247   public static void setPropertyNoSave(String key, String obj)
1248   {
1249     getInstance().setPropertyImpl(key, obj, false);
1250   }
1251
1252   /**
1253    * Sets a property value, and optionally also saves the current properties to
1254    * file
1255    *
1256    * @param key
1257    * @param obj
1258    * @param andSave
1259    * @return
1260    */
1261   private Object setPropertyImpl(
1262           String key, String obj, boolean andSave)
1263   {
1264     Object oldValue = null;
1265     try
1266     {
1267       oldValue = applicationProperties.setProperty(key, obj);
1268       if (andSave && !propsAreReadOnly && propertiesFile != null)
1269       {
1270         FileOutputStream out = new FileOutputStream(propertiesFile);
1271         applicationProperties.store(out, "---JalviewX Properties File---");
1272         out.close();
1273       }
1274     } catch (Exception ex)
1275     {
1276       System.out.println(
1277               "Error setting property: " + key + " " + obj + "\n" + ex);
1278     }
1279     return oldValue;
1280   }
1281
1282 }