775 lines
34 KiB
Python
775 lines
34 KiB
Python
# Copyright 2013-2014 The Meson development team
|
||
|
||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||
# you may not use this file except in compliance with the License.
|
||
# You may obtain a copy of the License at
|
||
|
||
# http://www.apache.org/licenses/LICENSE-2.0
|
||
|
||
# Unless required by applicable law or agreed to in writing, software
|
||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
# See the License for the specific language governing permissions and
|
||
# limitations under the License.
|
||
from __future__ import annotations
|
||
|
||
from glob import glob
|
||
from pathlib import Path
|
||
import argparse
|
||
import errno
|
||
import os
|
||
import shlex
|
||
import shutil
|
||
import subprocess
|
||
import sys
|
||
import typing as T
|
||
|
||
from . import build
|
||
from . import environment
|
||
from .backend.backends import InstallData
|
||
from .mesonlib import MesonException, Popen_safe, RealPathAction, is_windows, setup_vsenv, pickle_load, is_osx
|
||
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 (
|
||
ExecutableSerialisation, InstallDataBase, InstallEmptyDir,
|
||
InstallSymlinkData, TargetInstallData
|
||
)
|
||
from .mesonlib import FileMode
|
||
|
||
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 will copy the file,
|
||
but this will be changed in a future version of Meson to copy the symlink as is. Please update your
|
||
build definitions so that it will not break when the change happens.'''
|
||
|
||
selinux_updates: T.List[str] = []
|
||
|
||
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:
|
||
obj = pickle_load(fname, 'InstallData', InstallData)
|
||
assert isinstance(obj, InstallData), 'fo mypy'
|
||
return obj
|
||
|
||
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}: Non-existent owner {mode.owner!r} or group {mode.group!r}: ignoring...')
|
||
except OSError as e:
|
||
if e.errno == errno.EINVAL:
|
||
print(f'{path!r}: Non-existent 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, *args: T.Any, **kwargs: T.Any) -> int:
|
||
if not self.dry_run:
|
||
return run_exe(*args, **kwargs)
|
||
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) -> 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.remove(to_file)
|
||
elif makedirs:
|
||
# Unpack tuple
|
||
dirmaker, outdir = makedirs
|
||
# Create dirs if needed
|
||
dirmaker.makedirs(outdir, exist_ok=True)
|
||
self.log(f'Installing {from_file} to {outdir}')
|
||
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:
|
||
# Remove this entire branch when changing the behaviour to duplicate
|
||
# symlinks rather than copying what they point to.
|
||
print(symlink_warning)
|
||
self.copy2(from_file, to_file)
|
||
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) -> 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
|
||
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)
|
||
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 shutil.which('pkexec') is not None and 'PKEXEC_UID' not in os.environ and destdir == '':
|
||
print('Installation failed due to insufficient permissions.')
|
||
print('Attempting to use polkit to gain elevated privileges...')
|
||
os.execlp('pkexec', 'pkexec', sys.executable, main_file, *sys.argv[1:],
|
||
'-C', os.getcwd())
|
||
else:
|
||
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)
|
||
|
||
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)):
|
||
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)):
|
||
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,
|
||
'MESON_INSTALL_PREFIX': d.prefix,
|
||
'MESON_INSTALL_DESTDIR_PREFIX': fullprefix,
|
||
'MESONINTROSPECT': ' '.join([shlex.quote(x) for x in d.mesonintrospect]),
|
||
}
|
||
if self.options.quiet:
|
||
env['MESON_INSTALL_QUIET'] = '1'
|
||
|
||
for i in d.install_scripts:
|
||
if not self.should_install(i):
|
||
continue
|
||
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, env)
|
||
except OSError:
|
||
print(f'FAILED: install script \'{name}\' could not be run, stopped')
|
||
# POSIX shells return 127 when a command could not be found
|
||
sys.exit(127)
|
||
if rc != 0:
|
||
print(f'FAILED: install script \'{name}\' exit code {rc}, stopped')
|
||
sys.exit(rc)
|
||
|
||
def install_targets(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None:
|
||
for t in d.targets:
|
||
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) -> bool:
|
||
if not (Path(wd) / 'build.ninja').is_file():
|
||
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
|
||
|
||
ret = subprocess.run(ninja + ['-C', wd]).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)
|
||
setup_vsenv(b.need_vsenv)
|
||
if not rebuild_all(opts.wd):
|
||
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
|