Rename cros_update to cros_portage_upgrade and Updater -> Upgrader.

bin/cros_portage_upgrade.py

 #!/usr/bin/python2.6
 # 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.
 
 """Perform various tasks related to updating Portage packages."""
 
 import glob
 import logging
 import optparse
 import os
 import parallel_emerge
 import portage
 import re
 import shutil
 import sys
 
 sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))
 import chromite.lib.cros_build_lib as cros_lib
 
 
-class Updater(object):
+class Upgrader(object):
   """A class to perform various tasks related to updating Portage packages."""
 
   def __init__(self, options, args):
     self._options = options
     self._args = args
     self._stable_repo = os.path.join(self._options.srcroot,
                                      'third_party', 'portage-stable')
     self._upstream_repo = self._options.upstream
     if not self._upstream_repo:
       self._upstream_repo = os.path.join(self._options.srcroot,
                                          'third_party', 'portage')
 
   @staticmethod
   def _GetPreOrderDepGraphPackage(deps_graph, package, pkglist, visited):
     """Collect packages from |deps_graph| into |pkglist| in pre-order."""
     if package in visited:
       return
     visited.add(package)
     for parent in deps_graph[package]['provides']:
-      Updater._GetPreOrderDepGraphPackage(deps_graph, parent, pkglist, visited)
+      Upgrader._GetPreOrderDepGraphPackage(deps_graph, parent, pkglist, visited)
     pkglist.append(package)
 
   @staticmethod
   def _GetPreOrderDepGraph(deps_graph):
     """Return packages from |deps_graph| in pre-order."""
     pkglist = []
     visited = set()
     for package in deps_graph:
-      Updater._GetPreOrderDepGraphPackage(deps_graph, package, pkglist, visited)
+      Upgrader._GetPreOrderDepGraphPackage(deps_graph, package, pkglist,
+                                           visited)
     return pkglist
 
   @staticmethod
   def _IsStableEBuild(ebuild_path):
     """Returns true if |ebuild_path| is a stable ebuild, false otherwise."""
     with open(ebuild_path, 'r') as ebuild:
       for line in ebuild:
         if line.startswith('KEYWORDS='):
           # TODO(petkov): Support non-x86 targets.
           return re.search(r'[ "]x86[ "]', line)
@@ skipping 12 matching lines @@
     (ebuild_path, cat) = os.path.split(ebuild_path)
     (ebuild_path, overlay) = os.path.split(ebuild_path)
     return (overlay, cat, pn, pv)
 
   def _FindLatestVersion(self, cpv):
     """Returns the latest cpv in |_upstream_repo| if it's newer than |cpv|."""
     latest_cpv = cpv
     (cat, pn, version, rev) = portage.versions.catpkgsplit(cpv)
     pkgpath = os.path.join(self._upstream_repo, cat, pn)
     for ebuild_path in glob.glob(os.path.join(pkgpath, '%s*.ebuild' % pn)):
-      if not Updater._IsStableEBuild(ebuild_path): continue
+      if not Upgrader._IsStableEBuild(ebuild_path): continue
       (overlay, cat, pn, pv) = self._SplitEBuildPath(ebuild_path)
       upstream_cpv = os.path.join(cat, pv)
       if portage.versions.pkgcmp(portage.versions.pkgsplit(upstream_cpv),
                                  portage.versions.pkgsplit(latest_cpv)) > 0:
         latest_cpv = upstream_cpv
     if latest_cpv != cpv: return latest_cpv
     return None
 
   def _CopyUpstreamPackage(self, info):
     """Upgrades package described by |info| by copying from usptream.
@@ skipping 17 matching lines @@
     # Copy the whole package except the ebuilds.
     shutil.copytree(upstream_pkgdir, pkgdir,
                     ignore=shutil.ignore_patterns('*.ebuild'))
     # Copy just the ebuild that will be used in the build.
     shutil.copy2(os.path.join(upstream_pkgdir,
                               latest_cpv.split('/')[1] + '.ebuild'), pkgdir)
     self._RunGit(self._stable_repo, 'add ' + catpkgname)
     return True
 
   def _UpgradePackage(self, info):
     """Updates |info| with latest_cpv and performs an upgrade if necessary."""

[sosa, 2011/03/30 18:38:59]

Upgrade?

[petkov, 2011/03/30 18:49:48]

It does _update_ the map structure and then "_upgrade_ if necessary."

     cpv = info['cpv']
     # No need to report or try to upgrade chromeos-base packages.
     if cpv.startswith('chromeos-base/'): return
     info['latest_cpv'] = self._FindLatestVersion(cpv)
     info['upgraded'] = self._CopyUpstreamPackage(info)
-    update = ''
-    if info['latest_cpv']: update = ' -> %s' % info['latest_cpv']
+    upgrade = ''
+    if info['latest_cpv']: upgrade = ' -> %s' % info['latest_cpv']
     upgraded = ''
     if info['upgraded']: upgraded = ' (UPGRADED)'
-    print '[%s] %s%s%s' % (info['overlay'], info['cpv'], update, upgraded)
+    print '[%s] %s%s%s' % (info['overlay'], info['cpv'], upgrade, upgraded)
 
   def _UpgradePackages(self, infolist):
     """Given a list of cpv info maps, adds the latest_cpv to the infos."""
     dash_q = ''
     if not self._options.verbose: dash_q = '-q'
     try:
       # TODO(petkov): Currently portage's master branch is stale so we need to
       # checkout latest upstream. At some point portage's master branch will be
       # upstream so there will be no need to chdir/checkout. At that point we
       # can also fuse this loop into the caller and avoid generating a separate
@@ skipping 22 matching lines @@
     if not self._options.verbose:
       argv.append('--quiet')
     if self._options.rdeps:
       argv.append('--root-deps=rdeps')
     argv.extend(self._args)
 
     deps = parallel_emerge.DepGraphGenerator()
     deps.Initialize(argv)
     deps_tree, deps_info = deps.GenDependencyTree({})
     deps_graph = deps.GenDependencyGraph(deps_tree, deps_info, {})
-    return Updater._GetPreOrderDepGraph(deps_graph)
+    return Upgrader._GetPreOrderDepGraph(deps_graph)
 
   def _GetInfoListWithOverlays(self, cpvlist):
     """Returns a list of cpv/overlay info maps corresponding to |cpvlist|."""
     infolist = []
     for cpv in cpvlist:
       # TODO(petkov): Use internal portage utilities to find the overlay instead
       # of equery to improve performance, if possible.
       equery = ['equery-%s' % self._options.board, 'which', cpv]
       ebuild_path = cros_lib.RunCommand(equery, print_cmd=self._options.verbose,
                                         redirect_stdout=True).output.strip()
       (overlay, cat, pn, pv) = self._SplitEBuildPath(ebuild_path)
       infolist.append({'cpv': cpv, 'overlay': overlay})
 
     return infolist
 
   def Run(self):
-    """Runs the updater based on the supplied options and arguments.
+    """Runs the upgrader based on the supplied options and arguments.
 
     Currently just lists all package dependencies in pre-order along with
     potential upgrades."""
     cpvlist = self._GetCurrentVersions()
     infolist = self._GetInfoListWithOverlays(cpvlist)
     self._UpgradePackages(infolist)
 
 def main():
   usage = 'Usage: %prog [options] packages...'
   parser = optparse.OptionParser(usage=usage)
@@ skipping 20 matching lines @@
   if (options.verbose): logging.basicConfig(level=logging.DEBUG)
 
   if not options.board:
     parser.print_help()
     cros_lib.Die('board is required')
 
   if not args:
     parser.print_help()
     cros_lib.Die('no packages provided')
 
-  updater = Updater(options, args)
-  updater.Run()
+  upgrader = Upgrader(options, args)
+  upgrader.Run()
 
 
 if __name__ == '__main__':
   main()