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