blob: 466da277b595f8caff427234c651a6de7a773747 [file] [log] [blame]
#!/bin/bash
# Copyright 2018 The Bazel Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
CURRENT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
source "${CURRENT_DIR}/../integration_test_setup.sh" \
|| { echo "integration_test_setup.sh not found!" >&2; exit 1; }
# Bazel build arguments to disable the use of the sandbox. We have tests below
# that configure a fake sandboxfs and they would fail if they were to use it.
DISABLE_SANDBOX_ARGS=(
--genrule_strategy=local
--spawn_strategy=local
)
# Creates a fake sandboxfs process in "path" that logs interactions with it in
# the given "log" file and reports the given "version".
function create_fake_sandboxfs() {
local path="${1}"; shift
local log="${1}"; shift
local version="${1}"; shift
cat >"${path}" <<EOF
#!/bin/sh
rm -f "${log}"
trap 'echo "Terminated" >>"${log}"' EXIT TERM
echo "PID: \${$}" >>"${log}"
echo "ARGS: \${*}" >>"${log}"
if [ "\${1}" = --version ]; then
echo "${version}"
exit 0
fi
while read line; do
echo "Received: \${line}" >>"${log}"
if [ -z "\${line}" ]; then
echo "Done"
fi
done
EOF
chmod +x "${path}"
}
function create_hello_package() {
mkdir -p hello
cat >hello/BUILD <<EOF
cc_binary(name = "hello", srcs = ["hello.cc"])
EOF
cat >hello/hello.cc <<EOF
#include <stdio.h>
int main(void) { printf("Hello, world!\n"); return 0; }
EOF
}
function test_default_sandboxfs_from_path() {
mkdir -p fake-tools
create_fake_sandboxfs fake-tools/sandboxfs "$(pwd)/log" "sandboxfs 0.0.0"
PATH="$(pwd)/fake-tools:${PATH}"; export PATH
create_hello_package
# This test relies on a PATH change that is only recognized when the server
# first starts up, so ensure there are no Bazel servers left behind.
#
# TODO(philwo): This is awful. The testing infrastructure should ensure
# that tests cannot pollute each other's state, but at the moment that's not
# the case.
bazel shutdown
bazel build \
"${DISABLE_SANDBOX_ARGS[@]}" \
--experimental_use_sandboxfs \
//hello >"${TEST_log}" 2>&1 || fail "Build should have succeeded"
# Dump fake sandboxfs' log for debugging.
sed -e 's,^,SANDBOXFS: ,' log >>"${TEST_log}"
grep -q "Terminated" log \
|| fail "sandboxfs process was not terminated (not executed?)"
}
function test_explicit_sandboxfs_not_found() {
create_hello_package
bazel build \
--experimental_use_sandboxfs \
--experimental_sandboxfs_path="/non-existent/sandboxfs" \
//hello >"${TEST_log}" 2>&1 && fail "Build succeeded but should have failed"
expect_log "/non-existent/sandboxfs.*not be found"
}
function test_explicit_sandboxfs_is_invalid() {
mkdir -p fake-tools
create_hello_package
do_build() {
bazel build \
"${DISABLE_SANDBOX_ARGS[@]}" \
--experimental_use_sandboxfs=yes \
--experimental_sandboxfs_path="$(pwd)/fake-tools/sandboxfs" \
//hello
}
# Try with a binary that prints an invalid version string.
create_fake_sandboxfs fake-tools/sandboxfs "$(pwd)/log" "not-sandboxfs 0.0.0"
do_build >"${TEST_log}" 2>&1 && fail "Build should have failed"
# Now try with a valid binary just to ensure our test scenario works.
create_fake_sandboxfs fake-tools/sandboxfs "$(pwd)/log" "sandboxfs 0.0.0"
do_build >"${TEST_log}" 2>&1 || fail "Build should have succeeded"
sed -e 's,^,SANDBOXFS: ,' log >>"${TEST_log}"
grep -q "Terminated" log \
|| fail "sandboxfs process was not terminated (not executed?)"
}
function test_use_sandboxfs_if_present() {
# This test relies on a PATH change that is only recognized when the server
# first starts up, so ensure there are no Bazel servers left behind.
#
# TODO(philwo): This is awful. The testing infrastructure should ensure
# that tests cannot pollute each other's state, but at the moment that's not
# the case.
bazel shutdown
mkdir -p fake-tools
PATH="$(pwd)/fake-tools:${PATH}"; export PATH
create_hello_package
do_build() {
bazel build \
"${DISABLE_SANDBOX_ARGS[@]}" \
--experimental_use_sandboxfs=auto \
//hello
}
# Try with sandboxfs not in the PATH.
do_build >"${TEST_log}" 2>&1 || fail "Build should have succeeded"
[[ ! -f log ]] || echo "sandboxfs was used but should not have"
# Now try with sandboxfs in the PATH to ensure our test scenario works.
create_fake_sandboxfs fake-tools/sandboxfs "$(pwd)/log" "sandboxfs 0.0.0"
do_build >"${TEST_log}" 2>&1 || fail "Build should have succeeded"
sed -e 's,^,SANDBOXFS: ,' log >>"${TEST_log}"
grep -q "Terminated" log \
|| fail "sandboxfs process was not terminated (not executed?)"
}
# Runs a build of the given target using a fake sandboxfs that captures its
# activity and dumps it to the given log file.
function build_with_fake_sandboxfs() {
local log="${1}"; shift
create_fake_sandboxfs fake-sandboxfs.sh "${log}" "sandboxfs 0.0.0"
local ret=0
bazel build \
"${DISABLE_SANDBOX_ARGS[@]}" \
--experimental_use_sandboxfs \
--experimental_sandboxfs_path="$(pwd)/fake-sandboxfs.sh" \
"${@}" >"${TEST_log}" 2>&1 || ret="${?}"
# Dump fake sandboxfs' log for debugging.
sed -e 's,^,SANDBOXFS: ,' log >>"${TEST_log}"
return "${ret}"
}
function test_mount_unmount() {
create_hello_package
local output_base="$(bazel info output_base)"
local sandbox_base="${output_base}/sandbox"
build_with_fake_sandboxfs "$(pwd)/log" //hello \
|| fail "Build should have succeeded"
grep -q "ARGS: .*${sandbox_base}/sandboxfs" log \
|| fail "Cannot find expected mount point in sandboxfs mount call"
grep -q "Terminated" log \
|| fail "sandboxfs process was not terminated (not unmounted?)"
}
function test_debug_lifecycle() {
create_hello_package
function sandboxfs_pid() {
case "$(uname)" in
Darwin)
# We cannot use ps to look for the sandbox process because this is
# not allowed when running with macOS's App Sandboxing.
grep -q "Terminated" log && return
grep "^PID:" log | awk '{print $2}'
;;
*)
# We could use the same approach we follow on Darwin to look for the
# PID of the subprocess, but it's better if we look at the real
# process table if we are able to.
ps ax | grep [f]ake-sandboxfs | awk '{print $1}'
;;
esac
}
# Want sandboxfs to be left mounted after a build with debugging on.
build_with_fake_sandboxfs "$(pwd)/log" --sandbox_debug //hello
grep -q "ARGS:" log || fail "sandboxfs was not run"
grep -q "Terminated" log \
&& fail "sandboxfs process was terminated but should not have been"
local pid1="$(sandboxfs_pid)"
[[ -n "${pid1}" ]] || fail "sandboxfs process not found in process table"
# Want sandboxfs to be restarted if the previous build had debugging on.
build_with_fake_sandboxfs "$(pwd)/log" --sandbox_debug //hello
local pid2="$(sandboxfs_pid)"
[[ -n "${pid2}" ]] || fail "sandboxfs process not found in process table"
[[ "${pid1}" -ne "${pid2}" ]] || fail "sandboxfs was not restarted"
# Want build to finish successfully and to clear the mount point.
build_with_fake_sandboxfs "$(pwd)/log" --nosandbox_debug //hello
local pid3="$(sandboxfs_pid)"
[[ -z "${pid3}" ]] || fail "sandboxfs was not terminated"
}
function test_always_unmounted_on_exit() {
create_hello_package
# Want sandboxfs to be left mounted after a build with debugging on.
build_with_fake_sandboxfs "$(pwd)/log" --sandbox_debug //hello
grep -q "ARGS:" log || fail "sandboxfs was not run"
grep -q "Terminated" log \
&& fail "sandboxfs process was terminated but should not have been"
# Want Bazel to unmount the sandboxfs instance on exit no matter what.
#
# Note that we do not even tell Bazel where the sandboxfs binary lives
# but we expect changes to the log of the currently-running sandboxfs
# binary. This is intentional to verify that the already-mounted
# instance is the one shut down.
bazel shutdown
grep -q "Terminated" log \
|| fail "sandboxfs process was not terminated but should have been"
}
run_suite "sandboxfs-based sandboxing tests"