vasilito
cb424d7448
verify-patch-sanity.py validates every active recipe .patch has internally- consistent hunk line counts — catching the 'malformed patch at line N' failure at commit/CI/preflight time instead of hours into a cook. This cycle hit that class three times (qtwaylandscanner, sddm, xwayland), each only discovered when cookbook tried to apply the patch. Running it across the repo found 29 latent malformed patches (validated against GNU patch: e.g. relibc/P3-sysv-ipc reproduces 'malformed patch at line 22'). They were harmless only because they sit in vendored recipes (baked, not re- applied) — but would fail on any version-bump re-derivation. --fix recounts the hunk headers (body untouched) and repaired all 29. Wired into build-preflight.sh (Phase 1.0D) and redbear-ci.yml, with a unit test (test-patch-sanity.sh). Skips archived/legacy trees and unvalidatable formats (empty placeholders, bare-@@ git hunks).
178 lines
7.2 KiB
Python
178 lines
7.2 KiB
Python
#!/usr/bin/env python
|
|
# ===----------------------------------------------------------------------===##
|
|
#
|
|
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
# See https://llvm.org/LICENSE.txt for license information.
|
|
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
#
|
|
# ===----------------------------------------------------------------------===##
|
|
|
|
"""
|
|
Runs an executable on a remote host.
|
|
|
|
This is meant to be used as an executor when running the LLVM and the Libraries
|
|
tests on a target.
|
|
"""
|
|
|
|
import argparse
|
|
import os
|
|
import posixpath
|
|
import shlex
|
|
import subprocess
|
|
import sys
|
|
import tarfile
|
|
import tempfile
|
|
import re
|
|
|
|
|
|
def ssh(args, command):
|
|
cmd = ["ssh", "-oBatchMode=yes"]
|
|
if args.extra_ssh_args is not None:
|
|
cmd.extend(shlex.split(args.extra_ssh_args))
|
|
return cmd + [args.host, command]
|
|
|
|
|
|
def scp(args, src, dst):
|
|
cmd = ["scp", "-q", "-oBatchMode=yes"]
|
|
if args.extra_scp_args is not None:
|
|
cmd.extend(shlex.split(args.extra_scp_args))
|
|
return cmd + [src, "{}:{}".format(args.host, dst)]
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("--host", type=str, required=True)
|
|
parser.add_argument("--execdir", type=str, required=False)
|
|
parser.add_argument("--extra-ssh-args", type=str, required=False)
|
|
parser.add_argument("--extra-scp-args", type=str, required=False)
|
|
parser.add_argument("--codesign_identity", type=str, required=False, default=None)
|
|
parser.add_argument("--env", type=str, nargs="*", required=False, default=dict())
|
|
|
|
# Note: The default value is for the backward compatibility with a hack in
|
|
# libcxx test suite.
|
|
# If an argument is a file that ends in `.tmp.exe`, assume it is the name
|
|
# of an executable generated by a test file. We call these test-executables
|
|
# below. This allows us to do custom processing like codesigning test-executables
|
|
# and changing their path when running on the remote host. It's also possible
|
|
# for there to be no such executable, for example in the case of a .sh.cpp
|
|
# test.
|
|
parser.add_argument(
|
|
"--exec-pattern",
|
|
type=str,
|
|
required=False,
|
|
default=".*",
|
|
help="The name regex pattern of the executables generated by \
|
|
a test file. Specifying it allows us to do custom \
|
|
processing like codesigning test-executables \
|
|
and changing their path when running on \
|
|
the remote host. It's also possible for there \
|
|
to be no such executable, for example in \
|
|
the case of a .sh.cpp test.",
|
|
)
|
|
|
|
parser.add_argument("command", nargs=argparse.ONE_OR_MORE)
|
|
args = parser.parse_args()
|
|
commandLine = args.command
|
|
|
|
execdir = args.execdir
|
|
if execdir == ".":
|
|
# Retrieve the exec directory from the command line.
|
|
execdir, _ = os.path.split(commandLine[0])
|
|
if execdir == "":
|
|
# Get the current directory in that case.
|
|
execdir = os.getcwd()
|
|
arcname = os.path.basename(execdir) if execdir else None
|
|
|
|
# Create a temporary directory where the test will be run.
|
|
# That is effectively the value of %T on the remote host.
|
|
tmp = subprocess.check_output(
|
|
ssh(args, "mktemp -d /tmp/llvm.XXXXXXXXXX"), universal_newlines=True
|
|
).strip()
|
|
|
|
isExecutable = lambda exe: re.match(args.exec_pattern, exe) and os.path.exists(exe)
|
|
pathOnRemote = lambda file: posixpath.join(tmp, os.path.basename(file))
|
|
|
|
remoteCommands = []
|
|
|
|
try:
|
|
# Do any necessary codesigning of test-executables found in the command line.
|
|
if args.codesign_identity:
|
|
for exe in filter(isExecutable, commandLine):
|
|
subprocess.check_call(
|
|
["xcrun", "codesign", "-f", "-s", args.codesign_identity, exe],
|
|
env={},
|
|
)
|
|
|
|
# tar up the execution directory (which contains everything that's needed
|
|
# to run the test), and copy the tarball over to the remote host.
|
|
if execdir:
|
|
try:
|
|
tmpTar = tempfile.NamedTemporaryFile(suffix=".tar", delete=False)
|
|
with tarfile.open(fileobj=tmpTar, mode="w") as tarball:
|
|
tarball.add(execdir, arcname=arcname)
|
|
|
|
# Make sure we close the file before we scp it, because accessing
|
|
# the temporary file while still open doesn't work on Windows.
|
|
tmpTar.close()
|
|
remoteTarball = pathOnRemote(tmpTar.name)
|
|
subprocess.check_call(scp(args, tmpTar.name, remoteTarball))
|
|
finally:
|
|
# Make sure we close the file in case an exception happens before
|
|
# we've closed it above -- otherwise close() is idempotent.
|
|
tmpTar.close()
|
|
os.remove(tmpTar.name)
|
|
|
|
# Untar the dependencies in the temporary directory and remove the tarball.
|
|
remoteCommands.extend(
|
|
[
|
|
"tar -xf {} -C {} --strip-components 1".format(remoteTarball, tmp),
|
|
"rm {}".format(remoteTarball),
|
|
]
|
|
)
|
|
else:
|
|
# Copy only files which are specified in the command line and exist on
|
|
# the host. Copy them to the remote host one by one.
|
|
for x in commandLine:
|
|
if os.path.exists(x):
|
|
_, f = os.path.split(x)
|
|
subprocess.check_call(scp(args, x, pathOnRemote(f)))
|
|
|
|
# Make sure all executables in the remote command line have 'execute'
|
|
# permissions on the remote host. The host that compiled the test-executable
|
|
# might not have a notion of 'executable' permissions.
|
|
for exe in filter(isExecutable, commandLine):
|
|
remoteCommands.append("chmod +x {}".format(pathOnRemote(exe)))
|
|
|
|
# Execute the command through SSH in the temporary directory, with the
|
|
# correct environment. We tweak the command line to run it on the remote
|
|
# host by transforming the path of test-executables to their path in the
|
|
# temporary directory on the remote host.
|
|
for i, x in enumerate(commandLine):
|
|
if isExecutable(x):
|
|
commandLine[i] = pathOnRemote(x)
|
|
remoteCommands.append("cd {}".format(tmp))
|
|
if args.env:
|
|
remoteCommands.append("export {}".format(" ".join(args.env)))
|
|
remoteCommands.append(subprocess.list2cmdline(commandLine))
|
|
|
|
# Finally, SSH to the remote host and execute all the commands.
|
|
rc = subprocess.call(ssh(args, " && ".join(remoteCommands)))
|
|
return rc
|
|
|
|
finally:
|
|
# Make sure the temporary directory is removed when we're done.
|
|
subprocess.check_call(ssh(args, "rm -r {}".format(tmp)))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
rc = main()
|
|
|
|
# If the remote process died with a signal, this will be exposed by ssh as
|
|
# an exit code in this range. We may be running under `not --crash` which
|
|
# will expect us to also die with a signal, so send the signal to ourselves
|
|
# so that wait4() in `not` will detect the signal.
|
|
if rc > 128 and rc < 160:
|
|
os.kill(os.getpid(), rc - 128)
|
|
|
|
exit(rc)
|