cdist

   1 #!/usr/bin/python3
   2
   3 #    Copyright (C) 2012-2022 Carl Hetherington <cth@carlh.net>
   4 #
   5 #    This program is free software; you can redistribute it and/or modify
   6 #    it under the terms of the GNU General Public License as published by
   7 #    the Free Software Foundation; either version 2 of the License, or
   8 #    (at your option) any later version.
   9 #
  10 #    This program is distributed in the hope that it will be useful,
  11 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 #    GNU General Public License for more details.
  14
  15 #    You should have received a copy of the GNU General Public License
  16 #    along with this program; if not, write to the Free Software
  17 #    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 from __future__ import print_function
  20
  21 import argparse
  22 import copy
  23 import datetime
  24 import getpass
  25 import glob
  26 import inspect
  27 import multiprocessing
  28 import os
  29 from pathlib import Path
  30 import platform
  31 import re
  32 import signal
  33 import shlex
  34 import shutil
  35 import subprocess
  36 import sys
  37 import tempfile
  38 import time
  39
  40 class Error(Exception):
  41     def __init__(self, value):
  42         self.value = value
  43     def __str__(self):
  44         return self.value
  45     def __repr__(self):
  46         return str(self)
  47
  48 class Trees:
  49     """
  50     Store for Tree objects which re-uses already-created objects
  51     and checks for requests for different versions of the same thing.
  52     """
  53
  54     def __init__(self):
  55         self.trees = []
  56
  57     def get(self, name, commit_ish, target, required_by=None):
  58         for t in self.trees:
  59             if t.name == name and t.commit_ish == commit_ish and t.target == target:
  60                 return t
  61             elif t.name == name and t.commit_ish != commit_ish:
  62                 a = commit_ish if commit_ish is not None else "[Any]"
  63                 if required_by is not None:
  64                     a += ' by %s' % required_by
  65                 b = t.commit_ish if t.commit_ish is not None else "[Any]"
  66                 if t.required_by is not None:
  67                     b += ' by %s' % t.required_by
  68                 raise Error('conflicting versions of %s required (%s versus %s)' % (name, a, b))
  69
  70         nt = Tree(name, commit_ish, target, required_by)
  71         self.trees.append(nt)
  72         return nt
  73
  74     def add_built(self, name, commit_ish, target):
  75         self.trees.append(Tree(name, commit_ish, target, None, built=True))
  76
  77
  78 class Globals:
  79     quiet = False
  80     command = None
  81     dry_run = False
  82     use_git_reference = True
  83     trees = Trees()
  84
  85 globals = Globals()
  86
  87
  88 #
  89 # Configuration
  90 #
  91
  92 class Option:
  93     def __init__(self, key, default=None):
  94         self.key = key
  95         self.value = default
  96
  97     def offer(self, key, value):
  98         if key == self.key:
  99             self.value = value
 100
 101 class BoolOption:
 102     def __init__(self, key):
 103         self.key = key
 104         self.value = False
 105
 106     def offer(self, key, value):
 107         if key == self.key:
 108             self.value = value in ['yes', '1', 'true']
 109
 110 class Config:
 111     def __init__(self):
 112         self.options = [ Option('mxe_prefix'),
 113                          Option('git_prefix'),
 114                          Option('git_reference'),
 115                          Option('osx_environment_prefix'),
 116                          Option('osx_sdk_prefix'),
 117                          Option('osx_sdk'),
 118                          Option('osx_intel_deployment'),
 119                          Option('osx_arm_deployment'),
 120                          Option('osx_old_deployment'),
 121                          Option('osx_keychain_file'),
 122                          Option('osx_keychain_password'),
 123                          Option('apple_id'),
 124                          Option('apple_password'),
 125                          Option('apple_team_id'),
 126                          BoolOption('docker_sudo'),
 127                          BoolOption('docker_no_user'),
 128                          Option('docker_hub_repository'),
 129                          Option('flatpak_state_dir'),
 130                          Option('parallel', multiprocessing.cpu_count()),
 131                          Option('temp', '/var/tmp'),
 132                          Option('osx_notarytool', ['xcrun', 'notarytool'])]
 133
 134         config_dir = '%s/.config' % os.path.expanduser('~')
 135         if not os.path.exists(config_dir):
 136             os.mkdir(config_dir)
 137         config_file = '%s/cdist' % config_dir
 138         if not os.path.exists(config_file):
 139             f = open(config_file, 'w')
 140             for o in self.options:
 141                 print('# %s ' % o.key, file=f)
 142             f.close()
 143             print('Template config file written to %s; please edit and try again.' % config_file, file=sys.stderr)
 144             sys.exit(1)
 145
 146         f = open('%s/.config/cdist' % os.path.expanduser('~'), 'r')
 147         while True:
 148             l = f.readline()
 149             if l == '':
 150                 break
 151
 152             if len(l) > 0 and l[0] == '#':
 153                 continue
 154
 155             s = l.strip().split()
 156             if len(s) == 2:
 157                 for k in self.options:
 158                     k.offer(s[0], s[1])
 159
 160         if not isinstance(self.get('osx_notarytool'), list):
 161             self.set('osx_notarytool', [self.get('osx_notarytool')])
 162
 163
 164     def has(self, k):
 165         for o in self.options:
 166             if o.key == k and o.value is not None:
 167                 return True
 168         return False
 169
 170     def get(self, k):
 171         for o in self.options:
 172             if o.key == k:
 173                 if o.value is None:
 174                     raise Error('Required setting %s not found' % k)
 175                 return o.value
 176
 177     def set(self, k, v):
 178         for o in self.options:
 179             o.offer(k, v)
 180
 181     def docker(self):
 182         if self.get('docker_sudo'):
 183             return 'sudo docker'
 184         else:
 185             return 'docker'
 186
 187 config = Config()
 188
 189 #
 190 # Utility bits
 191 #
 192
 193 def log_normal(m):
 194     if not globals.quiet:
 195         print('\x1b[33m* %s\x1b[0m' % m)
 196
 197 def log_verbose(m):
 198     if globals.verbose:
 199         print('\x1b[35m* %s\x1b[0m' % m)
 200
 201 def escape_spaces(s):
 202     return s.replace(' ', '\\ ')
 203
 204 def scp_escape(n):
 205     """Escape a host:filename string for use with an scp command"""
 206     s = n.split(':')
 207     assert(len(s) == 1 or len(s) == 2)
 208     if len(s) == 2:
 209         return '%s:"\'%s\'"' % (s[0], s[1])
 210     else:
 211         return '\"%s\"' % s[0]
 212
 213 def mv_escape(n):
 214     return '\"%s\"' % n.substr(' ', '\\ ')
 215
 216 def copytree(a, b):
 217     log_normal('copy %s -> %s' % (scp_escape(a), scp_escape(b)))
 218     if b.startswith('s3://'):
 219         command('s3cmd -P -r put "%s" "%s"' % (a, b))
 220     else:
 221         command('scp -r %s %s' % (scp_escape(a), scp_escape(b)))
 222
 223 def copyfile(a, b):
 224     log_normal('copy %s -> %s with cwd %s' % (scp_escape(a), scp_escape(b), os.getcwd()))
 225     if b.startswith('s3://'):
 226         command('s3cmd -P put "%s" "%s"' % (a, b))
 227     else:
 228         bc = b.find(":")
 229         if bc != -1:
 230             host = b[:bc]
 231             path = b[bc+1:]
 232             temp_path = os.path.join(os.path.dirname(path), ".tmp." + os.path.basename(path))
 233             command('scp %s %s' % (scp_escape(a), scp_escape(host + ":" + temp_path)))
 234             command('ssh %s -- mv "%s" "%s"' % (host, escape_spaces(temp_path), escape_spaces(path)))
 235         else:
 236             command('scp %s %s' % (scp_escape(a), scp_escape(b)))
 237
 238 def makedirs(d):
 239     """
 240     Make directories either locally or on a remote host; remotely if
 241     d includes a colon, otherwise locally.
 242     """
 243     if d.startswith('s3://'):
 244         # No need to create folders on S3
 245         return
 246
 247     if d.find(':') == -1:
 248         try:
 249             os.makedirs(d)
 250         except OSError as e:
 251             if e.errno != 17:
 252                 raise e
 253     else:
 254         s = d.split(':')
 255         command('ssh %s -- mkdir -p %s' % (s[0], s[1]))
 256
 257 def rmdir(a):
 258     log_normal('remove %s' % a)
 259     os.rmdir(a)
 260
 261 def rmtree(a):
 262     log_normal('remove %s' % a)
 263     shutil.rmtree(a, ignore_errors=True)
 264
 265 def command(c):
 266     log_normal(c)
 267     try:
 268         r = subprocess.run(c, shell=True)
 269         if r.returncode != 0:
 270             raise Error('command %s failed (%d)' % (c, r.returncode))
 271     except Exception as e:
 272         raise Error('command %s failed (%s)' % (c, e))
 273
 274 def command_and_read(c):
 275     log_normal(c)
 276     p = subprocess.Popen(c.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 277     (out, err) = p.communicate()
 278     if p.returncode != 0:
 279         raise Error('command %s failed (%s)' % (c, err))
 280     return str(out, 'utf-8').splitlines()
 281
 282 def read_wscript_variable(directory, variable):
 283     f = open('%s/wscript' % directory, 'r')
 284     while True:
 285         l = f.readline()
 286         if l == '':
 287             break
 288
 289         s = l.split()
 290         if len(s) == 3 and s[0] == variable:
 291             f.close()
 292             return s[2][1:-1]
 293
 294     f.close()
 295     return None
 296
 297
 298 def devel_to_git(git_commit, filename):
 299     if git_commit is not None:
 300         filename = filename.replace('devel', '-%s' % git_commit)
 301     return filename
 302
 303
 304 def get_command_line_options(args):
 305     """Get the options specified by --option on the command line"""
 306     options = dict()
 307     if args.option is not None:
 308         for o in args.option:
 309             b = o.split(':')
 310             if len(b) != 2:
 311                 raise Error("Bad option `%s'" % o)
 312             if b[1] == 'False':
 313                 options[b[0]] = False
 314             elif b[1] == 'True':
 315                 options[b[0]] = True
 316             else:
 317                 options[b[0]] = b[1]
 318     return options
 319
 320
 321 class TreeDirectory:
 322     def __init__(self, tree):
 323         self.tree = tree
 324     def __enter__(self):
 325         self.cwd = os.getcwd()
 326         os.chdir('%s/src/%s' % (self.tree.target.directory, self.tree.name))
 327     def __exit__(self, type, value, traceback):
 328         os.chdir(self.cwd)
 329
 330 #
 331 # Version
 332 #
 333
 334 class Version:
 335     def __init__(self, s):
 336         self.devel = False
 337
 338         if s.startswith("'"):
 339             s = s[1:]
 340         if s.endswith("'"):
 341             s = s[0:-1]
 342
 343         if s.endswith('devel'):
 344             s = s[0:-5]
 345             self.devel = True
 346
 347         if s.endswith('pre'):
 348             s = s[0:-3]
 349
 350         p = s.split('.')
 351         self.major = int(p[0])
 352         self.minor = int(p[1])
 353         if len(p) == 3:
 354             self.micro = int(p[2])
 355         else:
 356             self.micro = 0
 357
 358     @classmethod
 359     def from_git_tag(cls, tag):
 360         bits = tag.split('-')
 361         c = cls(bits[0])
 362         if len(bits) > 1 and int(bits[1]) > 0:
 363             c.devel = True
 364         return c
 365
 366     def bump_minor(self):
 367         self.minor += 1
 368         self.micro = 0
 369
 370     def bump_micro(self):
 371         self.micro += 1
 372
 373     def to_devel(self):
 374         self.devel = True
 375
 376     def to_release(self):
 377         self.devel = False
 378
 379     def __str__(self):
 380         s = '%d.%d.%d' % (self.major, self.minor, self.micro)
 381         if self.devel:
 382             s += 'devel'
 383
 384         return s
 385
 386 #
 387 # Targets
 388 #
 389
 390 class Target:
 391     """
 392     Class representing the target that we are building for.  This is exposed to cscripts,
 393     though not all of it is guaranteed 'API'.  cscripts may expect:
 394
 395     platform: platform string (e.g. 'windows', 'linux', 'osx')
 396     parallel: number of parallel jobs to run
 397     directory: directory to work in
 398     variables: dict of environment variables
 399     debug: True to build a debug version, otherwise False
 400     ccache: True to use ccache, False to not
 401     set(a, b): set the value of variable 'a' to 'b'
 402     unset(a): unset the value of variable 'a'
 403     command(c): run the command 'c' in the build environment
 404
 405     """
 406
 407     def __init__(self, platform, directory=None, dependencies_only=False):
 408         """
 409         platform -- platform string (e.g. 'windows', 'linux', 'osx')
 410         directory -- directory to work in; if None we will use a temporary directory
 411         Temporary directories will be removed after use; specified directories will not.
 412         """
 413         self.platform = platform
 414         self.parallel = int(config.get('parallel'))
 415
 416         # Environment variables that we will use when we call cscripts
 417         self.variables = {}
 418         self.debug = False
 419         self._ccache = False
 420         # True to build our dependencies ourselves; False if this is taken care
 421         # of in some other way
 422         self.build_dependencies = True
 423         self.dependencies_only = dependencies_only
 424
 425         if directory is None:
 426             try:
 427                 os.makedirs(config.get('temp'))
 428             except OSError as e:
 429                 if e.errno != 17:
 430                     raise e
 431             self.directory = tempfile.mkdtemp('', 'tmp', config.get('temp'))
 432             self.rmdir = True
 433             self.set('CCACHE_BASEDIR', os.path.realpath(self.directory))
 434             self.set('CCACHE_NOHASHDIR', '')
 435         else:
 436             self.directory = os.path.realpath(directory)
 437             self.rmdir = False
 438
 439
 440     def setup(self):
 441         pass
 442
 443     def _cscript_package(self, tree, options):
 444         """
 445         Call package() in the cscript and return what it returns, except that
 446         anything not in a list will be put into one.
 447         """
 448         if len(inspect.getfullargspec(tree.cscript['package']).args) == 3:
 449             packages = tree.call('package', tree.version, options)
 450         else:
 451             log_normal("Deprecated cscript package() method with no options parameter")
 452             packages = tree.call('package', tree.version)
 453
 454         return packages if isinstance(packages, list) else [packages]
 455
 456     def _copy_packages(self, tree, packages, output_dir):
 457         for p in packages:
 458             copyfile(p, os.path.join(output_dir, os.path.basename(devel_to_git(tree.commit, p))))
 459
 460     def package(self, project, checkout, output_dir, options, notarize):
 461         tree = self.build(project, checkout, options, for_package=True)
 462         tree.add_defaults(options)
 463         p = self._cscript_package(tree, options)
 464         self._copy_packages(tree, p, output_dir)
 465
 466     def build(self, project, checkout, options, for_package=False):
 467         tree = globals.trees.get(project, checkout, self)
 468         if self.build_dependencies:
 469             tree.build_dependencies(options)
 470         if not self.dependencies_only:
 471             tree.build(options, for_package=for_package)
 472         return tree
 473
 474     def test(self, project, checkout, target, test, options):
 475         """test is the test case to run, or None"""
 476         tree = globals.trees.get(project, checkout, target)
 477
 478         tree.add_defaults(options)
 479         with TreeDirectory(tree):
 480             if len(inspect.getfullargspec(tree.cscript['test']).args) == 3:
 481                 return tree.call('test', options, test)
 482             else:
 483                 log_normal('Deprecated cscript test() method with no options parameter')
 484                 return tree.call('test', test)
 485
 486     def set(self, a, b):
 487         self.variables[a] = b
 488
 489     def unset(self, a):
 490         del(self.variables[a])
 491
 492     def get(self, a):
 493         return self.variables[a]
 494
 495     def append(self, k, v, s):
 496         if (not k in self.variables) or len(self.variables[k]) == 0:
 497             self.variables[k] = '"%s"' % v
 498         else:
 499             e = self.variables[k]
 500             if e[0] == '"' and e[-1] == '"':
 501                 self.variables[k] = '"%s%s%s"' % (e[1:-1], s, v)
 502             else:
 503                 self.variables[k] = '"%s%s%s"' % (e, s, v)
 504
 505     def append_with_space(self, k, v):
 506         return self.append(k, v, ' ')
 507
 508     def append_with_colon(self, k, v):
 509         return self.append(k, v, ':')
 510
 511     def variables_string(self, escaped_quotes=False):
 512         e = ''
 513         for k, v in self.variables.items():
 514             if escaped_quotes:
 515                 v = v.replace('"', '\\"')
 516             e += '%s=%s ' % (k, v)
 517         return e
 518
 519     def cleanup(self):
 520         if self.rmdir:
 521             rmtree(self.directory)
 522
 523     def mount(self, m):
 524         pass
 525
 526     @property
 527     def ccache(self):
 528         return self._ccache
 529
 530     @ccache.setter
 531     def ccache(self, v):
 532         self._ccache = v
 533
 534
 535 class DockerTarget(Target):
 536     def __init__(self, platform, directory):
 537         super(DockerTarget, self).__init__(platform, directory)
 538         self.mounts = []
 539         self.privileged = False
 540
 541     def _user_tag(self):
 542         if config.get('docker_no_user'):
 543             return ''
 544         return '-u %s' % getpass.getuser()
 545
 546     def _mount_option(self, d):
 547         return '-v %s:%s ' % (os.path.realpath(d), os.path.realpath(d))
 548
 549     def setup(self):
 550         opts = self._mount_option(self.directory)
 551         for m in self.mounts:
 552             opts += self._mount_option(m)
 553         if config.has('git_reference'):
 554             opts += self._mount_option(config.get('git_reference'))
 555         if self.privileged:
 556             opts += '--privileged=true '
 557         if self.ccache:
 558             opts += "-e CCACHE_DIR=/ccache/%s-%d --mount source=ccache,target=/ccache " % (self.image, os.getuid())
 559         opts += "--rm "
 560
 561         tag = self.image
 562         if config.has('docker_hub_repository'):
 563             tag = '%s:%s' % (config.get('docker_hub_repository'), tag)
 564
 565         def signal_handler(signum, frame):
 566             raise Error('Killed')
 567         signal.signal(signal.SIGTERM, signal_handler)
 568
 569         self.container = command_and_read('%s run %s %s -itd %s /bin/bash' % (config.docker(), self._user_tag(), opts, tag))[0].strip()
 570
 571     def command(self, cmd):
 572         dir = os.path.join(self.directory, os.path.relpath(os.getcwd(), self.directory))
 573         interactive_flag = '-i ' if sys.stdin.isatty() else ''
 574         command('%s exec %s %s -t %s /bin/bash -c \'export %s; cd %s; %s\'' % (config.docker(), self._user_tag(), interactive_flag, self.container, self.variables_string(), dir, cmd))
 575
 576     def cleanup(self):
 577         super(DockerTarget, self).cleanup()
 578         command('%s kill %s' % (config.docker(), self.container))
 579
 580     def mount(self, m):
 581         self.mounts.append(m)
 582
 583
 584 class WindowsDockerTarget(DockerTarget):
 585     """
 586     This target exposes the following additional API:
 587
 588     bits: bitness of Windows (32 or 64)
 589     name: name of our target e.g. x86_64-w64-mingw32.shared
 590     environment_prefix: path to Windows environment for the appropriate target (libraries and some tools)
 591     tool_path: path to 32- and 64-bit tools
 592     """
 593     def __init__(self, bits, directory, environment_version):
 594         super(WindowsDockerTarget, self).__init__('windows', directory)
 595         self.bits = bits
 596
 597         self.tool_path = '%s/usr/bin' % config.get('mxe_prefix')
 598         if self.bits == 32:
 599             self.name = 'i686-w64-mingw32.shared'
 600         else:
 601             self.name = 'x86_64-w64-mingw32.shared'
 602         self.environment_prefix = '%s/usr/%s' % (config.get('mxe_prefix'), self.name)
 603
 604         self.set('PKG_CONFIG_LIBDIR', '%s/lib/pkgconfig' % self.environment_prefix)
 605         self.set('PKG_CONFIG_PATH', '%s/lib/pkgconfig:%s/bin/pkgconfig' % (self.directory, self.directory))
 606         self.set('PATH', '%s/bin:%s:%s' % (self.environment_prefix, self.tool_path, os.environ['PATH']))
 607         self.set('LD', '%s-ld' % self.name)
 608         self.set('RANLIB', '%s-ranlib' % self.name)
 609         self.set('WINRC', '%s-windres' % self.name)
 610         cxx = '-I%s/include -I%s/include' % (self.environment_prefix, self.directory)
 611         link = '-L%s/lib -L%s/lib' % (self.environment_prefix, self.directory)
 612         self.set('CXXFLAGS', '"%s"' % cxx)
 613         self.set('CPPFLAGS', '')
 614         self.set('LINKFLAGS', '"%s"' % link)
 615         self.set('LDFLAGS', '"%s"' % link)
 616
 617         self.image = 'windows'
 618         if environment_version is not None:
 619             self.image += '_%s' % environment_version
 620
 621     def setup(self):
 622         super().setup()
 623         if self.ccache:
 624             self.set('CC', '"ccache %s-gcc"' % self.name)
 625             self.set('CXX', '"ccache %s-g++"' % self.name)
 626         else:
 627             self.set('CC', '%s-gcc' % self.name)
 628             self.set('CXX', '%s-g++' % self.name)
 629
 630     @property
 631     def library_prefix(self):
 632         log_normal('Deprecated property library_prefix: use environment_prefix')
 633         return self.environment_prefix
 634
 635     @property
 636     def windows_prefix(self):
 637         log_normal('Deprecated property windows_prefix: use environment_prefix')
 638         return self.environment_prefix
 639
 640     @property
 641     def mingw_prefixes(self):
 642         log_normal('Deprecated property mingw_prefixes: use environment_prefix')
 643         return [self.environment_prefix]
 644
 645     @property
 646     def mingw_path(self):
 647         log_normal('Deprecated property mingw_path: use tool_path')
 648         return self.tool_path
 649
 650     @property
 651     def mingw_name(self):
 652         log_normal('Deprecated property mingw_name: use name')
 653         return self.name
 654
 655
 656 class WindowsNativeTarget(Target):
 657     """
 658     This target exposes the following additional API:
 659
 660     bits: bitness of Windows (32 or 64)
 661     name: name of our target e.g. x86_64-w64-mingw32.shared
 662     environment_prefix: path to Windows environment for the appropriate target (libraries and some tools)
 663     """
 664     def __init__(self, directory):
 665         super().__init__('windows', directory)
 666         self.bits = 64
 667
 668         self.environment_prefix = config.get('windows_native_environmnet_prefix')
 669
 670         self.set('PATH', '%s/bin:%s' % (self.environment_prefix, os.environ['PATH']))
 671
 672     def command(self, cmd):
 673         command(cmd)
 674
 675
 676 class LinuxTarget(DockerTarget):
 677     """
 678     Build for Linux in a docker container.
 679     This target exposes the following additional API:
 680
 681     distro: distribution ('debian', 'ubuntu', 'centos' or 'fedora')
 682     version: distribution version (e.g. '12.04', '8', '6.5')
 683     bits: bitness of the distribution (32 or 64)
 684     detail: None or 'appimage' if we are building for appimage
 685     """
 686
 687     def __init__(self, distro, version, bits, directory=None):
 688         super(LinuxTarget, self).__init__('linux', directory)
 689         self.distro = distro
 690         self.version = version
 691         self.bits = bits
 692         self.detail = None
 693
 694         self.set('CXXFLAGS', '-I%s/include' % self.directory)
 695         self.set('CPPFLAGS', '')
 696         self.set('LINKFLAGS', '-L%s/lib' % self.directory)
 697         self.set('PKG_CONFIG_PATH',
 698                  '%s/lib/pkgconfig:%s/lib64/pkgconfig:/usr/local/lib64/pkgconfig:/usr/local/lib/pkgconfig' % (self.directory, self.directory))
 699         self.set('PATH', '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin')
 700
 701         if self.version is None:
 702             self.image = '%s-%s' % (self.distro, self.bits)
 703         else:
 704             self.image = '%s-%s-%s' % (self.distro, self.version, self.bits)
 705
 706     def setup(self):
 707         super(LinuxTarget, self).setup()
 708         if self.ccache:
 709             self.set('CC', '"ccache gcc"')
 710             self.set('CXX', '"ccache g++"')
 711
 712     def test(self, project, checkout, target, test, options):
 713         self.append_with_colon('PATH', '%s/bin' % self.directory)
 714         self.append_with_colon('LD_LIBRARY_PATH', '%s/lib' % self.directory)
 715         super(LinuxTarget, self).test(project, checkout, target, test, options)
 716
 717
 718 class AppImageTarget(LinuxTarget):
 719     def __init__(self, work):
 720         super(AppImageTarget, self).__init__('ubuntu', '18.04', 64, work)
 721         self.detail = 'appimage'
 722         self.privileged = True
 723
 724
 725 class FlatpakTarget(Target):
 726     def __init__(self, project, checkout, work):
 727         super(FlatpakTarget, self).__init__('flatpak')
 728         self.build_dependencies = False
 729         self.project = project
 730         self.checkout = checkout
 731         # If we use git references we end up with a checkout in one mount trying
 732         # to link to the git reference repo in other, which doesn't work.
 733         globals.use_git_reference = False
 734         if config.has('flatpak_state_dir'):
 735             self.mount(config.get('flatpak_state_dir'))
 736
 737     def command(self, c):
 738         log_normal('host -> %s' % c)
 739         command('%s %s' % (self.variables_string(), c))
 740
 741     def setup(self):
 742         super().setup()
 743         globals.trees.get(self.project, self.checkout, self).checkout_dependencies()
 744
 745     def flatpak(self):
 746         return 'flatpak'
 747
 748     def flatpak_builder(self):
 749         b = 'flatpak-builder'
 750         if config.has('flatpak_state_dir'):
 751             b += ' --state-dir=%s' % config.get('flatpak_state_dir')
 752         return b
 753
 754
 755 def notarize_dmg(dmg):
 756     p = subprocess.run(
 757             config.get('osx_notarytool') + [
 758             'submit',
 759             '--apple-id',
 760             config.get('apple_id'),
 761             '--password',
 762             config.get('apple_password'),
 763             '--team-id',
 764             config.get('apple_team_id'),
 765             '--wait',
 766             dmg
 767         ], capture_output=True)
 768
 769     last_line = [x.strip() for x in p.stdout.decode('utf-8').splitlines() if x.strip()][-1]
 770     if last_line != 'status: Accepted':
 771         print("Could not understand notarytool response")
 772         print(p)
 773         print(f"Last line: {last_line}")
 774         raise Error('Notarization failed')
 775
 776     subprocess.run(['xcrun', 'stapler', 'staple', dmg])
 777
 778
 779 class OSXTarget(Target):
 780     def __init__(self, directory=None):
 781         super(OSXTarget, self).__init__('osx', directory)
 782         self.sdk_prefix = config.get('osx_sdk_prefix')
 783         self.environment_prefix = config.get('osx_environment_prefix')
 784         self.apple_id = config.get('apple_id')
 785         self.apple_password = config.get('apple_password')
 786         self.osx_keychain_file = config.get('osx_keychain_file')
 787         self.osx_keychain_password = config.get('osx_keychain_password')
 788
 789     def command(self, c):
 790         command('%s %s' % (self.variables_string(False), c))
 791
 792     def unlock_keychain(self):
 793         self.command('security unlock-keychain -p %s %s' % (self.osx_keychain_password, self.osx_keychain_file))
 794
 795     def package(self, project, checkout, output_dir, options, notarize):
 796         self.unlock_keychain()
 797         tree = globals.trees.get(project, checkout, self)
 798         with TreeDirectory(tree):
 799             p = self._cscript_package_and_notarize(tree, options, self.can_notarize and notarize)
 800             self._copy_packages(tree, p, output_dir)
 801
 802     def _copy_packages(self, tree, packages, output_dir):
 803         for p in packages:
 804             dest = os.path.join(output_dir, os.path.basename(devel_to_git(tree.commit, p)))
 805             copyfile(p, dest)
 806
 807     def _cscript_package_and_notarize(self, tree, options, notarize):
 808         """
 809         Call package() in the cscript and notarize the .dmgs that are returned, if notarize == True
 810         """
 811         output = []
 812         for x in self._cscript_package(tree, options):
 813             # Some older cscripts give us the DMG filename and the bundle ID, even though
 814             # (since using notarytool instead of altool for notarization) the bundle ID
 815             # is no longer necessary.  Cope with either type of cscript.
 816             dmg = x[0] if isinstance(x, tuple) else x
 817             if notarize:
 818                 notarize_dmg(dmg)
 819             output.append(dmg)
 820         return output
 821
 822
 823 class OSXSingleTarget(OSXTarget):
 824     def __init__(self, arch, sdk, deployment, directory=None, can_notarize=True):
 825         super(OSXSingleTarget, self).__init__(directory)
 826         self.arch = arch
 827         self.sdk = sdk
 828         self.deployment = deployment
 829         self.can_notarize = can_notarize
 830         self.sub_targets = [self]
 831
 832         flags = '-isysroot %s/MacOSX%s.sdk -arch %s' % (self.sdk_prefix, sdk, arch)
 833         if arch == 'x86_64':
 834             host_enviro = '%s/x86_64/%s' % (config.get('osx_environment_prefix'), deployment)
 835         else:
 836             host_enviro = '%s/x86_64/10.10' % config.get('osx_environment_prefix')
 837         target_enviro = '%s/%s/%s' % (config.get('osx_environment_prefix'), arch, deployment)
 838
 839         self.bin = '%s/bin' % target_enviro
 840
 841         # Environment variables
 842         self.set('CFLAGS', '"-I%s/include -I%s/include %s"' % (self.directory, target_enviro, flags))
 843         self.set('CPPFLAGS', '')
 844         self.set('CXXFLAGS', '"-I%s/include -I%s/include -stdlib=libc++ %s"' % (self.directory, target_enviro, flags))
 845         self.set('LDFLAGS', '"-L%s/lib -L%s/lib -stdlib=libc++ %s"' % (self.directory, target_enviro, flags))
 846         self.set('LINKFLAGS', '"-L%s/lib -L%s/lib %s"' % (self.directory, target_enviro, flags))
 847         self.set('PKG_CONFIG_PATH', '%s/lib/pkgconfig:%s/lib/pkgconfig:/usr/lib/pkgconfig' % (self.directory, target_enviro))
 848         self.set('PATH', '$PATH:/usr/bin:/sbin:/usr/local/bin:%s/bin' % host_enviro)
 849         self.set('MACOSX_DEPLOYMENT_TARGET', self.deployment)
 850         self.set('CCACHE_BASEDIR', self.directory)
 851
 852     @Target.ccache.setter
 853     def ccache(self, v):
 854         Target.ccache.fset(self, v)
 855         if v:
 856             self.set('CC', '"ccache gcc"')
 857             self.set('CXX', '"ccache g++"')
 858
 859     def package(self, project, checkout, output_dir, options, notarize):
 860         tree = self.build(project, checkout, options, for_package=True)
 861         tree.add_defaults(options)
 862
 863         super().package(project, checkout, output_dir, options, notarize)
 864
 865
 866 class OSXUniversalTarget(OSXTarget):
 867     def __init__(self, directory=None):
 868         super(OSXUniversalTarget, self).__init__(directory)
 869         self.sdk = config.get('osx_sdk')
 870         self.sub_targets = []
 871         for arch, deployment in (('x86_64', config.get('osx_intel_deployment')), ('arm64', config.get('osx_arm_deployment'))):
 872             target = OSXSingleTarget(arch, self.sdk, deployment, os.path.join(self.directory, arch, deployment))
 873             target.ccache = self.ccache
 874             self.sub_targets.append(target)
 875         self.can_notarize = True
 876
 877     def package(self, project, checkout, output_dir, options, notarize):
 878         for target in self.sub_targets:
 879             tree = globals.trees.get(project, checkout, target)
 880             tree.build_dependencies(options)
 881             tree.build(options, for_package=True)
 882
 883         super().package(project, checkout, output_dir, options, notarize)
 884
 885     @Target.ccache.setter
 886     def ccache(self, v):
 887         for target in self.sub_targets:
 888             target.ccache = v
 889
 890
 891 class SourceTarget(Target):
 892     """Build a source .tar.bz2 and .zst"""
 893     def __init__(self):
 894         super(SourceTarget, self).__init__('source')
 895
 896     def command(self, c):
 897         log_normal('host -> %s' % c)
 898         command('%s %s' % (self.variables_string(), c))
 899
 900     def cleanup(self):
 901         rmtree(self.directory)
 902
 903     def package(self, project, checkout, output_dir, options, notarize):
 904         tree = globals.trees.get(project, checkout, self)
 905         with TreeDirectory(tree):
 906             name = read_wscript_variable(os.getcwd(), 'APPNAME')
 907             command('./waf dist')
 908             bz2 = os.path.abspath('%s-%s.tar.bz2' % (name, tree.version))
 909             copyfile(bz2, os.path.join(output_dir, os.path.basename(devel_to_git(tree.commit, bz2))))
 910             command('tar xjf %s' % bz2)
 911             command('tar --zstd -cf %s-%s.tar.zst %s-%s' % (name, tree.version, name, tree.version))
 912             zstd = os.path.abspath('%s-%s.tar.zst' % (name, tree.version))
 913             copyfile(zstd, os.path.join(output_dir, os.path.basename(devel_to_git(tree.commit, zstd))))
 914
 915
 916 class LocalTarget(Target):
 917     """Build on the local machine with its environment"""
 918     def __init__(self, work):
 919         super(LocalTarget, self).__init__('local', work)
 920         # Hack around ffmpeg.git which sees that the target isn't windows/osx and then assumes
 921         # distro will be there.
 922         self.distro = None
 923         self.set('PKG_CONFIG_PATH', '%s/lib/pkgconfig:%s/bin/pkgconfig' % (self.directory, self.directory))
 924
 925     def command(self, c):
 926         log_normal('host -> %s' % c)
 927         command('%s %s' % (self.variables_string(), c))
 928
 929     def cleanup(self):
 930         rmtree(self.directory)
 931
 932 # @param s Target string:
 933 #       windows-{32,64}
 934 #    or ubuntu-version-{32,64}
 935 #    or debian-version-{32,64}
 936 #    or centos-version-{32,64}
 937 #    or fedora-version-{32,64}
 938 #    or mageia-version-{32,64}
 939 #    or osx
 940 #    or source
 941 #    or flatpak
 942 #    or appimage
 943 def target_factory(args):
 944     s = args.target
 945     target = None
 946     if s.startswith('windows-'):
 947         x = s.split('-')
 948         if platform.system() == "Windows":
 949             target = WindowsNativeTarget(args.work)
 950         elif len(x) == 2:
 951             target = WindowsDockerTarget(int(x[1]), args.work, args.environment_version)
 952         else:
 953             raise Error("Bad Windows target name `%s'")
 954     elif s.startswith('ubuntu-') or s.startswith('debian-') or s.startswith('centos-') or s.startswith('fedora-') or s.startswith('mageia-'):
 955         p = s.split('-')
 956         if len(p) != 3:
 957             raise Error("Bad Linux target name `%s'; must be something like ubuntu-16.04-32 (i.e. distro-version-bits)" % s)
 958         target = LinuxTarget(p[0], p[1], int(p[2]), args.work)
 959     elif s.startswith('arch-'):
 960         p = s.split('-')
 961         if len(p) != 2:
 962             raise Error("Bad Arch target name `%s'; must be arch-32 or arch-64")
 963         target = LinuxTarget(p[0], None, int(p[1]), args.work)
 964     elif s == 'raspbian':
 965         target = LinuxTarget(s, None, None, args.work)
 966     elif s == 'osx':
 967         target = OSXUniversalTarget(args.work)
 968     elif s == 'osx-intel':
 969         target = OSXSingleTarget('x86_64', config.get('osx_sdk'), config.get('osx_intel_deployment'), args.work)
 970     elif s == 'osx-old':
 971         target = OSXSingleTarget('x86_64', config.get('osx_sdk'), config.get('osx_old_deployment'), args.work, False)
 972     elif s == 'source':
 973         target = SourceTarget()
 974     elif s == 'flatpak':
 975         target = FlatpakTarget(args.project, args.checkout, args.work)
 976     elif s == 'appimage':
 977         target = AppImageTarget(args.work)
 978     elif s == 'local':
 979         target = LocalTarget(args.work, args.dependencies_only)
 980
 981     if target is None:
 982         raise Error("Bad target `%s'" % s)
 983
 984     target.debug = args.debug
 985     target.ccache = args.ccache
 986
 987     if args.environment is not None:
 988         for e in args.environment:
 989             target.set(e, os.environ[e])
 990
 991     if args.mount is not None:
 992         for m in args.mount:
 993             target.mount(m)
 994
 995     target.setup()
 996     return target
 997
 998
 999 #
1000 # Tree
1001 #
1002
1003 class Tree:
1004     """Description of a tree, which is a checkout of a project,
1005        possibly built.  This class is never exposed to cscripts.
1006        Attributes:
1007            name -- name of git repository (without the .git)
1008            commit_ish -- git tag or revision to use
1009            target -- target object that we are using
1010            version -- version from the wscript (if one is present)
1011            commit -- git revision that is actually being used
1012            built -- true if the tree has been built yet in this run
1013            required_by -- name of the tree that requires this one
1014     """
1015
1016     def __init__(self, name, commit_ish, target, required_by, built=False):
1017         self.name = name
1018         self.commit_ish = commit_ish
1019         self.target = target
1020         self.version = None
1021         self.commit = None
1022         self.built = built
1023         self.required_by = required_by
1024
1025         cwd = os.getcwd()
1026         proj = '%s/src/%s' % (target.directory, self.name)
1027
1028         if not built:
1029             flags = ''
1030             redirect = ''
1031             if globals.quiet:
1032                 flags = '-q'
1033                 redirect = '>/dev/null'
1034             if config.has('git_reference') and globals.use_git_reference:
1035                 ref = '--reference-if-able %s/%s.git' % (config.get('git_reference'), self.name)
1036             else:
1037                 ref = ''
1038             command('git -c protocol.file.allow=always clone %s %s %s/%s.git %s/src/%s' % (flags, ref, config.get('git_prefix'), self.name, target.directory, self.name))
1039             os.chdir('%s/src/%s' % (target.directory, self.name))
1040
1041             if self.commit_ish is not None:
1042                 command('git checkout %s %s %s' % (flags, self.commit_ish, redirect))
1043             self.commit = command_and_read('git rev-parse --short=7 HEAD')[0].strip()
1044
1045         self.cscript = {}
1046         exec(open('%s/cscript' % proj).read(), self.cscript)
1047
1048         if not built:
1049             # cscript can include submodules = False to stop submodules being fetched
1050             if (not 'submodules' in self.cscript or self.cscript['submodules'] == True) and os.path.exists('.gitmodules'):
1051                 command('git submodule --quiet init')
1052                 paths = command_and_read('git config --file .gitmodules --get-regexp path')
1053                 urls = command_and_read('git config --file .gitmodules --get-regexp url')
1054                 for path, url in zip(paths, urls):
1055                     ref = ''
1056                     if config.has('git_reference') and globals.use_git_reference:
1057                         url = url.split(' ')[1]
1058                         ref_path = os.path.join(config.get('git_reference'), os.path.basename(url))
1059                         if os.path.exists(ref_path):
1060                             ref = '--reference %s' % ref_path
1061                     path = path.split(' ')[1]
1062                     command('git -c protocol.file.allow=always submodule --quiet update %s %s' % (ref, path))
1063
1064         if os.path.exists('%s/wscript' % proj):
1065             v = read_wscript_variable(proj, "VERSION");
1066             if v is not None:
1067                 try:
1068                     self.version = Version(v)
1069                 except:
1070                     try:
1071                         tag = command_and_read('git -C %s describe --match v* --tags' % proj)[0][1:]
1072                         self.version = Version.from_git_tag(tag)
1073                     except:
1074                         # We'll leave version as None if we can't read it; maybe this is a bad idea
1075                         # Should probably just install git on the Windows VM
1076                         pass
1077
1078         os.chdir(cwd)
1079
1080     def call(self, function, *args):
1081         with TreeDirectory(self):
1082             return self.cscript[function](self.target, *args)
1083
1084     def add_defaults(self, options):
1085         """Add the defaults from self into a dict options"""
1086         if 'option_defaults' in self.cscript:
1087             from_cscript = self.cscript['option_defaults']
1088             if isinstance(from_cscript, dict):
1089                 defaults_dict = from_cscript
1090             else:
1091                 log_normal("Deprecated cscript option_defaults method; replace with a dict")
1092                 defaults_dict = from_cscript()
1093             for k, v in defaults_dict.items():
1094                 if not k in options:
1095                     options[k] = v
1096
1097     def dependencies(self, options):
1098         """
1099         yield details of the dependencies of this tree.  Each dependency is returned
1100         as a tuple of (tree, options, parent_tree).  The 'options' parameter are the options that
1101         we want to force for 'self'.
1102         """
1103         if not 'dependencies' in self.cscript:
1104             return
1105
1106         if len(inspect.getfullargspec(self.cscript['dependencies']).args) == 2:
1107             self_options = copy.copy(options)
1108             self.add_defaults(self_options)
1109             deps = self.call('dependencies', self_options)
1110         else:
1111             log_normal("Deprecated cscript dependencies() method with no options parameter")
1112             deps = self.call('dependencies')
1113
1114         # Loop over our immediate dependencies
1115         for d in deps:
1116             dep = globals.trees.get(d[0], d[1], self.target, self.name)
1117
1118             # deps only get their options from the parent's cscript
1119             dep_options = d[2] if len(d) > 2 else {}
1120             for i in dep.dependencies(dep_options):
1121                 yield i
1122             yield (dep, dep_options, self)
1123
1124     def checkout_dependencies(self, options={}):
1125         for i in self.dependencies(options):
1126             pass
1127
1128     def build_dependencies(self, options):
1129         """
1130         Called on the 'main' project tree (-p on the command line) to build all dependencies.
1131         'options' will be the ones from the command line.
1132         """
1133         for i in self.dependencies(options):
1134             i[0].build(i[1])
1135
1136     def build(self, options, for_package=False):
1137         if self.built:
1138             return
1139
1140         log_verbose("Building %s %s %s with %s" % (self.name, self.commit_ish, self.version, options))
1141
1142         variables = copy.copy(self.target.variables)
1143
1144         options = copy.copy(options)
1145         self.add_defaults(options)
1146
1147         if not globals.dry_run:
1148             num_args = len(inspect.getfullargspec(self.cscript['build']).args)
1149             if num_args == 3:
1150                 self.call('build', options, for_package)
1151             elif num_args == 2:
1152                 self.call('build', options)
1153             else:
1154                 self.call('build')
1155
1156         self.target.variables = variables
1157         self.built = True
1158
1159
1160 #
1161 # Command-line parser
1162 #
1163
1164 def main():
1165     parser = argparse.ArgumentParser()
1166     parser.add_argument('-p', '--project', help='project name')
1167     parser.add_argument('-c', '--checkout', help='string to pass to git for checkout')
1168     parser.add_argument('-o', '--output', help='output directory', default='.')
1169     parser.add_argument('-q', '--quiet', help='be quiet', action='store_true')
1170     parser.add_argument('-t', '--target', help='target', action='append')
1171     parser.add_argument('--environment-version', help='version of environment to use')
1172     parser.add_argument('-k', '--keep', help='keep working tree', action='store_true')
1173     parser.add_argument('--debug', help='build with debugging symbols where possible', action='store_true')
1174     parser.add_argument('-w', '--work', help='override default work directory')
1175     parser.add_argument('-g', '--git-prefix', help='override configured git prefix')
1176     parser.add_argument('-n', '--dry-run', help='run the process without building anything', action='store_true')
1177     parser.add_argument('-e', '--environment', help='pass the value of the named environment variable into the build', action='append')
1178     parser.add_argument('-m', '--mount', help='mount a given directory in the build environment', action='append')
1179     parser.add_argument('--option', help='set an option for the build (use --option key:value)', action='append')
1180     parser.add_argument('--ccache', help='use ccache', action='store_true')
1181     parser.add_argument('--verbose', help='be verbose', action='store_true')
1182
1183     subparsers = parser.add_subparsers(help='command to run', dest='command')
1184     parser_build = subparsers.add_parser("build", help="build project")
1185     parser_build.add_argument('--dependencies-only', help='only build dependencies', action='store_true')
1186     parser_package = subparsers.add_parser("package", help="build and package project")
1187     parser_package.add_argument('--no-notarize', help='do not notarize .dmg packages', action='store_true')
1188     parser_release = subparsers.add_parser("release", help="release a project using its next version number (adding a tag)")
1189     parser_release.add_argument('--minor', help='minor version number bump', action='store_true')
1190     parser_release.add_argument('--micro', help='micro version number bump', action='store_true')
1191     parser_pot = subparsers.add_parser("pot", help="build the project's .pot files")
1192     parser_manual = subparsers.add_parser("manual", help="build the project's manual")
1193     parser_doxygen = subparsers.add_parser("doxygen", help="build the project's Doxygen documentation")
1194     parser_latest = subparsers.add_parser("latest", help="print out the latest version")
1195     parser_latest.add_argument('--major', help='major version to return', type=int)
1196     parser_latest.add_argument('--minor', help='minor version to return', type=int)
1197     parser_test = subparsers.add_parser("test", help="build the project and run its unit tests")
1198     parser_test.add_argument('--no-implicit-build', help='do not build first', action='store_true')
1199     parser_test.add_argument('--test', help="name of test to run, defaults to all")
1200     parser_shell = subparsers.add_parser("shell", help="start a shell in the project's work directory")
1201     parser_checkout = subparsers.add_parser("checkout", help="check out the project")
1202     parser_revision = subparsers.add_parser("revision", help="print the head git revision number")
1203     parser_dependencies = subparsers.add_parser("dependencies", help="print details of the project's dependencies as a .dot file")
1204     parser_notarize = subparsers.add_parser("notarize", help="notarize .dmgs in a directory")
1205     parser_notarize.add_argument('--dmgs', help='directory containing *.dmg')
1206
1207     global args
1208     args = parser.parse_args()
1209
1210     # Check for incorrect multiple parameters
1211     if args.target is not None:
1212         if len(args.target) > 1:
1213             parser.error('multiple -t options specified')
1214             sys.exit(1)
1215         else:
1216             args.target = args.target[0]
1217
1218     # Override configured stuff
1219     if args.git_prefix is not None:
1220         config.set('git_prefix', args.git_prefix)
1221
1222     if args.output.find(':') == -1:
1223         # This isn't of the form host:path so make it absolute
1224         args.output = os.path.abspath(args.output) + '/'
1225     else:
1226         if args.output[-1] != ':' and args.output[-1] != '/':
1227             args.output += '/'
1228
1229     # Now, args.output is 'host:', 'host:path/' or 'path/'
1230
1231     if args.work is not None:
1232         args.work = os.path.abspath(args.work)
1233         if not os.path.exists(args.work):
1234             os.makedirs(args.work)
1235
1236     if args.project is None and not args.command in ['shell', 'notarize']:
1237         raise Error('you must specify -p or --project')
1238
1239     globals.quiet = args.quiet
1240     globals.verbose = args.verbose
1241     globals.dry_run = args.dry_run
1242
1243     if args.command == 'build':
1244         if args.target is None:
1245             raise Error('you must specify -t or --target')
1246
1247         target = target_factory(args)
1248         try:
1249             target.build(args.project, args.checkout, get_command_line_options(args))
1250         finally:
1251             if not args.keep:
1252                 target.cleanup()
1253
1254     elif args.command == 'package':
1255         if args.target is None:
1256             raise Error('you must specify -t or --target')
1257
1258         target = None
1259         try:
1260             target = target_factory(args)
1261
1262             if target.platform == 'linux' and target.detail != "appimage":
1263                 if target.distro != 'arch':
1264                     output_dir = os.path.join(args.output, '%s-%s-%d' % (target.distro, target.version, target.bits))
1265                 else:
1266                     output_dir = os.path.join(args.output, '%s-%d' % (target.distro, target.bits))
1267             else:
1268                 output_dir = args.output
1269
1270             makedirs(output_dir)
1271             target.package(args.project, args.checkout, output_dir, get_command_line_options(args), not args.no_notarize)
1272         finally:
1273             if target is not None and not args.keep:
1274                 target.cleanup()
1275
1276     elif args.command == 'release':
1277         if args.minor is False and args.micro is False:
1278             raise Error('you must specify --minor or --micro')
1279
1280         target = SourceTarget()
1281         tree = globals.trees.get(args.project, args.checkout, target)
1282
1283         version = tree.version
1284         version.to_release()
1285         if args.minor:
1286             version.bump_minor()
1287         else:
1288             version.bump_micro()
1289
1290         with TreeDirectory(tree):
1291             command('git tag -m "v%s" v%s' % (version, version))
1292             command('git push --tags')
1293
1294         target.cleanup()
1295
1296     elif args.command == 'pot':
1297         target = SourceTarget()
1298         tree = globals.trees.get(args.project, args.checkout, target)
1299
1300         pots = tree.call('make_pot')
1301         for p in pots:
1302             copyfile(p, '%s%s' % (args.output, os.path.basename(p)))
1303
1304         target.cleanup()
1305
1306     elif args.command == 'manual':
1307         target = SourceTarget()
1308         tree = globals.trees.get(args.project, args.checkout, target)
1309         tree.checkout_dependencies()
1310
1311         outs = tree.call('make_manual')
1312         for o in outs:
1313             if os.path.isfile(o):
1314                 copyfile(o, '%s%s' % (args.output, os.path.basename(o)))
1315             else:
1316                 copytree(o, '%s%s' % (args.output, os.path.basename(o)))
1317
1318         target.cleanup()
1319
1320     elif args.command == 'doxygen':
1321         target = SourceTarget()
1322         tree = globals.trees.get(args.project, args.checkout, target)
1323
1324         dirs = tree.call('make_doxygen')
1325         if hasattr(dirs, 'strip') or (not hasattr(dirs, '__getitem__') and not hasattr(dirs, '__iter__')):
1326             dirs = [dirs]
1327
1328         for d in dirs:
1329             copytree(d, args.output)
1330
1331         target.cleanup()
1332
1333     elif args.command == 'latest':
1334         target = SourceTarget()
1335         tree = globals.trees.get(args.project, args.checkout, target)
1336
1337         with TreeDirectory(tree):
1338             f = command_and_read('git log --tags --simplify-by-decoration --pretty="%d"')
1339             latest = None
1340             line = 0
1341             while latest is None:
1342                 t = f[line]
1343                 line += 1
1344                 m = re.compile(".*\((.*)\).*").match(t)
1345                 if m:
1346                     tags = m.group(1).split(', ')
1347                     for t in tags:
1348                         s = t.split()
1349                         if len(s) > 1:
1350                             t = s[1]
1351                         if len(t) > 0 and t[0] == 'v':
1352                             v = Version(t[1:])
1353                             if (args.major is None or v.major == args.major) and (args.minor is None or v.minor == args.minor):
1354                                 latest = v
1355
1356         print(latest)
1357         target.cleanup()
1358
1359     elif args.command == 'test':
1360         if args.target is None:
1361             raise Error('you must specify -t or --target')
1362
1363         target = None
1364         try:
1365             target = target_factory(args)
1366             options = get_command_line_options(args)
1367             if args.no_implicit_build:
1368                 globals.trees.add_built(args.project, args.checkout, target)
1369             else:
1370                 target.build(args.project, args.checkout, options)
1371             target.test(args.project, args.checkout, target, args.test, options)
1372         finally:
1373             if target is not None and not args.keep:
1374                 target.cleanup()
1375
1376     elif args.command == 'shell':
1377         if args.target is None:
1378             raise Error('you must specify -t or --target')
1379
1380         target = target_factory(args)
1381         target.command('bash')
1382
1383     elif args.command == 'revision':
1384
1385         target = SourceTarget()
1386         tree = globals.trees.get(args.project, args.checkout, target)
1387         with TreeDirectory(tree):
1388             print(command_and_read('git rev-parse HEAD')[0].strip()[:7])
1389         target.cleanup()
1390
1391     elif args.command == 'checkout':
1392
1393         if args.output is None:
1394             raise Error('you must specify -o or --output')
1395
1396         target = SourceTarget()
1397         tree = globals.trees.get(args.project, args.checkout, target)
1398         with TreeDirectory(tree):
1399             shutil.copytree('.', args.output)
1400         target.cleanup()
1401
1402     elif args.command == 'dependencies':
1403         if args.target is None:
1404             raise Error('you must specify -t or --target')
1405         if args.checkout is None:
1406             raise Error('you must specify -c or --checkout')
1407
1408         target = target_factory(args)
1409         tree = globals.trees.get(args.project, args.checkout, target)
1410         print("strict digraph {")
1411         for d in list(tree.dependencies({})):
1412             print("%s -> %s;" % (d[2].name.replace("-", "-"), d[0].name.replace("-", "_")))
1413         print("}")
1414
1415     elif args.command == 'notarize':
1416         if args.dmgs is None:
1417             raise Error('you must specify ---dmgs')
1418
1419         for dmg in Path(args.dmgs).glob('*.dmg'):
1420             notarize_dmg(dmg)
1421
1422 try:
1423     main()
1424 except Error as e:
1425     print('cdist: %s' % str(e), file=sys.stderr)
1426     sys.exit(1)