Refactor devserver to print out relative paths to the update file

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
 import urlparse
 
 
 def _LogMessage(message):
   cherrypy.log(message, 'UPDATE')
 
-UPDATE_FILE='update.gz'
-STATEFUL_FILE='stateful.tgz'
+UPDATE_FILE = 'update.gz'
+STATEFUL_FILE = 'stateful.tgz'
+CACHE_DIR = 'cache'
 
 
 def _ChangeUrlPort(url, new_port):
   """Return the URL passed in with a different port"""
   scheme, netloc, path, query, fragment = urlparse.urlsplit(url)
   host_port = netloc.split(':')
 
   if len(host_port) == 1:
     host_port.append(new_port)
   else:
@@ skipping 44 matching lines @@
 
     self.client_prefix = client_prefix
     self.forced_image = forced_image
     self.forced_payload = forced_payload
     self.src_image = src_image
     self.proxy_port = proxy_port
     self.vm = vm
     self.board = board
     self.copy_to_static_root = copy_to_static_root
 
-    # Track update pregeneration, so we don't recopy if not needed.
-    self.pregenerated = False
+    # Path to pre-generated file.
+    self.pregenerated_path = None
 
   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 148 matching lines @@
     if self.vm:
       patch_kernel_flag = ''
 
     mkupdate_command = (
         '%s/cros_generate_update_payload --image="%s" --output="%s" '
         '%s --noold_style --src_image="%s"' % (
             self.scripts_dir, image_path, update_path, patch_kernel_flag,
             src_image))
     _LogMessage(mkupdate_command)
     if os.system(mkupdate_command) != 0:
-      _LogMessage('Failed to create base update file')
+      _LogMessage('Failed to create update payload')
       return None
 
     return UPDATE_FILE
 
   def GenerateStatefulFile(self, image_path, output_dir):
     """Generates a stateful update payload given a full path to an image.
 
     Args:
       image_path: Full path to image.
     Returns:
@@ skipping 11 matching lines @@
     return STATEFUL_FILE
 
   def FindCachedUpdateImageSubDir(self, src_image, dest_image):
     """Find directory to store a cached update.
 
        Given one, or two images for an update, this finds which
        cache directory should hold the update files, even if they don't exist
        yet. The directory will be inside static_image_dir, and of the form:
 
        Non-delta updates:
-         cache/12345678
+         CACHE_DIR/12345678
 
        Delta updates:
-         cache/12345678_12345678
+         CACHE_DIR/12345678_12345678
        """
     # If there is no src, we only have an image file, check image for changes
     if not src_image:
-      return os.path.join('cache', self._GetMd5(dest_image))
+      return os.path.join(CACHE_DIR, self._GetMd5(dest_image))
 
     # If we have src and dest, we are a delta, and check both for changes
-    return os.path.join('cache',
+    return os.path.join(CACHE_DIR,
                         "%s_%s" % (self._GetMd5(src_image),
                                    self._GetMd5(dest_image)))
 
   def GenerateUpdateImage(self, image_path, output_dir):
     """Force generates an update payload based on the given image_path.
 
     Args:
       src_image: image we are updating from (Null/empty for non-delta)
       image_path: full path to the image.
       output_dir: the directory to write the update payloads in
     Returns:
       update payload name relative to output_dir
     """
     update_file = None
     stateful_update_file = None
 
     # Actually do the generation
     _LogMessage('Generating update for image %s' % image_path)
     update_file = self.GenerateUpdateFile(self.src_image,
                                           image_path,
                                           output_dir)
 
     if update_file:
       stateful_update_file = self.GenerateStatefulFile(image_path,
                                                        output_dir)
 
     if update_file and stateful_update_file:
       return update_file
-
-    _LogMessage('Failed to generate update')
-
-    # Cleanup incomplete files, if they exist
-    if update_file and os.path.exists(update_file):
-      os.remove(update_file)
-
-    return None
+    else:
+      _LogMessage('Failed to generate update.')
+      return None
 
   def GenerateUpdateImageWithCache(self, image_path, static_image_dir):
     """Force generates an update payload based on the given image_path.
 
     Args:
       image_path: full path to the image.
       static_image_dir: the directory to move images to after generating.
     Returns:
       update filename (not directory) relative to static_image_dir on success,
-        or None
+        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 it was pregenerated_path, don't regenerate
+    if self.pregenerated_path:
+      return self.pregenerated_path
 
     # 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)
 
+    update_path = os.path.join(cache_sub_dir, UPDATE_FILE)
+
     # The cached payloads exist in a cache dir
     cache_update_payload = os.path.join(static_image_dir,
-                                        cache_sub_dir,
-                                        UPDATE_FILE)
+                                        update_path)
     cache_stateful_payload = os.path.join(static_image_dir,
                                           cache_sub_dir,
                                           STATEFUL_FILE)
 
-    # The final results exist directly in static
-    update_payload = os.path.join(static_image_dir,
-                                  UPDATE_FILE)
-    stateful_payload = os.path.join(static_image_dir,
-                                    STATEFUL_FILE)
+    # Check to see if this cache directory is valid.
+    if not os.path.exists(cache_update_payload) or not os.path.exists(
+        cache_stateful_payload):
+      full_cache_dir = os.path.join(static_image_dir, cache_sub_dir)
+      # Clean up stale state.
+      os.system('rm -rf "%s"' % full_cache_dir)
+      os.makedirs(full_cache_dir)
+      return_path = self.GenerateUpdateImage(image_path,
+                                             full_cache_dir)
 
-    # If there isn't a cached payload, make one
-    if not os.path.exists(cache_update_payload):
-      full_cache_dir = os.path.join(static_image_dir, cache_sub_dir)
+      # Clean up cache dir since it's not valid.
+      if not return_path:
+        os.system('rm -rf "%s"' % full_cache_dir)
+        return None
+      else:
+        assert (return_path == update_path,
+                'Returned path %s not equal to %s' % (return_path, update_path))
 
-      # Create the directory for the cache values
-      if not os.path.exists(full_cache_dir):
-        os.makedirs(full_cache_dir)
-
-      result = self.GenerateUpdateImage(image_path,
-                                        full_cache_dir)
-
-      if not result:
-        # Clean up cache dir if it's not valid
-        os.system("rm -rf %s" % os.path.join(static_image_dir, cache_sub_dir))
-        return None
+    self.pregenerated_path = update_path
 
     # Generation complete, copy if requested.
     if self.copy_to_static_root:
+      # The final results exist directly in static
+      update_payload = os.path.join(static_image_dir,
+                                    UPDATE_FILE)
+      stateful_payload = os.path.join(static_image_dir,
+                                      STATEFUL_FILE)
       self._Copy(cache_update_payload, update_payload)
       self._Copy(cache_stateful_payload, stateful_payload)
-
-    # Return just the filename in static_image_dir.
-    return UPDATE_FILE
+      return UPDATE_FILE
+    else:
+      return self.pregenerated_path
 
   def GenerateLatestUpdateImage(self, board_id, client_version,
                                 static_image_dir):
     """Generates an update using the latest image that has been built.
 
     This will only generate an update if the newest update is newer than that
     on the client or client_version is 'ForcedUpdate'.
 
     Args:
       board_id: Name of the board.
@@ skipping 118 matching lines @@
        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)
-
       src_stateful = os.path.join(os.path.dirname(src_path),
                                   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)
@@ skipping 18 matching lines @@
         _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.')
+      _LogMessage('Failed to genereate update. '
+                  'You must set --board when pre-generating latest update.')
       return None
 
   def PreGenerateUpdate(self):
-    """Pre-generates an update.  Returns True on success.
+    """Pre-generates an update and prints out the relative path it.
+
+    Returns relative path of the update on success.
     """
      # Does not work with factory config.
     assert(not self.factory_config)
     _LogMessage('Pre-generating the update payload.')
     # Does not work with labels so just use static dir.
-    if self.GenerateUpdatePayloadForNonFactory(self.board, '0.0.0.0',
-                                               self.static_dir):
-      _LogMessage('Pre-generated update successfully.')
-      self.pregenerated = True
-      return True
-    else:
-      _LogMessage('Failed to pre-generate update.')
-      return False
+    pregenerated_update = self.GenerateUpdatePayloadForNonFactory(
+        self.board, '0.0.0.0', self.static_dir)
+    if pregenerated_update:
+      print 'PREGENERATED_UPDATE=%s' % pregenerated_update
+
+    return pregenerated_update
 
   def HandleUpdatePing(self, data, label=None):
     """Handles an update ping from an update client.
 
     Args:
       data: xml blob from client.
       label: optional label for the update.
     Returns:
       Update payload message for client.
     """
@@ skipping 59 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()