Make stateful_update use ping_omaha's flags. small devserver clenaups.

src/platform/dev/autoupdate.py

 # Copyright (c) 2009 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 sys
@@ skipping 72 matching lines @@
     client_tokens = client_version.replace('_','').split('.')
     latest_tokens = latest_version.replace('_','').split('.')
     web.debug('client version %s latest version %s' \
         % (client_version, latest_version))
     for i in range(4):
       if int(latest_tokens[i]) == int(client_tokens[i]):
         continue
       return int(latest_tokens[i]) > int(client_tokens[i])
     return False
 
-  def UnpackImage(self, image_path, image_file, stateful_file, kernel_file, rootfs_file):
+  def UnpackImage(self, image_path, image_file, stateful_file,
+                  kernel_file, rootfs_file):
     unpack_command = 'cd %s && ./unpack_partitions.sh %s' % \
         (image_path, image_file)
     if os.system(unpack_command) == 0:
       shutil.move(os.path.join(image_path, 'part_1'), stateful_file)
       shutil.move(os.path.join(image_path, 'part_2'), kernel_file)
       shutil.move(os.path.join(image_path, 'part_3'), rootfs_file)
       os.system('cd %s && rm part_*' % image_path)
       return True
     return False
 
   def UnpackZip(self, image_path, image_file):
-    return os.system('cd %s && unzip -o image.zip %s unpack_partitions.sh' % \
-                     (image_path, image_file)) == 0
+    image = os.path.join(image_path, image_file)
+    if os.path.exists(image):
+      return True
+    else:
+      return os.system('cd %s && unzip -o image.zip %s unpack_partitions.sh' %
+                       (image_path, image_file)) == 0
 
   def GetImageBinPath(self, image_path):
     if self.test_image:
       image_file = 'chromiumos_test_image.bin'
     else:
       image_file = 'chromiumos_image.bin'
     return image_file
 
   def BuildUpdateImage(self, image_path):
     stateful_file = '%s/stateful.image' % image_path
     kernel_file = '%s/kernel.image' % image_path
     rootfs_file = '%s/rootfs.image' % image_path
 
     image_file = self.GetImageBinPath(image_path)
     bin_path = os.path.join(image_path, image_file)
 
     # Get appropriate update.gz to compare timestamps.
     if self.serve_only:
       cached_update_file = os.path.join(image_path, 'update.gz')
     else:
       cached_update_file = os.path.join(self.static_dir, 'update.gz')
 
-    # Check whether we need to re-create if the original image is newer.
+    # If the rootfs image is newer, re-create everything.
     if (os.path.exists(cached_update_file) and
         os.path.getmtime(cached_update_file) >= os.path.getmtime(bin_path)):
       web.debug('Using cached update image at %s instead of %s' %
                 (cached_update_file, bin_path))
     else:
       # Unpack zip file if we are serving from a directory.
       if self.serve_only and not self.UnpackZip(image_path, image_file):
         web.debug('unzip image.zip failed.')
         return False
 
       if not self.UnpackImage(image_path, image_file, stateful_file,
                               kernel_file, rootfs_file):
         web.debug('Failed to unpack image.')
         return False
 
       update_file = os.path.join(image_path, 'update.gz')
       web.debug('Generating update image %s' % update_file)
       mkupdate_command = '%s/mk_memento_images.sh %s %s' % \
                           (self.scripts_dir, kernel_file, rootfs_file)
       if os.system(mkupdate_command) != 0:
         web.debug('Failed to create update image')
         return False
 
-      mkstatefulupdate_command = 'gzip %s' % stateful_file
+      mkstatefulupdate_command = 'gzip -f %s' % stateful_file
       if os.system(mkstatefulupdate_command) != 0:
         web.debug('Failed to create stateful update image')
         return False
 
       # Add gz suffix
       stateful_file = '%s.gz' % stateful_file
 
       # Cleanup of image files
       os.remove(kernel_file)
       os.remove(rootfs_file)
@@ skipping 162 matching lines @@
       ok = self.BuildUpdateImage(latest_image_path)
       if ok != True:
         web.debug('Failed to build an update image')
         return self.GetNoUpdatePayload()
 
       hash = self.GetHash('%s/update.gz' % self.static_dir)
       size = self.GetSize('%s/update.gz' % self.static_dir)
 
       url = 'http://%s/static/update.gz' % hostname
       return self.GetUpdatePayload(hash, size, url)