Merge MVP script into cbuildbot.

buildbot/cbuildbot_stages.py

 # Copyright (c) 2011 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.
 
 """Module containing the various stages that a builder runs."""
 
 import os
 import re
 import sys
 import tempfile
 
 import chromite.buildbot.cbuildbot_commands as commands
 import chromite.lib.cros_build_lib as cros_lib
+import chromite.buildbot.manifest_version as manifest_version
 
 _FULL_BINHOST = 'FULL_BINHOST'
 PUBLIC_OVERLAY = '%(buildroot)s/src/third_party/chromiumos-overlay'
 _CROS_ARCHIVE_URL = 'CROS_ARCHIVE_URL'
 OVERLAY_LIST_CMD = '%(buildroot)s/src/platform/dev/host/cros_overlay_list'
 
 class BuilderStage():
   """Parent class for stages to be performed by a builder."""
   name_stage_re = re.compile('(\w+)Stage')
 
@@ skipping 226 matching lines @@
       self.Results.Record(self._name, e)
       raise
     else:
       self.Results.Record(self._name, self.Results.SUCCESS)
     finally:
       self._Finish()
 
 
 class SyncStage(BuilderStage):
   """Stage that performs syncing for the builder."""
+
   def _PerformStage(self):
     if self._options.clobber or not os.path.isdir(os.path.join(self._build_root,
                                                                '.repo')):
       commands.FullCheckout(self._build_root, self._options.tracking_branch,
-                            url=self._options.url)
-      self._ExtractOverlays()
+                            url=self._build_config['git_url'])
     else:
       commands.PreFlightRinse(self._build_root, self._build_config['board'],
                               self._options.tracking_branch,
                               BuilderStage.rev_overlays)
       BuilderStage.old_binhost = self._GetPortageEnvVar(_FULL_BINHOST)
       commands.IncrementalCheckout(self._build_root)
 
     # Check that all overlays can be found.
+    self._ExtractOverlays() # Our list of overlays are from pre-sync, refresh
     for path in BuilderStage.rev_overlays:
       assert os.path.isdir(path), 'Missing overlay: %s' % path
 
 
+class ManifestVersionedSyncStage(BuilderStage):
+  """Stage that generates a unique manifest file, and sync's to it."""
+
+  build_version = None
+
+  def _PerformStage(self):
+    # Need to determine branch and set a local value here
+    branch = self._options.tracking_branch.split('/')
+    increment = 'patch'
+
+    if not branch[1]:
+      branch[1] = 'master'
+      increment = 'branch' # TODO Is this right?
+
+    next_version = manifest_version.GenerateWorkload(
+       tmp_dir='/tmp/git.root',
+       source_repo=self._build_config['git_url'],
+       manifest_repo=self._build_config['manifest_version'],
+       branch=branch[1],
+       version_file='src/third_party/chromiumos-overlay/chromeos/config'
+                    '/chromeos_version.sh',
+       board=self._build_config['board'],
+       incr_type= increment,
+       debug=self._options.debug)
+
+    if not next_version:
+      print "AUTOREV: Nothing to build!"
+      sys.exit(0);
+
+    # Store off this value where the Completion stage can find it...
+    ManifestVersionedSyncStage.build_version = next_version
+
+    commands.ManifestCheckout(self._build_root,
+                              self._options.tracking_branch,
+                              next_version,
+                              url=self._build_config['manifest_version'])
+
+    # Check that all overlays can be found.
+    self._ExtractOverlays() # Our list of overlays are from pre-sync, refresh
+    for path in BuilderStage.rev_overlays:
+      assert os.path.isdir(path), 'Missing overlay: %s' % path
+
+
+class ManifestVersionedSyncCompletionStage(BuilderStage):
+  """Stage that records board specific results for a unique manifest file."""
+
+  def __init__(self, bot_id, options, build_config, success):
+    BuilderStage.__init__(self, bot_id, options, build_config)
+    self.success = success
+
+  def _PerformStage(self):
+
+    if not ManifestVersionedSyncStage.build_version:
+      # Nothing to do if ManifestVersionedSyncStage didn't complete
+      return
+
+    manifest_version.UpdateStatus(
+       tmp_dir='/tmp/git.root',
+       manifest_repo=self._build_config['manifest_version'],
+       board=self._build_config['board'],
+       build_version=ManifestVersionedSyncStage.build_version,
+       success=self.success,
+       debug=self._options.debug)
+
 class BuildBoardStage(BuilderStage):
   """Stage that is responsible for building host pkgs and setting up a board."""
   def _PerformStage(self):
     chroot_path = os.path.join(self._build_root, 'chroot')
     board_path = os.path.join(chroot_path, 'build', self._build_config['board'])
     if not os.path.isdir(chroot_path) or self._build_config['chroot_replace']:
       commands.MakeChroot(
           self._build_root, self._build_config['chroot_replace'])
 
     if not os.path.isdir(board_path):
@@ skipping 104 matching lines @@
   def _PerformStage(self):
     if self._build_type in ('preflight', 'chrome'):
       commands.UploadPrebuilts(
           self._build_root, self._build_config['board'],
           self._build_config['rev_overlays'], [BuilderStage.new_binhost],
           self._build_type, self._options.chrome_rev)
 
     commands.UprevPush(self._build_root, self._options.tracking_branch,
                        self._build_config['board'], BuilderStage.push_overlays,
                        self._options.debug)