Fix pre-generate logic to work with latest and fix other bug.

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
@@ skipping 13 matching lines @@
     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,
-               use_cached=False, port=8080, src_image='', vm=False, *args,
-               **kwargs):
+               use_cached=False, 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.use_cached = use_cached
     self.src_image = src_image
     self.vm = vm
+    self.board = board
 
   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 229 matching lines @@
 
     Args:
       image_path: full path to the image.
       move_to_static_dir: Moves the files from their dir to the static dir.
       static_image_dir: the directory to move images to after generating.
     Returns:
       True if the update payload was created successfully.
     """
     _LogMessage('Generating update for image %s' % image_path)
     update_path = self.GenerateUpdateFile(image_path)
-    stateful_update_path = self.GenerateStatefulFile(image_path)
-    if not update_path or not stateful_update_path:
-      _LogMessage('Failed to generate update')
-      return False
+    if update_path:
+      stateful_update_path = self.GenerateStatefulFile(image_path)
+      if stateful_update_path:
+        if move_to_static_dir:
+          return self.MoveImagesToStaticDir(update_path, stateful_update_path,
+                                            static_image_dir)
 
-    if move_to_static_dir:
-      return self.MoveImagesToStaticDir(update_path, stateful_update_path,
-                                        static_image_dir)
-    else:
-      return True
+        return True
+
+    _LogMessage('Failed to generate update')
+    return False
 
   def GenerateLatestUpdateImage(self, board_id, client_version,
                                 static_image_dir=None):
     """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 147 matching lines @@
     """Generates an update for non-factory and returns True on success."""
     if self.use_cached and os.path.exists(os.path.join(static_image_dir,
                                                        'update.gz')):
       _LogMessage('Using cached image regardless of timestamps.')
       return True
     else:
       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, force devserver to use it.
-        self.use_cached = True
+        return has_built_image
       elif self.serve_only:
         return self.GenerateImageFromZip(static_image_dir)
-      elif board_id and client_version:
-        return self.GenerateLatestUpdateImage(board_id,
-                                              client_version,
-                                              static_image_dir)
       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 False
 
   def PreGenerateUpdate(self):
-    """Pre-generates an update.  Does not work for factory or label updates."""
+    """Pre-generates an update.  Returns True 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(None, None, self.static_dir):
+    if self.GenerateUpdatePayloadForNonFactory(self.board, '0.0.0.0',
+                                               self.static_dir):
       # Force the devserver to use the pre-generated payload.
       self.use_cached = True
+      _LogMessage('Pre-generated update successfully.')
+      return True
     else:
       _LogMessage('Failed to pre-generate update.')
+      return False
 
   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 52 matching lines @@
         is_delta_format = self._IsDeltaFormatFile(filename)
         if label:
           url = '%s/%s/update.gz' % (static_urlbase, label)
         else:
           url = '%s/update.gz' % static_urlbase
 
         _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()