$ curl http://commondatastorage.googleapis.com/git-repo-downloads/repo > ~/bin/repo 
$ chmod a+x ~/bin/repo 

$ repo init -u https://android.googlesource.com/platform/manifest 

def main(orig_args): 
 repo_main, rel_repo_dir = _FindRepo() 
 cmd, opt, args = _ParseArguments(orig_args)  
 wrapper_path = os.path.abspath(__file__) 
 my_main, my_git = _RunSelf(wrapper_path) 
 
 if not repo_main: 
  if opt.help: 
   _Usage() 
  if cmd == 'help': 
   _Help(args) 
  if not cmd: 
   _NotInstalled() 
  if cmd == 'init': 
   if my_git: 
    _SetDefaultsTo(my_git) 
   try: 
    _Init(args) 
   except CloneFailure: 
    ...... 
    sys.exit(1) 
   repo_main, rel_repo_dir = _FindRepo() 
  else: 
   _NoCommands(cmd) 
  if my_main: 
  repo_main = my_main 
  ver_str = '.'.join(map(str, VERSION)) 
 me = [repo_main, 
    '--repo-dir=%s' % rel_repo_dir, 
    '--wrapper-version=%s' % ver_str, 
    '--wrapper-path=%s' % wrapper_path, 
    '--'] 
 me.extend(orig_args) 
 me.extend(extra_args) 
 try: 
  os.execv(repo_main, me) 
 except OSError as e: 
  ...... 
  sys.exit(148)  
if __name__ == '__main__': 
 main(sys.argv[1:]) 

repodir = '.repo'   # name of repo's private directory 
S_repo = 'repo'    # special repo repository 
REPO_MAIN = S_repo + '/main.py' # main script  
def _FindRepo(): 
 """Look for a repo installation, starting at the current directory. 
 """ 
 curdir = os.getcwd() 
 repo = None  
 olddir = None 
 while curdir != '/' \ 
  and curdir != olddir \ 
  and not repo: 
  repo = os.path.join(curdir, repodir, REPO_MAIN) 
  if not os.path.isfile(repo): 
   repo = None 
   olddir = curdir 
   curdir = os.path.dirname(curdir) 
 return (repo, os.path.join(curdir, repodir)) 

def _RunSelf(wrapper_path): 
 my_dir = os.path.dirname(wrapper_path) 
 my_main = os.path.join(my_dir, 'main.py') 
 my_git = os.path.join(my_dir, '.git') 
 
 if os.path.isfile(my_main) and os.path.isdir(my_git): 
  for name in ['git_config.py', 
         'project.py', 
         'subcmds']: 
   if not os.path.exists(os.path.join(my_dir, name)): 
    return None, None 
  return my_main, my_git 
 return None, None 

GIT = 'git'  
REPO_URL = 'https://gerrit.googlesource.com/git-repo' 
REPO_REV = 'stable'  
def _SetDefaultsTo(gitdir): 
 global REPO_URL 
 global REPO_REV  
 REPO_URL = gitdir 
 proc = subprocess.Popen([GIT, 
              '--git-dir=%s' % gitdir, 
              'symbolic-ref', 
              'HEAD'], 
             stdout = subprocess.PIPE, 
             stderr = subprocess.PIPE) 
 REPO_REV = proc.stdout.read().strip() 
 proc.stdout.close()  
 proc.stderr.read() 
 proc.stderr.close()  
 if proc.wait() != 0: 
  _print('fatal: %s has no current branch' % gitdir, file=sys.stderr) 
  sys.exit(1) 

def _Init(args): 
 """Installs repo by cloning it over the network. 
 """ 
 opt, args = init_optparse.parse_args(args) 
 ...... 
 
 url = opt.repo_url 
 if not url: 
  url = REPO_URL 
  extra_args.append('--repo-url=%s' % url) 
 
 branch = opt.repo_branch 
 if not branch: 
  branch = REPO_REV 
  extra_args.append('--repo-branch=%s' % branch) 
 
 ...... 
 
 if not os.path.isdir(repodir): 
  try: 
   os.mkdir(repodir) 
  except OSError as e: 
   ...... 
   sys.exit(1) 
 
 _CheckGitVersion() 
 try: 
  if NeedSetupGnuPG(): 
   can_verify = SetupGnuPG(opt.quiet) 
  else: 
   can_verify = True 
 
  dst = os.path.abspath(os.path.join(repodir, S_repo)) 
  _Clone(url, dst, opt.quiet) 
 
  if can_verify and not opt.no_repo_verify: 
   rev = _Verify(dst, branch, opt.quiet) 
  else: 
   rev = 'refs/remotes/origin/%s^0' % branch 
 
  _Checkout(dst, branch, rev, opt.quiet) 
 except CloneFailure: 
  ...... 

def _Clone(url, local, quiet): 
 """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), 
      file=sys.stderr) 
  raise CloneFailure()  
 cmd = [GIT, 'init', '--quiet'] 
 try: 
  proc = subprocess.Popen(cmd, cwd = local) 
 except OSError as e: 
 ......  
 ......  
 _InitHttp() 
 _SetConfig(local, 'remote.origin.url', url) 
 _SetConfig(local, 'remote.origin.fetch', 
          '+refs/heads/*:refs/remotes/origin/*') 
 if _DownloadBundle(url, local, quiet): 
  _ImportBundle(local) 
 else: 
  _Fetch(url, local, 'origin', quiet) 

def _DownloadBundle(url, local, quiet): 
 if not url.endswith('/'): 
  url += '/' 
 url += 'clone.bundle' 
 ......  
 if not url.startswith('http:') and not url.startswith('https:'): 
  return False  
 dest = open(os.path.join(local, '.git', 'clone.bundle'), 'w+b') 
 try: 
  try: 
   r = urllib.request.urlopen(url) 
  except urllib.error.HTTPError as e: 
   if e.code in [403, 404]: 
    return False 
   ...... 
   raise CloneFailure() 
  except urllib.error.URLError as e: 
   ...... 
   raise CloneFailure() 
  try: 
   if not quiet: 
    _print('Get %s' % url, file=sys.stderr) 
   while True: 
    buf = r.read(8192) 
    if buf == '': 
     return True 
    dest.write(buf) 
  finally: 
   r.close() 
 finally: 
  dest.close() 

def _ImportBundle(local): 
 path = os.path.join(local, '.git', 'clone.bundle') 
 try: 
  _Fetch(local, local, path, True) 
 finally: 
  os.remove(path) 

def _Fetch(url, local, src, quiet): 
 if not quiet: 
  _print('Get %s' % url, file=sys.stderr)  
 cmd = [GIT, 'fetch'] 
 if quiet: 
  cmd.append('--quiet') 
  err = subprocess.PIPE 
 else: 
  err = None 
 cmd.append(src) 
 cmd.append('+refs/heads/*:refs/remotes/origin/*') 
 cmd.append('refs/tags/*:refs/tags/*') 
 
 proc = subprocess.Popen(cmd, cwd = local, stderr = err) 
 if err: 
  proc.stderr.read() 
  proc.stderr.close() 
 if proc.wait() != 0: 
  raise CloneFailure() 

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: 
  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: 
  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: 
  raise CloneFailure() 

repo init -u https://android.googlesource.com/platform/manifest 

def _Main(argv): 
 result = 0 
 
 opt = optparse.OptionParser(usage="repo wrapperinfo -- ...") 
 opt.add_option("--repo-dir", dest="repodir", 
         help="path to .repo/") 
 ...... 
 
 repo = _Repo(opt.repodir) 
 try: 
  try: 
   init_ssh() 
   init_http() 
   result = repo._Run(argv) or 0 
  finally: 
   close_ssh() 
 except KeyboardInterrupt: 
  ...... 
  result = 1 
 except ManifestParseError as mpe: 
  ...... 
  result = 1 
 except RepoChangedException as rce: 
  # If repo changed, re-exec ourselves. 
  # 
  argv = list(sys.argv) 
  argv.extend(rce.extra_args) 
  try: 
   os.execv(__file__, argv) 
  except OSError as e: 
   ...... 
   result = 128 
 
 sys.exit(result) 
 
if __name__ == '__main__': 
 _Main(sys.argv[1:]) 

from subcmds import all_commands 
 class _Repo(object): 
 def __init__(self, repodir): 
  self.repodir = repodir 
  self.commands = all_commands 
  # add 'branch' as an alias for 'branches' 
  all_commands['branch'] = all_commands['branches'] 
  def _Run(self, argv): 
  result = 0 
  name = None 
  glob = [] 
 
  for i in range(len(argv)): 
   if not argv[i].startswith('-'): 
    name = argv[i] 
    if i > 0: 
     glob = argv[:i] 
    argv = argv[i + 1:] 
    break 
  if not name: 
   glob = argv 
   name = 'help' 
   argv = [] 
  gopts, _gargs = global_options.parse_args(glob)  
  ......  
  try: 
   cmd = self.commands[name] 
  except KeyError: 
   ...... 
   return 1  
  cmd.repodir = self.repodir 
  cmd.manifest = XmlManifest(cmd.repodir)  
  ......  
  try: 
   result = cmd.Execute(copts, cargs) 
  except DownloadError as e: 
   ...... 
   result = 1 
  except ManifestInvalidRevisionError as e: 
   ...... 
   result = 1 
  except NoManifestException as e: 
   ...... 
   result = 1 
  except NoSuchProjectError as e: 
   ...... 
   result = 1 
  finally: 
   ......  
  return result 

class XmlManifest(object): 
 """manages the repo configuration file"""  
 def __init__(self, repodir): 
  self.repodir = os.path.abspath(repodir) 
  self.topdir = os.path.dirname(self.repodir) 
  self.manifestFile = os.path.join(self.repodir, MANIFEST_FILE_NAME) 
  ......  
  self.repoProject = MetaProject(self, 'repo', 
   gitdir  = os.path.join(repodir, 'repo/.git'), 
   worktree = os.path.join(repodir, 'repo'))  
  self.manifestProject = MetaProject(self, 'manifests', 
   gitdir  = os.path.join(repodir, 'manifests.git'), 
   worktree = os.path.join(repodir, 'manifests'))  
  ...... 

class Project(object): 
 def __init__(self, 
        manifest, 
        name, 
        remote, 
        gitdir, 
        worktree, 
        relpath, 
        revisionExpr, 
        revisionId, 
        rebase = True, 
        groups = None, 
        sync_c = False, 
        sync_s = False, 
        clone_depth = None, 
        upstream = None, 
        parent = None, 
        is_derived = False, 
        dest_branch = None): 
  """Init a Project object. 
  Args: 
   manifest: The XmlManifest object. 
   name: The `name` attribute of manifest.xml's project element. 
   remote: RemoteSpec object specifying its remote's properties. 
   gitdir: Absolute path of git directory. 
   worktree: Absolute path of git working tree. 
   relpath: Relative path of git working tree to repo's top directory. 
   revisionExpr: The `revision` attribute of manifest.xml's project element. 
   revisionId: git commit id for checking out. 
   rebase: The `rebase` attribute of manifest.xml's project element. 
   groups: The `groups` attribute of manifest.xml's project element. 
   sync_c: The `sync-c` attribute of manifest.xml's project element. 
   sync_s: The `sync-s` attribute of manifest.xml's project element. 
   upstream: The `upstream` attribute of manifest.xml's project element. 
   parent: The parent Project object. 
   is_derived: False if the project was explicitly defined in the manifest; 
         True if the project is a discovered submodule. 
   dest_branch: The branch to which to push changes for review by default. 
  """ 
  self.manifest = manifest 
  self.name = name 
  self.remote = remote 
  self.gitdir = gitdir.replace('\\', '/') 
  if worktree: 
   self.worktree = worktree.replace('\\', '/') 
  else: 
   self.worktree = None 
  self.relpath = relpath 
  self.revisionExpr = revisionExpr 
 
  if  revisionId is None \ 
   and revisionExpr \ 
   and IsId(revisionExpr): 
   self.revisionId = revisionExpr 
  else: 
   self.revisionId = revisionId 
 
  self.rebase = rebase 
  self.groups = groups 
  self.sync_c = sync_c 
  self.sync_s = sync_s 
  self.clone_depth = clone_depth 
  self.upstream = upstream 
  self.parent = parent 
  self.is_derived = is_derived 
  self.subprojects = [] 
 
  self.snapshots = {} 
  self.copyfiles = [] 
  self.annotations = [] 
  self.config = GitConfig.ForRepository( 
          gitdir = self.gitdir, 
          defaults = self.manifest.globalConfig) 
 
  if self.worktree: 
   self.work_git = self._GitGetByExec(self, bare=False) 
  else: 
   self.work_git = None 
  self.bare_git = self._GitGetByExec(self, bare=True) 
  self.bare_ref = GitRefs(gitdir) 
  self.dest_branch = dest_branch 
 
  # This will be filled in if a project is later identified to be the 
  # project containing repo hooks. 
  self.enabled_repo_hooks = [] 

class MetaProject(Project): 
 """A special project housed under .repo. 
 """ 
 def __init__(self, manifest, name, gitdir, worktree): 
  Project.__init__(self, 
           manifest = manifest, 
           name = name, 
           gitdir = gitdir, 
           worktree = worktree, 
           remote = RemoteSpec('origin'), 
           relpath = '.repo/%s' % name, 
           revisionExpr = 'refs/heads/master', 
           revisionId = None, 
           groups = None) 

class Init(InteractiveCommand, MirrorSafeCommand): 
  ......  
 def Execute(self, opt, args): 
  ...... 
 
  self._SyncManifest(opt) 
  self._LinkManifest(opt.manifest_name)  
  ...... 

class Init(InteractiveCommand, MirrorSafeCommand): 
 ...... 
  def _SyncManifest(self, opt): 
  m = self.manifest.manifestProject 
  is_new = not m.Exists 
   if is_new: 
    ......  
   m._InitGitDir(mirror_git=mirrored_manifest_git) 
 
   if opt.manifest_branch: 
    m.revisionExpr = opt.manifest_branch 
   else: 
    m.revisionExpr = 'refs/heads/master 
  else: 
   if opt.manifest_branch: 
    m.revisionExpr = opt.manifest_branch 
   else: 
    m.PreSync() 
 
  ...... 
   if not m.Sync_NetworkHalf(is_new=is_new): 
   ...... 
   sys.exit(1)  
  if opt.manifest_branch: 
   m.MetaBranchSwitch(opt.manifest_branch) 
  ......  
  m.Sync_LocalHalf(syncbuf) 
  ......  
  if is_new or m.CurrentBranch is None: 
   if not m.StartBranch('default'): 
    ...... 
    sys.exit(1) 

class Project(object): 
 ...... 
 
 def _InitGitDir(self, mirror_git=None): 
  if not os.path.exists(self.gitdir): 
   os.makedirs(self.gitdir) 
   self.bare_git.init() 
   ...... 

class Project(object): 
 ...... 
 
 class _GitGetByExec(object): 
  ...... 
 
  def __getattr__(self, name): 
   """Allow arbitrary git commands using pythonic syntax. 
 
   This allows you to do things like: 
    git_obj.rev_parse('HEAD') 
 
   Since we don't have a 'rev_parse' method defined, the __getattr__ will 
   run. We'll replace the '_' with a '-' and try to run a git command. 
   Any other positional arguments will be passed to the git command, and the 
   following keyword arguments are supported: 
    config: An optional dict of git config options to be passed with '-c'. 
 
   Args: 
    name: The name of the git command to call. Any '_' characters will 
      be replaced with '-'. 
 
   Returns: 
    A callable object that will try to call git with the named command. 
   """ 
   name = name.replace('_', '-') 
   def runner(*args, **kwargs): 
    cmdv = [] 
    config = kwargs.pop('config', None) 
    ...... 
    if config is not None: 
     ...... 
     for k, v in config.items(): 
      cmdv.append('-c') 
      cmdv.append('%s=%s' % (k, v)) 
    cmdv.append(name) 
    cmdv.extend(args) 
    p = GitCommand(self._project, 
            cmdv, 
            bare = self._bare, 
            capture_stdout = True, 
            capture_stderr = True) 
    if p.Wait() != 0: 
     ...... 
    r = p.stdout 
    try: 
     r = r.decode('utf-8') 
    except AttributeError: 
     pass 
    if r.endswith('\n') and r.index('\n') == len(r) - 1: 
     return r[:-1] 
    return r 
   return runner 

class Project(object): 
 ......  
 def Sync_NetworkHalf(self, 
   quiet=False, 
   is_new=None, 
   current_branch_only=False, 
   clone_bundle=True, 
   no_tags=False): 
  """Perform only the network IO portion of the sync process. 
    Local working directory/branch state is not affected. 
  """ 
  if is_new is None: 
   is_new = not self.Exists 
  if is_new: 
   self._InitGitDir()  
  ......  
  if not self._RemoteFetch(initial=is_new, quiet=quiet, alt_dir=alt_dir, 
               current_branch_only=current_branch_only, 
               no_tags=no_tags): 
   return False 
    ...... 

class Project(object): 
......  
def _RemoteFetch(self, name=None, 
          current_branch_only=False, 
          initial=False, 
          quiet=False, 
          alt_dir=None, 
          no_tags=False): 
  ......  
  cmd = ['fetch'] 
  ......  
  ok = False 
  for _i in range(2): 
   ret = GitCommand(self, cmd, bare=True, ssh_proxy=ssh_proxy).Wait() 
   if ret == 0: 
    ok = True 
    break 
   elif current_branch_only and is_sha1 and ret == 128: 
    # Exit code 128 means "couldn't find the ref you asked for"; if we're in sha1 
    # mode, we just tried sync'ing from the upstream field; it doesn't exist, thus 
    # abort the optimization attempt and do a full sync. 
    break 
   time.sleep(random.randint(30, 45))    
  ...... 

class Project(object): 
 ......  
 def Sync_LocalHalf(self, syncbuf): 
  """Perform only the local IO portion of the sync process. 
    Network access is not required. 
  """ 
  ...... 
  revid = self.GetRevisionId(all_refs) 
   ...... 
   self._InitWorkTree() 
  head = self.work_git.GetHead() 
  if head.startswith(R_HEADS): 
   branch = head[len(R_HEADS):] 
   try: 
    head = all_refs[head] 
   except KeyError: 
    head = None 
  else: 
   branch = None 
 
  ......  
  if head == revid: 
   # No changes; don't do anything further. 
   # 
   return 
 
  branch = self.GetBranch(branch) 
   ......  
  if not branch.LocalMerge: 
   # The current branch has no tracking configuration. 
   # Jump off it to a detached HEAD. 
   # 
   syncbuf.info(self, 
          "leaving %s; does not track upstream", 
          branch.name) 
   try: 
    self._Checkout(revid, quiet=True) 
   except GitError as e: 
    syncbuf.fail(self, e) 
    return 
   ...... 
   return  
  ...... 

class Project(object): 
 ...... 
 
 def _Checkout(self, rev, quiet=False): 
  cmd = ['checkout'] 
  if quiet: 
   cmd.append('-q') 
  cmd.append(rev) 
  cmd.append('--') 
  if GitCommand(self, cmd).Wait() != 0: 
   if self._allrefs: 
    raise GitError('%s checkout %s ' % (self.name, rev)) 

class Init(InteractiveCommand, MirrorSafeCommand): 
 ...... 
 
 def _LinkManifest(self, name): 
  if not name: 
   print('fatal: manifest name (-m) is required.', file=sys.stderr) 
   sys.exit(1) 
 
  try: 
   self.manifest.Link(name) 
  except ManifestParseError as e: 
   print("fatal: manifest '%s' not available" % name, file=sys.stderr) 
   print('fatal: %s' % str(e), file=sys.stderr) 
   sys.exit(1) 

class XmlManifest(object): 
 """manages the repo configuration file""" 
 ...... 
 
 def Link(self, name): 
  """Update the repo metadata to use a different manifest. 
  """ 
  ...... 
 
  try: 
   if os.path.lexists(self.manifestFile): 
    os.remove(self.manifestFile) 
   os.symlink('manifests/%s' % name, self.manifestFile) 
  except OSError as e: 
   raise ManifestParseError('cannot link manifest %s: %s' % (name, str(e))) 

<?xml version="1.0" encoding="UTF-8"?> 
<manifest>  
 <remote name="aosp" 
      fetch=".." 
      review="https://android-review.googlesource.com/" /> 
 <default revision="refs/tags/android-4.2_r1" 
      remote="aosp" 
      sync-j="4" />  
 <project path="build" name="platform/build" > 
  <copyfile src="core/root.mk" dest="Makefile" /> 
 </project> 
 <project path="abi/cpp" name="platform/abi/cpp" /> 
 <project path="bionic" name="platform/bionic" /> 
 ......  
</manifest> 

$ repo sync 

all_commands = {}  
my_dir = os.path.dirname(__file__) 
for py in os.listdir(my_dir): 
 if py == '__init__.py': 
  continue  
 if py.endswith('.py'): 
  name = py[:-3] 
  clsn = name.capitalize() 
  while clsn.find('_') > 0: 
   h = clsn.index('_') 
   clsn = clsn[0:h] + clsn[h + 1:].capitalize() 
   mod = __import__(__name__, 
           globals(), 
           locals(), 
           ['%s' % name]) 
  mod = getattr(mod, name) 
  try: 
   cmd = getattr(mod, clsn)() 
  except AttributeError: 
   raise SyntaxError('%s/%s does not define class %s' % ( 
             __name__, py, clsn)) 
 
  name = name.replace('_', '-') 
  cmd.NAME = name 
  all_commands[name] = cmd 

class Sync(Command, MirrorSafeCommand): 
 ...... 
 
 def Execute(self, opt, args): 
  ...... 
 
  mp = self.manifest.manifestProject 
  ...... 
 
  if not opt.local_only: 
   mp.Sync_NetworkHalf(quiet=opt.quiet, 
             current_branch_only=opt.current_branch_only, 
             no_tags=opt.no_tags) 
  ...... 
 
  if mp.HasChanges: 
   ...... 
   mp.Sync_LocalHalf(syncbuf) 
   ...... 
 
  all_projects = self.GetProjects(args, 
                  missing_ok=True, 
                  submodules_ok=opt.fetch_submodules) 
  ...... 
 
  if not opt.local_only: 
   to_fetch = [] 
   ...... 
   to_fetch.extend(all_projects) 
   to_fetch.sort(key=self._fetch_times.Get, reverse=True) 
 
   fetched = self._Fetch(to_fetch, opt) 
   ...... 
 
   if opt.network_only: 
    # bail out now; the rest touches the working tree 
    return 
 
   # Iteratively fetch missing and/or nested unregistered submodules 
   while True: 
    ...... 
    all_projects = self.GetProjects(args, 
                    missing_ok=True, 
                    submodules_ok=opt.fetch_submodules) 
    missing = [] 
    for project in all_projects: 
     if project.gitdir not in fetched: 
      missing.append(project) 
    if not missing: 
     break 
    ...... 
    fetched.update(self._Fetch(missing, opt)) 
 
  if self.UpdateProjectList(): 
   sys.exit(1) 
   ......  
  for project in all_projects: 
   ...... 
   if project.worktree: 
    project.Sync_LocalHalf(syncbuf)  
  ...... 

$ repo start BRANCH_NAME [PROJECT_LIST] 

class Start(Command): 
 ...... 
 
 def Execute(self, opt, args): 
  ...... 
 
  nb = args[0] 
  if not git.check_ref_format('heads/%s' % nb): 
   print("error: '%s' is not a valid name" % nb, file=sys.stderr) 
   sys.exit(1) 
 
  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) 
    sys.exit(1) 
 
  all_projects = self.GetProjects(projects) 
 
  pm = Progress('Starting %s' % nb, len(all_projects)) 
  for project in all_projects: 
   pm.update() 
   ...... 
   if not project.StartBranch(nb): 
    err.append(project) 
  pm.end() 
 
  ...... 

class Project(object): 
 ...... 
 
 def StartBranch(self, name): 
  """Create a new branch off the manifest's revision. 
  """ 
  head = self.work_git.GetHead() 
  if head == (R_HEADS + name): 
   return True 
 
  all_refs = self.bare_ref.all 
  if (R_HEADS + name) in all_refs: 
   return GitCommand(self, 
            ['checkout', name, '--'], 
            capture_stdout = True, 
            capture_stderr = True).Wait() == 0 
 
  branch = self.GetBranch(name) 
  branch.remote = self.GetRemote(self.remote.name) 
  branch.merge = self.revisionExpr 
  revid = self.GetRevisionId(all_refs) 
 
  if head.startswith(R_HEADS): 
   try: 
    head = all_refs[head] 
   except KeyError: 
    head = None 
 
  if revid and head and revid == head: 
   ref = os.path.join(self.gitdir, R_HEADS + name) 
   try: 
    os.makedirs(os.path.dirname(ref)) 
   except OSError: 
    pass 
   _lwrite(ref, '%s\n' % revid) 
   _lwrite(os.path.join(self.worktree, '.git', HEAD), 
       'ref: %s%s\n' % (R_HEADS, name)) 
   branch.Save() 
   return True 
 
  if GitCommand(self, 
         ['checkout', '-b', branch.name, revid], 
         capture_stdout = True, 
         capture_stderr = True).Wait() == 0: 
   branch.Save() 
   return True 
  return False