| # Copyright 2016 The Fuchsia Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Recipe for building Zircon.""" |
| |
| import contextlib |
| import pipes |
| import re |
| |
| from recipe_engine.config import Enum, List |
| from recipe_engine.recipe_api import Property, StepFailure |
| |
| |
| DEPS = [ |
| 'infra/fuchsia', |
| 'infra/goma', |
| 'infra/jiri', |
| 'infra/isolated', |
| 'infra/minfs', |
| 'infra/qemu', |
| 'infra/swarming', |
| 'infra/tar', |
| 'infra/zbi', |
| 'recipe_engine/buildbucket', |
| 'recipe_engine/context', |
| 'recipe_engine/file', |
| 'recipe_engine/json', |
| 'recipe_engine/path', |
| 'recipe_engine/platform', |
| 'recipe_engine/properties', |
| 'recipe_engine/raw_io', |
| 'recipe_engine/source_manifest', |
| 'recipe_engine/step', |
| 'recipe_engine/tempfile', |
| ] |
| |
| TARGETS = ['x64', 'arm64'] |
| # TODO(dbort): Add a new class to manage these mappings more clearly. |
| TARGET_TO_ARCH = dict(zip( |
| TARGETS, |
| ['x86_64', 'aarch64'], |
| )) |
| |
| # The name of the Zircon ZBI image produced by the build. Contains both kernel |
| # and a ramdisk. |
| ZIRCON_ZBI_NAME = 'zircon.zbi' |
| |
| # The kernel image. |
| TARGET_TO_KERNEL_IMAGE = dict(zip( |
| TARGETS, |
| ['multiboot.bin', 'qemu-boot-shim.bin'], |
| )) |
| ARCHS = ('x86_64', 'aarch64') |
| |
| # Supported device types for testing. |
| DEVICES = ('QEMU', 'Intel NUC Kit NUC7i5DNHE', 'Khadas Vim2 Max') |
| |
| # toolchain: (['make', 'args'], 'builddir-suffix') |
| TOOLCHAINS = { |
| 'gcc': ([], ''), |
| 'clang': (['USE_CLANG=true'], '-clang'), |
| 'asan': (['USE_ASAN=true'], '-asan'), |
| 'lto': (['USE_LTO=true', 'USE_THINLTO=false'], '-lto'), |
| 'profile': (['USE_PROFILE=true'], '-profile'), |
| 'thinlto': (['USE_LTO=true', 'USE_THINLTO=true'], '-thinlto'), |
| } |
| |
| # The path under /boot to the runcmds script (which runs tests) in the zircon |
| # bootfs. |
| RUNCMDS_BOOTFS_PATH = 'infra/runcmds' |
| |
| # The PCI address to use for the block device to contain test results. This value |
| # is somewhat arbitrary, but it works very consistently and appears to be a safe |
| # PCI address value to use within QEMU. |
| TEST_FS_PCI_ADDR = '06.0' |
| |
| # How long to wait (in seconds) before killing the test swarming task if there's |
| # no output being produced. |
| TEST_IO_TIMEOUT_SECS = 180 |
| |
| # This string matches the one in //zircon/system/utest/core/main.c. |
| CORE_TESTS_SUCCESS_STR = 'core-tests succeeded RZMm59f7zOSs6aZUIXZR' |
| |
| # Common to all NUC devices: block device path for use by blktest and other |
| # destructive local storage tests. |
| NUC_SCRATCH_BLOCK_DEVICE_PATH = '/dev/sys/pci/00:17.0/ahci/sata2/block' |
| |
| # Key is device_type recipe property. |
| # Val is a block device path for use by blktest and other destructive local |
| # storage tests. 'Scratch' here means it can be destroyed by the tests. |
| # Destructive local storage tests will run on a given device type iff that |
| # device type is present in this dict. |
| DEVICE_TYPE_TO_SCRATCH_BLOCK_DEVICE_PATH = { |
| 'Intel NUC Kit NUC7i5DNHE': NUC_SCRATCH_BLOCK_DEVICE_PATH, |
| } |
| |
| PROPERTIES = { |
| 'project': |
| Property(kind=str, help='Jiri remote manifest project', default=None), |
| 'manifest': Property(kind=str, help='Jiri manifest to use'), |
| 'remote': Property(kind=str, help='Remote manifest repository'), |
| 'target': Property(kind=Enum(*TARGETS), help='Target to build'), |
| 'toolchain': Property(kind=Enum(*(TOOLCHAINS.keys())), |
| help='Toolchain to use'), |
| 'make_args': Property(kind=List(basestring), |
| help='Extra args to pass to Make', |
| default=[]), |
| 'run_tests' : Property(kind=bool, help='Run tests in qemu after building', default=False), |
| 'runtests_args': Property(kind=str, |
| help='Shell-quoted string to add to the runtests commandline', |
| default=''), |
| 'use_kvm': Property(kind=bool, |
| help='Whether to use KVM when running tests in QEMU', |
| default=True), |
| 'device_type': Property(kind=Enum(*DEVICES), |
| help='The type of device to execute tests on', |
| default='QEMU'), |
| 'run_host_tests': Property(kind=bool, |
| help='Run host tests after building', |
| default=False), |
| 'gcs_bucket': |
| Property( |
| kind=str, |
| help='GCS bucket for uploading test results', |
| default=''), |
| } |
| |
| |
| def RunTestsOnHost(api, build_dir): |
| """Runs host tests. |
| |
| Args: |
| build_dir (Path): Path to the build directory. |
| Returns: |
| A FuchsiaTestResults representing the completed test. |
| """ |
| runtests = build_dir.join('tools', 'runtests') |
| host_test_dir = build_dir.join('host_tests') |
| |
| # Write test results to the 'host' subdirectory of |results_dir_on_host| |
| # so as not to collide with target test results. |
| test_results_dir = api.fuchsia.results_dir_on_host.join('host') |
| |
| # In order to symbolize host ASan output, the llvm symbolizer must be in |
| # one's PATH and the path to the symbolizer must be set as |
| # ASAN_SYMBOLIZER_PATH. See the following for documentation: |
| # https://clang.llvm.org/docs/AddressSanitizer.html#symbolizing-the-reports |
| llvm_symbolizer = api.path['start_dir'].join( |
| 'zircon', 'prebuilt', 'downloads', 'clang', 'bin', 'llvm-symbolizer') |
| with api.context(env={"ASAN_SYMBOLIZER_PATH": llvm_symbolizer}): |
| |
| # Allow the runtests invocation to fail without resulting in a step failure. |
| # The relevant, individual test failures will be reported during the |
| # processing of summary.json - and an early step failure will prevent this. |
| api.step( |
| 'run host tests', [ |
| runtests, |
| '-o', |
| api.raw_io.output_dir(leak_to=test_results_dir), |
| host_test_dir, |
| ], |
| ok_ret='any') |
| |
| # Extract test results. |
| test_results_map = api.step.active_result.raw_io.output_dir |
| return api.fuchsia.FuchsiaTestResults( |
| name='host', |
| build_dir=build_dir, |
| results_dir=test_results_dir, |
| zircon_kernel_log=None, # We did not run tests on target. |
| outputs=test_results_map, |
| api=api, |
| ) |
| |
| |
| def RunTestsOnDevice(api, target, build_dir, device_type): |
| """Executes Zircon tests on a hardware device. |
| |
| Args |
| api (recipe_engine.Api): The recipe engine API for this recipe. |
| target (str): The zircon target architecture to execute tests on. |
| build_dir (Path): Path to the build directory. |
| device_type (Enum(*DEVICES)): The type of device to run tests on. |
| Returns: |
| A FuchsiaTestResults representing the completed test. |
| """ |
| output_archive_name = 'out.tar' |
| botanist_cmd = [ |
| './botanist/botanist', |
| 'zedboot', |
| '-kernel', ZIRCON_ZBI_NAME, |
| '-results-dir', api.fuchsia.results_dir_on_target, |
| '-out', output_archive_name, |
| ] |
| |
| if target == 'arm64': |
| # Create a Zedboot image for flashing physical hardware. |
| # Zedboot can be trivialized as Zircon + netsvc.netboot=true. |
| cmdline_file = api.path['cleanup'].join('cmdline.txt') |
| zedboot_img_name = 'boot.img' |
| zedboot_img_path = api.path['cleanup'].join(zedboot_img_name) |
| api.file.write_raw( |
| name='write cmdline file', |
| dest=cmdline_file, |
| data='netsvc.netboot=true') |
| api.zbi.zbi_path = build_dir.join('tools', 'zbi') |
| api.zbi.copy_and_overwrite_cmdline( |
| step_name='create boot img', |
| input_image=build_dir.join(ZIRCON_ZBI_NAME), |
| output_image=zedboot_img_path, |
| cmdline_file=cmdline_file) |
| botanist_cmd.extend(['-fastboot', '-zedboot', zedboot_img_name]) |
| |
| # Botanist args must be added after all flags are set |
| botanist_cmd.append('zircon.autorun.boot=/boot/bin/sh+/boot/' + RUNCMDS_BOOTFS_PATH) |
| |
| # Isolate all necessary build artifacts. |
| isolated = api.isolated.isolated() |
| isolated.add_file(build_dir.join(ZIRCON_ZBI_NAME), wd=build_dir) |
| if target == 'arm64': |
| isolated.add_file(zedboot_img_path, wd=api.path['cleanup']) |
| digest = isolated.archive('isolate zircon artifacts') |
| |
| with api.context(infra_steps=True): |
| # Trigger task. |
| trigger_result = api.swarming.trigger( |
| 'booted tests', |
| botanist_cmd, |
| isolated=digest, |
| dimensions={ |
| 'pool': 'fuchsia.tests', |
| 'device_type': device_type, |
| }, |
| io_timeout=TEST_IO_TIMEOUT_SECS, |
| hard_timeout=40*60, # 40 minute hard timeout |
| outputs=[output_archive_name], |
| cipd_packages=[ |
| ('botanist', 'fuchsia/tools/botanist/linux-amd64', 'latest'), |
| ('fastboot', 'fuchsia/infra/external/fastboot/linux-amd64', 'latest') |
| ], |
| ) |
| # Collect results. |
| results = api.swarming.collect(tasks_json=api.json.input(trigger_result.json.output)) |
| # This assert just makes sure that we only get 1 result back, as requested. |
| # If this assert fails, it indicates a fatal error in our stack. |
| assert len(results) == 1 |
| result = results[0] |
| symbolizer_output = api.path['cleanup'].join('symbolizer-output.json') |
| api.fuchsia.analyze_collect_result( |
| 'task results', |
| result, |
| build_dir, |
| symbolizer_output, |
| ) |
| |
| # Extract test results. |
| test_results_dir = api.fuchsia.results_dir_on_host.join('target') |
| with api.context(infra_steps=True): |
| api.tar.ensure_tar() |
| test_results_map = api.tar.extract( |
| step_name='extract results', |
| path=result.outputs[output_archive_name], |
| directory=api.raw_io.output_dir(leak_to=test_results_dir), |
| ).raw_io.output_dir |
| |
| # Analyze the test results and report them in the presentation. |
| return api.fuchsia.FuchsiaTestResults( |
| name='booted', |
| build_dir=build_dir, |
| results_dir=test_results_dir, |
| zircon_kernel_log=result.output, |
| outputs=test_results_map, |
| api=api, |
| symbolizer_output=symbolizer_output, |
| ) |
| |
| def RunTestsInQEMU(api, target, build_dir, use_kvm): |
| """Executes Zircon tests in QEMU on a different machine. |
| |
| Args: |
| api (recipe_engine.Api): The recipe engine API for this recipe. |
| target (str): The zircon target architecture to execute tests on. |
| build_dir (Path): Path to the build directory. |
| use_kvm (bool): Whether or not to enable KVM with QEMU when testing. |
| |
| Returns: |
| A FuchsiaTestResults representing the completed test. |
| """ |
| arch = TARGET_TO_ARCH[target] |
| assert arch in ARCHS |
| |
| # Generate a MinFS image which will hold test results. This will later be |
| # declared as a block device to QEMU and will then be mounted by the |
| # runcmds script. The size of the MinFS should be large enough to |
| # accomodate all test results and test output. The current size is picked |
| # to be able to safely hold test results for quite some time (as of 03/18 |
| # the space used is very roughly on the order of a megabyte). Having a |
| # larger-image-than-necessary isn't a big deal for isolate, which |
| # compresses the image before uploading. |
| minfs_image_name = 'output.fs' |
| minfs_image = api.path['start_dir'].join(minfs_image_name) |
| api.minfs.create(minfs_image, '1G', name='create minfs image') |
| |
| # Generate the botanist QEMU commands. |
| base_botanist_cmd = [ |
| './botanist/botanist', |
| 'qemu', |
| '-qemu-dir', './qemu/bin', |
| '-qemu-kernel', TARGET_TO_KERNEL_IMAGE[target], |
| '-zircon-a', ZIRCON_ZBI_NAME, |
| '-arch', target, |
| ] # yapf: disable |
| if use_kvm: |
| base_botanist_cmd.append('-use-kvm') |
| |
| core_tests_botanist_cmd = base_botanist_cmd + [ |
| # executes bin/core-tests in place of userspace. |
| 'userboot=bin/core-tests', |
| # shuts down zircon after the userboot process exits. |
| 'userboot.shutdown', |
| ] # yapf: disable |
| |
| booted_tests_botanist_cmd = base_botanist_cmd + [ |
| '-minfs', minfs_image_name, |
| '-pci-addr', TEST_FS_PCI_ADDR, |
| # On boot, execute the RUNCMDS script. |
| 'zircon.autorun.boot=/boot/bin/sh+/boot/%s' % RUNCMDS_BOOTFS_PATH, |
| ] # yapf: disable |
| |
| # Isolate all necessary build artifacts as well as the MinFS image. |
| isolated = api.isolated.isolated() |
| isolated.add_file(build_dir.join(TARGET_TO_KERNEL_IMAGE[target]), wd=build_dir) |
| isolated.add_file(build_dir.join(ZIRCON_ZBI_NAME), wd=build_dir) |
| isolated.add_file(minfs_image, wd=api.path['start_dir']) |
| digest = isolated.archive('isolate zircon artifacts') |
| |
| # Trigger a task that runs the core tests in place of userspace at boot. |
| core_task = TriggerTestsTask( |
| api=api, |
| name='core tests', |
| cmd=core_tests_botanist_cmd, |
| arch=arch, |
| use_kvm=use_kvm, |
| isolated_hash=digest, |
| timeout_secs=10*60, # 10 minute hard timeout. |
| ) |
| # Trigger a task that runs tests in the standard way with runtests and |
| # the runcmds script. |
| booted_task = TriggerTestsTask( |
| api=api, |
| name='booted tests', |
| cmd=booted_tests_botanist_cmd, |
| arch=arch, |
| use_kvm=use_kvm, |
| isolated_hash=digest, |
| output=minfs_image_name, |
| timeout_secs=40*60, # 40 minute hard timeout. |
| ) |
| |
| # Collect task results and analyze. |
| return FinalizeTestsTasks(api, core_task, booted_task, minfs_image_name, build_dir) |
| |
| def TriggerTestsTask(api, name, cmd, arch, use_kvm, isolated_hash, output='', |
| timeout_secs=60*60): |
| """TriggerTestsTask triggers a task to execute a command on a remote machine. |
| |
| The remote machine is guaranteed to have QEMU and botanist installed |
| |
| Args: |
| api: Recipe engine API object. |
| name (str): Name of the task. |
| cmd (seq[str]): The command to execute with each argument as a separate |
| list entry. |
| arch (str): The target architecture to execute tests for. |
| use_kvm (bool): Whether or not a bot with KVM should be requested for the |
| task. |
| isolated_hash (str): A digest of the isolated containing the build |
| artifacts. |
| output (str): Optional relative path to an output file on the target |
| machine which will be isolated and returned back to the machine |
| executing this recipe. |
| timeout_secs (int): The amount of seconds the task should run for before |
| timing out. |
| |
| Returns: |
| The task ID of the triggered task. |
| """ |
| # If we're not using KVM, we'll be executing on an x86 machine, so we need to |
| # make sure we're dropping in the correct binaries. |
| if not use_kvm: |
| cipd_arch = 'amd64' |
| else: |
| cipd_arch = { |
| 'aarch64': 'arm64', |
| 'x86_64': 'amd64', |
| }[arch] |
| |
| dimensions = { |
| 'pool': 'fuchsia.tests', |
| 'os': 'Debian', |
| } |
| if use_kvm: |
| dimensions['cpu'] = {'aarch64': 'arm64', 'x86_64': 'x86-64'}[arch] |
| dimensions['kvm'] = '1' |
| else: |
| # If we're not using KVM, we should use our x86 testers since we'll be in |
| # full emulation mode anyway, and our arm64 resources are much fewer in |
| # number. |
| dimensions['cpu'] = 'x86-64' |
| |
| with api.context(infra_steps=True): |
| # Trigger task. |
| trigger_result = api.swarming.trigger( |
| name, |
| cmd, |
| isolated=isolated_hash, |
| dimensions=dimensions, |
| hard_timeout=timeout_secs, |
| io_timeout=TEST_IO_TIMEOUT_SECS, |
| cipd_packages=[('qemu', 'fuchsia/qemu/linux-%s' % cipd_arch, 'latest'), |
| ('botanist', 'fuchsia/tools/botanist/linux-%s' % cipd_arch, 'latest')], |
| outputs=[output] if output else None, |
| ).json.output |
| assert 'tasks' in trigger_result and len(trigger_result['tasks']) == 1 |
| return trigger_result['tasks'][0]['task_id'] |
| |
| |
| def FinalizeTestsTasks(api, core_task, booted_task, booted_task_output_image, |
| build_dir): |
| """Waits on the tasks running core tests and booted tests, then analyzes the |
| results. |
| |
| Args: |
| core_task (str): The swarming task ID of the task running core tests. |
| booted_task (str): The swarming task ID of the task running booted tests. |
| build_dir (Path): A path to the directory containing build artifacts. |
| """ |
| with api.context(infra_steps=True): |
| collect_results = api.swarming.collect(tasks=[core_task, booted_task]) |
| results_map = {r.id: r for r in collect_results} |
| |
| # Analyze core tests results. |
| symbolizer_output = api.path['cleanup'].join('symbolizer-output.json') |
| api.fuchsia.analyze_collect_result( |
| 'core tests task results', |
| results_map[core_task], |
| build_dir, |
| symbolizer_output, |
| ) |
| |
| # Because of the way these tests run (they are the only user-mode process in |
| # the system, and then the system shuts down) we can't collect an exit code or |
| # nicely structured output, so we have to search the output for a hard-coded |
| # string to detect success. |
| if CORE_TESTS_SUCCESS_STR not in results_map[core_task].output: |
| raise StepFailure( |
| 'Did not find string "%s" in kernel log, so assuming core tests ' |
| 'failed.' % CORE_TESTS_SUCCESS_STR) |
| |
| # Analyze booted tests results just like the fuchsia recipe module does. |
| booted_result = results_map[booted_task] |
| api.fuchsia.analyze_collect_result( |
| 'booted tests task results', |
| booted_result, |
| build_dir, |
| symbolizer_output, |
| ) |
| |
| # Extract test results from the MinFS image. |
| test_results_dir = api.fuchsia.results_dir_on_host.join('target') |
| test_results_map = api.minfs.copy_image( |
| step_name='extract results', |
| image_path=booted_result.outputs[booted_task_output_image], |
| out_dir=test_results_dir, |
| ).raw_io.output_dir |
| |
| # Analyze the test results and report them in the presentation. |
| return api.fuchsia.FuchsiaTestResults( |
| name='booted', |
| build_dir=build_dir, |
| results_dir=test_results_dir, |
| zircon_kernel_log=booted_result.output, |
| outputs=test_results_map, |
| api=api, |
| symbolizer_output=symbolizer_output, |
| ) |
| |
| |
| def _BlockDeviceTestExtraUserManifestLines(api, tmp_dir, block_device_path): |
| extra_user_manifest_lines = [] |
| # Tuple of (test name, command). |
| commands = [ |
| ('blktest', 'blktest -d %s' % block_device_path), |
| ('fs-test-minfs', |
| '/boot/test/fs/fs-test -f minfs -d %s' % block_device_path), |
| # value for -c is block count, should be small enough to let the test run |
| # in < 30 seconds. |
| ('iochk', 'iochk -c 16384 --live-dangerously %s' % block_device_path)] |
| for name, command in commands: |
| test_sh = ['#!/boot/bin/sh', |
| command, |
| 'TEST_EXIT_CODE="$?"', |
| 'if [ "$TEST_EXIT_CODE" -ne 0 ]; then', |
| # lsblk output may be useful to debug. |
| ' echo "lsblk output:"', |
| ' lsblk', |
| ' exit "$TEST_EXIT_CODE"', |
| 'fi'] |
| test_sh_basename = '%s.sh' % name |
| test_sh_path = tmp_dir.join(test_sh_basename) |
| api.file.write_text( |
| 'write %s_sh' % name, test_sh_path, '\n'.join(test_sh)) |
| api.step.active_result.presentation.logs[test_sh_basename] = test_sh |
| # Put it under test/fs/ so that runtests finds it. See kDefaultTestDirs in |
| # runtests. |
| extra_user_manifest_lines.append( |
| 'test/fs/%s=%s' % (test_sh_basename, test_sh_path)) |
| |
| return extra_user_manifest_lines |
| |
| |
| def Build(api, target, toolchain, make_args, src_dir, test_cmd, needs_blkdev, |
| device_type): |
| """Builds zircon and returns a path to the build output directory.""" |
| # Generate runcmds script to drive tests. |
| tmp_dir = api.path['cleanup'].join('zircon_tmp') |
| api.file.ensure_directory('makedirs tmp', tmp_dir) |
| runcmds_path = tmp_dir.join('runcmds') |
| # In the use_isolate case, we need to mount a block device to write test |
| # results and test output to. Thus, the runcmds script must: |
| results_dir_on_target = api.fuchsia.results_dir_on_target |
| runcmds = [ |
| # 1. Make a test directory. |
| 'mkdir %s' % results_dir_on_target, |
| ] |
| if needs_blkdev: |
| # If we need a block device to get test output off Fuchsia, then we need |
| # to mount a MinFS image which we'll declare as a block device to QEMU at |
| # PCI address TEST_FS_PCI_ADDR. |
| # |
| # This topological path is the path on the device to the MinFS image as a |
| # raw block device. |
| device_topological_path = '/dev/sys/pci/00:%s/virtio-block/block' % TEST_FS_PCI_ADDR |
| runcmds.extend([ |
| # 2. Wait for devmgr to bring up the MinFS test output image (max |
| # <timeout> ms). |
| 'waitfor class=block topo=%s timeout=60000' % device_topological_path, |
| # 3. Mount the block device to the new test directory. |
| 'mount %s %s' % (device_topological_path, results_dir_on_target), |
| # 4. Execute the desired test command. |
| test_cmd, |
| # 5. Unmount and poweroff. |
| 'umount %s' % results_dir_on_target, |
| 'dm poweroff', |
| ]) |
| else: |
| # If we don't need a block device, just run the tests and wait for |
| # something to copy the test results off. Note that in this case we do not |
| # power off the device (via `dm poweroff`). |
| runcmds.extend([test_cmd]) |
| api.file.write_text('write runcmds', runcmds_path, '\n'.join(runcmds)) |
| api.step.active_result.presentation.logs['runcmds.sh'] = runcmds |
| |
| # The bootfs manifest is a list of mappings between bootfs paths and local |
| # file paths. The syntax is roughly: |
| # install/path/under/boot=path/to/file/or/dir. |
| extra_user_manifest_lines = ['%s=%s' % (RUNCMDS_BOOTFS_PATH, runcmds_path)] |
| |
| # Unfortuantely there's currently no way for the test to discover the block |
| # device to use on its own, so we have to construct this script here, once we |
| # know what device type we're using. See IN-459 for discussion. |
| block_device_path = DEVICE_TYPE_TO_SCRATCH_BLOCK_DEVICE_PATH.get(device_type) |
| if block_device_path: |
| extra_user_manifest_lines.extend( |
| _BlockDeviceTestExtraUserManifestLines(api, tmp_dir, block_device_path)) |
| |
| with api.step.nest('build'): |
| # Set up toolchain and build args. |
| tc_args, tc_suffix = TOOLCHAINS[toolchain] |
| build_args = [ |
| 'make', |
| target, |
| 'GOMACC=%s' % api.goma.goma_dir.join('gomacc'), |
| '-j', api.goma.jobs, |
| 'HOST_USE_ASAN=true', |
| 'BUILDROOT=%s' % src_dir, |
| ] + make_args + tc_args |
| |
| # If thinlto build, it needs a cache. Pass it a directory in the cache |
| # directory. |
| if toolchain == 'thinlto': |
| build_args.append('THINLTO_CACHE_DIR=' + |
| str(api.path['cache'].join('thinlto'))) |
| |
| build_args.append('EXTRA_USER_MANIFEST_LINES=%s' % |
| ' '.join(extra_user_manifest_lines)) |
| |
| # Build zircon. |
| with api.goma.build_with_goma(), api.context(cwd=src_dir): |
| api.step('build', build_args) |
| |
| # Return the location of the build artifacts. |
| return src_dir.join('build-%s' % target + tc_suffix) |
| |
| |
| def RunSteps(api, project, manifest, remote, target, toolchain, make_args, |
| use_kvm, run_tests, runtests_args, device_type, run_host_tests, |
| gcs_bucket): |
| api.goma.ensure_goma() |
| |
| with api.context(infra_steps=True): |
| assert manifest |
| assert remote |
| api.fuchsia.checkout( |
| build=api.buildbucket.build, |
| manifest=manifest, |
| remote=remote, |
| project=project, |
| ) |
| |
| src_dir = api.path['start_dir'].join('zircon') |
| build_dir = Build( |
| api=api, |
| target=target, |
| toolchain=toolchain, |
| make_args=make_args, |
| src_dir=src_dir, |
| test_cmd='runtests -o %s %s' % ( |
| api.fuchsia.results_dir_on_target, |
| runtests_args, |
| ), |
| needs_blkdev=(device_type == 'QEMU'), |
| device_type=device_type, |
| ) |
| |
| |
| if run_tests: |
| api.qemu.ensure_qemu() |
| api.swarming.ensure_swarming(version='latest') |
| api.isolated.ensure_isolated(version='latest') |
| if device_type == 'QEMU': |
| # The MinFS tool is generated during the Zircon build, so only after we |
| # build may we set the recipe module's tool path. |
| api.minfs.minfs_path = build_dir.join('tools', 'minfs') |
| |
| # Execute tests. |
| test_results = RunTestsInQEMU(api, target, build_dir, use_kvm) |
| else: |
| test_results = RunTestsOnDevice(api, target, build_dir, device_type) |
| if gcs_bucket and not api.properties.get('tryjob'): |
| test_results.upload_results( |
| gcs_bucket=gcs_bucket, |
| process_coverage_data=(toolchain=='profile'), |
| ) |
| test_results.raise_failures() |
| if run_host_tests: |
| test_results = RunTestsOnHost(api, build_dir) |
| test_results.raise_failures() |
| |
| |
| def GenTests(api): |
| ci_build = api.buildbucket.ci_build( |
| git_repo='https://fuchsia.googlesource.com/zircon', |
| ) |
| try_build = api.buildbucket.try_build( |
| git_repo='https://fuchsia.googlesource.com/zircon', |
| ) |
| |
| # Step test data for triggering the booted tests task. |
| booted_tests_trigger_data = api.step_data( |
| 'trigger booted tests', |
| api.swarming.trigger( |
| 'booted tests', |
| 'qemu', |
| task_id='11', |
| ), |
| ) |
| # Step test data for collecting core and booted tasks. |
| core_task_datum = api.swarming.task_data( |
| id='10', state=api.swarming.TaskState.SUCCESS, |
| output=CORE_TESTS_SUCCESS_STR, outputs=['output.fs']) |
| booted_task_datum = api.swarming.task_data( |
| id='11', state=api.swarming.TaskState.SUCCESS, outputs=['output.fs']) |
| collect_data = api.step_data('collect', api.swarming.collect( |
| task_data=(core_task_datum, booted_task_datum))) |
| # Step test data for triggering the core tests task. |
| core_tests_trigger_data = api.step_data( |
| 'trigger core tests', |
| api.swarming.trigger( |
| 'core tests', |
| 'qemu', |
| task_id='10', |
| ), |
| ) |
| test_data = (core_tests_trigger_data + |
| booted_tests_trigger_data + |
| collect_data + |
| api.fuchsia.test_step_data() |
| ) |
| yield (api.test('ci_arm64') + |
| ci_build + |
| api.properties(project='zircon', |
| manifest='manifest', |
| remote='https://fuchsia.googlesource.com/zircon', |
| target='arm64', |
| toolchain='gcc', |
| run_tests=True) + |
| test_data) |
| yield (api.test('ci_arm64_nokvm') + |
| ci_build + |
| api.properties(project='zircon', |
| manifest='manifest', |
| remote='https://fuchsia.googlesource.com/zircon', |
| target='arm64', |
| toolchain='gcc', |
| use_kvm=False, |
| run_tests=True) + |
| test_data) |
| yield (api.test('ci_host_tests') + |
| ci_build + |
| api.properties(project='zircon', |
| manifest='manifest', |
| remote='https://fuchsia.googlesource.com/zircon', |
| target='x64', |
| toolchain='gcc', |
| run_host_tests=True)) |
| yield (api.test('ci_host_and_target_tests') + |
| ci_build + |
| api.properties(project='zircon', |
| manifest='manifest', |
| remote='https://fuchsia.googlesource.com/zircon', |
| target='x64', |
| toolchain='gcc', |
| run_tests=True, |
| run_host_tests=True) + |
| test_data) |
| yield (api.test('ci_x86') + |
| ci_build + |
| api.properties(project='zircon', |
| manifest='manifest', |
| remote='https://fuchsia.googlesource.com/zircon', |
| target='x64', |
| toolchain='gcc', |
| run_tests=True) + |
| test_data) |
| yield (api.test('ci_x86_with_args') + |
| ci_build + |
| api.properties(project='zircon', |
| manifest='manifest', |
| remote='https://fuchsia.googlesource.com/zircon', |
| target='x64', |
| runtests_args='-L', |
| toolchain='gcc', |
| run_tests=True) + |
| test_data) |
| yield (api.test('ci_x86_nokvm') + |
| ci_build + |
| api.properties(project='zircon', |
| manifest='manifest', |
| remote='https://fuchsia.googlesource.com/zircon', |
| target='x64', |
| toolchain='gcc', |
| use_kvm=False, |
| run_tests=True) + |
| test_data) |
| |
| # Exercise all device types, since some recipe logic changes for certain |
| # devices. |
| for device_type in DEVICES: |
| target = 'x64' |
| if device_type == 'QEMU': |
| # QEMU is the default, well-exercised by other tests. |
| continue |
| if device_type == 'Khadas Vim2 Max': |
| target = 'arm64' |
| test_name = 'ci_device_' + re.sub(r'\s+', '_', device_type) |
| yield (api.test(test_name) + |
| ci_build + |
| api.properties(project='zircon', |
| manifest='manifest', |
| remote='https://fuchsia.googlesource.com/zircon', |
| target=target, |
| toolchain='gcc', |
| device_type=device_type, |
| run_tests=True) + |
| booted_tests_trigger_data + |
| api.step_data('collect', api.swarming.collect( |
| task_data=[api.swarming.task_data(outputs=['out.tar'])], |
| )) + |
| api.fuchsia.test_step_data()) |
| |
| yield (api.test('task_failure') + |
| ci_build + |
| api.properties(project='zircon', |
| manifest='manifest', |
| remote='https://fuchsia.googlesource.com/zircon', |
| target='x64', |
| toolchain='gcc', |
| run_tests=True) + |
| core_tests_trigger_data + |
| booted_tests_trigger_data + |
| api.step_data('collect', api.swarming.collect( |
| task_data=[ |
| api.swarming.task_data(id='10', state=api.swarming.TaskState.TASK_FAILURE), |
| api.swarming.task_data(id='11', state=api.swarming.TaskState.TASK_FAILURE), |
| ]))) |
| yield (api.test('asan') + |
| ci_build + |
| api.properties(project='zircon', |
| manifest='manifest', |
| remote='https://fuchsia.googlesource.com/zircon', |
| target='x64', |
| toolchain='asan', |
| run_tests=True) + |
| test_data) |
| yield (api.test('lto') + |
| api.properties(project='zircon', |
| manifest='manifest', |
| remote='https://fuchsia.googlesource.com/zircon', |
| target='x64', |
| toolchain='lto', |
| run_tests=True) + |
| test_data) |
| yield (api.test('thinlto') + |
| ci_build + |
| api.properties(project='zircon', |
| manifest='manifest', |
| remote='https://fuchsia.googlesource.com/zircon', |
| target='x64', |
| toolchain='thinlto', |
| run_tests=True) + |
| test_data) |
| yield (api.test('profile') + |
| ci_build + |
| api.properties(project='zircon', |
| manifest='manifest', |
| remote='https://fuchsia.googlesource.com/zircon', |
| target='x64', |
| toolchain='profile', |
| run_tests=True, |
| gcs_bucket='fuchsia-build') + |
| test_data) |
| yield (api.test('cq_try') + |
| try_build + |
| api.properties.tryserver( |
| project='zircon', |
| manifest='manifest', |
| remote='https://fuchsia.googlesource.com/zircon', |
| target='x64', |
| toolchain='clang', |
| run_tests=True) + |
| test_data) |
| yield (api.test('no_run_tests') + |
| try_build + |
| api.properties.tryserver( |
| project='zircon', |
| manifest='manifest', |
| remote='https://fuchsia.googlesource.com/zircon', |
| target='x64', |
| toolchain='clang')) |
| yield (api.test('debug_buildonly') + |
| try_build + |
| api.properties.tryserver( |
| project='zircon', |
| manifest='manifest', |
| remote='https://fuchsia.googlesource.com/zircon', |
| target='x64', |
| toolchain='clang', |
| make_args=['DEBUG_HARD=1'])) |
| |
| # This task should trigger a failure because its output does not contain |
| # CORE_TESTS_SUCCESS_STR |
| failed_core_task_datum = api.swarming.task_data( |
| id='10', output='not success') |
| core_tests_failed_collect_data = api.step_data( |
| 'collect', |
| api.swarming.collect(task_data=(failed_core_task_datum, booted_task_datum) |
| )) |
| yield (api.test('ci_core_test_failure') + |
| ci_build + |
| api.properties(project='zircon', |
| manifest='manifest', |
| remote='https://fuchsia.googlesource.com/zircon', |
| target='x64', |
| toolchain='clang', |
| run_tests=True) + |
| core_tests_trigger_data + |
| booted_tests_trigger_data + |
| core_tests_failed_collect_data) |
