command: filter projects by active manifest groups

`repo forall <proj>` will look up all <proj> in the manifest for all manifest groups regardless of which are active. If <proj> is checked out to different locations depending on the group, this ultimately fails as we're unable to locate all of them. Simple fix is to only include projects that match the manifest groups that we already passed down & initialized to the active set, and that we already use when getting the default project list. Bug: https://crbug.com/gerrit/11677 Bug: https://crbug.com/1011226 Change-Id: I975f10f9a9e5a1cad7d87344123f8003732dab27 Reviewed-on: https://gerrit-review.googlesource.com/c/git-repo/+/239652 Tested-by: Mike Frysinger <vapier@google.com> Reviewed-by: Raul Rangel <rrangel@chromium.org> Reviewed-by: David Pursehouse <dpursehouse@collab.net>
info: fix "current" output
2025-06-26 20:17:52 +00:00 · 2019-10-08 20:15:08 +00:00 · 2019-10-05 05:24:34 +00:00 · 2019-10-05 04:41:40 +00:00 · 2019-10-01 05:53:35 +00:00 · 2019-10-01 05:53:09 +00:00
70 changed files with 6195 additions and 2052 deletions
--- a/.flake8
+++ b/.flake8
@ -0,0 +1,3 @@
 [flake8]
 max-line-length=80
 ignore=E111,E114,E402
--- a/.gitattributes
+++ b/.gitattributes
@ -1,4 +1,4 @@
 # Prevent /bin/sh scripts from being clobbered by autocrlf=true
 git_ssh text eol=lf
 main.py text eol=lf
 repo text eol=lf
 hooks/* text eol=lf
--- a/.mailmap
+++ b/.mailmap
@ -0,0 +1,12 @@
 Anthony Newnam <anthony.newnam@garmin.com>    Anthony <anthony@bnovc.com>
 He Ping <tdihp@hotmail.com>                   heping <tdihp@hotmail.com>
 Hu Xiuyun <xiuyun.hu@hisilicon.com>           Hu xiuyun <xiuyun.hu@hisilicon.com>
 Hu Xiuyun <xiuyun.hu@hisilicon.com>           Hu Xiuyun <clouds08@qq.com>
 Jelly Chen <chenguodong@huawei.com>           chenguodong <chenguodong@huawei.com>
 Jia Bi <bijia@xiaomi.com>                     bijia <bijia@xiaomi.com>
 JoonCheol Park <jooncheol@gmail.com>          Jooncheol Park <jooncheol@gmail.com>
 Sergii Pylypenko <x.pelya.x@gmail.com>        pelya <x.pelya.x@gmail.com>
 Shawn Pearce <sop@google.com>                 Shawn O. Pearce <sop@google.com>
 Ulrik Sjölin <ulrik.sjolin@sonyericsson.com>  Ulrik Sjolin <ulrik.sjolin@gmail.com>
 Ulrik Sjölin <ulrik.sjolin@sonyericsson.com>  Ulrik Sjolin <ulrik.sjolin@sonyericsson.com>
 Ulrik Sjölin <ulrik.sjolin@sonyericsson.com>  Ulrik Sjölin <ulrik.sjolin@sonyericsson.com>
--- a/.pydevproject
+++ b/.pydevproject
@ -5,6 +5,6 @@
 <pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
 <path>/git-repo</path>
 </pydev_pathproperty>
-<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.6</pydev_property>
+<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.7</pydev_property>
 <pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>
 </pydev_project>
--- a/.pylintrc
+++ b/.pylintrc
@ -1,301 +0,0 @@
 # lint Python modules using external checkers.
 #
 # This is the main checker controling the other ones and the reports
 # generation. It is itself both a raw checker and an astng checker in order
 # to:
 # * handle message activation / deactivation at the module level
 # * handle some basic but necessary stats'data (number of classes, methods...)
 #
 [MASTER]
 # Specify a configuration file.
 #rcfile=
 # Python code to execute, usually for sys.path manipulation such as
 # pygtk.require().
 #init-hook=
 # Profiled execution.
 profile=no
 # Add <file or directory> to the black list. It should be a base name, not a
 # path. You may set this option multiple times.
 ignore=SVN
 # Pickle collected data for later comparisons.
 persistent=yes
 # Set the cache size for astng objects.
 cache-size=500
 # List of plugins (as comma separated values of python modules names) to load,
 # usually to register additional checkers.
 load-plugins=
 [MESSAGES CONTROL]
 # Enable only checker(s) with the given id(s). This option conflicts with the
 # disable-checker option
 #enable-checker=
 # Enable all checker(s) except those with the given id(s). This option
 # conflicts with the enable-checker option
 #disable-checker=
 # Enable all messages in the listed categories.
 #enable-msg-cat=
 # Disable all messages in the listed categories.
 #disable-msg-cat=
 # Enable the message(s) with the given id(s).
 enable=RP0004
 # Disable the message(s) with the given id(s).
 disable=R0903,R0912,R0913,R0914,R0915,W0141,C0111,C0103,W0603,W0703,R0911,C0301,C0302,R0902,R0904,W0142,W0212,E1101,E1103,R0201,W0201,W0122,W0232,RP0001,RP0003,RP0101,RP0002,RP0401,RP0701,RP0801,F0401,E0611,R0801,I0011
 [REPORTS]
 # set the output format. Available formats are text, parseable, colorized, msvs
 # (visual studio) and html
 output-format=text
 # Include message's id in output
 include-ids=yes
 # Put messages in a separate file for each module / package specified on the
 # command line instead of printing them on stdout. Reports (if any) will be
 # written in a file name "pylint_global.[txt|html]".
 files-output=no
 # Tells whether to display a full report or only the messages
 reports=yes
 # Python expression which should return a note less than 10 (10 is the highest
 # note).You have access to the variables errors warning, statement which
 # respectivly contain the number of errors / warnings messages and the total
 # number of statements analyzed. This is used by the global evaluation report
 # (R0004).
 evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
 # Add a comment according to your evaluation note. This is used by the global
 # evaluation report (R0004).
 comment=no
 # checks for
 # * unused variables / imports
 # * undefined variables
 # * redefinition of variable from builtins or from an outer scope
 # * use of variable before assigment
 #
 [VARIABLES]
 # Tells whether we should check for unused import in __init__ files.
 init-import=no
 # A regular expression matching names used for dummy variables (i.e. not used).
 dummy-variables-rgx=_|dummy
 # List of additional names supposed to be defined in builtins. Remember that
 # you should avoid to define new builtins when possible.
 additional-builtins=
 # try to find bugs in the code using type inference
 #
 [TYPECHECK]
 # Tells whether missing members accessed in mixin class should be ignored. A
 # mixin class is detected if its name ends with "mixin" (case insensitive).
 ignore-mixin-members=yes
 # List of classes names for which member attributes should not be checked
 # (useful for classes with attributes dynamicaly set).
 ignored-classes=SQLObject
 # When zope mode is activated, consider the acquired-members option to ignore
 # access to some undefined attributes.
 zope=no
 # List of members which are usually get through zope's acquisition mecanism and
 # so shouldn't trigger E0201 when accessed (need zope=yes to be considered).
 acquired-members=REQUEST,acl_users,aq_parent
 # checks for :
 # * doc strings
 # * modules / classes / functions / methods / arguments / variables name
 # * number of arguments, local variables, branchs, returns and statements in
 # functions, methods
 # * required module attributes
 # * dangerous default values as arguments
 # * redefinition of function / method / class
 # * uses of the global statement
 #
 [BASIC]
 # Required attributes for module, separated by a comma
 required-attributes=
 # Regular expression which should only match functions or classes name which do
 # not require a docstring
 no-docstring-rgx=_main|__.*__
 # Regular expression which should only match correct module names
 module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
 # Regular expression which should only match correct module level names
 const-rgx=(([A-Z_][A-Z1-9_]*)|(__.*__))|(log)$
 # Regular expression which should only match correct class names
 class-rgx=[A-Z_][a-zA-Z0-9]+$
 # Regular expression which should only match correct function names
 function-rgx=[a-z_][a-z0-9_]{2,30}$
 # Regular expression which should only match correct method names
 method-rgx=[a-z_][a-z0-9_]{2,30}$
 # Regular expression which should only match correct instance attribute names
 attr-rgx=[a-z_][a-z0-9_]{2,30}$
 # Regular expression which should only match correct argument names
 argument-rgx=[a-z_][a-z0-9_]{2,30}$
 # Regular expression which should only match correct variable names
 variable-rgx=[a-z_][a-z0-9_]{2,30}$
 # Regular expression which should only match correct list comprehension /
 # generator expression variable names
 inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$
 # Good variable names which should always be accepted, separated by a comma
 good-names=i,j,k,ex,Run,_,e,d1,d2,v,f,l,d
 # Bad variable names which should always be refused, separated by a comma
 bad-names=foo,bar,baz,toto,tutu,tata
 # List of builtins function names that should not be used, separated by a comma
 bad-functions=map,filter,apply,input
 # checks for sign of poor/misdesign:
 # * number of methods, attributes, local variables...
 # * size, complexity of functions, methods
 #
 [DESIGN]
 # Maximum number of arguments for function / method
 max-args=5
 # Maximum number of locals for function / method body
 max-locals=15
 # Maximum number of return / yield for function / method body
 max-returns=6
 # Maximum number of branch for function / method body
 max-branchs=12
 # Maximum number of statements in function / method body
 max-statements=50
 # Maximum number of parents for a class (see R0901).
 max-parents=7
 # Maximum number of attributes for a class (see R0902).
 max-attributes=20
 # Minimum number of public methods for a class (see R0903).
 min-public-methods=2
 # Maximum number of public methods for a class (see R0904).
 max-public-methods=30
 # checks for
 # * external modules dependencies
 # * relative / wildcard imports
 # * cyclic imports
 # * uses of deprecated modules
 #
 [IMPORTS]
 # Deprecated modules which should not be used, separated by a comma
 deprecated-modules=regsub,string,TERMIOS,Bastion,rexec
 # Create a graph of every (i.e. internal and external) dependencies in the
 # given file (report R0402 must not be disabled)
 import-graph=
 # Create a graph of external dependencies in the given file (report R0402 must
 # not be disabled)
 ext-import-graph=
 # Create a graph of internal dependencies in the given file (report R0402 must
 # not be disabled)
 int-import-graph=
 # checks for :
 # * methods without self as first argument
 # * overridden methods signature
 # * access only to existant members via self
 # * attributes not defined in the __init__ method
 # * supported interfaces implementation
 # * unreachable code
 #
 [CLASSES]
 # List of interface methods to ignore, separated by a comma. This is used for
 # instance to not check methods defines in Zope's Interface base class.
 ignore-iface-methods=isImplementedBy,deferred,extends,names,namesAndDescriptions,queryDescriptionFor,getBases,getDescriptionFor,getDoc,getName,getTaggedValue,getTaggedValueTags,isEqualOrExtendedBy,setTaggedValue,isImplementedByInstancesOf,adaptWith,is_implemented_by
 # List of method names used to declare (i.e. assign) instance attributes.
 defining-attr-methods=__init__,__new__,setUp
 # checks for similarities and duplicated code. This computation may be
 # memory / CPU intensive, so you should disable it if you experiments some
 # problems.
 #
 [SIMILARITIES]
 # Minimum lines number of a similarity.
 min-similarity-lines=4
 # Ignore comments when computing similarities.
 ignore-comments=yes
 # Ignore docstrings when computing similarities.
 ignore-docstrings=yes
 # checks for:
 # * warning notes in the code like FIXME, XXX
 # * PEP 263: source code with non ascii character but no encoding declaration
 #
 [MISCELLANEOUS]
 # List of note tags to take in consideration, separated by a comma.
 notes=FIXME,XXX,TODO
 # checks for :
 # * unauthorized constructions
 # * strict indentation
 # * line length
 # * use of <> instead of !=
 #
 [FORMAT]
 # Maximum number of characters on a single line.
 max-line-length=80
 # Maximum number of lines in a module
 max-module-lines=1000
 # String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
 # tab).  In repo it is 2 spaces.
 indent-string='  '
--- a/README.md
+++ b/README.md
@ -0,0 +1,16 @@
 # repo
 Repo is a tool built on top of Git.  Repo helps manage many Git repositories,
 does the uploads to revision control systems, and automates parts of the
 development workflow.  Repo is not meant to replace Git, only to make it
 easier to work with Git.  The repo command is an executable Python script
 that you can put anywhere in your path.
 * Homepage: https://gerrit.googlesource.com/git-repo/
 * Bug reports: https://bugs.chromium.org/p/gerrit/issues/list?q=component:repo
 * Source: https://gerrit.googlesource.com/git-repo/
 * Overview: https://source.android.com/source/developing.html
 * Docs: https://source.android.com/source/using-repo.html
 * [repo Manifest Format](./docs/manifest-format.md)
 * [repo Hooks](./docs/repo-hooks.md)
 * [Submitting patches](./SUBMITTING_PATCHES.md)
--- a/87
+++ b/87
@ -1,87 +0,0 @@
 Short Version:
 - Make small logical changes.
 - Provide a meaningful commit message.
 - Check for coding errors with pylint
 - Make sure all code is under the Apache License, 2.0.
 - Publish your changes for review:
   git push https://gerrit-review.googlesource.com/git-repo HEAD:refs/for/master
 Long Version:
 I wanted a file describing how to submit patches for repo,
 so I started with the one found in the core Git distribution
 (Documentation/SubmittingPatches), which itself was based on the
 patch submission guidelines for the Linux kernel.
 However there are some differences, so please review and familiarize
 yourself with the following relevant bits:
 (1) Make separate commits for logically separate changes.
 Unless your patch is really trivial, you should not be sending
 out a patch that was generated between your working tree and your
 commit head.  Instead, always make a commit with complete commit
 message and generate a series of patches from your repository.
 It is a good discipline.
 Describe the technical detail of the change(s).
 If your description starts to get too long, that's a sign that you
 probably need to split up your commit to finer grained pieces.
 (2) Check for coding errors with pylint
 Run pylint on changed modules using the provided configuration:
  pylint --rcfile=.pylintrc file.py
 (3) Check the license
 repo is licensed under the Apache License, 2.0.
 Because of this licensing model *every* file within the project
 *must* list the license that covers it in the header of the file.
 Any new contributions to an existing file *must* be submitted under
 the current license of that file.  Any new files *must* clearly
 indicate which license they are provided under in the file header.
 Please verify that you are legally allowed and willing to submit your
 changes under the license covering each file *prior* to submitting
 your patch.  It is virtually impossible to remove a patch once it
 has been applied and pushed out.
 (4) Sending your patches.
 Do not email your patches to anyone.
 Instead, login to the Gerrit Code Review tool at:
  https://gerrit-review.googlesource.com/
 Ensure you have completed one of the necessary contributor
 agreements, providing documentation to the project maintainers that
 they have right to redistribute your work under the Apache License:
  https://gerrit-review.googlesource.com/#/settings/agreements
 Ensure you have obtained an HTTP password to authenticate:
  https://gerrit-review.googlesource.com/new-password
 Push your patches over HTTPS to the review server, possibly through
 a remembered remote to make this easier in the future:
   git config remote.review.url https://gerrit-review.googlesource.com/git-repo
   git config remote.review.push HEAD:refs/for/master
   git push review
 You will be automatically emailed a copy of your commits, and any
 comments made by the project maintainers.
--- a/SUBMITTING_PATCHES.md
+++ b/SUBMITTING_PATCHES.md
@ -0,0 +1,149 @@
 [TOC]
 # Short Version
 - Make small logical changes.
 - Provide a meaningful commit message.
 - Check for coding errors and style nits with pyflakes and flake8
 - Make sure all code is under the Apache License, 2.0.
 - Publish your changes for review.
 - Make corrections if requested.
 - Verify your changes on gerrit so they can be submitted.
   `git push https://gerrit-review.googlesource.com/git-repo HEAD:refs/for/master`
 # Long Version
 I wanted a file describing how to submit patches for repo,
 so I started with the one found in the core Git distribution
 (Documentation/SubmittingPatches), which itself was based on the
 patch submission guidelines for the Linux kernel.
 However there are some differences, so please review and familiarize
 yourself with the following relevant bits.
 ## Make separate commits for logically separate changes.
 Unless your patch is really trivial, you should not be sending
 out a patch that was generated between your working tree and your
 commit head.  Instead, always make a commit with complete commit
 message and generate a series of patches from your repository.
 It is a good discipline.
 Describe the technical detail of the change(s).
 If your description starts to get too long, that's a sign that you
 probably need to split up your commit to finer grained pieces.
 ## Check for coding errors and style nits with pyflakes and flake8
 ### Coding errors
 Run `pyflakes` on changed modules:
    pyflakes file.py
 Ideally there should be no new errors or warnings introduced.
 ### Style violations
 Run `flake8` on changes modules:
    flake8 file.py
 Note that repo generally follows [Google's python style guide] rather than
 [PEP 8], so it's possible that the output of `flake8` will be quite noisy.
 It's not mandatory to avoid all warnings, but at least the maximum line
 length should be followed.
 If there are many occurrences of the same warning that cannot be
 avoided without going against the Google style guide, these may be
 suppressed in the included `.flake8` file.
 [Google's python style guide]: https://google.github.io/styleguide/pyguide.html
 [PEP 8]: https://www.python.org/dev/peps/pep-0008/
 ## Running tests
 There is a [`./run_tests`](./run_tests) helper script for quickly invoking all
 of our unittests.  The coverage isn't great currently, but it should still be
 run for all commits.
 Adding more unittests for changes you make would be greatly appreciated :).
 Check out the [tests/](./tests/) subdirectory for more details.
 ## Check the license
 repo is licensed under the Apache License, 2.0.
 Because of this licensing model *every* file within the project
 *must* list the license that covers it in the header of the file.
 Any new contributions to an existing file *must* be submitted under
 the current license of that file.  Any new files *must* clearly
 indicate which license they are provided under in the file header.
 Please verify that you are legally allowed and willing to submit your
 changes under the license covering each file *prior* to submitting
 your patch.  It is virtually impossible to remove a patch once it
 has been applied and pushed out.
 ## Sending your patches.
 Do not email your patches to anyone.
 Instead, login to the Gerrit Code Review tool at:
  https://gerrit-review.googlesource.com/
 Ensure you have completed one of the necessary contributor
 agreements, providing documentation to the project maintainers that
 they have right to redistribute your work under the Apache License:
  https://gerrit-review.googlesource.com/#/settings/agreements
 Ensure you have obtained an HTTP password to authenticate:
  https://gerrit-review.googlesource.com/new-password
 Ensure that you have the local commit hook installed to automatically
 add a ChangeId to your commits:
    curl -Lo `git rev-parse --git-dir`/hooks/commit-msg https://gerrit-review.googlesource.com/tools/hooks/commit-msg
    chmod +x `git rev-parse --git-dir`/hooks/commit-msg
 If you have already committed your changes you will need to amend the commit
 to get the ChangeId added.
    git commit --amend
 Push your patches over HTTPS to the review server, possibly through
 a remembered remote to make this easier in the future:
    git config remote.review.url https://gerrit-review.googlesource.com/git-repo
    git config remote.review.push HEAD:refs/for/master
    git push review
 You will be automatically emailed a copy of your commits, and any
 comments made by the project maintainers.
 ## Make changes if requested
 The project maintainer who reviews your changes might request changes to your
 commit. If you make the requested changes you will need to amend your commit
 and push it to the review server again.
 ## Verify your changes on gerrit
 After you receive a Code-Review+2 from the maintainer, select the Verified
 button on the gerrit page for the change. This verifies that you have tested
 your changes and notifies the maintainer that they are ready to be submitted.
 The maintainer will then submit your changes to the repository.
--- a/color.py
+++ b/color.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -18,41 +19,43 @@ import sys
 import pager
-COLORS = {None     :-1,
+COLORS = {None: -1,
-          'normal' :-1,
+          'normal': -1,
-          'black'  : 0,
+          'black': 0,
-          'red'    : 1,
+          'red': 1,
-          'green'  : 2,
+          'green': 2,
-          'yellow' : 3,
+          'yellow': 3,
-          'blue'   : 4,
+          'blue': 4,
          'magenta': 5,
-          'cyan'   : 6,
+          'cyan': 6,
-          'white'  : 7}
+          'white': 7}
-ATTRS = {None     :-1,
+ATTRS = {None: -1,
-         'bold'   : 1,
+         'bold': 1,
-         'dim'    : 2,
+         'dim': 2,
-         'ul'     : 4,
+         'ul': 4,
-         'blink'  : 5,
+         'blink': 5,
         'reverse': 7}
-RESET = "\033[m"  # pylint: disable=W1401
+RESET = "\033[m"
-                  # backslash is not anomalous
+
 def is_color(s):
  return s in COLORS
 def is_attr(s):
  return s in ATTRS
-def _Color(fg = None, bg = None, attr = None):
+
 def _Color(fg=None, bg=None, attr=None):
  fg = COLORS[fg]
  bg = COLORS[bg]
  attr = ATTRS[attr]
  if attr >= 0 or fg >= 0 or bg >= 0:
    need_sep = False
-    code = "\033["  #pylint: disable=W1401
+    code = "\033["
    if attr >= 0:
      code += chr(ord('0') + attr)
@ -71,7 +74,6 @@ def _Color(fg = None, bg = None, attr = None):
    if bg >= 0:
      if need_sep:
        code += ';'
      need_sep = True
      if bg < 8:
        code += '4%c' % (ord('0') + bg)
@ -82,6 +84,27 @@ def _Color(fg = None, bg = None, attr = None):
    code = ''
  return code
 DEFAULT = None
 def SetDefaultColoring(state):
  """Set coloring behavior to |state|.
  This is useful for overriding config options via the command line.
  """
  if state is None:
    # Leave it alone -- return quick!
    return
  global DEFAULT
  state = state.lower()
  if state in ('auto',):
    DEFAULT = state
  elif state in ('always', 'yes', 'true', True):
    DEFAULT = 'always'
  elif state in ('never', 'no', 'false', False):
    DEFAULT = 'never'
 class Coloring(object):
  def __init__(self, config, section_type):
@ -89,6 +112,8 @@ class Coloring(object):
    self._config = config
    self._out = sys.stdout
    on = DEFAULT
    if on is None:
      on = self._config.GetString(self._section)
      if on is None:
        on = self._config.GetString('color.ui')
@ -122,6 +147,7 @@ class Coloring(object):
  def printer(self, opt=None, fg=None, bg=None, attr=None):
    s = self
    c = self.colorer(opt, fg, bg, attr)
    def f(fmt, *args):
      s._out.write(c(fmt, *args))
    return f
@ -129,6 +155,7 @@ class Coloring(object):
  def nofmt_printer(self, opt=None, fg=None, bg=None, attr=None):
    s = self
    c = self.nofmt_colorer(opt, fg, bg, attr)
    def f(fmt):
      s._out.write(c(fmt))
    return f
@ -136,11 +163,13 @@ class Coloring(object):
  def colorer(self, opt=None, fg=None, bg=None, attr=None):
    if self._on:
      c = self._parse(opt, fg, bg, attr)
      def f(fmt, *args):
        output = fmt % args
        return ''.join([c, output, RESET])
      return f
    else:
      def f(fmt, *args):
        return fmt % args
      return f
@ -148,6 +177,7 @@ class Coloring(object):
  def nofmt_colorer(self, opt=None, fg=None, bg=None, attr=None):
    if self._on:
      c = self._parse(opt, fg, bg, attr)
      def f(fmt):
        return ''.join([c, fmt, RESET])
      return f
--- a/command.py
+++ b/command.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -19,6 +20,7 @@ import platform
 import re
 import sys
 from event_log import EventLog
 from error import NoSuchProjectError
 from error import InvalidProjectGroupsError
@ -28,10 +30,11 @@ class Command(object):
  """
  common = False
  event_log = EventLog()
  manifest = None
  _optparse = None
-  def WantPager(self, opt):
+  def WantPager(self, _opt):
    return False
  def ReadEnvironmentOptions(self, opts):
@ -63,7 +66,7 @@ class Command(object):
        usage = self.helpUsage.strip().replace('%prog', me)
      except AttributeError:
        usage = 'repo %s' % self.NAME
-      self._optparse = optparse.OptionParser(usage = usage)
+      self._optparse = optparse.OptionParser(usage=usage)
      self._Options(self._optparse)
    return self._optparse
@ -95,6 +98,16 @@ class Command(object):
    self.OptionParser.print_usage()
    sys.exit(1)
  def ValidateOptions(self, opt, args):
    """Validate the user options & arguments before executing.
    This is meant to help break the code up into logical steps.  Some tips:
    * Use self.OptionParser.error to display CLI related errors.
    * Adjust opt member defaults as makes sense.
    * Adjust the args list, but do so inplace so the caller sees updates.
    * Try to avoid updating self state.  Leave that to Execute.
    """
  def Execute(self, opt, args):
    """Perform the action, after option parsing is complete.
    """
@ -106,19 +119,24 @@ class Command(object):
  def _UpdatePathToProjectMap(self, project):
    self._by_path[project.worktree] = project
-  def _GetProjectByPath(self, path):
+  def _GetProjectByPath(self, manifest, path):
    project = None
    if os.path.exists(path):
      oldpath = None
-      while path \
+      while path and \
-        and path != oldpath \
+            path != oldpath and \
-        and path != self.manifest.topdir:
+            path != manifest.topdir:
        try:
          project = self._by_path[path]
          break
        except KeyError:
          oldpath = path
          path = os.path.dirname(path)
      if not project and path == manifest.topdir:
        try:
          project = self._by_path[path]
        except KeyError:
          pass
    else:
      try:
        project = self._by_path[path]
@ -126,14 +144,18 @@ class Command(object):
        pass
    return project
-  def GetProjects(self, args, missing_ok=False, submodules_ok=False):
+  def GetProjects(self, args, manifest=None, groups='', missing_ok=False,
                  submodules_ok=False):
    """A list of projects that match the arguments.
    """
-    all_projects_list = self.manifest.projects
+    if not manifest:
      manifest = self.manifest
    all_projects_list = manifest.projects
    result = []
-    mp = self.manifest.manifestProject
+    mp = manifest.manifestProject
    if not groups:
      groups = mp.config.GetString('manifest.groups')
    if not groups:
      groups = 'default,platform-' + platform.system().lower()
@ -147,29 +169,31 @@ class Command(object):
                                  for p in project.GetDerivedSubprojects())
      all_projects_list.extend(derived_projects.values())
      for project in all_projects_list:
-        if ((missing_ok or project.Exists) and
+        if (missing_ok or project.Exists) and project.MatchesGroups(groups):
            project.MatchesGroups(groups)):
          result.append(project)
    else:
      self._ResetPathToProjectMap(all_projects_list)
      for arg in args:
-        projects = self.manifest.GetProjectsWithName(arg)
+        # We have to filter by manifest groups in case the requested project is
        # checked out multiple times or differently based on them.
        projects = [project for project in manifest.GetProjectsWithName(arg)
                    if project.MatchesGroups(groups)]
        if not projects:
          path = os.path.abspath(arg).replace('\\', '/')
-          project = self._GetProjectByPath(path)
+          project = self._GetProjectByPath(manifest, path)
          # If it's not a derived project, update path->project mapping and
          # search again, as arg might actually point to a derived subproject.
-          if (project and not project.Derived and
+          if (project and not project.Derived and (submodules_ok or
-              (submodules_ok or project.sync_s)):
+                                                   project.sync_s)):
            search_again = False
            for subproject in project.GetDerivedSubprojects():
              self._UpdatePathToProjectMap(subproject)
              search_again = True
            if search_again:
-              project = self._GetProjectByPath(path) or project
+              project = self._GetProjectByPath(manifest, path) or project
          if project:
            projects = [project]
@ -179,7 +203,7 @@ class Command(object):
        for project in projects:
          if not missing_ok and not project.Exists:
-            raise NoSuchProjectError(arg)
+            raise NoSuchProjectError('%s (%s)' % (arg, project.relpath))
          if not project.MatchesGroups(groups):
            raise InvalidProjectGroupsError(arg)
@ -190,39 +214,53 @@ class Command(object):
    result.sort(key=_getpath)
    return result
-  def FindProjects(self, args):
+  def FindProjects(self, args, inverse=False):
    result = []
    patterns = [re.compile(r'%s' % a, re.IGNORECASE) for a in args]
    for project in self.GetProjects(''):
      for pattern in patterns:
-        if pattern.search(project.name) or pattern.search(project.relpath):
+        match = pattern.search(project.name) or pattern.search(project.relpath)
        if not inverse and match:
          result.append(project)
          break
        if inverse and match:
          break
      else:
        if inverse:
          result.append(project)
    result.sort(key=lambda project: project.relpath)
    return result
-# pylint: disable=W0223
+
 # Pylint warns that the `InteractiveCommand` and `PagedCommand` classes do not
 # override method `Execute` which is abstract in `Command`.  Since that method
 # is always implemented in classes derived from `InteractiveCommand` and
 # `PagedCommand`, this warning can be suppressed.
 class InteractiveCommand(Command):
  """Command which requires user interaction on the tty and
     must not run within a pager, even if the user asks to.
  """
-  def WantPager(self, opt):
+  def WantPager(self, _opt):
    return False
 class PagedCommand(Command):
  """Command which defaults to output in a pager, as its
     display tends to be larger than one screen full.
  """
-  def WantPager(self, opt):
+  def WantPager(self, _opt):
    return True
 # pylint: enable=W0223
 class MirrorSafeCommand(object):
  """Command permits itself to run within a mirror,
     and does not require a working directory.
  """
 class GitcAvailableCommand(object):
  """Command that requires GITC to be available, but does
     not require the local client to be a GITC client.
  """
 class GitcClientCommand(object):
  """Command that requires the local client to be a GITC
     client.
  """
--- a/docs/manifest-format.txt
+++ b/docs/manifest-format.txt
@ -1,54 +1,63 @@
-repo Manifest Format
+# repo Manifest Format
 ====================
 A repo manifest describes the structure of a repo client; that is
 the directories that are visible and where they should be obtained
 from with git.
 The basic structure of a manifest is a bare Git repository holding
-a single 'default.xml' XML file in the top level directory.
+a single `default.xml` XML file in the top level directory.
 Manifests are inherently version controlled, since they are kept
 within a Git repository.  Updates to manifests are automatically
 obtained by clients during `repo sync`.
 [TOC]
 XML File Format
 ---------------
-A manifest XML file (e.g. 'default.xml') roughly conforms to the
+## XML File Format
 A manifest XML file (e.g. `default.xml`) roughly conforms to the
 following DTD:
-  <!DOCTYPE manifest [
+```xml
 <!DOCTYPE manifest [
  <!ELEMENT manifest (notice?,
                      remote*,
                      default?,
                      manifest-server?,
                      remove-project*,
                      project*,
-                        repo-hooks?)>
+                      extend-project*,
                      repo-hooks?,
                      include*)>
  <!ELEMENT notice (#PCDATA)>
-    <!ELEMENT remote (EMPTY)>
+  <!ELEMENT remote EMPTY>
  <!ATTLIST remote name         ID    #REQUIRED>
  <!ATTLIST remote alias        CDATA #IMPLIED>
  <!ATTLIST remote fetch        CDATA #REQUIRED>
  <!ATTLIST remote pushurl      CDATA #IMPLIED>
  <!ATTLIST remote review       CDATA #IMPLIED>
  <!ATTLIST remote revision     CDATA #IMPLIED>
-    <!ELEMENT default (EMPTY)>
+  <!ELEMENT default EMPTY>
  <!ATTLIST default remote      IDREF #IMPLIED>
  <!ATTLIST default revision    CDATA #IMPLIED>
  <!ATTLIST default dest-branch CDATA #IMPLIED>
  <!ATTLIST default upstream    CDATA #IMPLIED>
  <!ATTLIST default sync-j      CDATA #IMPLIED>
  <!ATTLIST default sync-c      CDATA #IMPLIED>
  <!ATTLIST default sync-s      CDATA #IMPLIED>
  <!ATTLIST default sync-tags   CDATA #IMPLIED>
-    <!ELEMENT manifest-server (EMPTY)>
+  <!ELEMENT manifest-server EMPTY>
-    <!ATTLIST url              CDATA #REQUIRED>
+  <!ATTLIST manifest-server url CDATA #REQUIRED>
  <!ELEMENT project (annotation*,
-                       project*)>
+                     project*,
                     copyfile*,
                     linkfile*)>
  <!ATTLIST project name        CDATA #REQUIRED>
  <!ATTLIST project path        CDATA #IMPLIED>
  <!ATTLIST project remote      IDREF #IMPLIED>
@ -57,37 +66,51 @@ following DTD:
  <!ATTLIST project groups      CDATA #IMPLIED>
  <!ATTLIST project sync-c      CDATA #IMPLIED>
  <!ATTLIST project sync-s      CDATA #IMPLIED>
  <!ATTLIST project sync-tags   CDATA #IMPLIED>
  <!ATTLIST project upstream CDATA #IMPLIED>
  <!ATTLIST project clone-depth CDATA #IMPLIED>
  <!ATTLIST project force-path CDATA #IMPLIED>
-    <!ELEMENT annotation (EMPTY)>
+  <!ELEMENT annotation EMPTY>
  <!ATTLIST annotation name  CDATA #REQUIRED>
  <!ATTLIST annotation value CDATA #REQUIRED>
  <!ATTLIST annotation keep  CDATA "true">
-    <!ELEMENT remove-project (EMPTY)>
+  <!ELEMENT copyfile EMPTY>
  <!ATTLIST copyfile src  CDATA #REQUIRED>
  <!ATTLIST copyfile dest CDATA #REQUIRED>
  <!ELEMENT linkfile EMPTY>
  <!ATTLIST linkfile src CDATA #REQUIRED>
  <!ATTLIST linkfile dest CDATA #REQUIRED>
  <!ELEMENT extend-project EMPTY>
  <!ATTLIST extend-project name CDATA #REQUIRED>
  <!ATTLIST extend-project path CDATA #IMPLIED>
  <!ATTLIST extend-project groups CDATA #IMPLIED>
  <!ATTLIST extend-project revision CDATA #IMPLIED>
  <!ELEMENT remove-project EMPTY>
  <!ATTLIST remove-project name  CDATA #REQUIRED>
-    <!ELEMENT repo-hooks (EMPTY)>
+  <!ELEMENT repo-hooks EMPTY>
  <!ATTLIST repo-hooks in-project CDATA #REQUIRED>
  <!ATTLIST repo-hooks enabled-list CDATA #REQUIRED>
-    <!ELEMENT include      (EMPTY)>
+  <!ELEMENT include EMPTY>
  <!ATTLIST include name CDATA #REQUIRED>
-  ]>
+]>
 ```
 A description of the elements and their attributes follows.
-Element manifest
+### Element manifest
 ----------------
 The root element of the file.
-Element remote
+### Element remote
 --------------
 One or more remote elements may be specified.  Each remote element
 specifies a Git URL shared by one or more projects and (optionally)
@ -108,12 +131,21 @@ Attribute `fetch`: The Git URL prefix for all projects which use
 this remote.  Each project's name is appended to this prefix to
 form the actual URL used to clone the project.
 Attribute `pushurl`: The Git "push" URL prefix for all projects
 which use this remote.  Each project's name is appended to this
 prefix to form the actual URL used to "git push" the project.
 This attribute is optional; if not specified then "git push"
 will use the same URL as the `fetch` attribute.
 Attribute `review`: Hostname of the Gerrit server where reviews
 are uploaded to by `repo upload`.  This attribute is optional;
 if not specified then `repo upload` will not function.
-Element default
+Attribute `revision`: Name of a Git branch (e.g. `master` or
---------------
+`refs/heads/master`). Remotes with their own revision will override
 the default revision.
 ### Element default
 At most one default element may be specified.  Its remote and
 revision attributes are used when a project element does not
@ -132,18 +164,26 @@ Project elements not setting their own `dest-branch` will inherit
 this value. If this value is not set, projects will use `revision`
 by default instead.
-Attribute `sync_j`: Number of parallel jobs to use when synching.
+Attribute `upstream`: Name of the Git ref in which a sha1
 can be found.  Used when syncing a revision locked manifest in
 -c mode to avoid having to sync the entire ref space. Project elements
 not setting their own `upstream` will inherit this value.
-Attribute `sync_c`: Set to true to only sync the given Git
+Attribute `sync-j`: Number of parallel jobs to use when synching.
 Attribute `sync-c`: Set to true to only sync the given Git
 branch (specified in the `revision` attribute) rather than the
-whole ref space.  Project elements lacking a sync_c element of
+whole ref space.  Project elements lacking a sync-c element of
 their own will use this value.
-Attribute `sync_s`: Set to true to also sync sub-projects.
+Attribute `sync-s`: Set to true to also sync sub-projects.
 Attribute `sync-tags`: Set to false to only sync the given Git
 branch (specified in the `revision` attribute) rather than
 the other ref tags.
-Element manifest-server
+### Element manifest-server
 -----------------------
 At most one manifest-server may be specified. The url attribute
 is used to specify the URL of a manifest server, which is an
@ -154,7 +194,8 @@ The manifest server should implement the following RPC methods:
    GetApprovedManifest(branch, target)
 Return a manifest in which each project is pegged to a known good revision
-for the current branch and target.
+for the current branch and target. This is used by repo sync when the
 --smart-sync option is given.
 The target to use is defined by environment variables TARGET_PRODUCT
 and TARGET_BUILD_VARIANT. These variables are used to create a string
@ -166,11 +207,11 @@ should choose a reasonable default target.
    GetManifest(tag)
 Return a manifest in which each project is pegged to the revision at
-the specified tag.
+the specified tag. This is used by repo sync when the --smart-tag option
 is given.
-Element project
+### Element project
 ---------------
 One or more project elements may be specified.  Each element
 describes a single Git repository to be cloned into the repo
@ -208,7 +249,8 @@ to track for this project.  Names can be relative to refs/heads
 (e.g. just "master") or absolute (e.g. "refs/heads/master").
 Tags and/or explicit SHA-1s should work in theory, but have not
 been extensively tested.  If not supplied the revision given by
-the default element is used.
+the remote element is used if applicable, else the default
 element is used.
 Attribute `dest-branch`: Name of a Git branch (e.g. `master`).
 When using `repo upload`, changes will be submitted for code
@ -226,13 +268,13 @@ group "notdefault", it will not be automatically downloaded by repo.
 If the project has a parent element, the `name` and `path` here
 are the prefixed ones.
-Attribute `sync_c`: Set to true to only sync the given Git
+Attribute `sync-c`: Set to true to only sync the given Git
 branch (specified in the `revision` attribute) rather than the
 whole ref space.
-Attribute `sync_s`: Set to true to also sync sub-projects.
+Attribute `sync-s`: Set to true to also sync sub-projects.
-Attribute `upstream`: Name of the Git branch in which a sha1
+Attribute `upstream`: Name of the Git ref in which a sha1
 can be found.  Used when syncing a revision locked manifest in
 -c mode to avoid having to sync the entire ref space.
@ -246,8 +288,25 @@ rather than the `name` attribute.  This attribute only applies to the
 local mirrors syncing, it will be ignored when syncing the projects in a
 client working directory.
-Element annotation
+### Element extend-project
------------------
+
 Modify the attributes of the named project.
 This element is mostly useful in a local manifest file, to modify the
 attributes of an existing project without completely replacing the
 existing project definition.  This makes the local manifest more robust
 against changes to the original manifest.
 Attribute `path`: If specified, limit the change to projects checked out
 at the specified path, rather than all projects with the given name.
 Attribute `groups`: List of additional groups to which this project
 belongs.  Same syntax as the corresponding element of `project`.
 Attribute `revision`: If specified, overrides the revision of the original
 project.  Same syntax as the corresponding element of `project`.
 ### Element annotation
 Zero or more annotation elements may be specified as children of a
 project element. Each element describes a name-value pair that will be
@ -257,8 +316,36 @@ prefixed with REPO__.  In addition, there is an optional attribute
 "false".  This attribute determines whether or not the annotation will
 be kept when exported with the manifest subcommand.
-Element remove-project
+### Element copyfile
----------------------
+
 Zero or more copyfile elements may be specified as children of a
 project element. Each element describes a src-dest pair of files;
 the "src" file will be copied to the "dest" place during `repo sync`
 command.
 "src" is project relative, "dest" is relative to the top of the tree.
 Copying from paths outside of the project or to paths outside of the repo
 client is not allowed.
 "src" and "dest" must be files.  Directories or symlinks are not allowed.
 Intermediate paths must not be symlinks either.
 Parent directories of "dest" will be automatically created if missing.
 ### Element linkfile
 It's just like copyfile and runs at the same time as copyfile but
 instead of copying it creates a symlink.
 The symlink is created at "dest" (relative to the top of the tree) and
 points to the path specified by "src".
 Parent directories of "dest" will be automatically created if missing.
 The symlink target may be a file or directory, but it may not point outside
 of the repo client.
 ### Element remove-project
 Deletes the named project from the internal manifest table, possibly
 allowing a subsequent project element in the same manifest file to
@ -268,8 +355,7 @@ This element is mostly useful in a local manifest file, where
 the user can remove a project, and possibly replace it with their
 own definition.
-Element include
+### Element include
 ---------------
 This element provides the capability of including another manifest
 file into the originating manifest.  Normal rules apply for the
@ -279,8 +365,7 @@ Attribute `name`: the manifest to include, specified relative to
 the manifest repository's root.
-Local Manifests
+## Local Manifests
 ===============
 Additional remotes and projects may be added through local manifest
 files stored in `$TOP_DIR/.repo/local_manifests/*.xml`.
--- a/docs/python-support.md
+++ b/docs/python-support.md
@ -0,0 +1,47 @@
 # Supported Python Versions
 With Python 2.7 officially going EOL on [01 Jan 2020](https://pythonclock.org/),
 we need a support plan for the repo project itself.
 Inevitably, there will be a long tail of users who still want to use Python 2 on
 their old LTS/corp systems and have little power to change the system.
 ## Summary
 * Python 3.6 (released Dec 2016) is required by default starting with repo-1.14.
 * Older versions of Python (e.g. v2.7) may use the legacy feature-frozen branch
  based on repo-1.13.
 ## Overview
 We provide a branch for Python 2 users that is feature-frozen.
 Bugfixes may be added on a best-effort basis or from the community, but largely
 no new features will be added, nor is support guaranteed.
 Users can select this during `repo init` time via the [repo launcher].
 Otherwise the default branches (e.g. stable & master) will be used which will
 require Python 3.
 This means the [repo launcher] needs to support both Python 2 & Python 3, but
 since it doesn't import any other repo code, this shouldn't be too problematic.
 The master branch will require Python 3.6 at a minimum.
 If the system has an older version of Python 3, then users will have to select
 the legacy Python 2 branch instead.
 ### repo hooks
 Projects that use [repo hooks] run on independent schedules.
 They might migrate to Python 3 earlier or later than us.
 To support them, we'll probe the shebang of the hook script and if we find an
 interpreter in there that indicates a different version than repo is currently
 running under, we'll attempt to reexec ourselves under that.
 For example, a hook with a header like `#!/usr/bin/python2` will have repo
 execute `/usr/bin/python2` to execute the hook code specifically if repo is
 currently running Python 3.
 For more details, consult the [repo hooks] documentation.
 [repo hooks]: ./repo-hooks.md
 [repo launcher]: ../repo
--- a/docs/release-process.md
+++ b/docs/release-process.md
@ -0,0 +1,167 @@
 # repo release process
 This is the process for creating a new release of repo, as well as all the
 related topics and flows.
 [TOC]
 ## Launcher script
 The main repo script serves as a standalone program and is often referred to as
 the "launcher script".
 This makes it easy to copy around and install as you don't have to install any
 other files from the git repo.
 Whenever major changes are made to the launcher script, you should increment the
 `VERSION` variable in the launcher itself.
 At runtime, repo will check this to see if it needs to be updated (and notify
 the user automatically).
 ## Key management
 Every release has a git tag that is signed with a key that repo recognizes.
 Those keys are hardcoded inside of the repo launcher itself -- look for the
 `KEYRING_VERSION` and `MAINTAINER_KEYS` settings.
 Adding new keys to the repo launcher will allow tags to be recognized by new
 keys, but only people using that updated version will be able to.
 Since the majority of users will be using an official launcher version, their
 version will simply ignore any new signed tags.
 If you want to add new keys, it's best to register them long ahead of time,
 and then wait for that updated launcher to make its way out to everyone.
 Even then, there will be a long tail of users with outdated launchers, so be
 prepared for people asking questions.
 ### Registering a new key
 The process of actually adding a new key is quite simple.
 1.  Add the public half of the key to `MAINTAINER_KEYS`.
 2.  Increment `KEYRING_VERSION` so repo knows it needs to update.
 3.  Wait a long time after that version is in a release (~months) before trying
    to create a new release using those new keys.
 ## Self update algorithm
 When creating a new repo checkout with `repo init`, there are a few options that
 control how repo finds updates:
 *   `--repo-url`: This tells repo where to clone the full repo project itself.
    It defaults to the official project (`REPO_URL` in the launcher script).
 *   `--repo-branch`: This tells repo which branch to use for the full project.
    It defaults to the `stable` branch (`REPO_REV` in the launcher script).
 Whenever `repo sync` is run, repo will check to see if an update is available.
 It fetches the latest repo-branch from the repo-url.
 Then it verifies that the latest commit in the branch has a valid signed tag
 using `git tag -v` (which uses gpg).
 If the tag is valid, then repo will update its internal checkout to it.
 If the latest commit doesn't have a signed tag, repo will fall back to the
 most recent tag it can find (via `git describe`).
 If that tag is valid, then repo will warn and use that commit instead.
 If that tag cannot be verified, it gives up and forces the user to resolve.
 ## Branch management
 All development happens on the `master` branch and should generally be stable.
 Since the repo launcher defaults to tracking the `stable` branch, it is not
 normally updated until a new release is available.
 If something goes wrong with a new release, an older release can be force pushed
 and clients will automatically downgrade.
 The `maint` branch is used to track the previous major release of repo.
 It is not normally meant to be used by people as `stable` should be good enough.
 Once a new major release is pushed to the `stable` branch, then the previous
 major release can be pushed to `maint`.
 For example, when `stable` moves from `v1.10.x` to `v1.11.x`, then the `maint`
 branch will be updated from `v1.9.x` to `v1.10.x`.
 We don't have parallel release branches/series.
 Typically all tags are made against the `master` branch and then pushed to the
 `stable` branch to make it available to the rest of the world.
 Since repo doesn't typically see a lot of changes, this tends to be OK.
 ## Creating a new release
 When you want to create a new release, you'll need to select a good version and
 create a signed tag using a key registered in repo itself.
 Typically we just tag the latest version of the `master` branch.
 The tag could be pushed now, but it won't be used by clients normally (since the
 default `repo-branch` setting is `stable`).
 This would allow some early testing on systems who explicitly select `master`.
 ### Creating a signed tag
 Lets assume your keys live in a dedicated directory, e.g. `~/.gnupg/repo/`.
 *** note
 If you need access to the official keys, check out the internal documentation
 at [go/repo-release].
 Note that only official maintainers of repo will have access as it describes
 internal processes for accessing the restricted keys.
 ***
 ```sh
 # Set the gpg key directory.
 $ export GNUPGHOME=~/.gnupg/repo/
 # Verify the listed key is “Repo Maintainer”.
 $ gpg -K
 # Pick whatever branch or commit you want to tag.
 $ r=master
 # Pick the new version.
 $ t=1.12.10
 # Create the signed tag.
 $ git tag -s v$t -u "Repo Maintainer <repo@android.kernel.org>" -m "repo $t" $r
 # Verify the signed tag.
 $ git show v$t
 ```
 ### Push the new release
 Once you're ready to make the release available to everyone, push it to the
 `stable` branch.
 Make sure you never push the tag itself to the stable branch!
 Only push the commit -- notice the use of `$t` and `$r` below.
 ```sh
 $ git push https://gerrit-review.googlesource.com/git-repo v$t
 $ git push https://gerrit-review.googlesource.com/git-repo $r:stable
 ```
 If something goes horribly wrong, you can force push the previous version to the
 `stable` branch and people should automatically recover.
 Again, make sure you never push the tag itself!
 ```sh
 $ oldrev="whatever-old-commit"
 $ git push https://gerrit-review.googlesource.com/git-repo $oldrev:stable --force
 ```
 ### Announce the release
 Once you do push a new release to `stable`, make sure to announce it on the
 [repo-discuss@googlegroups.com] group.
 Here is an [example announcement].
 You can create a short changelog using the command:
 ```sh
 # If you haven't pushed to the stable branch yet, you can use origin/stable.
 # If you have pushed, change origin/stable to the previous release tag.
 $ git log --format="%h (%aN) %s" --no-merges origin/stable..$r
 ```
 [example announcement]: https://groups.google.com/d/topic/repo-discuss/UGBNismWo1M/discussion
 [repo-discuss@googlegroups.com]: https://groups.google.com/forum/#!forum/repo-discuss
 [go/repo-release]: https://goto.google.com/repo-release
--- a/docs/repo-hooks.md
+++ b/docs/repo-hooks.md
@ -0,0 +1,135 @@
 # repo hooks
 [TOC]
 Repo provides a mechanism to hook specific stages of the runtime with custom
 python modules.  All the hooks live in one git project which is checked out by
 the manifest (specified during `repo init`), and the manifest itself defines
 which hooks are registered.
 These are useful to run linters, check formatting, and run quick unittests
 before allowing a step to proceed (e.g. before uploading a commit to Gerrit).
 A complete example can be found in the Android project.  It can be easily
 re-used by any repo based project and is not specific to Android.<br>
 https://android.googlesource.com/platform/tools/repohooks
 ## Approvals
 When a hook is processed the first time, the user is prompted for approval.
 We don't want to execute arbitrary code without explicit consent.  For manifests
 fetched via secure protocols (e.g. https://), the user is prompted once.  For
 insecure protocols (e.g. http://), the user is prompted whenever the registered
 repohooks project is updated and a hook is triggered.
 ## Manifest Settings
 For the full syntax, see the [repo manifest format](./manifest-format.md).
 Here's a short example from
 [Android](https://android.googlesource.com/platform/manifest/+/master/default.xml).
 The `<project>` line checks out the repohooks git repo to the local
 `tools/repohooks/` path.  The `<repo-hooks>` line says to look in the project
 with the name `platform/tools/repohooks` for hooks to run during the
 `pre-upload` phase.
 ```xml
 <project path="tools/repohooks" name="platform/tools/repohooks" />
 <repo-hooks in-project="platform/tools/repohooks" enabled-list="pre-upload" />
 ```
 ## Source Layout
 The repohooks git repo should have a python file with the same name as the hook.
 So if you want to support the `pre-upload` hook, you'll need to create a file
 named `pre-upload.py`.  Repo will dynamically load that module when processing
 the hook and then call the `main` function in it.
 Hooks should have their `main` accept `**kwargs` for future compatibility.
 ## Runtime
 Hook return values are ignored.
 Any uncaught exceptions from the hook will cause the step to fail.  This is
 intended as a fallback safety check though rather than the normal flow.  If
 you want your hook to trigger a failure, it should call `sys.exit()` (after
 displaying relevant diagnostics).
 Output (stdout & stderr) are not filtered in any way.  Hooks should generally
 not be too verbose.  A short summary is nice, and some status information when
 long running operations occur, but long/verbose output should be used only if
 the hook ultimately fails.
 The hook runs from the top level of the repo client where the operation is
 started.
 For example, if the repo client is under `~/tree/`, then that is where the hook
 runs, even if you ran repo in a git repository at `~/tree/src/foo/`, or in a
 subdirectory of that git repository in `~/tree/src/foo/bar/`.
 Hooks frequently start off by doing a `os.chdir` to the specific project they're
 called on (see below) and then changing back to the original dir when they're
 finished.
 Python's `sys.path` is modified so that the top of repohooks directory comes
 first.  This should help simplify the hook logic to easily allow importing of
 local modules.
 Repo does not modify the state of the git checkout.  This means that the hooks
 might be running in a dirty git repo with many commits and checked out to the
 latest one.  If the hook wants to operate on specific git commits, it needs to
 manually discover the list of pending commits, extract the diff/commit, and
 then check it directly.  Hooks should not normally modify the active git repo
 (such as checking out a specific commit to run checks) without first prompting
 the user.  Although user interaction is discouraged in the common case, it can
 be useful when deploying automatic fixes.
 ### Shebang Handling
 *** note
 This is intended as a transitional feature.  Hooks are expected to eventually
 migrate to Python 3 only as Python 2 is EOL & deprecated.
 ***
 If the hook is written against a specific version of Python (either 2 or 3),
 the script can declare that explicitly.  Repo will then attempt to execute it
 under the right version of Python regardless of the version repo itself might
 be executing under.
 Here are the shebangs that are recognized.
 * `#!/usr/bin/env python` & `#!/usr/bin/python`: The hook is compatible with
  Python 2 & Python 3.  For maximum compatibility, these are recommended.
 * `#!/usr/bin/env python2` & `#!/usr/bin/python2`: The hook requires Python 2.
  Version specific names like `python2.7` are also recognized.
 * `#!/usr/bin/env python3` & `#!/usr/bin/python3`: The hook requires Python 3.
  Version specific names like `python3.6` are also recognized.
 If no shebang is detected, or does not match the forms above, we assume that the
 hook is compatible with both Python 2 & Python 3 as if `#!/usr/bin/python` was
 used.
 ## Hooks
 Here are all the points available for hooking.
 ### pre-upload
 This hook runs when people run `repo upload`.
 The `pre-upload.py` file should be defined like:
 ```py
 def main(project_list, worktree_list=None, **kwargs):
    """Main function invoked directly by repo.
    We must use the name "main" as that is what repo requires.
    Args:
      project_list: List of projects to run on.
      worktree_list: A list of directories.  It should be the same length as
          project_list, so that each entry in project_list matches with a
          directory in worktree_list.  If None, we will attempt to calculate
          the directories automatically.
      kwargs: Leave this here for forward-compatibility.
    """
 ```
--- a/editor.py
+++ b/editor.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -21,6 +22,7 @@ import subprocess
 import tempfile
 from error import EditorError
 import platform_utils
 class Editor(object):
  """Manages the user's preferred text editor."""
@ -82,7 +84,12 @@ least one of these before using this command.""", file=sys.stderr)
      os.close(fd)
      fd = None
-      if re.compile("^.*[$ \t'].*$").match(editor):
+      if platform_utils.isWindows():
        # Split on spaces, respecting quoted strings
        import shlex
        args = shlex.split(editor)
        shell = False
      elif re.compile("^.*[$ \t'].*$").match(editor):
        args = [editor + ' "$@"', 'sh']
        shell = True
      else:
@ -107,4 +114,4 @@ least one of these before using this command.""", file=sys.stderr)
    finally:
      if fd:
        os.close(fd)
-      os.remove(path)
+      platform_utils.remove(path)
--- a/error.py
+++ b/error.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -24,6 +25,13 @@ class ManifestInvalidRevisionError(Exception):
 class NoManifestException(Exception):
  """The required manifest does not exist.
  """
  def __init__(self, path, reason):
    super(NoManifestException, self).__init__()
    self.path = path
    self.reason = reason
  def __str__(self):
    return self.reason
 class EditorError(Exception):
  """Unspecified error from the user's text editor.
@ -73,7 +81,7 @@ class NoSuchProjectError(Exception):
    self.name = name
  def __str__(self):
-    if self.Name is None:
+    if self.name is None:
      return 'in current directory'
    return self.name
@ -86,7 +94,7 @@ class InvalidProjectGroupsError(Exception):
    self.name = name
  def __str__(self):
-    if self.Name is None:
+    if self.name is None:
      return 'in current directory'
    return self.name
--- a/event_log.py
+++ b/event_log.py
@ -0,0 +1,177 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2017 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from __future__ import print_function
 import json
 import multiprocessing
 TASK_COMMAND = 'command'
 TASK_SYNC_NETWORK = 'sync-network'
 TASK_SYNC_LOCAL = 'sync-local'
 class EventLog(object):
  """Event log that records events that occurred during a repo invocation.
  Events are written to the log as a consecutive JSON entries, one per line.
  Each entry contains the following keys:
  - id: A ('RepoOp', ID) tuple, suitable for storing in a datastore.
        The ID is only unique for the invocation of the repo command.
  - name: Name of the object being operated upon.
  - task_name: The task that was performed.
  - start: Timestamp of when the operation started.
  - finish: Timestamp of when the operation finished.
  - success: Boolean indicating if the operation was successful.
  - try_count: A counter indicating the try count of this task.
  Optionally:
  - parent: A ('RepoOp', ID) tuple indicating the parent event for nested
            events.
  Valid task_names include:
  - command: The invocation of a subcommand.
  - sync-network: The network component of a sync command.
  - sync-local: The local component of a sync command.
  Specific tasks may include additional informational properties.
  """
  def __init__(self):
    """Initializes the event log."""
    self._log = []
    self._parent = None
  def Add(self, name, task_name, start, finish=None, success=None,
          try_count=1, kind='RepoOp'):
    """Add an event to the log.
    Args:
      name: Name of the object being operated upon.
      task_name: A sub-task that was performed for name.
      start: Timestamp of when the operation started.
      finish: Timestamp of when the operation finished.
      success: Boolean indicating if the operation was successful.
      try_count: A counter indicating the try count of this task.
      kind: The kind of the object for the unique identifier.
    Returns:
      A dictionary of the event added to the log.
    """
    event = {
        'id': (kind, _NextEventId()),
        'name': name,
        'task_name': task_name,
        'start_time': start,
        'try': try_count,
    }
    if self._parent:
      event['parent'] = self._parent['id']
    if success is not None or finish is not None:
        self.FinishEvent(event, finish, success)
    self._log.append(event)
    return event
  def AddSync(self, project, task_name, start, finish, success):
    """Add a event to the log for a sync command.
    Args:
      project: Project being synced.
      task_name: A sub-task that was performed for name.
                 One of (TASK_SYNC_NETWORK, TASK_SYNC_LOCAL)
      start: Timestamp of when the operation started.
      finish: Timestamp of when the operation finished.
      success: Boolean indicating if the operation was successful.
    Returns:
      A dictionary of the event added to the log.
    """
    event = self.Add(project.relpath, task_name, start, finish, success)
    if event is not None:
      event['project'] = project.name
      if project.revisionExpr:
        event['revision'] = project.revisionExpr
      if project.remote.url:
        event['project_url'] = project.remote.url
      if project.remote.fetchUrl:
        event['remote_url'] = project.remote.fetchUrl
      try:
        event['git_hash'] = project.GetCommitRevisionId()
      except Exception:
        pass
    return event
  def GetStatusString(self, success):
    """Converst a boolean success to a status string.
    Args:
      success: Boolean indicating if the operation was successful.
    Returns:
      status string.
    """
    return 'pass' if success else 'fail'
  def FinishEvent(self, event, finish, success):
    """Finishes an incomplete event.
    Args:
      event: An event that has been added to the log.
      finish: Timestamp of when the operation finished.
      success: Boolean indicating if the operation was successful.
    Returns:
      A dictionary of the event added to the log.
    """
    event['status'] =  self.GetStatusString(success)
    event['finish_time'] = finish
    return event
  def SetParent(self, event):
    """Set a parent event for all new entities.
    Args:
      event: The event to use as a parent.
    """
    self._parent = event
  def Write(self, filename):
    """Writes the log out to a file.
    Args:
      filename: The file to write the log to.
    """
    with open(filename, 'w+') as f:
      for e in self._log:
        json.dump(e, f, sort_keys=True)
        f.write('\n')
 # An integer id that is unique across this invocation of the program.
 _EVENT_ID = multiprocessing.Value('i', 1)
 def _NextEventId():
  """Helper function for grabbing the next unique id.
  Returns:
    A unique, to this invocation of the program, integer id.
  """
  with _EVENT_ID.get_lock():
    val = _EVENT_ID.value
    _EVENT_ID.value += 1
  return val
--- a/git_command.py
+++ b/git_command.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -19,8 +20,11 @@ import sys
 import subprocess
 import tempfile
 from signal import SIGTERM
 from error import GitError
-from trace import REPO_TRACE, IsTrace, Trace
+from git_refs import HEAD
 import platform_utils
 from repo_trace import REPO_TRACE, IsTrace, Trace
 from wrapper import Wrapper
 GIT = 'git'
@ -77,19 +81,12 @@ def terminate_ssh_clients():
 _git_version = None
 class _GitCall(object):
  def version(self):
    p = GitCommand(None, ['--version'], capture_stdout=True)
    if p.Wait() == 0:
      return p.stdout
    return None
  def version_tuple(self):
    global _git_version
    if _git_version is None:
-      ver_str = git.version().decode('utf-8')
+      _git_version = Wrapper().ParseGitVersion()
      _git_version = Wrapper().ParseGitVersion(ver_str)
      if _git_version is None:
-        print('fatal: "%s" unsupported' % ver_str, file=sys.stderr)
+        print('fatal: unable to detect git version', file=sys.stderr)
        sys.exit(1)
    return _git_version
@ -102,13 +99,95 @@ class _GitCall(object):
    return fun
 git = _GitCall()
-def git_require(min_version, fail=False):
+
 def RepoSourceVersion():
  """Return the version of the repo.git tree."""
  ver = getattr(RepoSourceVersion, 'version', None)
  # We avoid GitCommand so we don't run into circular deps -- GitCommand needs
  # to initialize version info we provide.
  if ver is None:
    env = GitCommand._GetBasicEnv()
    proj = os.path.dirname(os.path.abspath(__file__))
    env[GIT_DIR] = os.path.join(proj, '.git')
    p = subprocess.Popen([GIT, 'describe', HEAD], stdout=subprocess.PIPE,
                         env=env)
    if p.wait() == 0:
      ver = p.stdout.read().strip().decode('utf-8')
      if ver.startswith('v'):
        ver = ver[1:]
    else:
      ver = 'unknown'
    setattr(RepoSourceVersion, 'version', ver)
  return ver
 class UserAgent(object):
  """Mange User-Agent settings when talking to external services
  We follow the style as documented here:
  https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent
  """
  _os = None
  _repo_ua = None
  _git_ua = None
  @property
  def os(self):
    """The operating system name."""
    if self._os is None:
      os_name = sys.platform
      if os_name.lower().startswith('linux'):
        os_name = 'Linux'
      elif os_name == 'win32':
        os_name = 'Win32'
      elif os_name == 'cygwin':
        os_name = 'Cygwin'
      elif os_name == 'darwin':
        os_name = 'Darwin'
      self._os = os_name
    return self._os
  @property
  def repo(self):
    """The UA when connecting directly from repo."""
    if self._repo_ua is None:
      py_version = sys.version_info
      self._repo_ua = 'git-repo/%s (%s) git/%s Python/%d.%d.%d' % (
          RepoSourceVersion(),
          self.os,
          git.version_tuple().full,
          py_version.major, py_version.minor, py_version.micro)
    return self._repo_ua
  @property
  def git(self):
    """The UA when running git."""
    if self._git_ua is None:
      self._git_ua = 'git/%s (%s) git-repo/%s' % (
          git.version_tuple().full,
          self.os,
          RepoSourceVersion())
    return self._git_ua
 user_agent = UserAgent()
 def git_require(min_version, fail=False, msg=''):
  git_version = git.version_tuple()
  if min_version <= git_version:
    return True
  if fail:
    need = '.'.join(map(str, min_version))
-    print('fatal: git %s or later required' % need, file=sys.stderr)
+    if msg:
      msg = ' for ' + msg
    print('fatal: git %s or later required%s' % (need, msg), file=sys.stderr)
    sys.exit(1)
  return False
@ -127,29 +206,27 @@ class GitCommand(object):
               ssh_proxy = False,
               cwd = None,
               gitdir = None):
-    env = os.environ.copy()
+    env = self._GetBasicEnv()
-    for key in [REPO_TRACE,
+    # If we are not capturing std* then need to print it.
-              GIT_DIR,
+    self.tee = {'stdout': not capture_stdout, 'stderr': not capture_stderr}
              'GIT_ALTERNATE_OBJECT_DIRECTORIES',
              'GIT_OBJECT_DIRECTORY',
              'GIT_WORK_TREE',
              'GIT_GRAFT_FILE',
              'GIT_INDEX_FILE']:
      if key in env:
        del env[key]
    if disable_editor:
      _setenv(env, 'GIT_EDITOR', ':')
    if ssh_proxy:
      _setenv(env, 'REPO_SSH_SOCK', ssh_sock())
      _setenv(env, 'GIT_SSH', _ssh_proxy())
      _setenv(env, 'GIT_SSH_VARIANT', 'ssh')
    if 'http_proxy' in env and 'darwin' == sys.platform:
      s = "'http.proxy=%s'" % (env['http_proxy'],)
      p = env.get('GIT_CONFIG_PARAMETERS')
      if p is not None:
        s = p + ' ' + s
      _setenv(env, 'GIT_CONFIG_PARAMETERS', s)
    if 'GIT_ALLOW_PROTOCOL' not in env:
      _setenv(env, 'GIT_ALLOW_PROTOCOL',
              'file:git:http:https:ssh:persistent-http:persistent-https:sso:rpc')
    _setenv(env, 'GIT_HTTP_USER_AGENT', user_agent.git)
    if project:
      if not cwd:
@ -162,22 +239,21 @@ class GitCommand(object):
      if gitdir:
        _setenv(env, GIT_DIR, gitdir)
      cwd = None
-    command.extend(cmdv)
+    command.append(cmdv[0])
    # Need to use the --progress flag for fetch/clone so output will be
    # displayed as by default git only does progress output if stderr is a TTY.
    if sys.stderr.isatty() and cmdv[0] in ('fetch', 'clone'):
      if '--progress' not in cmdv and '--quiet' not in cmdv:
        command.append('--progress')
    command.extend(cmdv[1:])
    if provide_stdin:
      stdin = subprocess.PIPE
    else:
      stdin = None
    if capture_stdout:
    stdout = subprocess.PIPE
    else:
      stdout = None
    if capture_stderr:
    stderr = subprocess.PIPE
    else:
      stderr = None
    if IsTrace():
      global LAST_CWD
@ -223,11 +299,53 @@ class GitCommand(object):
    self.process = p
    self.stdin = p.stdin
  @staticmethod
  def _GetBasicEnv():
    """Return a basic env for running git under.
    This is guaranteed to be side-effect free.
    """
    env = os.environ.copy()
    for key in (REPO_TRACE,
                GIT_DIR,
                'GIT_ALTERNATE_OBJECT_DIRECTORIES',
                'GIT_OBJECT_DIRECTORY',
                'GIT_WORK_TREE',
                'GIT_GRAFT_FILE',
                'GIT_INDEX_FILE'):
      env.pop(key, None)
    return env
  def Wait(self):
    try:
      p = self.process
-      (self.stdout, self.stderr) = p.communicate()
+      rc = self._CaptureOutput()
      rc = p.returncode
    finally:
      _remove_ssh_client(p)
    return rc
  def _CaptureOutput(self):
    p = self.process
    s_in = platform_utils.FileDescriptorStreams.create()
    s_in.add(p.stdout, sys.stdout, 'stdout')
    s_in.add(p.stderr, sys.stderr, 'stderr')
    self.stdout = ''
    self.stderr = ''
    while not s_in.is_done:
      in_ready = s_in.select()
      for s in in_ready:
        buf = s.read()
        if not buf:
          s_in.remove(s)
          continue
        if not hasattr(buf, 'encode'):
          buf = buf.decode()
        if s.std_name == 'stdout':
          self.stdout += buf
        else:
          self.stderr += buf
        if self.tee[s.std_name]:
          s.dest.write(buf)
          s.dest.flush()
    return p.wait()
--- a/git_config.py
+++ b/git_config.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -15,9 +16,12 @@
 from __future__ import print_function
 import contextlib
 import errno
 import json
 import os
 import pickle
 import re
 import ssl
 import subprocess
 import sys
 try:
@ -39,7 +43,8 @@ else:
 from signal import SIGTERM
 from error import GitError, UploadError
-from trace import Trace
+import platform_utils
 from repo_trace import Trace
 if is_python3():
  from http.client import HTTPException
 else:
@ -48,16 +53,24 @@ else:
 from git_command import GitCommand
 from git_command import ssh_sock
 from git_command import terminate_ssh_clients
 from git_refs import R_CHANGES, R_HEADS, R_TAGS
 R_HEADS = 'refs/heads/'
 R_TAGS  = 'refs/tags/'
 ID_RE = re.compile(r'^[0-9a-f]{40}$')
 REVIEW_CACHE = dict()
 def IsChange(rev):
  return rev.startswith(R_CHANGES)
 def IsId(rev):
  return ID_RE.match(rev)
 def IsTag(rev):
  return rev.startswith(R_TAGS)
 def IsImmutable(rev):
    return IsChange(rev) or IsId(rev) or IsTag(rev)
 def _key(name):
  parts = name.split('.')
  if len(parts) < 2:
@ -80,7 +93,7 @@ class GitConfig(object):
    return cls(configfile = os.path.join(gitdir, 'config'),
               defaults = defaults)
-  def __init__(self, configfile, defaults=None, pickleFile=None):
+  def __init__(self, configfile, defaults=None, jsonFile=None):
    self.file = configfile
    self.defaults = defaults
    self._cache_dict = None
@ -88,12 +101,11 @@ class GitConfig(object):
    self._remotes = {}
    self._branches = {}
-    if pickleFile is None:
+    self._json = jsonFile
-      self._pickle = os.path.join(
+    if self._json is None:
      self._json = os.path.join(
        os.path.dirname(self.file),
-        '.repopickle_' + os.path.basename(self.file))
+        '.repo_' + os.path.basename(self.file) + '.json')
    else:
      self._pickle = pickleFile
  def Has(self, name, include_defaults = True):
    """Return true if this configuration file has the key.
@ -217,7 +229,7 @@ class GitConfig(object):
    """Resolve any url.*.insteadof references.
    """
    for new_url in self.GetSubSections('url'):
-      old_url = self.GetString('url.%s.insteadof' % new_url)
+      for old_url in self.GetString('url.%s.insteadof' % new_url, True):
        if old_url is not None and url.startswith(old_url):
          return new_url + url[len(old_url):]
    return url
@ -248,50 +260,41 @@ class GitConfig(object):
    return self._cache_dict
  def _Read(self):
-    d = self._ReadPickle()
+    d = self._ReadJson()
    if d is None:
      d = self._ReadGit()
-      self._SavePickle(d)
+      self._SaveJson(d)
    return d
-  def _ReadPickle(self):
+  def _ReadJson(self):
    try:
-      if os.path.getmtime(self._pickle) \
+      if os.path.getmtime(self._json) \
      <= os.path.getmtime(self.file):
-        os.remove(self._pickle)
+        platform_utils.remove(self._json)
        return None
    except OSError:
      return None
    try:
-      Trace(': unpickle %s', self.file)
+      Trace(': parsing %s', self.file)
-      fd = open(self._pickle, 'rb')
+      fd = open(self._json)
      try:
-        return pickle.load(fd)
+        return json.load(fd)
      finally:
        fd.close()
-    except EOFError:
+    except (IOError, ValueError):
-      os.remove(self._pickle)
+      platform_utils.remove(self._json)
      return None
    except IOError:
      os.remove(self._pickle)
      return None
    except pickle.PickleError:
      os.remove(self._pickle)
      return None
-  def _SavePickle(self, cache):
+  def _SaveJson(self, cache):
    try:
-      fd = open(self._pickle, 'wb')
+      fd = open(self._json, 'w')
      try:
-        pickle.dump(cache, fd, pickle.HIGHEST_PROTOCOL)
+        json.dump(cache, fd, indent=2)
      finally:
        fd.close()
-    except IOError:
+    except (IOError, TypeError):
-      if os.path.exists(self._pickle):
+      if os.path.exists(self._json):
-        os.remove(self._pickle)
+        platform_utils.remove(self._json)
    except pickle.PickleError:
      if os.path.exists(self._pickle):
        os.remove(self._pickle)
  def _ReadGit(self):
    """
@ -304,8 +307,9 @@ class GitConfig(object):
    d = self._do('--null', '--list')
    if d is None:
      return c
-    for line in d.decode('utf-8').rstrip('\0').split('\0'):  # pylint: disable=W1401
+    if not is_python3():
-                                                             # Backslash is not anomalous
+      d = d.decode('utf-8')
    for line in d.rstrip('\0').split('\0'):
      if '\n' in line:
        key, val = line.split('\n', 1)
      else:
@ -472,9 +476,13 @@ def _open_ssh(host, port=None):
             % (host,port, str(e)), file=sys.stderr)
      return False
    time.sleep(1)
    ssh_died = (p.poll() is not None)
    if ssh_died:
      return False
    _master_processes.append(p)
    _master_keys.add(key)
    time.sleep(1)
    return True
  finally:
    _master_keys_lock.release()
@ -496,7 +504,7 @@ def close_ssh():
  d = ssh_sock(create=False)
  if d:
    try:
-      os.rmdir(os.path.dirname(d))
+      platform_utils.rmdir(os.path.dirname(d))
    except OSError:
      pass
@ -512,6 +520,46 @@ def GetSchemeFromUrl(url):
    return m.group(1)
  return None
@contextlib.contextmanager
 def GetUrlCookieFile(url, quiet):
  if url.startswith('persistent-'):
    try:
      p = subprocess.Popen(
          ['git-remote-persistent-https', '-print_config', url],
          stdin=subprocess.PIPE, stdout=subprocess.PIPE,
          stderr=subprocess.PIPE)
      try:
        cookieprefix = 'http.cookiefile='
        proxyprefix = 'http.proxy='
        cookiefile = None
        proxy = None
        for line in p.stdout:
          line = line.strip()
          if line.startswith(cookieprefix):
            cookiefile = os.path.expanduser(line[len(cookieprefix):])
          if line.startswith(proxyprefix):
            proxy = line[len(proxyprefix):]
        # Leave subprocess open, as cookie file may be transient.
        if cookiefile or proxy:
          yield cookiefile, proxy
          return
      finally:
        p.stdin.close()
        if p.wait():
          err_msg = p.stderr.read()
          if ' -print_config' in err_msg:
            pass  # Persistent proxy doesn't support -print_config.
          elif not quiet:
            print(err_msg, file=sys.stderr)
    except OSError as e:
      if e.errno == errno.ENOENT:
        pass  # No persistent proxy.
      raise
  cookiefile = GitConfig.ForUser().GetString('http.cookiefile')
  if cookiefile:
    cookiefile = os.path.expanduser(cookiefile)
  yield cookiefile, None
 def _preconnect(url):
  m = URI_ALL.match(url)
  if m:
@ -539,6 +587,7 @@ class Remote(object):
    self._config = config
    self.name = name
    self.url = self._Get('url')
    self.pushUrl = self._Get('pushurl')
    self.review = self._Get('review')
    self.projectname = self._Get('projectname')
    self.fetch = list(map(RefSpec.FromString,
@ -570,13 +619,15 @@ class Remote(object):
    connectionUrl = self._InsteadOf()
    return _preconnect(connectionUrl)
-  def ReviewUrl(self, userEmail):
+  def ReviewUrl(self, userEmail, validate_certs):
    if self._review_url is None:
      if self.review is None:
        return None
      u = self.review
-      if not u.startswith('http:') and not u.startswith('https:'):
+      if u.startswith('persistent-'):
        u = u[len('persistent-'):]
      if u.split(':')[0] not in ('http', 'https', 'sso', 'ssh'):
        u = 'http://%s' % u
      if u.endswith('/Gerrit'):
        u = u[:len(u) - len('/Gerrit')]
@ -592,17 +643,28 @@ class Remote(object):
        host, port = os.environ['REPO_HOST_PORT_INFO'].split()
        self._review_url = self._SshReviewUrl(userEmail, host, port)
        REVIEW_CACHE[u] = self._review_url
      elif u.startswith('sso:') or u.startswith('ssh:'):
        self._review_url = u  # Assume it's right
        REVIEW_CACHE[u] = self._review_url
      elif 'REPO_IGNORE_SSH_INFO' in os.environ:
        self._review_url = http_url
        REVIEW_CACHE[u] = self._review_url
      else:
        try:
          info_url = u + 'ssh_info'
          if not validate_certs:
              context = ssl._create_unverified_context()
              info = urllib.request.urlopen(info_url, context=context).read()
          else:
              info = urllib.request.urlopen(info_url).read()
-          if info == 'NOT_AVAILABLE' or '<' in info:
+          if info == b'NOT_AVAILABLE' or b'<' in info:
            # If `info` contains '<', we assume the server gave us some sort
            # of HTML response back, like maybe a login page.
            #
            # Assume HTTP if SSH is not enabled or ssh_info doesn't look right.
-            self._review_url = http_url + 'p/'
+            self._review_url = http_url
          else:
            info = info.decode('utf-8')
            host, port = info.split()
            self._review_url = self._SshReviewUrl(userEmail, host, port)
        except urllib.error.HTTPError as e:
@ -624,9 +686,7 @@ class Remote(object):
  def ToLocal(self, rev):
    """Convert a remote revision string to something we have locally.
    """
-    if IsId(rev):
+    if self.name == '.' or IsId(rev):
      return rev
    if rev.startswith(R_TAGS):
      return rev
    if not rev.startswith('refs/'):
@ -635,7 +695,12 @@ class Remote(object):
    for spec in self.fetch:
      if spec.SourceMatches(rev):
        return spec.MapSource(rev)
-    raise GitError('remote %s does not have %s' % (self.name, rev))
+
    if not rev.startswith(R_HEADS):
      return rev
    raise GitError('%s: remote %s does not have %s' %
                   (self.projectname, self.name, rev))
  def WritesTo(self, ref):
    """True if the remote stores to the tracking ref.
@ -658,6 +723,10 @@ class Remote(object):
    """Save this remote to the configuration.
    """
    self._Set('url', self.url)
    if self.pushUrl is not None:
      self._Set('pushurl', self.pushUrl + '/' + self.projectname)
    else:
      self._Set('pushurl', self.pushUrl)
    self._Set('review', self.review)
    self._Set('projectname', self.projectname)
    self._Set('fetch', list(map(str, self.fetch)))
@ -704,7 +773,7 @@ class Branch(object):
      self._Set('merge', self.merge)
    else:
-      fd = open(self._config.file, 'ab')
+      fd = open(self._config.file, 'a')
      try:
        fd.write('[branch "%s"]\n' % self.name)
        if self.remote:
--- a/git_refs.py
+++ b/git_refs.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2009 The Android Open Source Project
 #
@ -14,9 +15,11 @@
 # limitations under the License.
 import os
-from trace import Trace
+from repo_trace import Trace
 import platform_utils
 HEAD      = 'HEAD'
 R_CHANGES = 'refs/changes/'
 R_HEADS   = 'refs/heads/'
 R_TAGS    = 'refs/tags/'
 R_PUB     = 'refs/published/'
@ -126,9 +129,9 @@ class GitRefs(object):
  def _ReadLoose(self, prefix):
    base = os.path.join(self._gitdir, prefix)
-    for name in os.listdir(base):
+    for name in platform_utils.listdir(base):
      p = os.path.join(base, name)
-      if os.path.isdir(p):
+      if platform_utils.isdir(p):
        self._mtime[prefix] = os.path.getmtime(base)
        self._ReadLoose(prefix + name + '/')
      elif name.endswith('.lock'):
@ -138,7 +141,7 @@ class GitRefs(object):
  def _ReadLoose1(self, path, name):
    try:
-      fd = open(path, 'rb')
+      fd = open(path)
    except IOError:
      return
--- a/15
+++ b/15
@ -1,2 +1,17 @@
 #!/bin/sh
 #
 # Copyright (C) 2009 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 exec ssh -o "ControlMaster no" -o "ControlPath $REPO_SSH_SOCK" "$@"
--- a/gitc_utils.py
+++ b/gitc_utils.py
@ -0,0 +1,155 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2015 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from __future__ import print_function
 import os
 import platform
 import re
 import sys
 import time
 import git_command
 import git_config
 import wrapper
 from error import ManifestParseError
 NUM_BATCH_RETRIEVE_REVISIONID = 32
 def get_gitc_manifest_dir():
  return wrapper.Wrapper().get_gitc_manifest_dir()
 def parse_clientdir(gitc_fs_path):
  return wrapper.Wrapper().gitc_parse_clientdir(gitc_fs_path)
 def _set_project_revisions(projects):
  """Sets the revisionExpr for a list of projects.
  Because of the limit of open file descriptors allowed, length of projects
  should not be overly large. Recommend calling this function multiple times
  with each call not exceeding NUM_BATCH_RETRIEVE_REVISIONID projects.
  @param projects: List of project objects to set the revionExpr for.
  """
  # Retrieve the commit id for each project based off of it's current
  # revisionExpr and it is not already a commit id.
  project_gitcmds = [(
      project, git_command.GitCommand(None,
                                      ['ls-remote',
                                       project.remote.url,
                                       project.revisionExpr],
                                      capture_stdout=True, cwd='/tmp'))
      for project in projects if not git_config.IsId(project.revisionExpr)]
  for proj, gitcmd in project_gitcmds:
    if gitcmd.Wait():
      print('FATAL: Failed to retrieve revisionExpr for %s' % proj)
      sys.exit(1)
    revisionExpr = gitcmd.stdout.split('\t')[0]
    if not revisionExpr:
      raise ManifestParseError('Invalid SHA-1 revision project %s (%s)' %
                               (proj.remote.url, proj.revisionExpr))
    proj.revisionExpr = revisionExpr
 def _manifest_groups(manifest):
  """Returns the manifest group string that should be synced
  This is the same logic used by Command.GetProjects(), which is used during
  repo sync
  @param manifest: The XmlManifest object
  """
  mp = manifest.manifestProject
  groups = mp.config.GetString('manifest.groups')
  if not groups:
    groups = 'default,platform-' + platform.system().lower()
  return groups
 def generate_gitc_manifest(gitc_manifest, manifest, paths=None):
  """Generate a manifest for shafsd to use for this GITC client.
  @param gitc_manifest: Current gitc manifest, or None if there isn't one yet.
  @param manifest: A GitcManifest object loaded with the current repo manifest.
  @param paths: List of project paths we want to update.
  """
  print('Generating GITC Manifest by fetching revision SHAs for each '
        'project.')
  if paths is None:
    paths = list(manifest.paths.keys())
  groups = [x for x in re.split(r'[,\s]+', _manifest_groups(manifest)) if x]
  # Convert the paths to projects, and filter them to the matched groups.
  projects = [manifest.paths[p] for p in paths]
  projects = [p for p in projects if p.MatchesGroups(groups)]
  if gitc_manifest is not None:
    for path, proj in manifest.paths.items():
      if not proj.MatchesGroups(groups):
        continue
      if not proj.upstream and not git_config.IsId(proj.revisionExpr):
        proj.upstream = proj.revisionExpr
      if not path in gitc_manifest.paths:
        # Any new projects need their first revision, even if we weren't asked
        # for them.
        projects.append(proj)
      elif not path in paths:
        # And copy revisions from the previous manifest if we're not updating
        # them now.
        gitc_proj = gitc_manifest.paths[path]
        if gitc_proj.old_revision:
          proj.revisionExpr = None
          proj.old_revision = gitc_proj.old_revision
        else:
          proj.revisionExpr = gitc_proj.revisionExpr
  index = 0
  while index < len(projects):
    _set_project_revisions(
        projects[index:(index+NUM_BATCH_RETRIEVE_REVISIONID)])
    index += NUM_BATCH_RETRIEVE_REVISIONID
  if gitc_manifest is not None:
    for path, proj in gitc_manifest.paths.items():
      if proj.old_revision and path in paths:
        # If we updated a project that has been started, keep the old-revision
        # updated.
        repo_proj = manifest.paths[path]
        repo_proj.old_revision = repo_proj.revisionExpr
        repo_proj.revisionExpr = None
  # Convert URLs from relative to absolute.
  for _name, remote in manifest.remotes.items():
    remote.fetchUrl = remote.resolvedFetchUrl
  # Save the manifest.
  save_manifest(manifest)
 def save_manifest(manifest, client_dir=None):
  """Save the manifest file in the client_dir.
  @param client_dir: Client directory to save the manifest in.
  @param manifest: Manifest object to save.
  """
  if not client_dir:
    client_dir = manifest.gitc_client_dir
  with open(os.path.join(client_dir, '.manifest'), 'w') as f:
    manifest.Save(f, groups=_manifest_groups(manifest))
  # TODO(sbasi/jorg): Come up with a solution to remove the sleep below.
  # Give the GITC filesystem time to register the manifest changes.
  time.sleep(3)
--- a/hooks/commit-msg
+++ b/hooks/commit-msg
@ -1,7 +1,7 @@
 #!/bin/sh
-# From Gerrit Code Review 2.6
+# From Gerrit Code Review 2.14.6
 #
-# Part of Gerrit Code Review (http://code.google.com/p/gerrit/)
+# Part of Gerrit Code Review (https://www.gerritcodereview.com/)
 #
 # Copyright (C) 2009 The Android Open Source Project
 #
@ -20,14 +20,14 @@
 unset GREP_OPTIONS
-CHANGE_ID_AFTER="Bug|Issue"
+CHANGE_ID_AFTER="Bug|Depends-On|Issue|Test|Feature|Fixes|Fixed"
 MSG="$1"
 # Check for, and add if missing, a unique Change-Id
 #
 add_ChangeId() {
 	clean_message=`sed -e '
-		/^diff --git a\/.*/{
+		/^diff --git .*/{
 			s///
 			q
 		}
@ -39,6 +39,17 @@ add_ChangeId() {
 		return
 	fi
 	# Do not add Change-Id to temp commits
 	if echo "$clean_message" | head -1 | grep -q '^\(fixup\|squash\)!'
 	then
 		return
 	fi
 	if test "false" = "`git config --bool --get gerrit.createChangeId`"
 	then
 		return
 	fi
 	# Does Change-Id: already exist? if so, exit (no change).
 	if grep -i '^Change-Id:' "$MSG" >/dev/null
 	then
@ -53,6 +64,10 @@ add_ChangeId() {
 		AWK=/usr/xpg4/bin/awk
 	fi
 	# Get core.commentChar from git config or use default symbol
 	commentChar=`git config --get core.commentChar`
 	commentChar=${commentChar:-#}
 	# How this works:
 	# - parse the commit message as (textLine+ blankLine*)*
 	# - assume textLine+ to be a footer until proven otherwise
@ -71,13 +86,13 @@ add_ChangeId() {
 		blankLines = 0
 	}
-	# Skip lines starting with "#" without any spaces before it.
+	# Skip lines starting with commentChar without any spaces before it.
-	/^#/ { next }
+	/^'"$commentChar"'/ { next }
 	# Skip the line starting with the diff command and everything after it,
 	# up to the end of the file, assuming it is only patch data.
 	# If more than one line before the diff was empty, strip all but one.
-	/^diff --git a/ {
+	/^diff --git / {
 		blankLines = 0
 		while (getline) { }
 		next
--- a/hooks/pre-auto-gc
+++ b/hooks/pre-auto-gc
@ -1,9 +1,9 @@
 #!/bin/sh
 #
 # An example hook script to verify if you are on battery, in case you
-# are running Linux or OS X. Called by git-gc --auto with no arguments.
+# are running Windows, Linux or OS X. Called by git-gc --auto with no
-# The hook should exit with non-zero status after issuing an appropriate
+# arguments. The hook should exit with non-zero status after issuing an
-# message if it wants to stop the auto repacking.
+# appropriate message if it wants to stop the auto repacking.
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@ -19,7 +19,17 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-if test -x /sbin/on_ac_power && /sbin/on_ac_power
+if uname -s | grep -q "_NT-"
 then
 	if test -x $SYSTEMROOT/System32/Wbem/wmic
 	then
 		STATUS=$(wmic path win32_battery get batterystatus /format:list | tr -d '\r\n')
 		[ "$STATUS" = "BatteryStatus=2" ] && exit 0 || exit 1
 	fi
 	exit 0
 fi
 if test -x /sbin/on_ac_power && (/sbin/on_ac_power;test $? -ne 1)
 then
 	exit 0
 elif test "$(cat /sys/class/power_supply/AC/online 2>/dev/null)" = 1
--- a/main.py
+++ b/main.py
@ -1,4 +1,5 @@
 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -14,9 +15,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """The repo tool.
 People shouldn't run this directly; instead, they should use the `repo` wrapper
 which takes care of execing this entry point.
 """
 from __future__ import print_function
 import getpass
 import imp
 import netrc
 import optparse
 import os
@ -27,33 +33,42 @@ from pyversion import is_python3
 if is_python3():
  import urllib.request
 else:
  import imp
  import urllib2
  urllib = imp.new_module('urllib')
  urllib.request = urllib2
-from trace import SetTrace
+try:
-from git_command import git, GitCommand
+  import kerberos
 except ImportError:
  kerberos = None
 from color import SetDefaultColoring
 import event_log
 from repo_trace import SetTrace
 from git_command import git, GitCommand, user_agent
 from git_config import init_ssh, close_ssh
 from command import InteractiveCommand
 from command import MirrorSafeCommand
 from command import GitcAvailableCommand, GitcClientCommand
 from subcmds.version import Version
 from editor import Editor
 from error import DownloadError
 from error import InvalidProjectGroupsError
 from error import ManifestInvalidRevisionError
 from error import ManifestParseError
 from error import NoManifestException
 from error import NoSuchProjectError
 from error import RepoChangedException
-from manifest_xml import XmlManifest
+import gitc_utils
-from pager import RunPager
+from manifest_xml import GitcManifest, XmlManifest
 from pager import RunPager, TerminatePager
 from wrapper import WrapperPath, Wrapper
 from subcmds import all_commands
 if not is_python3():
  # pylint:disable=W0622
  input = raw_input
  # pylint:enable=W0622
 global_options = optparse.OptionParser(
                 usage="repo [-p|--paginate|--no-pager] COMMAND [ARGS]"
@ -64,15 +79,24 @@ global_options.add_option('-p', '--paginate',
 global_options.add_option('--no-pager',
                          dest='no_pager', action='store_true',
                          help='disable the pager')
 global_options.add_option('--color',
                          choices=('auto', 'always', 'never'), default=None,
                          help='control color usage: auto, always, never')
 global_options.add_option('--trace',
                          dest='trace', action='store_true',
-                          help='trace git command execution')
+                          help='trace git command execution (REPO_TRACE=1)')
 global_options.add_option('--trace-python',
                          dest='trace_python', action='store_true',
                          help='trace python command execution')
 global_options.add_option('--time',
                          dest='time', action='store_true',
                          help='time repo command execution')
 global_options.add_option('--version',
                          dest='show_version', action='store_true',
                          help='display this version of repo')
 global_options.add_option('--event-log',
                          dest='event_log', action='store',
                          help='filename of event log to append timeline to')
 class _Repo(object):
  def __init__(self, repodir):
@ -81,8 +105,8 @@ class _Repo(object):
    # add 'branch' as an alias for 'branches'
    all_commands['branch'] = all_commands['branches']
-  def _Run(self, argv):
+  def _ParseArgs(self, argv):
-    result = 0
+    """Parse the main `repo` command line options."""
    name = None
    glob = []
@ -99,6 +123,12 @@ class _Repo(object):
      argv = []
    gopts, _gargs = global_options.parse_args(glob)
    return (name, gopts, argv)
  def _Run(self, name, gopts, argv):
    """Execute the requested subcommand."""
    result = 0
    if gopts.trace:
      SetTrace()
    if gopts.show_version:
@ -108,6 +138,8 @@ class _Repo(object):
        print('fatal: invalid usage of --version', file=sys.stderr)
        return 1
    SetDefaultColoring(gopts.color)
    try:
      cmd = self.commands[name]
    except KeyError:
@ -117,6 +149,12 @@ class _Repo(object):
    cmd.repodir = self.repodir
    cmd.manifest = XmlManifest(cmd.repodir)
    cmd.gitc_manifest = None
    gitc_client_name = gitc_utils.parse_clientdir(os.getcwd())
    if gitc_client_name:
      cmd.gitc_manifest = GitcManifest(cmd.repodir, gitc_client_name)
      cmd.manifest.isGitcClient = True
    Editor.globalConfig = cmd.manifest.globalConfig
    if not isinstance(cmd, MirrorSafeCommand) and cmd.manifest.IsMirror:
@ -124,8 +162,25 @@ class _Repo(object):
            file=sys.stderr)
      return 1
    if isinstance(cmd, GitcAvailableCommand) and not gitc_utils.get_gitc_manifest_dir():
      print("fatal: '%s' requires GITC to be available" % name,
            file=sys.stderr)
      return 1
    if isinstance(cmd, GitcClientCommand) and not gitc_client_name:
      print("fatal: '%s' requires a GITC client" % name,
            file=sys.stderr)
      return 1
    try:
      copts, cargs = cmd.OptionParser.parse_args(argv)
      copts = cmd.ReadEnvironmentOptions(copts)
    except NoManifestException as e:
      print('error: in `%s`: %s' % (' '.join([name] + argv), str(e)),
        file=sys.stderr)
      print('error: manifest missing or unreadable -- please run init',
            file=sys.stderr)
      return 1
    if not gopts.no_pager and not isinstance(cmd, InteractiveCommand):
      config = cmd.manifest.globalConfig
@ -139,16 +194,17 @@ class _Repo(object):
        RunPager(config)
    start = time.time()
    cmd_event = cmd.event_log.Add(name, event_log.TASK_COMMAND, start)
    cmd.event_log.SetParent(cmd_event)
    try:
      cmd.ValidateOptions(copts, cargs)
      result = cmd.Execute(copts, cargs)
-    except DownloadError as e:
+    except (DownloadError, ManifestInvalidRevisionError,
-      print('error: %s' % str(e), file=sys.stderr)
+        NoManifestException) as e:
-      result = 1
+      print('error: in `%s`: %s' % (' '.join([name] + argv), str(e)),
-    except ManifestInvalidRevisionError as e:
+        file=sys.stderr)
-      print('error: %s' % str(e), file=sys.stderr)
+      if isinstance(e, NoManifestException):
-      result = 1
+        print('error: manifest missing or unreadable -- please run init',
    except NoManifestException as e:
      print('error: manifest required for this command -- please run init',
              file=sys.stderr)
      result = 1
    except NoSuchProjectError as e:
@ -157,8 +213,19 @@ class _Repo(object):
      else:
        print('error: no project in current directory', file=sys.stderr)
      result = 1
    except InvalidProjectGroupsError as e:
      if e.name:
        print('error: project group must be enabled for project %s' % e.name, file=sys.stderr)
      else:
        print('error: project group must be enabled for the project in the current directory', file=sys.stderr)
      result = 1
    except SystemExit as e:
      if e.code:
        result = e.code
      raise
    finally:
-      elapsed = time.time() - start
+      finish = time.time()
      elapsed = finish - start
      hours, remainder = divmod(elapsed, 3600)
      minutes, seconds = divmod(remainder, 60)
      if gopts.time:
@ -168,13 +235,15 @@ class _Repo(object):
          print('real\t%dh%dm%.3fs' % (hours, minutes, seconds),
                file=sys.stderr)
      cmd.event_log.FinishEvent(cmd_event, finish,
                                result is None or result == 0)
      if gopts.event_log:
        cmd.event_log.Write(os.path.abspath(
                            os.path.expanduser(gopts.event_log)))
    return result
 def _MyRepoPath():
  return os.path.dirname(__file__)
 def _CheckWrapperVersion(ver, repo_path):
  if not repo_path:
    repo_path = '~/bin/repo'
@ -226,51 +295,13 @@ def _PruneOptions(argv, opt):
      continue
    i += 1
 _user_agent = None
 def _UserAgent():
  global _user_agent
  if _user_agent is None:
    py_version = sys.version_info
    os_name = sys.platform
    if os_name == 'linux2':
      os_name = 'Linux'
    elif os_name == 'win32':
      os_name = 'Win32'
    elif os_name == 'cygwin':
      os_name = 'Cygwin'
    elif os_name == 'darwin':
      os_name = 'Darwin'
    p = GitCommand(
      None, ['describe', 'HEAD'],
      cwd = _MyRepoPath(),
      capture_stdout = True)
    if p.Wait() == 0:
      repo_version = p.stdout
      if len(repo_version) > 0 and repo_version[-1] == '\n':
        repo_version = repo_version[0:-1]
      if len(repo_version) > 0 and repo_version[0] == 'v':
        repo_version = repo_version[1:]
    else:
      repo_version = 'unknown'
    _user_agent = 'git-repo/%s (%s) git/%s Python/%d.%d.%d' % (
      repo_version,
      os_name,
      '.'.join(map(str, git.version_tuple())),
      py_version[0], py_version[1], py_version[2])
  return _user_agent
 class _UserAgentHandler(urllib.request.BaseHandler):
  def http_request(self, req):
-    req.add_header('User-Agent', _UserAgent())
+    req.add_header('User-Agent', user_agent.repo)
    return req
  def https_request(self, req):
-    req.add_header('User-Agent', _UserAgent())
+    req.add_header('User-Agent', user_agent.repo)
    return req
 def _AddPasswordFromUserInput(handler, msg, req):
@ -332,6 +363,86 @@ class _DigestAuthHandler(urllib.request.HTTPDigestAuthHandler):
        self.retried = 0
      raise
 class _KerberosAuthHandler(urllib.request.BaseHandler):
  def __init__(self):
    self.retried = 0
    self.context = None
    self.handler_order = urllib.request.BaseHandler.handler_order - 50
  def http_error_401(self, req, fp, code, msg, headers):
    host = req.get_host()
    retry = self.http_error_auth_reqed('www-authenticate', host, req, headers)
    return retry
  def http_error_auth_reqed(self, auth_header, host, req, headers):
    try:
      spn = "HTTP@%s" % host
      authdata = self._negotiate_get_authdata(auth_header, headers)
      if self.retried > 3:
        raise urllib.request.HTTPError(req.get_full_url(), 401,
          "Negotiate auth failed", headers, None)
      else:
        self.retried += 1
      neghdr = self._negotiate_get_svctk(spn, authdata)
      if neghdr is None:
        return None
      req.add_unredirected_header('Authorization', neghdr)
      response = self.parent.open(req)
      srvauth = self._negotiate_get_authdata(auth_header, response.info())
      if self._validate_response(srvauth):
        return response
    except kerberos.GSSError:
      return None
    except:
      self.reset_retry_count()
      raise
    finally:
      self._clean_context()
  def reset_retry_count(self):
    self.retried = 0
  def _negotiate_get_authdata(self, auth_header, headers):
    authhdr = headers.get(auth_header, None)
    if authhdr is not None:
      for mech_tuple in authhdr.split(","):
        mech, __, authdata = mech_tuple.strip().partition(" ")
        if mech.lower() == "negotiate":
          return authdata.strip()
    return None
  def _negotiate_get_svctk(self, spn, authdata):
    if authdata is None:
      return None
    result, self.context = kerberos.authGSSClientInit(spn)
    if result < kerberos.AUTH_GSS_COMPLETE:
      return None
    result = kerberos.authGSSClientStep(self.context, authdata)
    if result < kerberos.AUTH_GSS_CONTINUE:
      return None
    response = kerberos.authGSSClientResponse(self.context)
    return "Negotiate %s" % response
  def _validate_response(self, authdata):
    if authdata is None:
      return None
    result = kerberos.authGSSClientStep(self.context, authdata)
    if result == kerberos.AUTH_GSS_COMPLETE:
      return True
    return None
  def _clean_context(self):
    if self.context is not None:
      kerberos.authGSSClientClean(self.context)
      self.context = None
 def init_http():
  handlers = [_UserAgentHandler()]
@ -348,6 +459,8 @@ def init_http():
    pass
  handlers.append(_BasicAuthHandler(mgr))
  handlers.append(_DigestAuthHandler(mgr))
  if kerberos:
    handlers.append(_KerberosAuthHandler())
  if 'http_proxy' in os.environ:
    url = os.environ['http_proxy']
@ -381,7 +494,15 @@ def _Main(argv):
    try:
      init_ssh()
      init_http()
-      result = repo._Run(argv) or 0
+      name, gopts, argv = repo._ParseArgs(argv)
      run = lambda: repo._Run(name, gopts, argv) or 0
      if gopts.trace_python:
        import trace
        tracer = trace.Trace(count=False, trace=True, timing=True,
                             ignoredirs=set(sys.path[1:]))
        result = tracer.runfunc(run)
      else:
        result = run()
    finally:
      close_ssh()
  except KeyboardInterrupt:
@ -402,6 +523,7 @@ def _Main(argv):
      print('fatal: %s' % e, file=sys.stderr)
      result = 128
  TerminatePager()
  sys.exit(result)
 if __name__ == '__main__':
--- a/manifest_xml.py
+++ b/manifest_xml.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -29,27 +30,42 @@ else:
  urllib = imp.new_module('urllib')
  urllib.parse = urlparse
 import gitc_utils
 from git_config import GitConfig
 from git_refs import R_HEADS, HEAD
 import platform_utils
 from project import RemoteSpec, Project, MetaProject
-from error import ManifestParseError
+from error import ManifestParseError, ManifestInvalidRevisionError
 MANIFEST_FILE_NAME = 'manifest.xml'
 LOCAL_MANIFEST_NAME = 'local_manifest.xml'
 LOCAL_MANIFESTS_DIR_NAME = 'local_manifests'
-urllib.parse.uses_relative.extend(['ssh', 'git'])
+# urljoin gets confused if the scheme is not known.
-urllib.parse.uses_netloc.extend(['ssh', 'git'])
+urllib.parse.uses_relative.extend([
    'ssh',
    'git',
    'persistent-https',
    'sso',
    'rpc'])
 urllib.parse.uses_netloc.extend([
    'ssh',
    'git',
    'persistent-https',
    'sso',
    'rpc'])
 class _Default(object):
  """Project defaults within the manifest."""
  revisionExpr = None
  destBranchExpr = None
  upstreamExpr = None
  remote = None
  sync_j = 1
  sync_c = False
  sync_s = False
  sync_tags = True
  def __eq__(self, other):
    return self.__dict__ == other.__dict__
@ -62,13 +78,17 @@ class _XmlRemote(object):
               name,
               alias=None,
               fetch=None,
               pushUrl=None,
               manifestUrl=None,
-               review=None):
+               review=None,
               revision=None):
    self.name = name
    self.fetchUrl = fetch
    self.pushUrl = pushUrl
    self.manifestUrl = manifestUrl
    self.remoteAlias = alias
    self.reviewUrl = review
    self.revision = revision
    self.resolvedFetchUrl = self._resolveFetchUrl()
  def __eq__(self, other):
@ -80,26 +100,31 @@ class _XmlRemote(object):
  def _resolveFetchUrl(self):
    url = self.fetchUrl.rstrip('/')
    manifestUrl = self.manifestUrl.rstrip('/')
-    p = manifestUrl.startswith('persistent-http')
+    # urljoin will gets confused over quite a few things.  The ones we care
-    if p:
+    # about here are:
-      manifestUrl = manifestUrl[len('persistent-'):]
+    # * no scheme in the base url, like <hostname:port>
    # We handle no scheme by replacing it with an obscure protocol, gopher
    # and then replacing it with the original when we are done.
    # urljoin will get confused if there is no scheme in the base url
    # ie, if manifestUrl is of the form <hostname:port>
    if manifestUrl.find(':') != manifestUrl.find('/') - 1:
-      manifestUrl = 'gopher://' + manifestUrl
+      url = urllib.parse.urljoin('gopher://' + manifestUrl, url)
    url = urllib.parse.urljoin(manifestUrl, url)
      url = re.sub(r'^gopher://', '', url)
-    if p:
+    else:
-      url = 'persistent-' + url
+      url = urllib.parse.urljoin(manifestUrl, url)
    return url
  def ToRemoteSpec(self, projectName):
-    url = self.resolvedFetchUrl.rstrip('/') + '/' + projectName
+    fetchUrl = self.resolvedFetchUrl.rstrip('/')
    url = fetchUrl + '/' + projectName
    remoteName = self.name
    if self.remoteAlias:
      remoteName = self.remoteAlias
-    return RemoteSpec(remoteName, url, self.reviewUrl)
+    return RemoteSpec(remoteName,
                      url=url,
                      pushUrl=self.pushUrl,
                      review=self.reviewUrl,
                      orig_name=self.name,
                      fetchUrl=self.fetchUrl)
 class XmlManifest(object):
  """manages the repo configuration file"""
@ -110,6 +135,8 @@ class XmlManifest(object):
    self.manifestFile = os.path.join(self.repodir, MANIFEST_FILE_NAME)
    self.globalConfig = GitConfig.ForUser()
    self.localManifestWarning = False
    self.isGitcClient = False
    self._load_local_manifests = True
    self.repoProject = MetaProject(self, 'repo',
      gitdir   = os.path.join(repodir, 'repo/.git'),
@ -121,15 +148,26 @@ class XmlManifest(object):
    self._Unload()
-  def Override(self, name):
+  def Override(self, name, load_local_manifests=True):
    """Use a different manifest, just for the current instantiation.
    """
    path = None
    # Look for a manifest by path in the filesystem (including the cwd).
    if not load_local_manifests:
      local_path = os.path.abspath(name)
      if os.path.isfile(local_path):
        path = local_path
    # Look for manifests by name from the manifests repo.
    if path is None:
      path = os.path.join(self.manifestProject.worktree, name)
      if not os.path.isfile(path):
        raise ManifestParseError('manifest %s not found' % name)
    old = self.manifestFile
    try:
      self._load_local_manifests = load_local_manifests
      self.manifestFile = path
      self._Unload()
      self._Load()
@ -143,8 +181,8 @@ class XmlManifest(object):
    try:
      if os.path.lexists(self.manifestFile):
-        os.remove(self.manifestFile)
+        platform_utils.remove(self.manifestFile)
-      os.symlink('manifests/%s' % name, self.manifestFile)
+      platform_utils.symlink(os.path.join('manifests', name), self.manifestFile)
    except OSError as e:
      raise ManifestParseError('cannot link manifest %s: %s' % (name, str(e)))
@ -153,19 +191,27 @@ class XmlManifest(object):
    root.appendChild(e)
    e.setAttribute('name', r.name)
    e.setAttribute('fetch', r.fetchUrl)
    if r.pushUrl is not None:
      e.setAttribute('pushurl', r.pushUrl)
    if r.remoteAlias is not None:
      e.setAttribute('alias', r.remoteAlias)
    if r.reviewUrl is not None:
      e.setAttribute('review', r.reviewUrl)
    if r.revision is not None:
      e.setAttribute('revision', r.revision)
-  def Save(self, fd, peg_rev=False, peg_rev_upstream=True):
+  def _ParseGroups(self, groups):
    return [x for x in re.split(r'[,\s]+', groups) if x]
  def Save(self, fd, peg_rev=False, peg_rev_upstream=True, groups=None):
    """Write the current manifest out to the given file descriptor.
    """
    mp = self.manifestProject
    if groups is None:
      groups = mp.config.GetString('manifest.groups')
    if groups:
-      groups = [x for x in re.split(r'[,\s]+', groups) if x]
+      groups = self._ParseGroups(groups)
    doc = xml.dom.minidom.Document()
    root = doc.createElement('manifest')
@ -195,6 +241,12 @@ class XmlManifest(object):
    if d.revisionExpr:
      have_default = True
      e.setAttribute('revision', d.revisionExpr)
    if d.destBranchExpr:
      have_default = True
      e.setAttribute('dest-branch', d.destBranchExpr)
    if d.upstreamExpr:
      have_default = True
      e.setAttribute('upstream', d.upstreamExpr)
    if d.sync_j > 1:
      have_default = True
      e.setAttribute('sync-j', '%d' % d.sync_j)
@ -204,6 +256,9 @@ class XmlManifest(object):
    if d.sync_s:
      have_default = True
      e.setAttribute('sync-s', 'true')
    if not d.sync_tags:
      have_default = True
      e.setAttribute('sync-tags', 'false')
    if have_default:
      root.appendChild(e)
      root.appendChild(doc.createTextNode(''))
@ -236,22 +291,33 @@ class XmlManifest(object):
        e.setAttribute('path', relpath)
      remoteName = None
      if d.remote:
-        remoteName = d.remote.remoteAlias or d.remote.name
+        remoteName = d.remote.name
-      if not d.remote or p.remote.name != remoteName:
+      if not d.remote or p.remote.orig_name != remoteName:
-        e.setAttribute('remote', p.remote.name)
+        remoteName = p.remote.orig_name
        e.setAttribute('remote', remoteName)
      if peg_rev:
        if self.IsMirror:
          value = p.bare_git.rev_parse(p.revisionExpr + '^0')
        else:
          value = p.work_git.rev_parse(HEAD + '^0')
        e.setAttribute('revision', value)
-        if peg_rev_upstream and value != p.revisionExpr:
+        if peg_rev_upstream:
          if p.upstream:
            e.setAttribute('upstream', p.upstream)
          elif value != p.revisionExpr:
            # Only save the origin if the origin is not a sha1, and the default
-          # isn't our value, and the if the default doesn't already have that
+            # isn't our value
          # covered.
            e.setAttribute('upstream', p.revisionExpr)
-      elif not d.revisionExpr or p.revisionExpr != d.revisionExpr:
+      else:
        revision = self.remotes[p.remote.orig_name].revision or d.revisionExpr
        if not revision or revision != p.revisionExpr:
          e.setAttribute('revision', p.revisionExpr)
        if (p.upstream and (p.upstream != p.revisionExpr or
                            p.upstream != d.upstreamExpr)):
          e.setAttribute('upstream', p.upstream)
      if p.dest_branch and p.dest_branch != d.destBranchExpr:
        e.setAttribute('dest-branch', p.dest_branch)
      for c in p.copyfiles:
        ce = doc.createElement('copyfile')
@ -259,6 +325,12 @@ class XmlManifest(object):
        ce.setAttribute('dest', c.dest)
        e.appendChild(ce)
      for l in p.linkfiles:
        le = doc.createElement('linkfile')
        le.setAttribute('src', l.src)
        le.setAttribute('dest', l.dest)
        e.appendChild(le)
      default_groups = ['all', 'name:%s' % p.name, 'path:%s' % p.relpath]
      egroups = [g for g in p.groups if g not in default_groups]
      if egroups:
@ -277,6 +349,14 @@ class XmlManifest(object):
      if p.sync_s:
        e.setAttribute('sync-s', 'true')
      if not p.sync_tags:
        e.setAttribute('sync-tags', 'false')
      if p.clone_depth:
        e.setAttribute('clone-depth', str(p.clone_depth))
      self._output_manifest_project_extras(p, e)
      if p.subprojects:
        subprojects = set(subp.name for subp in p.subprojects)
        output_projects(p, e, list(sorted(subprojects)))
@ -294,6 +374,10 @@ class XmlManifest(object):
    doc.writexml(fd, '', '  ', '\n', 'UTF-8')
  def _output_manifest_project_extras(self, p, e):
    """Manifests can modify e if they support extra project attributes."""
    pass
  @property
  def paths(self):
    self._Load()
@ -302,7 +386,7 @@ class XmlManifest(object):
  @property
  def projects(self):
    self._Load()
-    return self._paths.values()
+    return list(self._paths.values())
  @property
  def remotes(self):
@ -329,6 +413,12 @@ class XmlManifest(object):
    self._Load()
    return self._manifest_server
  @property
  def CloneFilter(self):
    if self.manifestProject.config.GetBoolean('repo.partialclone'):
      return self.manifestProject.config.GetString('repo.clonefilter')
    return None
  @property
  def IsMirror(self):
    return self.manifestProject.config.GetBoolean('repo.mirror')
@ -337,6 +427,10 @@ class XmlManifest(object):
  def IsArchive(self):
    return self.manifestProject.config.GetBoolean('repo.archive')
  @property
  def HasSubmodules(self):
    return self.manifestProject.config.GetBoolean('repo.submodules')
  def _Unload(self):
    self._loaded = False
    self._projects = {}
@ -360,18 +454,21 @@ class XmlManifest(object):
      nodes.append(self._ParseManifestXml(self.manifestFile,
                                          self.manifestProject.worktree))
      if self._load_local_manifests:
        local = os.path.join(self.repodir, LOCAL_MANIFEST_NAME)
        if os.path.exists(local):
          if not self.localManifestWarning:
            self.localManifestWarning = True
-          print('warning: %s is deprecated; put local manifests in `%s` instead'
+            print('warning: %s is deprecated; put local manifests '
-                % (LOCAL_MANIFEST_NAME, os.path.join(self.repodir, LOCAL_MANIFESTS_DIR_NAME)),
+                  'in `%s` instead' % (LOCAL_MANIFEST_NAME,
                  os.path.join(self.repodir, LOCAL_MANIFESTS_DIR_NAME)),
                  file=sys.stderr)
          nodes.append(self._ParseManifestXml(local, self.repodir))
-      local_dir = os.path.abspath(os.path.join(self.repodir, LOCAL_MANIFESTS_DIR_NAME))
+        local_dir = os.path.abspath(os.path.join(self.repodir,
                                    LOCAL_MANIFESTS_DIR_NAME))
        try:
-        for local_file in sorted(os.listdir(local_dir)):
+          for local_file in sorted(platform_utils.listdir(local_dir)):
            if local_file.endswith('.xml'):
              local = os.path.join(local_dir, local_file)
              nodes.append(self._ParseManifestXml(local, self.repodir))
@ -408,8 +505,7 @@ class XmlManifest(object):
      raise ManifestParseError("no <manifest> in %s" % (path,))
    nodes = []
-    for node in manifest.childNodes:  # pylint:disable=W0631
+    for node in manifest.childNodes:
                                      # We only get here if manifest is initialised
      if node.nodeName == 'include':
        name = self._reqatt(node, 'name')
        fp = os.path.join(include_root, name)
@ -424,7 +520,7 @@ class XmlManifest(object):
          raise
        except Exception as e:
          raise ManifestParseError(
-              "failed parsing included manifest %s: %s", (name, e))
+              "failed parsing included manifest %s: %s" % (name, e))
      else:
        nodes.append(node)
    return nodes
@ -490,6 +586,26 @@ class XmlManifest(object):
      if node.nodeName == 'project':
        project = self._ParseProject(node)
        recursively_add_projects(project)
      if node.nodeName == 'extend-project':
        name = self._reqatt(node, 'name')
        if name not in self._projects:
          raise ManifestParseError('extend-project element specifies non-existent '
                                   'project: %s' % name)
        path = node.getAttribute('path')
        groups = node.getAttribute('groups')
        if groups:
          groups = self._ParseGroups(groups)
        revision = node.getAttribute('revision')
        for p in self._projects[name]:
          if path and p.relpath != path:
            continue
          if groups:
            p.groups.extend(groups)
          if revision:
            p.revisionExpr = revision
      if node.nodeName == 'repo-hooks':
        # Get the name of the project and the (space-separated) list of enabled.
        repo_hooks_project = self._reqatt(node, 'in-project')
@ -566,10 +682,11 @@ class XmlManifest(object):
                        gitdir = gitdir,
                        objdir = gitdir,
                        worktree = None,
-                        relpath = None,
+                        relpath = name or None,
                        revisionExpr = m.revisionExpr,
                        revisionId = None)
      self._projects[project.name] = [project]
      self._paths[project.relpath] = project
  def _ParseRemote(self, node):
    """
@ -580,11 +697,17 @@ class XmlManifest(object):
    if alias == '':
      alias = None
    fetch = self._reqatt(node, 'fetch')
    pushUrl = node.getAttribute('pushurl')
    if pushUrl == '':
      pushUrl = None
    review = node.getAttribute('review')
    if review == '':
      review = None
    revision = node.getAttribute('revision')
    if revision == '':
      revision = None
    manifestUrl = self.manifestProject.config.GetString('remote.origin.url')
-    return _XmlRemote(name, alias, fetch, manifestUrl, review)
+    return _XmlRemote(name, alias, fetch, pushUrl, manifestUrl, review, revision)
  def _ParseDefault(self, node):
    """
@ -597,6 +720,7 @@ class XmlManifest(object):
      d.revisionExpr = None
    d.destBranchExpr = node.getAttribute('dest-branch') or None
    d.upstreamExpr = node.getAttribute('upstream') or None
    sync_j = node.getAttribute('sync-j')
    if sync_j == '' or sync_j is None:
@ -615,6 +739,12 @@ class XmlManifest(object):
      d.sync_s = False
    else:
      d.sync_s = sync_s.lower() in ("yes", "true", "1")
    sync_tags = node.getAttribute('sync-tags')
    if not sync_tags:
      d.sync_tags = True
    else:
      d.sync_tags = sync_tags.lower() in ("yes", "true", "1")
    return d
  def _ParseNotice(self, node):
@ -662,7 +792,7 @@ class XmlManifest(object):
  def _UnjoinName(self, parent_name, name):
    return os.path.relpath(name, parent_name)
-  def _ParseProject(self, node, parent = None):
+  def _ParseProject(self, node, parent = None, **extra_proj_attrs):
    """
    reads a <project> element from the manifest file
    """
@ -677,7 +807,7 @@ class XmlManifest(object):
      raise ManifestParseError("no remote for project %s within %s" %
            (name, self.manifestFile))
-    revisionExpr = node.getAttribute('revision')
+    revisionExpr = node.getAttribute('revision') or remote.revision
    if not revisionExpr:
      revisionExpr = self._default.revisionExpr
    if not revisionExpr:
@ -709,6 +839,12 @@ class XmlManifest(object):
    else:
      sync_s = sync_s.lower() in ("yes", "true", "1")
    sync_tags = node.getAttribute('sync-tags')
    if not sync_tags:
      sync_tags = self._default.sync_tags
    else:
      sync_tags = sync_tags.lower() in ("yes", "true", "1")
    clone_depth = node.getAttribute('clone-depth')
    if clone_depth:
      try:
@ -721,12 +857,12 @@ class XmlManifest(object):
    dest_branch = node.getAttribute('dest-branch') or self._default.destBranchExpr
-    upstream = node.getAttribute('upstream')
+    upstream = node.getAttribute('upstream') or self._default.upstreamExpr
    groups = ''
    if node.hasAttribute('groups'):
      groups = node.getAttribute('groups')
-    groups = [x for x in re.split(r'[,\s]+', groups) if x]
+    groups = self._ParseGroups(groups)
    if parent is None:
      relpath, worktree, gitdir, objdir = self.GetProjectPaths(name, path)
@ -754,14 +890,18 @@ class XmlManifest(object):
                      groups = groups,
                      sync_c = sync_c,
                      sync_s = sync_s,
                      sync_tags = sync_tags,
                      clone_depth = clone_depth,
                      upstream = upstream,
                      parent = parent,
-                      dest_branch = dest_branch)
+                      dest_branch = dest_branch,
                      **extra_proj_attrs)
    for n in node.childNodes:
      if n.nodeName == 'copyfile':
        self._ParseCopyFile(project, n)
      if n.nodeName == 'linkfile':
        self._ParseLinkFile(project, n)
      if n.nodeName == 'annotation':
        self._ParseAnnotation(project, n)
      if n.nodeName == 'project':
@ -811,6 +951,14 @@ class XmlManifest(object):
      # dest is relative to the top of the tree
      project.AddCopyFile(src, dest, os.path.join(self.topdir, dest))
  def _ParseLinkFile(self, project, node):
    src = self._reqatt(node, 'src')
    dest = self._reqatt(node, 'dest')
    if not self.IsMirror:
      # src is project relative;
      # dest is relative to the top of the tree
      project.AddLinkFile(src, dest, os.path.join(self.topdir, dest))
  def _ParseAnnotation(self, project, node):
    name = self._reqatt(node, 'name')
    value = self._reqatt(node, 'value')
@ -843,3 +991,61 @@ class XmlManifest(object):
      raise ManifestParseError("no %s in <%s> within %s" %
            (attname, node.nodeName, self.manifestFile))
    return v
  def projectsDiff(self, manifest):
    """return the projects differences between two manifests.
    The diff will be from self to given manifest.
    """
    fromProjects = self.paths
    toProjects = manifest.paths
    fromKeys = sorted(fromProjects.keys())
    toKeys = sorted(toProjects.keys())
    diff = {'added': [], 'removed': [], 'changed': [], 'unreachable': []}
    for proj in fromKeys:
      if not proj in toKeys:
        diff['removed'].append(fromProjects[proj])
      else:
        fromProj = fromProjects[proj]
        toProj = toProjects[proj]
        try:
          fromRevId = fromProj.GetCommitRevisionId()
          toRevId = toProj.GetCommitRevisionId()
        except ManifestInvalidRevisionError:
          diff['unreachable'].append((fromProj, toProj))
        else:
          if fromRevId != toRevId:
            diff['changed'].append((fromProj, toProj))
        toKeys.remove(proj)
    for proj in toKeys:
      diff['added'].append(toProjects[proj])
    return diff
 class GitcManifest(XmlManifest):
  def __init__(self, repodir, gitc_client_name):
    """Initialize the GitcManifest object."""
    super(GitcManifest, self).__init__(repodir)
    self.isGitcClient = True
    self.gitc_client_name = gitc_client_name
    self.gitc_client_dir = os.path.join(gitc_utils.get_gitc_manifest_dir(),
                                        gitc_client_name)
    self.manifestFile = os.path.join(self.gitc_client_dir, '.manifest')
  def _ParseProject(self, node, parent = None):
    """Override _ParseProject and add support for GITC specific attributes."""
    return super(GitcManifest, self)._ParseProject(
        node, parent=parent, old_revision=node.getAttribute('old-revision'))
  def _output_manifest_project_extras(self, p, e):
    """Output GITC Specific Project attributes"""
    if p.old_revision:
      e.setAttribute('old-revision', str(p.old_revision))
--- a/pager.py
+++ b/pager.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -16,19 +17,53 @@
 from __future__ import print_function
 import os
 import select
 import subprocess
 import sys
 import platform_utils
 active = False
 pager_process = None
 old_stdout = None
 old_stderr = None
 def RunPager(globalConfig):
  global active
  if not os.isatty(0) or not os.isatty(1):
    return
  pager = _SelectPager(globalConfig)
  if pager == '' or pager == 'cat':
    return
  if platform_utils.isWindows():
    _PipePager(pager);
  else:
    _ForkPager(pager)
 def TerminatePager():
  global pager_process, old_stdout, old_stderr
  if pager_process:
    sys.stdout.flush()
    sys.stderr.flush()
    pager_process.stdin.close()
    pager_process.wait();
    pager_process = None
    # Restore initial stdout/err in case there is more output in this process
    # after shutting down the pager process
    sys.stdout = old_stdout
    sys.stderr = old_stderr
 def _PipePager(pager):
  global pager_process, old_stdout, old_stderr
  assert pager_process is None, "Only one active pager process at a time"
  # Create pager process, piping stdout/err into its stdin
  pager_process = subprocess.Popen([pager], stdin=subprocess.PIPE, stdout=sys.stdout, stderr=sys.stderr)
  old_stdout = sys.stdout
  old_stderr = sys.stderr
  sys.stdout = pager_process.stdin
  sys.stderr = pager_process.stdin
 def _ForkPager(pager):
  global active
  # This process turns into the pager; a child it forks will
  # do the real processing and output back to the pager. This
  # is necessary to keep the pager in control of the tty.
--- a/platform_utils.py
+++ b/platform_utils.py
@ -0,0 +1,415 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2016 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import errno
 import os
 import platform
 import select
 import shutil
 import stat
 from pyversion import is_python3
 if is_python3():
  from queue import Queue
 else:
  from Queue import Queue
 from threading import Thread
 def isWindows():
  """ Returns True when running with the native port of Python for Windows,
  False when running on any other platform (including the Cygwin port of
  Python).
  """
  # Note: The cygwin port of Python returns "CYGWIN_NT_xxx"
  return platform.system() == "Windows"
 class FileDescriptorStreams(object):
  """ Platform agnostic abstraction enabling non-blocking I/O over a
  collection of file descriptors. This abstraction is required because
  fctnl(os.O_NONBLOCK) is not supported on Windows.
  """
  @classmethod
  def create(cls):
    """ Factory method: instantiates the concrete class according to the
    current platform.
    """
    if isWindows():
      return _FileDescriptorStreamsThreads()
    else:
      return _FileDescriptorStreamsNonBlocking()
  def __init__(self):
    self.streams = []
  def add(self, fd, dest, std_name):
    """ Wraps an existing file descriptor as a stream.
    """
    self.streams.append(self._create_stream(fd, dest, std_name))
  def remove(self, stream):
    """ Removes a stream, when done with it.
    """
    self.streams.remove(stream)
  @property
  def is_done(self):
    """ Returns True when all streams have been processed.
    """
    return len(self.streams) == 0
  def select(self):
    """ Returns the set of streams that have data available to read.
    The returned streams each expose a read() and a close() method.
    When done with a stream, call the remove(stream) method.
    """
    raise NotImplementedError
  def _create_stream(fd, dest, std_name):
    """ Creates a new stream wrapping an existing file descriptor.
    """
    raise NotImplementedError
 class _FileDescriptorStreamsNonBlocking(FileDescriptorStreams):
  """ Implementation of FileDescriptorStreams for platforms that support
  non blocking I/O.
  """
  class Stream(object):
    """ Encapsulates a file descriptor """
    def __init__(self, fd, dest, std_name):
      self.fd = fd
      self.dest = dest
      self.std_name = std_name
      self.set_non_blocking()
    def set_non_blocking(self):
      import fcntl
      flags = fcntl.fcntl(self.fd, fcntl.F_GETFL)
      fcntl.fcntl(self.fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
    def fileno(self):
      return self.fd.fileno()
    def read(self):
      return self.fd.read(4096)
    def close(self):
      self.fd.close()
  def _create_stream(self, fd, dest, std_name):
    return self.Stream(fd, dest, std_name)
  def select(self):
    ready_streams, _, _ = select.select(self.streams, [], [])
    return ready_streams
 class _FileDescriptorStreamsThreads(FileDescriptorStreams):
  """ Implementation of FileDescriptorStreams for platforms that don't support
  non blocking I/O. This implementation requires creating threads issuing
  blocking read operations on file descriptors.
  """
  def __init__(self):
    super(_FileDescriptorStreamsThreads, self).__init__()
    # The queue is shared accross all threads so we can simulate the
    # behavior of the select() function
    self.queue = Queue(10)  # Limit incoming data from streams
  def _create_stream(self, fd, dest, std_name):
    return self.Stream(fd, dest, std_name, self.queue)
  def select(self):
    # Return only one stream at a time, as it is the most straighforward
    # thing to do and it is compatible with the select() function.
    item = self.queue.get()
    stream = item.stream
    stream.data = item.data
    return [stream]
  class QueueItem(object):
    """ Item put in the shared queue """
    def __init__(self, stream, data):
      self.stream = stream
      self.data = data
  class Stream(object):
    """ Encapsulates a file descriptor """
    def __init__(self, fd, dest, std_name, queue):
      self.fd = fd
      self.dest = dest
      self.std_name = std_name
      self.queue = queue
      self.data = None
      self.thread = Thread(target=self.read_to_queue)
      self.thread.daemon = True
      self.thread.start()
    def close(self):
      self.fd.close()
    def read(self):
      data = self.data
      self.data = None
      return data
    def read_to_queue(self):
      """ The thread function: reads everything from the file descriptor into
      the shared queue and terminates when reaching EOF.
      """
      for line in iter(self.fd.readline, b''):
        self.queue.put(_FileDescriptorStreamsThreads.QueueItem(self, line))
      self.fd.close()
      self.queue.put(_FileDescriptorStreamsThreads.QueueItem(self, None))
 def symlink(source, link_name):
  """Creates a symbolic link pointing to source named link_name.
  Note: On Windows, source must exist on disk, as the implementation needs
  to know whether to create a "File" or a "Directory" symbolic link.
  """
  if isWindows():
    import platform_utils_win32
    source = _validate_winpath(source)
    link_name = _validate_winpath(link_name)
    target = os.path.join(os.path.dirname(link_name), source)
    if isdir(target):
      platform_utils_win32.create_dirsymlink(_makelongpath(source), link_name)
    else:
      platform_utils_win32.create_filesymlink(_makelongpath(source), link_name)
  else:
    return os.symlink(source, link_name)
 def _validate_winpath(path):
  path = os.path.normpath(path)
  if _winpath_is_valid(path):
    return path
  raise ValueError("Path \"%s\" must be a relative path or an absolute "
                   "path starting with a drive letter".format(path))
 def _winpath_is_valid(path):
  """Windows only: returns True if path is relative (e.g. ".\\foo") or is
  absolute including a drive letter (e.g. "c:\\foo"). Returns False if path
  is ambiguous (e.g. "x:foo" or "\\foo").
  """
  assert isWindows()
  path = os.path.normpath(path)
  drive, tail = os.path.splitdrive(path)
  if tail:
    if not drive:
      return tail[0] != os.sep  # "\\foo" is invalid
    else:
      return tail[0] == os.sep  # "x:foo" is invalid
  else:
    return not drive  # "x:" is invalid
 def _makelongpath(path):
  """Return the input path normalized to support the Windows long path syntax
  ("\\\\?\\" prefix) if needed, i.e. if the input path is longer than the
  MAX_PATH limit.
  """
  if isWindows():
    # Note: MAX_PATH is 260, but, for directories, the maximum value is actually 246.
    if len(path) < 246:
      return path
    if path.startswith(u"\\\\?\\"):
      return path
    if not os.path.isabs(path):
      return path
    # Append prefix and ensure unicode so that the special longpath syntax
    # is supported by underlying Win32 API calls
    return u"\\\\?\\" + os.path.normpath(path)
  else:
    return path
 def rmtree(path):
  """shutil.rmtree(path) wrapper with support for long paths on Windows.
  Availability: Unix, Windows."""
  if isWindows():
    shutil.rmtree(_makelongpath(path), onerror=handle_rmtree_error)
  else:
    shutil.rmtree(path)
 def handle_rmtree_error(function, path, excinfo):
  # Allow deleting read-only files
  os.chmod(path, stat.S_IWRITE)
  function(path)
 def rename(src, dst):
  """os.rename(src, dst) wrapper with support for long paths on Windows.
  Availability: Unix, Windows."""
  if isWindows():
    # On Windows, rename fails if destination exists, see
    # https://docs.python.org/2/library/os.html#os.rename
    try:
      os.rename(_makelongpath(src), _makelongpath(dst))
    except OSError as e:
      if e.errno == errno.EEXIST:
        os.remove(_makelongpath(dst))
        os.rename(_makelongpath(src), _makelongpath(dst))
      else:
        raise
  else:
    os.rename(src, dst)
 def remove(path):
  """Remove (delete) the file path. This is a replacement for os.remove that
  allows deleting read-only files on Windows, with support for long paths and
  for deleting directory symbolic links.
  Availability: Unix, Windows."""
  if isWindows():
    longpath = _makelongpath(path)
    try:
      os.remove(longpath)
    except OSError as e:
      if e.errno == errno.EACCES:
        os.chmod(longpath, stat.S_IWRITE)
        # Directory symbolic links must be deleted with 'rmdir'.
        if islink(longpath) and isdir(longpath):
          os.rmdir(longpath)
        else:
          os.remove(longpath)
      else:
        raise
  else:
    os.remove(path)
 def walk(top, topdown=True, onerror=None, followlinks=False):
  """os.walk(path) wrapper with support for long paths on Windows.
  Availability: Windows, Unix.
  """
  if isWindows():
    return _walk_windows_impl(top, topdown, onerror, followlinks)
  else:
    return os.walk(top, topdown, onerror, followlinks)
 def _walk_windows_impl(top, topdown, onerror, followlinks):
  try:
    names = listdir(top)
  except Exception as err:
    if onerror is not None:
      onerror(err)
    return
  dirs, nondirs = [], []
  for name in names:
    if isdir(os.path.join(top, name)):
      dirs.append(name)
    else:
      nondirs.append(name)
  if topdown:
    yield top, dirs, nondirs
  for name in dirs:
    new_path = os.path.join(top, name)
    if followlinks or not islink(new_path):
      for x in _walk_windows_impl(new_path, topdown, onerror, followlinks):
        yield x
  if not topdown:
    yield top, dirs, nondirs
 def listdir(path):
  """os.listdir(path) wrapper with support for long paths on Windows.
  Availability: Windows, Unix.
  """
  return os.listdir(_makelongpath(path))
 def rmdir(path):
  """os.rmdir(path) wrapper with support for long paths on Windows.
  Availability: Windows, Unix.
  """
  os.rmdir(_makelongpath(path))
 def isdir(path):
  """os.path.isdir(path) wrapper with support for long paths on Windows.
  Availability: Windows, Unix.
  """
  return os.path.isdir(_makelongpath(path))
 def islink(path):
  """os.path.islink(path) wrapper with support for long paths on Windows.
  Availability: Windows, Unix.
  """
  if isWindows():
    import platform_utils_win32
    return platform_utils_win32.islink(_makelongpath(path))
  else:
    return os.path.islink(path)
 def readlink(path):
  """Return a string representing the path to which the symbolic link
  points. The result may be either an absolute or relative pathname;
  if it is relative, it may be converted to an absolute pathname using
  os.path.join(os.path.dirname(path), result).
  Availability: Windows, Unix.
  """
  if isWindows():
    import platform_utils_win32
    return platform_utils_win32.readlink(_makelongpath(path))
  else:
    return os.readlink(path)
 def realpath(path):
  """Return the canonical path of the specified filename, eliminating
  any symbolic links encountered in the path.
  Availability: Windows, Unix.
  """
  if isWindows():
    current_path = os.path.abspath(path)
    path_tail = []
    for c in range(0, 100):  # Avoid cycles
      if islink(current_path):
        target = readlink(current_path)
        current_path = os.path.join(os.path.dirname(current_path), target)
      else:
        basename = os.path.basename(current_path)
        if basename == '':
          path_tail.append(current_path)
          break
        path_tail.append(basename)
        current_path = os.path.dirname(current_path)
    path_tail.reverse()
    result = os.path.normpath(os.path.join(*path_tail))
    return result
  else:
    return os.path.realpath(path)
--- a/platform_utils_win32.py
+++ b/platform_utils_win32.py
@ -0,0 +1,219 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2016 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import errno
 from ctypes import WinDLL, get_last_error, FormatError, WinError, addressof
 from ctypes import c_buffer
 from ctypes.wintypes import BOOL, BOOLEAN, LPCWSTR, DWORD, HANDLE, POINTER, c_ubyte
 from ctypes.wintypes import WCHAR, USHORT, LPVOID, Structure, Union, ULONG
 from ctypes.wintypes import byref
 kernel32 = WinDLL('kernel32', use_last_error=True)
 LPDWORD = POINTER(DWORD)
 UCHAR = c_ubyte
 # Win32 error codes
 ERROR_SUCCESS = 0
 ERROR_NOT_SUPPORTED = 50
 ERROR_PRIVILEGE_NOT_HELD = 1314
 # Win32 API entry points
 CreateSymbolicLinkW = kernel32.CreateSymbolicLinkW
 CreateSymbolicLinkW.restype = BOOLEAN
 CreateSymbolicLinkW.argtypes = (LPCWSTR,  # lpSymlinkFileName In
                                LPCWSTR,  # lpTargetFileName In
                                DWORD)    # dwFlags In
 # Symbolic link creation flags
 SYMBOLIC_LINK_FLAG_FILE = 0x00
 SYMBOLIC_LINK_FLAG_DIRECTORY = 0x01
 # symlink support for CreateSymbolicLink() starting with Windows 10 (1703, v10.0.14972)
 SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE = 0x02
 GetFileAttributesW = kernel32.GetFileAttributesW
 GetFileAttributesW.restype = DWORD
 GetFileAttributesW.argtypes = (LPCWSTR,)  # lpFileName In
 INVALID_FILE_ATTRIBUTES = 0xFFFFFFFF
 FILE_ATTRIBUTE_REPARSE_POINT = 0x00400
 CreateFileW = kernel32.CreateFileW
 CreateFileW.restype = HANDLE
 CreateFileW.argtypes = (LPCWSTR,  # lpFileName In
                        DWORD,    # dwDesiredAccess In
                        DWORD,    # dwShareMode In
                        LPVOID,   # lpSecurityAttributes In_opt
                        DWORD,    # dwCreationDisposition In
                        DWORD,    # dwFlagsAndAttributes In
                        HANDLE)   # hTemplateFile In_opt
 CloseHandle = kernel32.CloseHandle
 CloseHandle.restype = BOOL
 CloseHandle.argtypes = (HANDLE,)  # hObject In
 INVALID_HANDLE_VALUE = HANDLE(-1).value
 OPEN_EXISTING = 3
 FILE_FLAG_BACKUP_SEMANTICS = 0x02000000
 FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000
 DeviceIoControl = kernel32.DeviceIoControl
 DeviceIoControl.restype = BOOL
 DeviceIoControl.argtypes = (HANDLE,   # hDevice In
                            DWORD,    # dwIoControlCode In
                            LPVOID,   # lpInBuffer In_opt
                            DWORD,    # nInBufferSize In
                            LPVOID,   # lpOutBuffer Out_opt
                            DWORD,    # nOutBufferSize In
                            LPDWORD,  # lpBytesReturned Out_opt
                            LPVOID)   # lpOverlapped Inout_opt
 # Device I/O control flags and options
 FSCTL_GET_REPARSE_POINT = 0x000900A8
 IO_REPARSE_TAG_MOUNT_POINT = 0xA0000003
 IO_REPARSE_TAG_SYMLINK = 0xA000000C
 MAXIMUM_REPARSE_DATA_BUFFER_SIZE = 0x4000
 class GENERIC_REPARSE_BUFFER(Structure):
  _fields_ = (('DataBuffer', UCHAR * 1),)
 class SYMBOLIC_LINK_REPARSE_BUFFER(Structure):
  _fields_ = (('SubstituteNameOffset', USHORT),
              ('SubstituteNameLength', USHORT),
              ('PrintNameOffset', USHORT),
              ('PrintNameLength', USHORT),
              ('Flags', ULONG),
              ('PathBuffer', WCHAR * 1))
  @property
  def PrintName(self):
    arrayt = WCHAR * (self.PrintNameLength // 2)
    offset = type(self).PathBuffer.offset + self.PrintNameOffset
    return arrayt.from_address(addressof(self) + offset).value
 class MOUNT_POINT_REPARSE_BUFFER(Structure):
  _fields_ = (('SubstituteNameOffset', USHORT),
              ('SubstituteNameLength', USHORT),
              ('PrintNameOffset', USHORT),
              ('PrintNameLength', USHORT),
              ('PathBuffer', WCHAR * 1))
  @property
  def PrintName(self):
    arrayt = WCHAR * (self.PrintNameLength // 2)
    offset = type(self).PathBuffer.offset + self.PrintNameOffset
    return arrayt.from_address(addressof(self) + offset).value
 class REPARSE_DATA_BUFFER(Structure):
  class REPARSE_BUFFER(Union):
    _fields_ = (('SymbolicLinkReparseBuffer', SYMBOLIC_LINK_REPARSE_BUFFER),
                ('MountPointReparseBuffer', MOUNT_POINT_REPARSE_BUFFER),
                ('GenericReparseBuffer', GENERIC_REPARSE_BUFFER))
  _fields_ = (('ReparseTag', ULONG),
              ('ReparseDataLength', USHORT),
              ('Reserved', USHORT),
              ('ReparseBuffer', REPARSE_BUFFER))
  _anonymous_ = ('ReparseBuffer',)
 def create_filesymlink(source, link_name):
  """Creates a Windows file symbolic link source pointing to link_name."""
  _create_symlink(source, link_name, SYMBOLIC_LINK_FLAG_FILE)
 def create_dirsymlink(source, link_name):
  """Creates a Windows directory symbolic link source pointing to link_name.
  """
  _create_symlink(source, link_name, SYMBOLIC_LINK_FLAG_DIRECTORY)
 def _create_symlink(source, link_name, dwFlags):
  if not CreateSymbolicLinkW(link_name, source, dwFlags | SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE):
    # See https://github.com/golang/go/pull/24307/files#diff-b87bc12e4da2497308f9ef746086e4f0
    # "the unprivileged create flag is unsupported below Windows 10 (1703, v10.0.14972).
    # retry without it."
    if not CreateSymbolicLinkW(link_name, source, dwFlags):
      code = get_last_error()
      error_desc = FormatError(code).strip()
      if code == ERROR_PRIVILEGE_NOT_HELD:
        raise OSError(errno.EPERM, error_desc, link_name)
      _raise_winerror(
          code,
          'Error creating symbolic link \"%s\"'.format(link_name))
 def islink(path):
  result = GetFileAttributesW(path)
  if result == INVALID_FILE_ATTRIBUTES:
    return False
  return bool(result & FILE_ATTRIBUTE_REPARSE_POINT)
 def readlink(path):
  reparse_point_handle = CreateFileW(path,
                                     0,
                                     0,
                                     None,
                                     OPEN_EXISTING,
                                     FILE_FLAG_OPEN_REPARSE_POINT |
                                     FILE_FLAG_BACKUP_SEMANTICS,
                                     None)
  if reparse_point_handle == INVALID_HANDLE_VALUE:
    _raise_winerror(
        get_last_error(),
        'Error opening symblic link \"%s\"'.format(path))
  target_buffer = c_buffer(MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
  n_bytes_returned = DWORD()
  io_result = DeviceIoControl(reparse_point_handle,
                              FSCTL_GET_REPARSE_POINT,
                              None,
                              0,
                              target_buffer,
                              len(target_buffer),
                              byref(n_bytes_returned),
                              None)
  CloseHandle(reparse_point_handle)
  if not io_result:
    _raise_winerror(
        get_last_error(),
        'Error reading symblic link \"%s\"'.format(path))
  rdb = REPARSE_DATA_BUFFER.from_buffer(target_buffer)
  if rdb.ReparseTag == IO_REPARSE_TAG_SYMLINK:
    return _preserve_encoding(path, rdb.SymbolicLinkReparseBuffer.PrintName)
  elif rdb.ReparseTag == IO_REPARSE_TAG_MOUNT_POINT:
    return _preserve_encoding(path, rdb.MountPointReparseBuffer.PrintName)
  # Unsupported reparse point type
  _raise_winerror(
      ERROR_NOT_SUPPORTED,
      'Error reading symblic link \"%s\"'.format(path))
 def _preserve_encoding(source, target):
  """Ensures target is the same string type (i.e. unicode or str) as source."""
  if isinstance(source, unicode):
    return unicode(target)
  return str(target)
 def _raise_winerror(code, error_desc):
  win_error_desc = FormatError(code).strip()
  error_desc = "%s: %s".format(error_desc, win_error_desc)
  raise WinError(code, error_desc)
--- a/progress.py
+++ b/progress.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2009 The Android Open Source Project
 #
@ -16,12 +17,18 @@
 import os
 import sys
 from time import time
-from trace import IsTrace
+from repo_trace import IsTrace
 _NOT_TTY = not os.isatty(2)
 # This will erase all content in the current line (wherever the cursor is).
 # It does not move the cursor, so this is usually followed by \r to move to
 # column 0.
 CSI_ERASE_LINE = '\x1b[2K'
 class Progress(object):
-  def __init__(self, title, total=0, units=''):
+  def __init__(self, title, total=0, units='', print_newline=False,
               always_print_percentage=False):
    self._title = title
    self._total = total
    self._done = 0
@ -29,6 +36,8 @@ class Progress(object):
    self._start = time()
    self._show = False
    self._units = units
    self._print_newline = print_newline
    self._always_print_percentage = always_print_percentage
  def update(self, inc=1):
    self._done += inc
@ -43,20 +52,23 @@ class Progress(object):
        return
    if self._total <= 0:
-      sys.stderr.write('\r%s: %d, ' % (
+      sys.stderr.write('%s\r%s: %d,' % (
        CSI_ERASE_LINE,
        self._title,
        self._done))
      sys.stderr.flush()
    else:
      p = (100 * self._done) / self._total
-      if self._lastp != p:
+      if self._lastp != p or self._always_print_percentage:
        self._lastp = p
-        sys.stderr.write('\r%s: %3d%% (%d%s/%d%s)  ' % (
+        sys.stderr.write('%s\r%s: %3d%% (%d%s/%d%s)%s' % (
          CSI_ERASE_LINE,
          self._title,
          p,
          self._done, self._units,
-          self._total, self._units))
+          self._total, self._units,
          "\n" if self._print_newline else ""))
        sys.stderr.flush()
  def end(self):
@ -64,13 +76,15 @@ class Progress(object):
      return
    if self._total <= 0:
-      sys.stderr.write('\r%s: %d, done.  \n' % (
+      sys.stderr.write('%s\r%s: %d, done.\n' % (
        CSI_ERASE_LINE,
        self._title,
        self._done))
      sys.stderr.flush()
    else:
      p = (100 * self._done) / self._total
-      sys.stderr.write('\r%s: %3d%% (%d%s/%d%s), done.  \n' % (
+      sys.stderr.write('%s\r%s: %3d%% (%d%s/%d%s), done.\n' % (
        CSI_ERASE_LINE,
        self._title,
        p,
        self._done, self._units,
--- a/project.py
+++ b/project.py
--- a/pyversion.py
+++ b/pyversion.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2013 The Android Open Source Project
 #
--- a/398
+++ b/398
@ -1,8 +1,21 @@
 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
-## repo default configuration
+"""Repo launcher.
-##
+
-REPO_URL = 'https://gerrit.googlesource.com/git-repo'
+This is a standalone tool that people may copy to anywhere in their system.
 It is used to get an initial repo client checkout, and after that it runs the
 copy of repo in the checkout.
 """
 from __future__ import print_function
 # repo default configuration
 #
 import os
 REPO_URL = os.environ.get('REPO_URL', None)
 if not REPO_URL:
  REPO_URL = 'https://gerrit.googlesource.com/git-repo'
 REPO_REV = 'stable'
 # Copyright (C) 2008 Google Inc.
@ -20,10 +33,13 @@ REPO_REV = 'stable'
 # limitations under the License.
 # increment this whenever we make important changes to this script
-VERSION = (1, 21)
+VERSION = (1, 26)
 # increment this if the MAINTAINER_KEYS block is modified
 KEYRING_VERSION = (1, 2)
 # Each individual key entry is created by using:
 # gpg --armor --export keyid
 MAINTAINER_KEYS = """
     Repo Maintainer <repo@android.kernel.org>
@ -107,13 +123,17 @@ repodir = '.repo'               # name of repo's private directory
 S_repo = 'repo'                  # special repo repository
 S_manifests = 'manifests'        # special manifest repository
 REPO_MAIN = S_repo + '/main.py'  # main script
-MIN_PYTHON_VERSION = (2, 6)     # minimum supported python version
+MIN_PYTHON_VERSION = (2, 7)      # minimum supported python version
 GITC_CONFIG_FILE = '/gitc/.config'
 GITC_FS_ROOT_DIR = '/gitc/manifest-rw/'
 import collections
 import errno
 import optparse
-import os
+import platform
 import re
 import shutil
 import stat
 import subprocess
 import sys
@ -129,23 +149,15 @@ else:
  urllib.error = urllib2
 def _print(*objects, **kwargs):
  sep = kwargs.get('sep', ' ')
  end = kwargs.get('end', '\n')
  out = kwargs.get('file', sys.stdout)
  out.write(sep.join(objects) + end)
 # Python version check
 ver = sys.version_info
 if ver[0] == 3:
  _print('warning: Python 3 support is currently experimental. YMMV.\n'
         'Please use Python 2.6 - 2.7 instead.',
         file=sys.stderr)
 if (ver[0], ver[1]) < MIN_PYTHON_VERSION:
-  _print('error: Python version %s unsupported.\n'
+  print('error: Python version {} unsupported.\n'
-         'Please use Python 2.6 - 2.7 instead.'
+        'Please use Python {}.{} instead.'.format(
-         % sys.version.split(' ')[0], file=sys.stderr)
+            sys.version.split(' ')[0],
            MIN_PYTHON_VERSION[0],
            MIN_PYTHON_VERSION[1],
        ), file=sys.stderr)
  sys.exit(1)
 home_dot_repo = os.path.expanduser('~/.repoconfig')
@ -171,6 +183,9 @@ group.add_option('-b', '--manifest-branch',
 group.add_option('-m', '--manifest-name',
                 dest='manifest_name',
                 help='initial manifest file', metavar='NAME.xml')
 group.add_option('--current-branch',
                 dest='current_branch_only', action='store_true',
                 help='fetch only current manifest branch from server')
 group.add_option('--mirror',
                 dest='mirror', action='store_true',
                 help='create a replica of the remote repositories '
@ -178,13 +193,26 @@ group.add_option('--mirror',
 group.add_option('--reference',
                 dest='reference',
                 help='location of mirror directory', metavar='DIR')
 group.add_option('--dissociate',
                 dest='dissociate', action='store_true',
                 help='dissociate from reference mirrors after clone')
 group.add_option('--depth', type='int', default=None,
                 dest='depth',
                 help='create a shallow clone with given depth; see git clone')
 group.add_option('--partial-clone', action='store_true',
                 dest='partial_clone',
                 help='perform partial clone (https://git-scm.com/'
                 'docs/gitrepository-layout#_code_partialclone_code)')
 group.add_option('--clone-filter', action='store', default='blob:none',
                 dest='clone_filter',
                 help='filter for use with --partial-clone [default: %default]')
 group.add_option('--archive',
                 dest='archive', action='store_true',
                 help='checkout an archive instead of a git repository for '
                      'each project. See git archive.')
 group.add_option('--submodules',
                 dest='submodules', action='store_true',
                 help='sync any submodules associated with the manifest repo')
 group.add_option('-g', '--groups',
                 dest='groups', default='default',
                 help='restrict manifest projects to ones with specified '
@ -195,6 +223,12 @@ group.add_option('-p', '--platform',
                 help='restrict manifest projects to ones with a specified '
                      'platform group [auto|all|none|linux|darwin|...]',
                 metavar='PLATFORM')
 group.add_option('--no-clone-bundle',
                 dest='no_clone_bundle', action='store_true',
                 help='disable use of /clone.bundle on HTTP/HTTPS')
 group.add_option('--no-tags',
                 dest='no_tags', action='store_true',
                 help="don't fetch tags in the manifest")
 # Tool
@ -215,14 +249,69 @@ group.add_option('--config-name',
                 dest='config_name', action="store_true", default=False,
                 help='Always prompt for name/e-mail')
 def _GitcInitOptions(init_optparse_arg):
  init_optparse_arg.set_usage("repo gitc-init -u url -c client [options]")
  g = init_optparse_arg.add_option_group('GITC options')
  g.add_option('-f', '--manifest-file',
               dest='manifest_file',
               help='Optional manifest file to use for this GITC client.')
  g.add_option('-c', '--gitc-client',
               dest='gitc_client',
               help='The name of the gitc_client instance to create or modify.')
 _gitc_manifest_dir = None
 def get_gitc_manifest_dir():
  global _gitc_manifest_dir
  if _gitc_manifest_dir is None:
    _gitc_manifest_dir = ''
    try:
      with open(GITC_CONFIG_FILE, 'r') as gitc_config:
        for line in gitc_config:
          match = re.match('gitc_dir=(?P<gitc_manifest_dir>.*)', line)
          if match:
            _gitc_manifest_dir = match.group('gitc_manifest_dir')
    except IOError:
      pass
  return _gitc_manifest_dir
 def gitc_parse_clientdir(gitc_fs_path):
  """Parse a path in the GITC FS and return its client name.
  @param gitc_fs_path: A subdirectory path within the GITC_FS_ROOT_DIR.
  @returns: The GITC client name
  """
  if gitc_fs_path == GITC_FS_ROOT_DIR:
    return None
  if not gitc_fs_path.startswith(GITC_FS_ROOT_DIR):
    manifest_dir = get_gitc_manifest_dir()
    if manifest_dir == '':
      return None
    if manifest_dir[-1] != '/':
      manifest_dir += '/'
    if gitc_fs_path == manifest_dir:
      return None
    if not gitc_fs_path.startswith(manifest_dir):
      return None
    return gitc_fs_path.split(manifest_dir)[1].split('/')[0]
  return gitc_fs_path.split(GITC_FS_ROOT_DIR)[1].split('/')[0]
 class CloneFailure(Exception):
  """Indicate the remote clone of repo itself failed.
  """
-def _Init(args):
+def _Init(args, gitc_init=False):
  """Installs repo by cloning it over the network.
  """
  if gitc_init:
    _GitcInitOptions(init_optparse)
  opt, args = init_optparse.parse_args(args)
  if args:
    init_optparse.print_usage()
@ -241,14 +330,34 @@ def _Init(args):
  if branch.startswith('refs/heads/'):
    branch = branch[len('refs/heads/'):]
  if branch.startswith('refs/'):
-    _print("fatal: invalid branch name '%s'" % branch, file=sys.stderr)
+    print("fatal: invalid branch name '%s'" % branch, file=sys.stderr)
    raise CloneFailure()
  try:
    if gitc_init:
      gitc_manifest_dir = get_gitc_manifest_dir()
      if not gitc_manifest_dir:
        print('fatal: GITC filesystem is not available. Exiting...',
              file=sys.stderr)
        sys.exit(1)
      gitc_client = opt.gitc_client
      if not gitc_client:
        gitc_client = gitc_parse_clientdir(os.getcwd())
      if not gitc_client:
        print('fatal: GITC client (-c) is required.', file=sys.stderr)
        sys.exit(1)
      client_dir = os.path.join(gitc_manifest_dir, gitc_client)
      if not os.path.exists(client_dir):
        os.makedirs(client_dir)
      os.chdir(client_dir)
      if os.path.exists(repodir):
        # This GITC Client has already initialized repo so continue.
        return
    os.mkdir(repodir)
  except OSError as e:
    if e.errno != errno.EEXIST:
-      _print('fatal: cannot make %s directory: %s'
+      print('fatal: cannot make %s directory: %s'
            % (repodir, e.strerror), file=sys.stderr)
      # Don't raise CloneFailure; that would delete the
      # name. Instead exit immediately.
@ -263,7 +372,7 @@ def _Init(args):
      can_verify = True
    dst = os.path.abspath(os.path.join(repodir, S_repo))
-    _Clone(url, dst, opt.quiet)
+    _Clone(url, dst, opt.quiet, not opt.no_clone_bundle)
    if can_verify and not opt.no_repo_verify:
      rev = _Verify(dst, branch, opt.quiet)
@ -271,52 +380,75 @@ def _Init(args):
      rev = 'refs/remotes/origin/%s^0' % branch
    _Checkout(dst, branch, rev, opt.quiet)
    if not os.path.isfile(os.path.join(dst, 'repo')):
      print("warning: '%s' does not look like a git-repo repository, is "
            "REPO_URL set correctly?" % url, file=sys.stderr)
  except CloneFailure:
    if opt.quiet:
-      _print('fatal: repo init failed; run without --quiet to see why',
+      print('fatal: repo init failed; run without --quiet to see why',
            file=sys.stderr)
    raise
-def ParseGitVersion(ver_str):
+# The git version info broken down into components for easy analysis.
 # Similar to Python's sys.version_info.
 GitVersion = collections.namedtuple(
    'GitVersion', ('major', 'minor', 'micro', 'full'))
 def ParseGitVersion(ver_str=None):
  if ver_str is None:
    # Load the version ourselves.
    ver_str = _GetGitVersion()
  if not ver_str.startswith('git version '):
    return None
-  num_ver_str = ver_str[len('git version '):].strip().split('-')[0]
+  full_version = ver_str[len('git version '):].strip()
  num_ver_str = full_version.split('-')[0]
  to_tuple = []
  for num_str in num_ver_str.split('.')[:3]:
    if num_str.isdigit():
      to_tuple.append(int(num_str))
    else:
      to_tuple.append(0)
-  return tuple(to_tuple)
+  to_tuple.append(full_version)
  return GitVersion(*to_tuple)
-def _CheckGitVersion():
+def _GetGitVersion():
  cmd = [GIT, '--version']
  try:
    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE)
  except OSError as e:
-    _print(file=sys.stderr)
+    print(file=sys.stderr)
-    _print("fatal: '%s' is not available" % GIT, file=sys.stderr)
+    print("fatal: '%s' is not available" % GIT, file=sys.stderr)
-    _print('fatal: %s' % e, file=sys.stderr)
+    print('fatal: %s' % e, file=sys.stderr)
-    _print(file=sys.stderr)
+    print(file=sys.stderr)
-    _print('Please make sure %s is installed and in your path.' % GIT,
+    print('Please make sure %s is installed and in your path.' % GIT,
          file=sys.stderr)
-    raise CloneFailure()
+    raise
  ver_str = proc.stdout.read().strip()
  proc.stdout.close()
  proc.wait()
  return ver_str.decode('utf-8')
 def _CheckGitVersion():
  try:
    ver_act = ParseGitVersion()
  except OSError:
    raise CloneFailure()
  ver_act = ParseGitVersion(ver_str)
  if ver_act is None:
-    _print('error: "%s" unsupported' % ver_str, file=sys.stderr)
+    print('fatal: unable to detect git version', file=sys.stderr)
    raise CloneFailure()
  if ver_act < MIN_GIT_VERSION:
    need = '.'.join(map(str, MIN_GIT_VERSION))
-    _print('fatal: git %s or later required' % need, file=sys.stderr)
+    print('fatal: git %s or later required' % need, file=sys.stderr)
    raise CloneFailure()
@ -343,7 +475,7 @@ def SetupGnuPG(quiet):
    os.mkdir(home_dot_repo)
  except OSError as e:
    if e.errno != errno.EEXIST:
-      _print('fatal: cannot make %s directory: %s'
+      print('fatal: cannot make %s directory: %s'
            % (home_dot_repo, e.strerror), file=sys.stderr)
      sys.exit(1)
@ -351,32 +483,35 @@ def SetupGnuPG(quiet):
    os.mkdir(gpg_dir, stat.S_IRWXU)
  except OSError as e:
    if e.errno != errno.EEXIST:
-      _print('fatal: cannot make %s directory: %s' % (gpg_dir, e.strerror),
+      print('fatal: cannot make %s directory: %s' % (gpg_dir, e.strerror),
            file=sys.stderr)
      sys.exit(1)
  env = os.environ.copy()
  try:
    env['GNUPGHOME'] = gpg_dir
  except UnicodeEncodeError:
    env['GNUPGHOME'] = gpg_dir.encode()
  cmd = ['gpg', '--import']
  try:
    proc = subprocess.Popen(cmd,
-                            env = env,
+                            env=env,
-                            stdin = subprocess.PIPE)
+                            stdin=subprocess.PIPE)
  except OSError as e:
    if not quiet:
-      _print('warning: gpg (GnuPG) is not available.', file=sys.stderr)
+      print('warning: gpg (GnuPG) is not available.', file=sys.stderr)
-      _print('warning: Installing it is strongly encouraged.', file=sys.stderr)
+      print('warning: Installing it is strongly encouraged.', file=sys.stderr)
-      _print(file=sys.stderr)
+      print(file=sys.stderr)
    return False
-  proc.stdin.write(MAINTAINER_KEYS)
+  proc.stdin.write(MAINTAINER_KEYS.encode('utf-8'))
  proc.stdin.close()
  if proc.wait() != 0:
-    _print('fatal: registering repo maintainer keys failed', file=sys.stderr)
+    print('fatal: registering repo maintainer keys failed', file=sys.stderr)
    sys.exit(1)
-  _print()
+  print()
  fd = open(os.path.join(home_dot_repo, 'keyring-version'), 'w')
  fd.write('.'.join(map(str, KEYRING_VERSION)) + '\n')
@ -388,7 +523,7 @@ def _SetConfig(local, name, value):
  """Set a git configuration option to the specified value.
  """
  cmd = [GIT, 'config', name, value]
-  if subprocess.Popen(cmd, cwd = local).wait() != 0:
+  if subprocess.Popen(cmd, cwd=local).wait() != 0:
    raise CloneFailure()
@ -416,9 +551,10 @@ def _InitHttp():
    handlers.append(urllib.request.HTTPSHandler(debuglevel=1))
  urllib.request.install_opener(urllib.request.build_opener(*handlers))
 def _Fetch(url, local, src, quiet):
  if not quiet:
-    _print('Get %s' % url, file=sys.stderr)
+    print('Get %s' % url, file=sys.stderr)
  cmd = [GIT, 'fetch']
  if quiet:
@ -428,15 +564,16 @@ def _Fetch(url, local, src, quiet):
    err = None
  cmd.append(src)
  cmd.append('+refs/heads/*:refs/remotes/origin/*')
-  cmd.append('refs/tags/*:refs/tags/*')
+  cmd.append('+refs/tags/*:refs/tags/*')
-  proc = subprocess.Popen(cmd, cwd = local, stderr = err)
+  proc = subprocess.Popen(cmd, cwd=local, stderr=err)
  if err:
    proc.stderr.read()
    proc.stderr.close()
  if proc.wait() != 0:
    raise CloneFailure()
 def _DownloadBundle(url, local, quiet):
  if not url.endswith('/'):
    url += '/'
@ -444,9 +581,10 @@ def _DownloadBundle(url, local, quiet):
  proc = subprocess.Popen(
      [GIT, 'config', '--get-regexp', 'url.*.insteadof'],
-    cwd = local,
+      cwd=local,
-    stdout = subprocess.PIPE)
+      stdout=subprocess.PIPE)
  for line in proc.stdout:
    line = line.decode('utf-8')
    m = re.compile(r'^url\.(.*)\.insteadof (.*)$').match(line)
    if m:
      new_url = m.group(1)
@ -465,21 +603,21 @@ def _DownloadBundle(url, local, quiet):
    try:
      r = urllib.request.urlopen(url)
    except urllib.error.HTTPError as e:
-      if e.code in [403, 404]:
+      if e.code in [401, 403, 404, 501]:
        return False
-      _print('fatal: Cannot get %s' % url, file=sys.stderr)
+      print('fatal: Cannot get %s' % url, file=sys.stderr)
-      _print('fatal: HTTP error %s' % e.code, file=sys.stderr)
+      print('fatal: HTTP error %s' % e.code, file=sys.stderr)
      raise CloneFailure()
    except urllib.error.URLError as e:
-      _print('fatal: Cannot get %s' % url, file=sys.stderr)
+      print('fatal: Cannot get %s' % url, file=sys.stderr)
-      _print('fatal: error %s' % e.reason, file=sys.stderr)
+      print('fatal: error %s' % e.reason, file=sys.stderr)
      raise CloneFailure()
    try:
      if not quiet:
-        _print('Get %s' % url, file=sys.stderr)
+        print('Get %s' % url, file=sys.stderr)
      while True:
        buf = r.read(8192)
-        if buf == '':
+        if not buf:
          return True
        dest.write(buf)
    finally:
@ -487,6 +625,7 @@ def _DownloadBundle(url, local, quiet):
  finally:
    dest.close()
 def _ImportBundle(local):
  path = os.path.join(local, '.git', 'clone.bundle')
  try:
@ -494,38 +633,39 @@ def _ImportBundle(local):
  finally:
    os.remove(path)
-def _Clone(url, local, quiet):
+
 def _Clone(url, local, quiet, clone_bundle):
  """Clones a git repository to a new subdirectory of repodir
  """
  try:
    os.mkdir(local)
  except OSError as e:
-    _print('fatal: cannot make %s directory: %s' % (local, e.strerror),
+    print('fatal: cannot make %s directory: %s' % (local, e.strerror),
          file=sys.stderr)
    raise CloneFailure()
  cmd = [GIT, 'init', '--quiet']
  try:
-    proc = subprocess.Popen(cmd, cwd = local)
+    proc = subprocess.Popen(cmd, cwd=local)
  except OSError as e:
-    _print(file=sys.stderr)
+    print(file=sys.stderr)
-    _print("fatal: '%s' is not available" % GIT, file=sys.stderr)
+    print("fatal: '%s' is not available" % GIT, file=sys.stderr)
-    _print('fatal: %s' % e, file=sys.stderr)
+    print('fatal: %s' % e, file=sys.stderr)
-    _print(file=sys.stderr)
+    print(file=sys.stderr)
-    _print('Please make sure %s is installed and in your path.' % GIT,
+    print('Please make sure %s is installed and in your path.' % GIT,
          file=sys.stderr)
    raise CloneFailure()
  if proc.wait() != 0:
-    _print('fatal: could not create %s' % local, file=sys.stderr)
+    print('fatal: could not create %s' % local, file=sys.stderr)
    raise CloneFailure()
  _InitHttp()
  _SetConfig(local, 'remote.origin.url', url)
-  _SetConfig(local, 'remote.origin.fetch',
+  _SetConfig(local,
             'remote.origin.fetch',
             '+refs/heads/*:refs/remotes/origin/*')
-  if _DownloadBundle(url, local, quiet):
+  if clone_bundle and _DownloadBundle(url, local, quiet):
    _ImportBundle(local)
  else:
  _Fetch(url, local, 'origin', quiet)
@ -536,47 +676,50 @@ def _Verify(cwd, branch, quiet):
  proc = subprocess.Popen(cmd,
                          stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE,
-                          cwd = cwd)
+                          cwd=cwd)
-  cur = proc.stdout.read().strip()
+  cur = proc.stdout.read().strip().decode('utf-8')
  proc.stdout.close()
  proc.stderr.read()
  proc.stderr.close()
  if proc.wait() != 0 or not cur:
-    _print(file=sys.stderr)
+    print(file=sys.stderr)
-    _print("fatal: branch '%s' has not been signed" % branch, file=sys.stderr)
+    print("fatal: branch '%s' has not been signed" % branch, file=sys.stderr)
    raise CloneFailure()
  m = re.compile(r'^(.*)-[0-9]{1,}-g[0-9a-f]{1,}$').match(cur)
  if m:
    cur = m.group(1)
    if not quiet:
-      _print(file=sys.stderr)
+      print(file=sys.stderr)
-      _print("info: Ignoring branch '%s'; using tagged release '%s'"
+      print("info: Ignoring branch '%s'; using tagged release '%s'"
            % (branch, cur), file=sys.stderr)
-      _print(file=sys.stderr)
+      print(file=sys.stderr)
  env = os.environ.copy()
  try:
    env['GNUPGHOME'] = gpg_dir
  except UnicodeEncodeError:
    env['GNUPGHOME'] = gpg_dir.encode()
  cmd = [GIT, 'tag', '-v', cur]
  proc = subprocess.Popen(cmd,
-                          stdout = subprocess.PIPE,
+                          stdout=subprocess.PIPE,
-                          stderr = subprocess.PIPE,
+                          stderr=subprocess.PIPE,
-                          cwd = cwd,
+                          cwd=cwd,
-                          env = env)
+                          env=env)
-  out = proc.stdout.read()
+  out = proc.stdout.read().decode('utf-8')
  proc.stdout.close()
-  err = proc.stderr.read()
+  err = proc.stderr.read().decode('utf-8')
  proc.stderr.close()
  if proc.wait() != 0:
-    _print(file=sys.stderr)
+    print(file=sys.stderr)
-    _print(out, file=sys.stderr)
+    print(out, file=sys.stderr)
-    _print(err, file=sys.stderr)
+    print(err, file=sys.stderr)
-    _print(file=sys.stderr)
+    print(file=sys.stderr)
    raise CloneFailure()
  return '%s^0' % cur
@ -585,21 +728,21 @@ def _Checkout(cwd, branch, rev, quiet):
  """Checkout an upstream branch into the repository and track it.
  """
  cmd = [GIT, 'update-ref', 'refs/heads/default', rev]
-  if subprocess.Popen(cmd, cwd = cwd).wait() != 0:
+  if subprocess.Popen(cmd, cwd=cwd).wait() != 0:
    raise CloneFailure()
  _SetConfig(cwd, 'branch.default.remote', 'origin')
  _SetConfig(cwd, 'branch.default.merge', 'refs/heads/%s' % branch)
  cmd = [GIT, 'symbolic-ref', 'HEAD', 'refs/heads/default']
-  if subprocess.Popen(cmd, cwd = cwd).wait() != 0:
+  if subprocess.Popen(cmd, cwd=cwd).wait() != 0:
    raise CloneFailure()
  cmd = [GIT, 'read-tree', '--reset', '-u']
  if not quiet:
    cmd.append('-v')
  cmd.append('HEAD')
-  if subprocess.Popen(cmd, cwd = cwd).wait() != 0:
+  if subprocess.Popen(cmd, cwd=cwd).wait() != 0:
    raise CloneFailure()
@ -621,7 +764,7 @@ def _FindRepo():
  return (repo, os.path.join(curdir, repodir))
-class _Options:
+class _Options(object):
  help = False
@ -643,19 +786,24 @@ def _ParseArguments(args):
 def _Usage():
-  _print(
+  gitc_usage = ""
-"""usage: repo COMMAND [ARGS]
+  if get_gitc_manifest_dir():
    gitc_usage = "  gitc-init Initialize a GITC Client.\n"
  print(
      """usage: repo COMMAND [ARGS]
 repo is not yet installed.  Use "repo init" to install it here.
 The most commonly used repo commands are:
  init      Install repo in the current working directory
-  help      Display detailed help on a command
+""" + gitc_usage +
      """  help      Display detailed help on a command
 For access to the full online help, install repo ("repo init").
-""", file=sys.stderr)
+""")
-  sys.exit(1)
+  sys.exit(0)
 def _Help(args):
@ -663,8 +811,12 @@ def _Help(args):
    if args[0] == 'init':
      init_optparse.print_help()
      sys.exit(0)
    elif args[0] == 'gitc-init':
      _GitcInitOptions(init_optparse)
      init_optparse.print_help()
      sys.exit(0)
    else:
-      _print("error: '%s' is not a bootstrap command.\n"
+      print("error: '%s' is not a bootstrap command.\n"
            '        For access to online help, install repo ("repo init").'
            % args[0], file=sys.stderr)
  else:
@ -673,13 +825,13 @@ def _Help(args):
 def _NotInstalled():
-  _print('error: repo is not installed.  Use "repo init" to install it here.',
+  print('error: repo is not installed.  Use "repo init" to install it here.',
        file=sys.stderr)
  sys.exit(1)
 def _NoCommands(cmd):
-  _print("""error: command '%s' requires repo to be installed first.
+  print("""error: command '%s' requires repo to be installed first.
        Use "repo init" to install it here.""" % cmd, file=sys.stderr)
  sys.exit(1)
@ -708,26 +860,37 @@ def _SetDefaultsTo(gitdir):
                           '--git-dir=%s' % gitdir,
                           'symbolic-ref',
                           'HEAD'],
-                          stdout = subprocess.PIPE,
+                          stdout=subprocess.PIPE,
-                          stderr = subprocess.PIPE)
+                          stderr=subprocess.PIPE)
-  REPO_REV = proc.stdout.read().strip()
+  REPO_REV = proc.stdout.read().strip().decode('utf-8')
  proc.stdout.close()
  proc.stderr.read()
  proc.stderr.close()
  if proc.wait() != 0:
-    _print('fatal: %s has no current branch' % gitdir, file=sys.stderr)
+    print('fatal: %s has no current branch' % gitdir, file=sys.stderr)
    sys.exit(1)
 def main(orig_args):
  repo_main, rel_repo_dir = _FindRepo()
  cmd, opt, args = _ParseArguments(orig_args)
  repo_main, rel_repo_dir = None, None
  # Don't use the local repo copy, make sure to switch to the gitc client first.
  if cmd != 'gitc-init':
    repo_main, rel_repo_dir = _FindRepo()
  wrapper_path = os.path.abspath(__file__)
  my_main, my_git = _RunSelf(wrapper_path)
  cwd = os.getcwd()
  if get_gitc_manifest_dir() and cwd.startswith(get_gitc_manifest_dir()):
    print('error: repo cannot be used in the GITC local manifest directory.'
          '\nIf you want to work on this GITC client please rerun this '
          'command from the corresponding client under /gitc/',
          file=sys.stderr)
    sys.exit(1)
  if not repo_main:
    if opt.help:
      _Usage()
@ -735,18 +898,16 @@ def main(orig_args):
      _Help(args)
    if not cmd:
      _NotInstalled()
-    if cmd == 'init':
+    if cmd == 'init' or cmd == 'gitc-init':
      if my_git:
        _SetDefaultsTo(my_git)
      try:
-        _Init(args)
+        _Init(args, gitc_init=(cmd == 'gitc-init'))
      except CloneFailure:
-        for root, dirs, files in os.walk(repodir, topdown=False):
+        path = os.path.join(repodir, S_repo)
-          for name in files:
+        print("fatal: cloning the git-repo repository failed, will remove "
-            os.remove(os.path.join(root, name))
+              "'%s' " % path, file=sys.stderr)
-          for name in dirs:
+        shutil.rmtree(path, ignore_errors=True)
            os.rmdir(os.path.join(root, name))
        os.rmdir(repodir)
        sys.exit(1)
      repo_main, rel_repo_dir = _FindRepo()
    else:
@ -764,10 +925,13 @@ def main(orig_args):
  me.extend(orig_args)
  me.extend(extra_args)
  try:
    if platform.system() == "Windows":
      sys.exit(subprocess.call(me))
    else:
      os.execv(sys.executable, me)
  except OSError as e:
-    _print("fatal: unable to start %s" % repo_main, file=sys.stderr)
+    print("fatal: unable to start %s" % repo_main, file=sys.stderr)
-    _print("fatal: %s" % e, file=sys.stderr)
+    print("fatal: %s" % e, file=sys.stderr)
    sys.exit(148)
--- a/repo_trace.py
+++ b/repo_trace.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -13,15 +14,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Logic for tracing repo interactions.
 Activated via `repo --trace ...` or `REPO_TRACE=1 repo ...`.
 """
 from __future__ import print_function
 import sys
 import os
 # Env var to implicitly turn on tracing.
 REPO_TRACE = 'REPO_TRACE'
-try:
+_TRACE = os.environ.get(REPO_TRACE) == '1'
  _TRACE = os.environ[REPO_TRACE] == '1'
 except KeyError:
  _TRACE = False
 def IsTrace():
  return _TRACE
--- a/54
+++ b/54
@ -0,0 +1,54 @@
 #!/usr/bin/python
 # -*- coding:utf-8 -*-
 # Copyright 2019 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Wrapper to run pytest with the right settings."""
 from __future__ import print_function
 import errno
 import os
 import subprocess
 import sys
 def run_pytest(cmd, argv):
  """Run the unittests via |cmd|."""
  try:
    subprocess.check_call([cmd] + argv)
    return 0
  except OSError as e:
    if e.errno == errno.ENOENT:
      print('%s: unable to run `%s`: %s' % (__file__, cmd, e), file=sys.stderr)
      print('%s: Try installing pytest: sudo apt-get install python-pytest' %
            (__file__,), file=sys.stderr)
      return 1
    else:
      raise
 def main(argv):
  """The main entry."""
  # Add the repo tree to PYTHONPATH as the tests expect to be able to import
  # modules directly.
  topdir = os.path.dirname(os.path.realpath(__file__))
  pythonpath = os.environ.get('PYTHONPATH', '')
  os.environ['PYTHONPATH'] = '%s:%s' % (topdir, pythonpath)
  return run_pytest('pytest', argv)
 if __name__ == '__main__':
  sys.exit(main(sys.argv[1:]))
--- a/subcmds/init.py
+++ b/subcmds/init.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
--- a/subcmds/abandon.py
+++ b/subcmds/abandon.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -16,6 +17,7 @@
 from __future__ import print_function
 import sys
 from command import Command
 from collections import defaultdict
 from git_command import git
 from progress import Progress
@ -23,49 +25,75 @@ class Abandon(Command):
  common = True
  helpSummary = "Permanently abandon a development branch"
  helpUsage = """
-%prog <branchname> [<project>...]
+%prog [--all | <branchname>] [<project>...]
 This subcommand permanently abandons a development branch by
 deleting it (and all its history) from your local repository.
 It is equivalent to "git branch -D <branchname>".
 """
  def _Options(self, p):
    p.add_option('--all',
                 dest='all', action='store_true',
                 help='delete all branches in all projects')
-  def Execute(self, opt, args):
+  def ValidateOptions(self, opt, args):
-    if not args:
+    if not opt.all and not args:
      self.Usage()
    if not opt.all:
      nb = args[0]
      if not git.check_ref_format('heads/%s' % nb):
-      print("error: '%s' is not a valid name" % nb, file=sys.stderr)
+        self.OptionParser.error("'%s' is not a valid branch name" % nb)
-      sys.exit(1)
+    else:
      args.insert(0, "'All local branches'")
  def Execute(self, opt, args):
    nb = args[0]
-    err = []
+    err = defaultdict(list)
-    success = []
+    success = defaultdict(list)
    all_projects = self.GetProjects(args[1:])
    pm = Progress('Abandon %s' % nb, len(all_projects))
    for project in all_projects:
      pm.update()
-      status = project.AbandonBranch(nb)
+      if opt.all:
        branches = list(project.GetBranches().keys())
      else:
        branches = [nb]
      for name in branches:
        status = project.AbandonBranch(name)
        if status is not None:
          if status:
-          success.append(project)
+            success[name].append(project)
          else:
-          err.append(project)
+            err[name].append(project)
    pm.end()
    width = 25
    for name in branches:
      if width < len(name):
        width = len(name)
    if err:
-      for p in err:
+      for br in err.keys():
-        print("error: %s/: cannot abandon %s" % (p.relpath, nb),
+        err_msg = "error: cannot abandon %s" %br
-              file=sys.stderr)
+        print(err_msg, file=sys.stderr)
        for proj in err[br]:
          print(' '*len(err_msg) + " | %s" % proj.relpath, file=sys.stderr)
      sys.exit(1)
    elif not success:
-      print('error: no project has branch %s' % nb, file=sys.stderr)
+      print('error: no project has local branch(es) : %s' % nb,
            file=sys.stderr)
      sys.exit(1)
    else:
-      print('Abandoned in %d project(s):\n  %s'
+      print('Abandoned branches:', file=sys.stderr)
-            % (len(success), '\n  '.join(p.relpath for p in success)),
+      for br in success.keys():
-            file=sys.stderr)
+        if len(all_projects) > 1 and len(all_projects) == len(success[br]):
          result = "all project"
        else:
          result = "%s" % (
            ('\n'+' '*width + '| ').join(p.relpath for p in success[br]))
        print("%s%s| %s\n" % (br,' '*(width-len(br)), result),file=sys.stderr)
--- a/subcmds/branches.py
+++ b/subcmds/branches.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2009 The Android Open Source Project
 #
@ -46,6 +47,10 @@ class BranchInfo(object):
  def IsCurrent(self):
    return self.current > 0
  @property
  def IsSplitCurrent(self):
    return self.current != 0 and self.current != len(self.projects)
  @property
  def IsPublished(self):
    return self.published > 0
@ -63,8 +68,7 @@ class Branches(Command):
 Summarizes the currently available topic branches.
-Branch Display
+# Branch Display
 --------------
 The branch display output by this command is organized into four
 columns of information; for example:
@ -139,10 +143,14 @@ is shown, then the branch appears in all projects.
      if in_cnt < project_cnt:
        fmt = out.write
        paths = []
-        if in_cnt < project_cnt - in_cnt:
+        non_cur_paths = []
        if i.IsSplitCurrent or (in_cnt < project_cnt - in_cnt):
          in_type = 'in'
          for b in i.projects:
            if not i.IsSplitCurrent or b.current:
              paths.append(b.project.relpath)
            else:
              non_cur_paths.append(b.project.relpath)
        else:
          fmt = out.notinproject
          in_type = 'not in'
@ -154,13 +162,19 @@ is shown, then the branch appears in all projects.
              paths.append(p.relpath)
        s = ' %s %s' % (in_type, ', '.join(paths))
-        if width + 7 + len(s) < 80:
+        if not i.IsSplitCurrent and (width + 7 + len(s) < 80):
          fmt = out.current if i.IsCurrent else fmt
          fmt(s)
        else:
          fmt(' %s:' % in_type)
          fmt = out.current if i.IsCurrent else out.write
          for p in paths:
            out.nl()
            fmt(width*' ' + '          %s' % p)
          fmt = out.write
          for p in non_cur_paths:
            out.nl()
            fmt(width*' ' + '          %s' % p)
      else:
        out.write(' in all projects')
      out.nl()
--- a/subcmds/checkout.py
+++ b/subcmds/checkout.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2009 The Android Open Source Project
 #
@ -33,10 +34,11 @@ The command is equivalent to:
  repo forall [<project>...] -c git checkout <branchname>
 """
-  def Execute(self, opt, args):
+  def ValidateOptions(self, opt, args):
    if not args:
      self.Usage()
  def Execute(self, opt, args):
    nb = args[0]
    err = []
    success = []
--- a/subcmds/cherry_pick.py
+++ b/subcmds/cherry_pick.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2010 The Android Open Source Project
 #
@ -36,10 +37,11 @@ change id will be added.
  def _Options(self, p):
    pass
-  def Execute(self, opt, args):
+  def ValidateOptions(self, opt, args):
    if len(args) != 1:
      self.Usage()
  def Execute(self, opt, args):
    reference = args[0]
    p = GitCommand(None,
@ -76,6 +78,7 @@ change id will be added.
                     capture_stdout = True,
                     capture_stderr = True)
      p.stdin.write(new_msg)
      p.stdin.close()
      if p.Wait() != 0:
        print("error: Failed to update commit message", file=sys.stderr)
        sys.exit(1)
--- a/subcmds/diff.py
+++ b/subcmds/diff.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -36,5 +37,8 @@ to the Unix 'patch' command.
                 help='Paths are relative to the repository root')
  def Execute(self, opt, args):
    ret = 0
    for project in self.GetProjects(args):
-      project.PrintWorkTreeDiff(opt.absolute)
+      if not project.PrintWorkTreeDiff(opt.absolute):
        ret = 1
    return ret
--- a/subcmds/diffmanifests.py
+++ b/subcmds/diffmanifests.py
@ -0,0 +1,206 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2014 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from color import Coloring
 from command import PagedCommand
 from manifest_xml import XmlManifest
 class _Coloring(Coloring):
  def __init__(self, config):
    Coloring.__init__(self, config, "status")
 class Diffmanifests(PagedCommand):
  """ A command to see logs in projects represented by manifests
  This is used to see deeper differences between manifests. Where a simple
  diff would only show a diff of sha1s for example, this command will display
  the logs of the project between both sha1s, allowing user to see diff at a
  deeper level.
  """
  common = True
  helpSummary = "Manifest diff utility"
  helpUsage = """%prog manifest1.xml [manifest2.xml] [options]"""
  helpDescription = """
 The %prog command shows differences between project revisions of manifest1 and
 manifest2. if manifest2 is not specified, current manifest.xml will be used
 instead. Both absolute and relative paths may be used for manifests. Relative
 paths start from project's ".repo/manifests" folder.
 The --raw option Displays the diff in a way that facilitates parsing, the
 project pattern will be <status> <path> <revision from> [<revision to>] and the
 commit pattern will be <status> <onelined log> with status values respectively :
  A = Added project
  R = Removed project
  C = Changed project
  U = Project with unreachable revision(s) (revision(s) not found)
 for project, and
   A = Added commit
   R = Removed commit
 for a commit.
 Only changed projects may contain commits, and commit status always starts with
 a space, and are part of last printed project.
 Unreachable revisions may occur if project is not up to date or if repo has not
 been initialized with all the groups, in which case some projects won't be
 synced and their revisions won't be found.
 """
  def _Options(self, p):
    p.add_option('--raw',
                 dest='raw', action='store_true',
                 help='Display raw diff.')
    p.add_option('--no-color',
                 dest='color', action='store_false', default=True,
                 help='does not display the diff in color.')
    p.add_option('--pretty-format',
                 dest='pretty_format', action='store',
                 metavar='<FORMAT>',
                 help='print the log using a custom git pretty format string')
  def _printRawDiff(self, diff):
    for project in diff['added']:
      self.printText("A %s %s" % (project.relpath, project.revisionExpr))
      self.out.nl()
    for project in diff['removed']:
      self.printText("R %s %s" % (project.relpath, project.revisionExpr))
      self.out.nl()
    for project, otherProject in diff['changed']:
      self.printText("C %s %s %s" % (project.relpath, project.revisionExpr,
                                     otherProject.revisionExpr))
      self.out.nl()
      self._printLogs(project, otherProject, raw=True, color=False)
    for project, otherProject in diff['unreachable']:
      self.printText("U %s %s %s" % (project.relpath, project.revisionExpr,
                                     otherProject.revisionExpr))
      self.out.nl()
  def _printDiff(self, diff, color=True, pretty_format=None):
    if diff['added']:
      self.out.nl()
      self.printText('added projects : \n')
      self.out.nl()
      for project in diff['added']:
        self.printProject('\t%s' % (project.relpath))
        self.printText(' at revision ')
        self.printRevision(project.revisionExpr)
        self.out.nl()
    if diff['removed']:
      self.out.nl()
      self.printText('removed projects : \n')
      self.out.nl()
      for project in diff['removed']:
        self.printProject('\t%s' % (project.relpath))
        self.printText(' at revision ')
        self.printRevision(project.revisionExpr)
        self.out.nl()
    if diff['changed']:
      self.out.nl()
      self.printText('changed projects : \n')
      self.out.nl()
      for project, otherProject in diff['changed']:
        self.printProject('\t%s' % (project.relpath))
        self.printText(' changed from ')
        self.printRevision(project.revisionExpr)
        self.printText(' to ')
        self.printRevision(otherProject.revisionExpr)
        self.out.nl()
        self._printLogs(project, otherProject, raw=False, color=color,
                        pretty_format=pretty_format)
        self.out.nl()
    if diff['unreachable']:
      self.out.nl()
      self.printText('projects with unreachable revisions : \n')
      self.out.nl()
      for project, otherProject in diff['unreachable']:
        self.printProject('\t%s ' % (project.relpath))
        self.printRevision(project.revisionExpr)
        self.printText(' or ')
        self.printRevision(otherProject.revisionExpr)
        self.printText(' not found')
        self.out.nl()
  def _printLogs(self, project, otherProject, raw=False, color=True,
                 pretty_format=None):
    logs = project.getAddedAndRemovedLogs(otherProject,
                                          oneline=(pretty_format is None),
                                          color=color,
                                          pretty_format=pretty_format)
    if logs['removed']:
      removedLogs = logs['removed'].split('\n')
      for log in removedLogs:
        if log.strip():
          if raw:
            self.printText(' R ' + log)
            self.out.nl()
          else:
            self.printRemoved('\t\t[-] ')
            self.printText(log)
            self.out.nl()
    if logs['added']:
      addedLogs = logs['added'].split('\n')
      for log in addedLogs:
        if log.strip():
          if raw:
            self.printText(' A ' + log)
            self.out.nl()
          else:
            self.printAdded('\t\t[+] ')
            self.printText(log)
            self.out.nl()
  def ValidateOptions(self, opt, args):
    if not args or len(args) > 2:
      self.OptionParser.error('missing manifests to diff')
  def Execute(self, opt, args):
    self.out = _Coloring(self.manifest.globalConfig)
    self.printText = self.out.nofmt_printer('text')
    if opt.color:
      self.printProject = self.out.nofmt_printer('project', attr = 'bold')
      self.printAdded = self.out.nofmt_printer('green', fg = 'green', attr = 'bold')
      self.printRemoved = self.out.nofmt_printer('red', fg = 'red', attr = 'bold')
      self.printRevision = self.out.nofmt_printer('revision', fg = 'yellow')
    else:
      self.printProject = self.printAdded = self.printRemoved = self.printRevision = self.printText
    manifest1 = XmlManifest(self.manifest.repodir)
    manifest1.Override(args[0], load_local_manifests=False)
    if len(args) == 1:
      manifest2 = self.manifest
    else:
      manifest2 = XmlManifest(self.manifest.repodir)
      manifest2.Override(args[1], load_local_manifests=False)
    diff = manifest1.projectsDiff(manifest2)
    if opt.raw:
      self._printRawDiff(diff)
    else:
      self._printDiff(diff, color=opt.color, pretty_format=opt.pretty_format)
--- a/subcmds/download.py
+++ b/subcmds/download.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -18,6 +19,7 @@ import re
 import sys
 from command import Command
 from error import GitError
 CHANGE_RE = re.compile(r'^([1-9][0-9]*)(?:[/\.-]([1-9][0-9]*))?$')
@ -25,11 +27,12 @@ class Download(Command):
  common = True
  helpSummary = "Download and checkout a change"
  helpUsage = """
-%prog {project change[/patchset]}...
+%prog {[project] change[/patchset]}...
 """
  helpDescription = """
 The '%prog' command downloads a change from the review system and
 makes it available in your project's local working directory.
 If no project is specified try to use current directory as a project.
 """
  def _Options(self, p):
@ -54,12 +57,21 @@ makes it available in your project's local working directory.
      m = CHANGE_RE.match(a)
      if m:
        if not project:
-          self.Usage()
+          project = self.GetProjects(".")[0]
        chg_id = int(m.group(1))
        if m.group(2):
          ps_id = int(m.group(2))
        else:
          ps_id = 1
          refs = 'refs/changes/%2.2d/%d/' % (chg_id % 100, chg_id)
          output = project._LsRemote(refs + '*')
          if output:
            regex = refs + r'(\d+)'
            rcomp = re.compile(regex, re.I)
            for line in output.splitlines():
              match = rcomp.search(line)
              if match:
                ps_id = max(int(match.group(1)), ps_id)
        to_get.append((project, chg_id, ps_id))
      else:
        project = self.GetProjects([a])[0]
@ -87,7 +99,13 @@ makes it available in your project's local working directory.
        for c in dl.commits:
          print('  %s' % (c), file=sys.stderr)
      if opt.cherrypick:
        try:
          project._CherryPick(dl.commit)
        except GitError:
          print('[%s] Could not complete the cherry-pick of %s' \
                % (project.name, dl.commit), file=sys.stderr)
          sys.exit(1)
      elif opt.revert:
        project._Revert(dl.commit)
      elif opt.ffonly:
--- a/subcmds/forall.py
+++ b/subcmds/forall.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -14,15 +15,17 @@
 # limitations under the License.
 from __future__ import print_function
-import fcntl
+import errno
 import multiprocessing
 import re
 import os
-import select
+import signal
 import sys
 import subprocess
 from color import Coloring
 from command import Command, MirrorSafeCommand
 import platform_utils
 _CAN_COLOR = [
  'branch',
@ -31,6 +34,7 @@ _CAN_COLOR = [
  'log',
 ]
 class ForallColoring(Coloring):
  def __init__(self, config):
    Coloring.__init__(self, config, 'forall')
@ -50,8 +54,7 @@ Executes the same shell command in each project.
 The -r option allows running the command only on projects matching
 regex or wildcard expression.
-Output Formatting
+# Output Formatting
 -----------------
 The -p option causes '%prog' to bind pipes to the command's stdin,
 stdout and stderr streams, and pipe all output into a continuous
@ -68,8 +71,7 @@ command produces output only on stderr.  Normally the -p option
 causes command output to be suppressed until the command produces
 at least one byte of output on stdout.
-Environment
+# Environment
 -----------
 pwd is the project's working directory.  If the current client is
 a mirror client, then pwd is the Git repository.
@ -87,6 +89,12 @@ revision to a locally executed git command, use REPO_LREV.
 REPO_RREV is the name of the revision from the manifest, exactly
 as written in the manifest.
 REPO_COUNT is the total number of projects being iterated.
 REPO_I is the current (1-based) iteration count. Can be used in
 conjunction with REPO_COUNT to add a simple progress indicator to your
 command.
 REPO__* are any extra environment variables, specified by the
 "annotation" element under any project element.  This can be useful
 for differentiating trees based on user-specific criteria, or simply
@ -95,6 +103,13 @@ annotating tree details.
 shell positional arguments ($1, $2, .., $#) are set to any arguments
 following <command>.
 Example: to list projects:
  %prog -c 'echo $REPO_PROJECT'
 Notice that $REPO_PROJECT is quoted to ensure it is expanded in
 the context of running <command> instead of in the calling shell.
 Unless -p is used, stdin, stdout, stderr are inherited from the
 terminal and are not redirected.
@ -110,6 +125,12 @@ without iterating through the remaining projects.
    p.add_option('-r', '--regex',
                 dest='regex', action='store_true',
                 help="Execute the command only on projects matching regex or wildcard expression")
    p.add_option('-i', '--inverse-regex',
                 dest='inverse_regex', action='store_true',
                 help="Execute the command only on projects not matching regex or wildcard expression")
    p.add_option('-g', '--groups',
                 dest='groups',
                 help="Execute the command only on projects matching the specified groups")
    p.add_option('-c', '--command',
                 help='Command (and arguments) to execute',
                 dest='command',
@ -126,14 +147,41 @@ without iterating through the remaining projects.
    g.add_option('-v', '--verbose',
                 dest='verbose', action='store_true',
                 help='Show command error messages')
    g.add_option('-j', '--jobs',
                 dest='jobs', action='store', type='int', default=1,
                 help='number of commands to execute simultaneously')
  def WantPager(self, opt):
-    return opt.project_header
+    return opt.project_header and opt.jobs == 1
-  def Execute(self, opt, args):
+  def _SerializeProject(self, project):
    """ Serialize a project._GitGetByExec instance.
    project._GitGetByExec is not pickle-able. Instead of trying to pass it
    around between processes, make a dict ourselves containing only the
    attributes that we need.
    """
    if not self.manifest.IsMirror:
      lrev = project.GetRevisionId()
    else:
      lrev = None
    return {
      'name': project.name,
      'relpath': project.relpath,
      'remote_name': project.remote.name,
      'lrev': lrev,
      'rrev': project.revisionExpr,
      'annotations': dict((a.name, a.value) for a in project.annotations),
      'gitdir': project.gitdir,
      'worktree': project.worktree,
    }
  def ValidateOptions(self, opt, args):
    if not opt.command:
      self.Usage()
  def Execute(self, opt, args):
    cmd = [opt.command[0]]
    shell = True
@ -157,53 +205,128 @@ without iterating through the remaining projects.
          break
      else:
        cn = None
      # pylint: disable=W0631
      if cn and cn in _CAN_COLOR:
        class ColorCmd(Coloring):
          def __init__(self, config, cmd):
            Coloring.__init__(self, config, cmd)
        if ColorCmd(self.manifest.manifestProject.config, cn).is_on:
          cmd.insert(cmd.index(cn) + 1, '--color')
      # pylint: enable=W0631
    mirror = self.manifest.IsMirror
    out = ForallColoring(self.manifest.manifestProject.config)
    out.redirect(sys.stdout)
    rc = 0
    first = True
-    if not opt.regex:
+    smart_sync_manifest_name = "smart_sync_override.xml"
-      projects = self.GetProjects(args)
+    smart_sync_manifest_path = os.path.join(
-    else:
+      self.manifest.manifestProject.worktree, smart_sync_manifest_name)
    if os.path.isfile(smart_sync_manifest_path):
      self.manifest.Override(smart_sync_manifest_path)
    if opt.regex:
      projects = self.FindProjects(args)
    elif opt.inverse_regex:
      projects = self.FindProjects(args, inverse=True)
    else:
      projects = self.GetProjects(args, groups=opt.groups)
-    for project in projects:
+    os.environ['REPO_COUNT'] = str(len(projects))
    pool = multiprocessing.Pool(opt.jobs, InitWorker)
    try:
      config = self.manifest.manifestProject.config
      results_it = pool.imap(
         DoWorkWrapper,
         self.ProjectArgs(projects, mirror, opt, cmd, shell, config))
      pool.close()
      for r in results_it:
        rc = rc or r
        if r != 0 and opt.abort_on_errors:
          raise Exception('Aborting due to previous error')
    except (KeyboardInterrupt, WorkerKeyboardInterrupt):
      # Catch KeyboardInterrupt raised inside and outside of workers
      print('Interrupted - terminating the pool')
      pool.terminate()
      rc = rc or errno.EINTR
    except Exception as e:
      # Catch any other exceptions raised
      print('Got an error, terminating the pool: %s: %s' %
              (type(e).__name__, e),
            file=sys.stderr)
      pool.terminate()
      rc = rc or getattr(e, 'errno', 1)
    finally:
      pool.join()
    if rc != 0:
      sys.exit(rc)
  def ProjectArgs(self, projects, mirror, opt, cmd, shell, config):
    for cnt, p in enumerate(projects):
      try:
        project = self._SerializeProject(p)
      except Exception as e:
        print('Project list error on project %s: %s: %s' %
                (p.name, type(e).__name__, e),
              file=sys.stderr)
        return
      except KeyboardInterrupt:
        print('Project list interrupted',
              file=sys.stderr)
        return
      yield [mirror, opt, cmd, shell, cnt, config, project]
 class WorkerKeyboardInterrupt(Exception):
  """ Keyboard interrupt exception for worker processes. """
  pass
 def InitWorker():
  signal.signal(signal.SIGINT, signal.SIG_IGN)
 def DoWorkWrapper(args):
  """ A wrapper around the DoWork() method.
  Catch the KeyboardInterrupt exceptions here and re-raise them as a different,
  ``Exception``-based exception to stop it flooding the console with stacktraces
  and making the parent hang indefinitely.
  """
  project = args.pop()
  try:
    return DoWork(project, *args)
  except KeyboardInterrupt:
    print('%s: Worker interrupted' % project['name'])
    raise WorkerKeyboardInterrupt()
 def DoWork(project, mirror, opt, cmd, shell, cnt, config):
  env = os.environ.copy()
  def setenv(name, val):
    if val is None:
      val = ''
-        env[name] = val.encode()
+    if hasattr(val, 'encode'):
      val = val.encode()
    env[name] = val
-      setenv('REPO_PROJECT', project.name)
+  setenv('REPO_PROJECT', project['name'])
-      setenv('REPO_PATH', project.relpath)
+  setenv('REPO_PATH', project['relpath'])
-      setenv('REPO_REMOTE', project.remote.name)
+  setenv('REPO_REMOTE', project['remote_name'])
-      setenv('REPO_LREV', project.GetRevisionId())
+  setenv('REPO_LREV', project['lrev'])
-      setenv('REPO_RREV', project.revisionExpr)
+  setenv('REPO_RREV', project['rrev'])
-      for a in project.annotations:
+  setenv('REPO_I', str(cnt + 1))
-        setenv("REPO__%s" % (a.name), a.value)
+  for name in project['annotations']:
    setenv("REPO__%s" % (name), project['annotations'][name])
  if mirror:
-        setenv('GIT_DIR', project.gitdir)
+    setenv('GIT_DIR', project['gitdir'])
-        cwd = project.gitdir
+    cwd = project['gitdir']
  else:
-        cwd = project.worktree
+    cwd = project['worktree']
  if not os.path.exists(cwd):
-        if (opt.project_header and opt.verbose) \
+    if ((opt.project_header and opt.verbose)
-        or not opt.project_header:
+        or not opt.project_header):
-          print('skipping %s/' % project.relpath, file=sys.stderr)
+      print('skipping %s/' % project['relpath'], file=sys.stderr)
-        continue
+    return 1
  if opt.project_header:
    stdin = subprocess.PIPE
@ -215,56 +338,46 @@ without iterating through the remaining projects.
    stderr = None
  p = subprocess.Popen(cmd,
-                           cwd = cwd,
+                       cwd=cwd,
-                           shell = shell,
+                       shell=shell,
-                           env = env,
+                       env=env,
-                           stdin = stdin,
+                       stdin=stdin,
-                           stdout = stdout,
+                       stdout=stdout,
-                           stderr = stderr)
+                       stderr=stderr)
  if opt.project_header:
-        class sfd(object):
+    out = ForallColoring(config)
-          def __init__(self, fd, dest):
+    out.redirect(sys.stdout)
            self.fd = fd
            self.dest = dest
          def fileno(self):
            return self.fd.fileno()
    empty = True
    errbuf = ''
    p.stdin.close()
-        s_in = [sfd(p.stdout, sys.stdout),
+    s_in = platform_utils.FileDescriptorStreams.create()
-                sfd(p.stderr, sys.stderr)]
+    s_in.add(p.stdout, sys.stdout, 'stdout')
    s_in.add(p.stderr, sys.stderr, 'stderr')
-        for s in s_in:
+    while not s_in.is_done:
-          flags = fcntl.fcntl(s.fd, fcntl.F_GETFL)
+      in_ready = s_in.select()
          fcntl.fcntl(s.fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
        while s_in:
          in_ready, _out_ready, _err_ready = select.select(s_in, [], [])
      for s in in_ready:
-            buf = s.fd.read(4096)
+        buf = s.read()
        if not buf:
-              s.fd.close()
+          s.close()
          s_in.remove(s)
          continue
        if not opt.verbose:
-              if s.fd != p.stdout:
+          if s.std_name == 'stderr':
            errbuf += buf
            continue
-            if empty:
+        if empty and out:
-              if first:
+          if not cnt == 0:
                first = False
              else:
            out.nl()
          if mirror:
-                project_header_path = project.name
+            project_header_path = project['name']
          else:
-                project_header_path = project.relpath
+            project_header_path = project['relpath']
          out.project('project %s/', project_header_path)
          out.nl()
          out.flush()
@ -278,12 +391,4 @@ without iterating through the remaining projects.
        s.dest.flush()
  r = p.wait()
-      if r != 0:
+  return r
        if r != rc:
          rc = r
        if opt.abort_on_errors:
          print("error: %s: Aborting due to previous error" % project.relpath,
                file=sys.stderr)
          sys.exit(r)
    if rc != 0:
      sys.exit(rc)
--- a/subcmds/gitc_delete.py
+++ b/subcmds/gitc_delete.py
@ -0,0 +1,52 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2015 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from __future__ import print_function
 import sys
 from command import Command, GitcClientCommand
 import platform_utils
 from pyversion import is_python3
 if not is_python3():
  input = raw_input
 class GitcDelete(Command, GitcClientCommand):
  common = True
  visible_everywhere = False
  helpSummary = "Delete a GITC Client."
  helpUsage = """
 %prog
 """
  helpDescription = """
 This subcommand deletes the current GITC client, deleting the GITC manifest
 and all locally downloaded sources.
 """
  def _Options(self, p):
    p.add_option('-f', '--force',
                 dest='force', action='store_true',
                 help='Force the deletion (no prompt).')
  def Execute(self, opt, args):
    if not opt.force:
      prompt = ('This will delete GITC client: %s\nAre you sure? (yes/no) ' %
                self.gitc_manifest.gitc_client_name)
      response = input(prompt).lower()
      if not response == 'yes':
        print('Response was not "yes"\n Exiting...')
        sys.exit(1)
    platform_utils.rmtree(self.gitc_manifest.gitc_client_dir)
--- a/subcmds/gitc_init.py
+++ b/subcmds/gitc_init.py
@ -0,0 +1,83 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2015 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from __future__ import print_function
 import os
 import sys
 import gitc_utils
 from command import GitcAvailableCommand
 from manifest_xml import GitcManifest
 from subcmds import init
 import wrapper
 class GitcInit(init.Init, GitcAvailableCommand):
  common = True
  helpSummary = "Initialize a GITC Client."
  helpUsage = """
 %prog [options] [client name]
 """
  helpDescription = """
 The '%prog' command is ran to initialize a new GITC client for use
 with the GITC file system.
 This command will setup the client directory, initialize repo, just
 like repo init does, and then downloads the manifest collection
 and installs it in the .repo/directory of the GITC client.
 Once this is done, a GITC manifest is generated by pulling the HEAD
 SHA for each project and generates the properly formatted XML file
 and installs it as .manifest in the GITC client directory.
 The -c argument is required to specify the GITC client name.
 The optional -f argument can be used to specify the manifest file to
 use for this GITC client.
 """
  def _Options(self, p):
    super(GitcInit, self)._Options(p)
    g = p.add_option_group('GITC options')
    g.add_option('-f', '--manifest-file',
                 dest='manifest_file',
                 help='Optional manifest file to use for this GITC client.')
    g.add_option('-c', '--gitc-client',
                 dest='gitc_client',
                 help='The name of the gitc_client instance to create or modify.')
  def Execute(self, opt, args):
    gitc_client = gitc_utils.parse_clientdir(os.getcwd())
    if not gitc_client or (opt.gitc_client and gitc_client != opt.gitc_client):
      print('fatal: Please update your repo command. See go/gitc for instructions.', file=sys.stderr)
      sys.exit(1)
    self.client_dir = os.path.join(gitc_utils.get_gitc_manifest_dir(),
                                   gitc_client)
    super(GitcInit, self).Execute(opt, args)
    manifest_file = self.manifest.manifestFile
    if opt.manifest_file:
      if not os.path.exists(opt.manifest_file):
        print('fatal: Specified manifest file %s does not exist.' %
              opt.manifest_file)
        sys.exit(1)
      manifest_file = opt.manifest_file
    manifest = GitcManifest(self.repodir, gitc_client)
    manifest.Override(manifest_file)
    gitc_utils.generate_gitc_manifest(None, manifest)
    print('Please run `cd %s` to view your GITC client.' %
          os.path.join(wrapper.Wrapper().GITC_FS_ROOT_DIR, gitc_client))
--- a/subcmds/grep.py
+++ b/subcmds/grep.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2009 The Android Open Source Project
 #
@ -14,15 +15,19 @@
 # limitations under the License.
 from __future__ import print_function
 import sys
 from color import Coloring
 from command import PagedCommand
 from error import GitError
 from git_command import git_require, GitCommand
 class GrepColoring(Coloring):
  def __init__(self, config):
    Coloring.__init__(self, config, 'grep')
    self.project = self.printer('project', attr='bold')
    self.fail = self.printer('fail', fg='red')
 class Grep(PagedCommand):
  common = True
@ -33,8 +38,7 @@ class Grep(PagedCommand):
  helpDescription = """
 Search for the specified patterns in all project files.
-Boolean Options
+# Boolean Options
 ---------------
 The following options can appear as often as necessary to express
 the pattern to locate:
@ -47,8 +51,7 @@ in order to scan multiple trees.  If the same file matches in more
 than one tree, only the first result is reported, prefixed by the
 revision name it was found under.
-Examples
+# Examples
 -------
 Look for a line that has '#define' and either 'MAX_PATH or 'PATH_MAX':
@ -185,15 +188,25 @@ contain a line that matches both expressions:
      cmd_argv.extend(opt.revision)
    cmd_argv.append('--')
    git_failed = False
    bad_rev = False
    have_match = False
    for project in projects:
      try:
        p = GitCommand(project,
                       cmd_argv,
-                     bare = False,
+                       bare=False,
-                     capture_stdout = True,
+                       capture_stdout=True,
-                     capture_stderr = True)
+                       capture_stderr=True)
      except GitError as e:
        git_failed = True
        out.project('--- project %s ---' % project.relpath)
        out.nl()
        out.fail('%s', str(e))
        out.nl()
        continue
      if p.Wait() != 0:
        # no results
        #
@ -203,7 +216,7 @@ contain a line that matches both expressions:
          else:
            out.project('--- project %s ---' % project.relpath)
            out.nl()
-            out.write("%s", p.stderr)
+            out.fail('%s', p.stderr.strip())
            out.nl()
        continue
      have_match = True
@ -232,7 +245,9 @@ contain a line that matches both expressions:
        for line in r:
          print(line)
-    if have_match:
+    if git_failed:
      sys.exit(1)
    elif have_match:
      sys.exit(0)
    elif have_rev and bad_rev:
      for r in opt.revision:
--- a/subcmds/help.py
+++ b/subcmds/help.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -19,7 +20,8 @@ import sys
 from formatter import AbstractFormatter, DumbWriter
 from color import Coloring
-from command import PagedCommand, MirrorSafeCommand
+from command import PagedCommand, MirrorSafeCommand, GitcAvailableCommand, GitcClientCommand
 import gitc_utils
 class Help(PagedCommand, MirrorSafeCommand):
  common = False
@ -54,9 +56,21 @@ Displays detailed usage information about a command.
  def _PrintCommonCommands(self):
    print('usage: repo COMMAND [ARGS]')
    print('The most commonly used repo commands are:')
    def gitc_supported(cmd):
      if not isinstance(cmd, GitcAvailableCommand) and not isinstance(cmd, GitcClientCommand):
        return True
      if self.manifest.isGitcClient:
        return True
      if isinstance(cmd, GitcClientCommand):
        return False
      if gitc_utils.get_gitc_manifest_dir():
        return True
      return False
    commandNames = list(sorted([name
                    for name, command in self.commands.items()
-                    if command.common]))
+                    if command.common and gitc_supported(command)]))
    maxlen = 0
    for name in commandNames:
@ -74,7 +88,7 @@ Displays detailed usage information about a command.
 "See 'repo help <command>' for more information on a specific command.\n"
 "See 'repo help --all' for a complete list of recognized commands.")
-  def _PrintCommandHelp(self, cmd):
+  def _PrintCommandHelp(self, cmd, header_prefix=''):
    class _Out(Coloring):
      def __init__(self, gc):
        Coloring.__init__(self, gc, 'help')
@ -92,17 +106,15 @@ Displays detailed usage information about a command.
        self.nl()
-        self.heading('%s', heading)
+        self.heading('%s%s', header_prefix, heading)
        self.nl()
        self.heading('%s', ''.ljust(len(heading), '-'))
        self.nl()
        me = 'repo %s' % cmd.NAME
        body = body.strip()
        body = body.replace('%prog', me)
-        asciidoc_hdr = re.compile(r'^\n?([^\n]{1,})\n([=~-]{2,})$')
+        asciidoc_hdr = re.compile(r'^\n?#+ (.+)$')
        for para in body.split("\n\n"):
          if para.startswith(' '):
            self.write('%s', para)
@ -112,19 +124,8 @@ Displays detailed usage information about a command.
          m = asciidoc_hdr.match(para)
          if m:
-            title = m.group(1)
+            self.heading('%s%s', header_prefix, m.group(1))
            section_type = m.group(2)
            if section_type[0] in ('=', '-'):
              p = self.heading
            else:
              def _p(fmt, *args):
                self.write('  ')
                self.heading(fmt, *args)
              p = _p
            p('%s', title)
            self.nl()
            p('%s', ''.ljust(len(title), section_type[0]))
            self.nl()
            continue
@ -137,14 +138,25 @@ Displays detailed usage information about a command.
    cmd.OptionParser.print_help()
    out._PrintSection('Description', 'helpDescription')
  def _PrintAllCommandHelp(self):
    for name in sorted(self.commands):
      cmd = self.commands[name]
      cmd.manifest = self.manifest
      self._PrintCommandHelp(cmd, header_prefix='[%s] ' % (name,))
  def _Options(self, p):
    p.add_option('-a', '--all',
                 dest='show_all', action='store_true',
                 help='show the complete list of commands')
    p.add_option('--help-all',
                 dest='show_all_help', action='store_true',
                 help='show the --help of all commands')
  def Execute(self, opt, args):
    if len(args) == 0:
-      if opt.show_all:
+      if opt.show_all_help:
        self._PrintAllCommandHelp()
      elif opt.show_all:
        self._PrintAllCommands()
      else:
        self._PrintCommonCommands()
--- a/subcmds/info.py
+++ b/subcmds/info.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2012 The Android Open Source Project
 #
@ -15,7 +16,6 @@
 from command import PagedCommand
 from color import Coloring
 from error import NoSuchProjectError
 from git_refs import R_M
 class _Coloring(Coloring):
@ -45,7 +45,7 @@ class Info(PagedCommand):
  def Execute(self, opt, args):
    self.out = _Coloring(self.manifest.globalConfig)
    self.heading = self.out.printer('heading', attr = 'bold')
-    self.headtext = self.out.printer('headtext', fg = 'yellow')
+    self.headtext = self.out.nofmt_printer('headtext', fg = 'yellow')
    self.redtext = self.out.printer('redtext', fg = 'red')
    self.sha = self.out.printer("sha", fg = 'yellow')
    self.text = self.out.nofmt_printer('text')
@ -59,6 +59,7 @@ class Info(PagedCommand):
                      or 'all,-notdefault')
    self.heading("Manifest branch: ")
    if self.manifest.default.revisionExpr:
        self.headtext(self.manifest.default.revisionExpr)
    self.out.nl()
    self.heading("Manifest merge branch: ")
@ -80,10 +81,8 @@ class Info(PagedCommand):
    self.out.nl()
  def printDiffInfo(self, args):
-    try:
+    # We let exceptions bubble up to main as they'll be well structured.
    projs = self.GetProjects(args)
    except NoSuchProjectError:
      return
    for p in projs:
      self.heading("Project: ")
@ -95,13 +94,19 @@ class Info(PagedCommand):
      self.out.nl()
      self.heading("Current revision: ")
-      self.headtext(p.revisionExpr)
+      self.headtext(p.GetRevisionId())
      self.out.nl()
-      localBranches = p.GetBranches().keys()
+      currentBranch = p.CurrentBranch
      if currentBranch:
        self.heading('Current branch: ')
        self.headtext(currentBranch)
        self.out.nl()
      localBranches = list(p.GetBranches().keys())
      self.heading("Local Branches: ")
      self.redtext(str(len(localBranches)))
-      if len(localBranches) > 0:
+      if localBranches:
        self.text(" [")
        self.text(", ".join(localBranches))
        self.text("]")
--- a/subcmds/init.py
+++ b/subcmds/init.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -17,7 +18,6 @@ from __future__ import print_function
 import os
 import platform
 import re
 import shutil
 import sys
 from pyversion import is_python3
@ -27,7 +27,7 @@ else:
  import imp
  import urlparse
  urllib = imp.new_module('urllib')
-  urllib.parse = urlparse.urlparse
+  urllib.parse = urlparse
 from color import Coloring
 from command import InteractiveCommand, MirrorSafeCommand
@ -35,6 +35,7 @@ from error import ManifestParseError
 from project import SyncBuffer
 from git_config import GitConfig
 from git_command import git_require, MIN_GIT_VERSION
 import platform_utils
 class Init(InteractiveCommand, MirrorSafeCommand):
  common = True
@ -61,9 +62,18 @@ directory use as much data as possible from the local reference
 directory when fetching from the server. This will make the sync
 go a lot faster by reducing data traffic on the network.
 The --dissociate option can be used to borrow the objects from
 the directory specified with the --reference option only to reduce
 network transfer, and stop borrowing from them after a first clone
 is made by making necessary local copies of borrowed objects.
-Switching Manifest Branches
+The --no-clone-bundle option disables any attempt to use
---------------------------
+$URL/clone.bundle to bootstrap a new Git repository from a
 resumeable bundle file on a content delivery network. This
 may be necessary if there are problems with the local Python
 HTTP client or proxy configuration, but the Git binary works.
 # Switching Manifest Branches
 To switch to another manifest branch, `repo init -b otherbranch`
 may be used in an existing client.  However, as this only updates the
@ -86,6 +96,9 @@ to update the working directory files.
    g.add_option('-b', '--manifest-branch',
                 dest='manifest_branch',
                 help='manifest branch or revision', metavar='REVISION')
    g.add_option('--current-branch',
                 dest='current_branch_only', action='store_true',
                 help='fetch only current manifest branch from server')
    g.add_option('-m', '--manifest-name',
                 dest='manifest_name', default='default.xml',
                 help='initial manifest file', metavar='NAME.xml')
@ -96,13 +109,26 @@ to update the working directory files.
    g.add_option('--reference',
                 dest='reference',
                 help='location of mirror directory', metavar='DIR')
    g.add_option('--dissociate',
                 dest='dissociate', action='store_true',
                 help='dissociate from reference mirrors after clone')
    g.add_option('--depth', type='int', default=None,
                 dest='depth',
                 help='create a shallow clone with given depth; see git clone')
    g.add_option('--partial-clone', action='store_true',
                 dest='partial_clone',
                 help='perform partial clone (https://git-scm.com/'
                 'docs/gitrepository-layout#_code_partialclone_code)')
    g.add_option('--clone-filter', action='store', default='blob:none',
                 dest='clone_filter',
                 help='filter for use with --partial-clone [default: %default]')
    g.add_option('--archive',
                 dest='archive', action='store_true',
                 help='checkout an archive instead of a git repository for '
                      'each project. See git archive.')
    g.add_option('--submodules',
                 dest='submodules', action='store_true',
                 help='sync any submodules associated with the manifest repo')
    g.add_option('-g', '--groups',
                 dest='groups', default='default',
                 help='restrict manifest projects to ones with specified '
@ -113,6 +139,12 @@ to update the working directory files.
                 help='restrict manifest projects to ones with a specified '
                      'platform group [auto|all|none|linux|darwin|...]',
                 metavar='PLATFORM')
    g.add_option('--no-clone-bundle',
                 dest='no_clone_bundle', action='store_true',
                 help='disable use of /clone.bundle on HTTP/HTTPS')
    g.add_option('--no-tags',
                 dest='no_tags', action='store_true',
                 help="don't fetch tags in the manifest")
    # Tool
    g = p.add_option_group('repo Version options')
@ -153,12 +185,13 @@ to update the working directory files.
      # server where this git is located, so let's save that here.
      mirrored_manifest_git = None
      if opt.reference:
-        manifest_git_path = urllib.parse(opt.manifest_url).path[1:]
+        manifest_git_path = urllib.parse.urlparse(opt.manifest_url).path[1:]
        mirrored_manifest_git = os.path.join(opt.reference, manifest_git_path)
        if not mirrored_manifest_git.endswith(".git"):
          mirrored_manifest_git += ".git"
        if not os.path.exists(mirrored_manifest_git):
-          mirrored_manifest_git = os.path.join(opt.reference + '/.repo/manifests.git')
+          mirrored_manifest_git = os.path.join(opt.reference,
                                               '.repo/manifests.git')
      m._InitGitDir(mirror_git=mirrored_manifest_git)
@ -172,6 +205,8 @@ to update the working directory files.
      else:
        m.PreSync()
    self._ConfigureDepth(opt)
    if opt.manifest_url:
      r = m.GetRemote(m.remote.name)
      r.url = opt.manifest_url
@ -179,7 +214,7 @@ to update the working directory files.
      r.Save()
    groups = re.split(r'[,\s]+', opt.groups)
-    all_platforms = ['linux', 'darwin']
+    all_platforms = ['linux', 'darwin', 'windows']
    platformize = lambda x: 'platform-' + x
    if opt.platform == 'auto':
      if (not opt.mirror and
@ -188,7 +223,7 @@ to update the working directory files.
    elif opt.platform == 'all':
      groups.extend(map(platformize, all_platforms))
    elif opt.platform in all_platforms:
-      groups.extend(platformize(opt.platform))
+      groups.append(platformize(opt.platform))
    elif opt.platform != 'none':
      print('fatal: invalid platform flag', file=sys.stderr)
      sys.exit(1)
@ -202,6 +237,9 @@ to update the working directory files.
    if opt.reference:
      m.config.SetString('repo.reference', opt.reference)
    if opt.dissociate:
      m.config.SetString('repo.dissociate', 'true')
    if opt.archive:
      if is_new:
        m.config.SetString('repo.archive', 'true')
@ -222,21 +260,39 @@ to update the working directory files.
              'in another location.', file=sys.stderr)
        sys.exit(1)
-    if not m.Sync_NetworkHalf(is_new=is_new):
+    if opt.partial_clone:
      if opt.mirror:
        print('fatal: --mirror and --partial-clone are mutually exclusive',
              file=sys.stderr)
        sys.exit(1)
      m.config.SetString('repo.partialclone', 'true')
      if opt.clone_filter:
        m.config.SetString('repo.clonefilter', opt.clone_filter)
    else:
      opt.clone_filter = None
    if opt.submodules:
      m.config.SetString('repo.submodules', 'true')
    if not m.Sync_NetworkHalf(is_new=is_new, quiet=opt.quiet,
        clone_bundle=not opt.no_clone_bundle,
        current_branch_only=opt.current_branch_only,
        no_tags=opt.no_tags, submodules=opt.submodules,
        clone_filter=opt.clone_filter):
      r = m.GetRemote(m.remote.name)
      print('fatal: cannot obtain manifest %s' % r.url, file=sys.stderr)
      # Better delete the manifest git dir if we created it; otherwise next
      # time (when user fixes problems) we won't go through the "is_new" logic.
      if is_new:
-        shutil.rmtree(m.gitdir)
+        platform_utils.rmtree(m.gitdir)
      sys.exit(1)
    if opt.manifest_branch:
-      m.MetaBranchSwitch(opt.manifest_branch)
+      m.MetaBranchSwitch(submodules=opt.submodules)
    syncbuf = SyncBuffer(m.config)
-    m.Sync_LocalHalf(syncbuf)
+    m.Sync_LocalHalf(syncbuf, submodules=opt.submodules)
    syncbuf.Finish()
    if is_new or m.CurrentBranch is None:
@ -257,7 +313,9 @@ to update the working directory files.
      sys.exit(1)
  def _Prompt(self, prompt, value):
-    sys.stdout.write('%-10s [%s]: ' % (prompt, value))
+    print('%-10s [%s]: ' % (prompt, value), end='')
    # TODO: When we require Python 3, use flush=True w/print above.
    sys.stdout.flush()
    a = sys.stdin.readline().strip()
    if a == '':
      return value
@ -291,7 +349,9 @@ to update the working directory files.
      print()
      print('Your identity is: %s <%s>' % (name, email))
-      sys.stdout.write('is this correct [y/N]? ')
+      print('is this correct [y/N]? ', end='')
      # TODO: When we require Python 3, use flush=True w/print above.
      sys.stdout.flush()
      a = sys.stdin.readline().strip().lower()
      if a in ('yes', 'y', 't', 'true'):
        break
@ -333,7 +393,9 @@ to update the working directory files.
      out.printer(fg='black', attr=c)(' %-6s ', c)
    out.nl()
-    sys.stdout.write('Enable color display in this user account (y/N)? ')
+    print('Enable color display in this user account (y/N)? ', end='')
    # TODO: When we require Python 3, use flush=True w/print above.
    sys.stdout.flush()
    a = sys.stdin.readline().strip().lower()
    if a in ('y', 'yes', 't', 'true', 'on'):
      gc.SetString('color.ui', 'auto')
@ -374,18 +436,17 @@ to update the working directory files.
      print('   rm -r %s/.repo' % self.manifest.topdir)
      print('and try again.')
-  def Execute(self, opt, args):
+  def ValidateOptions(self, opt, args):
    git_require(MIN_GIT_VERSION, fail=True)
    if opt.reference:
      opt.reference = os.path.expanduser(opt.reference)
    # Check this here, else manifest will be tagged "not new" and init won't be
    # possible anymore without removing the .repo/manifests directory.
    if opt.archive and opt.mirror:
-      print('fatal: --mirror and --archive cannot be used together.',
+      self.OptionParser.error('--mirror and --archive cannot be used together.')
-            file=sys.stderr)
+
-      sys.exit(1)
+  def Execute(self, opt, args):
    git_require(MIN_GIT_VERSION, fail=True)
    self._SyncManifest(opt)
    self._LinkManifest(opt.manifest_name)
@ -395,6 +456,4 @@ to update the working directory files.
        self._ConfigureUser()
      self._ConfigureColor()
    self._ConfigureDepth(opt)
    self._DisplayResult()
--- a/subcmds/list.py
+++ b/subcmds/list.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2011 The Android Open Source Project
 #
@ -35,6 +36,9 @@ This is similar to running: repo forall -c 'echo "$REPO_PATH : $REPO_PROJECT"'.
    p.add_option('-r', '--regex',
                 dest='regex', action='store_true',
                 help="Filter the project list based on regex or wildcard matching of strings")
    p.add_option('-g', '--groups',
                 dest='groups',
                 help="Filter the project list based on the groups the project is in")
    p.add_option('-f', '--fullpath',
                 dest='fullpath', action='store_true',
                 help="Display the full work tree path instead of the relative path")
@ -45,6 +49,10 @@ This is similar to running: repo forall -c 'echo "$REPO_PATH : $REPO_PROJECT"'.
                 dest='path_only', action='store_true',
                 help="Display only the path of the repository")
  def ValidateOptions(self, opt, args):
    if opt.fullpath and opt.name_only:
      self.OptionParser.error('cannot combine -f and -n')
  def Execute(self, opt, args):
    """List all projects and the associated directories.
@ -56,13 +64,8 @@ This is similar to running: repo forall -c 'echo "$REPO_PATH : $REPO_PROJECT"'.
      opt: The options.
      args: Positional args.  Can be a list of projects to list, or empty.
    """
    if opt.fullpath and opt.name_only:
      print('error: cannot combine -f and -n', file=sys.stderr)
      sys.exit(1)
    if not opt.regex:
-      projects = self.GetProjects(args)
+      projects = self.GetProjects(args, groups=opt.groups)
    else:
      projects = self.FindProjects(args)
--- a/subcmds/manifest.py
+++ b/subcmds/manifest.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2009 The Android Open Source Project
 #
@ -39,7 +40,7 @@ in a Git repository for use during future 'repo init' invocations.
    helptext = self._helpDescription + '\n'
    r = os.path.dirname(__file__)
    r = os.path.dirname(r)
-    fd = open(os.path.join(r, 'docs', 'manifest-format.txt'))
+    fd = open(os.path.join(r, 'docs', 'manifest-format.md'))
    for line in fd:
      helptext += line
    fd.close()
@ -72,14 +73,9 @@ in a Git repository for use during future 'repo init' invocations.
    if opt.output_file != '-':
      print('Saved manifest to %s' % opt.output_file, file=sys.stderr)
-  def Execute(self, opt, args):
+  def ValidateOptions(self, opt, args):
    if args:
      self.Usage()
-    if opt.output_file is not None:
+  def Execute(self, opt, args):
    self._Output(opt)
      return
    print('error: no operation to perform', file=sys.stderr)
    print('error: see repo help manifest', file=sys.stderr)
    sys.exit(1)
--- a/subcmds/overview.py
+++ b/subcmds/overview.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2012 The Android Open Source Project
 #
--- a/subcmds/prune.py
+++ b/subcmds/prune.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
--- a/subcmds/rebase.py
+++ b/subcmds/rebase.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2010 The Android Open Source Project
 #
@ -16,9 +17,18 @@
 from __future__ import print_function
 import sys
 from color import Coloring
 from command import Command
 from git_command import GitCommand
 class RebaseColoring(Coloring):
  def __init__(self, config):
    Coloring.__init__(self, config, 'rebase')
    self.project = self.printer('project', attr='bold')
    self.fail = self.printer('fail', fg='red')
 class Rebase(Command):
  common = True
  helpSummary = "Rebase local branches on upstream branch"
@ -36,6 +46,9 @@ branch but need to incorporate new upstream changes "underneath" them.
                dest="interactive", action="store_true",
                help="interactive rebase (single project only)")
    p.add_option('--fail-fast',
                 dest='fail_fast', action='store_true',
                 help='Stop rebasing after first error is hit')
    p.add_option('-f', '--force-rebase',
                 dest='force_rebase', action='store_true',
                 help='Pass --force-rebase to git rebase')
@ -54,6 +67,11 @@ branch but need to incorporate new upstream changes "underneath" them.
    p.add_option('--auto-stash',
                 dest='auto_stash', action='store_true',
                 help='Stash local modifications before starting')
    p.add_option('-m', '--onto-manifest',
                 dest='onto_manifest', action='store_true',
                 help='Rebase onto the manifest version instead of upstream '
                      'HEAD.  This helps to make sure the local tree stays '
                      'consistent if you previously synced to a manifest.')
  def Execute(self, opt, args):
    all_projects = self.GetProjects(args)
@ -65,15 +83,38 @@ branch but need to incorporate new upstream changes "underneath" them.
      if len(args) == 1:
        print('note: project %s is mapped to more than one path' % (args[0],),
            file=sys.stderr)
-      return -1
+      return 1
    # Setup the common git rebase args that we use for all projects.
    common_args = ['rebase']
    if opt.whitespace:
      common_args.append('--whitespace=%s' % opt.whitespace)
    if opt.quiet:
      common_args.append('--quiet')
    if opt.force_rebase:
      common_args.append('--force-rebase')
    if opt.no_ff:
      common_args.append('--no-ff')
    if opt.autosquash:
      common_args.append('--autosquash')
    if opt.interactive:
      common_args.append('-i')
    config = self.manifest.manifestProject.config
    out = RebaseColoring(config)
    out.redirect(sys.stdout)
    ret = 0
    for project in all_projects:
      if ret and opt.fail_fast:
        break
      cb = project.CurrentBranch
      if not cb:
        if one_project:
          print("error: project %s has a detached HEAD" % project.relpath,
                file=sys.stderr)
-          return -1
+          return 1
        # ignore branches with detatched HEADs
        continue
@ -82,34 +123,21 @@ branch but need to incorporate new upstream changes "underneath" them.
        if one_project:
          print("error: project %s does not track any remote branches"
                % project.relpath, file=sys.stderr)
-          return -1
+          return 1
        # ignore branches without remotes
        continue
-      args = ["rebase"]
+      args = common_args[:]
-
+      if opt.onto_manifest:
-      if opt.whitespace:
+        args.append('--onto')
-        args.append('--whitespace=%s' % opt.whitespace)
+        args.append(project.revisionExpr)
      if opt.quiet:
        args.append('--quiet')
      if opt.force_rebase:
        args.append('--force-rebase')
      if opt.no_ff:
        args.append('--no-ff')
      if opt.autosquash:
        args.append('--autosquash')
      if opt.interactive:
        args.append("-i")
      args.append(upbranch.LocalMerge)
-      print('# %s: rebasing %s -> %s'
+      out.project('project %s: rebasing %s -> %s',
-            % (project.relpath, cb, upbranch.LocalMerge), file=sys.stderr)
+                  project.relpath, cb, upbranch.LocalMerge)
      out.nl()
      out.flush()
      needs_stash = False
      if opt.auto_stash:
@ -121,13 +149,21 @@ branch but need to incorporate new upstream changes "underneath" them.
          stash_args = ["stash"]
          if GitCommand(project, stash_args).Wait() != 0:
-            return -1
+            ret += 1
            continue
      if GitCommand(project, args).Wait() != 0:
-        return -1
+        ret += 1
        continue
      if needs_stash:
        stash_args.append('pop')
        stash_args.append('--quiet')
        if GitCommand(project, stash_args).Wait() != 0:
-          return -1
+          ret += 1
    if ret:
      out.fail('%i projects had errors', ret)
      out.nl()
    return ret
--- a/subcmds/selfupdate.py
+++ b/subcmds/selfupdate.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2009 The Android Open Source Project
 #
--- a/subcmds/smartsync.py
+++ b/subcmds/smartsync.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2010 The Android Open Source Project
 #
--- a/subcmds/stage.py
+++ b/subcmds/stage.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -60,8 +61,8 @@ The '%prog' command stages files to prepare the next commit.
      out.nl()
      for i in range(len(all_projects)):
-        p = all_projects[i]
+        project = all_projects[i]
-        out.write('%3d:    %s', i + 1, p.relpath + '/')
+        out.write('%3d:    %s', i + 1, project.relpath + '/')
        out.nl()
      out.nl()
--- a/subcmds/start.py
+++ b/subcmds/start.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -14,11 +15,15 @@
 # limitations under the License.
 from __future__ import print_function
 import os
 import sys
 from command import Command
-from git_config import IsId
+from git_config import IsImmutable
 from git_command import git
 import gitc_utils
 from progress import Progress
 from project import SyncBuffer
 class Start(Command):
  common = True
@ -35,34 +40,80 @@ revision specified in the manifest.
    p.add_option('--all',
                 dest='all', action='store_true',
                 help='begin branch in all projects')
    p.add_option('-r', '--rev', '--revision', dest='revision',
                 help='point branch at this revision instead of upstream')
    p.add_option('--head', dest='revision', action='store_const', const='HEAD',
                 help='abbreviation for --rev HEAD')
-  def Execute(self, opt, args):
+  def ValidateOptions(self, opt, args):
    if not args:
      self.Usage()
    nb = args[0]
    if not git.check_ref_format('heads/%s' % nb):
-      print("error: '%s' is not a valid name" % nb, file=sys.stderr)
+      self.OptionParser.error("'%s' is not a valid name" % nb)
      sys.exit(1)
  def Execute(self, opt, args):
    nb = args[0]
    err = []
    projects = []
    if not opt.all:
      projects = args[1:]
      if len(projects) < 1:
-        print("error: at least one project must be specified", file=sys.stderr)
+        projects = ['.',]  # start it in the local project by default
        sys.exit(1)
-    all_projects = self.GetProjects(projects)
+    all_projects = self.GetProjects(projects,
                                    missing_ok=bool(self.gitc_manifest))
    # This must happen after we find all_projects, since GetProjects may need
    # the local directory, which will disappear once we save the GITC manifest.
    if self.gitc_manifest:
      gitc_projects = self.GetProjects(projects, manifest=self.gitc_manifest,
                                       missing_ok=True)
      for project in gitc_projects:
        if project.old_revision:
          project.already_synced = True
        else:
          project.already_synced = False
          project.old_revision = project.revisionExpr
        project.revisionExpr = None
      # Save the GITC manifest.
      gitc_utils.save_manifest(self.gitc_manifest)
      # Make sure we have a valid CWD
      if not os.path.exists(os.getcwd()):
        os.chdir(self.manifest.topdir)
    pm = Progress('Starting %s' % nb, len(all_projects))
    for project in all_projects:
      pm.update()
-      # If the current revision is a specific SHA1 then we can't push back
+
-      # to it so substitute the manifest default revision instead.
+      if self.gitc_manifest:
-      if IsId(project.revisionExpr):
+        gitc_project = self.gitc_manifest.paths[project.relpath]
-        project.revisionExpr = self.manifest.default.revisionExpr
+        # Sync projects that have not been opened.
-      if not project.StartBranch(nb):
+        if not gitc_project.already_synced:
          proj_localdir = os.path.join(self.gitc_manifest.gitc_client_dir,
                                       project.relpath)
          project.worktree = proj_localdir
          if not os.path.exists(proj_localdir):
            os.makedirs(proj_localdir)
          project.Sync_NetworkHalf()
          sync_buf = SyncBuffer(self.manifest.manifestProject.config)
          project.Sync_LocalHalf(sync_buf)
          project.revisionId = gitc_project.old_revision
      # If the current revision is immutable, such as a SHA1, a tag or
      # a change, then we can't push back to it. Substitute with
      # dest_branch, if defined; or with manifest default revision instead.
      branch_merge = ''
      if IsImmutable(project.revisionExpr):
        if project.dest_branch:
          branch_merge = project.dest_branch
        else:
          branch_merge = self.manifest.default.revisionExpr
      if not project.StartBranch(
          nb, branch_merge=branch_merge, revision=opt.revision):
        err.append(project)
    pm.end()
--- a/subcmds/status.py
+++ b/subcmds/status.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -13,6 +14,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from __future__ import print_function
 from command import PagedCommand
 try:
@ -22,17 +25,11 @@ except ImportError:
 import glob
 from pyversion import is_python3
 if is_python3():
  import io
 else:
  import StringIO as io
 import itertools
 import os
 import sys
 from color import Coloring
 import platform_utils
 class Status(PagedCommand):
  common = True
@ -56,8 +53,7 @@ includes deeper items.  For example, if dir/subdir/proj1 and
 dir/subdir/proj2 are repo projects, dir/subdir/proj3 will be shown
 if it is not known to repo.
-Status Display
+# Status Display
 --------------
 The status display is organized into three columns of information,
 for example if the file 'subcmds/status.py' is modified in the
@ -96,8 +92,10 @@ the following meanings:
    p.add_option('-o', '--orphans',
                 dest='orphans', action='store_true',
                 help="include objects in working directory outside of repo projects")
    p.add_option('-q', '--quiet', action='store_true',
                 help="only print the name of modified projects")
-  def _StatusHelper(self, project, clean_counter, sem, output):
+  def _StatusHelper(self, project, clean_counter, sem, quiet):
    """Obtains the status for a specific project.
    Obtains the status for a project, redirecting the output to
@ -111,9 +109,9 @@ the following meanings:
      output: Where to output the status.
    """
    try:
-      state = project.PrintWorkTreeStatus(output)
+      state = project.PrintWorkTreeStatus(quiet=quiet)
      if state == 'CLEAN':
-        clean_counter.next()
+        next(clean_counter)
    finally:
      sem.release()
@ -121,17 +119,17 @@ the following meanings:
    """find 'dirs' that are present in 'proj_dirs_parents' but not in 'proj_dirs'"""
    status_header = ' --\t'
    for item in dirs:
-      if not os.path.isdir(item):
+      if not platform_utils.isdir(item):
-        outstring.write(''.join([status_header, item]))
+        outstring.append(''.join([status_header, item]))
        continue
      if item in proj_dirs:
        continue
      if item in proj_dirs_parents:
-        self._FindOrphans(glob.glob('%s/.*' % item) + \
+        self._FindOrphans(glob.glob('%s/.*' % item) +
-            glob.glob('%s/*' % item), \
+            glob.glob('%s/*' % item),
            proj_dirs, proj_dirs_parents, outstring)
        continue
-      outstring.write(''.join([status_header, item, '/']))
+      outstring.append(''.join([status_header, item, '/']))
  def Execute(self, opt, args):
    all_projects = self.GetProjects(args)
@ -139,32 +137,23 @@ the following meanings:
    if opt.jobs == 1:
      for project in all_projects:
-        state = project.PrintWorkTreeStatus()
+        state = project.PrintWorkTreeStatus(quiet=opt.quiet)
        if state == 'CLEAN':
-          counter.next()
+          next(counter)
    else:
      sem = _threading.Semaphore(opt.jobs)
-      threads_and_output = []
+      threads = []
      for project in all_projects:
        sem.acquire()
        class BufList(io.StringIO):
          def dump(self, ostream):
            for entry in self.buflist:
              ostream.write(entry)
        output = BufList()
        t = _threading.Thread(target=self._StatusHelper,
-                              args=(project, counter, sem, output))
+                              args=(project, counter, sem, opt.quiet))
-        threads_and_output.append((t, output))
+        threads.append(t)
        t.daemon = True
        t.start()
-      for (t, output) in threads_and_output:
+      for t in threads:
        t.join()
-        output.dump(sys.stdout)
+    if not opt.quiet and len(all_projects) == next(counter):
        output.close()
    if len(all_projects) == counter.next():
      print('nothing to commit (working directory clean)')
    if opt.orphans:
@ -188,23 +177,21 @@ the following meanings:
      try:
        os.chdir(self.manifest.topdir)
-        outstring = io.StringIO()
+        outstring = []
-        self._FindOrphans(glob.glob('.*') + \
+        self._FindOrphans(glob.glob('.*') +
-            glob.glob('*'), \
+            glob.glob('*'),
            proj_dirs, proj_dirs_parents, outstring)
-        if outstring.buflist:
+        if outstring:
          output = StatusColoring(self.manifest.globalConfig)
          output.project('Objects not within a project (orphans)')
          output.nl()
-          for entry in outstring.buflist:
+          for entry in outstring:
            output.untracked(entry)
            output.nl()
        else:
          print('No orphan files or directories')
        outstring.close()
      finally:
        # Restore CWD.
        os.chdir(orig_path)
--- a/subcmds/sync.py
+++ b/subcmds/sync.py
--- a/subcmds/upload.py
+++ b/subcmds/upload.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2008 The Android Open Source Project
 #
@ -26,9 +27,9 @@ from project import RepoHook
 from pyversion import is_python3
 if not is_python3():
  # pylint:disable=W0622
  input = raw_input
-  # pylint:enable=W0622
+else:
  unicode = str
 UNUSUAL_COMMIT_THRESHOLD = 5
@ -78,8 +79,7 @@ added to the respective list of users, and emails are sent to any
 new users.  Users passed as --reviewers must already be registered
 with the code review system, or the upload will fail.
-Configuration
+# Configuration
 -------------
 review.URL.autoupload:
@ -89,6 +89,11 @@ to "true" then repo will assume you always answer "y" at the prompt,
 and will not prompt you further.  If it is set to "false" then repo
 will assume you always answer "n", and will abort.
 review.URL.autoreviewer:
 To automatically append a user or mailing list to reviews, you can set
 a per-project or global Git option to do so.
 review.URL.autocopy:
 To automatically copy a user or mailing list to all uploaded reviews,
@ -121,10 +126,9 @@ is set to "true" then repo will assume you always want the equivalent
 of the -t option to the repo command. If unset or set to "false" then
 repo will make use of only the command line option.
-References
+# References
 ----------
-Gerrit Code Review:  http://code.google.com/p/gerrit/
+Gerrit Code Review:  https://www.gerritcodereview.com/
 """
@ -147,6 +151,19 @@ Gerrit Code Review:  http://code.google.com/p/gerrit/
    p.add_option('-d', '--draft',
                 action='store_true', dest='draft', default=False,
                 help='If specified, upload as a draft.')
    p.add_option('--ne', '--no-emails',
                 action='store_false', dest='notify', default=True,
                 help='If specified, do not send emails on upload.')
    p.add_option('-p', '--private',
                 action='store_true', dest='private', default=False,
                 help='If specified, upload as a private change.')
    p.add_option('-w', '--wip',
                 action='store_true', dest='wip', default=False,
                 help='If specified, upload as a work-in-progress change.')
    p.add_option('-o', '--push-option',
                 type='string', action='append', dest='push_options',
                 default=[],
                 help='Additional push options to transmit')
    p.add_option('-D', '--destination', '--dest',
                 type='string', action='store', dest='dest_branch',
                 metavar='BRANCH',
@ -168,6 +185,9 @@ Gerrit Code Review:  http://code.google.com/p/gerrit/
    #   Never run upload hooks, but upload anyway (AKA bypass hooks).
    # - no-verify=True, verify=True:
    #   Invalid
    p.add_option('--no-cert-checks',
                 dest='validate_certs', action='store_false', default=True,
                 help='Disable verifying ssl certs (unsafe).')
    p.add_option('--no-verify',
                 dest='bypass_hooks', action='store_true',
                 help='Do not run the upload hook.')
@ -191,7 +211,8 @@ Gerrit Code Review:  http://code.google.com/p/gerrit/
      commit_list = branch.commits
      destination = opt.dest_branch or project.dest_branch or project.revisionExpr
-      print('Upload project %s/ to remote branch %s:' % (project.relpath, destination))
+      print('Upload project %s/ to remote branch %s%s:' %
            (project.relpath, destination, ' (draft)' if opt.draft else ''))
      print('  branch %s (%2d commit%s, %s):' % (
                    name,
                    len(commit_list),
@ -200,7 +221,9 @@ Gerrit Code Review:  http://code.google.com/p/gerrit/
      for commit in commit_list:
        print('         %s' % commit)
-      sys.stdout.write('to %s (y/N)? ' % remote.review)
+      print('to %s (y/N)? ' % remote.review, end='')
      # TODO: When we require Python 3, use flush=True w/print above.
      sys.stdout.flush()
      answer = sys.stdin.readline().strip().lower()
      answer = answer in ('y', 'yes', '1', 'true', 't')
@ -293,14 +316,20 @@ Gerrit Code Review:  http://code.google.com/p/gerrit/
    self._UploadAndReport(opt, todo, people)
-  def _AppendAutoCcList(self, branch, people):
+  def _AppendAutoList(self, branch, people):
    """
    Appends the list of reviewers in the git project's config.
    Appends the list of users in the CC list in the git project's config if a
    non-empty reviewer list was found.
    """
    name = branch.name
    project = branch.project
    key = 'review.%s.autoreviewer' % project.GetBranch(name).remote.review
    raw_list = project.config.GetString(key)
    if not raw_list is None:
      people[0].extend([entry.strip() for entry in raw_list.split(',')])
    key = 'review.%s.autocopy' % project.GetBranch(name).remote.review
    raw_list = project.config.GetString(key)
    if not raw_list is None and len(people[0]) > 0:
@ -323,16 +352,23 @@ Gerrit Code Review:  http://code.google.com/p/gerrit/
    for branch in todo:
      try:
        people = copy.deepcopy(original_people)
-        self._AppendAutoCcList(branch, people)
+        self._AppendAutoList(branch, people)
        # Check if there are local changes that may have been forgotten
-        if branch.project.HasChanges():
+        changes = branch.project.UncommitedFiles()
        if changes:
          key = 'review.%s.autoupload' % branch.project.remote.review
          answer = branch.project.config.GetBoolean(key)
          # if they want to auto upload, let's not ask because it could be automated
          if answer is None:
-            sys.stdout.write('Uncommitted changes in ' + branch.project.name + ' (did you forget to amend?). Continue uploading? (y/N) ')
+            print()
            print('Uncommitted changes in %s (did you forget to amend?):'
                  % branch.project.name)
            print('\n'.join(changes))
            print('Continue uploading? (y/N) ', end='')
            # TODO: When we require Python 3, use flush=True w/print above.
            sys.stdout.flush()
            a = sys.stdin.readline().strip().lower()
            if a not in ('y', 'yes', 't', 'true', 'on'):
              print("skipping upload", file=sys.stderr)
@ -360,7 +396,16 @@ Gerrit Code Review:  http://code.google.com/p/gerrit/
            branch.uploaded = False
            continue
-        branch.UploadForReview(people, auto_topic=opt.auto_topic, draft=opt.draft, dest_branch=destination)
+        branch.UploadForReview(people,
                               auto_topic=opt.auto_topic,
                               draft=opt.draft,
                               private=opt.private,
                               notify=None if opt.notify else 'NONE',
                               wip=opt.wip,
                               dest_branch=destination,
                               validate_certs=opt.validate_certs,
                               push_options=opt.push_options)
        branch.uploaded = True
      except UploadError as e:
        branch.error = e
@ -437,11 +482,17 @@ Gerrit Code Review:  http://code.google.com/p/gerrit/
      if avail:
        pending.append((project, avail))
-    if pending and (not opt.bypass_hooks):
+    if not pending:
      print("no branches ready for upload", file=sys.stderr)
      return
    if not opt.bypass_hooks:
      hook = RepoHook('pre-upload', self.manifest.repo_hooks_project,
-                      self.manifest.topdir, abort_if_user_denies=True)
+                      self.manifest.topdir,
-      pending_proj_names = [project.name for (project, avail) in pending]
+                      self.manifest.manifestProject.GetRemote('origin').url,
-      pending_worktrees = [project.worktree for (project, avail) in pending]
+                      abort_if_user_denies=True)
      pending_proj_names = [project.name for (project, available) in pending]
      pending_worktrees = [project.worktree for (project, available) in pending]
      try:
        hook.Run(opt.allow_all_hooks, project_list=pending_proj_names,
                 worktree_list=pending_worktrees)
@ -455,9 +506,7 @@ Gerrit Code Review:  http://code.google.com/p/gerrit/
      cc = _SplitEmails(opt.cc)
    people = (reviewers, cc)
-    if not pending:
+    if len(pending) == 1 and len(pending[0][1]) == 1:
      print("no branches ready for upload", file=sys.stderr)
    elif len(pending) == 1 and len(pending[0][1]) == 1:
      self._SingleBranch(opt, pending[0][1][0], people)
    else:
      self._MultipleBranches(opt, pending, people)
--- a/subcmds/version.py
+++ b/subcmds/version.py
@ -1,3 +1,4 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2009 The Android Open Source Project
 #
@ -16,7 +17,7 @@
 from __future__ import print_function
 import sys
 from command import Command, MirrorSafeCommand
-from git_command import git
+from git_command import git, RepoSourceVersion, user_agent
 from git_refs import HEAD
 class Version(Command, MirrorSafeCommand):
@ -33,12 +34,20 @@ class Version(Command, MirrorSafeCommand):
    rp = self.manifest.repoProject
    rem = rp.GetRemote(rp.remote.name)
-    print('repo version %s' % rp.work_git.describe(HEAD))
+    # These might not be the same.  Report them both.
    src_ver = RepoSourceVersion()
    rp_ver = rp.bare_git.describe(HEAD)
    print('repo version %s' % rp_ver)
    print('       (from %s)' % rem.url)
    if Version.wrapper_path is not None:
      print('repo launcher version %s' % Version.wrapper_version)
      print('       (from %s)' % Version.wrapper_path)
-    print(git.version().strip())
+      if src_ver != rp_ver:
        print('       (currently at %s)' % src_ver)
    print('repo User-Agent %s' % user_agent.repo)
    print('git %s' % git.version_tuple().full)
    print('git User-Agent %s' % user_agent.git)
    print('Python %s' % sys.version)
--- a/tests/fixtures/.gitignore
+++ b/tests/fixtures/.gitignore
@ -0,0 +1,2 @@
 /.repo_not.present.gitconfig.json
 /.repo_test.gitconfig.json
--- a/tests/fixtures/gitc_config
+++ b/tests/fixtures/gitc_config
@ -0,0 +1 @@
 gitc_dir=/test/usr/local/google/gitc
--- a/tests/test_git_command.py
+++ b/tests/test_git_command.py
@ -0,0 +1,78 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright 2019 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Unittests for the git_command.py module."""
 from __future__ import print_function
 import re
 import unittest
 import git_command
 class GitCallUnitTest(unittest.TestCase):
  """Tests the _GitCall class (via git_command.git)."""
  def test_version_tuple(self):
    """Check git.version_tuple() handling."""
    ver = git_command.git.version_tuple()
    self.assertIsNotNone(ver)
    # We don't dive too deep into the values here to avoid having to update
    # whenever git versions change.  We do check relative to this min version
    # as this is what `repo` itself requires via MIN_GIT_VERSION.
    MIN_GIT_VERSION = (1, 7, 2)
    self.assertTrue(isinstance(ver.major, int))
    self.assertTrue(isinstance(ver.minor, int))
    self.assertTrue(isinstance(ver.micro, int))
    self.assertGreater(ver.major, MIN_GIT_VERSION[0] - 1)
    self.assertGreaterEqual(ver.micro, 0)
    self.assertGreaterEqual(ver.major, 0)
    self.assertGreaterEqual(ver, MIN_GIT_VERSION)
    self.assertLess(ver, (9999, 9999, 9999))
    self.assertNotEqual('', ver.full)
 class UserAgentUnitTest(unittest.TestCase):
  """Tests the UserAgent function."""
  def test_smoke_os(self):
    """Make sure UA OS setting returns something useful."""
    os_name = git_command.user_agent.os
    # We can't dive too deep because of OS/tool differences, but we can check
    # the general form.
    m = re.match(r'^[^ ]+$', os_name)
    self.assertIsNotNone(m)
  def test_smoke_repo(self):
    """Make sure repo UA returns something useful."""
    ua = git_command.user_agent.repo
    # We can't dive too deep because of OS/tool differences, but we can check
    # the general form.
    m = re.match(r'^git-repo/[^ ]+ ([^ ]+) git/[^ ]+ Python/[0-9.]+', ua)
    self.assertIsNotNone(m)
  def test_smoke_git(self):
    """Make sure git UA returns something useful."""
    ua = git_command.user_agent.git
    # We can't dive too deep because of OS/tool differences, but we can check
    # the general form.
    m = re.match(r'^git/[^ ]+ ([^ ]+) git-repo/[^ ]+', ua)
    self.assertIsNotNone(m)
--- a/tests/test_git_config.py
+++ b/tests/test_git_config.py
@ -1,3 +1,23 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2009 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Unittests for the git_config.py module."""
 from __future__ import print_function
 import os
 import unittest
--- a/tests/test_project.py
+++ b/tests/test_project.py
@ -0,0 +1,62 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2019 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Unittests for the project.py module."""
 from __future__ import print_function
 import unittest
 import project
 class RepoHookShebang(unittest.TestCase):
  """Check shebang parsing in RepoHook."""
  def test_no_shebang(self):
    """Lines w/out shebangs should be rejected."""
    DATA = (
        '',
        '# -*- coding:utf-8 -*-\n',
        '#\n# foo\n',
        '# Bad shebang in script\n#!/foo\n'
    )
    for data in DATA:
      self.assertIsNone(project.RepoHook._ExtractInterpFromShebang(data))
  def test_direct_interp(self):
    """Lines whose shebang points directly to the interpreter."""
    DATA = (
        ('#!/foo', '/foo'),
        ('#! /foo', '/foo'),
        ('#!/bin/foo ', '/bin/foo'),
        ('#! /usr/foo ', '/usr/foo'),
        ('#! /usr/foo -args', '/usr/foo'),
    )
    for shebang, interp in DATA:
      self.assertEqual(project.RepoHook._ExtractInterpFromShebang(shebang),
                       interp)
  def test_env_interp(self):
    """Lines whose shebang launches through `env`."""
    DATA = (
        ('#!/usr/bin/env foo', 'foo'),
        ('#!/bin/env foo', 'foo'),
        ('#! /bin/env /bin/foo ', '/bin/foo'),
    )
    for shebang, interp in DATA:
      self.assertEqual(project.RepoHook._ExtractInterpFromShebang(shebang),
                       interp)
--- a/tests/test_wrapper.py
+++ b/tests/test_wrapper.py
@ -0,0 +1,80 @@
 # -*- coding:utf-8 -*-
 #
 # Copyright (C) 2015 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Unittests for the wrapper.py module."""
 from __future__ import print_function
 import os
 import unittest
 import wrapper
 def fixture(*paths):
  """Return a path relative to tests/fixtures.
  """
  return os.path.join(os.path.dirname(__file__), 'fixtures', *paths)
 class RepoWrapperUnitTest(unittest.TestCase):
  """Tests helper functions in the repo wrapper
  """
  def setUp(self):
    """Load the wrapper module every time
    """
    wrapper._wrapper_module = None
    self.wrapper = wrapper.Wrapper()
  def test_get_gitc_manifest_dir_no_gitc(self):
    """
    Test reading a missing gitc config file
    """
    self.wrapper.GITC_CONFIG_FILE = fixture('missing_gitc_config')
    val = self.wrapper.get_gitc_manifest_dir()
    self.assertEqual(val, '')
  def test_get_gitc_manifest_dir(self):
    """
    Test reading the gitc config file and parsing the directory
    """
    self.wrapper.GITC_CONFIG_FILE = fixture('gitc_config')
    val = self.wrapper.get_gitc_manifest_dir()
    self.assertEqual(val, '/test/usr/local/google/gitc')
  def test_gitc_parse_clientdir_no_gitc(self):
    """
    Test parsing the gitc clientdir without gitc running
    """
    self.wrapper.GITC_CONFIG_FILE = fixture('missing_gitc_config')
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/something'), None)
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/gitc/manifest-rw/test'), 'test')
  def test_gitc_parse_clientdir(self):
    """
    Test parsing the gitc clientdir
    """
    self.wrapper.GITC_CONFIG_FILE = fixture('gitc_config')
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/something'), None)
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/gitc/manifest-rw/test'), 'test')
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/gitc/manifest-rw/test/'), 'test')
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/gitc/manifest-rw/test/extra'), 'test')
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/test/usr/local/google/gitc/test'), 'test')
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/test/usr/local/google/gitc/test/'), 'test')
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/test/usr/local/google/gitc/test/extra'), 'test')
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/gitc/manifest-rw/'), None)
    self.assertEqual(self.wrapper.gitc_parse_clientdir('/test/usr/local/google/gitc/'), None)
 if __name__ == '__main__':
  unittest.main()
--- a/wrapper.py
+++ b/wrapper.py
@ -1,4 +1,4 @@
-#!/usr/bin/env python
+# -*- coding:utf-8 -*-
 #
 # Copyright (C) 2014 The Android Open Source Project
 #
@ -15,7 +15,12 @@
 # limitations under the License.
 from __future__ import print_function
-import imp
+try:
  from importlib.machinery import SourceFileLoader
  _loader = lambda *args: SourceFileLoader(*args).load_module()
 except ImportError:
  import imp
  _loader = lambda *args: imp.load_source(*args)
 import os
@ -26,5 +31,5 @@ _wrapper_module = None
 def Wrapper():
  global _wrapper_module
  if not _wrapper_module:
-    _wrapper_module = imp.load_source('wrapper', WrapperPath())
+    _wrapper_module = _loader('wrapper', WrapperPath())
  return _wrapper_module
		`@ -0,0 +1,2 @@`
							`/.repo_not.present.gitconfig.json`
							`/.repo_test.gitconfig.json`