X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fbin%2FCache.java;h=6648099eac8e8195fceb7df691cd9a8e7c5c84ff;hb=245686954f67953e2dda80efc8c7a5c6d6b965e1;hp=362fca8f37e0389d21c25a1b9f233027e57f8c8d;hpb=0df0d8560e30bdd32d0f8982c1774fd141835086;p=jalview.git

diff --git a/src/jalview/bin/Cache.java b/src/jalview/bin/Cache.java
index 362fca8..6648099 100755
--- a/src/jalview/bin/Cache.java
+++ b/src/jalview/bin/Cache.java
@@ -20,17 +20,6 @@
  */
 package jalview.bin;
 
-import jalview.datamodel.PDBEntry;
-import jalview.gui.UserDefinedColours;
-import jalview.schemes.ColourSchemeLoader;
-import jalview.schemes.ColourSchemes;
-import jalview.schemes.UserColourScheme;
-import jalview.structure.StructureImportSettings;
-import jalview.urls.IdOrgSettings;
-import jalview.util.ColorUtils;
-import jalview.util.Platform;
-import jalview.ws.sifts.SiftsSettings;
-
 import java.awt.Color;
 import java.io.BufferedReader;
 import java.io.File;
@@ -38,6 +27,11 @@ import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.InputStream;
 import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.net.Authenticator;
+import java.net.PasswordAuthentication;
+import java.net.URL;
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
 import java.util.Collections;
@@ -47,12 +41,27 @@ import java.util.Locale;
 import java.util.Properties;
 import java.util.StringTokenizer;
 import java.util.TreeSet;
+import java.util.regex.Pattern;
+
+import javax.swing.LookAndFeel;
+import javax.swing.UIManager;
 
 import org.apache.log4j.ConsoleAppender;
 import org.apache.log4j.Level;
 import org.apache.log4j.Logger;
 import org.apache.log4j.SimpleLayout;
 
+import jalview.datamodel.PDBEntry;
+import jalview.gui.UserDefinedColours;
+import jalview.schemes.ColourSchemeLoader;
+import jalview.schemes.ColourSchemes;
+import jalview.schemes.UserColourScheme;
+import jalview.structure.StructureImportSettings;
+import jalview.urls.IdOrgSettings;
+import jalview.util.ColorUtils;
+import jalview.util.Platform;
+import jalview.ws.sifts.SiftsSettings;
+
 /**
  * Stores and retrieves Jalview Application Properties Lists and fields within
  * list entries are separated by '|' symbols unless otherwise stated (|) clauses
@@ -264,6 +273,25 @@ public class Cache
    */
   public static Logger log;
 
+  // save the proxy properties set at startup
+  public final static String[] startupProxyProperties = {
+      System.getProperty("http.proxyHost"),
+      System.getProperty("http.proxyPort"),
+      System.getProperty("https.proxyHost"),
+      System.getProperty("https.proxyPort"),
+      System.getProperty("http.proxyUser"),
+      System.getProperty("http.proxyPassword"),
+      System.getProperty("https.proxyUser"),
+      System.getProperty("https.proxyPassword"),
+      System.getProperty("http.nonProxyHosts") };
+
+  public final static String PROXYTYPE_NONE = "none";
+
+  // "false" and "true" for backward compatibility
+  public final static String PROXYTYPE_SYSTEM = "false";
+
+  public final static String PROXYTYPE_CUSTOM = "true";
+
   /** Jalview Properties */
   public static Properties applicationProperties = new Properties()
   {
@@ -312,6 +340,10 @@ public class Cache
       // lcastor = Logger.getLogger("org.exolab.castor.xml.Marshaller");
       // lcastor.setLevel(Level.toLevel(Cache.getDefault("logs.Castor.Level",
       // Level.INFO.toString())));
+      // we shouldn't need to do this
+      org.apache.log4j.Logger.getRootLogger()
+              .setLevel(org.apache.log4j.Level.INFO);
+
       jalview.bin.Cache.log.setLevel(Level.toLevel(Cache
               .getDefault("logs.Jalview.level", Level.INFO.toString())));
       // laxis.addAppender(ap);
@@ -356,7 +388,7 @@ public class Cache
         InputStream fis;
         try
         {
-          fis = new java.net.URL(propertiesFile).openStream();
+          fis = new URL(propertiesFile).openStream();
           System.out.println(
                   "Loading jalview properties from : " + propertiesFile);
           System.out.println(
@@ -383,26 +415,56 @@ public class Cache
         System.out.println("Error reading properties file: " + ex);
       }
     }
+
+    /* TO BE REPLACED WITH PROXY_TYPE SETTINGS 
     if (getDefault("USE_PROXY", false))
     {
       String proxyServer = getDefault("PROXY_SERVER", ""),
               proxyPort = getDefault("PROXY_PORT", "8080");
+    }
+    */
 
-      System.out.println("Using proxyServer: " + proxyServer
-              + " proxyPort: " + proxyPort);
-
-      System.setProperty("http.proxyHost", proxyServer);
-      System.setProperty("http.proxyPort", proxyPort);
+    // PROXY TYPE settings (now three options "none", "false", "true", but using
+    // backward compatible strings)
+    String proxyType = getDefault("USE_PROXY", PROXYTYPE_SYSTEM);
+    // default to upgrading old settings
+    switch (proxyType)
+    {
+    case PROXYTYPE_NONE:
+      setProxyProperties(null, null, null, null, null, null, null, null);
+      break;
+    case PROXYTYPE_SYSTEM: // use system settings
+      resetProxyProperties();
+      break;
+    case PROXYTYPE_CUSTOM: // use specified proxy settings
+      String httpHost = getDefault("PROXY_SERVER", "");
+      String httpPort = getDefault("PROXY_PORT", "8080");
+      String httpsHost = getDefault("PROXY_SERVER_HTTPS", httpHost);
+      String httpsPort = getDefault("PROXY_PORT_HTTPS", httpPort);
+      String httpUser = getDefault("PROXY_AUTH_USER", null);
+      String httpPassword = getDefault("PROXY_AUTH_PASSWORD", null);
+      // https.proxyUser and https.proxyPassword are not able to be
+      // independently set in Preferences yet
+      String httpsUser = getDefault("PROXY_AUTH_USER_HTTPS", httpUser);
+      String httpsPassword = getDefault("PROXY_AUTH_PASSWORD_HTTPS",
+              httpPassword);
+      setProxyProperties(httpHost, httpPort, httpsHost, httpsPort, httpUser,
+              httpPassword, httpsUser, httpsPassword);
+      break;
+    default:
+      String message = "Incorrect PROXY_TYPE - should be 'none' (clear proxy properties), 'false' (system settings), 'true' (custom settings): "
+              + proxyType;
+      Cache.warn(message);
     }
 
     // LOAD THE AUTHORS FROM THE authors.props file
-    String authorDetails = resolveResourceURLFor("authors.props");
+    String authorDetails = resolveResourceURLFor("/authors.props");
 
     try
     {
       if (authorDetails != null)
       {
-        java.net.URL localJarFileURL = new java.net.URL(authorDetails);
+        URL localJarFileURL = new URL(authorDetails);
         InputStream in = localJarFileURL.openStream();
         applicationProperties.load(in);
         in.close();
@@ -414,49 +476,12 @@ public class Cache
     }
     if (authorDetails == null)
     {
-        applicationProperties.remove("AUTHORS");
-        applicationProperties.remove("AUTHORFNAMES");
-        applicationProperties.remove("YEAR");
+      applicationProperties.remove("AUTHORS");
+      applicationProperties.remove("AUTHORFNAMES");
+      applicationProperties.remove("YEAR");
     }
 
-    // FIND THE VERSION NUMBER AND BUILD DATE FROM jalview.jar
-    // MUST FOLLOW READING OF LOCAL PROPERTIES FILE AS THE
-    // VERSION MAY HAVE CHANGED SINCE LAST USING JALVIEW
-    String buildDetails = resolveResourceURLFor("/.build_properties");
-
-    if (buildDetails != null)
-    {
-      try
-      {
-        java.net.URL localJarFileURL = new java.net.URL(buildDetails);
-        InputStream in = localJarFileURL.openStream();
-        applicationProperties.load(in);
-        in.close();
-      } catch (Exception ex)
-      {
-        System.out.println("Error reading build details: " + ex);
-        buildDetails = null;
-      }
-    }
-    if (buildDetails == null)
-    {
-        applicationProperties.remove("VERSION");
-    }
-    String jnlpVersion = System.getProperty("jalview.version");
-    String codeVersion = getProperty("VERSION");
-    String codeInstallation = getProperty("INSTALLATION");
-    if (codeVersion == null)
-    {
-      // THIS SHOULD ONLY BE THE CASE WHEN TESTING!!
-      codeVersion = "Test";
-      jnlpVersion = "Test";
-      codeInstallation = "";
-    }
-    else
-    {
-      codeInstallation = " (" + codeInstallation + ")";
-    }
-    new BuildDetails(codeVersion, null, codeInstallation);
+    loadBuildProperties(false);
 
     SiftsSettings
             .setMapWithSifts(Cache.getDefault("MAP_WITH_SIFTS", false));
@@ -476,9 +501,6 @@ public class Cache
             "http://www.jalview.org/services/identifiers"));
     IdOrgSettings.setDownloadLocation(ID_ORG_FILE);
 
-    System.out
-            .println("Jalview Version: " + codeVersion + codeInstallation);
-
     StructureImportSettings.setDefaultStructureFileFormat(jalview.bin.Cache
             .getDefault("PDB_DOWNLOAD_FORMAT", PDB_DOWNLOAD_FORMAT));
     StructureImportSettings
@@ -486,8 +508,13 @@ public class Cache
     // StructureImportSettings
     // .setDefaultPDBFileParser(jalview.bin.Cache.getDefault(
     // "DEFAULT_PDB_FILE_PARSER", DEFAULT_PDB_FILE_PARSER));
-    // jnlpVersion will be null if we're using InstallAnywhere
+
+    String jnlpVersion = System.getProperty("jalview.version");
+
+    // jnlpVersion will be null if a latest version check for the channel needs
+    // to be done
     // Dont do this check if running in headless mode
+
     if (jnlpVersion == null && getDefault("VERSION_CHECK", true)
             && (System.getProperty("java.awt.headless") == null || System
                     .getProperty("java.awt.headless").equals("false")))
@@ -558,16 +585,12 @@ public class Cache
       }
     }
 
-    setProperty("VERSION", codeVersion);
-
     // LOAD USERDEFINED COLOURS
-    jalview.bin.Cache
-            .initUserColourSchemes(getProperty("USER_DEFINED_COLOURS"));
+    Cache.initUserColourSchemes(getProperty("USER_DEFINED_COLOURS"));
     jalview.io.PIRFile.useModellerOutput = Cache.getDefault("PIR_MODELLER",
             false);
   }
 
-
   /**
    * construct a resource URL for the given absolute resource pathname
    * 
@@ -585,7 +608,8 @@ public class Cache
         url = Cache.class.getResource(resourcePath).toString();
       } catch (Exception ex)
       {
-
+        System.err.println("Failed to resolve resource " + resourcePath
+                + ": " + ex.getMessage());
       }
     }
     else
@@ -596,6 +620,49 @@ public class Cache
     return url;
   }
 
+  public static void loadBuildProperties(boolean reportVersion)
+  {
+    String codeInstallation = getProperty("INSTALLATION");
+    boolean printVersion = codeInstallation == null;
+
+    /*
+     * read build properties - from the Jalview jar for a Java distribution,
+     * or from codebase file in test or JalviewJS context
+     */
+    try
+    {
+      String buildDetails = resolveResourceURLFor("/.build_properties");
+      URL localJarFileURL = new URL(buildDetails);
+      InputStream in = localJarFileURL.openStream();
+      applicationProperties.load(in);
+      in.close();
+    } catch (Exception ex)
+    {
+      System.out.println("Error reading build details: " + ex);
+      applicationProperties.remove("VERSION");
+    }
+    String codeVersion = getProperty("VERSION");
+    codeInstallation = getProperty("INSTALLATION");
+
+    if (codeVersion == null)
+    {
+      // THIS SHOULD ONLY BE THE CASE WHEN TESTING!!
+      codeVersion = "Test";
+      codeInstallation = "";
+    }
+    else
+    {
+      codeInstallation = " (" + codeInstallation + ")";
+    }
+    setProperty("VERSION", codeVersion);
+    new BuildDetails(codeVersion, null, codeInstallation);
+    if (printVersion && reportVersion)
+    {
+      System.out.println(
+              "Jalview Version: " + codeVersion + codeInstallation);
+    }
+  }
+
   private static void deleteBuildProperties()
   {
     applicationProperties.remove("LATEST_VERSION");
@@ -687,7 +754,7 @@ public class Cache
     try
     {
       oldValue = applicationProperties.setProperty(key, obj);
-      if (!propsAreReadOnly)
+      if (propertiesFile != null && !propsAreReadOnly)
       {
         FileOutputStream out = new FileOutputStream(propertiesFile);
         applicationProperties.store(out, "---JalviewX Properties File---");
@@ -1111,4 +1178,276 @@ public class Cache
     }
   }
 
+  /**
+   * Initial logging information helper for various versions output
+   * 
+   * @param prefix
+   * @param value
+   * @param defaultValue
+   */
+  private static void appendIfNotNull(StringBuilder sb, String prefix,
+          String value, String suffix, String defaultValue)
+  {
+    if (value == null && defaultValue == null)
+    {
+      return;
+    }
+    String line = prefix + (value != null ? value : defaultValue) + suffix;
+    sb.append(line);
+  }
+
+  /**
+   * 
+   * @return Jalview version, build details and JVM platform version for console
+   */
+  public static String getVersionDetailsForConsole()
+  {
+    StringBuilder sb = new StringBuilder();
+    sb.append("Jalview Version: ");
+    sb.append(jalview.bin.Cache.getDefault("VERSION", "TEST"));
+    sb.append("\n");
+    sb.append("Jalview Installation: ");
+    sb.append(jalview.bin.Cache.getDefault("INSTALLATION", "unknown"));
+    sb.append("\n");
+    sb.append("Build Date: ");
+    sb.append(jalview.bin.Cache.getDefault("BUILD_DATE", "unknown"));
+    sb.append("\n");
+    sb.append("Java version: ");
+    sb.append(System.getProperty("java.version"));
+    sb.append("\n");
+    sb.append(System.getProperty("os.arch"));
+    sb.append(" ");
+    sb.append(System.getProperty("os.name"));
+    sb.append(" ");
+    sb.append(System.getProperty("os.version"));
+    sb.append("\n");
+    appendIfNotNull(sb, "Install4j version: ",
+            System.getProperty("sys.install4jVersion"), "\n", null);
+    appendIfNotNull(sb, "Install4j template version: ",
+            System.getProperty("installer_template_version"), "\n", null);
+    appendIfNotNull(sb, "Launcher version: ",
+            System.getProperty("launcher_version"), "\n", null);
+    LookAndFeel laf = UIManager.getLookAndFeel();
+    String lafName = laf == null ? "Not obtained" : laf.getName();
+    String lafClass = laf == null ? "unknown" : laf.getClass().getName();
+    sb.append("LookAndFeel: ");
+    sb.append(lafName);
+    sb.append(" (");
+    sb.append(lafClass);
+    sb.append(")\n");
+    // Not displayed in release version ( determined by possible version number
+    // regex 9[9.]*9[.-_a9]* )
+    if (Pattern.matches("^\\d[\\d\\.]*\\d[\\.\\-\\w]*$",
+            jalview.bin.Cache.getDefault("VERSION", "TEST")))
+    {
+      appendIfNotNull(sb, "Getdown appdir: ",
+              System.getProperty("getdownappdir"), "\n", null);
+      appendIfNotNull(sb, "Java home: ", System.getProperty("java.home"),
+              "\n", "unknown");
+    }
+    return sb.toString();
+  }
+
+  /**
+   * 
+   * @return build details as reported in splashscreen
+   */
+  public static String getBuildDetailsForSplash()
+  {
+    // consider returning more human friendly info
+    // eg 'built from Source' or update channel
+    return jalview.bin.Cache.getDefault("INSTALLATION", "unknown");
+  }
+
+  public static String getStackTraceString(Throwable t)
+  {
+    StringWriter sw = new StringWriter();
+    PrintWriter pw = new PrintWriter(sw);
+    t.printStackTrace(pw);
+    return sw.toString();
+  }
+
+  // proxy properties methods
+  public static void resetProxyProperties()
+  {
+    setProxyProperties(startupProxyProperties[0], startupProxyProperties[1],
+            startupProxyProperties[2], startupProxyProperties[3],
+            startupProxyProperties[4], startupProxyProperties[5],
+            startupProxyProperties[6], startupProxyProperties[7]);
+    StringBuilder sb = new StringBuilder();
+    sb.append("Setting proxy properties to: http.proxyHost=")
+            .append(startupProxyProperties[0]).append(", http.proxyPort=")
+            .append(startupProxyProperties[1])
+            .append(startupProxyProperties[4] != null
+                    && !startupProxyProperties[4].isEmpty()
+                            ? " [" + startupProxyProperties[4] + "]"
+                            : "")
+            .append(", https.proxyHost=").append(startupProxyProperties[2])
+            .append(", https.proxyPort=").append(startupProxyProperties[3])
+            .append(startupProxyProperties[6] != null
+                    && !startupProxyProperties[6].isEmpty()
+                            ? " [" + startupProxyProperties[6] + "]"
+                            : "");
+
+    Cache.debug(sb.toString());
+  }
+
+  public static void setProxyProperties(String httpHost, String httpPort,
+          String httpsHost, String httpsPort, String httpUser,
+          String httpPassword)
+  {
+    setProxyProperties(httpHost, httpPort, httpsHost, httpsPort, httpUser,
+            httpPassword, httpUser, httpPassword);
+  }
+
+  public static void setProxyProperties(String httpHost, String httpPort,
+          String httpsHost, String httpsPort, String httpUser,
+          String httpPassword, String httpsUser, String httpsPassword)
+  {
+    setOrClearSystemProperty("http.proxyHost", httpHost);
+    setOrClearSystemProperty("http.proxyPort", httpPort);
+    setOrClearSystemProperty("https.proxyHost", httpsHost);
+    setOrClearSystemProperty("https.proxyPort", httpsPort);
+    setOrClearSystemProperty("http.proxyUser", httpUser);
+    setOrClearSystemProperty("http.proxyPassword", httpPassword);
+    setOrClearSystemProperty("https.proxyUser", httpsUser);
+    setOrClearSystemProperty("https.proxyPassword", httpsPassword);
+    if (httpUser != null || httpsUser != null)
+    {
+      try
+      {
+        Authenticator.setDefault(new Authenticator()
+        {
+          @Override
+          protected PasswordAuthentication getPasswordAuthentication()
+          {
+            if (getRequestorType() == RequestorType.PROXY)
+            {
+              try
+              {
+                if (getRequestingScheme().equalsIgnoreCase("http")
+                        && getRequestingHost().equalsIgnoreCase(httpHost)
+                        && getRequestingPort() == Integer.valueOf(httpPort))
+                {
+                  return new PasswordAuthentication(httpUser,
+                          httpPassword == null ? new char[] {}
+                                  : httpPassword.toCharArray());
+                }
+                if (getRequestingScheme().equalsIgnoreCase("https")
+                        && getRequestingHost().equalsIgnoreCase(httpsHost)
+                        && getRequestingPort() == Integer
+                                .valueOf(httpsPort))
+                {
+                  return new PasswordAuthentication(httpsUser,
+                          httpsPassword == null ? new char[] {}
+                                  : httpsPassword.toCharArray());
+                }
+              } catch (NumberFormatException e)
+              {
+                Cache.error("Problem with proxy port values [http:"
+                        + httpPort + ", https:" + httpsPort + "]");
+              }
+            }
+            // non proxy request
+            return null;
+          }
+        });
+        // required to re-enable basic authentication (should be okay for a
+        // local proxy)
+        System.setProperty("jdk.http.auth.tunneling.disabledSchemes", "");
+      } catch (SecurityException e)
+      {
+        Cache.error("Could not set default Authenticator");
+        Cache.debug(getStackTraceString(e));
+      }
+    }
+    else
+    {
+      // reset the Authenticator to protect http.proxyUser and
+      // http.proxyPassword Just In Case
+      Authenticator.setDefault(new Authenticator()
+      {
+        @Override
+        protected PasswordAuthentication getPasswordAuthentication()
+        {
+          return null;
+        }
+      });
+    }
+
+    // clear localhost from proxying unless nonProxyHosts already set (not
+    // currently configurable in Preferences)
+    String nonProxyHosts = startupProxyProperties[8];
+    System.setProperty("http.nonProxyHosts",
+            nonProxyHosts == null ? "localhost" : nonProxyHosts);
+  }
+
+  public static void setOrClearSystemProperty(String key, String value)
+  {
+    if (key == null)
+    {
+      return;
+    }
+    if (value == null)
+    {
+      System.clearProperty(key);
+    }
+    else
+    {
+      System.setProperty(key, value);
+    }
+  }
+
+  public final static int DEBUG = 10;
+
+  public final static int INFO = 20;
+
+  public final static int WARN = 30;
+
+  public final static int ERROR = 40;
+
+  public static boolean println(int level, String message)
+  {
+    if (Cache.log == null)
+    {
+      if (level >= ERROR)
+        System.err.println(message);
+      else
+        System.out.println(message);
+      return false;
+    }
+    if (level >= WARN)
+    {
+      Cache.log.warn(message);
+    }
+    else if (level >= INFO)
+    {
+      Cache.log.info(message);
+    }
+    else
+    {
+      Cache.log.debug(message);
+    }
+    return true;
+  }
+
+  public static void debug(String message)
+  {
+    println(DEBUG, message);
+  }
+
+  public static void info(String message)
+  {
+    println(INFO, message);
+  }
+
+  public static void warn(String message)
+  {
+    println(WARN, message);
+  }
+
+  public static void error(String message)
+  {
+    println(ERROR, message);
+  }
 }