Android源代碼倉庫及其管理工具Repo分析

軟件工程由於需要不斷迭代開發，因此要對源代碼進行版本管理。Android源代碼工程（AOSP）也不例外，它采用Git來進行版本管理。AOSP作為一個大型開放源代碼工程，由許許多多子項目組成，因此不能簡單地用Git進行管理，它在Git的基礎上建立了一套自己的代碼倉庫，並且使用工具Repo進行管理。工欲善其事，必先利其器。本文就對AOSP代碼倉庫及其管理工具repo進行分析，以便提高我們日常開發效率。

老羅的新浪微博：http://weibo.com/shengyangluo，歡迎關注！

現代的代碼版本管理工具，SVN和Git是最流行的。SVN是一種集中式的代碼管理工具，需要有一個中心服務器，而Git是一種分布式的代碼管理工具。不需要一個中心服務器。不需要中心服務器意味著在沒有網絡的情況下，Git也能進行版本管理。因此，單從這一點出發，Git就比SVN要方便很多。當然，Git和SVN相比，還有許多不同的理念設計，但是總的來說，Git越來越受到大家的青睐，尤其是在開源社區。君不見，Linux是采用Git進行版本管理，而越來越火的GitHub，提供也是Git代碼管理服務。本文不打算分析Git與SVN的區別，以及Git的使用方法，不過強烈建議大家先去了解Git，然後再看下面的內容。這裡推薦一本Git書籍《Pro Git》，它是GitHub的員工Scott Chacon撰寫的，對Git的使用及其原理都介紹得非常詳細和清晰。

前面提到，AOSP是由許許多項目組成的，例如，在Android 4.2中，就包含了329個項目，每一個項目都是一個獨立的Git倉庫。這意味著，如果我們要創建一個AOSP分支來做feature開發，那麼就需要到每一個子項目去創建對應的分支。這顯然不能手動地到每一個子項目裡面去創建分支，必須要采用一種自動化的方式來處理。這些自動化處理工作就是由Repo工具來完成的。當然，Repo工具所負責的自動化工作不只是創建分支那麼簡單，查看分支狀態、提交代碼、更新代碼等基礎Git操作它都可以完成。

Repo工具實際上是由一系列的Python腳本組成的，這些Python腳本通過調用Git命令來完成自己的功能。比較有意思的是，組成Repo工具的那些Python腳本本身也是一個Git倉庫。這個Git倉庫在AOSP裡面就稱為Repo倉庫。我們每次執行Repo命令的時候，Repo倉庫都會對自己進行一次更新。

上面我們討論的是Repo倉庫，但是實際上我們執行Repo命令想操作的是AOSP。這就要求Repo命令要知道AOSP都包含有哪些子項目，並且要知道這些子項目的名稱、倉庫地址是什麼。換句話說，就是Repo命令要知道AOSP所有子項目的Git倉庫元信息。我們知道，AOSP也是不斷地迭代法變化的，例如，它的每一個版本所包含的子項目可能都是不一樣的。這意味著需要通過另外一個Git倉庫來管理AOSP所有的子項目的Git倉庫元信息。這個Git倉庫在AOSP裡面就稱為Manifest倉庫。

到目前為止，我們提到了三種類型的Git倉庫，分別是Repo倉庫、Manifest倉庫和AOSP子項目倉庫。Repo倉庫通過Manifest倉庫可以獲得所有AOSP子項目倉庫的元信息。有了這些元信息之後，我們就可以通過Repo倉庫裡面的Python腳本來操作AOSP的子項目。那麼，Repo倉庫和Manifest倉庫又是怎麼來的呢？答案是通過一個獨立的Repo腳本來獲取，這個Repo腳本位於AOSP的一個官方網站上，我們可以通過HTTP協議來下載。

現在，我們就通過一個圖來來勾勒一下整個AOSP的Picture，它由Repo腳本、Repo倉庫、Manifest倉庫和AOSP子項目倉庫組成，如圖1所示：

圖1 Repo腳本、Repo倉庫、Manifest倉庫和AOSP子項目倉庫<喎?/kf/ware/vc/" target="_blank" class="keylink">vcD48cD4gICAgICAgvdPPwsC0ztLDx77Nv7S/tMnPyva9xbG+us2y1r/iysfU9cO0wLS1xKGjPC9wPjxwPiAgICAgICAxLiBSZXBvvcWxvjwvcD48cD4gICAgICAgtNO52be9zfjVvr/J0tTWqrXAo6xSZXBvvcWxvr/J0tTNqLn90tTPwsP8we7AtLvxyKGjujwvcD48cD48L3A+PHByZSBjbGFzcz0="brush:java;">$ curl http://commondatastorage.googleapis.com/git-repo-downloads/repo > ~/bin/repo $ chmod a+x ~/bin/repo 也就是可以通過curl工具從http://commondatastorage.googleapis.com/git-repo-downloads/repo獲得，並且保存在文件~/bin/repo中。由於~/bin/repo是一個python腳本，我們通過chmod命令賦予它可執行的權限，以便接下來我們可以通過repo命令來運行它。

2. Repo倉庫

我們下載好Repo腳本之後，要選通過以下命令來安裝一個Repo倉庫：

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

我們看看Repo腳本是如何執行repo init命令的：

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:])

_FindRepo的實現如下所示：

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))

_RunSelf檢查Repo腳本所在目錄是否存在一個Repo倉庫，如果存在的話，就從該倉庫克隆一個新的倉庫到執行Repo腳本的目錄來。實際上就是從本地克隆一個新的Repo倉庫。如果不存在的話，那麼就需要從遠程地址克隆一個Repo倉庫到本地來。這個遠程地址是Hard Code在Repo腳本裡面。

_RunSelf的實現如下所示：

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

(1). 存在一個.git目錄；

(2). 存在一個main.py文件；

(3). 存在一個git_config.py文件；

(4). 存在一個project.py文件；

(5). 存在一個subcmds目錄。

上述目錄和文件實際上都是一個標准的Repo倉庫所具有的。

我們再回到main函數中。如果調用_FindRepo得到的repo_main的值等於空，那麼就說明當前目錄還沒有安裝Repo倉庫，這時候Repo後面所跟的參數只能是help或者init，否則的話，就會顯示錯誤信息。如果Repo後面跟的參數是help，就打印出Repo腳本的幫助文檔。

我們關注Repo後面跟的參數是init的情況。這時候看一下調用_RunSelf的返回值my_git是否不等於空。如果不等於空的話，那麼就說明Repo腳本所在目錄存一個Repo倉庫，這時候就調用_SetDefaultsTo設置等一會要克隆的Repo倉庫源。

_SetDefaultsTo的實現如下所示：

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)

如果Repo腳本所在目錄不存在一個Repo倉庫，那麼默認就將https://gerrit.googlesource.com/git-repo設置為一會要克隆的Repo倉庫源，並且要克隆的分支是stable。否則的話，就以該Repo倉庫作為克隆源，並且以該Repo倉庫的當前分支作為要克隆的分支。

從前面的分析就可以知道，當我們執行"repo init"命令的時候：

(1). 如果我們只是從網上下載了一個Repo腳本，那麼在執行Repo命令的時候，就會從遠程克隆一個Repo倉庫到當前執行Repo腳本的目錄來。

(2). 如果我們從網上下載的是一個帶有Repo倉庫的Repo腳本，那麼在執行Repo命令的時候，就可以從本地克隆一個Repo倉庫到當前執行Repo腳本的目錄來。

我們再繼續看main函數的實現，它接下來調用_Init在當前執行Repo腳本的目錄下安裝一個Repo倉庫：

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:
    ......

_Init函數繼續檢查當前執行Repo腳本的目錄是否存在一個.repo目錄。如果不存在的話，那麼就新創建一個。接著是否需要驗證等一會克隆回來的Repo倉庫的GPG。如果需要驗證的話，那麼就會在調用_Clone函數來克隆好Repo倉庫之後，調用_Verify函數來驗證該Repo倉庫的GPG。

最關鍵的地方就在於函數_Clone函數和_Checkout函數的調用，前者用來從url指定的地方克隆一個倉庫到dst指定的地方來，實際上就是克隆到當前目錄下的./repo/repo目錄來，後者在克隆回來的倉庫中將branch分支checkout出來。

函數_Clone的實現如下所示：

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)

這個函數首先是調用"git init"在當前目錄下的.repo/repo子目錄初始化一個Git倉庫，接著再調用_SetConfig函來設置該Git倉庫的url信息等。再接著調用_DownloadBundle來檢查指定的url是否存在一個clone.bundle文件。如果存在這個clone.bundle文件的話，就以它作為Repo倉庫的克隆源。

函數_DownloadBundle的實現如下所示：

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()

回到函數_Clone中，如果存在對應的clone.bundle文件，並且能成功下載到該clone.bundle，接下來就調用函數_ImportBundle將它作為源倉庫克隆為新的Repo倉庫。函數_ImportBundle的實現如下所示：

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

函數_Fetch的實現如下所示：

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()

注意，以上只是克隆好了一個Repo倉庫，接下來還需要從這個Repo倉庫checkout出一個分支來，才能正常工作。從Repo倉庫checkout出一個分支是通過調用函數_Checkout來實現的：

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()

需要注意的是，這裡從倉庫checkout出分支不是使用“git checkout”命令來實現的，而是通過更底層的Git命令“git update-ref”來實現的。實際上，“git checkout”命令也是通過“git update-ref”命令來實現的，只不過它進行了更高層的封裝，更方便使用。如果我們去分析組成Repo倉庫的那些Python腳本命令，就會發現它們基本上都是通過底層的Git命令來完成Git功能的。

3. Manifest倉庫

我們接著再分析下面這個命令的執行：

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:])

_Repo類的成員函數_Run的實現如下所示：

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

_Repo類的成員函數_Run首先是在repo後面所帶的參數中，不是以橫線“-”開始的第一個選項，該選項就代表要執行的命令，該命令的名稱就保存在變量name中。接著根據變量name的值在_Repo類的成員變量commands中找到對應的命令模塊cmd，並且指定該命令模塊cmd的成員變量repodir和manifest的值。命令模塊cmd的成員變量repodir描述的就是AOSP的.repo目錄，成員變量manifest指向的是一個XmlManifest對象，它描述的是AOSP的Repo倉庫和Manifest倉庫。

我們看看XmlManifest類的構造函數，它定義在文件.repo/repo/xml_manifest.py文件中：

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'))

    ......

在AOSP中，每一個子項目（或者說倉庫）都用一個Project對象來描述。Project類定義在文件.repo/repo/project.py文件中，用來封裝對各個項目的基礎Git操作，例如，對項目進行暫存、提交和更新等。它的構造函數如下所示：

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 = []

manifest：指向一個XmlManifest對象，描述AOSP的Repo倉庫和Manifest倉庫元信息

name：項目名稱

remote：描述項目對應的遠程倉庫元信息

gitdir：項目的Git倉庫目錄

worktree：項目的工作目錄

relpath：項目的相對於AOSP根目錄的工作目錄

revisionExpr、revisionId、rebase、groups、sync_c、sync_s和upstream：每一個項目在.repo/repo/manifest.xml文件中都有對應的描述，這幾個屬性的值就來自於該manifest.xml文件對自己的描述的，它們的含義可以參考.repo/repo/docs/manifest-format.txt文件

parent：父項目

is_derived：如果一個項目含有子模塊（也是一個Git倉庫），那麼這些子模塊也會用一個Project對象來描述，這些Project的is_derived屬性會設置為true

dest_branch：用來code review的分支

這裡重點說一下項目的Git倉庫目錄和工作目錄的概念。一般來說，一個項目的Git倉庫目錄（默認為.git目錄）是位於工作目錄下面的，但是Git支持將一個項目的Git倉庫目錄和工作目錄分開來存放。在AOSP中，Repo倉庫的Git目錄（.git）位於工作目錄（.repo/repo）下，Manifest倉庫的Git目錄有兩份拷貝，一份（.git）位於工作目錄（.repo/manifests）下，另外一份位於.repo/manifests.git目錄，其余的AOSP子項目的工作目錄和Git目錄都是分開存放的，其中，工作目錄位於AOSP根目錄下，Git目錄位於.repo/repo/projects目錄下。

此外，每一個AOSP子項目的工作目錄也有一個.git目錄，不過這個.git目錄是一個符號鏈接，鏈接到.repo/repo/projects對應的Git目錄。這樣，我們就既可以在AOSP子項目的工作目錄下執行Git命令，也可以在其對應的Git目錄下執行Git命令。一般來說，要訪問到工作目錄的命令（例如git status）需要在工作目錄下執行，而不需要訪問工作目錄（例如git log）可以在Git目錄下執行。

Project類有兩個成員變量work_git和bare_git，它們指向的都是一個_GitGetByExec對象。用來封裝對Git命令的執行。其中，前者在執行Git命令的時候，會將當前目錄設置為項目的工作目錄，而後者在執行的時候，不會設置當前目錄，但是會將環境變量GIT_DIR的值設置為項目的Git目錄，也就是.repo/projects目錄下面的那些目錄。通過這種方式，Project類就可以根據需要來在工作目錄或者Git目錄下執行Git命令。

回到XmlManifest類的構造函數中，由於Repo和Manifest也是屬於Git倉庫，所以我們也需要創建一個Project對象來描述它們。不過，由於它們是比較特殊的Git倉庫（用來描述AOSP子項目元信息的Git倉庫），所以我們就使用另外一個類型為MetaProject的對象來描述它們。MetaProject類是從Project類繼承下來的，定義在project.py文件中，如下所示：

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)

回到_Repo類的成員函數_Run中，創建好用來描述Repo倉庫和Manifest倉庫的XmlManifest對象之後，就開始執行跟在repo腳本後面的不帶橫線“-”的選項所表示的命令。在我們這個場景中，這個命令就是init，它對應的Python模塊為.repo/repo/subcmds/init.py，入口函數為定義在該模塊的Init類的成員函數Execute，它的實現如下所示：

class Init(InteractiveCommand, MirrorSafeCommand):
    ......

  def Execute(self, opt, args):
    ......

    self._SyncManifest(opt)
    self._LinkManifest(opt.manifest_name)

    ......

Init類的成員函數_SyncManifest的實現如下所示：

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)

Init類的成員函數_SyncManifest執行以下操作：

(1). 檢查本地是否存在Manifest倉庫，即檢查用來描述Manifest倉庫MetaProject對象m的成員變量mExists值是否等於true。如果不等於的話，那麼就說明本地還沒有安裝過Manifest倉庫。這時候就需要調用該MetaProject對象m的成員函數_InitGitDir來在.repo/manifests目錄初始化一個Git倉庫。

(2). 調用用來描述Manifest倉庫MetaProject對象m的成員函數Sync_NetworkHalf來從遠程倉庫中克隆一個新的Manifest倉庫到本地來，或者更新本地的Manifest倉庫。這個遠程倉庫的地址即為在執行"repo init"命令時，通過-u指定的url，即https://android.googlesource.com/platform/manifest。

(3). 檢查"repo init"命令後面是否通過-b指定要在Manifest倉庫中checkout出來的分支。如果有的話，那麼就調用用來描述Manifest倉庫MetaProject對象m的成員函數MetaBranchSwitch做一些清理工作，以便接下來可以checkout到指定的分支。

(4). 調用用來描述Manifest倉庫MetaProject對象m的成員函數Sync_LocaHalf來執行checkout分支的操作。注意，要切換的分支在前面已經記錄在MetaProject對象m的成員變量revisionExpr中。

(5). 如果前面執行的是新安裝Manifest倉庫的操作，並且沒有通過-b選項指定要checkout的分支，那麼默認就checkout出一個default分支。

接下來，我們就主要分析MetaProject類的成員函數_InitGitDir、Sync_NetworkHalf和Sync_LocaHalf的實現。這幾個函數實際上都是由MetaProject的父類Project來實現的，因此，下面我們就分析Project類的成員函數_InitGitDir、Sync_NetworkHalf和Sync_LocaHalf的實現。

Project類的成員函數_InitGitDir的成員函數的實現如下所示：

class Project(object):
  ......

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

_GitGetByExec類的成員函數init是通過另外一個成員函數__getattr__來實現的，如下所示：

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

我們再來看Project類的成員函數Sync_NetworkHalf的實現：

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
 
    ......

(1). 檢查本地是否已經存在對應的Git倉庫。如果不存在，那麼就先調用另外一個成員函數_InitGitDir來初始化該Git倉庫。

(2). 調用另外一個成員函籹_RemoteFetch來從遠程倉庫更新本地倉庫。

Project類的成員函數_RemoteFetch的實現如下所示：

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))
    
    ......

接下來我們再看MetaProject類的成員函數Sync_LocaHalf的實現：

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

    ......

(1). 調用另外一個成員函數GetRevisionId獲得即將要checkout的分支，保存在變量revid中。

(2). 調用成員變量work_git所描述的一個_GitGetByExec對象的成員函數GetHead獲得項目當前checkout的分支，只存在變量head中。

(3). 如果即將要checkout的分支revid就是當前已經checkout分支，那麼就什麼也不用做。否則繼續往下執行。

(4). 調用另外一個成員函數GetBranch獲得用來描述當前分支的一個Branch對象。

(5). 如果上述Branch對象的屬性LocalMerge的值等於None，也就是屬於我們討論的情況，那麼就調用另外一個成員函數_Checkout真正執行checkout分支revid的操作。

如果要checkout的分支revid不是一個干淨的分支，也就是它正在跳蹤遠程分支，並且在本地做過提交，這些提交又沒有上傳到遠程分支去，那麼就需要執行一些merge或者rebase的操作。不過無論如何，這些操作都是通過標准的Git命令來完成的。

我們接著再看Project類的成員函數_Checkout的實現：

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))

至此，我們就將Manifest倉庫從遠程地址https://android.googlesource.com/platform/manifest克隆到本地來了，並且checkout出了指定的分支。回到Init類的成員函數Execute中，它接下來還要調用另外一個成員函數_LinkManifest來執行一個符號鏈接的操作。

Init類的成員函數_LinkManifest的實現如下所示：

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)))

  
  

  
    
  
  
  
  ......

$ 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