The Tor Browser: build/util/hg.py@6474c204b198 (annotated)

build/util/hg.py@6474c204b198 (annotated)

build/util/hg.py

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 """Functions for interacting with hg"""
 import os
 import re
 import subprocess
 from urlparse import urlsplit
 from ConfigParser import RawConfigParser
 from util.commands import run_cmd, get_output, remove_path
 from util.retry import retry
 import logging
 log = logging.getLogger(__name__)
 class DefaultShareBase:
     pass
 DefaultShareBase = DefaultShareBase()
 class HgUtilError(Exception):
     pass
 def _make_absolute(repo):
     if repo.startswith("file://"):
         path = repo[len("file://"):]
         repo = "file://%s" % os.path.abspath(path)
     elif "://" not in repo:
         repo = os.path.abspath(repo)
     return repo
 def make_hg_url(hgHost, repoPath, protocol='https', revision=None,
                 filename=None):
     """construct a valid hg url from a base hg url (hg.mozilla.org),
     repoPath, revision and possible filename"""
     base = '%s://%s' % (protocol, hgHost)
     repo = '/'.join(p.strip('/') for p in [base, repoPath])
     if not filename:
         if not revision:
             return repo
         else:
             return '/'.join([p.strip('/') for p in [repo, 'rev', revision]])
     else:
         assert revision
         return '/'.join([p.strip('/') for p in [repo, 'raw-file', revision, filename]])
 def get_repo_name(repo):
     return repo.rstrip('/').split('/')[-1]
 def get_repo_path(repo):
     repo = _make_absolute(repo)
     if repo.startswith("/"):
         return repo.lstrip("/")
     else:
         return urlsplit(repo).path.lstrip("/")
 def get_revision(path):
     """Returns which revision directory `path` currently has checked out."""
     return get_output(['hg', 'parent', '--template', '{node|short}'], cwd=path)
 def get_branch(path):
     return get_output(['hg', 'branch'], cwd=path).strip()
 def get_branches(path):
     branches = []
     for line in get_output(['hg', 'branches', '-c'], cwd=path).splitlines():
         branches.append(line.split()[0])
     return branches
 def is_hg_cset(rev):
     """Retruns True if passed revision represents a valid HG revision
     (long or short(er) 40 bit hex)"""
     try:
         int(rev, 16)
         return True
     except (TypeError, ValueError):
         return False
 def hg_ver():
     """Returns the current version of hg, as a tuple of
     (major, minor, build)"""
     ver_string = get_output(['hg', '-q', 'version'])
     match = re.search("\(version ([0-9.]+)\)", ver_string)
     if match:
         bits = match.group(1).split(".")
         if len(bits) < 3:
             bits += (0,)
         ver = tuple(int(b) for b in bits)
     else:
         ver = (0, 0, 0)
     log.debug("Running hg version %s", ver)
     return ver
 def purge(dest):
     """Purge the repository of all untracked and ignored files."""
     try:
         run_cmd(['hg', '--config', 'extensions.purge=', 'purge',
                  '-a', '--all', dest], cwd=dest)
     except subprocess.CalledProcessError, e:
         log.debug('purge failed: %s' % e)
         raise
 def update(dest, branch=None, revision=None):
     """Updates working copy `dest` to `branch` or `revision`.  If neither is
     set then the working copy will be updated to the latest revision on the
     current branch.  Local changes will be discarded."""
     # If we have a revision, switch to that
     if revision is not None:
         cmd = ['hg', 'update', '-C', '-r', revision]
         run_cmd(cmd, cwd=dest)
     else:
         # Check & switch branch
         local_branch = get_output(['hg', 'branch'], cwd=dest).strip()
         cmd = ['hg', 'update', '-C']
         # If this is different, checkout the other branch
         if branch and branch != local_branch:
             cmd.append(branch)
         run_cmd(cmd, cwd=dest)
     return get_revision(dest)
 def clone(repo, dest, branch=None, revision=None, update_dest=True,
           clone_by_rev=False, mirrors=None, bundles=None):
     """Clones hg repo and places it at `dest`, replacing whatever else is
     there.  The working copy will be empty.
     If `revision` is set, only the specified revision and its ancestors will
     be cloned.
     If `update_dest` is set, then `dest` will be updated to `revision` if
     set, otherwise to `branch`, otherwise to the head of default.
     If `mirrors` is set, will try and clone from the mirrors before
     cloning from `repo`.
     If `bundles` is set, will try and download the bundle first and
     unbundle it. If successful, will pull in new revisions from mirrors or
     the master repo. If unbundling fails, will fall back to doing a regular
     clone from mirrors or the master repo.
     Regardless of how the repository ends up being cloned, the 'default' path
     will point to `repo`.
     """
     if os.path.exists(dest):
         remove_path(dest)
     if bundles:
         log.info("Attempting to initialize clone with bundles")
         for bundle in bundles:
             if os.path.exists(dest):
                 remove_path(dest)
             init(dest)
             log.info("Trying to use bundle %s", bundle)
             try:
                 if not unbundle(bundle, dest):
                     remove_path(dest)
                     continue
                 adjust_paths(dest, default=repo)
                 # Now pull / update
                 return pull(repo, dest, update_dest=update_dest,
                             mirrors=mirrors, revision=revision, branch=branch)
             except Exception:
                 remove_path(dest)
                 log.exception("Problem unbundling/pulling from %s", bundle)
                 continue
         else:
             log.info("Using bundles failed; falling back to clone")
     if mirrors:
         log.info("Attempting to clone from mirrors")
         for mirror in mirrors:
             log.info("Cloning from %s", mirror)
             try:
                 retval = clone(mirror, dest, branch, revision,
                                update_dest=update_dest, clone_by_rev=clone_by_rev)
                 adjust_paths(dest, default=repo)
                 return retval
             except:
                 log.exception("Problem cloning from mirror %s", mirror)
                 continue
         else:
             log.info("Pulling from mirrors failed; falling back to %s", repo)
             # We may have a partial repo here; mercurial() copes with that
             # We need to make sure our paths are correct though
             if os.path.exists(os.path.join(dest, '.hg')):
                 adjust_paths(dest, default=repo)
             return mercurial(repo, dest, branch, revision, autoPurge=True,
                              update_dest=update_dest, clone_by_rev=clone_by_rev)
     cmd = ['hg', 'clone']
     if not update_dest:
         cmd.append('-U')
     if clone_by_rev:
         if revision:
             cmd.extend(['-r', revision])
         elif branch:
             # hg >= 1.6 supports -b branch for cloning
             ver = hg_ver()
             if ver >= (1, 6, 0):
                 cmd.extend(['-b', branch])
     cmd.extend([repo, dest])
     run_cmd(cmd)
     if update_dest:
         return update(dest, branch, revision)
 def common_args(revision=None, branch=None, ssh_username=None, ssh_key=None):
     """Fill in common hg arguments, encapsulating logic checks that depend on
        mercurial versions and provided arguments"""
     args = []
     if ssh_username or ssh_key:
         opt = ['-e', 'ssh']
         if ssh_username:
             opt[1] += ' -l %s' % ssh_username
         if ssh_key:
             opt[1] += ' -i %s' % ssh_key
         args.extend(opt)
     if revision:
         args.extend(['-r', revision])
     elif branch:
         if hg_ver() >= (1, 6, 0):
             args.extend(['-b', branch])
     return args
 def pull(repo, dest, update_dest=True, mirrors=None, **kwargs):
     """Pulls changes from hg repo and places it in `dest`.
     If `update_dest` is set, then `dest` will be updated to `revision` if
     set, otherwise to `branch`, otherwise to the head of default.
     If `mirrors` is set, will try and pull from the mirrors first before
     `repo`."""
     if mirrors:
         for mirror in mirrors:
             try:
                 return pull(mirror, dest, update_dest=update_dest, **kwargs)
             except:
                 log.exception("Problem pulling from mirror %s", mirror)
                 continue
         else:
             log.info("Pulling from mirrors failed; falling back to %s", repo)
     # Convert repo to an absolute path if it's a local repository
     repo = _make_absolute(repo)
     cmd = ['hg', 'pull']
     # Don't pass -r to "hg pull", except when it's a valid HG revision.
     # Pulling using tag names is dangerous: it uses the local .hgtags, so if
     # the tag has moved on the remote side you won't pull the new revision the
     # remote tag refers to.
     pull_kwargs = kwargs.copy()
     if 'revision' in pull_kwargs and \
        not is_hg_cset(pull_kwargs['revision']):
         del pull_kwargs['revision']
     cmd.extend(common_args(**pull_kwargs))
     cmd.append(repo)
     run_cmd(cmd, cwd=dest)
     if update_dest:
         branch = None
         if 'branch' in kwargs and kwargs['branch']:
             branch = kwargs['branch']
         revision = None
         if 'revision' in kwargs and kwargs['revision']:
             revision = kwargs['revision']
         return update(dest, branch=branch, revision=revision)
 # Defines the places of attributes in the tuples returned by `out'
 REVISION, BRANCH = 0, 1
 def out(src, remote, **kwargs):
     """Check for outgoing changesets present in a repo"""
     cmd = ['hg', '-q', 'out', '--template', '{node} {branches}\n']
     cmd.extend(common_args(**kwargs))
     cmd.append(remote)
     if os.path.exists(src):
         try:
             revs = []
             for line in get_output(cmd, cwd=src).rstrip().split("\n"):
                 try:
                     rev, branch = line.split()
                 # Mercurial displays no branch at all if the revision is on
                 # "default"
                 except ValueError:
                     rev = line.rstrip()
                     branch = "default"
                 revs.append((rev, branch))
             return revs
         except subprocess.CalledProcessError, inst:
             # In some situations, some versions of Mercurial return "1"
             # if no changes are found, so we need to ignore this return code
             if inst.returncode == 1:
                 return []
             raise
 def push(src, remote, push_new_branches=True, force=False, **kwargs):
     cmd = ['hg', 'push']
     cmd.extend(common_args(**kwargs))
     if force:
         cmd.append('-f')
     if push_new_branches:
         cmd.append('--new-branch')
     cmd.append(remote)
     run_cmd(cmd, cwd=src)
 def mercurial(repo, dest, branch=None, revision=None, update_dest=True,
               shareBase=DefaultShareBase, allowUnsharedLocalClones=False,
               clone_by_rev=False, mirrors=None, bundles=None, autoPurge=False):
     """Makes sure that `dest` is has `revision` or `branch` checked out from
     `repo`.
     Do what it takes to make that happen, including possibly clobbering
     dest.
     If allowUnsharedLocalClones is True and we're trying to use the share
     extension but fail, then we will be able to clone from the shared repo to
     our destination.  If this is False, the default, then if we don't have the
     share extension we will just clone from the remote repository.
     If `clone_by_rev` is True, use 'hg clone -r <rev>' instead of 'hg clone'.
     This is slower, but useful when cloning repos with lots of heads.
     If `mirrors` is set, will try and use the mirrors before `repo`.
     If `bundles` is set, will try and download the bundle first and
     unbundle it instead of doing a full clone. If successful, will pull in
     new revisions from mirrors or the master repo. If unbundling fails, will
     fall back to doing a regular clone from mirrors or the master repo.
     """
     dest = os.path.abspath(dest)
     if shareBase is DefaultShareBase:
         shareBase = os.environ.get("HG_SHARE_BASE_DIR", None)
     log.info("Reporting hg version in use")
     cmd = ['hg', '-q', 'version']
     run_cmd(cmd, cwd='.')
     if shareBase:
         # Check that 'hg share' works
         try:
             log.info("Checking if share extension works")
             output = get_output(['hg', 'help', 'share'], dont_log=True)
             if 'no commands defined' in output:
                 # Share extension is enabled, but not functional
                 log.info("Disabling sharing since share extension doesn't seem to work (1)")
                 shareBase = None
             elif 'unknown command' in output:
                 # Share extension is disabled
                 log.info("Disabling sharing since share extension doesn't seem to work (2)")
                 shareBase = None
         except subprocess.CalledProcessError:
             # The command failed, so disable sharing
             log.info("Disabling sharing since share extension doesn't seem to work (3)")
             shareBase = None
     # Check that our default path is correct
     if os.path.exists(os.path.join(dest, '.hg')):
         hgpath = path(dest, "default")
         # Make sure that our default path is correct
         if hgpath != _make_absolute(repo):
             log.info("hg path isn't correct (%s should be %s); clobbering",
                      hgpath, _make_absolute(repo))
             remove_path(dest)
     # If the working directory already exists and isn't using share we update
     # the working directory directly from the repo, ignoring the sharing
     # settings
     if os.path.exists(dest):
         if not os.path.exists(os.path.join(dest, ".hg")):
             log.warning("%s doesn't appear to be a valid hg directory; clobbering", dest)
             remove_path(dest)
         elif not os.path.exists(os.path.join(dest, ".hg", "sharedpath")):
             try:
                 if autoPurge:
                     purge(dest)
                 return pull(repo, dest, update_dest=update_dest, branch=branch,
                             revision=revision,
                             mirrors=mirrors)
             except subprocess.CalledProcessError:
                 log.warning("Error pulling changes into %s from %s; clobbering", dest, repo)
                 log.debug("Exception:", exc_info=True)
                 remove_path(dest)
     # If that fails for any reason, and sharing is requested, we'll try to
     # update the shared repository, and then update the working directory from
     # that.
     if shareBase:
         sharedRepo = os.path.join(shareBase, get_repo_path(repo))
         dest_sharedPath = os.path.join(dest, '.hg', 'sharedpath')
         if os.path.exists(sharedRepo):
             hgpath = path(sharedRepo, "default")
             # Make sure that our default path is correct
             if hgpath != _make_absolute(repo):
                 log.info("hg path isn't correct (%s should be %s); clobbering",
                          hgpath, _make_absolute(repo))
                 # we need to clobber both the shared checkout and the dest,
                 # since hgrc needs to be in both places
                 remove_path(sharedRepo)
                 remove_path(dest)
         if os.path.exists(dest_sharedPath):
             # Make sure that the sharedpath points to sharedRepo
             dest_sharedPath_data = os.path.normpath(
                 open(dest_sharedPath).read())
             norm_sharedRepo = os.path.normpath(os.path.join(sharedRepo, '.hg'))
             if dest_sharedPath_data != norm_sharedRepo:
                 # Clobber!
                 log.info("We're currently shared from %s, but are being requested to pull from %s (%s); clobbering",
                          dest_sharedPath_data, repo, norm_sharedRepo)
                 remove_path(dest)
         try:
             log.info("Updating shared repo")
             mercurial(repo, sharedRepo, branch=branch, revision=revision,
                       update_dest=False, shareBase=None, clone_by_rev=clone_by_rev,
                       mirrors=mirrors, bundles=bundles, autoPurge=False)
             if os.path.exists(dest):
                 if autoPurge:
                     purge(dest)
                 return update(dest, branch=branch, revision=revision)
             try:
                 log.info("Trying to share %s to %s", sharedRepo, dest)
                 return share(sharedRepo, dest, branch=branch, revision=revision)
             except subprocess.CalledProcessError:
                 if not allowUnsharedLocalClones:
                     # Re-raise the exception so it gets caught below.
                     # We'll then clobber dest, and clone from original repo
                     raise
                 log.warning("Error calling hg share from %s to %s;"
                             "falling back to normal clone from shared repo",
                             sharedRepo, dest)
                 # Do a full local clone first, and then update to the
                 # revision we want
                 # This lets us use hardlinks for the local clone if the OS
                 # supports it
                 clone(sharedRepo, dest, update_dest=False,
                       mirrors=mirrors, bundles=bundles)
                 return update(dest, branch=branch, revision=revision)
         except subprocess.CalledProcessError:
             log.warning(
                 "Error updating %s from sharedRepo (%s): ", dest, sharedRepo)
             log.debug("Exception:", exc_info=True)
             remove_path(dest)
     # end if shareBase
     if not os.path.exists(os.path.dirname(dest)):
         os.makedirs(os.path.dirname(dest))
     # Share isn't available or has failed, clone directly from the source
     return clone(repo, dest, branch, revision,
                  update_dest=update_dest, mirrors=mirrors,
                  bundles=bundles, clone_by_rev=clone_by_rev)
 def apply_and_push(localrepo, remote, changer, max_attempts=10,
                    ssh_username=None, ssh_key=None, force=False):
     """This function calls `changer' to make changes to the repo, and tries
        its hardest to get them to the origin repo. `changer' must be a
        callable object that receives two arguments: the directory of the local
        repository, and the attempt number. This function will push ALL
        changesets missing from remote."""
     assert callable(changer)
     branch = get_branch(localrepo)
     changer(localrepo, 1)
     for n in range(1, max_attempts + 1):
         new_revs = []
         try:
             new_revs = out(src=localrepo, remote=remote,
                            ssh_username=ssh_username,
                            ssh_key=ssh_key)
             if len(new_revs) < 1:
                 raise HgUtilError("No revs to push")
             push(src=localrepo, remote=remote, ssh_username=ssh_username,
                  ssh_key=ssh_key, force=force)
             return
         except subprocess.CalledProcessError, e:
             log.debug("Hit error when trying to push: %s" % str(e))
             if n == max_attempts:
                 log.debug("Tried %d times, giving up" % max_attempts)
                 for r in reversed(new_revs):
                     run_cmd(['hg', '--config', 'extensions.mq=', 'strip', '-n',
                              r[REVISION]], cwd=localrepo)
                 raise HgUtilError("Failed to push")
             pull(remote, localrepo, update_dest=False,
                  ssh_username=ssh_username, ssh_key=ssh_key)
             # After we successfully rebase or strip away heads the push is
             # is attempted again at the start of the loop
             try:
                 run_cmd(['hg', '--config', 'ui.merge=internal:merge',
                          'rebase'], cwd=localrepo)
             except subprocess.CalledProcessError, e:
                 log.debug("Failed to rebase: %s" % str(e))
                 update(localrepo, branch=branch)
                 for r in reversed(new_revs):
                     run_cmd(['hg', '--config', 'extensions.mq=', 'strip', '-n',
                              r[REVISION]], cwd=localrepo)
                 changer(localrepo, n + 1)
 def share(source, dest, branch=None, revision=None):
     """Creates a new working directory in "dest" that shares history with
        "source" using Mercurial's share extension"""
     run_cmd(['hg', 'share', '-U', source, dest])
     return update(dest, branch=branch, revision=revision)
 def cleanOutgoingRevs(reponame, remote, username, sshKey):
     outgoingRevs = retry(out, kwargs=dict(src=reponame, remote=remote,
                                           ssh_username=username,
                                           ssh_key=sshKey))
     for r in reversed(outgoingRevs):
         run_cmd(['hg', '--config', 'extensions.mq=', 'strip', '-n',
                  r[REVISION]], cwd=reponame)
 def path(src, name='default'):
     """Returns the remote path associated with "name" """
     try:
         return get_output(['hg', 'path', name], cwd=src).strip()
     except subprocess.CalledProcessError:
         return None
 def init(dest):
     """Initializes an empty repo in `dest`"""
     run_cmd(['hg', 'init', dest])
 def unbundle(bundle, dest):
     """Unbundles the bundle located at `bundle` into `dest`.
     `bundle` can be a local file or remote url."""
     try:
         get_output(['hg', 'unbundle', bundle], cwd=dest, include_stderr=True)
         return True
     except subprocess.CalledProcessError:
         return False
 def adjust_paths(dest, **paths):
     """Adjusts paths in `dest`/.hg/hgrc so that names in `paths` are set to
     paths[name].
     Note that any comments in the hgrc will be lost if changes are made to the
     file."""
     hgrc = os.path.join(dest, '.hg', 'hgrc')
     config = RawConfigParser()
     config.read(hgrc)
     if not config.has_section('paths'):
         config.add_section('paths')
     changed = False
     for path_name, path_value in paths.items():
         if (not config.has_option('paths', path_name) or
                 config.get('paths', path_name) != path_value):
             changed = True
             config.set('paths', path_name, path_value)
     if changed:
         config.write(open(hgrc, 'w'))
 def commit(dest, msg, user=None):
     cmd = ['hg', 'commit', '-m', msg]
     if user:
         cmd.extend(['-u', user])
     run_cmd(cmd, cwd=dest)
     return get_revision(dest)
 def tag(dest, tags, user=None, msg=None, rev=None, force=None):
     cmd = ['hg', 'tag']
     if user:
         cmd.extend(['-u', user])
     if msg:
         cmd.extend(['-m', msg])
     if rev:
         cmd.extend(['-r', rev])
     if force:
         cmd.append('-f')
     cmd.extend(tags)
     run_cmd(cmd, cwd=dest)
     return get_revision(dest)

The Tor Browser / annotate

build/util/hg.py@6474c204b198 (annotated)

build/util/hg.py