2.4/dev/core/src/com/google/gwt/dev/shell/CheckForUpdates.java - gwt - Git at Google

 /*
  * Copyright 2006 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations under
  * the License.
  */
 package com.google.gwt.dev.shell;

 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.TreeLogger.HelpInfo;
 import com.google.gwt.dev.About;
 import com.google.gwt.dev.GwtVersion;
 import com.google.gwt.dev.shell.ie.CheckForUpdatesIE6;

 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 import org.xml.sax.ErrorHandler;
 import org.xml.sax.SAXException;
 import org.xml.sax.SAXParseException;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.PrintWriter;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLConnection;
 import java.util.Date;
 import java.util.Locale;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.FutureTask;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.prefs.Preferences;

 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;

 /**
  * Orchestrates a best-effort attempt to find out if a new version of GWT is
  * available.
  */
 public class CheckForUpdates {

   /**
    * Returns the result of an update check.
    */
   public interface UpdateResult {
     /**
      * @return the new version of GWT available.
      */
     GwtVersion getNewVersion();

     /**
      * @return the URL for details about the new version.
      */
     URL getURL();
   }

   public static final long ONE_DAY = 24 * 60 * 60 * 1000;
   public static final long ONE_MINUTE = 60 * 1000;

   // System properties used by CheckForUpdates
   protected static final String PROPERTY_DEBUG_HTTP_GET = "gwt.debugLowLevelHttpGet";
   protected static final String PROPERTY_FORCE_NONNATIVE = "gwt.forceVersionCheckNonNative";
   protected static final String PROPERTY_PREFS_NAME = "gwt.prefsPathName";
   protected static final String PROPERTY_QUERY_URL = "gwt.forceVersionCheckURL";

   // Log levels -- in general we want the logging of the update process
   // to not be visible to normal users.
   private static final TreeLogger.Type CHECK_ERROR = TreeLogger.DEBUG;
   private static final TreeLogger.Type CHECK_INFO = TreeLogger.SPAM;
   private static final TreeLogger.Type CHECK_SPAM = TreeLogger.SPAM;
   private static final TreeLogger.Type CHECK_WARN = TreeLogger.SPAM;

   // Preferences keys
   private static final String FIRST_LAUNCH = "firstLaunch";
   private static final String HIGHEST_RUN_VERSION = "highestRunVersion";
   private static final String LAST_PING = "lastPing";
   private static final String NEXT_PING = "nextPing";

   // Uncomment one of constants below to try different variations of failure to
   // make sure we never interfere with the app running.

   // Check against a fake server to see failure to contact server.
   // protected static final String QUERY_URL =
   // "http://nonexistenthost:1111/gwt/currentversion.xml";

   // Check 404 on a real location that doesn't have the file.
   // protected static final String QUERY_URL =
   // "http://www.google.com/gwt/currentversion.xml";

   // A test URL for seeing it actually work in a sandbox.
   // protected static final String QUERY_URL =
   // "http://localhost/gwt/currentversion.xml";

   // The real URL that should be used.
   private static final String QUERY_URL = "http://tools.google.com/webtoolkit/currentversion.xml";

   public static FutureTask<UpdateResult> checkForUpdatesInBackgroundThread(
       final TreeLogger logger, final long minCheckMillis) {
     final String entryPoint = computeEntryPoint();
     FutureTask<UpdateResult> task = new FutureTask<UpdateResult>(
         new Callable<UpdateResult>() {
           public UpdateResult call() throws Exception {
             final CheckForUpdates updateChecker = createUpdateChecker(logger,
                 entryPoint);
             return updateChecker == null ? null
                 : updateChecker.check(minCheckMillis);
           }
         });
     Thread checkerThread = new Thread(task, "GWT Update Checker");
     checkerThread.setDaemon(true);
     checkerThread.start();
     return task;
   }

   /**
    * Find the first method named "main" on the call stack and use its class as
    * the entry point.
    */
   public static String computeEntryPoint() {
     Throwable t = new Throwable();
     for (StackTraceElement stackTrace : t.getStackTrace()) {
       if (stackTrace.getMethodName().equals("main")) {
         // Strip package name from main's class
         String className = stackTrace.getClassName();
         int i = className.lastIndexOf('.');
         if (i >= 0) {
           return className.substring(i + 1);
         }
         return className;
       }
     }
     return null;
   }

   public static CheckForUpdates createUpdateChecker(TreeLogger logger) {
     return createUpdateChecker(logger, computeEntryPoint());
   }

   public static CheckForUpdates createUpdateChecker(TreeLogger logger,
       String entryPoint) {
     // Windows has a custom implementation to handle proxies.
     if (System.getProperty("os.name").toLowerCase(Locale.ENGLISH).contains("win")) {
       return new CheckForUpdatesIE6(logger, entryPoint);
     } else {
       return new CheckForUpdates(logger, entryPoint);
     }
   }

   public static void logUpdateAvailable(TreeLogger logger,
       FutureTask<UpdateResult> updater) {
     if (updater != null && updater.isDone()) {
       UpdateResult result = null;
       try {
         result = updater.get(0, TimeUnit.MILLISECONDS);
       } catch (InterruptedException e) {
         // Silently ignore exception
       } catch (ExecutionException e) {
         // Silently ignore exception
       } catch (TimeoutException e) {
         // Silently ignore exception
       }
       logUpdateAvailable(logger, result);
     }
   }

   public static void logUpdateAvailable(TreeLogger logger,
       UpdateResult result) {
     if (result != null) {
       final URL url = result.getURL();
       logger.log(TreeLogger.WARN, "A new version of GWT ("
           + result.getNewVersion() + ") is available", null, new HelpInfo() {
             @Override
             public String getAnchorText() {
               return "Release Notes";
             }

             @Override
             public URL getURL() {
               return url;
             }
           });
     }
   }

   private static String getTextOfLastElementHavingTag(Document doc,
       String tagName) {
     NodeList nodeList = doc.getElementsByTagName(tagName);
     int n = nodeList.getLength();
     if (n > 0) {
       Element elem = (Element) nodeList.item(n - 1);
       // Assume the first child is the value.
       //
       Node firstChild = elem.getFirstChild();
       if (firstChild != null) {
         String text = firstChild.getNodeValue();
         return text;
       }
     }

     return null;
   }

   private String entryPoint;

   private TreeLogger logger;

   private GwtVersion myVersion;

   /**
    * Create an update checker which will poll a server URL and log a message
    * about an update if available.
    *
    * @param logger TreeLogger to use
    * @param entryPoint the name of the main entry point used for this execution
    */
   public CheckForUpdates(TreeLogger logger, String entryPoint) {
     this.logger = logger;
     this.entryPoint = entryPoint;
     myVersion = About.getGwtVersionObject();
   }

   /**
    * Check for updates and log to the logger if they are available.
    *
    * @return an UpdateResult or null if there is no new update
    */
   public UpdateResult check() {
     return check(0);
   }

   /**
    * Check for updates and log to the logger if they are available.
    *
    * @return an UpdateResult or null if there is no new update
    */
   public UpdateResult check(long minCheckMillis) {
     TreeLogger branch = logger.branch(CHECK_INFO, "Checking for updates");
     try {
       String prefsName = System.getProperty(PROPERTY_PREFS_NAME);
       Preferences prefs;
       if (prefsName != null) {
         prefs = Preferences.userRoot().node(prefsName);
       } else {
         prefs = Preferences.userNodeForPackage(CheckForUpdates.class);
       }

       String queryURL = QUERY_URL;
       String forceCheckURL = System.getProperty(PROPERTY_QUERY_URL);

       if (forceCheckURL != null) {
         branch.log(CHECK_INFO, "Explicit version check URL: " + forceCheckURL);
         queryURL = forceCheckURL;
       }

       // Get our unique user id (based on absolute timestamp).
       //
       long currentTimeMillis = System.currentTimeMillis();
       String firstLaunch = prefs.get(FIRST_LAUNCH, null);
       if (firstLaunch == null) {
         firstLaunch = Long.toHexString(currentTimeMillis);
         prefs.put(FIRST_LAUNCH, firstLaunch);
         branch.log(CHECK_SPAM, "Setting first launch to " + firstLaunch);
       } else {
         branch.log(CHECK_SPAM, "First launch was " + firstLaunch);
       }

       // See if enough time has passed.
       //
       String lastPing = prefs.get(LAST_PING, "0");
       if (lastPing != null) {
         try {
           long lastPingTime = Long.parseLong(lastPing);
           if (currentTimeMillis < lastPingTime + minCheckMillis) {
             // it's not time yet
             branch.log(CHECK_INFO, "Last ping was " + new Date(lastPingTime)
                 + ", min wait is " + minCheckMillis + "ms");
             return null;
           }
         } catch (NumberFormatException e) {
           branch.log(CHECK_WARN, "Error parsing last ping time", e);
         }
       }

       // See if it's time for our next ping yet.
       //
       String nextPing = prefs.get(NEXT_PING, "0");
       if (nextPing != null) {
         try {
           long nextPingTime = Long.parseLong(nextPing);
           if (currentTimeMillis < nextPingTime) {
             // it's not time yet
             branch.log(CHECK_INFO, "Next ping is not until "
                 + new Date(nextPingTime));
             return null;
           }
         } catch (NumberFormatException e) {
           branch.log(CHECK_WARN, "Error parsing next ping time", e);
         }
       }

       // See if new version is available.
       //
       String url = queryURL + "?v=" + myVersion.toString() + "&id="
           + firstLaunch + "&r=" + About.getGwtSvnRev();
       if (entryPoint != null) {
         url += "&e=" + entryPoint;
       }

       branch.log(CHECK_INFO, "Checking for new version at " + url);

       // Do the HTTP GET.
       //
       byte[] response;
       String fullUserAgent = makeUserAgent();
       if (System.getProperty(PROPERTY_FORCE_NONNATIVE) == null) {
         // Use subclass.
         //
         response = doHttpGet(branch, fullUserAgent, url);
       } else {
         // Use the pure Java version, but it probably doesn't work with proxies.
         //
         response = httpGetNonNative(branch, fullUserAgent, url);
       }

       if (response == null || response.length == 0) {
         // Problem. Quietly fail.
         //
         branch.log(CHECK_ERROR,
             "Failed to obtain current version info via HTTP");
         return null;
       }

       // Parse and process the response.
       // Bad responses will be silently ignored.
       //
       return parseResponse(branch, prefs, response);

     } catch (Throwable e) {
       // Always silently ignore any errors.
       //
       branch.log(CHECK_INFO, "Exception while processing version info", e);
     }
     return null;
   }

   /**
    * Default implementation just uses the platform-independent method. A
    * subclass should override this method for platform-dependent proxy handling,
    * for example.
    *
    * @param branch TreeLogger to use
    * @param userAgent user agent string to send in request
    * @param url URL to fetch
    * @return byte array of response, or null if an error
    */
   protected byte[] doHttpGet(TreeLogger branch, String userAgent, String url) {
     return httpGetNonNative(branch, userAgent, url);
   }

   /**
    * This default implementation uses regular Java HTTP, which doesn't deal with
    * proxies automagically. See the IE6 subclasses for an implementation that
    * does deal with proxies.
    *
    * @param branch TreeLogger to use
    * @param userAgent user agent string to send in request
    * @param url URL to fetch
    * @return byte array of response, or null if an error
    */
   protected byte[] httpGetNonNative(TreeLogger branch, String userAgent,
       String url) {
     Throwable caught;
     InputStream is = null;
     try {
       URL urlToGet = new URL(url);
       URLConnection conn = urlToGet.openConnection();
       conn.setRequestProperty("User-Agent", userAgent);
       is = conn.getInputStream();
       ByteArrayOutputStream baos = new ByteArrayOutputStream();
       byte[] buffer = new byte[4096];
       int bytesRead;
       while ((bytesRead = is.read(buffer)) != -1) {
         baos.write(buffer, 0, bytesRead);
       }
       byte[] response = baos.toByteArray();
       return response;
     } catch (MalformedURLException e) {
       caught = e;
     } catch (IOException e) {
       caught = e;
     } finally {
       if (is != null) {
         try {
           is.close();
         } catch (IOException e) {
         }
       }
     }

     if (System.getProperty(PROPERTY_DEBUG_HTTP_GET) != null) {
       branch.log(CHECK_ERROR, "Exception in HTTP request", caught);
     }

     return null;
   }

   private void appendUserAgentProperty(StringBuffer sb, String propName) {
     String propValue = System.getProperty(propName);
     if (propValue != null) {
       if (sb.length() > 0) {
         sb.append("; ");
       }
       sb.append(propName);
       sb.append("=");
       sb.append(propValue);
     }
   }

   /**
    * Creates a user-agent string by combining standard Java properties.
    */
   private String makeUserAgent() {
     String ua = "GWT Freshness Checker";

     StringBuffer extra = new StringBuffer();
     appendUserAgentProperty(extra, "java.vendor");
     appendUserAgentProperty(extra, "java.version");
     appendUserAgentProperty(extra, "os.arch");
     appendUserAgentProperty(extra, "os.name");
     appendUserAgentProperty(extra, "os.version");

     if (extra.length() > 0) {
       ua += " (" + extra.toString() + ")";
     }

     return ua;
   }

   private UpdateResult parseResponse(TreeLogger branch, Preferences prefs,
       byte[] response) throws IOException, ParserConfigurationException,
       SAXException {

     branch.log(CHECK_SPAM, "Parsing response (length " + response.length + ")");

     DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
     DocumentBuilder builder = factory.newDocumentBuilder();
     ByteArrayInputStream bais = new ByteArrayInputStream(response);

     // Parse the XML.
     //
     builder.setErrorHandler(new ErrorHandler() {

       public void error(SAXParseException exception) throws SAXException {
         // fail quietly
       }

       public void fatalError(SAXParseException exception) throws SAXException {
         // fail quietly
       }

       public void warning(SAXParseException exception) throws SAXException {
         // fail quietly
       }
     });
     Document doc = builder.parse(bais);

     // The latest version number.
     //
     String versionString = getTextOfLastElementHavingTag(doc, "latest-version");
     if (versionString == null) {
       // Not valid; quietly fail.
       //
       branch.log(CHECK_ERROR, "Failed to find <latest-version>");
       return null;
     }
     GwtVersion currentReleasedVersion;
     try {
       currentReleasedVersion = new GwtVersion(versionString.trim());
     } catch (NumberFormatException e) {
       branch.log(CHECK_ERROR, "Bad version: " + versionString, e);
       return null;
     }

     // Ping delay for server-controlled throttling.
     //
     String pingDelaySecsStr = getTextOfLastElementHavingTag(doc,
         "min-wait-seconds");
     int pingDelaySecs = 0;
     if (pingDelaySecsStr == null) {
       // Not valid; quietly fail.
       //
       branch.log(CHECK_ERROR, "Missing <min-wait-seconds>");
       return null;
     }
     try {
       pingDelaySecs = Integer.parseInt(pingDelaySecsStr.trim());
     } catch (NumberFormatException e) {
       // Not a valid number; quietly fail.
       //
       branch.log(CHECK_ERROR, "Bad min-wait-seconds number: "
           + pingDelaySecsStr);
       return null;
     }

     String url = getTextOfLastElementHavingTag(doc, "notification-url");

     if (url == null) {
       // no URL, so write the HTML locally and provide a URL from that

       // Read the HTML.
       //
       String html = getTextOfLastElementHavingTag(doc, "notification");

       if (html == null) {
         // Not valid; quietly fail.
         //
         branch.log(CHECK_ERROR, "Missing <notification>");
         return null;
       }
       PrintWriter writer = null;
       try {
         String tempDir = System.getProperty("java.io.tmpdir");
         File updateHtml = new File(tempDir, "gwt-update-"
             + currentReleasedVersion + ".html");
         writer = new PrintWriter(new FileOutputStream(updateHtml));
         writer.print(html);
         url = "file://" + updateHtml.getAbsolutePath();
       } finally {
         if (writer != null) {
           writer.close();
         }
       }
     }

     // Okay -- this is a valid response.
     //
     return processResponse(branch, prefs, currentReleasedVersion,
         pingDelaySecs, url);
   }

   private UpdateResult processResponse(TreeLogger branch, Preferences prefs,
       final GwtVersion serverVersion, int pingDelaySecs, final String notifyUrl) {

     // Record a ping; don't ping again until the delay is up.
     //
     long currentTimeMillis = System.currentTimeMillis();
     long nextPingTime = currentTimeMillis + pingDelaySecs * 1000;
     prefs.put(NEXT_PING, String.valueOf(nextPingTime));
     prefs.put(LAST_PING, String.valueOf(currentTimeMillis));

     branch.log(CHECK_INFO, "Ping delay is " + pingDelaySecs + "; next ping at "
         + new Date(nextPingTime));

     if (myVersion.isNoNagVersion()) {
       // If the version number indicates no nagging about updates, exit here
       // once we have recorded the next ping time. No-nag versions (ie,
       // trunk builds) should also not update the highest version that has been
       // run.
       return null;
     }

     // Update the highest version of GWT that has been run if we are later.
     GwtVersion highestRunVersion = new GwtVersion(prefs.get(
         HIGHEST_RUN_VERSION, null));
     if (myVersion.compareTo(highestRunVersion) > 0) {
       highestRunVersion = myVersion;
       prefs.put(HIGHEST_RUN_VERSION, highestRunVersion.toString());
     }

     // Are we up to date already?
     //
     if (highestRunVersion.compareTo(serverVersion) >= 0) {
       // Yes, we are.
       //
       branch.log(CHECK_INFO, "Server version (" + serverVersion
           + ") is not newer than " + highestRunVersion);
       return null;
     }

     // Commence nagging.
     //
     URL url = null;
     try {
       url = new URL(notifyUrl);
     } catch (MalformedURLException e) {
       logger.log(CHECK_ERROR, "Malformed notify URL: " + notifyUrl, e);
     }
     final URL finalUrl = url;
     return new UpdateResult() {
       public GwtVersion getNewVersion() {
         return serverVersion;
       }

       public URL getURL() {
         return finalUrl;
       }
     };
   }
 }
	/*
	* Copyright 2006 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License"); you may not
	* use this file except in compliance with the License. You may obtain a copy of
	* the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations under
	* the License.
	*/
	package com.google.gwt.dev.shell;

	import com.google.gwt.core.ext.TreeLogger;
	import com.google.gwt.core.ext.TreeLogger.HelpInfo;
	import com.google.gwt.dev.About;
	import com.google.gwt.dev.GwtVersion;
	import com.google.gwt.dev.shell.ie.CheckForUpdatesIE6;

	import org.w3c.dom.Document;
	import org.w3c.dom.Element;
	import org.w3c.dom.Node;
	import org.w3c.dom.NodeList;
	import org.xml.sax.ErrorHandler;
	import org.xml.sax.SAXException;
	import org.xml.sax.SAXParseException;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.PrintWriter;
	import java.net.MalformedURLException;
	import java.net.URL;
	import java.net.URLConnection;
	import java.util.Date;
	import java.util.Locale;
	import java.util.concurrent.Callable;
	import java.util.concurrent.ExecutionException;
	import java.util.concurrent.FutureTask;
	import java.util.concurrent.TimeUnit;
	import java.util.concurrent.TimeoutException;
	import java.util.prefs.Preferences;

	import javax.xml.parsers.DocumentBuilder;
	import javax.xml.parsers.DocumentBuilderFactory;
	import javax.xml.parsers.ParserConfigurationException;

	/**
	* Orchestrates a best-effort attempt to find out if a new version of GWT is
	* available.
	*/
	public class CheckForUpdates {

	/**
	* Returns the result of an update check.
	*/
	public interface UpdateResult {
	/**
	* @return the new version of GWT available.
	*/
	GwtVersion getNewVersion();

	/**
	* @return the URL for details about the new version.
	*/
	URL getURL();
	}

	public static final long ONE_DAY = 24 * 60 * 60 * 1000;
	public static final long ONE_MINUTE = 60 * 1000;

	// System properties used by CheckForUpdates
	protected static final String PROPERTY_DEBUG_HTTP_GET = "gwt.debugLowLevelHttpGet";
	protected static final String PROPERTY_FORCE_NONNATIVE = "gwt.forceVersionCheckNonNative";
	protected static final String PROPERTY_PREFS_NAME = "gwt.prefsPathName";
	protected static final String PROPERTY_QUERY_URL = "gwt.forceVersionCheckURL";

	// Log levels -- in general we want the logging of the update process
	// to not be visible to normal users.
	private static final TreeLogger.Type CHECK_ERROR = TreeLogger.DEBUG;
	private static final TreeLogger.Type CHECK_INFO = TreeLogger.SPAM;
	private static final TreeLogger.Type CHECK_SPAM = TreeLogger.SPAM;
	private static final TreeLogger.Type CHECK_WARN = TreeLogger.SPAM;

	// Preferences keys
	private static final String FIRST_LAUNCH = "firstLaunch";
	private static final String HIGHEST_RUN_VERSION = "highestRunVersion";
	private static final String LAST_PING = "lastPing";
	private static final String NEXT_PING = "nextPing";

	// Uncomment one of constants below to try different variations of failure to
	// make sure we never interfere with the app running.

	// Check against a fake server to see failure to contact server.
	// protected static final String QUERY_URL =
	// "http://nonexistenthost:1111/gwt/currentversion.xml";

	// Check 404 on a real location that doesn't have the file.
	// protected static final String QUERY_URL =
	// "http://www.google.com/gwt/currentversion.xml";

	// A test URL for seeing it actually work in a sandbox.
	// protected static final String QUERY_URL =
	// "http://localhost/gwt/currentversion.xml";

	// The real URL that should be used.
	private static final String QUERY_URL = "http://tools.google.com/webtoolkit/currentversion.xml";

	public static FutureTask<UpdateResult> checkForUpdatesInBackgroundThread(
	final TreeLogger logger, final long minCheckMillis) {
	final String entryPoint = computeEntryPoint();
	FutureTask<UpdateResult> task = new FutureTask<UpdateResult>(
	new Callable<UpdateResult>() {
	public UpdateResult call() throws Exception {
	final CheckForUpdates updateChecker = createUpdateChecker(logger,
	entryPoint);
	return updateChecker == null ? null
	: updateChecker.check(minCheckMillis);
	}
	});
	Thread checkerThread = new Thread(task, "GWT Update Checker");
	checkerThread.setDaemon(true);
	checkerThread.start();
	return task;
	}

	/**
	* Find the first method named "main" on the call stack and use its class as
	* the entry point.
	*/
	public static String computeEntryPoint() {
	Throwable t = new Throwable();
	for (StackTraceElement stackTrace : t.getStackTrace()) {
	if (stackTrace.getMethodName().equals("main")) {
	// Strip package name from main's class
	String className = stackTrace.getClassName();
	int i = className.lastIndexOf('.');
	if (i >= 0) {
	return className.substring(i + 1);
	}
	return className;
	}
	}
	return null;
	}

	public static CheckForUpdates createUpdateChecker(TreeLogger logger) {
	return createUpdateChecker(logger, computeEntryPoint());
	}

	public static CheckForUpdates createUpdateChecker(TreeLogger logger,
	String entryPoint) {
	// Windows has a custom implementation to handle proxies.
	if (System.getProperty("os.name").toLowerCase(Locale.ENGLISH).contains("win")) {
	return new CheckForUpdatesIE6(logger, entryPoint);
	} else {
	return new CheckForUpdates(logger, entryPoint);
	}
	}

	public static void logUpdateAvailable(TreeLogger logger,
	FutureTask<UpdateResult> updater) {
	if (updater != null && updater.isDone()) {
	UpdateResult result = null;
	try {
	result = updater.get(0, TimeUnit.MILLISECONDS);
	} catch (InterruptedException e) {
	// Silently ignore exception
	} catch (ExecutionException e) {
	// Silently ignore exception
	} catch (TimeoutException e) {
	// Silently ignore exception
	}
	logUpdateAvailable(logger, result);
	}
	}

	public static void logUpdateAvailable(TreeLogger logger,
	UpdateResult result) {
	if (result != null) {
	final URL url = result.getURL();
	logger.log(TreeLogger.WARN, "A new version of GWT ("
	+ result.getNewVersion() + ") is available", null, new HelpInfo() {
	@Override
	public String getAnchorText() {
	return "Release Notes";
	}

	@Override
	public URL getURL() {
	return url;
	}
	});
	}
	}

	private static String getTextOfLastElementHavingTag(Document doc,
	String tagName) {
	NodeList nodeList = doc.getElementsByTagName(tagName);
	int n = nodeList.getLength();
	if (n > 0) {
	Element elem = (Element) nodeList.item(n - 1);
	// Assume the first child is the value.
	//
	Node firstChild = elem.getFirstChild();
	if (firstChild != null) {
	String text = firstChild.getNodeValue();
	return text;
	}
	}

	return null;
	}

	private String entryPoint;

	private TreeLogger logger;

	private GwtVersion myVersion;

	/**
	* Create an update checker which will poll a server URL and log a message
	* about an update if available.
	*
	* @param logger TreeLogger to use
	* @param entryPoint the name of the main entry point used for this execution
	*/
	public CheckForUpdates(TreeLogger logger, String entryPoint) {
	this.logger = logger;
	this.entryPoint = entryPoint;
	myVersion = About.getGwtVersionObject();
	}

	/**
	* Check for updates and log to the logger if they are available.
	*
	* @return an UpdateResult or null if there is no new update
	*/
	public UpdateResult check() {
	return check(0);
	}

	/**
	* Check for updates and log to the logger if they are available.
	*
	* @return an UpdateResult or null if there is no new update
	*/
	public UpdateResult check(long minCheckMillis) {
	TreeLogger branch = logger.branch(CHECK_INFO, "Checking for updates");
	try {
	String prefsName = System.getProperty(PROPERTY_PREFS_NAME);
	Preferences prefs;
	if (prefsName != null) {
	prefs = Preferences.userRoot().node(prefsName);
	} else {
	prefs = Preferences.userNodeForPackage(CheckForUpdates.class);
	}

	String queryURL = QUERY_URL;
	String forceCheckURL = System.getProperty(PROPERTY_QUERY_URL);

	if (forceCheckURL != null) {
	branch.log(CHECK_INFO, "Explicit version check URL: " + forceCheckURL);
	queryURL = forceCheckURL;
	}

	// Get our unique user id (based on absolute timestamp).
	//
	long currentTimeMillis = System.currentTimeMillis();
	String firstLaunch = prefs.get(FIRST_LAUNCH, null);
	if (firstLaunch == null) {
	firstLaunch = Long.toHexString(currentTimeMillis);
	prefs.put(FIRST_LAUNCH, firstLaunch);
	branch.log(CHECK_SPAM, "Setting first launch to " + firstLaunch);
	} else {
	branch.log(CHECK_SPAM, "First launch was " + firstLaunch);
	}

	// See if enough time has passed.
	//
	String lastPing = prefs.get(LAST_PING, "0");
	if (lastPing != null) {
	try {
	long lastPingTime = Long.parseLong(lastPing);
	if (currentTimeMillis < lastPingTime + minCheckMillis) {
	// it's not time yet
	branch.log(CHECK_INFO, "Last ping was " + new Date(lastPingTime)
	+ ", min wait is " + minCheckMillis + "ms");
	return null;
	}
	} catch (NumberFormatException e) {
	branch.log(CHECK_WARN, "Error parsing last ping time", e);
	}
	}

	// See if it's time for our next ping yet.
	//
	String nextPing = prefs.get(NEXT_PING, "0");
	if (nextPing != null) {
	try {
	long nextPingTime = Long.parseLong(nextPing);
	if (currentTimeMillis < nextPingTime) {
	// it's not time yet
	branch.log(CHECK_INFO, "Next ping is not until "
	+ new Date(nextPingTime));
	return null;
	}
	} catch (NumberFormatException e) {
	branch.log(CHECK_WARN, "Error parsing next ping time", e);
	}
	}

	// See if new version is available.
	//
	String url = queryURL + "?v=" + myVersion.toString() + "&id="
	+ firstLaunch + "&r=" + About.getGwtSvnRev();
	if (entryPoint != null) {
	url += "&e=" + entryPoint;
	}

	branch.log(CHECK_INFO, "Checking for new version at " + url);

	// Do the HTTP GET.
	//
	byte[] response;
	String fullUserAgent = makeUserAgent();
	if (System.getProperty(PROPERTY_FORCE_NONNATIVE) == null) {
	// Use subclass.
	//
	response = doHttpGet(branch, fullUserAgent, url);
	} else {
	// Use the pure Java version, but it probably doesn't work with proxies.
	//
	response = httpGetNonNative(branch, fullUserAgent, url);
	}

	if (response == null \|\| response.length == 0) {
	// Problem. Quietly fail.
	//
	branch.log(CHECK_ERROR,
	"Failed to obtain current version info via HTTP");
	return null;
	}

	// Parse and process the response.
	// Bad responses will be silently ignored.
	//
	return parseResponse(branch, prefs, response);

	} catch (Throwable e) {
	// Always silently ignore any errors.
	//
	branch.log(CHECK_INFO, "Exception while processing version info", e);
	}
	return null;
	}

	/**
	* Default implementation just uses the platform-independent method. A
	* subclass should override this method for platform-dependent proxy handling,
	* for example.
	*
	* @param branch TreeLogger to use
	* @param userAgent user agent string to send in request
	* @param url URL to fetch
	* @return byte array of response, or null if an error
	*/
	protected byte[] doHttpGet(TreeLogger branch, String userAgent, String url) {
	return httpGetNonNative(branch, userAgent, url);
	}

	/**
	* This default implementation uses regular Java HTTP, which doesn't deal with
	* proxies automagically. See the IE6 subclasses for an implementation that
	* does deal with proxies.
	*
	* @param branch TreeLogger to use
	* @param userAgent user agent string to send in request
	* @param url URL to fetch
	* @return byte array of response, or null if an error
	*/
	protected byte[] httpGetNonNative(TreeLogger branch, String userAgent,
	String url) {
	Throwable caught;
	InputStream is = null;
	try {
	URL urlToGet = new URL(url);
	URLConnection conn = urlToGet.openConnection();
	conn.setRequestProperty("User-Agent", userAgent);
	is = conn.getInputStream();
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	byte[] buffer = new byte[4096];
	int bytesRead;
	while ((bytesRead = is.read(buffer)) != -1) {
	baos.write(buffer, 0, bytesRead);
	}
	byte[] response = baos.toByteArray();
	return response;
	} catch (MalformedURLException e) {
	caught = e;
	} catch (IOException e) {
	caught = e;
	} finally {
	if (is != null) {
	try {
	is.close();
	} catch (IOException e) {
	}
	}
	}

	if (System.getProperty(PROPERTY_DEBUG_HTTP_GET) != null) {
	branch.log(CHECK_ERROR, "Exception in HTTP request", caught);
	}

	return null;
	}

	private void appendUserAgentProperty(StringBuffer sb, String propName) {
	String propValue = System.getProperty(propName);
	if (propValue != null) {
	if (sb.length() > 0) {
	sb.append("; ");
	}
	sb.append(propName);
	sb.append("=");
	sb.append(propValue);
	}
	}

	/**
	* Creates a user-agent string by combining standard Java properties.
	*/
	private String makeUserAgent() {
	String ua = "GWT Freshness Checker";

	StringBuffer extra = new StringBuffer();
	appendUserAgentProperty(extra, "java.vendor");
	appendUserAgentProperty(extra, "java.version");
	appendUserAgentProperty(extra, "os.arch");
	appendUserAgentProperty(extra, "os.name");
	appendUserAgentProperty(extra, "os.version");

	if (extra.length() > 0) {
	ua += " (" + extra.toString() + ")";
	}

	return ua;
	}

	private UpdateResult parseResponse(TreeLogger branch, Preferences prefs,
	byte[] response) throws IOException, ParserConfigurationException,
	SAXException {

	branch.log(CHECK_SPAM, "Parsing response (length " + response.length + ")");

	DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
	DocumentBuilder builder = factory.newDocumentBuilder();
	ByteArrayInputStream bais = new ByteArrayInputStream(response);

	// Parse the XML.
	//
	builder.setErrorHandler(new ErrorHandler() {

	public void error(SAXParseException exception) throws SAXException {
	// fail quietly
	}

	public void fatalError(SAXParseException exception) throws SAXException {
	// fail quietly
	}

	public void warning(SAXParseException exception) throws SAXException {
	// fail quietly
	}
	});
	Document doc = builder.parse(bais);

	// The latest version number.
	//
	String versionString = getTextOfLastElementHavingTag(doc, "latest-version");
	if (versionString == null) {
	// Not valid; quietly fail.
	//
	branch.log(CHECK_ERROR, "Failed to find <latest-version>");
	return null;
	}
	GwtVersion currentReleasedVersion;
	try {
	currentReleasedVersion = new GwtVersion(versionString.trim());
	} catch (NumberFormatException e) {
	branch.log(CHECK_ERROR, "Bad version: " + versionString, e);
	return null;
	}

	// Ping delay for server-controlled throttling.
	//
	String pingDelaySecsStr = getTextOfLastElementHavingTag(doc,
	"min-wait-seconds");
	int pingDelaySecs = 0;
	if (pingDelaySecsStr == null) {
	// Not valid; quietly fail.
	//
	branch.log(CHECK_ERROR, "Missing <min-wait-seconds>");
	return null;
	}
	try {
	pingDelaySecs = Integer.parseInt(pingDelaySecsStr.trim());
	} catch (NumberFormatException e) {
	// Not a valid number; quietly fail.
	//
	branch.log(CHECK_ERROR, "Bad min-wait-seconds number: "
	+ pingDelaySecsStr);
	return null;
	}

	String url = getTextOfLastElementHavingTag(doc, "notification-url");

	if (url == null) {
	// no URL, so write the HTML locally and provide a URL from that

	// Read the HTML.
	//
	String html = getTextOfLastElementHavingTag(doc, "notification");

	if (html == null) {
	// Not valid; quietly fail.
	//
	branch.log(CHECK_ERROR, "Missing <notification>");
	return null;
	}
	PrintWriter writer = null;
	try {
	String tempDir = System.getProperty("java.io.tmpdir");
	File updateHtml = new File(tempDir, "gwt-update-"
	+ currentReleasedVersion + ".html");
	writer = new PrintWriter(new FileOutputStream(updateHtml));
	writer.print(html);
	url = "file://" + updateHtml.getAbsolutePath();
	} finally {
	if (writer != null) {
	writer.close();
	}
	}
	}

	// Okay -- this is a valid response.
	//
	return processResponse(branch, prefs, currentReleasedVersion,
	pingDelaySecs, url);
	}

	private UpdateResult processResponse(TreeLogger branch, Preferences prefs,
	final GwtVersion serverVersion, int pingDelaySecs, final String notifyUrl) {

	// Record a ping; don't ping again until the delay is up.
	//
	long currentTimeMillis = System.currentTimeMillis();
	long nextPingTime = currentTimeMillis + pingDelaySecs * 1000;
	prefs.put(NEXT_PING, String.valueOf(nextPingTime));
	prefs.put(LAST_PING, String.valueOf(currentTimeMillis));

	branch.log(CHECK_INFO, "Ping delay is " + pingDelaySecs + "; next ping at "
	+ new Date(nextPingTime));

	if (myVersion.isNoNagVersion()) {
	// If the version number indicates no nagging about updates, exit here
	// once we have recorded the next ping time. No-nag versions (ie,
	// trunk builds) should also not update the highest version that has been
	// run.
	return null;
	}

	// Update the highest version of GWT that has been run if we are later.
	GwtVersion highestRunVersion = new GwtVersion(prefs.get(
	HIGHEST_RUN_VERSION, null));
	if (myVersion.compareTo(highestRunVersion) > 0) {
	highestRunVersion = myVersion;
	prefs.put(HIGHEST_RUN_VERSION, highestRunVersion.toString());
	}

	// Are we up to date already?
	//
	if (highestRunVersion.compareTo(serverVersion) >= 0) {
	// Yes, we are.
	//
	branch.log(CHECK_INFO, "Server version (" + serverVersion
	+ ") is not newer than " + highestRunVersion);
	return null;
	}

	// Commence nagging.
	//
	URL url = null;
	try {
	url = new URL(notifyUrl);
	} catch (MalformedURLException e) {
	logger.log(CHECK_ERROR, "Malformed notify URL: " + notifyUrl, e);
	}
	final URL finalUrl = url;
	return new UpdateResult() {
	public GwtVersion getNewVersion() {
	return serverVersion;
	}

	public URL getURL() {
	return finalUrl;
	}
	};
	}
	}