--archive_dir will now serve existing update.gz

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 cherrypy
 import os
 import shutil
 import subprocess
 import time
 
 
 def _LogMessage(message):
   cherrypy.log(message, 'UPDATE')
 
 UPDATE_FILE='update.gz'
 STATEFUL_FILE='stateful.tgz'
 
 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.
+    serve_only: Serve only pre-built updates. static_dir must contain update.gz
+      and stateful.tgz.
     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, forced_payload=None,
                port=8080, src_image='', vm=False, board=None,
                *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
     if urlbase:
       self.urlbase = urlbase
     else:
       self.urlbase = None
 
     self.client_prefix = client_prefix
     self.forced_image = forced_image
     self.forced_payload = forced_payload
     self.src_image = src_image
     self.vm = vm
     self.board = board
 
-    # Caching is enabled if we are not doing serve_only
-    # aka if --archive_dir was not passed in.
-    self.caching_enabled = not self.serve_only
-
     # Track update pregeneration, so we don't recopy if not needed.
     self.pregenerated = False
 
   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."""
@@ skipping 247 matching lines @@
       update filename (not directory) relative to static_image_dir on success,
         or None
     """
     _LogMessage('Generating update for src %s image %s' % (self.src_image,
                                                            image_path))
 
     # If it was pregenerated, don't regenerate
     if self.pregenerated:
       return UPDATE_FILE
 
-    if not self.caching_enabled:
-      return self.GenerateUpdateImage(image_path, static_image_dir)
-
     # Which sub_dir of static_image_dir should hold our cached update image
     cache_sub_dir = self.FindCachedUpdateImageSubDir(self.src_image, image_path)
     _LogMessage('Caching in sub_dir "%s"' % cache_sub_dir)
 
     # The cached payloads exist in a cache dir
     cache_update_payload = os.path.join(static_image_dir,
                                         cache_sub_dir,
                                         UPDATE_FILE)
     cache_stateful_payload = os.path.join(static_image_dir,
                                           cache_sub_dir,
@@ skipping 51 matching lines @@
 
      # Check to see whether or not we should update.
     if client_version != 'ForcedUpdate' and not self._CanUpdate(
         client_version, latest_version):
       _LogMessage('no update')
       return None
 
     return self.GenerateUpdateImageWithCache(latest_image_path,
                                              static_image_dir=static_image_dir)
 
-  def GenerateImageFromZip(self, static_image_dir):
-    """Generates an update from an image zip file.
-
-    This method assumes you have an image.zip in directory you are serving
-    from.  If this file is newer than a previously cached file, it will unzip
-    this file, create a payload and serve it.
-
-    Args:
-      static_image_dir: Directory where the zip file exists.
-    Returns:
-      Name of the update payload relative to static_image_dir if successful.
-    """
-    _LogMessage('Preparing to generate update from zip in %s.' %
-                static_image_dir)
-    image_path = os.path.join(static_image_dir, self._GetImageName())
-    zip_file_path = os.path.join(static_image_dir, 'image.zip')
-
-    # TODO(dgarrett): Either work caching into this path before
-    #       we unpack, or remove zip support (sosa is considering).
-    #       It does currently cache, but after the unpack.
-
-    if not self._UnpackZip(static_image_dir):
-      _LogMessage('unzip image.zip failed.')
-      return None
-
-    return self.GenerateUpdateImageWithCache(image_path,
-                                             static_image_dir=static_image_dir)
-
   def ImportFactoryConfigFile(self, filename, validate_checksums=False):
     """Imports a factory-floor server configuration file. The file should
     be in this format:
       config = [
         {
           'qual_ids': set([1, 2, 3, "x86-generic"]),
           'factory_image': 'generic-factory.gz',
           'factory_checksum': 'AtiI8B64agHVN+yeBAyiNMX3+HM=',
           'release_image': 'generic-release.gz',
           'release_checksum': 'AtiI8B64agHVN+yeBAyiNMX3+HM=',
@@ skipping 80 matching lines @@
     # setting sha-256 to an empty string.
     return self.GetUpdatePayload(checksum, '', size, url, is_delta_format)
 
   def GenerateUpdatePayloadForNonFactory(self, board_id, client_version,
                                          static_image_dir):
     """Generates an update for non-factory image.
 
        Returns:
          file name relative to static_image_dir on success.
     """
+    dest_path = os.path.join(static_image_dir, UPDATE_FILE)
+    dest_stateful = os.path.join(static_image_dir, STATEFUL_FILE)
+
     if self.forced_payload:
       # If the forced payload is not already in our static_image_dir,
       # copy it there.
       src_path = os.path.abspath(self.forced_payload)
-      dest_path = os.path.join(static_image_dir, UPDATE_FILE)
 
       src_stateful = os.path.join(os.path.dirname(src_path),
                                   STATEFUL_FILE)
-      dest_stateful = os.path.join(static_image_dir,
-                                   STATEFUL_FILE)
 
       # Only copy the files if the source directory is different from dest.
       if os.path.dirname(src_path) != os.path.abspath(static_image_dir):
         self._Copy(src_path, dest_path)
 
         # The stateful payload is optional.
         if os.path.exists(src_stateful):
           self._Copy(src_stateful, dest_stateful)
         else:
           _LogMessage('WARN: %s not found. Expected for dev and test builds.' %
                       STATEFUL_FILE)
           if os.path.exists(dest_stateful):
             os.remove(dest_stateful)
 
       return UPDATE_FILE
     elif self.forced_image:
       return self.GenerateUpdateImageWithCache(
           self.forced_image,
           static_image_dir=static_image_dir)
     elif self.serve_only:
-      return self.GenerateImageFromZip(static_image_dir)
+      # Warn if update or stateful files can't be found.
+      if not os.path.exists(dest_path):
+        _LogMessage('WARN: %s not found. Expected for dev and test builds.' %
+                    UPDATE_FILE)
+
+      if not os.path.exists(dest_stateful):
+        _LogMessage('WARN: %s not found. Expected for dev and test builds.' %
+                    STATEFUL_FILE)
+
+      return UPDATE_FILE
     else:
       if board_id:
         return self.GenerateLatestUpdateImage(board_id,
                                               client_version,
                                               static_image_dir)
 
       _LogMessage('You must set --board for pre-generating latest update.')
       return None
 
   def PreGenerateUpdate(self):
@@ skipping 78 matching lines @@
         is_delta_format = self._IsDeltaFormatFile(filename)
         if label:
           url = '%s/%s/%s' % (static_urlbase, label, payload_path)
         else:
           url = '%s/%s' % (static_urlbase, payload_path)
 
         _LogMessage('Responding to client to use url %s to get image.' % url)
         return self.GetUpdatePayload(hash, sha256, size, url, is_delta_format)
       else:
         return self.GetNoUpdatePayload()