Bot update!

scripts/slave/chromium_commands.py

 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """A subclass of commands.SVN that allows more flexible error recovery.
 
 This code is only used on the slave but it is living in common/ because it is
 directly imported from buildbot/slave/bot.py."""
 
 import os
@@ skipping 251 matching lines @@
     self.gclient_deps = args.get('gclient_deps')
     self.sourcedata = '%s\n' % self.svnurl
     self.rm_timeout = args.get('rm_timeout', self.timeout)
     self.env = args.get('env')
     self.gclient_nohooks = args.get('gclient_nohooks', False)
     self.env['CHROMIUM_GYP_SYNTAX_CHECK'] = '1'
     self.no_gclient_branch = args.get('no_gclient_branch')
     self.no_gclient_revision = args.get('no_gclient_revision', False)
     self.gclient_transitive = args.get('gclient_transitive')
     self.gclient_jobs = args.get('gclient_jobs')
+    self.do_nothing = False
 
   def start(self):
     """Start the update process.
 
     start() is cut-and-paste from the base class, the block calling
     self.sourcedirIsPatched() and the revert support is the only functional
     difference from base."""
     self.sendStatus({'header': "starting " + self.header + "\n"})
     self.command = None
 
     # self.srcdir is where the VC system should put the sources
     if self.mode == "copy":
       self.srcdir = "source" # hardwired directory name, sorry
     else:
       self.srcdir = self.workdir
     self.sourcedatafile = os.path.join(self.builder.basedir,
                                        self.srcdir,
                                        ".buildbot-sourcedata")
+    self.do_nothing = os.path.isfile(os.path.join(self.builder.basedir,
+                                                  self.srcdir,
+                                                  'update.flag'))
 
-    d = defer.succeed(None)
+    d = defer.succeed(0)
+
+    if self.do_nothing:
+      # If bot update is run, we don't need to run the traditional update step.
+      self.sendStatus({'header': 'Found flag file, see "bot update" step, '
+                                 'exiting\n'})

[agable, 2014/02/07 04:47:40]

This message should match the messages in the other two scripts.

[Ryan Tseng, 2014/02/07 21:23:07]

Done.

+      d.addCallback(self._sendRC)
+      return d
+
     # Do we need to clobber anything?
     if self.mode in ("copy", "clobber", "export"):
       d.addCallback(self.doClobber, self.workdir)
     if not (self.sourcedirIsUpdateable() and self.sourcedataMatches()):
       # the directory cannot be updated, so we have to clobber it.
       # Perhaps the master just changed modes from 'export' to
       # 'update'.
       d.addCallback(self.doClobber, self.srcdir)
     elif self.sourcedirIsPatched():
       # The directory is patched. Revert the sources.
@@ skipping 34 matching lines @@
     cmd = ['python', '-c',
            'from common import chromium_utils; '
            'chromium_utils.RemoveDirectory("%s")' % rm_dir.replace('\\', '/')]
     if self.sudo_for_remove:
       cmd = ['sudo'] + cmd
     return cmd
 
   def doGclientUpdate(self):
     """Sync the client
     """
+    self.sendStatus({'header': "In Gclient Update\n"})
+    if self.do_nothing:
+      return defer.Deferred()
     dirname = os.path.join(self.builder.basedir, self.srcdir)
     command = [chromium_utils.GetGClientCommand(),
                'sync', '--verbose', '--reset', '--manually_grab_svn_rev',
                '--force', '--with_branch_heads']
     if self.delete_unversioned_trees_when_updating:
       command.append('--delete_unversioned_trees')
     if self.gclient_jobs:
       command.append('-j%d' % self.gclient_jobs)
     # Don't run hooks if it was patched or there is a patch since runhooks will
     # be run after.
@@ skipping 24 matching lines @@
     c = runprocess.RunProcess(
         self.builder, command, dirname,
         sendRC=False, timeout=self.timeout,
         keepStdout=True, environ=self.env)
     self.command = c
     return c.start()
 
   def getGclientConfigCommand(self):
     """Return the command to run the gclient config step.
     """
+    self.sendStatus({'header': "In Gclient Config\n"})
+    if self.do_nothing:
+      return defer.Deferred()
     dirname = os.path.join(self.builder.basedir, self.srcdir)
     command = [chromium_utils.GetGClientCommand(), 'config']
 
     if self.gclient_spec:
       command.append('--spec=%s' % self.gclient_spec)
     else:
       command.append(self.svnurl)
 
     git_cache_dir = os.path.abspath(
         os.path.join(self.builder.basedir, os.pardir, os.pardir, os.pardir,
                      'git_cache'))
     command.append('--cache-dir=' + git_cache_dir)
     c = runprocess.RunProcess(
         self.builder, command, dirname,
         sendRC=False, timeout=self.timeout,
         keepStdout=True, environ=self.env)
     return c
 
   def doVCUpdate(self):
     """Sync the client
     """
+    self.sendStatus({'header': "In VC Update\n"})

[agable, 2014/02/07 04:47:40]

Not sure why you introduced these sendStatus calls. They're not consistent (e.g.
with doClobber) and not directly related to this change afaict. Leave them out.

[Ryan Tseng, 2014/02/07 21:23:07]

Oh weird I totally thought i took these out, fixed

+    if self.do_nothing:
+      return defer.Deferred()
     # Make sure the .gclient is updated.
     os.remove(os.path.join(self.builder.basedir, self.srcdir, '.gclient'))
     c = self.getGclientConfigCommand()
     self.command = c
     d = c.start()
     d.addCallback(self._abandonOnFailure)
     d.addCallback(lambda _: self.doGclientUpdate())
     return d
 
   def doVCFull(self):
     """Setup the .gclient file and then sync
     """
+    self.sendStatus({'header': "In VC Full\n"})
+    if self.do_nothing:
+      return defer.Deferred()
     chromium_utils.MaybeMakeDirectory(self.builder.basedir, self.srcdir)
 
     c = self.getGclientConfigCommand()
     self.command = c
     d = c.start()
     d.addCallback(self._abandonOnFailure)
     d.addCallback(lambda _: self.doGclientUpdate())
     return d
 
   def doClobber(self, dummy, dirname, _=False):
     """Move the old directory aside, or delete it if that's already been done.
 
     This function is designed to be used with a source dir.  If it's called
     with anything else, the caller will need to be sure to clean up the
     <dirname>.dead directory once it's no longer needed.
 
     If this is the first time we're clobbering since we last finished a
     successful update or checkout, move the old directory aside so a human
     can try to recover from it if desired.  Otherwise -- if such a backup
     directory already exists, because this isn't the first retry -- just
     remove the old directory.
 
     Args:
       dummy: unused
       dirname: the directory within self.builder.basedir to be clobbered
     """
+    if self.do_nothing:
+      return defer.Deferred()
     old_dir = os.path.join(self.builder.basedir, dirname)
     dead_dir = old_dir + '.dead'
     if os.path.isdir(old_dir):
       if os.path.isdir(dead_dir):
         command = self._RemoveDirectoryCommand(old_dir)
       else:
         command = _RenameDirectoryCommand(old_dir, dead_dir)
       c = runprocess.RunProcess(
           self.builder, command, self.builder.basedir,
           sendRC=0, timeout=self.rm_timeout,
           environ=self.env)
       self.command = c
       # See commands.SVN.doClobber for notes about sendRC.
       d = c.start()
       d.addCallback(self._abandonOnFailure)
       return d
     return None
 
   def doRevert(self, dummy):
     """Revert any modification done by a previous patch.
 
     This is done in 2 parts to trap potential errors at each step. Note that
     it is assumed that .orig and .rej files will be reverted, e.g. deleted by
     the 'gclient revert' command. If the try bot is configured with
     'global-ignores=*.orig', patch failure will occur."""
+    if self.do_nothing:
+      return defer.Deferred()
     dirname = os.path.join(self.builder.basedir, self.srcdir)
     command = [chromium_utils.GetGClientCommand(), 'revert', '--nohooks']
     c = runprocess.RunProcess(
         self.builder, command, dirname,
         sendRC=False, timeout=self.timeout,
         keepStdout=True, environ=self.env)
     self.command = c
     d = c.start()
     d.addCallback(self._abandonOnFailure)
     # Remove patch residues.
@@ skipping 11 matching lines @@
     c = runprocess.RunProcess(
         self.builder, command, dirname,
         sendRC=False, timeout=self.timeout,
         keepStdout=True, environ=self.env)
     self.command = c
     d = c.start()
     d.addCallback(self._abandonOnFailure)
     return d
 
   def doPatch(self, res):
+    if self.do_nothing:
+      return defer.Deferred()
     patchlevel = self.patch[0]
     diff = FixDiffLineEnding(self.patch[1])
 
     # Allow overwriting the root with an environment variable.
     root = self.env.get("GCLIENT_PATCH_ROOT", None)
 
     if len(self.patch) >= 3 and root is None:
       root = self.patch[2]
     command = [
         self.getCommand("patch"),
@@ skipping 20 matching lines @@
         initialStdin=diff, environ=self.env)
     self.command = c
     d = c.start()
     d.addCallback(self._abandonOnFailure)
     if diff.find('DEPS') != -1:
       d.addCallback(self.doVCUpdateOnPatch)
       d.addCallback(self._abandonOnFailure)
     return d
 
   def doVCUpdateOnPatch(self, res):
+    if self.do_nothing:
+      return defer.Deferred()
     if self.revision and not self.branch and '@' not in str(self.revision):
       self.branch = 'src'
     self.delete_unversioned_trees_when_updating = False
     return self.doVCUpdate()
 
   def doRunHooks(self, dummy):
     """Runs "gclient runhooks" after patching."""
     dirname = os.path.join(self.builder.basedir, self.srcdir)
     command = [chromium_utils.GetGClientCommand(), 'runhooks']
     c = runprocess.RunProcess(
         self.builder, command, dirname,
         sendRC=False, timeout=self.timeout,
         keepStdout=True, environ=self.env)
     self.command = c
     d = c.start()
     d.addCallback(self._abandonOnFailure)
     return d
 
   def writeSourcedata(self, res):
     """Write the sourcedata file and remove any dead source directory."""
+    if self.do_nothing:
+      return defer.Deferred()
     dead_dir = os.path.join(self.builder.basedir, self.srcdir + '.dead')
     if os.path.isdir(dead_dir):
       msg = 'Removing dead source dir'
       self.sendStatus({'header': msg + '\n'})
       log.msg(msg)
       command = self._RemoveDirectoryCommand(dead_dir)
       c = runprocess.RunProcess(
           self.builder, command, self.builder.basedir,
           sendRC=0, timeout=self.rm_timeout,
           environ=self.env)
@@ skipping 48 matching lines @@
   try:
     # We run this code in a try because it fails with an assertion if
     # the module is loaded twice.
     commandRegistry['gclient'] = 'slave.chromium_commands.GClient'
     return
   except (AssertionError, NameError):
     pass
 
 
 RegisterCommands()