repo

#!/usr/bin/env python

## repo default configuration
##
from __future__ import print_function
REPO_URL = 'https://gerrit.googlesource.com/git-repo'
REPO_REV = 'stable'

# Copyright (C) 2008 Google Inc.
#
# 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.

# increment this whenever we make important changes to this script
VERSION = (1, 19)

# increment this if the MAINTAINER_KEYS block is modified
KEYRING_VERSION = (1, 1)
MAINTAINER_KEYS = """

 Repo Maintainer <repo@android.kernel.org>
-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.4.2.2 (GNU/Linux)
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=CMiZ
-----END PGP PUBLIC KEY BLOCK-----

 Conley Owens <cco3@android.com>
-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.4.11 (GNU/Linux)

mQENBFBiLPwBCACvISTASOgFXwADw2GYRH2I2z9RvYkYoZ6ThTTNlMXbbYYKO2Wo
a9LQDNW0TbCEekg5UKk0FD13XOdWaqUt4Gtuvq9c43GRSjMO6NXH+0BjcQ8vUtY2
/W4CYUevwdo4nQ1+1zsOCu1XYe/CReXq0fdugv3hgmRmh3sz1soo37Q44W2frxxg
U7Rz3Da4FjgAL0RQ8qndD+LwRHXTY7H7wYM8V/3cYFZV7pSodd75q3MAXYQLf0ZV
QR1XATu5l1QnXrxgHvz7MmDwb1D+jX3YPKnZveaukigQ6hDHdiVcePBiGXmk8LZC
2jQkdXeF7Su1ZYpr2nnEHLJ6vOLcCpPGb8gDABEBAAG0H0NvbmxleSBPd2VucyA8
Y2NvM0BhbmRyb2lkLmNvbT6JATgEEwECACIFAlBiLPwCGwMGCwkIBwMCBhUIAgkK
CwQWAgMBAh4BAheAAAoJEBkmlFUziHGkHVkH/2Hks2Cif5i2xPtv2IFZcjL42joU
T7lO5XFqUYS9ZNHpGa/V0eiPt7rHoO16glR83NZtwlrq2cSN89i9HfOhMYV/qLu8
fLCHcV2muw+yCB5s5bxnI5UkToiNZyBNqFkcOt/Kbj9Hpy68A1kmc6myVEaUYebq
2Chx/f3xuEthan099t746v1K+/6SvQGDNctHuaMr9cWdxZtHjdRf31SQRc99Phe5
w+ZGR/ebxNDKRK9mKgZT8wVFHlXerJsRqWIqtx1fsW1UgLgbpcpe2MChm6B5wTu0
s1ltzox3l4q71FyRRPUJxXyvGkDLZWpK7EpiHSCOYq/KP3HkKeXU3xqHpcG5AQ0E
UGIs/AEIAKzO/7lO9cB6dshmZYo8Vy/b7aGicThE+ChcDSfhvyOXVdEM2GKAjsR+
rlBWbTFX3It301p2HwZPFEi9nEvJxVlqqBiW0bPmNMkDRR55l2vbWg35wwkg6RyE
Bc5/TQjhXI2w8IvlimoGoUff4t3JmMOnWrnKSvL+5iuRj12p9WmanCHzw3Ee7ztf
/aU/q+FTpr3DLerb6S8xbv86ySgnJT6o5CyL2DCWRtnYQyGVi0ZmLzEouAYiO0hs
z0AAu28Mj+12g2WwePRz6gfM9rHtI37ylYW3oT/9M9mO9ei/Bc/1D7Dz6qNV+0vg
uSVJxM2Bl6GalHPZLhHntFEdIA6EdoUAEQEAAYkBHwQYAQIACQUCUGIs/AIbDAAK
CRAZJpRVM4hxpNfkB/0W/hP5WK/NETXBlWXXW7JPaWO2c5kGwD0lnj5RRmridyo1
vbm5PdM91jOsDQYqRu6YOoYBnDnEhB2wL2bPh34HWwwrA+LwB8hlcAV2z1bdwyfl
3R823fReKN3QcvLHzmvZPrF4Rk97M9UIyKS0RtnfTWykRgDWHIsrtQPoNwsXrWoT
9LrM2v+1+9mp3vuXnE473/NHxmiWEQH9Ez+O/mOxQ7rSOlqGRiKq/IBZCfioJOtV
fTQeIu/yASZnsLBqr6SJEGwYBoWcyjG++k4fyw8ocOAo4uGDYbxgN7yYfNQ0OH7o
V6pfUgqKLWa/aK7/N1ZHnPdFLD8Xt0Dmy4BPwrKC
=O7am
-----END PGP PUBLIC KEY BLOCK-----
"""

GIT = 'git' # our git command
MIN_GIT_VERSION = (1, 7, 2) # minimum supported git version
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


import optparse
import os
import re
import stat
import subprocess
import sys
try:
 import urllib2
except ImportError:
 # For python3
 import urllib.request
 import urllib.error
else:
 # For python2
 import imp
 urllib = imp.new_module('urllib')
 urllib.request = urllib2
 urllib.error = urllib2

home_dot_repo = os.path.expanduser('~/.repoconfig')
gpg_dir = os.path.join(home_dot_repo, 'gnupg')

extra_args = []
init_optparse = optparse.OptionParser(usage="repo init -u url [options]")

# Logging
group = init_optparse.add_option_group('Logging options')
group.add_option('-q', '--quiet',
 dest="quiet", action="store_true", default=False,
 help="be quiet")

# Manifest
group = init_optparse.add_option_group('Manifest options')
group.add_option('-u', '--manifest-url',
 dest='manifest_url',
 help='manifest repository location', metavar='URL')
group.add_option('-b', '--manifest-branch',
 dest='manifest_branch',
 help='manifest branch or revision', metavar='REVISION')
group.add_option('-m', '--manifest-name',
 dest='manifest_name',
 help='initial manifest file', metavar='NAME.xml')
group.add_option('--mirror',
 dest='mirror', action='store_true',
 help='mirror the forrest')
group.add_option('--reference',
 dest='reference',
 help='location of mirror directory', metavar='DIR')
group.add_option('--depth', type='int', default=None,
 dest='depth',
 help='create a shallow clone with given depth; see git clone')
group.add_option('-g', '--groups',
 dest='groups', default='default',
 help='restrict manifest projects to ones with a specified group',
 metavar='GROUP')
group.add_option('-p', '--platform',
 dest='platform', default="auto",
 help='restrict manifest projects to ones with a specified '
 'platform group [auto|all|none|linux|darwin|...]',
 metavar='PLATFORM')


# Tool
group = init_optparse.add_option_group('repo Version options')
group.add_option('--repo-url',
 dest='repo_url',
 help='repo repository location', metavar='URL')
group.add_option('--repo-branch',
 dest='repo_branch',
 help='repo branch or revision', metavar='REVISION')
group.add_option('--no-repo-verify',
 dest='no_repo_verify', action='store_true',
 help='do not verify repo source code')

# Other
group = init_optparse.add_option_group('Other options')
group.add_option('--config-name',
 dest='config_name', action="store_true", default=False,
 help='Always prompt for name/e-mail')

class CloneFailure(Exception):
 """Indicate the remote clone of repo itself failed.
 """


def _Init(args):
 """Installs repo by cloning it over the network.
 """
 opt, args = init_optparse.parse_args(args)
 if args:
 init_optparse.print_usage()
 sys.exit(1)

 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 branch.startswith('refs/heads/'):
 branch = branch[len('refs/heads/'):]
 if branch.startswith('refs/'):
 print("fatal: invalid branch name '%s'" % branch, file=sys.stderr)
 raise CloneFailure()

 if not os.path.isdir(repodir):
 try:
 os.mkdir(repodir)
 except OSError as e:
 print('fatal: cannot make %s directory: %s'
 % (repodir, e.strerror), file=sys.stderr)
 # Don't faise CloneFailure; that would delete the
 # name. Instead exit immediately.
 #
 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:
 if opt.quiet:
 print('fatal: repo init failed; run without --quiet to see why',
 file=sys.stderr)
 raise


def _CheckGitVersion():
 cmd = [GIT, '--version']
 try:
 proc = subprocess.Popen(cmd, stdout=subprocess.PIPE)
 except OSError as e:
 print(file=sys.stderr)
 print("fatal: '%s' is not available" % GIT, file=sys.stderr)
 print('fatal: %s' % e, file=sys.stderr)
 print(file=sys.stderr)
 print('Please make sure %s is installed and in your path.' % GIT,
 file=sys.stderr)
 raise CloneFailure()

 ver_str = proc.stdout.read().strip()
 proc.stdout.close()
 proc.wait()

 if not ver_str.startswith('git version '):
 print('error: "%s" unsupported' % ver_str, file=sys.stderr)
 raise CloneFailure()

 ver_str = ver_str[len('git version '):].strip()
 ver_act = tuple(map(int, ver_str.split('.')[0:3]))
 if ver_act < MIN_GIT_VERSION:
 need = '.'.join(map(str, MIN_GIT_VERSION))
 print('fatal: git %s or later required' % need, file=sys.stderr)
 raise CloneFailure()


def NeedSetupGnuPG():
 if not os.path.isdir(home_dot_repo):
 return True

 kv = os.path.join(home_dot_repo, 'keyring-version')
 if not os.path.exists(kv):
 return True

 kv = open(kv).read()
 if not kv:
 return True

 kv = tuple(map(int, kv.split('.')))
 if kv < KEYRING_VERSION:
 return True
 return False


def SetupGnuPG(quiet):
 if not os.path.isdir(home_dot_repo):
 try:
 os.mkdir(home_dot_repo)
 except OSError as e:
 print('fatal: cannot make %s directory: %s'
 % (home_dot_repo, e.strerror), file=sys.stderr)
 sys.exit(1)

 if not os.path.isdir(gpg_dir):
 try:
 os.mkdir(gpg_dir, stat.S_IRWXU)
 except OSError as e:
 print('fatal: cannot make %s directory: %s' % (gpg_dir, e.strerror),
 file=sys.stderr)
 sys.exit(1)

 env = os.environ.copy()
 env['GNUPGHOME'] = gpg_dir.encode()

 cmd = ['gpg', '--import']
 try:
 proc = subprocess.Popen(cmd,
 env = env,
 stdin = subprocess.PIPE)
 except OSError as e:
 if not quiet:
 print('warning: gpg (GnuPG) is not available.', file=sys.stderr)
 print('warning: Installing it is strongly encouraged.', file=sys.stderr)
 print(file=sys.stderr)
 return False

 proc.stdin.write(MAINTAINER_KEYS)
 proc.stdin.close()

 if proc.wait() != 0:
 print('fatal: registering repo maintainer keys failed', file=sys.stderr)
 sys.exit(1)
 print()

 fd = open(os.path.join(home_dot_repo, 'keyring-version'), 'w')
 fd.write('.'.join(map(str, KEYRING_VERSION)) + '\n')
 fd.close()
 return True


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


def _InitHttp():
 handlers = []

 mgr = urllib.request.HTTPPasswordMgrWithDefaultRealm()
 try:
 import netrc
 n = netrc.netrc()
 for host in n.hosts:
 p = n.hosts[host]
 mgr.add_password(p[1], 'http://%s/' % host, p[0], p[2])
 mgr.add_password(p[1], 'https://%s/' % host, p[0], p[2])
 except:
 pass
 handlers.append(urllib.request.HTTPBasicAuthHandler(mgr))
 handlers.append(urllib.request.HTTPDigestAuthHandler(mgr))

 if 'http_proxy' in os.environ:
 url = os.environ['http_proxy']
 handlers.append(urllib.request.ProxyHandler({'http': url, 'https': url}))
 if 'REPO_CURL_VERBOSE' in os.environ:
 handlers.append(urllib.request.HTTPHandler(debuglevel=1))
 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)

 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 _DownloadBundle(url, local, quiet):
 if not url.endswith('/'):
 url += '/'
 url += 'clone.bundle'

 proc = subprocess.Popen(
 [GIT, 'config', '--get-regexp', 'url.*.insteadof'],
 cwd = local,
 stdout = subprocess.PIPE)
 for line in proc.stdout:
 m = re.compile(r'^url\.(.*)\.insteadof (.*)$').match(line)
 if m:
 new_url = m.group(1)
 old_url = m.group(2)
 if url.startswith(old_url):
 url = new_url + url[len(old_url):]
 break
 proc.stdout.close()
 proc.wait()

 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 == 404:
 return False
 print('fatal: Cannot get %s' % url, 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: error %s' % e.reason, file=sys.stderr)
 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 _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:
 print(file=sys.stderr)
 print("fatal: '%s' is not available" % GIT, file=sys.stderr)
 print('fatal: %s' % e, file=sys.stderr)
 print(file=sys.stderr)
 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)
 raise CloneFailure()

 _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 _Verify(cwd, branch, quiet):
 """Verify the branch has been signed by a tag.
 """
 cmd = [GIT, 'describe', 'origin/%s' % branch]
 proc = subprocess.Popen(cmd,
 stdout=subprocess.PIPE,
 stderr=subprocess.PIPE,
 cwd = cwd)
 cur = proc.stdout.read().strip()
 proc.stdout.close()

 proc.stderr.read()
 proc.stderr.close()

 if proc.wait() != 0 or not cur:
 print(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("info: Ignoring branch '%s'; using tagged release '%s'"
 % (branch, cur), file=sys.stderr)
 print(file=sys.stderr)

 env = os.environ.copy()
 env['GNUPGHOME'] = gpg_dir.encode()

 cmd = [GIT, 'tag', '-v', cur]
 proc = subprocess.Popen(cmd,
 stdout = subprocess.PIPE,
 stderr = subprocess.PIPE,
 cwd = cwd,
 env = env)
 out = proc.stdout.read()
 proc.stdout.close()

 err = proc.stderr.read()
 proc.stderr.close()

 if proc.wait() != 0:
 print(file=sys.stderr)
 print(out, file=sys.stderr)
 print(err, file=sys.stderr)
 print(file=sys.stderr)
 raise CloneFailure()
 return '%s^0' % cur


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


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


class _Options:
 help = False


def _ParseArguments(args):
 cmd = None
 opt = _Options()
 arg = []

 for i in range(len(args)):
 a = args[i]
 if a == '-h' or a == '--help':
 opt.help = True

 elif not a.startswith('-'):
 cmd = a
 arg = args[i + 1:]
 break
 return cmd, opt, arg


def _Usage():
 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

For access to the full online help, install repo ("repo init").
""", file=sys.stderr)
 sys.exit(1)


def _Help(args):
 if args:
 if args[0] == 'init':
 init_optparse.print_help()
 sys.exit(0)
 else:
 print("error: '%s' is not a bootstrap command.\n"
 ' For access to online help, install repo ("repo init").'
 % args[0], file=sys.stderr)
 else:
 _Usage()
 sys.exit(1)


def _NotInstalled():
 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.
 Use "repo init" to install it here.""" % cmd, file=sys.stderr)
 sys.exit(1)


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


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 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:
 for root, dirs, files in os.walk(repodir, topdown=False):
 for name in files:
 os.remove(os.path.join(root, name))
 for name in dirs:
 os.rmdir(os.path.join(root, name))
 os.rmdir(repodir)
 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:
 print("fatal: unable to start %s" % repo_main, file=sys.stderr)
 print("fatal: %s" % e, file=sys.stderr)
 sys.exit(148)


if __name__ == '__main__':
 main(sys.argv[1:])