def __exit__(self, type, value, traceback):
os.chdir(self.cwd)
-#
-# Version
-#
-
-class Version:
- def __init__(self, s):
- self.devel = False
-
- if s.startswith("'"):
- s = s[1:]
- if s.endswith("'"):
- s = s[0:-1]
-
- if s.endswith('devel'):
- s = s[0:-5]
- self.devel = True
-
- if s.endswith('pre'):
- s = s[0:-3]
-
- p = s.split('.')
- self.major = int(p[0])
- self.minor = int(p[1])
- if len(p) == 3:
- self.micro = int(p[2])
- else:
- self.micro = 0
-
- @classmethod
- def from_git_tag(cls, tag):
- bits = tag.split('-')
- c = cls(bits[0])
- if len(bits) > 1 and int(bits[1]) > 0:
- c.devel = True
- return c
-
- def bump_minor(self):
- self.minor += 1
- self.micro = 0
-
- def bump_micro(self):
- self.micro += 1
-
- def to_devel(self):
- self.devel = True
-
- def to_release(self):
- self.devel = False
-
- def __str__(self):
- s = '%d.%d.%d' % (self.major, self.minor, self.micro)
- if self.devel:
- s += 'devel'
-
- return s
#
# Targets
"""
Call package() in the cscript and return what it returns, except that
anything not in a list will be put into one.
+ options: from command line
"""
if len(inspect.getfullargspec(tree.cscript['package']).args) == 3:
- packages = tree.call('package', tree.version, options)
+ packages = tree.call('package', tree.version, tree.add_defaults(options))
else:
log_normal("Deprecated cscript package() method with no options parameter")
packages = tree.call('package', tree.version)
copyfile(p, os.path.join(output_dir, os.path.basename(devel_to_git(tree.commit, p))))
def package(self, project, checkout, output_dir, options, notarize):
+ """
+ options: from command line
+ """
tree = self.build(project, checkout, options, for_package=True)
- tree.add_defaults(options)
p = self._cscript_package(tree, options)
self._copy_packages(tree, p, output_dir)
"""test is the test case to run, or None"""
tree = globals.trees.get(project, checkout, target)
- tree.add_defaults(options)
with TreeDirectory(tree):
if len(inspect.getfullargspec(tree.cscript['test']).args) == 3:
- return tree.call('test', options, test)
+ return tree.call('test', tree.add_defaults(options), test)
else:
log_normal('Deprecated cscript test() method with no options parameter')
return tree.call('test', test)
def __init__(self, bits, directory, environment_version):
super(WindowsDockerTarget, self).__init__('windows', directory)
self.bits = bits
+ # This was used to differentiate "normal" Windows from XP, and is no longer important,
+ # but old cscripts still look for it
+ self.version = None
self.tool_path = '%s/usr/bin' % config.get('mxe_prefix')
if self.bits == 32:
super().__init__('windows', directory)
self.bits = 64
- self.environment_prefix = config.get('windows_native_environmnet_prefix')
+ self.environment_prefix = config.get('windows_native_environment_prefix')
self.set('PATH', '%s/bin:%s' % (self.environment_prefix, os.environ['PATH']))
class OSXTarget(Target):
- def __init__(self, directory=None):
+ def __init__(self, directory=None, environment_version=None):
super(OSXTarget, self).__init__('osx', directory)
self.sdk_prefix = config.get('osx_sdk_prefix')
self.environment_prefix = config.get('osx_environment_prefix')
+ if environment_version:
+ self.environment_prefix += '_%s' % environment_version
self.apple_id = config.get('apple_id')
self.apple_password = config.get('apple_password')
self.osx_keychain_file = config.get('osx_keychain_file')
class OSXSingleTarget(OSXTarget):
- def __init__(self, arch, sdk, deployment, directory=None, can_notarize=True):
- super(OSXSingleTarget, self).__init__(directory)
+ def __init__(self, arch, sdk, deployment, directory=None, can_notarize=True, environment_version=None):
+ super(OSXSingleTarget, self).__init__(directory=directory, environment_version=environment_version)
self.arch = arch
self.sdk = sdk
self.deployment = deployment
flags = '-isysroot %s/MacOSX%s.sdk -arch %s' % (self.sdk_prefix, sdk, arch)
if arch == 'x86_64':
- host_enviro = '%s/x86_64/%s' % (config.get('osx_environment_prefix'), deployment)
+ host_enviro = '%s/x86_64/%s' % (self.environment_prefix, deployment)
else:
- host_enviro = '%s/x86_64/10.10' % config.get('osx_environment_prefix')
- target_enviro = '%s/%s/%s' % (config.get('osx_environment_prefix'), arch, deployment)
+ host_enviro = '%s/x86_64/10.10' % self.environment_prefix
+ target_enviro = '%s/%s/%s' % (self.environment_prefix, arch, deployment)
self.bin = '%s/bin' % target_enviro
def package(self, project, checkout, output_dir, options, notarize):
tree = self.build(project, checkout, options, for_package=True)
- tree.add_defaults(options)
-
super().package(project, checkout, output_dir, options, notarize)
class OSXUniversalTarget(OSXTarget):
- def __init__(self, directory=None):
- super(OSXUniversalTarget, self).__init__(directory)
+ def __init__(self, directory=None, environment_version=None):
+ super(OSXUniversalTarget, self).__init__(directory=directory, environment_version=environment_version)
self.sdk = config.get('osx_sdk')
self.sub_targets = []
for arch, deployment in (('x86_64', config.get('osx_intel_deployment')), ('arm64', config.get('osx_arm_deployment'))):
- target = OSXSingleTarget(arch, self.sdk, deployment, os.path.join(self.directory, arch, deployment))
+ target = OSXSingleTarget(arch, self.sdk, deployment, os.path.join(self.directory, arch, deployment), environment_version=environment_version)
target.ccache = self.ccache
self.sub_targets.append(target)
self.can_notarize = True
class LocalTarget(Target):
"""Build on the local machine with its environment"""
- def __init__(self, work):
- super(LocalTarget, self).__init__('local', work)
+ def __init__(self, work, dependencies_only=False):
+ super(LocalTarget, self).__init__('linux', work, dependencies_only=dependencies_only)
# Hack around ffmpeg.git which sees that the target isn't windows/osx and then assumes
# distro will be there.
self.distro = None
+ self.detail = None
+ self.bits = 64
self.set('PKG_CONFIG_PATH', '%s/lib/pkgconfig:%s/bin/pkgconfig' % (self.directory, self.directory))
+ self.append_with_colon('LD_LIBRARY_PATH', '%s/lib' % self.directory)
+ self.set('CXXFLAGS', '-I%s/include' % self.directory)
+ self.set('LINKFLAGS', '-L%s/lib' % self.directory)
def command(self, c):
log_normal('host -> %s' % c)
elif s == 'raspbian':
target = LinuxTarget(s, None, None, args.work)
elif s == 'osx':
- target = OSXUniversalTarget(args.work)
+ target = OSXUniversalTarget(args.work, environment_version=args.environment_version)
elif s == 'osx-intel':
- target = OSXSingleTarget('x86_64', config.get('osx_sdk'), config.get('osx_intel_deployment'), args.work)
+ target = OSXSingleTarget('x86_64', config.get('osx_sdk'), config.get('osx_intel_deployment'), args.work, environment_version=args.environment_version)
elif s == 'osx-old':
- target = OSXSingleTarget('x86_64', config.get('osx_sdk'), config.get('osx_old_deployment'), args.work, False)
+ target = OSXSingleTarget('x86_64', config.get('osx_sdk'), config.get('osx_old_deployment'), args.work, False, environment_version=args.environment_version)
elif s == 'source':
target = SourceTarget()
elif s == 'flatpak':
path = path.split(' ')[1]
command('git -c protocol.file.allow=always submodule --quiet update %s %s' % (ref, path))
- if os.path.exists('%s/wscript' % proj):
- v = read_wscript_variable(proj, "VERSION");
- if v is not None:
- try:
- self.version = Version(v)
- except:
- try:
- tag = command_and_read('git -C %s describe --match v* --tags' % proj)[0][1:]
- self.version = Version.from_git_tag(tag)
- except:
- # We'll leave version as None if we can't read it; maybe this is a bad idea
- # Should probably just install git on the Windows VM
- pass
+ head_tag = command_and_read(f'git -C {proj} tag -l --points-at HEAD')
+ if head_tag:
+ self.version = head_tag[0][1:]
+ else:
+ self.version = command_and_read(f'git -C {proj} rev-parse --short HEAD')[0]
os.chdir(cwd)
return self.cscript[function](self.target, *args)
def add_defaults(self, options):
- """Add the defaults from self into a dict options"""
+ """Add the defaults from self into a dict options and returns a new dict"""
+ new_options = copy.copy(options)
if 'option_defaults' in self.cscript:
from_cscript = self.cscript['option_defaults']
if isinstance(from_cscript, dict):
log_normal("Deprecated cscript option_defaults method; replace with a dict")
defaults_dict = from_cscript()
for k, v in defaults_dict.items():
- if not k in options:
- options[k] = v
+ if not k in new_options:
+ new_options[k] = v
+ return new_options
def dependencies(self, options):
"""
yield details of the dependencies of this tree. Each dependency is returned
- as a tuple of (tree, options, parent_tree). The 'options' parameter are the options that
- we want to force for 'self'.
+ as a tuple of (tree, options).
+ options: either from command line (for top-level tree) or from parent's dependencies() (for other trees)
"""
if not 'dependencies' in self.cscript:
return
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)
+ deps = self.call('dependencies', self.add_defaults(options))
else:
log_normal("Deprecated cscript dependencies() method with no options parameter")
deps = self.call('dependencies')
dep_options = d[2] if len(d) > 2 else {}
for i in dep.dependencies(dep_options):
yield i
- yield (dep, dep_options, self)
+ yield (dep, dep_options)
def checkout_dependencies(self, options={}):
for i in self.dependencies(options):
def build_dependencies(self, 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.
+ options: either from command line (for top-level tree) or from parent's dependencies() (for other trees)
"""
- for i in self.dependencies(options):
- i[0].build(i[1])
+ for dependency, dependency_options in self.dependencies(options):
+ dependency.build(dependency_options)
def build(self, options, for_package=False):
+ """
+ options: either from command line (for top-level tree) or from parent's dependencies() (for other trees)
+ """
if self.built:
return
- log_verbose("Building %s %s %s with %s" % (self.name, self.commit_ish, self.version, options))
+ log_verbose("Building %s %s %s with %s" % (self.name, self.commit_ish, self.version, self.add_defaults(options)))
variables = copy.copy(self.target.variables)
- options = copy.copy(options)
- self.add_defaults(options)
-
if not globals.dry_run:
num_args = len(inspect.getfullargspec(self.cscript['build']).args)
if num_args == 3:
- self.call('build', options, for_package)
+ self.call('build', self.add_defaults(options), for_package)
elif num_args == 2:
- self.call('build', options)
+ self.call('build', self.add_defaults(options))
else:
self.call('build')
if target is not None and not args.keep:
target.cleanup()
- elif args.command == 'release':
- if args.minor is False and args.micro is False:
- raise Error('you must specify --minor or --micro')
-
- target = SourceTarget()
- tree = globals.trees.get(args.project, args.checkout, target)
-
- version = tree.version
- version.to_release()
- if args.minor:
- version.bump_minor()
- else:
- version.bump_micro()
-
- with TreeDirectory(tree):
- command('git tag -m "v%s" v%s' % (version, version))
- command('git push --tags')
-
- target.cleanup()
-
elif args.command == 'pot':
target = SourceTarget()
tree = globals.trees.get(args.project, args.checkout, target)
if len(s) > 1:
t = s[1]
if len(t) > 0 and t[0] == 'v':
- v = Version(t[1:])
- if (args.major is None or v.major == args.major) and (args.minor is None or v.minor == args.minor):
+ v = t[1:].split('.')
+ if (args.major is None or int(v[0]) == args.major) and (args.minor is None or int(v[1]) == args.minor):
latest = v
- print(latest)
+ print('.'.join(latest))
target.cleanup()
elif args.command == 'test':
shutil.copytree('.', args.output)
target.cleanup()
- elif args.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("}")
-
elif args.command == 'notarize':
if args.dmgs is None:
raise Error('you must specify ---dmgs')
projects / cdist.git / blobdiff