Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
# Makefile for Docker tests
|
|
|
|
|
|
2021-02-02 16:39:50 +03:00
|
|
|
.PHONY: docker docker-help docker-test docker-clean docker-image docker-qemu-src
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
|
2020-09-01 19:10:05 +03:00
|
|
|
NULL :=
|
|
|
|
|
SPACE := $(NULL) #
|
|
|
|
|
COMMA := ,
|
|
|
|
|
|
2019-10-07 22:03:44 +03:00
|
|
|
HOST_ARCH = $(if $(ARCH),$(ARCH),$(shell uname -m))
|
|
|
|
|
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
DOCKER_SUFFIX := .docker
|
|
|
|
|
DOCKER_FILES_DIR := $(SRC_PATH)/tests/docker/dockerfiles
|
2018-06-28 19:46:41 +03:00
|
|
|
# we don't run tests on intermediate images (used as base by another image)
|
2021-10-26 13:22:15 +03:00
|
|
|
DOCKER_PARTIAL_IMAGES := debian10 debian11
|
|
|
|
|
# we don't directly build virtual images (they are used to build other images)
|
|
|
|
|
DOCKER_VIRTUAL_IMAGES := debian-bootstrap debian-toolchain empty
|
|
|
|
|
DOCKER_IMAGES := $(sort $(filter-out $(DOCKER_VIRTUAL_IMAGES), $(notdir $(basename $(wildcard $(DOCKER_FILES_DIR)/*.docker)))))
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
DOCKER_TARGETS := $(patsubst %,docker-image-%,$(DOCKER_IMAGES))
|
|
|
|
|
# Use a global constant ccache directory to speed up repetitive builds
|
|
|
|
|
DOCKER_CCACHE_DIR := $$HOME/.cache/qemu-docker-ccache
|
2021-04-01 13:25:21 +03:00
|
|
|
ifeq ($(HOST_ARCH),x86_64)
|
|
|
|
|
DOCKER_DEFAULT_REGISTRY := registry.gitlab.com/qemu-project/qemu
|
|
|
|
|
endif
|
|
|
|
|
DOCKER_REGISTRY := $(if $(REGISTRY),$(REGISTRY),$(DOCKER_DEFAULT_REGISTRY))
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
|
|
|
|
|
DOCKER_TESTS := $(notdir $(shell \
|
|
|
|
|
find $(SRC_PATH)/tests/docker/ -name 'test-*' -type f))
|
|
|
|
|
|
2019-05-23 18:37:51 +03:00
|
|
|
ENGINE := auto
|
|
|
|
|
|
|
|
|
|
DOCKER_SCRIPT=$(SRC_PATH)/tests/docker/docker.py --engine $(ENGINE)
|
2018-04-06 18:25:39 +03:00
|
|
|
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
TESTS ?= %
|
|
|
|
|
IMAGES ?= %
|
|
|
|
|
|
|
|
|
|
CUR_TIME := $(shell date +%Y-%m-%d-%H.%M.%S.$$$$)
|
2017-10-18 16:06:29 +03:00
|
|
|
DOCKER_SRC_COPY := $(BUILD_DIR)/docker-src.$(CUR_TIME)
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
|
2018-08-18 06:03:37 +03:00
|
|
|
.DELETE_ON_ERROR: $(DOCKER_SRC_COPY)
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
$(DOCKER_SRC_COPY):
|
|
|
|
|
@mkdir $@
|
2018-07-12 04:28:28 +03:00
|
|
|
$(if $(SRC_ARCHIVE), \
|
|
|
|
|
$(call quiet-command, cp "$(SRC_ARCHIVE)" $@/qemu.tar, \
|
|
|
|
|
"CP", "$@/qemu.tar"), \
|
|
|
|
|
$(call quiet-command, cd $(SRC_PATH) && scripts/archive-source.sh $@/qemu.tar, \
|
|
|
|
|
"GEN", "$@/qemu.tar"))
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
$(call quiet-command, cp $(SRC_PATH)/tests/docker/run $@/run, \
|
2016-10-04 19:27:21 +03:00
|
|
|
"COPY","RUNNER")
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
|
|
|
|
|
docker-qemu-src: $(DOCKER_SRC_COPY)
|
|
|
|
|
|
|
|
|
|
docker-image: ${DOCKER_TARGETS}
|
|
|
|
|
|
2018-06-15 21:20:55 +03:00
|
|
|
# General rule for building docker images. If we are a sub-make
|
2018-07-13 08:47:55 +03:00
|
|
|
# invoked with SKIP_DOCKER_BUILD we still check the image is up to date
|
2018-06-15 21:20:55 +03:00
|
|
|
# though
|
|
|
|
|
ifdef SKIP_DOCKER_BUILD
|
|
|
|
|
docker-image-%: $(DOCKER_FILES_DIR)/%.docker
|
|
|
|
|
$(call quiet-command, \
|
2020-07-01 16:56:29 +03:00
|
|
|
$(DOCKER_SCRIPT) check --quiet qemu/$* $<, \
|
2018-06-15 21:20:55 +03:00
|
|
|
"CHECK", "$*")
|
|
|
|
|
else
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
docker-image-%: $(DOCKER_FILES_DIR)/%.docker
|
|
|
|
|
$(call quiet-command,\
|
2020-07-01 16:56:29 +03:00
|
|
|
$(DOCKER_SCRIPT) build -t qemu/$* -f $< \
|
2020-07-01 16:56:36 +03:00
|
|
|
$(if $V,,--quiet) \
|
|
|
|
|
$(if $(NOCACHE),--no-cache, \
|
|
|
|
|
$(if $(DOCKER_REGISTRY),--registry $(DOCKER_REGISTRY))) \
|
2017-02-20 13:51:36 +03:00
|
|
|
$(if $(NOUSER),,--add-current-user) \
|
2017-06-02 21:56:08 +03:00
|
|
|
$(if $(EXTRA_FILES),--extra-files $(EXTRA_FILES))\
|
2016-07-19 16:20:45 +03:00
|
|
|
$(if $(EXECUTABLE),--include-executable=$(EXECUTABLE)),\
|
2016-10-04 19:27:21 +03:00
|
|
|
"BUILD","$*")
|
2018-06-29 19:57:57 +03:00
|
|
|
|
|
|
|
|
# Special rule for debootstraped binfmt linux-user images
|
|
|
|
|
docker-binfmt-image-debian-%: $(DOCKER_FILES_DIR)/debian-bootstrap.docker
|
|
|
|
|
$(if $(EXECUTABLE),,\
|
|
|
|
|
$(error EXECUTABLE not set, debootstrap of debian-$* would fail))
|
|
|
|
|
$(if $(DEB_ARCH),,\
|
|
|
|
|
$(error DEB_ARCH not set, debootstrap of debian-$* would fail))
|
|
|
|
|
$(if $(DEB_TYPE),,\
|
|
|
|
|
$(error DEB_TYPE not set, debootstrap of debian-$* would fail))
|
2018-07-12 12:35:54 +03:00
|
|
|
$(if $(wildcard $(EXECUTABLE)), \
|
2018-06-29 22:41:26 +03:00
|
|
|
$(call quiet-command, \
|
|
|
|
|
DEB_ARCH=$(DEB_ARCH) \
|
2019-09-09 13:11:49 +03:00
|
|
|
DEB_TYPE=$(DEB_TYPE) \
|
|
|
|
|
$(if $(DEB_URL),DEB_URL=$(DEB_URL),) \
|
2020-07-24 09:45:03 +03:00
|
|
|
$(DOCKER_SCRIPT) build -t qemu/debian-$* -f $< \
|
2018-06-29 22:41:26 +03:00
|
|
|
$(if $V,,--quiet) $(if $(NOCACHE),--no-cache) \
|
|
|
|
|
$(if $(NOUSER),,--add-current-user) \
|
|
|
|
|
$(if $(EXTRA_FILES),--extra-files $(EXTRA_FILES)) \
|
|
|
|
|
$(if $(EXECUTABLE),--include-executable=$(EXECUTABLE)), \
|
|
|
|
|
"BUILD","binfmt debian-$* (debootstrapped)"), \
|
|
|
|
|
$(call quiet-command, \
|
2020-07-01 16:56:29 +03:00
|
|
|
$(DOCKER_SCRIPT) check --quiet qemu/debian-$* $< || \
|
2018-07-12 16:36:18 +03:00
|
|
|
{ echo "You will need to build $(EXECUTABLE)"; exit 1;},\
|
2018-06-29 22:41:26 +03:00
|
|
|
"CHECK", "debian-$* exists"))
|
2018-06-29 19:57:57 +03:00
|
|
|
|
2021-02-02 16:39:51 +03:00
|
|
|
# These are test targets
|
|
|
|
|
USER_TCG_TARGETS=$(patsubst %-linux-user,qemu-%,$(filter %-linux-user,$(TARGET_DIRS)))
|
|
|
|
|
EXEC_COPY_TESTS=$(patsubst %,docker-exec-copy-test-%, $(USER_TCG_TARGETS))
|
|
|
|
|
|
|
|
|
|
$(EXEC_COPY_TESTS): docker-exec-copy-test-%: $(DOCKER_FILES_DIR)/empty.docker
|
|
|
|
|
$(call quiet-command, \
|
|
|
|
|
$(DOCKER_SCRIPT) build -t qemu/exec-copy-test-$* -f $< \
|
|
|
|
|
$(if $V,,--quiet) --no-cache \
|
|
|
|
|
--include-executable=$* \
|
|
|
|
|
--skip-binfmt, \
|
|
|
|
|
"TEST","copy $* to container")
|
|
|
|
|
$(call quiet-command, \
|
|
|
|
|
$(DOCKER_SCRIPT) run qemu/exec-copy-test-$* \
|
|
|
|
|
/$* -version > tests/docker-exec-copy-test-$*.out, \
|
|
|
|
|
"TEST","check $* works in container")
|
|
|
|
|
|
|
|
|
|
docker-exec-copy-test: $(EXEC_COPY_TESTS)
|
|
|
|
|
|
2018-06-15 21:20:55 +03:00
|
|
|
endif
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
|
2018-05-08 17:43:58 +03:00
|
|
|
# Enforce dependencies for composite images
|
2019-10-07 22:03:44 +03:00
|
|
|
ifeq ($(HOST_ARCH),x86_64)
|
2020-02-03 12:09:16 +03:00
|
|
|
docker-image-debian-amd64: docker-image-debian10
|
2019-08-14 18:25:50 +03:00
|
|
|
DOCKER_PARTIAL_IMAGES += debian-amd64-cross
|
|
|
|
|
else
|
|
|
|
|
docker-image-debian-amd64-cross: docker-image-debian10
|
|
|
|
|
DOCKER_PARTIAL_IMAGES += debian-amd64
|
|
|
|
|
endif
|
2018-04-23 15:54:09 +03:00
|
|
|
|
2019-08-15 22:40:48 +03:00
|
|
|
# For non-x86 hosts not all cross-compilers have been packaged
|
2019-10-07 22:03:44 +03:00
|
|
|
ifneq ($(HOST_ARCH),x86_64)
|
2019-08-15 22:40:48 +03:00
|
|
|
DOCKER_PARTIAL_IMAGES += debian-mips-cross debian-mipsel-cross debian-mips64el-cross
|
|
|
|
|
DOCKER_PARTIAL_IMAGES += debian-ppc64el-cross
|
|
|
|
|
DOCKER_PARTIAL_IMAGES += debian-s390x-cross
|
2021-02-11 15:27:43 +03:00
|
|
|
DOCKER_PARTIAL_IMAGES += fedora
|
2019-08-15 22:40:48 +03:00
|
|
|
endif
|
|
|
|
|
|
2019-08-12 17:47:10 +03:00
|
|
|
docker-image-debian-alpha-cross: docker-image-debian10
|
2019-08-12 17:08:28 +03:00
|
|
|
docker-image-debian-arm64-cross: docker-image-debian10
|
2020-02-03 12:09:16 +03:00
|
|
|
docker-image-debian-armel-cross: docker-image-debian10
|
|
|
|
|
docker-image-debian-armhf-cross: docker-image-debian10
|
2019-08-12 17:55:57 +03:00
|
|
|
docker-image-debian-hppa-cross: docker-image-debian10
|
2019-08-12 19:07:37 +03:00
|
|
|
docker-image-debian-m68k-cross: docker-image-debian10
|
2020-02-03 12:09:16 +03:00
|
|
|
docker-image-debian-mips-cross: docker-image-debian10
|
2019-08-13 17:47:50 +03:00
|
|
|
docker-image-debian-mips64-cross: docker-image-debian10
|
2020-02-03 12:09:16 +03:00
|
|
|
docker-image-debian-mips64el-cross: docker-image-debian10
|
|
|
|
|
docker-image-debian-mipsel-cross: docker-image-debian10
|
|
|
|
|
docker-image-debian-ppc64el-cross: docker-image-debian10
|
|
|
|
|
docker-image-debian-s390x-cross: docker-image-debian10
|
2019-08-13 17:24:32 +03:00
|
|
|
docker-image-debian-sh4-cross: docker-image-debian10
|
2019-08-13 17:16:48 +03:00
|
|
|
docker-image-debian-sparc64-cross: docker-image-debian10
|
2019-08-12 17:08:28 +03:00
|
|
|
|
2021-09-22 18:15:27 +03:00
|
|
|
# The native build should never use the registry
|
|
|
|
|
docker-image-debian-native: DOCKER_REGISTRY=
|
|
|
|
|
|
2021-11-15 17:29:10 +03:00
|
|
|
# base images should not add a local user
|
|
|
|
|
docker-image-debian10: NOUSER=1
|
|
|
|
|
docker-image-debian11: NOUSER=1
|
2021-09-22 18:15:27 +03:00
|
|
|
|
2021-05-12 13:20:26 +03:00
|
|
|
#
|
|
|
|
|
# The build rule for hexagon-cross is special in so far for most of
|
|
|
|
|
# the time we don't want to build it. While dockers caching does avoid
|
|
|
|
|
# this most of the time sometimes we want to force the issue.
|
|
|
|
|
#
|
|
|
|
|
docker-image-debian-hexagon-cross: $(DOCKER_FILES_DIR)/debian-hexagon-cross.docker
|
|
|
|
|
$(if $(NOCACHE), \
|
|
|
|
|
$(call quiet-command, \
|
|
|
|
|
$(DOCKER_SCRIPT) build -t qemu/debian-hexagon-cross -f $< \
|
|
|
|
|
$(if $V,,--quiet) --no-cache \
|
|
|
|
|
--registry $(DOCKER_REGISTRY) --extra-files \
|
|
|
|
|
$(DOCKER_FILES_DIR)/debian-hexagon-cross.docker.d/build-toolchain.sh, \
|
|
|
|
|
"BUILD", "debian-hexagon-cross"), \
|
|
|
|
|
$(call quiet-command, \
|
|
|
|
|
$(DOCKER_SCRIPT) fetch $(if $V,,--quiet) \
|
|
|
|
|
qemu/debian-hexagon-cross $(DOCKER_REGISTRY), \
|
|
|
|
|
"FETCH", "debian-hexagon-cross") \
|
|
|
|
|
$(call quiet-command, \
|
|
|
|
|
$(DOCKER_SCRIPT) update $(if $V,,--quiet) \
|
|
|
|
|
qemu/debian-hexagon-cross --add-current-user, \
|
|
|
|
|
"PREPARE", "debian-hexagon-cross"))
|
|
|
|
|
|
2021-10-26 13:22:11 +03:00
|
|
|
debian-toolchain-run = \
|
|
|
|
|
$(if $(NOCACHE), \
|
|
|
|
|
$(call quiet-command, \
|
|
|
|
|
$(DOCKER_SCRIPT) build -t qemu/$1 -f $< \
|
|
|
|
|
$(if $V,,--quiet) --no-cache \
|
|
|
|
|
--registry $(DOCKER_REGISTRY) --extra-files \
|
|
|
|
|
$(DOCKER_FILES_DIR)/$1.d/build-toolchain.sh, \
|
|
|
|
|
"BUILD", $1), \
|
|
|
|
|
$(call quiet-command, \
|
|
|
|
|
$(DOCKER_SCRIPT) fetch $(if $V,,--quiet) \
|
|
|
|
|
qemu/$1 $(DOCKER_REGISTRY), \
|
|
|
|
|
"FETCH", $1) \
|
|
|
|
|
$(call quiet-command, \
|
|
|
|
|
$(DOCKER_SCRIPT) update $(if $V,,--quiet) \
|
|
|
|
|
qemu/$1 \
|
|
|
|
|
$(if $(NOUSER),,--add-current-user) \
|
|
|
|
|
"PREPARE", $1))
|
|
|
|
|
debian-toolchain = $(call debian-toolchain-run,$(patsubst docker-image-%,%,$1))
|
|
|
|
|
|
2021-10-26 13:22:12 +03:00
|
|
|
docker-image-debian-microblaze-cross: $(DOCKER_FILES_DIR)/debian-toolchain.docker \
|
|
|
|
|
$(DOCKER_FILES_DIR)/debian-microblaze-cross.d/build-toolchain.sh
|
|
|
|
|
$(call debian-toolchain, $@)
|
|
|
|
|
|
2021-10-26 13:22:11 +03:00
|
|
|
docker-image-debian-nios2-cross: $(DOCKER_FILES_DIR)/debian-toolchain.docker \
|
|
|
|
|
$(DOCKER_FILES_DIR)/debian-nios2-cross.d/build-toolchain.sh
|
|
|
|
|
$(call debian-toolchain, $@)
|
|
|
|
|
|
2018-05-02 03:21:43 +03:00
|
|
|
# Specialist build images, sometimes very limited tools
|
2020-09-25 18:40:23 +03:00
|
|
|
docker-image-debian-tricore-cross: docker-image-debian10
|
2020-07-01 16:56:44 +03:00
|
|
|
docker-image-debian-all-test-cross: docker-image-debian10
|
2020-05-20 17:05:36 +03:00
|
|
|
docker-image-debian-arm64-test-cross: docker-image-debian11
|
2021-10-26 13:22:12 +03:00
|
|
|
docker-image-debian-microblaze-cross: docker-image-debian10
|
2021-10-26 13:22:11 +03:00
|
|
|
docker-image-debian-nios2-cross: docker-image-debian10
|
2021-05-12 13:20:46 +03:00
|
|
|
docker-image-debian-powerpc-test-cross: docker-image-debian11
|
2018-05-02 03:21:43 +03:00
|
|
|
|
2018-07-09 13:51:57 +03:00
|
|
|
# These images may be good enough for building tests but not for test builds
|
2019-08-13 19:09:43 +03:00
|
|
|
DOCKER_PARTIAL_IMAGES += debian-alpha-cross
|
2020-05-20 17:05:36 +03:00
|
|
|
DOCKER_PARTIAL_IMAGES += debian-arm64-test-cross
|
2021-05-12 13:20:46 +03:00
|
|
|
DOCKER_PARTIAL_IMAGES += debian-powerpc-test-cross
|
2019-08-13 19:09:43 +03:00
|
|
|
DOCKER_PARTIAL_IMAGES += debian-hppa-cross
|
|
|
|
|
DOCKER_PARTIAL_IMAGES += debian-m68k-cross debian-mips64-cross
|
2021-10-26 13:22:12 +03:00
|
|
|
DOCKER_PARTIAL_IMAGES += debian-microblaze-cross
|
2021-10-26 13:22:11 +03:00
|
|
|
DOCKER_PARTIAL_IMAGES += debian-nios2-cross
|
2019-08-13 19:09:43 +03:00
|
|
|
DOCKER_PARTIAL_IMAGES += debian-sh4-cross debian-sparc64-cross
|
|
|
|
|
DOCKER_PARTIAL_IMAGES += debian-tricore-cross
|
|
|
|
|
DOCKER_PARTIAL_IMAGES += debian-xtensa-cross
|
2021-09-30 19:36:35 +03:00
|
|
|
DOCKER_PARTIAL_IMAGES += fedora-cris-cross
|
2018-07-09 13:51:57 +03:00
|
|
|
|
2018-06-29 22:41:26 +03:00
|
|
|
# Rules for building linux-user powered images
|
|
|
|
|
#
|
|
|
|
|
# These are slower than using native cross compiler setups but can
|
|
|
|
|
# work around issues with poorly working multi-arch systems and broken
|
|
|
|
|
# packages.
|
|
|
|
|
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
# Expand all the pre-requistes for each docker image and test combination
|
2021-10-26 13:22:15 +03:00
|
|
|
$(foreach i,$(filter-out $(DOCKER_PARTIAL_IMAGES) $(DOCKER_VIRTUAL_IMAGES),$(DOCKER_IMAGES)), \
|
2021-02-11 15:27:43 +03:00
|
|
|
$(foreach t,$(DOCKER_TESTS), \
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
$(eval .PHONY: docker-$t@$i) \
|
|
|
|
|
$(eval docker-$t@$i: docker-image-$i docker-run-$t@$i) \
|
|
|
|
|
) \
|
|
|
|
|
$(foreach t,$(DOCKER_TESTS), \
|
2018-07-09 15:24:52 +03:00
|
|
|
$(eval docker-all-tests: docker-$t@$i) \
|
|
|
|
|
$(eval docker-$t: docker-$t@$i) \
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
) \
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
docker:
|
2019-05-23 18:37:51 +03:00
|
|
|
@echo 'Build QEMU and run tests inside Docker or Podman containers'
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
@echo
|
|
|
|
|
@echo 'Available targets:'
|
|
|
|
|
@echo
|
|
|
|
|
@echo ' docker: Print this help.'
|
2018-07-09 15:24:52 +03:00
|
|
|
@echo ' docker-all-tests: Run all image/test combinations.'
|
2019-03-22 00:25:28 +03:00
|
|
|
@echo ' docker-TEST: Run "TEST" on all image combinations.'
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
@echo ' docker-clean: Kill and remove residual docker testing containers.'
|
|
|
|
|
@echo ' docker-TEST@IMAGE: Run "TEST" in container "IMAGE".'
|
|
|
|
|
@echo ' Note: "TEST" is one of the listed test name,'
|
|
|
|
|
@echo ' or a script name under $$QEMU_SRC/tests/docker/;'
|
2019-03-22 00:25:28 +03:00
|
|
|
@echo ' "IMAGE" is one of the listed container name.'
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
@echo ' docker-image: Build all images.'
|
|
|
|
|
@echo ' docker-image-IMAGE: Build image "IMAGE".'
|
2019-03-22 00:25:28 +03:00
|
|
|
@echo ' docker-run: For manually running a "TEST" with "IMAGE".'
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
@echo
|
|
|
|
|
@echo 'Available container images:'
|
|
|
|
|
@echo ' $(DOCKER_IMAGES)'
|
2018-06-29 22:41:26 +03:00
|
|
|
ifneq ($(DOCKER_USER_IMAGES),)
|
|
|
|
|
@echo
|
|
|
|
|
@echo 'Available linux-user images (docker-binfmt-image-debian-%):'
|
|
|
|
|
@echo ' $(DOCKER_USER_IMAGES)'
|
|
|
|
|
endif
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
@echo
|
|
|
|
|
@echo 'Available tests:'
|
|
|
|
|
@echo ' $(DOCKER_TESTS)'
|
|
|
|
|
@echo
|
|
|
|
|
@echo 'Special variables:'
|
|
|
|
|
@echo ' TARGET_LIST=a,b,c Override target list in builds.'
|
2016-06-01 07:25:27 +03:00
|
|
|
@echo ' EXTRA_CONFIGURE_OPTS="..."'
|
|
|
|
|
@echo ' Extra configure options.'
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
@echo ' IMAGES="a b c ..": Filters which images to build or run.'
|
|
|
|
|
@echo ' TESTS="x y z .." Filters which tests to run (for docker-test).'
|
|
|
|
|
@echo ' J=[0..9]* Overrides the -jN parameter for make commands'
|
|
|
|
|
@echo ' (default is 1)'
|
|
|
|
|
@echo ' DEBUG=1 Stop and drop to shell in the created container'
|
|
|
|
|
@echo ' before running the command.'
|
2017-07-13 17:43:52 +03:00
|
|
|
@echo ' NETWORK=1 Enable virtual network interface with default backend.'
|
2017-11-08 05:47:19 +03:00
|
|
|
@echo ' NETWORK=$$BACKEND Enable virtual network interface with $$BACKEND.'
|
2021-02-02 16:39:47 +03:00
|
|
|
@echo ' NOUSER=1 Define to disable adding current user to containers passwd.'
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
@echo ' NOCACHE=1 Ignore cache when build images.'
|
2016-07-19 16:20:45 +03:00
|
|
|
@echo ' EXECUTABLE=<path> Include executable in image.'
|
2017-06-02 21:56:08 +03:00
|
|
|
@echo ' EXTRA_FILES="<path> [... <path>]"'
|
|
|
|
|
@echo ' Include extra files in image.'
|
2019-05-23 18:37:51 +03:00
|
|
|
@echo ' ENGINE=auto/docker/podman'
|
|
|
|
|
@echo ' Specify which container engine to run.'
|
2020-07-01 16:56:36 +03:00
|
|
|
@echo ' REGISTRY=url Cache builds from registry (default:$(DOCKER_REGISTRY))'
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
|
2021-02-02 16:39:50 +03:00
|
|
|
docker-help: docker
|
|
|
|
|
|
2016-10-11 19:16:24 +03:00
|
|
|
# This rule if for directly running against an arbitrary docker target.
|
|
|
|
|
# It is called by the expanded docker targets (e.g. make
|
|
|
|
|
# docker-test-foo@bar) which will do additional verification.
|
|
|
|
|
#
|
|
|
|
|
# For example: make docker-run TEST="test-quick" IMAGE="debian:arm64" EXECUTABLE=./aarch64-linux-user/qemu-aarch64
|
|
|
|
|
#
|
|
|
|
|
docker-run: docker-qemu-src
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
@mkdir -p "$(DOCKER_CCACHE_DIR)"
|
2016-10-11 19:16:24 +03:00
|
|
|
@if test -z "$(IMAGE)" || test -z "$(TEST)"; \
|
|
|
|
|
then echo "Invalid target $(IMAGE)/$(TEST)"; exit 1; \
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
fi
|
2016-10-11 19:16:24 +03:00
|
|
|
$(if $(EXECUTABLE), \
|
|
|
|
|
$(call quiet-command, \
|
2018-04-06 18:25:39 +03:00
|
|
|
$(DOCKER_SCRIPT) update \
|
2021-05-12 13:20:23 +03:00
|
|
|
$(IMAGE) --executable $(EXECUTABLE), \
|
2016-10-11 19:16:24 +03:00
|
|
|
" COPYING $(EXECUTABLE) to $(IMAGE)"))
|
|
|
|
|
$(call quiet-command, \
|
2018-04-06 18:25:39 +03:00
|
|
|
$(DOCKER_SCRIPT) run \
|
2019-07-12 13:50:52 +03:00
|
|
|
$(if $(NOUSER),,--run-as-current-user) \
|
2017-09-05 05:56:11 +03:00
|
|
|
--security-opt seccomp=unconfined \
|
2017-10-13 04:19:54 +03:00
|
|
|
$(if $(DEBUG),-ti,) \
|
2017-07-13 17:43:52 +03:00
|
|
|
$(if $(NETWORK),$(if $(subst $(NETWORK),,1),--net=$(NETWORK)),--net=none) \
|
2018-05-21 13:35:04 +03:00
|
|
|
-e TARGET_LIST=$(subst $(SPACE),$(COMMA),$(TARGET_LIST)) \
|
2016-10-11 19:16:24 +03:00
|
|
|
-e EXTRA_CONFIGURE_OPTS="$(EXTRA_CONFIGURE_OPTS)" \
|
|
|
|
|
-e V=$V -e J=$J -e DEBUG=$(DEBUG) \
|
|
|
|
|
-e SHOW_ENV=$(SHOW_ENV) \
|
2017-09-25 10:54:58 +03:00
|
|
|
$(if $(NOUSER),, \
|
|
|
|
|
-e CCACHE_DIR=/var/tmp/ccache \
|
|
|
|
|
-v $(DOCKER_CCACHE_DIR):/var/tmp/ccache:z \
|
|
|
|
|
) \
|
2016-10-11 19:16:24 +03:00
|
|
|
-v $$(readlink -e $(DOCKER_SRC_COPY)):/var/tmp/qemu:z$(COMMA)ro \
|
|
|
|
|
$(IMAGE) \
|
|
|
|
|
/var/tmp/qemu/run \
|
|
|
|
|
$(TEST), " RUN $(TEST) in ${IMAGE}")
|
2017-10-17 10:12:46 +03:00
|
|
|
$(call quiet-command, rm -r $(DOCKER_SRC_COPY), \
|
|
|
|
|
" CLEANUP $(DOCKER_SRC_COPY)")
|
2016-10-11 19:16:24 +03:00
|
|
|
|
|
|
|
|
# Run targets:
|
|
|
|
|
#
|
|
|
|
|
# Of the form docker-TEST-FOO@IMAGE-BAR which will then be expanded into a call to "make docker-run"
|
|
|
|
|
docker-run-%: CMD = $(shell echo '$@' | sed -e 's/docker-run-\([^@]*\)@\(.*\)/\1/')
|
|
|
|
|
docker-run-%: IMAGE = $(shell echo '$@' | sed -e 's/docker-run-\([^@]*\)@\(.*\)/\2/')
|
|
|
|
|
docker-run-%:
|
2020-07-01 16:56:29 +03:00
|
|
|
@$(MAKE) docker-run TEST=$(CMD) IMAGE=qemu/$(IMAGE)
|
Makefile: Rules for docker testing
This adds a group of make targets to run docker tests, all are available
in source tree without running ./configure.
The usage is shown with "make docker".
Besides the fixed ones, dynamic targets for building each image and
running each test in each image are generated automatically by make,
scanning $(SRC_PATH)/tests/docker/ files with specific patterns.
Alternative to manually list particular targets (docker-TEST@IMAGE)
set, you can control which tests/images to run by filtering variables,
TESTS= and IMAGES=, which are expressed in Makefile pattern syntax,
"foo% %bar ...". For example:
$ make docker-test IMAGES="ubuntu fedora"
Unfortunately, it's impossible to propagate "-j $JOBS" into make in
containers, however since each combination is made a first class target
in the top Makefile, "make -j$N docker-test" still parallels the tests
coarsely.
Still, $J is made a magic variable to let all make invocations in
containers to use -j$J.
Instead of providing a live version of the source tree to the docker
container we snapshot it with git-archive. This ensures the tree is in a
pristine state for whatever operations the container is going to run on
them.
Uncommitted changes known to files known by the git index will be
included in the snapshot if there are any.
Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 1464755128-32490-5-git-send-email-famz@redhat.com
2016-06-01 07:25:17 +03:00
|
|
|
|
|
|
|
|
docker-clean:
|
2018-04-06 18:25:39 +03:00
|
|
|
$(call quiet-command, $(DOCKER_SCRIPT) clean)
|