Reduce the size of the stateful update by only copying dirs and some clean up.

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 socket
+import subprocess
+import tempfile
 import time
 
+
 def _LogMessage(message):
   cherrypy.log(message, 'UPDATE')
 
 
 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.
@@ skipping 17 matching lines @@
       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
+    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]
 
   def _GetDefaultBoardID(self):
     """Returns the default board id stored in .default_board."""
     board_file = '%s/.default_board' % (self.scripts_dir)
     try:
@@ skipping 16 matching lines @@
     client_tokens = client_version.replace('_', '').split('.')
     latest_tokens = latest_version.replace('_', '').split('.')
     _LogMessage('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 _UnpackStatefulPartition(self, image_path, stateful_file):
-    """Given an image, unpacks its stateful partition to stateful_file."""
-    image_dir = os.path.dirname(image_path)
-    image_file = os.path.basename(image_path)
-
-    get_offset = '$(cgpt show -b -i 1 %s)' % image_file
-    get_size = '$(cgpt show -s -i 1 %s)' % image_file
-    unpack_command = (
-        'cd %s && '
-        'dd if=%s of=%s bs=512 skip=%s count=%s' % (image_dir, image_file,
-                                                    stateful_file, get_offset,
-                                                    get_size))
-    _LogMessage(unpack_command)
-    return os.system(unpack_command) == 0
-
   def _UnpackZip(self, image_dir):
     """Unpacks an image.zip into a given directory."""
     image = os.path.join(image_dir, self._GetImageName())
     if os.path.exists(image):
       return True
     else:
       # -n, never clobber an existing file, in case we get invoked
       # simultaneously by multiple request handlers. This means that
       # we're assuming each image.zip file lives in a versioned
       # directory (a la Buildbot).
@@ skipping 129 matching lines @@
     return update_path
 
   def GenerateStatefulFile(self, image_path):
     """Generates a stateful update gz given a full path to an image.
 
     Args:
       image_path: Full path to image.
     Returns:
       Path to created stateful update_payload or None on error.
     """
-    stateful_partition_path = '%s/stateful.image' % os.path.dirname(image_path)
+    _LogMessage('Generating stateful update file.')
+    from_dir = os.path.dirname(image_path)
+    image = os.path.basename(image_path)
+    output_gz = os.path.join(from_dir, 'stateful.tgz')
 
-    # Unpack to get stateful partition.
-    if self._UnpackStatefulPartition(image_path, stateful_partition_path):
-      mkstatefulupdate_command = 'gzip -f %s' % stateful_partition_path
-      if os.system(mkstatefulupdate_command) == 0:
-        _LogMessage('Successfully generated %s.gz' % stateful_partition_path)
-        return '%s.gz' % stateful_partition_path
+    # Temporary directories for this function.
+    rootfs_dir = tempfile.mkdtemp(suffix='rootfs', prefix='tmp')
+    stateful_dir = tempfile.mkdtemp(suffix='stateful', prefix='tmp')
 
-    _LogMessage('Failed to create stateful update file')
-    return None
+    # Mount the image to pull out the important directories.
+    try:
+      # Only need stateful partition, but this saves us having to manage our
+      # own loopback device.
+      subprocess.check_call(['%s/mount_gpt_image.sh' % self.crosutils,
+                             '--from=%s' % from_dir,
+                             '--image=%s' % image,
+                             '--read_only',
+                             '--rootfs_mountpt=%s' % rootfs_dir,
+                             '--stateful_mountpt=%s' % stateful_dir,
+                            ])
+      _LogMessage('Tarring up /usr/local and /var!')
+      subprocess.check_call(['sudo',
+                             'tar',
+                             '-czf',
+                             output_gz,
+                             '--directory=%s' % stateful_dir,
+                             'dev_image',
+                             'var',
+                            ])
+    except:
+      _LogMessage('Failed to create stateful update file')
+      raise
+    finally:
+      # Unmount best effort regardless.
+      subprocess.call(['%s/mount_gpt_image.sh' % self.crosutils,
+                       '--unmount',
+                       '--rootfs_mountpt=%s' % rootfs_dir,
+                       '--stateful_mountpt=%s' % stateful_dir,
+                      ])
+      # Clean up our directories.
+      os.rmdir(rootfs_dir)
+      os.rmdir(stateful_dir)
+
+    _LogMessage('Successfully generated %s' % output_gz)
+    return output_gz
 
   def MoveImagesToStaticDir(self, update_path, stateful_update_path,
                             static_image_dir):
     """Moves gz files from their directories to serving directories.
 
     Args:
       update_path: full path to main update gz.
       stateful_update_path: full path to stateful partition gz.
       static_image_dir: where to put files.
     Returns:
@@ skipping 295 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()