Add --payload to devserver to allow the update payload to be specified by the devserver user.

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 @@
       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,
+               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
     self.crosutils = os.path.join(os.path.dirname(__file__), '../../scripts')
 
   def _GetSecondsSinceMidnight(self):
     """Returns the seconds since midnight as a decimal value."""
     now = time.localtime()
     return now[3] * 3600 + now[4] * 60 + now[5]
 
@@ skipping 76 matching lines @@
     """Returns the sha256 of the file given."""
     cmd = ('cat %s | openssl dgst -sha256 -binary | openssl base64' %
            update_path)
     return os.popen(cmd).read().rstrip()
 
   def _GetMd5(self, update_path):
     """Returns the md5 checksum of the file given."""
     cmd = ("md5sum %s | awk '{print $1}'" % update_path)
     return os.popen(cmd).read().rstrip()
 
-  def _Symlink(self, source, dest):
-    """Creates a symlink at dest to source"""
-    if os.path.exists(dest):
+  def _Copy(self, source, dest):
+    """Copies a file from dest to source (if different)"""
+    _LogMessage('Copy File %s -> %s' % (source, dest))
+    if os.path.lexists(dest):
       os.remove(dest)
-    os.symlink(source, dest)
+    shutil.copy(source, dest)
 
   def GetUpdatePayload(self, hash, sha256, size, url, is_delta_format):
     """Returns a payload to the client corresponding to a new update.
 
     Args:
       hash: hash of update blob
       sha256: SHA-256 hash of update blob
       size: size of update blob
       url: where to find update blob
     Returns:
@@ skipping 186 matching lines @@
         return None
 
       # Verify they were created with the expected names
       new_update_payload, new_stateful_payload = payloads
 
       _LogMessage('"%s" "%s"' % (new_update_payload, cache_update_payload))
       assert new_update_payload == cache_update_payload
       _LogMessage('"%s" "%s"' % (new_stateful_payload, cache_stateful_payload))
       assert new_stateful_payload == cache_stateful_payload
 
-    # If the generation worked, create symlinks
-    self._Symlink(cache_update_payload, update_payload)
-    self._Symlink(cache_stateful_payload, stateful_payload)
+    # If the generation worked, copy files
+    self._Copy(cache_update_payload, update_payload)
+    self._Copy(cache_stateful_payload, stateful_payload)
 
     # return just the filename which is symlink in static_image_dir
     return 'update.gz'
 
   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'.
@@ skipping 142 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.
     """
-    if self.forced_image:
+    if self.forced_payload:
+      # If the forced payload is not already in our static_image_dir,
+      # copy it there.
+      if (os.path.dirname(os.path.abspath(self.forced_payload)) !=
+          os.path.abspath(static_image_dir)):
+        self._Copy(self.forced_payload, os.path.join(static_image_dir,
+                                                     'update.gz'))
+
+        self._Copy(os.path.join(os.path.dirname(self.forced_payload),
+                                'stateful.tgz'),
+                   os.path.join(static_image_dir,
+                                'stateful.tgz'))
+
+      return 'update.gz'
+    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)
     else:
       if board_id:
         return self.GenerateLatestUpdateImage(board_id,
                                               client_version,
                                               static_image_dir)
@@ skipping 82 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()