| # Copyright 2019 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. |
| |
| import copy |
| |
| from recipe_engine import recipe_api |
| |
| # System path at which authorized SSH keys are stored. |
| AUTHORIZED_KEY_PATH = 'data/ssh/authorized_keys' |
| # The path to the botanist config on the host. |
| BOTANIST_DEVICE_CONFIG = '/etc/botanist/config.json' |
| # The path to the catalyst config on the host. |
| CATALYST_DEVICE_CONFIG = '/etc/catalyst/config.json' |
| # The log level to use for botanist invocations in test tasks. Can be one of |
| # "fatal", "error", "warning", "info", "debug", or "trace", where "trace" is |
| # the most verbose, and fatal is the least. |
| BOTANIST_LOG_LEVEL = 'debug' |
| # Name of image manifest produced by the build. |
| IMAGES_JSON = 'images.json' |
| # The path in the BootFS manifest that we want runcmds to show up at. |
| RUNCMDS_BOOTFS_PATH = 'infra/runcmds' |
| |
| STORAGE_FULL = 'storage-full' |
| |
| # The PCI address to use for the block device to contain test results. |
| TEST_FS_PCI_ADDR = '06.0' |
| |
| _PRIVATE_KEY_PATH = 'private_key' |
| |
| # The version of catalyst to use. |
| CATALYST_CIPD_REVISION = "git_revision:12ba48e4eea05053e01e834502042a8c710bdc99" |
| |
| |
| class _TaskRequester(object): |
| """Creates requests for swarming tasks that run tests.""" |
| |
| def __init__(self, api, buildbucket_build, per_test_timeout_secs, pave, pool, |
| swarming_expiration_timeout_secs, swarming_io_timeout_secs, |
| timeout_secs, use_runtests, default_service_account, |
| targets_serial): |
| self._api = api |
| self._buildbucket_build = buildbucket_build |
| self._per_test_timeout_secs = per_test_timeout_secs |
| self._pave = pave |
| self._pool = pool |
| self._swarming_expiration_timeout_secs = swarming_expiration_timeout_secs |
| self._swarming_io_timeout_secs = swarming_io_timeout_secs |
| self._timeout_secs = timeout_secs |
| self._use_runtests = use_runtests |
| self._default_service_account = default_service_account |
| self._targets_serial = targets_serial |
| |
| def request(self, shard, build_results): |
| # Copy since we modify it for each shard. |
| build_results = copy.deepcopy(build_results) |
| task_request = self._construct_test_task_request( |
| build_results=build_results, shard=shard, pave=self._pave) |
| |
| return self._api.build.ShardTaskRequest(shard, task_request) |
| |
| def _construct_test_task_request(self, build_results, shard, pave): |
| # To freely archive files from the build directory, the source, and those we |
| # dynamically create, we create a tree of symlinks in a fresh directory and |
| # isolate that. This solves the problems of (a) finding a root directory |
| # that works for all artifacts, (b) being able to create files in that |
| # directory without fear of collision, and (c) not having to isolate |
| # extraneous files. |
| isolate_tree = self._api.file.symlink_tree( |
| root=self._api.path.mkdtemp('isolate')) |
| |
| test_manifest = 'tests.json' |
| self._api.file.write_json( |
| 'write test manifest', |
| isolate_tree.root.join(test_manifest), |
| [test.render_to_jsonish() for test in shard.tests], |
| indent=2) |
| |
| cmd = [] |
| outputs = [] |
| ensure_file = self._api.cipd.EnsureFile() |
| dimensions = {'pool': self._pool} |
| test_bot_cpu = 'x64' |
| is_emu_type = self._api.emu.is_emulator_type(shard.device_type) |
| |
| # This command spins up a metadata server that allows its subcommands to |
| # automagically authenticate with LUCI auth, provided the sub-exec'ed tool |
| # was written in go or dart and respectively makes use of the standard |
| # cloud.google.com/go/compute/metadata or |
| # github.com/dart-lang/googleapis_auth authentication libraries. Such |
| # libraries look for a metadata server under environment variables |
| # like $GCE_METADATA_HOST, which LUCI emulates. |
| service_account = shard.service_account or self._default_service_account |
| if service_account: |
| # TODO(fxbug.dev/37142): Find a way to use the version that LUCI is |
| # currently using, instead of 'latest'. |
| ensure_file.add_package('infra/tools/luci-auth/${platform}', 'latest') |
| cmd.extend(['./luci-auth', 'context', '--']) |
| |
| if is_emu_type: |
| dimensions.update(os='Debian', cpu=build_results.target, kvm='1') |
| # To take advantage of KVM, we execute QEMU-arm tasks on arm hardware. |
| test_bot_cpu = build_results.target |
| else: |
| if self._targets_serial: |
| dimensions['serial'] = '1' |
| dimensions.update(shard.dimensions) |
| |
| image_manifest = IMAGES_JSON |
| |
| if shard.targets_fuchsia: |
| # Construct the catalyst command. |
| ensure_file.add_package('fuchsia/infra/catalyst/${platform}', |
| CATALYST_CIPD_REVISION) |
| cmd.extend([ |
| './catalyst', |
| '-images', image_manifest, |
| '-bootserver', './bootserver_new', |
| ]) # yapf: disable |
| |
| if not is_emu_type: |
| # If this test shard runs on physical devices, catalyst needs to be given |
| # a device config. |
| cmd.extend(['-config', CATALYST_DEVICE_CONFIG]) |
| |
| botanist_cmd = [ |
| './botanist', |
| '-level', BOTANIST_LOG_LEVEL, |
| 'run', |
| '-images', image_manifest, |
| '-timeout', '%ds' % self._timeout_secs, |
| ] # yapf: disable |
| |
| # In the emulator case, serial is redirected to stdio. |
| if not is_emu_type: |
| botanist_cmd.extend( |
| ['-serial-log', self._api.testing_requests.SERIAL_LOG_NAME]) |
| outputs.append(self._api.testing_requests.SERIAL_LOG_NAME) |
| |
| if pave: |
| botanist_cmd.extend([ |
| '-syslog', self._api.testing_requests.SYSLOG_NAME, |
| ]) # yapf: disable |
| outputs.append(self._api.testing_requests.SYSLOG_NAME) |
| |
| if is_emu_type: |
| botanist_cmd.extend(['-ssh', _PRIVATE_KEY_PATH]) |
| else: |
| # TODO(fxbug.dev/40840): Once we can scope the proxy server to a |
| # an individual task, we can make free use of it in the emulator case. |
| botanist_cmd.extend([ |
| # For container networking and authentication reasons, we access GCS |
| # via a proxy server running on the controller. |
| '-repo', self._api.artifacts.package_repo_url(host='$GCS_PROXY_HOST'), |
| '-blobs', self._api.artifacts.package_blob_url(host='$GCS_PROXY_HOST'), |
| ]) # yapf: disable |
| else: |
| botanist_cmd.append('-netboot') |
| |
| config = BOTANIST_DEVICE_CONFIG |
| if is_emu_type: |
| config = './qemu.json' |
| qemu_config = [{ |
| 'type': shard.device_type.lower(), |
| 'path': './%s/bin' % shard.device_type.lower(), |
| 'target': build_results.target, |
| 'cpu': 8, |
| 'memory': 8192, |
| 'kvm': True, |
| }] |
| |
| if shard.device_type == 'AEMU': |
| self._api.emu.add_aemu_to_ensure_file(ensure_file, subdir='aemu/bin') |
| elif shard.device_type == 'QEMU': |
| self._api.emu.add_qemu_to_ensure_file(ensure_file, subdir='qemu') |
| |
| self._api.file.write_json( |
| 'write qemu config', |
| isolate_tree.root.join('qemu.json'), |
| qemu_config, |
| indent=2) |
| |
| botanist_cmd.extend(['-config', config]) |
| |
| cmd.extend(botanist_cmd) |
| |
| cmd.extend([ |
| './testrunner', |
| '-archive', |
| self._api.testing_requests.TEST_RESULTS_ARCHIVE_NAME, |
| ]) |
| if self._use_runtests: |
| cmd.append('-use-runtests') |
| if self._per_test_timeout_secs: |
| cmd.extend(['-per-test-timeout', '%ds' % self._per_test_timeout_secs]) |
| cmd.append(test_manifest) |
| |
| outputs.append(self._api.testing_requests.TEST_RESULTS_ARCHIVE_NAME) |
| |
| isolated_hash = self._api.testing_requests._isolate_build_artifacts( |
| isolate_tree, |
| build_results, |
| shard=shard, |
| test_bot_cpu=test_bot_cpu, |
| ) |
| |
| env_name = '%s-%s' % (shard.device_type or shard.os, build_results.target) |
| tags = {'test_environment_name': [env_name]} |
| |
| request = (self._api.swarming.task_request(). |
| with_name(shard.name). |
| with_tags(tags) |
| ) #yapf: disable |
| if service_account: |
| request = request.with_service_account(service_account) |
| return request.with_slice(0, request[0]. |
| with_command(cmd). |
| with_isolated(isolated_hash). |
| with_dimensions(**dimensions). |
| with_expiration_secs(self._swarming_expiration_timeout_secs). |
| with_io_timeout_secs(self._swarming_io_timeout_secs). |
| with_execution_timeout_secs(self._timeout_secs). |
| with_outputs(outputs). |
| with_cipd_ensure_file(ensure_file). |
| with_env_vars(**self._test_task_env_vars(shard, build_results)) |
| ) #yapf: disable |
| |
| def _test_task_env_vars(self, shard, build_results): |
| """Returns the environment variables to be set for the test task. |
| |
| Returns: |
| A dict mapping string env var names to string values. |
| """ |
| build = self._buildbucket_build |
| commit = build.input.gitiles_commit |
| llvm_symbolizer = self._api.path.basename(build_results.llvm_symbolizer) |
| env_vars = dict( |
| # `${ISOLATED_OUTDIR}` is a magic string that Swarming will replace |
| # with a temporary directory into which files will be automatically |
| # collected upon exit of a task. |
| FUCHSIA_TEST_OUTDIR='${ISOLATED_OUTDIR}', |
| BUILDBUCKET_ID=str(build.id), |
| BUILD_BOARD=build_results.board, |
| BUILD_TYPE=build_results.build_type, |
| BUILD_PRODUCT=build_results.product, |
| BUILD_TARGET=build_results.target, |
| BUILDBUCKET_BUCKET=build.builder.bucket, |
| |
| # Used for symbolization: |
| ASAN_SYMBOLIZER_PATH=llvm_symbolizer, |
| UBSAN_SYMBOLIZER_PATH=llvm_symbolizer, |
| LSAN_SYMBOLIZER_PATH=llvm_symbolizer, |
| |
| # Used by the catapult converter |
| BUILD_CREATE_TIME=str(build.create_time.seconds), |
| BUILDER_NAME=build.builder.builder, |
| FUCHSIA_DEVICE_TYPE=shard.device_type, |
| INPUT_COMMIT_HOST=commit.host, |
| INPUT_COMMIT_PROJECT=commit.project, |
| INPUT_COMMIT_REF=commit.ref, |
| ) |
| # For some reason, empty string environment variables sent to the swarming |
| # API get interpreted as null and rejected. So don't bother sending them to |
| # avoid breaking the task request. |
| # TODO(olivernewman): Figure out whether this logic should be moved into |
| # the upstream swarming module (or obviated by fixing the "" -> null |
| # behavior). |
| return {k: v for k, v in env_vars.iteritems() if v} |
| |
| |
| class TestingRequestsApi(recipe_api.RecipeApi): |
| """APIs for constructing Swarming task requests to test Fuchsia.""" |
| |
| SERIAL_LOG_NAME = 'serial.txt' |
| SYSLOG_NAME = 'syslog.txt' |
| TEST_RESULTS_ARCHIVE_NAME = 'out.tar' |
| TEST_RESULTS_MINFS_NAME = 'output.fs' |
| |
| def shard_requests( |
| self, |
| build_results, |
| buildbucket_build, |
| per_test_timeout_secs, |
| pool, |
| shards, |
| swarming_expiration_timeout_secs, |
| swarming_io_timeout_secs, |
| use_runtests, |
| default_service_account=None, |
| pave=True, |
| # TODO(garymm): Remove default value. |
| # We should always get this from a spec. |
| timeout_secs=40 * 60, |
| targets_serial=False): |
| """Returns a _ShardTaskRequest for each shard in build_artifact.shards. |
| |
| Args: |
| build_results (FuchsiaBuildResults): The Fuchsia build results to test. |
| buildbucket_build (build_pb2.Build): The buildbucket build that is going |
| to orchestrate testing. |
| per_test_timeout_secs (int): Any test that executes for longer than this |
| will be considered failed. |
| pool (str): The Swarming pool to schedule test tasks in. |
| shards (list of testsharder.Shard): Test shards. |
| use_runtests (bool): Whether to use runtests (or else run_test_component) |
| when executing tests on target. |
| default_service_account (str or None): The default service account to run the |
| test task with. This is required for fetching images from GCS. |
| pave (bool): Whether to pave (or else 'netboot') the system; this is |
| effectively equivalent to "not bringup" and is treated as such (even for |
| QEMU). |
| timeout_secs (int): The amount of seconds to wait for the tests to execute |
| before giving up. |
| targets_serial (bool): Whether the task should target a bot with serial |
| enabled. |
| """ |
| # Embed the authorized key into the appropriate ZBI. This enabled us to SSH |
| # into QEMU, in which case we are unable to supply the key at pave-time (as |
| # QEMU instances are not paved.) |
| has_emu_shard = any( |
| self.m.emu.is_emulator_type(shard.device_type) for shard in shards) |
| if pave and has_emu_shard: |
| self.m.zbi.zbi_path = build_results.zbi |
| zbi_name = self._zbi_name(build_results) |
| zbi_path = build_results.fuchsia_build_dir.join( |
| build_results.images[zbi_name]['path']) |
| |
| self.m.zbi.copy_and_extend( |
| step_name='embed authorized key', |
| input_image=zbi_path, |
| output_image=zbi_path, |
| manifest={AUTHORIZED_KEY_PATH: build_results.authorized_key}, |
| ) |
| |
| task_requester = _TaskRequester( |
| self.m, |
| buildbucket_build=buildbucket_build, |
| per_test_timeout_secs=per_test_timeout_secs, |
| pave=pave, |
| pool=pool, |
| swarming_expiration_timeout_secs=swarming_expiration_timeout_secs, |
| swarming_io_timeout_secs=swarming_io_timeout_secs, |
| timeout_secs=timeout_secs, |
| use_runtests=use_runtests, |
| default_service_account=default_service_account, |
| targets_serial=targets_serial, |
| ) |
| shard_requests = [] |
| for s in shards: |
| with self.m.step.nest('shard %s' % s.name): |
| shard_requests.append(task_requester.request(s, build_results)) |
| return shard_requests |
| |
| def deprecated_shard_requests(self, |
| build_results, |
| test_cmds, |
| device_type, |
| pool, |
| timeout_secs, |
| pave, |
| swarming_expiration_timeout_secs=18000, |
| swarming_io_timeout_secs=5 * 60, |
| default_service_account=None): |
| """Returns a swarming task request for testing in the deprecated way. |
| |
| Args: |
| build_results (FuchsiaBuildResults): The Fuchsia build to test. |
| test_cmds (list[str]): Command to have Fuchsia run on boot. |
| pool (str): Swarming pool from which the test task will be drawn. |
| timeout_secs (int): The amount of seconds to wait for the tests to execute |
| before giving up. |
| pave (bool): Whether to pave the image to disk. Ignored if device_type == |
| 'QEMU'. |
| swarming_expiration_timeout_secs (int): Maximum run time for the swarming |
| task, once scheduled (enforced by swarming). |
| swarming_io_timeout_secs (int): The swarming task will be killed if it does |
| not produce any output for this long. |
| default_service_account (str or None): The default service account to run the |
| task with. |
| |
| Returns: |
| A list of a single ShardTaskRequest. |
| """ |
| assert test_cmds |
| assert device_type |
| |
| self.m.minfs.minfs_path = build_results.minfs |
| self.m.zbi.zbi_path = build_results.zbi |
| |
| # Copy build_results because we modify its contents below. |
| build_results = copy.deepcopy(build_results) |
| self._install_runcmds_files( |
| build_results, |
| device_type=device_type, |
| pave=pave, |
| test_cmds=test_cmds, |
| ) |
| |
| if self.m.emu.is_emulator_type(device_type): |
| task = self._construct_legacy_qemu_task_request( |
| task_name='all tests', |
| build_results=build_results, |
| pool=pool, |
| timeout_secs=timeout_secs, |
| swarming_expiration_timeout_secs=swarming_expiration_timeout_secs, |
| swarming_io_timeout_secs=swarming_io_timeout_secs, |
| qemu_type=device_type, |
| service_account=default_service_account, |
| ) |
| else: |
| task = self._construct_device_task_request( |
| task_name='all tests', |
| device_type=device_type, |
| build_results=build_results, |
| pool=pool, |
| pave=pave, |
| timeout_secs=timeout_secs, |
| swarming_expiration_timeout_secs=swarming_expiration_timeout_secs, |
| swarming_io_timeout_secs=swarming_io_timeout_secs, |
| service_account=default_service_account, |
| ) |
| # In the deprecated testing code paths, shards are not used, but it makes |
| # other code simpler to have a valid shard here. |
| dummy_shard = self.m.testsharder.Shard('dummy', (), {}) |
| return [self.m.build.ShardTaskRequest(dummy_shard, task)] |
| |
| def deprecated_test_cmds(self, test_spec): |
| runtests_cmd_parts = ['runtests', '-o', self.results_dir_on_target] |
| if test_spec.per_test_timeout_secs: |
| runtests_cmd_parts.extend(['-i', '%d' % test_spec.per_test_timeout_secs]) |
| runtests_cmd_parts.append(test_spec.runtests_args) |
| return [' '.join(runtests_cmd_parts)] |
| |
| @property |
| def results_dir_on_target(self): |
| """The directory on target to which target test results will be written.""" |
| return '/tmp/infra-test-output' |
| |
| def _construct_legacy_qemu_task_request(self, |
| task_name, |
| build_results, |
| pool, |
| timeout_secs, |
| swarming_expiration_timeout_secs, |
| swarming_io_timeout_secs, |
| qemu_type, |
| service_account, |
| shard=None): |
| """Constructs a Swarming task request which runs Fuchsia tests inside QEMU. |
| |
| Expects the build and artifacts to be at the same place they were at |
| the end of the build. |
| |
| Args: |
| build_results (FuchsiaBuildResults): The Fuchsia build to test. |
| pool (str): Swarming pool from which the test task will be drawn. |
| timeout_secs (int): The amount of seconds to wait for the tests to execute |
| before giving up. |
| qemu_type (str): type of qemu, either QEMU or AEMU. |
| service_account (str or None): The service account to run the task with. |
| shard (api.testsharder.Shard or None): The shard associated with the task or |
| None if it's not a shard. |
| |
| Returns: |
| An api.swarming.TaskRequest representing the swarming task request. |
| """ |
| # To freely archive files from the build directory, the source, and those we |
| # dynamically create, we create a tree of symlinks in a fresh directory and |
| # isolate that. This solves the problems of (a) finding a root directory |
| # that works for all artifacts, (b) being able to create files in that |
| # directory without fear of collision, and (c) not having to isolate |
| # extraneous files. |
| isolate_tree = self.m.file.symlink_tree(root=self.m.path.mkdtemp('isolate')) |
| |
| # As part of running tests, we'll send a MinFS image over to another machine |
| # which will be declared as a block device in QEMU, at which point |
| # Fuchsia will mount it and write test output to. We choose 3.5G for the |
| # MinFS image arbitrarily, as it appears it can hold our test output |
| # comfortably without going overboard on size. |
| # |
| minfs_image_path = isolate_tree.root.join(self.TEST_RESULTS_MINFS_NAME) |
| self.m.minfs.create(minfs_image_path, '3584M', name='create test image') |
| |
| cmd = [] |
| ensure_file = self.m.cipd.EnsureFile() |
| if service_account: |
| # TODO(fxbug.dev/37142): Find a way to use the version that LUCI is |
| # currently using, instead of 'latest'. |
| ensure_file.add_package('infra/tools/luci-auth/${platform}', 'latest') |
| cmd.extend(['./luci-auth', 'context', '--']) |
| |
| image_manifest = IMAGES_JSON |
| |
| cmd.extend([ |
| './botanist', |
| '-level', BOTANIST_LOG_LEVEL, |
| 'qemu', |
| '-type', '%s' % qemu_type.lower(), |
| '-qemu-dir', './%s/bin' % qemu_type.lower(), |
| '-images', image_manifest, |
| '-arch', build_results.target, |
| '-minfs', self.TEST_RESULTS_MINFS_NAME, |
| '-pci-addr', TEST_FS_PCI_ADDR, |
| '-use-kvm' |
| ]) # yapf: disable |
| |
| variants = ('asan', 'asan-ubsan', 'profile') |
| if [v for v in variants if v in build_results.variants]: |
| cmd.extend([ |
| '-cpu', |
| str(8), |
| '-memory', |
| str(8192), |
| ]) |
| |
| # storage-full not being present signifies the exclusion of the system |
| # partition, which means `boot` (i.e. running on boot) must be used instead |
| # of `system` (i.e., running after the system partition is mounted). |
| storage_free_build = STORAGE_FULL not in build_results.images |
| arg_key = 'zircon.autorun.%s' % ('boot' if storage_free_build else 'system') |
| cmd.append('%s=/boot/bin/sh+/boot/%s' % (arg_key, RUNCMDS_BOOTFS_PATH)) |
| |
| isolated_hash = self._isolate_build_artifacts( |
| isolate_tree, |
| build_results, |
| # To take advantage of KVM, we execute QEMU-arm tasks on arm hardware. |
| test_bot_cpu=build_results.target, |
| legacy_qemu=True, |
| ) |
| |
| if qemu_type == 'AEMU': |
| self.m.emu.add_aemu_to_ensure_file(ensure_file, subdir='aemu/bin') |
| elif qemu_type == 'QEMU': |
| self.m.emu.add_qemu_to_ensure_file(ensure_file, subdir='qemu') |
| |
| env_name = '%s-%s' % (qemu_type, build_results.target) |
| tags = { |
| # consumed by google3 results uploader |
| 'test_environment_name': [env_name], |
| } |
| request = self.m.swarming.task_request().with_name(task_name).with_tags( |
| tags) |
| if service_account: |
| request = request.with_service_account(service_account) |
| return (request.with_slice(0, request[0]. |
| with_command(cmd). |
| with_isolated(isolated_hash). |
| with_dimensions(pool=pool, os='Debian', cpu=build_results.target, kvm='1'). |
| with_io_timeout_secs(swarming_io_timeout_secs). |
| with_execution_timeout_secs(timeout_secs). |
| with_expiration_secs(swarming_expiration_timeout_secs). |
| with_outputs([self.TEST_RESULTS_MINFS_NAME]). |
| with_cipd_ensure_file(ensure_file) |
| )) #yapf: disable |
| |
| def _construct_device_task_request(self, task_name, device_type, |
| build_results, pool, pave, timeout_secs, |
| swarming_expiration_timeout_secs, |
| swarming_io_timeout_secs, service_account): |
| """Constructs a Swarming task request to run Fuchsia tests on a device. |
| |
| Expects the build and artifacts to be at the same place they were at |
| the end of the build. |
| |
| Args: |
| build_results (FuchsiaBuildResults): The Fuchsia build to test. |
| pool (str): Swarming pool from which the test task will be drawn. |
| pave (bool): Whether or not the build artifacts should be paved. |
| timeout_secs (int): The amount of seconds to wait for the tests to execute |
| before giving up. |
| service_account (str or None): The service account to run the task with. |
| |
| Returns: |
| An api.swarming.TaskRequest representing the swarming task request. |
| """ |
| cmd = [] |
| ensure_file = self.m.cipd.EnsureFile() |
| if service_account: |
| # TODO(fxbug.dev/37142): Find a way to use the version that LUCI is |
| # currently using, instead of 'latest'. |
| ensure_file.add_package('infra/tools/luci-auth/${platform}', 'latest') |
| cmd.extend(['./luci-auth', 'context', '--']) |
| |
| image_manifest = IMAGES_JSON |
| |
| # Download catalyst. |
| ensure_file.add_package('fuchsia/infra/catalyst/${platform}', |
| CATALYST_CIPD_REVISION) |
| |
| # Construct the catalyst command. |
| cmd.extend([ |
| './catalyst', |
| '-images', |
| image_manifest, |
| '-bootserver', |
| './bootserver_new', |
| '-config', |
| CATALYST_DEVICE_CONFIG, |
| ]) |
| |
| # Construct the botanist command. |
| cmd.extend([ |
| './botanist', |
| '-level', BOTANIST_LOG_LEVEL, |
| 'zedboot', |
| '-config', BOTANIST_DEVICE_CONFIG, |
| '-images', image_manifest, |
| '-results-dir', self.results_dir_on_target, |
| '-out', self.TEST_RESULTS_ARCHIVE_NAME, |
| '-serial-log', self.SERIAL_LOG_NAME, |
| ]) # yapf: disable |
| |
| if not pave: |
| cmd.append('-netboot') |
| |
| # storage-full not being present signifies the exclusion of the system |
| # partition, which means `boot` (i.e. running on boot) must be used instead |
| # of `system` (i.e., running after the system partition is mounted). |
| storage_free_build = STORAGE_FULL not in build_results.images |
| arg_key = 'zircon.autorun.%s' % ('boot' if storage_free_build else 'system') |
| cmd.append('%s=/boot/bin/sh+/boot/%s' % (arg_key, RUNCMDS_BOOTFS_PATH)) |
| |
| # To freely archive files from the build directory, the source, and those we |
| # dynamically create, we create a tree of symlinks in a fresh directory and |
| # isolate that. This solves the problems of (a) finding a root directory |
| # that works for all artifacts, (b) being able to create files in that |
| # directory without fear of collision, and (c) not having to isolate |
| # extraneous files. |
| isolate_tree = self.m.file.symlink_tree(root=self.m.path.mkdtemp('isolate')) |
| isolated_hash = self._isolate_build_artifacts(isolate_tree, build_results) |
| |
| dimensions = { |
| 'pool': pool, |
| 'device_type': device_type, |
| } |
| |
| env_name = '%s-%s' % (device_type, build_results.target) |
| tags = {'test_environment_name': [env_name]} |
| request = self.m.swarming.task_request().with_name(task_name).with_tags( |
| tags) |
| if service_account: |
| request = request.with_service_account(service_account) |
| return (request.with_slice(0, request[0]. |
| with_command(cmd). |
| with_isolated(isolated_hash). |
| with_dimensions(**dimensions). |
| with_expiration_secs(swarming_expiration_timeout_secs). |
| with_io_timeout_secs(swarming_io_timeout_secs). |
| with_execution_timeout_secs(timeout_secs). |
| with_outputs([self.TEST_RESULTS_ARCHIVE_NAME, self.SERIAL_LOG_NAME]). |
| with_cipd_ensure_file(ensure_file) |
| )) #yapf: disable |
| |
| def _create_runcmds_script(self, device_type, test_cmds, output_path): |
| """Creates a script for running tests on boot.""" |
| # The device topological path is the toplogical path to the block device |
| # which will contain test output. |
| device_topological_path = '/dev/sys/pci/00:%s/virtio-block/block' % ( |
| TEST_FS_PCI_ADDR) |
| |
| # Script that mounts the block device to contain test output and runs tests, |
| # dropping test output into the block device. |
| results_dir = self.results_dir_on_target |
| runcmds = [ |
| 'mkdir %s' % results_dir, |
| ] |
| if self.m.emu.is_emulator_type(device_type): |
| runcmds.extend([ |
| # Wait until the MinFS test image shows up (max <timeout> ms). |
| 'waitfor class=block topo=%s timeout=60000' % device_topological_path, |
| 'mount %s %s' % (device_topological_path, results_dir), |
| ] + test_cmds + [ |
| 'umount %s' % results_dir, |
| 'dm poweroff', |
| ]) |
| else: |
| runcmds.extend(test_cmds) |
| runcmds_bytes = [] |
| for line in runcmds: |
| if isinstance(line, unicode): |
| runcmds_bytes.append(line.encode('utf-8')) |
| elif isinstance(line, str): |
| runcmds_bytes.append(line) |
| else: # pragma: no cover |
| assert False, 'line is not unicode or a str: %s, %s' % (line, |
| type(line)) |
| self.m.file.write_text('write runcmds', output_path, |
| '\n'.join(runcmds_bytes)) |
| |
| def _isolate_build_artifacts( |
| self, |
| isolate_tree, |
| build_results, |
| shard=None, |
| test_bot_cpu='x64', |
| legacy_qemu=False, |
| ): |
| """Populates a tree with build artifacts and isolates it. |
| |
| Specifically, the following is linked into or created within the tree: |
| - The images in the build are linked in and manifest of them is created |
| in the root, if targeting a fuchsia device; |
| - The Linux/Mac tests in the shard and their runtime dependencies. |
| |
| Args: |
| isolate_tree (api.file.SymlinkTree): A tree into which artifacts may be |
| linked. |
| build_results (FuchsiaBuildResults): The result of a fuchsia build. |
| shard (api.testsharder.Shard or None): A test shard. |
| test_bot_cpu (str or None): The host cpu of the bot running the test task. |
| legacy_qemu (bool): Whether to only isolate the images needed to run QEMU |
| alone. |
| |
| Returns: |
| The isolated hash that may be used to reference and download the |
| artifacts. |
| """ |
| |
| def register_link(relpath): |
| """Prepares a symlink of a relative path within the build directory to the tree.""" |
| isolate_tree.register_link( |
| target=build_results.fuchsia_build_dir.join(relpath), |
| linkname=isolate_tree.root.join(relpath), |
| ) |
| |
| # TODO(ihuh): Remove once paving from GCS is working. |
| if shard is None or shard.targets_fuchsia: |
| image_list = build_results.images.values() |
| # In the case of an emulated target, we restrict what we isolate to the |
| # bare essentials to avoid the needless downloading of several gigabytes |
| # of images on the other end. |
| is_emulated_target = ( |
| (shard is None and legacy_qemu) or |
| (shard and self.m.emu.is_emulator_type(shard.device_type)) |
| ) # yapf: disable |
| if is_emulated_target: |
| image_list = [ |
| img for img in image_list |
| if img['name'] in ['qemu-kernel', 'zircon-a', 'storage-full'] |
| ] # yapf: disable |
| image_manifest_path = isolate_tree.root.join(IMAGES_JSON) |
| self.m.file.write_json( |
| 'write image manifest', image_manifest_path, image_list, indent=2) |
| for image in image_list: |
| register_link(image['path']) |
| |
| if shard: |
| for test in shard.tests: |
| if test.os in ['linux', 'mac']: |
| register_link(test.path) |
| for dep in shard.deps: |
| register_link(dep) |
| |
| # If targeting QEMU we include a private key corresponding to an authorized |
| # key already in the boot image; this is needed as we do not pave QEMU. |
| if shard and self.m.emu.is_emulator_type(shard.device_type): |
| isolate_tree.register_link( |
| target=build_results.private_key, |
| linkname=isolate_tree.root.join(_PRIVATE_KEY_PATH), |
| ) |
| |
| for tool in [ |
| build_results.tool('botanist', test_bot_cpu), |
| build_results.tool('testrunner', test_bot_cpu), |
| build_results.llvm_symbolizer, |
| # TODO(fxb/38517): Replace with bootserver after there is only one. |
| build_results.tool('bootserver_new'), |
| ]: |
| tool_name = self.m.path.basename(tool) |
| isolate_tree.register_link( |
| target=tool, linkname=isolate_tree.root.join(tool_name)) |
| |
| isolate_tree.create_links('create tree of build artifacts') |
| isolated = self.m.isolated.isolated(isolate_tree.root) |
| isolated.add_dir(isolate_tree.root) |
| return isolated.archive('isolate build artifacts') |
| |
| def _zbi_name(self, build_results, pave=True): |
| zbi_name = next( |
| (image['name'] for image in build_results.images.values() if '--boot' in |
| image.get('bootserver_%s' % ('pave' if pave else 'netboot'), [])), |
| 'zircon-a') |
| return zbi_name |
| |
| def _install_runcmds_files(self, |
| build_results, |
| per_test_timeout_secs=None, |
| device_type=None, |
| pave=False, |
| test_cmds=None): |
| """Creates the files used to invoke runtests on boot. |
| |
| This is only necessary for QEMU shards, which are the only shards that |
| use runcmds, and the non-sharding codepath. |
| """ |
| assert device_type and test_cmds |
| self.m.zbi.zbi_path = build_results.zbi |
| |
| # TODO(fxbug.dev/41930): The deprecated QEMU codepath explicitly looks for |
| # a zircon-a. The attached bug will enable us to stop making these sorts of |
| # assumptions. |
| if self.m.emu.is_emulator_type(device_type): |
| zbi_name = 'zircon-a' |
| else: |
| zbi_name = self._zbi_name(build_results, pave) |
| runcmds_path = self.m.path['cleanup'].join('runcmds') |
| self._create_runcmds_script(device_type, test_cmds, runcmds_path) |
| |
| zbi_path = build_results.fuchsia_build_dir.join( |
| build_results.images[zbi_name]['path']) |
| |
| # Inject the runcmds script and/or authorized key into the bootfs image. |
| self.m.zbi.copy_and_extend( |
| step_name='create zbi', |
| input_image=zbi_path, |
| output_image=zbi_path, |
| manifest={RUNCMDS_BOOTFS_PATH: runcmds_path}, |
| ) |
