-#!/usr/bin/python
+#!/usr/bin/python3
# Copyright (C) 2012-2020 Carl Hetherington <cth@carlh.net>
#
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
from __future__ import print_function
-import os
-import sys
-import shutil
-import glob
-import tempfile
+
import argparse
-import datetime
-import subprocess
-import re
import copy
-import inspect
+import datetime
import getpass
-import shlex
+import glob
+import inspect
import multiprocessing
+import os
+import re
+import shlex
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
TEMPORARY_DIRECTORY = '/var/tmp'
def __init__(self):
self.options = [ Option('mxe_prefix'),
Option('git_prefix'),
+ Option('git_reference'),
Option('osx_environment_prefix'),
Option('osx_sdk_prefix'),
Option('osx_sdk'),
+ Option('osx_keychain_file'),
+ Option('osx_keychain_password'),
Option('apple_id'),
Option('apple_password'),
BoolOption('docker_sudo'),
(out, err) = p.communicate()
if p.returncode != 0:
raise Error('command %s failed (%s)' % (c, err))
- return out.splitlines()
+ return str(out, 'utf-8').splitlines()
def read_wscript_variable(directory, variable):
f = open('%s/wscript' % directory, 'r')
self.set('CCACHE_BASEDIR', os.path.realpath(self.directory))
self.set('CCACHE_NOHASHDIR', '')
else:
- self.directory = directory
+ self.directory = os.path.realpath(directory)
self.rmdir = False
def package(self, project, checkout, output_dir, options):
tree = self.build(project, checkout, options)
- if len(inspect.getargspec(tree.cscript['package']).args) == 3:
+ tree.add_defaults(options)
+ if len(inspect.getfullargspec(tree.cscript['package']).args) == 3:
packages = tree.call('package', tree.version, options)
else:
log_normal("Deprecated cscript package() method with no options parameter")
packages = tree.call('package', tree.version)
- if isinstance(packages, (str, unicode)):
- copyfile(packages, os.path.join(output_dir, os.path.basename(devel_to_git(tree.git_commit, packages))))
- else:
+ if isinstance(packages, list):
for p in packages:
copyfile(p, os.path.join(output_dir, os.path.basename(devel_to_git(tree.git_commit, p))))
+ else:
+ copyfile(packages, os.path.join(output_dir, os.path.basename(devel_to_git(tree.git_commit, packages))))
def build(self, project, checkout, options):
tree = globals.trees.get(project, checkout, self)
if self.build_dependencies:
tree.build_dependencies(options)
tree.build(options)
- return tree.call('test', test)
+
+ tree.add_defaults(options)
+ if len(inspect.getfullargspec(tree.cscript['test']).args) == 3:
+ return tree.call('test', options, test)
+ else:
+ log_normal('Deprecated cscript test() method with no options parameter')
+ return tree.call('test', test)
def set(self, a, b):
self.variables[a] = b
return ''
return '-u %s' % getpass.getuser()
+ def _mount_option(self, d):
+ return '-v %s:%s ' % (os.path.realpath(d), os.path.realpath(d))
+
def setup(self):
- opts = '-v %s:%s ' % (self.directory, self.directory)
+ opts = self._mount_option(self.directory)
for m in self.mounts:
- opts += '-v %s:%s ' % (m, m)
+ opts += self._mount_option(m)
+ if config.has('git_reference'):
+ opts += self._mount_option(config.get('git_reference'))
if self.privileged:
opts += '--privileged=true '
if self.ccache:
- opts += "-e CCACHE_DIR=/ccache --volumes-from ccache-%s" % self.image
+ opts += "-e CCACHE_DIR=/ccache/%s-%d --mount source=ccache,target=/ccache" % (self.image, os.getuid())
tag = self.image
if config.has('docker_hub_repository'):
self.set('PKG_CONFIG_LIBDIR', '%s/lib/pkgconfig' % self.environment_prefix)
self.set('PKG_CONFIG_PATH', '%s/lib/pkgconfig:%s/bin/pkgconfig' % (self.directory, self.directory))
self.set('PATH', '%s/bin:%s:%s' % (self.environment_prefix, self.tool_path, os.environ['PATH']))
- self.set('CC', '%s-gcc' % self.name)
- self.set('CXX', '%s-g++' % self.name)
self.set('LD', '%s-ld' % self.name)
self.set('RANLIB', '%s-ranlib' % self.name)
self.set('WINRC', '%s-windres' % self.name)
if environment_version is not None:
self.image += '_%s' % environment_version
+ def setup(self):
+ super().setup()
+ if self.ccache:
+ self.set('CC', '"ccache %s-gcc"' % self.name)
+ self.set('CXX', '"ccache %s-g++"' % self.name)
+ else:
+ self.set('CC', '%s-gcc' % self.name)
+ self.set('CXX', '%s-g++' % self.name)
+
@property
def library_prefix(self):
log_normal('Deprecated property library_prefix: use environment_prefix')
class AppImageTarget(LinuxTarget):
def __init__(self, work):
- super(AppImageTarget, self).__init__('ubuntu', '16.04', 64, work)
+ super(AppImageTarget, self).__init__('ubuntu', '18.04', 64, work)
self.detail = 'appimage'
self.privileged = True
self.environment_prefix = config.get('osx_environment_prefix')
self.apple_id = config.get('apple_id')
self.apple_password = config.get('apple_password')
+ self.osx_keychain_file = config.get('osx_keychain_file')
+ self.osx_keychain_password = config.get('osx_keychain_password')
def command(self, c):
command('%s %s' % (self.variables_string(False), c))
+ def build(self, *a, **k):
+ self.command('security unlock-keychain -p %s %s' % (self.osx_keychain_password, self.osx_keychain_file))
+ return super().build(*a, **k)
+
class OSXSingleTarget(OSXTarget):
def __init__(self, bits, directory=None):
tree = globals.trees.get(project, checkout, self)
with TreeDirectory(tree):
- if len(inspect.getargspec(tree.cscript['package']).args) == 3:
+ if len(inspect.getfullargspec(tree.cscript['package']).args) == 3:
packages = tree.call('package', tree.version, options)
else:
log_normal("Deprecated cscript package() method with no options parameter")
if globals.quiet:
flags = '-q'
redirect = '>/dev/null'
- command('git clone %s %s/%s.git %s/src/%s' % (flags, config.get('git_prefix'), self.name, target.directory, self.name))
+ if config.has('git_reference'):
+ ref = '--reference-if-able %s/%s.git' % (config.get('git_reference'), self.name)
+ else:
+ ref = ''
+ command('git clone %s %s %s/%s.git %s/src/%s' % (flags, ref, config.get('git_prefix'), self.name, target.directory, self.name))
os.chdir('%s/src/%s' % (target.directory, self.name))
spec = self.specifier
exec(open('%s/cscript' % proj).read(), self.cscript)
# cscript can include submodules = False to stop submodules being fetched
- if not 'submodules' in self.cscript or self.cscript['submodules'] == True:
- command('git submodule init --quiet')
- command('git submodule update --quiet')
+ if (not 'submodules' in self.cscript or self.cscript['submodules'] == True) and os.path.exists('.gitmodules'):
+ command('git submodule --quiet init')
+ paths = command_and_read('git config --file .gitmodules --get-regexp path')
+ urls = command_and_read('git config --file .gitmodules --get-regexp url')
+ for path, url in zip(paths, urls):
+ ref = ''
+ if config.has('git_reference'):
+ url = url.split(' ')[1]
+ ref_path = os.path.join(config.get('git_reference'), os.path.basename(url))
+ if os.path.exists(ref_path):
+ ref = '--reference %s' % ref_path
+ path = path.split(' ')[1]
+ command('git submodule --quiet update %s %s' % (ref, path))
if os.path.exists('%s/wscript' % proj):
v = read_wscript_variable(proj, "VERSION");
try:
self.version = Version(v)
except:
- tag = subprocess.Popen(shlex.split('git -C %s describe --tags' % proj), stdout=subprocess.PIPE).communicate()[0][1:]
+ tag = command_and_read('git -C %s describe --tags' % proj)[0][1:]
self.version = Version.from_git_tag(tag)
os.chdir(cwd)
def dependencies(self, options):
"""
yield details of the dependencies of this tree. Each dependency is returned
- as a tuple of (tree, options)
+ as a tuple of (tree, options, parent_tree). The 'options' parameter are the options that
+ we want to force for 'self'.
"""
if not 'dependencies' in self.cscript:
return
- if len(inspect.getargspec(self.cscript['dependencies']).args) == 2:
- deps = self.call('dependencies', options)
+ if len(inspect.getfullargspec(self.cscript['dependencies']).args) == 2:
+ self_options = copy.copy(options)
+ self.add_defaults(self_options)
+ deps = self.call('dependencies', self_options)
else:
log_normal("Deprecated cscript dependencies() method with no options parameter")
deps = self.call('dependencies')
+ # Loop over our immediate dependencies
for d in deps:
dep = globals.trees.get(d[0], d[1], self.target, self.name)
- # Start with the options passed in
- dep_options = copy.copy(options)
- # Override those options with anything the parent specifies
- if len(d) > 2:
- for k, v in d[2].items():
- dep_options[k] = v
-
+ # deps only get their options from the parent's cscript
+ dep_options = d[2] if len(d) > 2 else {}
for i in dep.dependencies(dep_options):
yield i
- yield (dep, dep_options)
+ yield (dep, dep_options, self)
def checkout_dependencies(self, options={}):
for i in self.dependencies(options):
pass
def build_dependencies(self, options):
- # Start with the options passed in
- options = copy.copy(options)
- # Fill in the defaults
- self.add_defaults(options)
+ """
+ Called on the 'main' project tree (-p on the command line) to build all dependencies.
+ 'options' will be the ones from the command line.
+ """
for i in self.dependencies(options):
i[0].build(i[1])
variables = copy.copy(self.target.variables)
- # Start with the options passed in
options = copy.copy(options)
- # Fill in the defaults
self.add_defaults(options)
if not globals.dry_run:
- if len(inspect.getargspec(self.cscript['build']).args) == 2:
+ if len(inspect.getfullargspec(self.cscript['build']).args) == 2:
self.call('build', options)
else:
self.call('build')
commands = {
"build": "build project",
- "package": "package and build project",
+ "package": "build and package project",
"release": "release a project using its next version number (changing wscript and tagging)",
"pot": "build the project's .pot files",
"manual": "build the project's manual",
"test": "run the project's unit tests",
"shell": "build the project then start a shell",
"checkout": "check out the project",
- "revision": "print the head git revision number"
+ "revision": "print the head git revision number",
+ "dependencies" : "print details of the project's dependencies as a .dot file"
}
one_of = "Command is one of:\n"
shutil.copytree('.', args.output)
target.cleanup()
+ elif globals.command == 'dependencies':
+ if args.target is None:
+ raise Error('you must specify -t or --target')
+ if args.checkout is None:
+ raise Error('you must specify -c or --checkout')
+
+ target = target_factory(args)
+ tree = globals.trees.get(args.project, args.checkout, target)
+ print("strict digraph {")
+ for d in list(tree.dependencies({})):
+ print("%s -> %s;" % (d[2].name.replace("-", "-"), d[0].name.replace("-", "_")))
+ print("}")
+
else:
raise Error('invalid command %s' % globals.command)
projects / cdist.git / blobdiff