Add support for sysroot'ed dependencies in BuildElement and ScriptElement
diff --git a/buildstream/_sysroot_dependency_loader.py b/buildstream/_sysroot_dependency_loader.py
new file mode 100644
index 0000000..c9b348c
--- /dev/null
+++ b/buildstream/_sysroot_dependency_loader.py
@@ -0,0 +1,260 @@
+#
+# Copyright (C) 2019 Codethink Limited
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library. If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors:
+# Valentin David <valentin.david@codethink.co.uk>
+
+import os
+import itertools
+from collections.abc import Mapping
+
+from .dependency_loader import DependencyLoader, Dependency
+from . import Element, ElementError, Scope, SandboxFlags
+
+
+# SysrootDependencyLoader():
+#
+# `SysrootDependencyLoader` implements a `DependencyLoader` to extract
+# sysroot'ed dependencies.
+class SysrootDependencyLoader(DependencyLoader):
+
+ def get_dependencies(self, node):
+ sysroots = self.node_get_member(node, list, 'sysroots', default=[])
+ dependencies = []
+
+ for sysroot in sysroots:
+ depends = self.node_get_member(sysroot, list, 'depends', default=[])
+ build_depends = self.node_get_member(sysroot, list, 'build-depends', default=[])
+ depends_iter = itertools.product(['all'], depends)
+ build_depends_iter = itertools.product(['build'], build_depends)
+ for default_type, dep in itertools.chain(depends_iter, build_depends_iter):
+ if isinstance(dep, Mapping):
+ provenance = self.node_provenance(dep)
+ filename = self.node_get_member(node, str, 'filename')
+ dep_type = self.node_get_member(node, str, 'type', default=default_type)
+ junction = self.node_get_member(node, str, 'junction', default=None)
+ dependencies.append(Dependency(filename, dep_type=dep_type,
+ junction=junction, provenance=provenance))
+ else:
+ provenance = self.node_provenance(sysroot)
+ dependencies.append(Dependency(dep, dep_type=default_type, provenance=provenance))
+
+ return dependencies
+
+
+# SysrootHelper():
+#
+# `SysrootHelper` should be used in element plugins that use
+# `SysrootDependencyLoader` as dependency loader. It provides
+# The implementation for staging.
+class SysrootHelper:
+
+ CONFIG_KEYS = ['sysroots']
+ __layout = []
+
+ def __init__(self, element, node):
+
+ self.__element = element
+
+ for sysroot in self.__element.node_get_member(node, list, 'sysroots', []):
+ self.__element.node_validate(sysroot, ['path', 'depends', 'build-depends'])
+ path = self.__element.node_subst_member(sysroot, 'path')
+ depends = self.__element.node_get_member(sysroot, list, 'depends', default=[])
+ build_depends = self.__element.node_get_member(sysroot, list, 'build-depends', default=[])
+ for dep in itertools.chain(depends, build_depends):
+ if isinstance(dep, Mapping):
+ self.__element.node_validate(dep, ['filename', 'type', 'junction'])
+ filename = self.__element.node_get_member(dep, str, 'filename')
+ junction = self.__element.node_get_member(dep, str, 'junction', default=None)
+ else:
+ filename = dep
+ junction = None
+ self.layout_add(filename, path, junction=junction)
+
+ # layout_add():
+ #
+ # Adds a destination where a dependency should be staged
+ #
+ # Args:
+ # element (str): Element name of the dependency
+ # destination (str): Path where element will be staged
+ # junction (str): Junction of the dependency
+ #
+ # If `junction` is None, then the dependency should be in the same
+ # project as the current element.
+ #
+ # If `junction` is ignored or `Element.IGNORE_JUNCTION`, the
+ # junction of the dependency is not checked. This is for backward
+ # compliancy and should not be used.
+ #
+ # If `element` is None, the destination will just
+ # be marked in the sandbox.
+ def layout_add(self, element, destination, *, junction=Element.IGNORE_JUNCTION):
+ #
+ # Even if this is an empty list by default, make sure that its
+ # instance data instead of appending stuff directly onto class data.
+ #
+ if not self.__layout:
+ self.__layout = []
+ item = {'element': element,
+ 'destination': destination}
+ if junction is not Element.IGNORE_JUNCTION:
+ item['junction'] = junction
+ self.__layout.append(item)
+
+ # validate():
+ #
+ # Verify that elements in layouts are dependencies.
+ #
+ # Raises:
+ # (ElementError): When a element is not in the dependencies
+ #
+ # This method is only useful when SysrootHelper.layout_add
+ # has been called directly.
+ #
+ # This should be called in implementation of Plugin.preflight.
+ def validate(self):
+ if self.__layout:
+ # Cannot proceed if layout specifies an element that isn't part
+ # of the dependencies.
+ for item in self.__layout:
+ if not item['element']:
+ if not self.__search(item):
+ raise ElementError("{}: '{}' in layout not found in dependencies"
+ .format(self.__element, item['element']))
+
+ # stage():
+ #
+ # Stage dependencies and integrate root dependencies
+ #
+ # Args:
+ # stage_all (bool): Whether to stage all dependencies, not just the ones mapped
+ #
+ def stage(self, sandbox, stage_all):
+
+ staged = set()
+ sysroots = {}
+
+ for item in self.__layout:
+
+ # Skip layout members which dont stage an element
+ if not item['element']:
+ continue
+
+ element = self.__search(item)
+ staged.add(element)
+ if item['destination'] not in sysroots:
+ sysroots[item['destination']] = [element]
+ else:
+ sysroots[item['destination']].append(element)
+
+ if stage_all or not self.__layout:
+ for build_dep in self.__element.dependencies(Scope.BUILD, recurse=False):
+ if build_dep in staged:
+ continue
+ if '/' not in sysroots:
+ sysroots['/'] = [build_dep]
+ else:
+ sysroots['/'].append(build_dep)
+
+ for sysroot, deps in sysroots.items():
+ with self.__element.timed_activity("Staging dependencies at {}".format(sysroot), silent_nested=True):
+ if sysroot != '/':
+ virtual_dstdir = sandbox.get_virtual_directory()
+ virtual_dstdir.descend(sysroot.lstrip(os.sep).split(os.sep), create=True)
+ all_deps = set()
+ for dep in deps:
+ for run_dep in dep.dependencies(Scope.RUN):
+ all_deps.add(run_dep)
+ self.__element.stage_dependency_artifacts(sandbox, Scope.BUILD, path=sysroot, dependencies=all_deps)
+
+ with sandbox.batch(SandboxFlags.NONE):
+ for item in self.__layout:
+
+ # Skip layout members which dont stage an element
+ if not item['element']:
+ continue
+
+ element = self.__search(item)
+
+ # Integration commands can only be run for elements staged to /
+ if item['destination'] == '/':
+ with self.__element.timed_activity("Integrating {}".format(element.name),
+ silent_nested=True):
+ for dep in element.dependencies(Scope.RUN):
+ element.integrate(sandbox)
+
+ if stage_all or not self.__layout:
+ for build_dep in self.__element.dependencies(Scope.BUILD, recurse=False):
+ if build_dep in staged:
+ continue
+
+ with self.__element.timed_activity("Integrating {}".format(build_dep.name), silent_nested=True):
+ for dep in build_dep.dependencies(Scope.RUN):
+ dep.integrate(sandbox)
+
+ # has_sysroots():
+ #
+ # Tells whether any element has been mapped
+ #
+ # Returns:
+ # (bool): Whether any element has been mapped
+ def has_sysroots(self):
+ return bool(self.__layout)
+
+ # get_unique_key():
+ #
+ # Returns a value usable for an element unique key
+ #
+ # Returns:
+ # (dict): A dictionary that uniquely identify the mapping configuration
+ def get_unique_key(self):
+ return self.__layout
+
+ # configure_sandbox():
+ #
+ # Configure the sandbox. Mark required directories in the sandbox.
+ #
+ # Args:
+ # extra_directories (list(str)): Extra directories to mark
+ #
+ # Because Sandbox.mark_directory should be called
+ # only once, marked directories should passed as `extra_directories`
+ # instead of being marked directly.
+ def configure_sandbox(self, sandbox, extra_directories):
+
+ directories = {directory: False for directory in extra_directories}
+
+ for item in self.__layout:
+ destination = item['destination']
+ was_artifact = directories.get(destination, False)
+ directories[destination] = item['element'] or was_artifact
+
+ for directory, artifact in directories.items():
+ # Root does not need to be marked as it is always mounted
+ # with artifact (unless explicitly marked non-artifact)
+ if directory != '/':
+ sandbox.mark_directory(directory, artifact=artifact)
+
+ #
+ # Private methods
+ #
+
+ def __search(self, item):
+ if 'junction' in item:
+ return self.__element.search(Scope.BUILD, item['element'], junction=item['junction'])
+ else:
+ return self.__element.search(Scope.BUILD, item['element'])
diff --git a/buildstream/buildelement.py b/buildstream/buildelement.py
index 6ef060f..126c966 100644
--- a/buildstream/buildelement.py
+++ b/buildstream/buildelement.py
@@ -135,8 +135,10 @@
"""
import os
-from . import Element, Scope
+
+from . import Element
from . import SandboxFlags
+from ._sysroot_dependency_loader import SysrootDependencyLoader, SysrootHelper
# This list is preserved because of an unfortunate situation, we
@@ -157,17 +159,20 @@
class BuildElement(Element):
+ DEPENDENCY_LOADER = SysrootDependencyLoader
+
#############################################################
# Abstract Method Implementations #
#############################################################
def configure(self, node):
self.__commands = {} # pylint: disable=attribute-defined-outside-init
+ self.__sysroots = SysrootHelper(self, node) # pylint: disable=attribute-defined-outside-init
# FIXME: Currently this forcefully validates configurations
# for all BuildElement subclasses so they are unable to
# extend the configuration
- self.node_validate(node, _command_steps)
+ self.node_validate(node, _command_steps + SysrootHelper.CONFIG_KEYS)
for command_name in _legacy_command_steps:
if command_name in _command_steps:
@@ -191,6 +196,9 @@
if self.get_variable('notparallel'):
dictionary['notparallel'] = True
+ if self.__sysroots.has_sysroots():
+ dictionary['sysroots'] = self.__sysroots.get_unique_key()
+
return dictionary
def configure_sandbox(self, sandbox):
@@ -198,8 +206,8 @@
install_root = self.get_variable('install-root')
# Tell the sandbox to mount the build root and install root
- sandbox.mark_directory(build_root)
- sandbox.mark_directory(install_root)
+ self.__sysroots.configure_sandbox(sandbox, [build_root,
+ install_root])
# Allow running all commands in a specified subdirectory
command_subdir = self.get_variable('command-subdir')
@@ -217,15 +225,7 @@
def stage(self, sandbox):
- # Stage deps in the sandbox root
- with self.timed_activity("Staging dependencies", silent_nested=True):
- self.stage_dependency_artifacts(sandbox, Scope.BUILD)
-
- # Run any integration commands provided by the dependencies
- # once they are all staged and ready
- with sandbox.batch(SandboxFlags.NONE, label="Integrating sandbox"):
- for dep in self.dependencies(Scope.BUILD):
- dep.integrate(sandbox)
+ self.__sysroots.stage(sandbox, True)
# Stage sources in the build root
self.stage_sources(sandbox, self.get_variable('build-root'))
diff --git a/buildstream/element.py b/buildstream/element.py
index fcf7c15..d28390f 100644
--- a/buildstream/element.py
+++ b/buildstream/element.py
@@ -677,7 +677,8 @@
return link_result.combine(copy_result)
def stage_dependency_artifacts(self, sandbox, scope, *, path=None,
- include=None, exclude=None, orphans=True):
+ include=None, exclude=None, orphans=True,
+ dependencies=None):
"""Stage element dependencies in scope
This is primarily a convenience wrapper around
@@ -692,6 +693,7 @@
include (list): An optional list of domains to include files from
exclude (list): An optional list of domains to exclude files from
orphans (bool): Whether to include files not spoken for by split domains
+ dependencies (list): An optional list of dependencies to stage
Raises:
(:class:`.ElementError`): If any of the dependencies in `scope` have not
@@ -707,7 +709,9 @@
if self.__can_build_incrementally() and workspace.last_successful:
old_dep_keys = self.__get_artifact_metadata_dependencies(workspace.last_successful)
- for dep in self.dependencies(scope):
+ if dependencies is None:
+ dependencies = self.dependencies(scope)
+ for dep in dependencies:
# If we are workspaced, and we therefore perform an
# incremental build, we must ensure that we update the mtimes
# of any files created by our dependencies since the last
diff --git a/buildstream/plugins/elements/script.py b/buildstream/plugins/elements/script.py
index 6c33ecf..657584b 100644
--- a/buildstream/plugins/elements/script.py
+++ b/buildstream/plugins/elements/script.py
@@ -36,6 +36,7 @@
"""
import buildstream
+from buildstream._sysroot_dependency_loader import DependencyLoader
# Element implementation for the 'script' kind.
@@ -46,6 +47,8 @@
BST_VIRTUAL_DIRECTORY = True
def configure(self, node):
+ super().configure(node)
+
for n in self.node_get_member(node, list, 'layout', []):
dst = self.node_subst_member(n, 'destination')
elm = self.node_subst_member(n, 'element', None)
@@ -53,7 +56,7 @@
self.node_validate(node, [
'commands', 'root-read-only', 'layout'
- ])
+ ] + self.COMMON_CONFIG_KEYS)
cmds = self.node_subst_list(node, "commands")
self.add_commands("commands", cmds)
diff --git a/buildstream/scriptelement.py b/buildstream/scriptelement.py
index 697cd28..703c5a9 100644
--- a/buildstream/scriptelement.py
+++ b/buildstream/scriptelement.py
@@ -35,7 +35,8 @@
import os
from collections import OrderedDict
-from . import Element, ElementError, Scope, SandboxFlags
+from . import Element, SandboxFlags
+from ._sysroot_dependency_loader import SysrootDependencyLoader, SysrootHelper
class ScriptElement(Element):
@@ -43,7 +44,6 @@
__cwd = "/"
__root_read_only = False
__commands = None
- __layout = []
# The compose element's output is its dependencies, so
# we must rebuild if the dependencies change even when
@@ -59,6 +59,15 @@
# added, to reduce the potential for confusion
BST_FORBID_SOURCES = True
+ COMMON_CONFIG_KEYS = SysrootHelper.CONFIG_KEYS
+
+ DEPENDENCY_LOADER = SysrootDependencyLoader
+
+ def configure(self, node):
+
+ self.__stage_all = True # pylint: disable=attribute-defined-outside-init
+ self.__sysroots = SysrootHelper(self, node) # pylint: disable=attribute-defined-outside-init
+
def set_work_dir(self, work_dir=None):
"""Sets the working dir
@@ -134,14 +143,8 @@
In the case that no element is specified, a read-write directory will
be made available at the specified location.
"""
- #
- # Even if this is an empty list by default, make sure that its
- # instance data instead of appending stuff directly onto class data.
- #
- if not self.__layout:
- self.__layout = []
- self.__layout.append({"element": element,
- "destination": destination})
+ self.__stage_all = False # pylint: disable=attribute-defined-outside-init
+ self.__sysroots.layout_add(element, destination)
def add_commands(self, group_name, command_list):
"""Adds a list of commands under the group-name.
@@ -164,32 +167,15 @@
self.__commands = OrderedDict()
self.__commands[group_name] = command_list
- def __validate_layout(self):
- if self.__layout:
- # Cannot proceeed if layout is used, but none are for "/"
- root_defined = any([(entry['destination'] == '/') for entry in self.__layout])
- if not root_defined:
- raise ElementError("{}: Using layout, but none are staged as '/'"
- .format(self))
-
- # Cannot proceed if layout specifies an element that isn't part
- # of the dependencies.
- for item in self.__layout:
- if item['element']:
- if not self.search(Scope.BUILD, item['element']):
- raise ElementError("{}: '{}' in layout not found in dependencies"
- .format(self, item['element']))
-
def preflight(self):
- # The layout, if set, must make sense.
- self.__validate_layout()
+ self.__sysroots.validate()
def get_unique_key(self):
return {
'commands': self.__commands,
'cwd': self.__cwd,
'install-root': self.__install_root,
- 'layout': self.__layout,
+ 'layout': self.__sysroots.get_unique_key(),
'root-read-only': self.__root_read_only
}
@@ -201,72 +187,11 @@
# Setup environment
sandbox.set_environment(self.get_environment())
- # Tell the sandbox to mount the install root
- directories = {self.__install_root: False}
-
- # Mark the artifact directories in the layout
- for item in self.__layout:
- destination = item['destination']
- was_artifact = directories.get(destination, False)
- directories[destination] = item['element'] or was_artifact
-
- for directory, artifact in directories.items():
- # Root does not need to be marked as it is always mounted
- # with artifact (unless explicitly marked non-artifact)
- if directory != '/':
- sandbox.mark_directory(directory, artifact=artifact)
+ self.__sysroots.configure_sandbox(sandbox, [self.__install_root])
def stage(self, sandbox):
- # Stage the elements, and run integration commands where appropriate.
- if not self.__layout:
- # if no layout set, stage all dependencies into /
- for build_dep in self.dependencies(Scope.BUILD, recurse=False):
- with self.timed_activity("Staging {} at /"
- .format(build_dep.name), silent_nested=True):
- build_dep.stage_dependency_artifacts(sandbox, Scope.RUN, path="/")
-
- with sandbox.batch(SandboxFlags.NONE):
- for build_dep in self.dependencies(Scope.BUILD, recurse=False):
- with self.timed_activity("Integrating {}".format(build_dep.name), silent_nested=True):
- for dep in build_dep.dependencies(Scope.RUN):
- dep.integrate(sandbox)
- else:
- # If layout, follow its rules.
- for item in self.__layout:
-
- # Skip layout members which dont stage an element
- if not item['element']:
- continue
-
- element = self.search(Scope.BUILD, item['element'])
- if item['destination'] == '/':
- with self.timed_activity("Staging {} at /".format(element.name),
- silent_nested=True):
- element.stage_dependency_artifacts(sandbox, Scope.RUN)
- else:
- with self.timed_activity("Staging {} at {}"
- .format(element.name, item['destination']),
- silent_nested=True):
- virtual_dstdir = sandbox.get_virtual_directory()
- virtual_dstdir.descend(item['destination'].lstrip(os.sep).split(os.sep), create=True)
- element.stage_dependency_artifacts(sandbox, Scope.RUN, path=item['destination'])
-
- with sandbox.batch(SandboxFlags.NONE):
- for item in self.__layout:
-
- # Skip layout members which dont stage an element
- if not item['element']:
- continue
-
- element = self.search(Scope.BUILD, item['element'])
-
- # Integration commands can only be run for elements staged to /
- if item['destination'] == '/':
- with self.timed_activity("Integrating {}".format(element.name),
- silent_nested=True):
- for dep in element.dependencies(Scope.RUN):
- dep.integrate(sandbox)
+ self.__sysroots.stage(sandbox, self.__stage_all)
install_root_path_components = self.__install_root.lstrip(os.sep).split(os.sep)
sandbox.get_virtual_directory().descend(install_root_path_components, create=True)
diff --git a/doc/source/format_declaring.rst b/doc/source/format_declaring.rst
index 714e1fa..13858f7 100644
--- a/doc/source/format_declaring.rst
+++ b/doc/source/format_declaring.rst
@@ -159,6 +159,64 @@
The ``runtime-depends`` configuration is available since :ref:`format version 14 <project_format_version>`
+Sysroot'ed dependencies
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Build elements and script elements can support sysroot'ed
+dependencies. Sysroot'ed dependencies are intended for bootstraping
+base systems or cross-compiling.
+
+Because sysroot'ed dependencies are plugin specific, they are defined
+within the plugin configuration node.
+
+.. code:: yaml
+
+ config:
+ # Specify some sysroot'ed dependencies
+ sysroots:
+ - path: /sysroot
+ depends:
+ - element1.bst
+ - element2.bst
+
+During build, or initialization of build shell, sysroot'ed build
+dependencies will be staged in the given sysroot path instead of '/'
+together with the runtime dependencies of those sysroot'ed build
+dependencies.
+
+It is possible to end up with indirect runtime dependencies in
+different sysroots if they are staged from build dependencies with
+different sysroots. They will be staged multiple times.
+
+Sysroot paths only apply to build dependencies. It is not possible to
+define runtime dependencies either with ``type: runtime`` or
+``runtime-depends``. It is possible to use ``all`` dependencies, but
+the sysroot part is only for the build part not the runtime.
+
+For example:
+
+.. code:: yaml
+
+ config:
+ sysroots:
+ - path: /sysroot
+ depends:
+ - element.bst
+
+is equivalent to:
+
+.. code:: yaml
+
+ config:
+ runtime-depends:
+ - element.bst
+ sysroots:
+ - path: /sysroot
+ build-depends:
+ - element.bst
+
+:ref:`Integration commands <public_integration>` are never executed for
+sysroot'ed dependencies.
.. _format_sources:
diff --git a/tests/sysroot_depends/project/elements/a.bst b/tests/sysroot_depends/project/elements/a.bst
new file mode 100644
index 0000000..600aed2
--- /dev/null
+++ b/tests/sysroot_depends/project/elements/a.bst
@@ -0,0 +1,4 @@
+kind: import
+sources:
+ - kind: local
+ path: files/a
diff --git a/tests/sysroot_depends/project/elements/b.bst b/tests/sysroot_depends/project/elements/b.bst
new file mode 100644
index 0000000..ebebf11
--- /dev/null
+++ b/tests/sysroot_depends/project/elements/b.bst
@@ -0,0 +1,4 @@
+kind: import
+sources:
+ - kind: local
+ path: files/b
diff --git a/tests/sysroot_depends/project/elements/base.bst b/tests/sysroot_depends/project/elements/base.bst
new file mode 100644
index 0000000..3c38c24
--- /dev/null
+++ b/tests/sysroot_depends/project/elements/base.bst
@@ -0,0 +1,3 @@
+kind: stack
+depends:
+- base/base-alpine.bst
diff --git a/tests/sysroot_depends/project/elements/base/base-alpine.bst b/tests/sysroot_depends/project/elements/base/base-alpine.bst
new file mode 100644
index 0000000..687588f
--- /dev/null
+++ b/tests/sysroot_depends/project/elements/base/base-alpine.bst
@@ -0,0 +1,12 @@
+kind: import
+
+description: |
+ Alpine Linux base for tests
+
+ Generated using the `tests/integration-tests/base/generate-base.sh` script.
+
+sources:
+ - kind: tar
+ url: alpine:integration-tests-base.v1.x86_64.tar.xz
+ base-dir: ''
+ ref: 3eb559250ba82b64a68d86d0636a6b127aa5f6d25d3601a79f79214dc9703639
diff --git a/tests/sysroot_depends/project/elements/compose-integration.bst b/tests/sysroot_depends/project/elements/compose-integration.bst
new file mode 100644
index 0000000..a6c5ec3
--- /dev/null
+++ b/tests/sysroot_depends/project/elements/compose-integration.bst
@@ -0,0 +1,6 @@
+kind: compose
+
+sysroots:
+- path: /sysroot
+ build-depends:
+ - integration.bst
diff --git a/tests/sysroot_depends/project/elements/compose-layers-with-sysroot.bst b/tests/sysroot_depends/project/elements/compose-layers-with-sysroot.bst
new file mode 100644
index 0000000..8de7950
--- /dev/null
+++ b/tests/sysroot_depends/project/elements/compose-layers-with-sysroot.bst
@@ -0,0 +1,13 @@
+kind: manual
+
+build-depends:
+- base.bst
+
+variables:
+ install-root: "/"
+
+config:
+ sysroots:
+ - path: /other-sysroot
+ build-depends:
+ - layer2.bst
diff --git a/tests/sysroot_depends/project/elements/compose-layers.bst b/tests/sysroot_depends/project/elements/compose-layers.bst
new file mode 100644
index 0000000..498e2fc
--- /dev/null
+++ b/tests/sysroot_depends/project/elements/compose-layers.bst
@@ -0,0 +1,4 @@
+kind: compose
+
+build-depends:
+- layer2.bst
diff --git a/tests/sysroot_depends/project/elements/integration.bst b/tests/sysroot_depends/project/elements/integration.bst
new file mode 100644
index 0000000..e2299b9
--- /dev/null
+++ b/tests/sysroot_depends/project/elements/integration.bst
@@ -0,0 +1,13 @@
+kind: manual
+
+depends:
+- base.bst
+
+config:
+ install-commands:
+ - echo 0 >"%{install-root}/integrated.txt"
+
+public:
+ bst:
+ integration-commands:
+ - echo 1 >/integrated.txt
diff --git a/tests/sysroot_depends/project/elements/layer1-files.bst b/tests/sysroot_depends/project/elements/layer1-files.bst
new file mode 100644
index 0000000..944d800
--- /dev/null
+++ b/tests/sysroot_depends/project/elements/layer1-files.bst
@@ -0,0 +1,4 @@
+kind: import
+sources:
+- kind: local
+ path: files/layer1
diff --git a/tests/sysroot_depends/project/elements/layer1.bst b/tests/sysroot_depends/project/elements/layer1.bst
new file mode 100644
index 0000000..5d72f78
--- /dev/null
+++ b/tests/sysroot_depends/project/elements/layer1.bst
@@ -0,0 +1,4 @@
+kind: stack
+
+depends:
+- layer1-files.bst
diff --git a/tests/sysroot_depends/project/elements/layer2-files.bst b/tests/sysroot_depends/project/elements/layer2-files.bst
new file mode 100644
index 0000000..435877d
--- /dev/null
+++ b/tests/sysroot_depends/project/elements/layer2-files.bst
@@ -0,0 +1,4 @@
+kind: import
+sources:
+- kind: local
+ path: files/layer2
diff --git a/tests/sysroot_depends/project/elements/layer2.bst b/tests/sysroot_depends/project/elements/layer2.bst
new file mode 100644
index 0000000..19fa166
--- /dev/null
+++ b/tests/sysroot_depends/project/elements/layer2.bst
@@ -0,0 +1,22 @@
+kind: manual
+
+depends:
+- layer2-files.bst
+
+build-depends:
+- base.bst
+
+config:
+ sysroots:
+ - path: /sysroot
+ depends:
+ - layer1.bst
+
+ install-commands:
+ - mkdir -p "%{install-root}"
+ - |
+ for file in /*; do
+ if test -f "${file}"; then
+ cp "${file}" "%{install-root}"
+ fi
+ done
diff --git a/tests/sysroot_depends/project/elements/manual-integration-runtime.bst b/tests/sysroot_depends/project/elements/manual-integration-runtime.bst
new file mode 100644
index 0000000..0abf89e
--- /dev/null
+++ b/tests/sysroot_depends/project/elements/manual-integration-runtime.bst
@@ -0,0 +1,14 @@
+kind: manual
+
+depends:
+- base.bst
+
+config:
+ sysroots:
+ - path: /sysroot
+ depends:
+ - integration.bst
+
+ install-commands:
+ - mkdir -p "%{install-root}"
+ - echo dummy >"%{install-root}/dummy.txt"
diff --git a/tests/sysroot_depends/project/elements/manual-integration.bst b/tests/sysroot_depends/project/elements/manual-integration.bst
new file mode 100644
index 0000000..218a7c9
--- /dev/null
+++ b/tests/sysroot_depends/project/elements/manual-integration.bst
@@ -0,0 +1,15 @@
+kind: manual
+
+build-depends:
+- base.bst
+
+config:
+ sysroots:
+ - path: /sysroot
+ build-depends:
+ - integration.bst
+
+ install-commands:
+ - mkdir -p "%{install-root}/sysroot"
+ - if test -f /sysroot/integrated.txt; then cp /sysroot/integrated.txt "%{install-root}/sysroot"; fi
+ - if test -f /integrated.txt; then cp /integrated.txt "%{install-root}"; fi
diff --git a/tests/sysroot_depends/project/elements/sysroot-integration.bst b/tests/sysroot_depends/project/elements/sysroot-integration.bst
new file mode 100644
index 0000000..0d2e440
--- /dev/null
+++ b/tests/sysroot_depends/project/elements/sysroot-integration.bst
@@ -0,0 +1,10 @@
+kind: manual
+
+variables:
+ install-root: "/"
+
+config:
+ sysroots:
+ - path: /sysroot
+ build-depends:
+ - integration.bst
diff --git a/tests/sysroot_depends/project/elements/target-variable.bst b/tests/sysroot_depends/project/elements/target-variable.bst
new file mode 100644
index 0000000..a4568ce
--- /dev/null
+++ b/tests/sysroot_depends/project/elements/target-variable.bst
@@ -0,0 +1,14 @@
+kind: manual
+
+build-depends:
+- base.bst
+
+variables:
+ mydir: test
+ install-root: "/path"
+
+config:
+ sysroots:
+ - path: "/path/%{mydir}"
+ build-depends:
+ - b.bst
diff --git a/tests/sysroot_depends/project/elements/target.bst b/tests/sysroot_depends/project/elements/target.bst
new file mode 100644
index 0000000..5c215e4
--- /dev/null
+++ b/tests/sysroot_depends/project/elements/target.bst
@@ -0,0 +1,14 @@
+kind: manual
+
+build-depends:
+- base.bst
+- a.bst
+
+variables:
+ install-root: '/'
+
+config:
+ sysroots:
+ - path: /sysroot
+ build-depends:
+ - b.bst
diff --git a/tests/sysroot_depends/project/files/a/a.txt b/tests/sysroot_depends/project/files/a/a.txt
new file mode 100644
index 0000000..9daeafb
--- /dev/null
+++ b/tests/sysroot_depends/project/files/a/a.txt
@@ -0,0 +1 @@
+test
diff --git a/tests/sysroot_depends/project/files/b/b.txt b/tests/sysroot_depends/project/files/b/b.txt
new file mode 100644
index 0000000..9daeafb
--- /dev/null
+++ b/tests/sysroot_depends/project/files/b/b.txt
@@ -0,0 +1 @@
+test
diff --git a/tests/sysroot_depends/project/files/layer1/1 b/tests/sysroot_depends/project/files/layer1/1
new file mode 100644
index 0000000..d00491f
--- /dev/null
+++ b/tests/sysroot_depends/project/files/layer1/1
@@ -0,0 +1 @@
+1
diff --git a/tests/sysroot_depends/project/files/layer2/2 b/tests/sysroot_depends/project/files/layer2/2
new file mode 100644
index 0000000..0cfbf08
--- /dev/null
+++ b/tests/sysroot_depends/project/files/layer2/2
@@ -0,0 +1 @@
+2
diff --git a/tests/sysroot_depends/project/project.conf b/tests/sysroot_depends/project/project.conf
new file mode 100644
index 0000000..e479168
--- /dev/null
+++ b/tests/sysroot_depends/project/project.conf
@@ -0,0 +1,9 @@
+name: test
+element-path: elements
+aliases:
+ alpine: https://bst-integration-test-images.ams3.cdn.digitaloceanspaces.com/
+options:
+ linux:
+ type: bool
+ description: Whether to expect a linux platform
+ default: True
diff --git a/tests/sysroot_depends/sysroot_depends.py b/tests/sysroot_depends/sysroot_depends.py
new file mode 100644
index 0000000..3dabecf
--- /dev/null
+++ b/tests/sysroot_depends/sysroot_depends.py
@@ -0,0 +1,176 @@
+import os
+import pytest
+from tests.testutils import cli_integration as cli
+from tests.testutils.site import IS_LINUX, HAVE_BWRAP
+
+
+# Project directory
+DATA_DIR = os.path.join(
+ os.path.dirname(os.path.realpath(__file__)),
+ "project",
+)
+
+
+@pytest.mark.integration
+@pytest.mark.skipif(IS_LINUX and not HAVE_BWRAP, reason='Only available with bubblewrap on Linux')
+@pytest.mark.datafiles(DATA_DIR)
+def test_sysroot_dependency_smoke_test(datafiles, cli, tmpdir):
+ "Test simple sysroot use case without integration"
+
+ project = str(datafiles)
+ checkout = os.path.join(str(tmpdir), 'checkout')
+
+ result = cli.run(project=project,
+ args=['build', 'target.bst'])
+ result.assert_success()
+
+ result = cli.run(project=project,
+ args=['checkout', 'target.bst', checkout])
+ result.assert_success()
+ assert os.path.exists(os.path.join(checkout, 'a.txt'))
+ assert os.path.exists(os.path.join(checkout, 'sysroot', 'b.txt'))
+
+
+@pytest.mark.integration
+@pytest.mark.skipif(IS_LINUX and not HAVE_BWRAP, reason='Only available with bubblewrap on Linux')
+@pytest.mark.datafiles(DATA_DIR)
+def test_skip_integration_commands_build_element(datafiles, cli, tmpdir):
+ "Integration commands are not run on sysroots"
+
+ project = str(datafiles)
+ checkout = os.path.join(str(tmpdir), 'checkout')
+
+ result = cli.run(project=project,
+ args=['build', 'manual-integration.bst'])
+ result.assert_success()
+
+ result = cli.run(project=project,
+ args=['checkout', 'manual-integration.bst', checkout])
+ result.assert_success()
+
+ sysroot_integrated = os.path.join(checkout, 'sysroot', 'integrated.txt')
+ integrated = os.path.join(checkout, 'integrated.txt')
+ assert os.path.exists(sysroot_integrated)
+ with open(sysroot_integrated, 'r') as f:
+ assert f.read() == '0\n'
+ # We need to make sure that integration command has not been run on / either.
+ assert not os.path.exists(integrated)
+
+
+@pytest.mark.integration
+@pytest.mark.skipif(IS_LINUX and not HAVE_BWRAP, reason='Only available with bubblewrap on Linux')
+@pytest.mark.datafiles(DATA_DIR)
+def test_sysroot_only_for_build(cli, tmpdir, datafiles):
+ project = str(datafiles)
+ checkout = os.path.join(str(tmpdir), 'checkout')
+
+ result = cli.run(project=project,
+ args=['build', 'compose-layers.bst'])
+ result.assert_success()
+
+ result = cli.run(project=project,
+ args=['checkout', 'compose-layers.bst', checkout])
+
+ result.assert_success()
+ assert os.path.exists(os.path.join(checkout, '1'))
+ assert os.path.exists(os.path.join(checkout, '2'))
+ assert not os.path.exists(os.path.join(checkout, 'sysroot', '1'))
+
+
+@pytest.mark.integration
+@pytest.mark.skipif(IS_LINUX and not HAVE_BWRAP, reason='Only available with bubblewrap on Linux')
+@pytest.mark.datafiles(DATA_DIR)
+def test_sysroot_only_for_build_with_sysroot(cli, tmpdir, datafiles):
+ project = str(datafiles)
+ checkout = os.path.join(str(tmpdir), 'checkout')
+
+ result = cli.run(project=project,
+ args=['build', 'compose-layers-with-sysroot.bst'])
+ result.assert_success()
+
+ result = cli.run(project=project,
+ args=['checkout', 'compose-layers-with-sysroot.bst', checkout])
+
+ result.assert_success()
+ assert os.path.exists(os.path.join(checkout, 'other-sysroot', '1'))
+ assert os.path.exists(os.path.join(checkout, 'other-sysroot', '2'))
+ assert not os.path.exists(os.path.join(checkout, 'sysroot', '1'))
+
+
+@pytest.mark.integration
+@pytest.mark.skipif(IS_LINUX and not HAVE_BWRAP, reason='Only available with bubblewrap on Linux')
+@pytest.mark.datafiles(DATA_DIR)
+def test_shell_no_sysroot(cli, tmpdir, datafiles):
+ "bst shell does not have sysroots and dependencies are integrated"
+
+ project = str(datafiles)
+
+ result = cli.run(project=project,
+ args=['build', 'base.bst', 'manual-integration-runtime.bst'])
+ result.assert_success()
+
+ result = cli.run(project=project,
+ args=['shell', 'manual-integration-runtime.bst', '--', 'cat', '/integrated.txt'])
+ result.assert_success()
+ assert result.output == '1\n'
+
+ result = cli.run(project=project,
+ args=['shell', 'manual-integration-runtime.bst', '--', 'ls', '/sysroot/integrated.txt'])
+ assert result.exit_code != 0
+ assert result.output == ''
+
+
+@pytest.mark.integration
+@pytest.mark.skipif(IS_LINUX and not HAVE_BWRAP, reason='Only available with bubblewrap on Linux')
+@pytest.mark.datafiles(DATA_DIR)
+def test_shell_build_sysroot(cli, tmpdir, datafiles):
+ "Build shell should stage build dependencies sysroot'ed non integrated"
+
+ project = str(datafiles)
+
+ result = cli.run(project=project,
+ args=['build', 'base.bst', 'integration.bst'])
+ result.assert_success()
+
+ result = cli.run(project=project,
+ args=['shell', '-b', 'manual-integration.bst', '--', 'cat', '/sysroot/integrated.txt'])
+ result.assert_success()
+ assert result.output == '0\n'
+
+
+@pytest.mark.integration
+@pytest.mark.datafiles(DATA_DIR)
+def test_show_dependencies_only_once(cli, tmpdir, datafiles):
+ """Dependencies should not show up in status several times when they
+ are staged with multiple sysroots"""
+
+ project = str(datafiles)
+
+ result = cli.run(project=project,
+ args=['show', '--format', '%{name}', 'manual-integration.bst'])
+ result.assert_success()
+ pipeline = result.output.splitlines()
+ assert pipeline == ['base/base-alpine.bst',
+ 'base.bst',
+ 'integration.bst',
+ 'manual-integration.bst']
+
+
+@pytest.mark.integration
+@pytest.mark.skipif(IS_LINUX and not HAVE_BWRAP, reason='Only available with bubblewrap on Linux')
+@pytest.mark.datafiles(DATA_DIR)
+def test_sysroot_path_subst_variable(datafiles, cli, tmpdir):
+ "Test that variables are expanded in sysroot path"
+
+ project = str(datafiles)
+ checkout = os.path.join(str(tmpdir), 'checkout')
+
+ result = cli.run(project=project,
+ args=['build', 'target-variable.bst'])
+ result.assert_success()
+
+ result = cli.run(project=project,
+ args=['checkout', 'target-variable.bst', checkout])
+ result.assert_success()
+
+ assert os.path.exists(os.path.join(checkout, 'test', 'b.txt'))
