1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
|
# 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
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, 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}.')
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
|