Use new stateful image builder

bin/cros_image_to_target.py

 #!/usr/bin/python
 #
 # Copyright (c) 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.
 
 """Create and copy update image to target host.
 
 auto-update and devserver change out from beneath us often enough
 that despite having to duplicate a litte code, it seems that the
@@ skipping 15 matching lines @@
 import traceback
 
 from xml.dom import minidom
 
 
 # This is the default filename within the image directory to load updates from
 DEFAULT_IMAGE_NAME = 'chromiumos_image.bin'
 
 # The filenames we provide to clients to pull updates
 UPDATE_FILENAME = 'update.gz'
-STATEFUL_FILENAME = 'stateful.image.gz'
+STATEFUL_FILENAME = 'stateful.tgz'
 
 # How long do we wait for the server to start before launching client
 SERVER_STARTUP_WAIT = 1
 
 
 class Command(object):
   """Shell command ease-ups for Python."""
 
   def __init__(self, env):
     self.env = env
@@ skipping 138 matching lines @@
       return True
 
     if not self.cmd.Run(self.CrosUtilsPath('cros_generate_update_payload'),
                         '--image=%s' % src, '--output=%s' % dst,
                         '--patch_kernel'):
       self.Error('generate_payload failed')
       return False
 
     return True
 
-  def BuildStateful(self, src, dst):
+  def BuildStateful(self, src, dst_dir, dst_file):
     """Create a stateful partition update image."""
 
-    if self.GetCached(src, dst):
-      self.Info('Using cached stateful %s' % dst)
+    if self.GetCached(src, dst_file):
+      self.Info('Using cached stateful %s' % dst_file)
       return True
 
-    cgpt = self.ChrootPath('/usr/bin/cgpt')
-    offset = self.cmd.OutputOneLine(cgpt, 'show', '-b', '-i', '1', src)
-    size = self.cmd.OutputOneLine(cgpt, 'show', '-s', '-i', '1', src)
-    if None in (size, offset):
-      self.Error('Unable to use cgpt to get image geometry')
-      return False
-
-    return self.cmd.RunPipe([['dd', 'if=%s' % src, 'bs=512',
-                              'skip=%s' % offset, 'count=%s' % size],
-                             ['gzip', '-c']], outfile=dst)
+    return self.cmd.Run(self.CrosUtilsPath(
+        'cros_generate_stateful_update_payload'),
+        '--image=%s' % src, '--output=%s' % dst_dir)
 
   def GetSize(self, filename):
     return os.path.getsize(filename)
 
   def GetHash(self, filename):
     return self.cmd.RunPipe([['openssl', 'sha1', '-binary'],
                              ['openssl', 'base64']],
                             infile=filename,
                             capture=True, oneline=True)
 
@@ skipping 385 matching lines @@
       cros_env.Fatal()
 
   elif not options.server_only:
     parser.error('Either --server-only must be specified or '
                  '--remote=<client> needs to be given')
 
   update_file = os.path.join(image_directory, UPDATE_FILENAME)
   stateful_file = os.path.join(image_directory, STATEFUL_FILENAME)
 
   if (not cros_env.GenerateUpdatePayload(image_file, update_file) or
-      not cros_env.BuildStateful(image_file, stateful_file)):
+      not cros_env.BuildStateful(image_file, image_directory, stateful_file)):
     cros_env.Fatal()
 
   cros_env.CreateServer(options.port, update_file, stateful_file)
 
   exit_status = 1
   if options.server_only:
     child = None
   else:
     # Start an "image-to-live" instance that will pull bits from the server
     child = os.fork()
@@ skipping 29 matching lines @@
 
   if child:
     os.kill(child, 15)
 
   cros_env.Info('Server exiting with status %d' % exit_status)
   sys.exit(exit_status)
 
 
 if __name__ == '__main__':
   main(sys.argv)