| # SPDX-License-Identifier: Apache-2.0 |
| # Copyright 2013-2014 The Meson development team |
| |
| from __future__ import annotations |
| |
| from glob import glob |
| import argparse |
| import errno |
| import os |
| import selectors |
| import shlex |
| import shutil |
| import subprocess |
| import sys |
| import typing as T |
| import re |
| |
| from . import build, environment |
| from .backend.backends import InstallData |
| from .mesonlib import (MesonException, Popen_safe, RealPathAction, is_windows, |
| is_aix, setup_vsenv, pickle_load, is_osx, OptionKey) |
| from .scripts import depfixer, destdir_join |
| from .scripts.meson_exe import run_exe |
| try: |
| from __main__ import __file__ as main_file |
| except ImportError: |
| # Happens when running as meson.exe which is native Windows. |
| # This is only used for pkexec which is not, so this is fine. |
| main_file = None |
| |
| if T.TYPE_CHECKING: |
| from .backend.backends import ( |
| InstallDataBase, InstallEmptyDir, |
| InstallSymlinkData, TargetInstallData |
| ) |
| from .mesonlib import FileMode, EnvironOrDict, ExecutableSerialisation |
| |
| try: |
| from typing import Protocol |
| except AttributeError: |
| from typing_extensions import Protocol # type: ignore |
| |
| class ArgumentType(Protocol): |
| """Typing information for the object returned by argparse.""" |
| no_rebuild: bool |
| only_changed: bool |
| profile: bool |
| quiet: bool |
| wd: str |
| destdir: str |
| dry_run: bool |
| skip_subprojects: str |
| tags: str |
| strip: bool |
| |
| |
| symlink_warning = '''\ |
| Warning: trying to copy a symlink that points to a file. This currently copies |
| the file by default, but will be changed in a future version of Meson to copy |
| the link instead. Set follow_symlinks to true to preserve current behavior, or |
| false to copy the link.''' |
| |
| selinux_updates: T.List[str] = [] |
| |
| # Note: when adding arguments, please also add them to the completion |
| # scripts in $MESONSRC/data/shell-completions/ |
| def add_arguments(parser: argparse.ArgumentParser) -> None: |
| parser.add_argument('-C', dest='wd', action=RealPathAction, |
| help='directory to cd into before running') |
| parser.add_argument('--profile-self', action='store_true', dest='profile', |
| help=argparse.SUPPRESS) |
| parser.add_argument('--no-rebuild', default=False, action='store_true', |
| help='Do not rebuild before installing.') |
| parser.add_argument('--only-changed', default=False, action='store_true', |
| help='Only overwrite files that are older than the copied file.') |
| parser.add_argument('--quiet', default=False, action='store_true', |
| help='Do not print every file that was installed.') |
| parser.add_argument('--destdir', default=None, |
| help='Sets or overrides DESTDIR environment. (Since 0.57.0)') |
| parser.add_argument('--dry-run', '-n', action='store_true', |
| help='Doesn\'t actually install, but print logs. (Since 0.57.0)') |
| parser.add_argument('--skip-subprojects', nargs='?', const='*', default='', |
| help='Do not install files from given subprojects. (Since 0.58.0)') |
| parser.add_argument('--tags', default=None, |
| help='Install only targets having one of the given tags. (Since 0.60.0)') |
| parser.add_argument('--strip', action='store_true', |
| help='Strip targets even if strip option was not set during configure. (Since 0.62.0)') |
| |
| class DirMaker: |
| def __init__(self, lf: T.TextIO, makedirs: T.Callable[..., None]): |
| self.lf = lf |
| self.dirs: T.List[str] = [] |
| self.all_dirs: T.Set[str] = set() |
| self.makedirs_impl = makedirs |
| |
| def makedirs(self, path: str, exist_ok: bool = False) -> None: |
| dirname = os.path.normpath(path) |
| self.all_dirs.add(dirname) |
| dirs = [] |
| while dirname != os.path.dirname(dirname): |
| if dirname in self.dirs: |
| # In dry-run mode the directory does not exist but we would have |
| # created it with all its parents otherwise. |
| break |
| if not os.path.exists(dirname): |
| dirs.append(dirname) |
| dirname = os.path.dirname(dirname) |
| self.makedirs_impl(path, exist_ok=exist_ok) |
| |
| # store the directories in creation order, with the parent directory |
| # before the child directories. Future calls of makedir() will not |
| # create the parent directories, so the last element in the list is |
| # the last one to be created. That is the first one to be removed on |
| # __exit__ |
| dirs.reverse() |
| self.dirs += dirs |
| |
| def __enter__(self) -> 'DirMaker': |
| return self |
| |
| def __exit__(self, exception_type: T.Type[Exception], value: T.Any, traceback: T.Any) -> None: |
| self.dirs.reverse() |
| for d in self.dirs: |
| append_to_log(self.lf, d) |
| |
| |
| def load_install_data(fname: str) -> InstallData: |
| return pickle_load(fname, 'InstallData', InstallData) |
| |
| def is_executable(path: str, follow_symlinks: bool = False) -> bool: |
| '''Checks whether any of the "x" bits are set in the source file mode.''' |
| return bool(os.stat(path, follow_symlinks=follow_symlinks).st_mode & 0o111) |
| |
| |
| def append_to_log(lf: T.TextIO, line: str) -> None: |
| lf.write(line) |
| if not line.endswith('\n'): |
| lf.write('\n') |
| lf.flush() |
| |
| |
| def set_chown(path: str, user: T.Union[str, int, None] = None, |
| group: T.Union[str, int, None] = None, |
| dir_fd: T.Optional[int] = None, follow_symlinks: bool = True) -> None: |
| # shutil.chown will call os.chown without passing all the parameters |
| # and particularly follow_symlinks, thus we replace it temporary |
| # with a lambda with all the parameters so that follow_symlinks will |
| # be actually passed properly. |
| # Not nice, but better than actually rewriting shutil.chown until |
| # this python bug is fixed: https://bugs.python.org/issue18108 |
| real_os_chown = os.chown |
| |
| def chown(path: T.Union[int, str, 'os.PathLike[str]', bytes, 'os.PathLike[bytes]'], |
| uid: int, gid: int, *, dir_fd: T.Optional[int] = dir_fd, |
| follow_symlinks: bool = follow_symlinks) -> None: |
| """Override the default behavior of os.chown |
| |
| Use a real function rather than a lambda to help mypy out. Also real |
| functions are faster. |
| """ |
| real_os_chown(path, uid, gid, dir_fd=dir_fd, follow_symlinks=follow_symlinks) |
| |
| try: |
| os.chown = chown |
| shutil.chown(path, user, group) |
| finally: |
| os.chown = real_os_chown |
| |
| |
| def set_chmod(path: str, mode: int, dir_fd: T.Optional[int] = None, |
| follow_symlinks: bool = True) -> None: |
| try: |
| os.chmod(path, mode, dir_fd=dir_fd, follow_symlinks=follow_symlinks) |
| except (NotImplementedError, OSError, SystemError): |
| if not os.path.islink(path): |
| os.chmod(path, mode, dir_fd=dir_fd) |
| |
| |
| def sanitize_permissions(path: str, umask: T.Union[str, int]) -> None: |
| # TODO: with python 3.8 or typing_extensions we could replace this with |
| # `umask: T.Union[T.Literal['preserve'], int]`, which would be more correct |
| if umask == 'preserve': |
| return |
| assert isinstance(umask, int), 'umask should only be "preserver" or an integer' |
| new_perms = 0o777 if is_executable(path, follow_symlinks=False) else 0o666 |
| new_perms &= ~umask |
| try: |
| set_chmod(path, new_perms, follow_symlinks=False) |
| except PermissionError as e: |
| print(f'{path!r}: Unable to set permissions {new_perms!r}: {e.strerror}, ignoring...') |
| |
| |
| def set_mode(path: str, mode: T.Optional['FileMode'], default_umask: T.Union[str, int]) -> None: |
| if mode is None or all(m is None for m in [mode.perms_s, mode.owner, mode.group]): |
| # Just sanitize permissions with the default umask |
| sanitize_permissions(path, default_umask) |
| return |
| # No chown() on Windows, and must set one of owner/group |
| if not is_windows() and (mode.owner is not None or mode.group is not None): |
| try: |
| set_chown(path, mode.owner, mode.group, follow_symlinks=False) |
| except PermissionError as e: |
| print(f'{path!r}: Unable to set owner {mode.owner!r} and group {mode.group!r}: {e.strerror}, ignoring...') |
| except LookupError: |
| print(f'{path!r}: Nonexistent owner {mode.owner!r} or group {mode.group!r}: ignoring...') |
| except OSError as e: |
| if e.errno == errno.EINVAL: |
| print(f'{path!r}: Nonexistent numeric owner {mode.owner!r} or group {mode.group!r}: ignoring...') |
| else: |
| raise |
| # Must set permissions *after* setting owner/group otherwise the |
| # setuid/setgid bits will get wiped by chmod |
| # NOTE: On Windows you can set read/write perms; the rest are ignored |
| if mode.perms_s is not None: |
| try: |
| set_chmod(path, mode.perms, follow_symlinks=False) |
| except PermissionError as e: |
| print(f'{path!r}: Unable to set permissions {mode.perms_s!r}: {e.strerror}, ignoring...') |
| else: |
| sanitize_permissions(path, default_umask) |
| |
| |
| def restore_selinux_contexts() -> None: |
| ''' |
| Restores the SELinux context for files in @selinux_updates |
| |
| If $DESTDIR is set, do not warn if the call fails. |
| ''' |
| try: |
| subprocess.check_call(['selinuxenabled']) |
| except (FileNotFoundError, NotADirectoryError, OSError, PermissionError, subprocess.CalledProcessError): |
| # If we don't have selinux or selinuxenabled returned 1, failure |
| # is ignored quietly. |
| return |
| |
| if not shutil.which('restorecon'): |
| # If we don't have restorecon, failure is ignored quietly. |
| return |
| |
| if not selinux_updates: |
| # If the list of files is empty, do not try to call restorecon. |
| return |
| |
| proc, out, err = Popen_safe(['restorecon', '-F', '-f-', '-0'], ('\0'.join(f for f in selinux_updates) + '\0')) |
| if proc.returncode != 0: |
| print('Failed to restore SELinux context of installed files...', |
| 'Standard output:', out, |
| 'Standard error:', err, sep='\n') |
| |
| def get_destdir_path(destdir: str, fullprefix: str, path: str) -> str: |
| if os.path.isabs(path): |
| output = destdir_join(destdir, path) |
| else: |
| output = os.path.join(fullprefix, path) |
| return output |
| |
| |
| def check_for_stampfile(fname: str) -> str: |
| '''Some languages e.g. Rust have output files |
| whose names are not known at configure time. |
| Check if this is the case and return the real |
| file instead.''' |
| if fname.endswith('.so') or fname.endswith('.dll'): |
| if os.stat(fname).st_size == 0: |
| (base, suffix) = os.path.splitext(fname) |
| files = glob(base + '-*' + suffix) |
| if len(files) > 1: |
| print("Stale dynamic library files in build dir. Can't install.") |
| sys.exit(1) |
| if len(files) == 1: |
| return files[0] |
| elif fname.endswith('.a') or fname.endswith('.lib'): |
| if os.stat(fname).st_size == 0: |
| (base, suffix) = os.path.splitext(fname) |
| files = glob(base + '-*' + '.rlib') |
| if len(files) > 1: |
| print("Stale static library files in build dir. Can't install.") |
| sys.exit(1) |
| if len(files) == 1: |
| return files[0] |
| return fname |
| |
| |
| class Installer: |
| |
| def __init__(self, options: 'ArgumentType', lf: T.TextIO): |
| self.did_install_something = False |
| self.printed_symlink_error = False |
| self.options = options |
| self.lf = lf |
| self.preserved_file_count = 0 |
| self.dry_run = options.dry_run |
| # [''] means skip none, |
| # ['*'] means skip all, |
| # ['sub1', ...] means skip only those. |
| self.skip_subprojects = [i.strip() for i in options.skip_subprojects.split(',')] |
| self.tags = [i.strip() for i in options.tags.split(',')] if options.tags else None |
| |
| def remove(self, *args: T.Any, **kwargs: T.Any) -> None: |
| if not self.dry_run: |
| os.remove(*args, **kwargs) |
| |
| def symlink(self, *args: T.Any, **kwargs: T.Any) -> None: |
| if not self.dry_run: |
| os.symlink(*args, **kwargs) |
| |
| def makedirs(self, *args: T.Any, **kwargs: T.Any) -> None: |
| if not self.dry_run: |
| os.makedirs(*args, **kwargs) |
| |
| def copy(self, *args: T.Any, **kwargs: T.Any) -> None: |
| if not self.dry_run: |
| shutil.copy(*args, **kwargs) |
| |
| def copy2(self, *args: T.Any, **kwargs: T.Any) -> None: |
| if not self.dry_run: |
| shutil.copy2(*args, **kwargs) |
| |
| def copyfile(self, *args: T.Any, **kwargs: T.Any) -> None: |
| if not self.dry_run: |
| shutil.copyfile(*args, **kwargs) |
| |
| def copystat(self, *args: T.Any, **kwargs: T.Any) -> None: |
| if not self.dry_run: |
| shutil.copystat(*args, **kwargs) |
| |
| def fix_rpath(self, *args: T.Any, **kwargs: T.Any) -> None: |
| if not self.dry_run: |
| depfixer.fix_rpath(*args, **kwargs) |
| |
| def set_chown(self, *args: T.Any, **kwargs: T.Any) -> None: |
| if not self.dry_run: |
| set_chown(*args, **kwargs) |
| |
| def set_chmod(self, *args: T.Any, **kwargs: T.Any) -> None: |
| if not self.dry_run: |
| set_chmod(*args, **kwargs) |
| |
| def sanitize_permissions(self, *args: T.Any, **kwargs: T.Any) -> None: |
| if not self.dry_run: |
| sanitize_permissions(*args, **kwargs) |
| |
| def set_mode(self, *args: T.Any, **kwargs: T.Any) -> None: |
| if not self.dry_run: |
| set_mode(*args, **kwargs) |
| |
| def restore_selinux_contexts(self, destdir: str) -> None: |
| if not self.dry_run and not destdir: |
| restore_selinux_contexts() |
| |
| def Popen_safe(self, *args: T.Any, **kwargs: T.Any) -> T.Tuple[int, str, str]: |
| if not self.dry_run: |
| p, o, e = Popen_safe(*args, **kwargs) |
| return p.returncode, o, e |
| return 0, '', '' |
| |
| def run_exe(self, exe: ExecutableSerialisation, extra_env: T.Optional[T.Dict[str, str]] = None) -> int: |
| if (not self.dry_run) or exe.dry_run: |
| return run_exe(exe, extra_env) |
| return 0 |
| |
| def should_install(self, d: T.Union[TargetInstallData, InstallEmptyDir, |
| InstallDataBase, InstallSymlinkData, |
| ExecutableSerialisation]) -> bool: |
| if d.subproject and (d.subproject in self.skip_subprojects or '*' in self.skip_subprojects): |
| return False |
| if self.tags and d.tag not in self.tags: |
| return False |
| return True |
| |
| def log(self, msg: str) -> None: |
| if not self.options.quiet: |
| print(msg) |
| |
| def should_preserve_existing_file(self, from_file: str, to_file: str) -> bool: |
| if not self.options.only_changed: |
| return False |
| # Always replace danging symlinks |
| if os.path.islink(from_file) and not os.path.isfile(from_file): |
| return False |
| from_time = os.stat(from_file).st_mtime |
| to_time = os.stat(to_file).st_mtime |
| return from_time <= to_time |
| |
| def do_copyfile(self, from_file: str, to_file: str, |
| makedirs: T.Optional[T.Tuple[T.Any, str]] = None, |
| follow_symlinks: T.Optional[bool] = None) -> bool: |
| outdir = os.path.split(to_file)[0] |
| if not os.path.isfile(from_file) and not os.path.islink(from_file): |
| raise MesonException(f'Tried to install something that isn\'t a file: {from_file!r}') |
| # copyfile fails if the target file already exists, so remove it to |
| # allow overwriting a previous install. If the target is not a file, we |
| # want to give a readable error. |
| if os.path.exists(to_file): |
| if not os.path.isfile(to_file): |
| raise MesonException(f'Destination {to_file!r} already exists and is not a file') |
| if self.should_preserve_existing_file(from_file, to_file): |
| append_to_log(self.lf, f'# Preserving old file {to_file}\n') |
| self.preserved_file_count += 1 |
| return False |
| self.log(f'Installing {from_file} to {outdir}') |
| self.remove(to_file) |
| else: |
| self.log(f'Installing {from_file} to {outdir}') |
| if makedirs: |
| # Unpack tuple |
| dirmaker, outdir = makedirs |
| # Create dirs if needed |
| dirmaker.makedirs(outdir, exist_ok=True) |
| if os.path.islink(from_file): |
| if not os.path.exists(from_file): |
| # Dangling symlink. Replicate as is. |
| self.copy(from_file, outdir, follow_symlinks=False) |
| else: |
| if follow_symlinks is None: |
| follow_symlinks = True # TODO: change to False when removing the warning |
| print(symlink_warning) |
| self.copy2(from_file, to_file, follow_symlinks=follow_symlinks) |
| else: |
| self.copy2(from_file, to_file) |
| selinux_updates.append(to_file) |
| append_to_log(self.lf, to_file) |
| return True |
| |
| def do_symlink(self, target: str, link: str, destdir: str, full_dst_dir: str, allow_missing: bool) -> bool: |
| abs_target = target |
| if not os.path.isabs(target): |
| abs_target = os.path.join(full_dst_dir, target) |
| elif not os.path.exists(abs_target) and not allow_missing: |
| abs_target = destdir_join(destdir, abs_target) |
| if not os.path.exists(abs_target) and not allow_missing: |
| raise MesonException(f'Tried to install symlink to missing file {abs_target}') |
| if os.path.exists(link): |
| if not os.path.islink(link): |
| raise MesonException(f'Destination {link!r} already exists and is not a symlink') |
| self.remove(link) |
| if not self.printed_symlink_error: |
| self.log(f'Installing symlink pointing to {target} to {link}') |
| try: |
| self.symlink(target, link, target_is_directory=os.path.isdir(abs_target)) |
| except (NotImplementedError, OSError): |
| if not self.printed_symlink_error: |
| print("Symlink creation does not work on this platform. " |
| "Skipping all symlinking.") |
| self.printed_symlink_error = True |
| return False |
| append_to_log(self.lf, link) |
| return True |
| |
| def do_copydir(self, data: InstallData, src_dir: str, dst_dir: str, |
| exclude: T.Optional[T.Tuple[T.Set[str], T.Set[str]]], |
| install_mode: 'FileMode', dm: DirMaker, follow_symlinks: T.Optional[bool] = None) -> None: |
| ''' |
| Copies the contents of directory @src_dir into @dst_dir. |
| |
| For directory |
| /foo/ |
| bar/ |
| excluded |
| foobar |
| file |
| do_copydir(..., '/foo', '/dst/dir', {'bar/excluded'}) creates |
| /dst/ |
| dir/ |
| bar/ |
| foobar |
| file |
| |
| Args: |
| src_dir: str, absolute path to the source directory |
| dst_dir: str, absolute path to the destination directory |
| exclude: (set(str), set(str)), tuple of (exclude_files, exclude_dirs), |
| each element of the set is a path relative to src_dir. |
| ''' |
| if not os.path.isabs(src_dir): |
| raise ValueError(f'src_dir must be absolute, got {src_dir}') |
| if not os.path.isabs(dst_dir): |
| raise ValueError(f'dst_dir must be absolute, got {dst_dir}') |
| if exclude is not None: |
| exclude_files, exclude_dirs = exclude |
| exclude_files = {os.path.normpath(x) for x in exclude_files} |
| exclude_dirs = {os.path.normpath(x) for x in exclude_dirs} |
| else: |
| exclude_files = exclude_dirs = set() |
| for root, dirs, files in os.walk(src_dir): |
| assert os.path.isabs(root) |
| for d in dirs[:]: |
| abs_src = os.path.join(root, d) |
| filepart = os.path.relpath(abs_src, start=src_dir) |
| abs_dst = os.path.join(dst_dir, filepart) |
| # Remove these so they aren't visited by os.walk at all. |
| if filepart in exclude_dirs: |
| dirs.remove(d) |
| continue |
| if os.path.isdir(abs_dst): |
| continue |
| if os.path.exists(abs_dst): |
| print(f'Tried to copy directory {abs_dst} but a file of that name already exists.') |
| sys.exit(1) |
| dm.makedirs(abs_dst) |
| self.copystat(abs_src, abs_dst) |
| self.sanitize_permissions(abs_dst, data.install_umask) |
| for f in files: |
| abs_src = os.path.join(root, f) |
| filepart = os.path.relpath(abs_src, start=src_dir) |
| if filepart in exclude_files: |
| continue |
| abs_dst = os.path.join(dst_dir, filepart) |
| if os.path.isdir(abs_dst): |
| print(f'Tried to copy file {abs_dst} but a directory of that name already exists.') |
| sys.exit(1) |
| parent_dir = os.path.dirname(abs_dst) |
| if not os.path.isdir(parent_dir): |
| dm.makedirs(parent_dir) |
| self.copystat(os.path.dirname(abs_src), parent_dir) |
| # FIXME: what about symlinks? |
| self.do_copyfile(abs_src, abs_dst, follow_symlinks=follow_symlinks) |
| self.set_mode(abs_dst, install_mode, data.install_umask) |
| |
| def do_install(self, datafilename: str) -> None: |
| d = load_install_data(datafilename) |
| |
| destdir = self.options.destdir |
| if destdir is None: |
| destdir = os.environ.get('DESTDIR') |
| if destdir and not os.path.isabs(destdir): |
| destdir = os.path.join(d.build_dir, destdir) |
| # Override in the env because some scripts could use it and require an |
| # absolute path. |
| if destdir is not None: |
| os.environ['DESTDIR'] = destdir |
| destdir = destdir or '' |
| fullprefix = destdir_join(destdir, d.prefix) |
| |
| if d.install_umask != 'preserve': |
| assert isinstance(d.install_umask, int) |
| os.umask(d.install_umask) |
| |
| self.did_install_something = False |
| try: |
| with DirMaker(self.lf, self.makedirs) as dm: |
| self.install_subdirs(d, dm, destdir, fullprefix) # Must be first, because it needs to delete the old subtree. |
| self.install_targets(d, dm, destdir, fullprefix) |
| self.install_headers(d, dm, destdir, fullprefix) |
| self.install_man(d, dm, destdir, fullprefix) |
| self.install_emptydir(d, dm, destdir, fullprefix) |
| self.install_data(d, dm, destdir, fullprefix) |
| self.install_symlinks(d, dm, destdir, fullprefix) |
| self.restore_selinux_contexts(destdir) |
| self.run_install_script(d, destdir, fullprefix) |
| if not self.did_install_something: |
| self.log('Nothing to install.') |
| if not self.options.quiet and self.preserved_file_count > 0: |
| self.log('Preserved {} unchanged files, see {} for the full list' |
| .format(self.preserved_file_count, os.path.normpath(self.lf.name))) |
| except PermissionError: |
| if is_windows() or destdir != '' or not os.isatty(sys.stdout.fileno()) or not os.isatty(sys.stderr.fileno()): |
| # can't elevate to root except in an interactive unix environment *and* when not doing a destdir install |
| raise |
| rootcmd = os.environ.get('MESON_ROOT_CMD') or shutil.which('sudo') or shutil.which('doas') |
| pkexec = shutil.which('pkexec') |
| if rootcmd is None and pkexec is not None and 'PKEXEC_UID' not in os.environ: |
| rootcmd = pkexec |
| |
| if rootcmd is not None: |
| print('Installation failed due to insufficient permissions.') |
| s = selectors.DefaultSelector() |
| s.register(sys.stdin, selectors.EVENT_READ) |
| ans = None |
| for attempt in range(5): |
| print(f'Attempt to use {rootcmd} to gain elevated privileges? [y/n] ', end='', flush=True) |
| if s.select(30): |
| # we waited on sys.stdin *only* |
| ans = sys.stdin.readline().rstrip('\n') |
| else: |
| print() |
| break |
| if ans in {'y', 'n'}: |
| break |
| else: |
| if ans is not None: |
| raise MesonException('Answer not one of [y/n]') |
| if ans == 'y': |
| os.execlp(rootcmd, rootcmd, sys.executable, main_file, *sys.argv[1:], |
| '-C', os.getcwd(), '--no-rebuild') |
| raise |
| |
| def do_strip(self, strip_bin: T.List[str], fname: str, outname: str) -> None: |
| self.log(f'Stripping target {fname!r}.') |
| if is_osx(): |
| # macOS expects dynamic objects to be stripped with -x maximum. |
| # To also strip the debug info, -S must be added. |
| # See: https://www.unix.com/man-page/osx/1/strip/ |
| returncode, stdo, stde = self.Popen_safe(strip_bin + ['-S', '-x', outname]) |
| else: |
| returncode, stdo, stde = self.Popen_safe(strip_bin + [outname]) |
| if returncode != 0: |
| print('Could not strip file.\n') |
| print(f'Stdout:\n{stdo}\n') |
| print(f'Stderr:\n{stde}\n') |
| sys.exit(1) |
| |
| def install_subdirs(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None: |
| for i in d.install_subdirs: |
| if not self.should_install(i): |
| continue |
| self.did_install_something = True |
| full_dst_dir = get_destdir_path(destdir, fullprefix, i.install_path) |
| self.log(f'Installing subdir {i.path} to {full_dst_dir}') |
| dm.makedirs(full_dst_dir, exist_ok=True) |
| self.do_copydir(d, i.path, full_dst_dir, i.exclude, i.install_mode, dm, |
| follow_symlinks=i.follow_symlinks) |
| |
| def install_data(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None: |
| for i in d.data: |
| if not self.should_install(i): |
| continue |
| fullfilename = i.path |
| outfilename = get_destdir_path(destdir, fullprefix, i.install_path) |
| outdir = os.path.dirname(outfilename) |
| if self.do_copyfile(fullfilename, outfilename, makedirs=(dm, outdir), follow_symlinks=i.follow_symlinks): |
| self.did_install_something = True |
| self.set_mode(outfilename, i.install_mode, d.install_umask) |
| |
| def install_symlinks(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None: |
| for s in d.symlinks: |
| if not self.should_install(s): |
| continue |
| full_dst_dir = get_destdir_path(destdir, fullprefix, s.install_path) |
| full_link_name = get_destdir_path(destdir, fullprefix, s.name) |
| dm.makedirs(full_dst_dir, exist_ok=True) |
| if self.do_symlink(s.target, full_link_name, destdir, full_dst_dir, s.allow_missing): |
| self.did_install_something = True |
| |
| def install_man(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None: |
| for m in d.man: |
| if not self.should_install(m): |
| continue |
| full_source_filename = m.path |
| outfilename = get_destdir_path(destdir, fullprefix, m.install_path) |
| outdir = os.path.dirname(outfilename) |
| if self.do_copyfile(full_source_filename, outfilename, makedirs=(dm, outdir)): |
| self.did_install_something = True |
| self.set_mode(outfilename, m.install_mode, d.install_umask) |
| |
| def install_emptydir(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None: |
| for e in d.emptydir: |
| if not self.should_install(e): |
| continue |
| self.did_install_something = True |
| full_dst_dir = get_destdir_path(destdir, fullprefix, e.path) |
| self.log(f'Installing new directory {full_dst_dir}') |
| if os.path.isfile(full_dst_dir): |
| print(f'Tried to create directory {full_dst_dir} but a file of that name already exists.') |
| sys.exit(1) |
| dm.makedirs(full_dst_dir, exist_ok=True) |
| self.set_mode(full_dst_dir, e.install_mode, d.install_umask) |
| |
| def install_headers(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None: |
| for t in d.headers: |
| if not self.should_install(t): |
| continue |
| fullfilename = t.path |
| fname = os.path.basename(fullfilename) |
| outdir = get_destdir_path(destdir, fullprefix, t.install_path) |
| outfilename = os.path.join(outdir, fname) |
| if self.do_copyfile(fullfilename, outfilename, makedirs=(dm, outdir), |
| follow_symlinks=t.follow_symlinks): |
| self.did_install_something = True |
| self.set_mode(outfilename, t.install_mode, d.install_umask) |
| |
| def run_install_script(self, d: InstallData, destdir: str, fullprefix: str) -> None: |
| env = {'MESON_SOURCE_ROOT': d.source_dir, |
| 'MESON_BUILD_ROOT': d.build_dir, |
| 'MESONINTROSPECT': ' '.join([shlex.quote(x) for x in d.mesonintrospect]), |
| } |
| if self.options.quiet: |
| env['MESON_INSTALL_QUIET'] = '1' |
| if self.dry_run: |
| env['MESON_INSTALL_DRY_RUN'] = '1' |
| |
| for i in d.install_scripts: |
| if not self.should_install(i): |
| continue |
| |
| if i.installdir_map is not None: |
| mapp = i.installdir_map |
| else: |
| mapp = {'prefix': d.prefix} |
| localenv = env.copy() |
| localenv.update({'MESON_INSTALL_'+k.upper(): os.path.join(d.prefix, v) for k, v in mapp.items()}) |
| localenv.update({'MESON_INSTALL_DESTDIR_'+k.upper(): get_destdir_path(destdir, fullprefix, v) for k, v in mapp.items()}) |
| |
| name = ' '.join(i.cmd_args) |
| if i.skip_if_destdir and destdir: |
| self.log(f'Skipping custom install script because DESTDIR is set {name!r}') |
| continue |
| self.did_install_something = True # Custom script must report itself if it does nothing. |
| self.log(f'Running custom install script {name!r}') |
| try: |
| rc = self.run_exe(i, localenv) |
| except OSError: |
| print(f'FAILED: install script \'{name}\' could not be run.') |
| # POSIX shells return 127 when a command could not be found |
| sys.exit(127) |
| if rc != 0: |
| print(f'FAILED: install script \'{name}\' failed with exit code {rc}.') |
| sys.exit(rc) |
| |
| def install_targets(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None: |
| for t in d.targets: |
| # In AIX, we archive our shared libraries. When we install any package in AIX we need to |
| # install the archive in which the shared library exists. The below code does the same. |
| # We change the .so files having lt_version or so_version to archive file install. |
| # If .so does not exist then it means it is in the archive. Otherwise it is a .so that exists. |
| if is_aix(): |
| if not os.path.exists(t.fname) and '.so' in t.fname: |
| t.fname = re.sub('[.][a]([.]?([0-9]+))*([.]?([a-z]+))*', '.a', t.fname.replace('.so', '.a')) |
| if not self.should_install(t): |
| continue |
| if not os.path.exists(t.fname): |
| # For example, import libraries of shared modules are optional |
| if t.optional: |
| self.log(f'File {t.fname!r} not found, skipping') |
| continue |
| else: |
| raise MesonException(f'File {t.fname!r} could not be found') |
| file_copied = False # not set when a directory is copied |
| fname = check_for_stampfile(t.fname) |
| outdir = get_destdir_path(destdir, fullprefix, t.outdir) |
| outname = os.path.join(outdir, os.path.basename(fname)) |
| final_path = os.path.join(d.prefix, t.outdir, os.path.basename(fname)) |
| should_strip = t.strip or (t.can_strip and self.options.strip) |
| install_rpath = t.install_rpath |
| install_name_mappings = t.install_name_mappings |
| install_mode = t.install_mode |
| if not os.path.exists(fname): |
| raise MesonException(f'File {fname!r} could not be found') |
| elif os.path.isfile(fname): |
| file_copied = self.do_copyfile(fname, outname, makedirs=(dm, outdir)) |
| if should_strip and d.strip_bin is not None: |
| if fname.endswith('.jar'): |
| self.log('Not stripping jar target: {}'.format(os.path.basename(fname))) |
| continue |
| self.do_strip(d.strip_bin, fname, outname) |
| if fname.endswith('.js'): |
| # Emscripten outputs js files and optionally a wasm file. |
| # If one was generated, install it as well. |
| wasm_source = os.path.splitext(fname)[0] + '.wasm' |
| if os.path.exists(wasm_source): |
| wasm_output = os.path.splitext(outname)[0] + '.wasm' |
| file_copied = self.do_copyfile(wasm_source, wasm_output) |
| elif os.path.isdir(fname): |
| fname = os.path.join(d.build_dir, fname.rstrip('/')) |
| outname = os.path.join(outdir, os.path.basename(fname)) |
| dm.makedirs(outdir, exist_ok=True) |
| self.do_copydir(d, fname, outname, None, install_mode, dm) |
| else: |
| raise RuntimeError(f'Unknown file type for {fname!r}') |
| if file_copied: |
| self.did_install_something = True |
| try: |
| self.fix_rpath(outname, t.rpath_dirs_to_remove, install_rpath, final_path, |
| install_name_mappings, verbose=False) |
| except SystemExit as e: |
| if isinstance(e.code, int) and e.code == 0: |
| pass |
| else: |
| raise |
| # file mode needs to be set last, after strip/depfixer editing |
| self.set_mode(outname, install_mode, d.install_umask) |
| |
| def rebuild_all(wd: str, backend: str) -> bool: |
| if backend == 'none': |
| # nothing to build... |
| return True |
| if backend != 'ninja': |
| print('Only ninja backend is supported to rebuild the project before installation.') |
| return True |
| |
| ninja = environment.detect_ninja() |
| if not ninja: |
| print("Can't find ninja, can't rebuild test.") |
| return False |
| |
| def drop_privileges() -> T.Tuple[T.Optional[EnvironOrDict], T.Optional[T.Callable[[], None]]]: |
| if not is_windows() and os.geteuid() == 0: |
| import pwd |
| env = os.environ.copy() |
| |
| if os.environ.get('SUDO_USER') is not None: |
| orig_user = env.pop('SUDO_USER') |
| orig_uid = env.pop('SUDO_UID', 0) |
| orig_gid = env.pop('SUDO_GID', 0) |
| try: |
| homedir = pwd.getpwuid(int(orig_uid)).pw_dir |
| except KeyError: |
| # `sudo chroot` leaves behind stale variable and builds as root without a user |
| return None, None |
| elif os.environ.get('DOAS_USER') is not None: |
| orig_user = env.pop('DOAS_USER') |
| try: |
| pwdata = pwd.getpwnam(orig_user) |
| except KeyError: |
| # `doas chroot` leaves behind stale variable and builds as root without a user |
| return None, None |
| orig_uid = pwdata.pw_uid |
| orig_gid = pwdata.pw_gid |
| homedir = pwdata.pw_dir |
| else: |
| return None, None |
| |
| if os.stat(os.path.join(wd, 'build.ninja')).st_uid != int(orig_uid): |
| # the entire build process is running with sudo, we can't drop privileges |
| return None, None |
| |
| env['USER'] = orig_user |
| env['HOME'] = homedir |
| |
| def wrapped() -> None: |
| print(f'Dropping privileges to {orig_user!r} before running ninja...') |
| if orig_gid is not None: |
| os.setgid(int(orig_gid)) |
| if orig_uid is not None: |
| os.setuid(int(orig_uid)) |
| |
| return env, wrapped |
| else: |
| return None, None |
| |
| env, preexec_fn = drop_privileges() |
| ret = subprocess.run(ninja + ['-C', wd], env=env, preexec_fn=preexec_fn).returncode |
| if ret != 0: |
| print(f'Could not rebuild {wd}') |
| return False |
| |
| return True |
| |
| |
| def run(opts: 'ArgumentType') -> int: |
| datafilename = 'meson-private/install.dat' |
| private_dir = os.path.dirname(datafilename) |
| log_dir = os.path.join(private_dir, '../meson-logs') |
| if not os.path.exists(os.path.join(opts.wd, datafilename)): |
| sys.exit('Install data not found. Run this command in build directory root.') |
| if not opts.no_rebuild: |
| b = build.load(opts.wd) |
| need_vsenv = T.cast('bool', b.environment.coredata.get_option(OptionKey('vsenv'))) |
| setup_vsenv(need_vsenv) |
| backend = T.cast('str', b.environment.coredata.get_option(OptionKey('backend'))) |
| if not rebuild_all(opts.wd, backend): |
| sys.exit(-1) |
| os.chdir(opts.wd) |
| with open(os.path.join(log_dir, 'install-log.txt'), 'w', encoding='utf-8') as lf: |
| installer = Installer(opts, lf) |
| append_to_log(lf, '# List of files installed by Meson') |
| append_to_log(lf, '# Does not contain files installed by custom scripts.') |
| if opts.profile: |
| import cProfile as profile |
| fname = os.path.join(private_dir, 'profile-installer.log') |
| profile.runctx('installer.do_install(datafilename)', globals(), locals(), filename=fname) |
| else: |
| installer.do_install(datafilename) |
| return 0 |
