Fix devserver with handling custom labels.

autoupdate.py

 # Copyright (c) 2009-2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 from buildutil import BuildObject
 from xml.dom import minidom
 
 import os
 import shutil
 import time
 import web
 
 
 class Autoupdate(BuildObject):
   """Class that contains functionality that handles Chrome OS update pings.
 
   Members:
     serve_only: Serve images from a pre-built image.zip file.  static_dir
       must be set to the location of the image.zip.
     factory_config: Path to the factory config file if handling factory
       requests.
     use_test_image: Use chromiumos_test_image.bin rather than the standard.
     static_url_base: base URL, other than devserver, for update images.
     client_prefix: The prefix for the update engine client.
     forced_image: Path to an image to use for all updates.
   """
 
   def __init__(self, serve_only=None, test_image=False, urlbase=None,
                factory_config_path=None, client_prefix=None, forced_image=None,
-               *args, **kwargs):
+               use_cached=False, *args, **kwargs):
     super(Autoupdate, self).__init__(*args, **kwargs)
     self.serve_only = serve_only
     self.factory_config = factory_config_path
     self.use_test_image = test_image
-    self.static_urlbase = urlbase
+    if urlbase:
+      self.static_urlbase = urlbase
+    elif self.serve_only:
+      self.static_urlbase = 'http://%(host)s/static/archive'
+    else:
+      self.static_urlbase = 'http://%(host)s/static'
+
     self.client_prefix = client_prefix
     self.forced_image = forced_image
+    self.use_cached = use_cached
 
   def _GetSecondsSinceMidnight(self):
     """Returns the seconds since midnight as a decimal value."""
     now = time.localtime()
     return now[3] * 3600 + now[4] * 60 + now[5]
 
   def _GetDefaultBoardID(self):
     """Returns the default board id stored in .default_board."""
     board_file = '%s/.default_board' % (self.scripts_dir)
     try:
@@ skipping 54 matching lines @@
     """Returns the name of the image that should be used."""
     if self.use_test_image:
       image_name = 'chromiumos_test_image.bin'
     else:
       image_name = 'chromiumos_image.bin'
     return image_name
 
   def _IsImageNewerThanCached(self, image_path, cached_file_path):
     """Returns true if the image is newer than the cached image."""
     if os.path.exists(cached_file_path) and os.path.exists(image_path):
-      web.debug('Usable cached image found.')
+      web.debug('Usable cached image found at %s.' % cached_file_path)
       return os.path.getmtime(image_path) > os.path.getmtime(cached_file_path)
     elif not os.path.exists(cached_file_path) and not os.path.exists(image_path):
       raise Exception('Image does not exist and cached image missing')
     else:
       # Only one is missing, figure out which one.
       if os.path.exists(image_path):
         web.debug('No cached image found - image generation required.')
         return True
       else:
-        web.debug('Only cached image found to serve.')
+        web.debug('Cached image found to serve at %s.' % cached_file_path)
         return False
 
   def _GetSize(self, update_path):
     """Returns the size of the file given."""
     return os.path.getsize(update_path)
 
   def _GetHash(self, update_path):
     """Returns the sha1 of the file given."""
     cmd = ('cat %s | openssl sha1 -binary | openssl base64 | tr \'\\n\' \' \';'
            % update_path)
@@ skipping 300 matching lines @@
     Args:
       data: xml blob from client.
       label: optional label for the update.
     Returns:
       Update payload message for client.
     """
     web.debug('handling update ping: %s' % data)
     update_dom = minidom.parseString(data)
     root = update_dom.firstChild
 
+    # Parse host if not done yet.
+    if '%(host)' in self.static_urlbase:
+      self.static_urlbase = self.static_urlbase % {'host' : web.ctx.host}
+
     # Check the client prefix to make sure you can support this type of update.
     if (root.hasAttribute('updaterversion') and
         not root.getAttribute('updaterversion').startswith(self.client_prefix)):
       web.debug('Got update from unsupported updater:' +
                 root.getAttribute('updaterversion'))
       return self.GetNoUpdatePayload()
 
     # We only generate update payloads for updatecheck requests.
     update_check = root.getElementsByTagName('o:updatecheck')
     if not update_check:
@@ skipping 12 matching lines @@
 
     # Separate logic as Factory requests have static url's that override
     # other options.
     if self.factory_config:
       return self.HandleFactoryRequest(hostname, board_id, channel)
     else:
       static_image_dir = self.static_dir
       if label:
         static_image_dir = os.path.join(static_image_dir, label)
 
-      # Not for factory, find and serve the correct image given the options.
-      if self.forced_image:
-        has_built_image = self.GenerateUpdateImage(
-            self.forced_image, move_to_static_dir=True,
-            static_image_dir=static_image_dir)
-        # Now that we've generated it, clear out so that other pings of same
-        # devserver instance do not generate new images.
-        self.forced_image = None
-      elif self.serve_only:
-        has_built_image = self.GenerateImageFromZip(static_image_dir)
+      # Prefer cached image if it exists.
+      if self.use_cached and os.path.exists(os.path.join(static_image_dir,
+                                                         'update.gz')):
+        web.debug('Using cached image regardless of timestamps.')
+        has_built_image = True
       else:
-        has_built_image = self.GenerateLatestUpdateImage(board_id,
-                                                         client_version,
-                                                         static_image_dir)
+        if self.forced_image:
+          has_built_image = self.GenerateUpdateImage(
+              self.forced_image, move_to_static_dir=True,
+              static_image_dir=static_image_dir)
+          # Now that we've generated it, clear out so that other pings of same
+          # devserver instance do not generate new images.
+          self.forced_image = None
+        elif self.serve_only:
+          has_built_image = self.GenerateImageFromZip(static_image_dir)
+        else:
+          has_built_image = self.GenerateLatestUpdateImage(board_id,
+                                                           client_version,
+                                                           static_image_dir)
 
       if has_built_image:
         hash = self._GetHash(os.path.join(static_image_dir, 'update.gz'))
         sha256 = self._GetSHA256(os.path.join(static_image_dir, 'update.gz'))
         size = self._GetSize(os.path.join(static_image_dir, 'update.gz'))
-        if self.static_urlbase and label:
+        if label:
           url = '%s/%s/update.gz' % (self.static_urlbase, label)
-        elif self.serve_only:
-          url = 'http://%s/static/archive/update.gz' % hostname
         else:
-          url = 'http://%s/static/update.gz' % hostname
+          url = '%s/update.gz' % self.static_urlbase
+
+        web.debug('Responding to client to use url %s to get image.' % url)
         return self.GetUpdatePayload(hash, sha256, size, url)
       else:
         return self.GetNoUpdatePayload()