| #!/bin/bash |
| # |
| # Copyright 2015 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. |
| # |
| # Test rules provided in Bazel not tested by examples |
| # |
| |
| set -u |
| ADDITIONAL_BUILD_FLAGS=$1 |
| WORKER_TYPE_LOG_STRING=$2 |
| shift 2 |
| |
| # Load the test setup defined in the parent directory |
| 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; } |
| |
| # TODO(philwo): Change this so the path to the custom worker gets passed in as an argument to the |
| # test, once the bug that makes using the "args" attribute with sh_tests in Bazel impossible is |
| # fixed. |
| example_worker=$(find $BAZEL_RUNFILES -name ExampleWorker_deploy.jar) |
| |
| add_to_bazelrc "build -s" |
| add_to_bazelrc "build --strategy=Javac=worker --strategy=Work=worker" |
| add_to_bazelrc "build --worker_verbose --worker_max_instances=1" |
| add_to_bazelrc "build ${ADDITIONAL_BUILD_FLAGS}" |
| |
| function set_up() { |
| # Run each test in a separate folder so that their output files don't get cached. |
| WORKSPACE_SUBDIR=$(basename $(mktemp -d ${WORKSPACE_DIR}/testXXXXXX)) |
| cd ${WORKSPACE_SUBDIR} |
| BINS=$(bazel info $PRODUCT_NAME-bin)/${WORKSPACE_SUBDIR} |
| |
| # This causes Bazel to shut down all running workers. |
| bazel build --worker_quit_after_build &> $TEST_log \ |
| || fail "'bazel build --worker_quit_after_build' during test set_up failed" |
| } |
| |
| function write_hello_library_files() { |
| mkdir -p java/main |
| cat >java/main/BUILD <<EOF |
| java_binary(name = 'main', |
| deps = [':hello_library'], |
| srcs = ['Main.java'], |
| main_class = 'main.Main') |
| |
| java_library(name = 'hello_library', |
| srcs = ['HelloLibrary.java']); |
| EOF |
| |
| cat >java/main/Main.java <<EOF |
| package main; |
| import main.HelloLibrary; |
| public class Main { |
| public static void main(String[] args) { |
| HelloLibrary.funcHelloLibrary(); |
| System.out.println("Hello, World!"); |
| } |
| } |
| EOF |
| |
| cat >java/main/HelloLibrary.java <<EOF |
| package main; |
| public class HelloLibrary { |
| public static void funcHelloLibrary() { |
| System.out.print("Hello, Library!;"); |
| } |
| } |
| EOF |
| } |
| |
| function test_compiles_hello_library_using_persistent_javac() { |
| write_hello_library_files |
| |
| bazel build java/main:main &> $TEST_log \ |
| || fail "build failed" |
| expect_log "Created new ${WORKER_TYPE_LOG_STRING} Javac worker (id [0-9]\+)" |
| $BINS/java/main/main | grep -q "Hello, Library!;Hello, World!" \ |
| || fail "comparison failed" |
| } |
| |
| function prepare_example_worker() { |
| cp ${example_worker} worker_lib.jar |
| chmod +w worker_lib.jar |
| echo "exampledata" > worker_data.txt |
| |
| mkdir worker_data_dir |
| echo "veryexample" > worker_data_dir/more_data.txt |
| |
| cat >work.bzl <<'EOF' |
| def _impl(ctx): |
| worker = ctx.executable.worker |
| output = ctx.outputs.out |
| |
| argfile_inputs = [] |
| argfile_arguments = [] |
| if ctx.attr.multiflagfiles: |
| # Generate one flagfile per command-line arg, alternate between @ and --flagfile= style. |
| # This is used to test the code that handles multiple flagfiles and the --flagfile= style. |
| idx = 1 |
| for arg in ["--output_file=" + output.path] + ctx.attr.args: |
| argfile = ctx.new_file(ctx.bin_dir, "%s_worker_input_%s" % (ctx.label.name, idx)) |
| ctx.file_action(output=argfile, content=arg) |
| ctx.actions.write(output=argfile, content=arg) |
| argfile_inputs.append(argfile) |
| flagfile_prefix = "@" if (idx % 2 == 0) else "--flagfile=" |
| argfile_arguments.append(flagfile_prefix + argfile.path) |
| idx += 1 |
| else: |
| # Generate the "@"-file containing the command-line args for the unit of work. |
| argfile = ctx.new_file(ctx.bin_dir, "%s_worker_input" % ctx.label.name) |
| argfile_contents = "\n".join(["--output_file=" + output.path] + ctx.attr.args) |
| ctx.actions.write(output=argfile, content=argfile_contents) |
| argfile_inputs.append(argfile) |
| argfile_arguments.append("@" + argfile.path) |
| |
| ctx.actions.run( |
| inputs=argfile_inputs + ctx.files.srcs, |
| outputs=[output], |
| executable=worker, |
| progress_message="Working on %s" % ctx.label.name, |
| mnemonic="Work", |
| execution_requirements={"supports-workers": "1"}, |
| arguments=ctx.attr.worker_args + argfile_arguments, |
| ) |
| |
| work = rule( |
| implementation=_impl, |
| attrs={ |
| "worker": attr.label(cfg="host", mandatory=True, allow_files=True, executable=True), |
| "worker_args": attr.string_list(), |
| "args": attr.string_list(), |
| "srcs": attr.label_list(allow_files=True), |
| "multiflagfiles": attr.bool(default=False), |
| }, |
| outputs = {"out": "%{name}.out"}, |
| ) |
| EOF |
| cat >BUILD <<EOF |
| load("work", "work") |
| |
| java_import( |
| name = "worker_lib", |
| jars = ["worker_lib.jar"], |
| ) |
| |
| java_binary( |
| name = "worker", |
| main_class = "com.google.devtools.build.lib.worker.ExampleWorker", |
| runtime_deps = [ |
| ":worker_lib", |
| ], |
| data = [ |
| ":worker_data.txt", |
| ":worker_data_dir", |
| ] |
| ) |
| EOF |
| } |
| |
| function test_example_worker() { |
| prepare_example_worker |
| cat >>BUILD <<EOF |
| work( |
| name = "hello_world", |
| worker = ":worker", |
| args = ["hello world"], |
| ) |
| |
| work( |
| name = "hello_world_uppercase", |
| worker = ":worker", |
| args = ["--uppercase", "hello world"], |
| ) |
| EOF |
| |
| bazel build :hello_world &> $TEST_log \ |
| || fail "build failed" |
| assert_equals "hello world" "$(cat $BINS/hello_world.out)" |
| |
| bazel build :hello_world_uppercase &> $TEST_log \ |
| || fail "build failed" |
| assert_equals "HELLO WORLD" "$(cat $BINS/hello_world_uppercase.out)" |
| } |
| |
| function test_multiple_flagfiles() { |
| prepare_example_worker |
| cat >>BUILD <<EOF |
| work( |
| name = "multi_hello_world", |
| worker = ":worker", |
| args = ["hello", "world", "nice", "to", "meet", "you"], |
| multiflagfiles = True, |
| ) |
| EOF |
| |
| bazel build :multi_hello_world &> $TEST_log \ |
| || fail "build failed" |
| assert_equals "hello world nice to meet you" "$(cat $BINS/multi_hello_world.out)" |
| } |
| |
| function test_workers_quit_after_build() { |
| prepare_example_worker |
| cat >>BUILD <<'EOF' |
| [work( |
| name = "hello_world_%s" % idx, |
| worker = ":worker", |
| args = ["--write_counter"], |
| ) for idx in range(10)] |
| EOF |
| |
| bazel build --worker_quit_after_build :hello_world_1 &> $TEST_log \ |
| || fail "build failed" |
| work_count=$(cat $BINS/hello_world_1.out | grep COUNTER | cut -d' ' -f2) |
| assert_equals "1" $work_count |
| |
| bazel build --worker_quit_after_build :hello_world_2 &> $TEST_log \ |
| || fail "build failed" |
| work_count=$(cat $BINS/hello_world_2.out | grep COUNTER | cut -d' ' -f2) |
| # If the worker hadn't quit as we told it, it would have been reused, causing this to be a "2". |
| assert_equals "1" $work_count |
| } |
| |
| function test_build_fails_when_worker_exits() { |
| prepare_example_worker |
| cat >>BUILD <<'EOF' |
| [work( |
| name = "hello_world_%s" % idx, |
| worker = ":worker", |
| worker_args = ["--exit_after=1"], |
| args = ["--write_uuid", "--write_counter"], |
| ) for idx in range(10)] |
| EOF |
| |
| bazel build :hello_world_1 &> $TEST_log \ |
| || fail "build failed" |
| |
| bazel build :hello_world_2 &> $TEST_log \ |
| && fail "expected build to failed" || true |
| |
| expect_log "Worker process quit or closed its stdin stream when we tried to send a WorkRequest" |
| } |
| |
| function test_worker_restarts_when_worker_binary_changes() { |
| prepare_example_worker |
| cat >>BUILD <<'EOF' |
| [work( |
| name = "hello_world_%s" % idx, |
| worker = ":worker", |
| args = ["--write_uuid", "--write_counter"], |
| ) for idx in range(10)] |
| EOF |
| |
| echo "First run" >> $TEST_log |
| bazel build :hello_world_1 &> $TEST_log \ |
| || fail "build failed" |
| worker_uuid_1=$(cat $BINS/hello_world_1.out | grep UUID | cut -d' ' -f2) |
| work_count=$(cat $BINS/hello_world_1.out | grep COUNTER | cut -d' ' -f2) |
| assert_equals "1" $work_count |
| |
| echo "Second run" >> $TEST_log |
| bazel build :hello_world_2 &> $TEST_log \ |
| || fail "build failed" |
| worker_uuid_2=$(cat $BINS/hello_world_2.out | grep UUID | cut -d' ' -f2) |
| work_count=$(cat $BINS/hello_world_2.out | grep COUNTER | cut -d' ' -f2) |
| assert_equals "2" $work_count |
| |
| # Check that the same worker was used twice. |
| assert_equals "$worker_uuid_1" "$worker_uuid_2" |
| |
| # Modify the example worker jar to trigger a rebuild of the worker. |
| tr -cd '[:alnum:]' < /dev/urandom | head -c32 > dummy_file |
| zip worker_lib.jar dummy_file |
| rm dummy_file |
| |
| bazel build :hello_world_3 &> $TEST_log \ |
| || fail "build failed" |
| worker_uuid_3=$(cat $BINS/hello_world_3.out | grep UUID | cut -d' ' -f2) |
| work_count=$(cat $BINS/hello_world_3.out | grep COUNTER | cut -d' ' -f2) |
| assert_equals "1" $work_count |
| |
| expect_log "worker .* can no longer be used, because its files have changed on disk" |
| expect_log "worker_lib.jar: .* -> .*" |
| |
| # Check that we used a new worker. |
| assert_not_equals "$worker_uuid_2" "$worker_uuid_3" |
| } |
| |
| function test_worker_restarts_when_worker_runfiles_change() { |
| prepare_example_worker |
| cat >>BUILD <<'EOF' |
| [work( |
| name = "hello_world_%s" % idx, |
| worker = ":worker", |
| args = ["--write_uuid", "--write_counter"], |
| ) for idx in range(10)] |
| EOF |
| |
| bazel build :hello_world_1 &> $TEST_log \ |
| || fail "build failed" |
| worker_uuid_1=$(cat $BINS/hello_world_1.out | grep UUID | cut -d' ' -f2) |
| work_count=$(cat $BINS/hello_world_1.out | grep COUNTER | cut -d' ' -f2) |
| assert_equals "1" $work_count |
| |
| bazel build :hello_world_2 &> $TEST_log \ |
| || fail "build failed" |
| worker_uuid_2=$(cat $BINS/hello_world_2.out | grep UUID | cut -d' ' -f2) |
| work_count=$(cat $BINS/hello_world_2.out | grep COUNTER | cut -d' ' -f2) |
| assert_equals "2" $work_count |
| |
| # Check that the same worker was used twice. |
| assert_equals "$worker_uuid_1" "$worker_uuid_2" |
| |
| # "worker_data.txt" is included in the "data" attribute of the example worker. |
| echo "changeddata" > worker_data.txt |
| |
| bazel build :hello_world_3 &> $TEST_log \ |
| || fail "build failed" |
| worker_uuid_3=$(cat $BINS/hello_world_3.out | grep UUID | cut -d' ' -f2) |
| work_count=$(cat $BINS/hello_world_3.out | grep COUNTER | cut -d' ' -f2) |
| assert_equals "1" $work_count |
| |
| expect_log "worker .* can no longer be used, because its files have changed on disk" |
| expect_log "worker_data.txt: edcca2268a017586e6b62a8d572b1b72 -> 594038395d71f98c79c00405e0f0eba8" |
| |
| # Check that we used a new worker. |
| assert_not_equals "$worker_uuid_2" "$worker_uuid_3" |
| } |
| |
| # When a worker does not conform to the protocol and returns a response that is not a parseable |
| # protobuf, it must be killed and a helpful error message should be printed. |
| function test_build_fails_when_worker_returns_junk() { |
| prepare_example_worker |
| cat >>BUILD <<'EOF' |
| [work( |
| name = "hello_world_%s" % idx, |
| worker = ":worker", |
| worker_args = ["--poison_after=1"], |
| args = ["--write_uuid", "--write_counter"], |
| ) for idx in range(10)] |
| EOF |
| |
| bazel build :hello_world_1 &> $TEST_log \ |
| || fail "build failed" |
| |
| # A failing worker should cause the build to fail. |
| bazel build :hello_world_2 &> $TEST_log \ |
| && fail "expected build to fail" || true |
| |
| # Check that a helpful error message was printed. |
| expect_log "Worker process returned an unparseable WorkResponse:" |
| expect_log "I'm a poisoned worker and this is not a protobuf." |
| } |
| |
| function test_input_digests() { |
| prepare_example_worker |
| cat >>BUILD <<'EOF' |
| [work( |
| name = "hello_world_%s" % idx, |
| worker = ":worker", |
| args = ["--write_uuid", "--print_inputs"], |
| srcs = [":input.txt"], |
| ) for idx in range(10)] |
| EOF |
| |
| echo "hello world" > input.txt |
| bazel build :hello_world_1 &> $TEST_log \ |
| || fail "build failed" |
| worker_uuid_1=$(cat $BINS/hello_world_1.out | grep UUID | cut -d' ' -f2) |
| hash1=$(egrep "INPUT .*/input.txt " $BINS/hello_world_1.out | cut -d' ' -f3) |
| |
| bazel build :hello_world_2 >> $TEST_log 2>&1 \ |
| || fail "build failed" |
| worker_uuid_2=$(cat $BINS/hello_world_2.out | grep UUID | cut -d' ' -f2) |
| hash2=$(egrep "INPUT .*/input.txt " $BINS/hello_world_2.out | cut -d' ' -f3) |
| |
| assert_equals "$worker_uuid_1" "$worker_uuid_2" |
| assert_equals "$hash1" "$hash2" |
| |
| echo "changeddata" > input.txt |
| |
| bazel build :hello_world_3 >> $TEST_log 2>&1 \ |
| || fail "build failed" |
| worker_uuid_3=$(cat $BINS/hello_world_3.out | grep UUID | cut -d' ' -f2) |
| hash3=$(egrep "INPUT .*/input.txt " $BINS/hello_world_3.out | cut -d' ' -f3) |
| |
| assert_equals "$worker_uuid_2" "$worker_uuid_3" |
| assert_not_equals "$hash2" "$hash3" |
| } |
| |
| function test_worker_verbose() { |
| prepare_example_worker |
| cat >>BUILD <<'EOF' |
| [work( |
| name = "hello_world_%s" % idx, |
| worker = ":worker", |
| args = ["--write_uuid", "--write_counter"], |
| ) for idx in range(10)] |
| EOF |
| |
| bazel build --worker_quit_after_build :hello_world_1 &> $TEST_log \ |
| || fail "build failed" |
| expect_log "Created new ${WORKER_TYPE_LOG_STRING} Work worker (id [0-9]\+)" |
| expect_log "Destroying Work worker (id [0-9]\+)" |
| expect_log "Build completed, shutting down worker pool..." |
| } |
| |
| function test_logs_are_deleted_on_server_restart() { |
| prepare_example_worker |
| cat >>BUILD <<'EOF' |
| [work( |
| name = "hello_world_%s" % idx, |
| worker = ":worker", |
| args = ["--write_uuid", "--write_counter"], |
| ) for idx in range(10)] |
| EOF |
| |
| bazel build --worker_quit_after_build :hello_world_1 &> $TEST_log \ |
| || fail "build failed" |
| |
| expect_log "Created new ${WORKER_TYPE_LOG_STRING} Work worker (id [0-9]\+)" |
| |
| worker_log=$(egrep -o -- 'logging to .*/b(azel|laze)-workers/worker-[0-9]-Work.log' "$TEST_log" | sed 's/^logging to //') |
| |
| [ -e "$worker_log" ] \ |
| || fail "Worker log was not found" |
| |
| # Running a build after a server shutdown should trigger the removal of old worker log files. |
| bazel shutdown &> $TEST_log |
| bazel build &> $TEST_log |
| |
| [ ! -e "$worker_log" ] \ |
| || fail "Worker log was not deleted" |
| } |
| |
| function test_missing_execution_requirements_gives_warning() { |
| prepare_example_worker |
| cat >>BUILD <<'EOF' |
| work( |
| name = "hello_world", |
| worker = ":worker", |
| args = ["--write_uuid", "--write_counter"], |
| ) |
| EOF |
| |
| sed -i.bak '/execution_requirements/d' work.bzl |
| rm -f work.bzl.bak |
| |
| bazel build --worker_quit_after_build :hello_world &> $TEST_log \ |
| || fail "build failed" |
| |
| expect_log "Worker strategy cannot execute this Work action, because the action's execution info does not contain 'supports-workers=1'" |
| expect_not_log "Created new ${WORKER_TYPE_LOG_STRING} Work worker (id [0-9]\+)" |
| expect_not_log "Destroying Work worker (id [0-9]\+)" |
| |
| # WorkerSpawnStrategy falls back to standalone strategy, so we still expect the output to be generated. |
| [ -e "$BINS/hello_world.out" ] \ |
| || fail "Worker did not produce output" |
| } |
| |
| function test_environment_is_clean() { |
| prepare_example_worker |
| cat >>BUILD <<'EOF' |
| work( |
| name = "hello_world", |
| worker = ":worker", |
| args = ["--print_env"], |
| ) |
| EOF |
| |
| bazel shutdown &> $TEST_log \ |
| || fail "shutdown failed" |
| CAKE=LIE bazel build --worker_quit_after_build :hello_world &> $TEST_log \ |
| || fail "build failed" |
| |
| fgrep CAKE=LIE $BINS/hello_world.out \ |
| && fail "environment variable leaked into worker env" || true |
| } |
| |
| function test_workers_quit_on_clean() { |
| prepare_example_worker |
| cat >>BUILD <<EOF |
| work( |
| name = "hello_clean", |
| worker = ":worker", |
| args = ["hello clean"], |
| ) |
| EOF |
| |
| bazel build :hello_clean &> $TEST_log \ |
| || fail "build failed" |
| assert_equals "hello clean" "$(cat $BINS/hello_clean.out)" |
| expect_log "Created new ${WORKER_TYPE_LOG_STRING} Work worker (id [0-9]\+)" |
| |
| bazel clean &> $TEST_log \ |
| || fail "clean failed" |
| expect_log "Clean command is running, shutting down worker pool..." |
| expect_log "Destroying Work worker (id [0-9]\+)" |
| } |
| |
| function test_crashed_worker_causes_log_dump() { |
| prepare_example_worker |
| cat >>BUILD <<'EOF' |
| [work( |
| name = "hello_world_%s" % idx, |
| worker = ":worker", |
| worker_args = ["--poison_after=1", "--hard_poison"], |
| args = ["--write_uuid", "--write_counter"], |
| ) for idx in range(10)] |
| EOF |
| |
| bazel build :hello_world_1 &> $TEST_log \ |
| || fail "build failed" |
| |
| bazel build :hello_world_2 &> $TEST_log \ |
| && fail "expected build to fail" || true |
| |
| expect_log "^---8<---8<--- Start of log, file at /" |
| expect_log "Worker process did not return a WorkResponse:" |
| expect_log "I'm a very poisoned worker and will just crash." |
| expect_log "^---8<---8<--- End of log ---8<---8<---" |
| } |
| run_suite "Worker integration tests" |