alibuild 1.17.19__py3-none-any.whl

alibuild_helpers/doctor.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+import os
+import re
+import sys
+from os.path import exists, abspath, expanduser
+import logging
+from alibuild_helpers.log import debug, error, banner, info, success, warning
+from alibuild_helpers.log import logger
+from alibuild_helpers.utilities import getPackageList, parseDefaults, readDefaults, validateDefaults
+from alibuild_helpers.cmd import getstatusoutput, DockerRunner
+import tempfile
+
+def prunePaths(workDir) -> None:
+  for x in ["PATH", "LD_LIBRARY_PATH", "DYLD_LIBRARY_PATH"]:
+    if x not in os.environ:
+      continue
+    workDirEscaped = re.escape("%s" % workDir) + "[^:]*:?"
+    os.environ[x] = re.sub(workDirEscaped, "", os.environ[x])
+
+def checkPreferSystem(spec, cmd, homebrew_replacement, getstatusoutput_docker):
+    if cmd == "false":
+      debug("Package %s can only be managed via alibuild.", spec["package"])
+      return (1, "")
+    cmd = homebrew_replacement + cmd
+    err, out = getstatusoutput_docker(cmd)
+    if not err:
+      success("Package %s will be picked up from the system.", spec["package"])
+      for x in out.split("\n"):
+        debug("%s: %s", spec["package"], x)
+      return (err, "")
+
+    warning("Package %s cannot be picked up from the system and will be built by aliBuild.\n"
+            "This is due to the fact the following script fails:\n\n%s\n\n"
+            "with the following output:\n\n%s\n",
+            spec["package"], cmd, "\n".join("%s: %s" % (spec["package"], x) for x in out.split("\n")))
+    return (err, "")
+
+def checkRequirements(spec, cmd, homebrew_replacement, getstatusoutput_docker):
+    if cmd == "false":
+      debug("Package %s is not a system requirement.", spec["package"])
+      return (0, "")
+    cmd = homebrew_replacement + cmd
+    err, out = getstatusoutput_docker(cmd)
+    if not err:
+      success("Required package %s will be picked up from the system.", spec["package"])
+      debug("%s", cmd)
+      for x in out.split("\n"):
+        debug("%s: %s", spec["package"], x)
+      return (0, "")
+    error("Package %s is a system requirement and cannot be found.\n"
+          "This is due to the fact that the following script fails:\n\n%s\n"
+          "with the following output:\n\n%s\n%s\n",
+          spec["package"], cmd,
+          "\n".join("%s: %s" % (spec["package"], x) for x in out.split("\n")),
+          spec.get("system_requirement_missing"))
+    return (err, "")
+
+def systemInfo() -> None:
+  _,out = getstatusoutput("env")
+  debug("Environment:\n%s", out)
+  _,out = getstatusoutput("uname -a")
+  debug("uname -a: %s", out)
+  _,out = getstatusoutput("mount")
+  debug("Mounts:\n%s", out)
+  _,out = getstatusoutput("df")
+  debug("Disk free:\n%s", out)
+  for f in ["/etc/lsb-release", "/etc/redhat-release", "/etc/os-release"]:
+    err,out = getstatusoutput("cat "+f)
+    if not err:
+      debug("%s:\n%s", f, out)
+
+def doDoctor(args, parser):
+  if not exists(args.configDir):
+    parser.error("Wrong path to alidist specified: %s" % args.configDir)
+
+  prunePaths(abspath(args.workDir))
+
+  if exists(expanduser("~/.rootlogon.C")):
+    warning("You have a ~/.rootlogon.C notice that this might"
+            " interfere with your environment in hidden ways.\n"
+            "Please review it an make sure you are not force loading any library"
+            " which might interphere with the rest of the setup.")
+  # Decide if we can use homebrew. If not, we replace it with "true" so
+  # that we do not get spurious messages on linux
+  homebrew_replacement = ""
+  with DockerRunner(args.dockerImage, args.docker_extra_args, extra_env={"ALIBUILD_CONFIG_DIR": "/alidist" if args.docker else os.path.abspath(args.configDir)}, extra_volumes=[f"{os.path.abspath(args.configDir)}:/alidist:ro"] if args.docker else []) as getstatusoutput_docker:
+    err, output = getstatusoutput_docker("type c++")
+  if err:
+    warning("Unable to find system compiler.\n"
+            "%s\n"
+            "Please follow prerequisites:\n"
+            "* On RHEL9 compatible systems (e.g. Alma9): https://alice-doc.github.io/alice-analysis-tutorial/building/prereq-alma9.html\n"
+            "* On Fedora compatible systems: https://alice-doc.github.io/alice-analysis-tutorial/building/prereq-fedora.html\n"
+            "* On Ubuntu compatible systems: https://alice-doc.github.io/alice-analysis-tutorial/building/prereq-ubuntu.html\n"
+            "* On macOS: https://alice-doc.github.io/alice-analysis-tutorial/building/prereq-macos.html\n",
+            output)
+  err, output = getstatusoutput("type git")
+  if err:
+    error("Unable to find git.\n"
+          "%s\n"
+          "Please follow prerequisites:\n"
+          "* On RHEL9 compatible systems (e.g. Alma9): https://alice-doc.github.io/alice-analysis-tutorial/building/prereq-alma9.html\n"
+          "* On Fedora compatible systems: https://alice-doc.github.io/alice-analysis-tutorial/building/prereq-fedora.html\n"
+          "* On Ubuntu compatible systems: https://alice-doc.github.io/alice-analysis-tutorial/building/prereq-ubuntu.html\n"
+          "* On macOS: https://alice-doc.github.io/alice-analysis-tutorial/building/prereq-macos.html\n",
+          output)
+  # Decide if we can use homebrew. If not, we replace it with "true" so
+  # that we do not get spurious messages on linux
+  homebrew_replacement = ""
+  err, output = getstatusoutput("which brew")
+  if err:
+    homebrew_replacement = "brew() { true; }; "
+
+  logger.setLevel(logging.BANNER)
+  if args.debug:
+    logger.setLevel(logging.DEBUG)
+
+  specs = {}
+  packages = []
+  exitcode = 0
+  for p in args.packages:
+    path = "%s/%s.sh" % (args.configDir, p.lower())
+    if not exists(path):
+      error("Cannot find recipe %s for package %s.", path, p)
+      exitcode = 1
+      continue
+    packages.append(p)
+  systemInfo()
+
+  specs = {}
+  defaultsReader = lambda : readDefaults(args.configDir, args.defaults, parser.error, args.architecture)
+  (err, overrides, taps) = parseDefaults(args.disable, defaultsReader, info)
+  if err:
+    error("%s", err)
+    sys.exit(1)
+
+  def performValidateDefaults(spec):
+    (ok,msg,valid) = validateDefaults(spec, args.defaults)
+    if not ok:
+      error("%s", msg)
+    return (ok,msg,valid)
+
+  with DockerRunner(args.dockerImage, args.docker_extra_args, extra_env={"ALIBUILD_CONFIG_DIR": "/alidist" if args.docker else os.path.abspath(args.configDir)}, extra_volumes=[f"{os.path.abspath(args.configDir)}:/alidist:ro"] if args.docker else []) as getstatusoutput_docker:
+    def performPreferCheckWithTempDir(pkg, cmd):
+      with tempfile.TemporaryDirectory(prefix=f"alibuild_prefer_check_{pkg['package']}_") as temp_dir:
+        return getstatusoutput_docker(cmd, cwd=temp_dir)
+    fromSystem, own, failed, validDefaults = \
+      getPackageList(packages                = packages,
+                     specs                   = specs,
+                     configDir               = args.configDir,
+                     preferSystem            = args.preferSystem,
+                     noSystem                = args.noSystem,
+                     architecture            = args.architecture,
+                     disable                 = args.disable,
+                     defaults                = args.defaults,
+                     performPreferCheck      = performPreferCheckWithTempDir,
+                     performRequirementCheck = performPreferCheckWithTempDir,
+                     performValidateDefaults = performValidateDefaults,
+                     overrides               = overrides,
+                     taps                    = taps,
+                     log                     = info)
+
+  alwaysBuilt = set(x for x in specs) - fromSystem - own - failed
+  if alwaysBuilt:
+    banner("The following packages will be built by aliBuild because\n"
+           " usage of a system version of it is not allowed or supported, by policy:\n\n- %s",
+           " \n- ".join(alwaysBuilt))
+  if fromSystem:
+    banner("The following packages will be picked up from the system:\n\n- %s\n\n"
+           "If this is not you want, you have to uninstall / unload them.",
+           "\n- ".join(fromSystem))
+  if own:
+    banner("The following packages will be built by aliBuild because they couldn't be picked up from the system:\n\n"
+           "- %s\n\n"
+           "This is not a real issue, but it might take longer the first time you invoke aliBuild.\n"
+           "Look at the error messages above to get hints on what packages you need to install separately.",
+           "\n- ".join(own))
+  if failed:
+    banner("The following packages are system dependencies and could not be found:\n\n- %s\n\n"
+           "Look at the error messages above to get hints on what packages you need to install separately.",
+           "\n- ".join(failed))
+    exitcode = 1
+  if validDefaults and args.defaults not in validDefaults:
+    banner("The list of packages cannot be built with the defaults you have specified.\n"
+           "List of valid defaults:\n\n- %s\n\n"
+           "Use the `--defaults' switch to specify one of them.",
+           "\n- ".join(validDefaults))
+    exitcode = 2
+  if validDefaults is None:
+    banner("No valid defaults combination was found for the given list of packages, check your recipes!")
+    exitcode = 3
+  if exitcode:
+    error("There were errors: build cannot be performed if they are not resolved. Check the messages above.")
+  sys.exit(exitcode)
+

alibuild_helpers/git.py

@@ -0,0 +1,104 @@
+from shlex import quote
+from alibuild_helpers.cmd import getstatusoutput
+from alibuild_helpers.log import debug
+from alibuild_helpers.scm import SCM, SCMError
+import os
+
+GIT_COMMAND_TIMEOUT_SEC = 120
+"""Default value for how many seconds to let any git command execute before being terminated."""
+
+GIT_CMD_TIMEOUTS = {
+  "clone": 600,
+  "checkout": 600
+}
+"""Customised timeout for some commands."""
+
+def clone_speedup_options():
+  """Return a list of options supported by the system git which speed up cloning."""
+  for filter_option in ("--filter=tree:0", "--filter=blob:none"):
+    _, out = getstatusoutput("LANG=C git clone " + filter_option)
+    if "unknown option" not in out and "invalid filter-spec" not in out:
+      return [filter_option]
+  return []
+
+
+class Git(SCM):
+  name = "Git"
+
+  def checkedOutCommitName(self, directory):
+    return git(("rev-parse", "HEAD"), directory)
+
+  def branchOrRef(self, directory):
+    out = git(("rev-parse", "--abbrev-ref", "HEAD"), directory=directory)
+    if out == "HEAD":
+      out = git(("rev-parse", "HEAD"), directory)[:10]
+    return out
+
+  def exec(self, *args, **kwargs):
+    return git(*args, **kwargs)
+
+  def parseRefs(self, output):
+    return {
+      git_ref: git_hash for git_hash, sep, git_ref
+      in (line.partition("\t") for line in output.splitlines()) if sep
+    }
+
+  def listRefsCmd(self, repository):
+    return ["ls-remote", "--heads", "--tags", repository]
+
+  def cloneReferenceCmd(self, spec, referenceRepo, usePartialClone):
+    cmd = ["clone", "--bare", spec, referenceRepo]
+    if usePartialClone:
+      cmd.extend(clone_speedup_options())
+    return cmd
+
+  def cloneSourceCmd(self, source, destination, referenceRepo, usePartialClone):
+    cmd = ["clone", "-n", source, destination]
+    if referenceRepo:
+      # If we're building inside a Docker container, we can't refer to the
+      # mirror repo directly, since Git uses an absolute path. With
+      # "--dissociate", we still copy the objects locally, but we don't refer
+      # to them by path.
+      cmd.extend(["--dissociate", "--reference", referenceRepo])
+    if usePartialClone:
+      cmd.extend(clone_speedup_options())
+    return cmd
+
+  def checkoutCmd(self, tag):
+    return ["checkout", "-f", tag]
+
+  def fetchCmd(self, remote, *refs):
+    return ["fetch", "-f"] + clone_speedup_options() + [remote, *refs]
+
+  def setWriteUrlCmd(self, url):
+    return ["remote", "set-url", "--push", "origin", url]
+
+  def diffCmd(self, directory):
+    return "cd %s && git diff HEAD && git status --porcelain" % directory
+
+  def checkUntracked(self, line):
+    return line.startswith("?? ")
+
+
+def git(args, directory=".", check=True, prompt=True):
+  lastGitOverride = int(os.environ.get("GIT_CONFIG_COUNT", "0"))
+  debug("Executing git %s (in directory %s)", " ".join(args), directory)
+  # We can't use git --git-dir=%s/.git or git -C %s here as the former requires
+  # that the directory we're inspecting to be the root of a git directory, not
+  # just contained in one (and that breaks CI tests), and the latter isn't
+  # supported by the git version we have on slc6.
+  # Silence cd as shell configuration can cause the new directory to be echoed.
+  err, output = getstatusoutput("""\
+  set -e +x
+  cd {directory} >/dev/null 2>&1
+  {prompt_var} {directory_safe_var} git {args}
+  """.format(
+    directory=quote(directory),
+    args=" ".join(map(quote, args)),
+    # GIT_TERMINAL_PROMPT is only supported in git 2.3+.
+    prompt_var="GIT_TERMINAL_PROMPT=0" if not prompt else "",
+    directory_safe_var=f"GIT_CONFIG_COUNT={lastGitOverride+2} GIT_CONFIG_KEY_{lastGitOverride}=safe.directory GIT_CONFIG_VALUE_{lastGitOverride}=$PWD GIT_CONFIG_KEY_{lastGitOverride+1}=gc.auto GIT_CONFIG_VALUE_{lastGitOverride+1}=0" if directory else "",
+  ), timeout=GIT_CMD_TIMEOUTS.get(args[0] if len(args) else "*", GIT_COMMAND_TIMEOUT_SEC))
+  if check and err != 0:
+    raise SCMError("Error {} from git {}: {}".format(err, " ".join(args), output))
+  return output if check else (err, output)

alibuild_helpers/init.py

@@ -0,0 +1,103 @@
+from alibuild_helpers.git import git, Git
+from alibuild_helpers.utilities import getPackageList, parseDefaults, readDefaults, validateDefaults
+from alibuild_helpers.log import debug, error, warning, banner, info
+from alibuild_helpers.log import dieOnError
+from alibuild_helpers.workarea import updateReferenceRepoSpec
+
+from os.path import join
+import os.path as path
+import os
+import sys
+
+def parsePackagesDefinition(pkgname):
+  return [ dict(zip(["name","ver"], y.split("@")[0:2]))
+           for y in [ x+"@" for x in list(filter(lambda y: y, pkgname.split(","))) ] ]
+
+def doInit(args):
+  assert(args.pkgname != None)
+  assert(type(args.dist) == dict)
+  assert(sorted(args.dist.keys()) == ["repo", "ver"])
+  pkgs = parsePackagesDefinition(args.pkgname)
+  assert(type(pkgs) == list)
+  if args.dryRun:
+    info("This will initialise local checkouts for %s\n"
+         "--dry-run / -n specified. Doing nothing.", ",".join(x["name"] for x in pkgs))
+    sys.exit(0)
+  try:
+    path.exists(args.develPrefix) or os.mkdir(args.develPrefix)
+    path.exists(args.referenceSources) or os.makedirs(args.referenceSources)
+  except OSError as e:
+    error("%s", e)
+    sys.exit(1)
+
+  # Fetch recipes first if necessary
+  if path.exists(args.configDir):
+    warning("using existing recipes from %s", args.configDir)
+  else:
+    cmd = ["clone", "--origin", "upstream",
+           args.dist["repo"] if ":" in args.dist["repo"] else "https://github.com/" + args.dist["repo"]]
+    if args.dist["ver"]:
+      cmd.extend(["-b", args.dist["ver"]])
+    cmd.append(args.configDir)
+    git(cmd)
+
+  # Use standard functions supporting overrides and taps. Ignore all disables
+  # and system packages as they are irrelevant in this context
+  specs = {}
+  defaultsReader = lambda: readDefaults(args.configDir, args.defaults, lambda msg: error("%s", msg), args.architecture)
+  (err, overrides, taps) = parseDefaults([], defaultsReader, debug)
+  (_,_,_,validDefaults) = getPackageList(packages=[ p["name"] for p in pkgs ],
+                                         specs=specs,
+                                         configDir=args.configDir,
+                                         preferSystem=False,
+                                         noSystem="*",
+                                         architecture="",
+                                         disable=[],
+                                         defaults=args.defaults,
+                                         performPreferCheck=lambda *x, **y: (1, ""),
+                                         performRequirementCheck=lambda *x, **y: (0, ""),
+                                         performValidateDefaults=lambda spec : validateDefaults(spec, args.defaults),
+                                         overrides=overrides,
+                                         taps=taps,
+                                         log=debug)
+  dieOnError(validDefaults and args.defaults not in validDefaults,
+             "Specified default `%s' is not compatible with the packages you want to build.\n" % args.defaults +
+             "Valid defaults:\n\n- " +
+             "\n- ".join(sorted(validDefaults)))
+
+  for p in pkgs:
+    spec = specs.get(p["name"])
+    spec["is_devel_pkg"] = False
+    spec["scm"] = Git()
+    dieOnError(spec is None, "cannot find recipe for package %s" % p["name"])
+    dest = join(args.develPrefix, spec["package"])
+    writeRepo = spec.get("write_repo", spec.get("source"))
+    dieOnError(not writeRepo, "package %s has no source field and cannot be developed" % spec["package"])
+    if path.exists(dest):
+      warning("not cloning %s since it already exists", spec["package"])
+      continue
+    p["ver"] = p["ver"] if p["ver"] else spec.get("tag", spec["version"])
+    debug("cloning %s%s for development", spec["package"], " version "+p["ver"] if p["ver"] else "")
+
+    updateReferenceRepoSpec(args.referenceSources, spec["package"], spec, True, False)
+
+    cmd = ["clone", "--origin", "upstream", spec["source"],
+           "--reference", join(args.referenceSources, spec["package"].lower())]
+    if p["ver"]:
+      cmd.extend(["-b", p["ver"]])
+    cmd.append(dest)
+    git(cmd)
+    git(("remote", "set-url", "--push", "upstream", writeRepo), directory=dest)
+
+    # Make it point relatively to the mirrors for relocation: as per Git specifics, the path has to
+    # be relative to the repository's `.git` directory. Don't do it if no common path is found
+    repoObjects = os.path.join(os.path.realpath(dest), ".git", "objects")
+    refObjects = os.path.join(os.path.realpath(args.referenceSources),
+                              spec["package"].lower(), "objects")
+    repoAltConf = os.path.join(repoObjects, "info", "alternates")
+    if len(os.path.commonprefix([repoObjects, refObjects])) > 1:
+      with open(repoAltConf, "w") as fil:
+        fil.write(os.path.relpath(refObjects, repoObjects) + "\n")
+
+  banner("Development directory %s created%s", args.develPrefix,
+         " for "+", ".join(x["name"].lower() for x in pkgs) if pkgs else "")

alibuild_helpers/log.py

@@ -0,0 +1,132 @@
+import logging
+import sys
+import re
+import time
+import datetime
+
+def dieOnError(err, msg) -> None:
+  if err:
+    error("%s", msg)
+    sys.exit(1)
+
+class LogFormatter(logging.Formatter):
+  def __init__(self, fmtstr) -> None:
+    self.fmtstr = fmtstr
+    self.COLOR_RESET = "\033[m" if sys.stdout.isatty() else ""
+    self.LEVEL_COLORS = { logging.WARNING:  "\033[4;33m",
+                          logging.ERROR:    "\033[4;31m",
+                          logging.CRITICAL: "\033[1;37;41m",
+                          logging.SUCCESS:  "\033[1;32m" } if sys.stdout.isatty() else {}
+  def format(self, record):
+    record.msg = record.msg % record.args
+    if record.levelno == logging.BANNER and sys.stdout.isatty():
+      lines = record.msg.split("\n")
+      return "\n\033[1;34m==>\033[m \033[1m%s\033[m" % lines[0] + \
+             "".join("\n    \033[1m%s\033[m" % x for x in lines[1:])
+    elif record.levelno == logging.INFO or record.levelno == logging.BANNER:
+      return record.msg
+    return "\n".join(self.fmtstr % {
+      "asctime": datetime.datetime.now().strftime("%Y-%m-%d@%H:%M:%S"),
+      "levelname": (self.LEVEL_COLORS.get(record.levelno, self.COLOR_RESET) +
+                    record.levelname + self.COLOR_RESET),
+      "message": x,
+    } for x in record.msg.split("\n"))
+
+
+def log_current_package(package, main_package, specs, devel_prefix) -> None:
+  """Show PACKAGE as the one currently being processed in future log messages."""
+  if logger_handler.level > logging.DEBUG:
+    return
+  if devel_prefix is not None:
+    short_version = devel_prefix
+  else:
+    short_version = specs[main_package]["commit_hash"]
+    if short_version != specs[main_package]["tag"]:
+      short_version = short_version[:8]
+  logger_handler.setFormatter(LogFormatter(
+    "%(asctime)s:%(levelname)s:{}:{}: %(message)s"
+    .format(main_package, short_version)
+    if package is None else
+    "%(asctime)s:%(levelname)s:{}:{}:{}: %(message)s"
+    .format(main_package, package, short_version)
+  ))
+
+
+class ProgressPrint:
+  def __init__(self, begin_msg="") -> None:
+    self.count = -1
+    self.lasttime = 0
+    self.STAGES = ".", "..", "...", "....", ".....", "....", "...", ".."
+    self.begin_msg = begin_msg
+    self.percent = -1
+
+  def __call__(self, txt, *args) -> None:
+    if logger.level <= logging.DEBUG or not sys.stdout.isatty():
+      debug(txt, *args)
+      return
+    if time.time() - self.lasttime < 0.5:
+      return
+    if self.count == -1 and self.begin_msg:
+      sys.stderr.write("\033[1;35m==>\033[m " + self.begin_msg)
+    txt %= args
+    self.erase()
+    m = re.search(r"((^|[^0-9])([0-9]{1,2})%|\[([0-9]+)/([0-9]+)\])", txt)
+    if m:
+      if m.group(3) is not None:
+        self.percent = int(m.group(3))
+      else:
+        num = int(m.group(4))
+        den = int(m.group(5))
+        if num >= 0 and den > 0:
+          self.percent = 100 * num / den
+    if self.percent > -1:
+      sys.stderr.write(" [%2d%%] " % self.percent)
+    self.count = (self.count+1) % len(self.STAGES)
+    sys.stderr.write(self.STAGES[self.count])
+    self.lasttime = time.time()
+    sys.stderr.flush()
+
+  def erase(self) -> None:
+    nerase = len(self.STAGES[self.count]) if self.count > -1 else 0
+    if self.percent > -1:
+      nerase = nerase + 7
+    sys.stderr.write("\b"*nerase+" "*nerase+"\b"*nerase)
+    sys.stderr.flush()
+
+  def end(self, msg="", error=False):
+    if self.count == -1:
+      return
+    self.erase()
+    if msg:
+      sys.stderr.write(": %s%s\033[m" % ("\033[31m" if error else "\033[32m", msg))
+    sys.stderr.write("\n")
+    sys.stderr.flush()
+
+
+# Add loglevel BANNER (same as INFO but with more emphasis on ttys)
+logging.BANNER = 25
+logging.addLevelName(logging.BANNER, "BANNER")
+def log_banner(self, message, *args, **kws):
+  if self.isEnabledFor(logging.BANNER):
+    self._log(logging.BANNER, message, args, **kws)
+logging.Logger.banner = log_banner
+
+# Add loglevel SUCCESS (same as ERROR, but green)
+logging.SUCCESS = 45
+logging.addLevelName(logging.SUCCESS, "SUCCESS")
+def log_success(self, message, *args, **kws):
+  if self.isEnabledFor(logging.SUCCESS):
+    self._log(logging.SUCCESS, message, args, **kws)
+logging.Logger.success = log_success
+
+logger = logging.getLogger('alibuild')
+logger_handler = logging.StreamHandler()
+logger.addHandler(logger_handler)
+logger_handler.setFormatter(LogFormatter("%(levelname)s: %(message)s"))
+
+debug = logger.debug
+error = logger.error
+warning = logger.warning
+info = logger.info
+banner = logger.banner
+success = logger.success

alibuild_helpers/scm.py

@@ -0,0 +1,31 @@
+class SCMError(Exception):
+  """Signal that an SCM-related error occurred."""
+
+
+class SCM(object):
+  def checkedOutCommitName(self, directory):
+    raise NotImplementedError
+  def branchOrRef(self, directory):
+    raise NotImplementedError
+  def lsRemote(self, remote):
+    raise NotImplementedError
+  def listRefsCmd(self, repository):
+    raise NotImplementedError
+  def parseRefs(self, output):
+    raise NotImplementedError
+  def exec(self, *args, **kwargs):
+    raise NotImplementedError
+  def checkoutCmd(self, tag):
+    raise NotImplementedError
+  def fetchCmd(self, remote, *refs):
+    raise NotImplementedError
+  def cloneReferenceCmd(self, spec, referenceRepo, usePartialClone):
+    raise NotImplementedError
+  def cloneSourceCmd(self, source, destination, referenceRepo, usePartialClone):
+    raise NotImplementedError
+  def setWriteUrlCmd(self, url):
+    raise NotImplementedError
+  def diffCmd(self, directory):
+    raise NotImplementedError
+  def checkUntracked(self, line):
+    raise NotImplementedError

alibuild_helpers/sl.py

@@ -0,0 +1,62 @@
+from shlex import quote  # Python 3.3+
+from alibuild_helpers.cmd import getstatusoutput
+from alibuild_helpers.log import debug
+from alibuild_helpers.scm import SCM, SCMError
+
+SL_COMMAND_TIMEOUT_SEC = 120
+"""How many seconds to let any sl command execute before being terminated."""
+
+
+# Sapling is a novel SCM by Meta (i.e. Facebook) that is fully compatible with
+# git, but has a different command line interface. Among the reasons why it's
+# worth supporting it is the ability to handle unnamed branches, the ability to
+# absorb changes to the correct commit without having to explicitly rebase and
+# the integration with github to allow for pull requests to be created from the
+# command line from each commit of a branch.
+class Sapling(SCM):
+  name = "Sapling"
+
+  def checkedOutCommitName(self, directory):
+    return sapling(("whereami", ), directory)
+
+  def branchOrRef(self, directory):
+    # Format is <hash>[+] <branch>
+    identity = sapling(("identify", ), directory)
+    return identity.split(" ")[-1]
+
+  def exec(self, *args, **kwargs):
+    return sapling(*args, **kwargs)
+
+  def parseRefs(self, output):
+    return {
+      sl_ref: sl_hash for sl_ref, sep, sl_hash
+      in (line.partition("\t") for line in output.splitlines()) if sep
+    }
+
+  def listRefsCmd(self, repository):
+    return ["bookmark", "--list", "--remote", "-R", repository]
+
+  def diffCmd(self, directory):
+    return "cd %s && sl diff && sl status" % directory
+
+  def checkUntracked(self, line):
+    return line.startswith("? ")
+
+
+def sapling(args, directory=".", check=True, prompt=True):
+  debug("Executing sl %s (in directory %s)", " ".join(args), directory)
+  # We can't use git --git-dir=%s/.git or git -C %s here as the former requires
+  # that the directory we're inspecting to be the root of a git directory, not
+  # just contained in one (and that breaks CI tests), and the latter isn't
+  # supported by the git version we have on slc6.
+  # Silence cd as shell configuration can cause the new directory to be echoed.
+  err, output = getstatusoutput("""\
+  set -e +x
+  sl -R {directory} {args}
+  """.format(
+    directory=quote(directory),
+    args=" ".join(map(quote, args)),
+  ), timeout=SL_COMMAND_TIMEOUT_SEC)
+  if check and err != 0:
+    raise SCMError("Error {} from sl {}: {}".format(err, " ".join(args), output))
+  return output if check else (err, output)