Include OTAFIX bootloader variants in complete release builds
This commit is contained in:
1 parent
bbe29fbf95
commit
0d93f73837
13 files changed
+1527
-61
No files matched your search
@@ -8,6 +8,7 @@ import subprocess
|
||||
import struct
|
||||
import sys
|
||||
import hashlib
|
||||
from copy import deepcopy
|
||||
from unittest.mock import patch
|
||||
import zipfile
|
||||
|
||||
@@ -15,7 +16,7 @@ ROOT = Path(__file__).resolve().parents[1]
|
||||
spec = importlib.util.spec_from_file_location("package_cascade_release", ROOT / "scripts/package_cascade_release.py")
|
||||
package = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(package)
|
||||
from motalib import FwIdent, Nrf52Layout, ensure_endf, ensure_nrf52_layout, target_id_for_env
|
||||
from motalib import ENDF_LEN, FwIdent, Nrf52Layout, ensure_endf, ensure_nrf52_layout, target_id_for_env
|
||||
|
||||
|
||||
class ReleaseQualificationTest(unittest.TestCase):
|
||||
@@ -106,8 +107,9 @@ class ReleaseQualificationTest(unittest.TestCase):
|
||||
def sensor_record(self, directory, sensor, *, target='test_repeater', target_id=None,
|
||||
hw_id='TEST', app_base=0x26000, flags=0x10, fw_version=0x01110107,
|
||||
version='v1.17.1.7-dev-deadbeef', storage='internal_flash_and_retained_ram',
|
||||
extra_application=b''):
|
||||
stem = target + '-' + sensor + '-ota-' + version
|
||||
extra_application=b'', artifact_variant=''):
|
||||
artifact_target = target + artifact_variant + '-' + sensor + '-ota'
|
||||
stem = artifact_target + '-' + version
|
||||
application, _ = ensure_endf(ensure_nrf52_layout(b'OTA: status\0invalid in-place patch geometry\0'
|
||||
+ extra_application,
|
||||
Nrf52Layout(app_base, 0xED000, 0xED000, flags)),
|
||||
@@ -118,7 +120,7 @@ class ReleaseQualificationTest(unittest.TestCase):
|
||||
archive.writestr('manifest.json', json.dumps({'manifest': {
|
||||
'application': {'bin_file': 'application.bin', 'dat_file': 'application.dat'}}}))
|
||||
archive.writestr('application.dat', b'fixture init')
|
||||
manifest = self.manifest(target, artifact_target=target + '-' + sensor + '-ota',
|
||||
manifest = self.manifest(target, artifact_target=artifact_target,
|
||||
platform='NRF52_PLATFORM', build_profile='auto', capabilities=['sensor.profile.' + sensor,
|
||||
'ota.update.lora'], ota_update_methods=['lora'],
|
||||
verification=[dict(capability='ota.update.lora', present=True, source='linked image')],
|
||||
@@ -160,6 +162,183 @@ class ReleaseQualificationTest(unittest.TestCase):
|
||||
path.with_suffix('.memory.json').write_text(json.dumps(proof))
|
||||
return record['manifest']
|
||||
|
||||
def embedded_sensor_record(self, directory, sensor, *, target='RAK_4631_repeater',
|
||||
candidate=None, **options):
|
||||
import nrf52_embedded_bootloader as bootloader
|
||||
profile, _ = bootloader.select_profile(bootloader.load_manifest(), target)
|
||||
candidate = b'\xa5' * bootloader.BOOT_SIZE if candidate is None else candidate
|
||||
prefix = b'OTA: status\0invalid in-place patch geometry\0'
|
||||
padding = b'\0' * (-len(prefix) % 4)
|
||||
item = self.sensor_record(directory, sensor, target=target,
|
||||
extra_application=padding + candidate + b'BL embedded 2.4.12\0',
|
||||
artifact_variant='-with-bootloader-2.4.12', **options)
|
||||
manifest = item['manifest']
|
||||
manifest['capabilities'].append('bootloader.embedded')
|
||||
manifest['verification'].append(dict(capability='bootloader.embedded', present=True,
|
||||
source='packaged application', evidence='exact pinned candidate in packaged application'))
|
||||
manifest['embedded_bootloader'] = dict(release=bootloader.VERSION, profile=profile['id'],
|
||||
manifest_sha256=bootloader.MANIFEST_SHA256, asset_sha256=profile['files']['zip']['sha256'],
|
||||
candidate_sha256=hashlib.sha256(candidate).hexdigest(), legacy_sha256=None,
|
||||
image_bytes=bootloader.BOOT_SIZE, app_offset=len(prefix) + len(padding),
|
||||
activation='ota bootloader update', automatic_delay_seconds=70)
|
||||
return item
|
||||
|
||||
def test_ordinary_and_embedded_pairs_coexist_without_satisfying_each_other(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
directory = Path(temp)
|
||||
ordinary = [self.sensor_record(directory, sensor, target='RAK_4631_repeater')
|
||||
for sensor in ('full', 'reduced')]
|
||||
embedded = [self.embedded_sensor_record(directory, sensor) for sensor in ('full', 'reduced')]
|
||||
before = {p.name: p.read_bytes() for p in directory.iterdir()}
|
||||
for inputs in (ordinary + embedded, list(reversed(ordinary + embedded))):
|
||||
package.validate_nrf52_sensor_pairs(inputs)
|
||||
self.assertEqual(package.embedded_bootloader_variant(ordinary[0]['manifest']), '')
|
||||
self.assertEqual(package.embedded_bootloader_variant(embedded[0]['manifest']), '2.4.12')
|
||||
self.assertIn('OTAFIX 2.4.12 bootloader', package.release_profile_label(embedded[0]['manifest']))
|
||||
for wrong in (ordinary + embedded[:1], ordinary[:1] + embedded,
|
||||
[ordinary[0], embedded[1]], ordinary + embedded + embedded[:1]):
|
||||
with self.subTest(count=len(wrong)), self.assertRaisesRegex(ValueError, 'exactly one full'):
|
||||
package.validate_nrf52_sensor_pairs(wrong)
|
||||
self.assertEqual({p.name: p.read_bytes() for p in directory.iterdir()}, before)
|
||||
|
||||
def test_embedded_metadata_requires_exact_pinned_profile_and_packaged_proof(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
item = self.embedded_sensor_record(Path(temp), 'full')
|
||||
package.validate_manifest(item['manifest'])
|
||||
for key, value in (('release', '2.4.11'), ('profile', 'another_board'),
|
||||
('manifest_sha256', 'b' * 64), ('asset_sha256', 'c' * 64),
|
||||
('candidate_sha256', 'A' * 64), ('image_bytes', 40959),
|
||||
('app_offset', -4), ('app_offset', 1), ('app_offset', True),
|
||||
('activation', 'automatic'), ('automatic_delay_seconds', 69),
|
||||
('legacy_sha256', 'd' * 64)):
|
||||
manifest = deepcopy(item['manifest'])
|
||||
manifest['embedded_bootloader'][key] = value
|
||||
with self.subTest(key=key, value=value), self.assertRaisesRegex(ValueError, 'pinned release'):
|
||||
package.validate_manifest(manifest)
|
||||
for fault in ('metadata', 'capability', 'proof', 'false_proof', 'wrong_proof', 'platform'):
|
||||
manifest = deepcopy(item['manifest'])
|
||||
if fault == 'metadata':
|
||||
manifest.pop('embedded_bootloader')
|
||||
elif fault == 'capability':
|
||||
manifest['capabilities'].remove('bootloader.embedded')
|
||||
elif fault == 'proof':
|
||||
manifest['verification'].pop()
|
||||
elif fault == 'false_proof':
|
||||
manifest['verification'][-1]['present'] = False
|
||||
elif fault == 'wrong_proof':
|
||||
manifest['verification'][-1]['source'] = 'filename'
|
||||
else:
|
||||
manifest['platform'] = 'ESP32_PLATFORM'
|
||||
with self.subTest(fault=fault), self.assertRaises(ValueError):
|
||||
package.validate_manifest(manifest)
|
||||
|
||||
def test_embedded_pair_checks_actual_candidate_marker_and_same_candidate_in_both_profiles(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
directory = Path(temp)
|
||||
full = self.embedded_sensor_record(directory, 'full')
|
||||
reduced = self.embedded_sensor_record(directory, 'reduced', candidate=b'\x5a' * 40960)
|
||||
with self.assertRaisesRegex(ValueError, 'storage layout'):
|
||||
package.validate_nrf52_sensor_pairs([full, reduced])
|
||||
reduced = self.embedded_sensor_record(directory, 'reduced')
|
||||
for fault in ('hash', 'offset', 'marker'):
|
||||
damaged = deepcopy(full)
|
||||
if fault == 'hash':
|
||||
damaged['manifest']['embedded_bootloader']['candidate_sha256'] = '0' * 64
|
||||
elif fault == 'offset':
|
||||
damaged['manifest']['embedded_bootloader']['app_offset'] += 4
|
||||
else:
|
||||
path = directory / 'damaged' / damaged['files'][0].name
|
||||
path.parent.mkdir(exist_ok=True)
|
||||
with zipfile.ZipFile(full['files'][0]) as source, zipfile.ZipFile(path, 'w') as out:
|
||||
for name in source.namelist():
|
||||
data = source.read(name)
|
||||
if name == 'application.bin':
|
||||
identity = package.parse_endf_ident(data)
|
||||
data, _ = ensure_endf(data[:-ENDF_LEN].replace(
|
||||
b'BL embedded 2.4.12', b'NO embedded 2.4.12'), identity)
|
||||
out.writestr(name, data)
|
||||
damaged['files'] = [path]
|
||||
with self.subTest(fault=fault), self.assertRaisesRegex(ValueError, 'differs from qualification'):
|
||||
package.validate_nrf52_sensor_pairs([damaged, reduced])
|
||||
|
||||
def test_qspi_retirement_requires_matching_bootloader_variant(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
directory = Path(temp)
|
||||
legacy_target = 'Xiao_nrf52_room_server'
|
||||
primary_target = legacy_target + '_lora_ota'
|
||||
legacy = [self.sensor_record(directory, sensor, target=legacy_target) for sensor in ('full', 'reduced')]
|
||||
primary = [self.sensor_record(directory, sensor, target=primary_target, storage='external_qspi')
|
||||
for sensor in ('full', 'reduced')]
|
||||
embedded_legacy = [self.embedded_sensor_record(directory, sensor, target=legacy_target)
|
||||
for sensor in ('full', 'reduced')]
|
||||
embedded_primary = [self.embedded_sensor_record(directory, sensor, target=primary_target,
|
||||
storage='external_qspi') for sensor in ('full', 'reduced')]
|
||||
before = {p.name: p.read_bytes() for p in directory.iterdir()}
|
||||
for mixed in (legacy + embedded_primary, embedded_legacy + primary):
|
||||
with self.assertRaisesRegex(ValueError, 'qualified external-QSPI Full/Reduced pair'):
|
||||
package.omit_retired_onboard_qspi_records(mixed)
|
||||
inputs = legacy + embedded_primary + embedded_legacy + primary
|
||||
self.assertCountEqual(package.omit_retired_onboard_qspi_records(inputs), primary + embedded_primary)
|
||||
self.assertEqual({p.name: p.read_bytes() for p in directory.iterdir()}, before)
|
||||
|
||||
def test_local_release_cannot_drop_or_forge_its_bootloader_receipts(self):
|
||||
from build_local_release import validate_embedded_bootloader_records
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
directory = Path(temp)
|
||||
folder = directory / 'firmware/lora-ota'
|
||||
folder.mkdir(parents=True)
|
||||
ordinary = [self.sensor_record(folder, sensor, target='RAK_4631_repeater')
|
||||
for sensor in ('full', 'reduced')]
|
||||
embedded = [self.embedded_sensor_record(folder, sensor) for sensor in ('full', 'reduced')]
|
||||
source, version = 'deadbeef' + 'a' * 32, 'v1.17.1.7-dev'
|
||||
records = ordinary + embedded
|
||||
standalone = directory / 'nrf52-bootloaders'
|
||||
standalone.mkdir()
|
||||
(standalone / 'verified-inventory.json').write_text('{}')
|
||||
receipt = validate_embedded_bootloader_records(ordinary, embedded)
|
||||
catalog_receipt = {'kind': 'nrf52-standalone-bootloader-catalog', 'version': '2.4.12'}
|
||||
manifest = dict(format='meshcore-local-release-v1', source_commit=source,
|
||||
firmware_version=version, profile='cascade', publication='local-only',
|
||||
radio=dict(frequency_mhz=910.525, bandwidth_khz=62.5, spreading_factor=7, coding_rate=5),
|
||||
firmware_target_count=4, migration_board_role_count=0,
|
||||
nrf52_bootloader_variants=receipt, nrf52_bootloaders=catalog_receipt,
|
||||
firmware=[dict(target=item['manifest']['target'], artifact_target=item['manifest']['artifact_target'],
|
||||
platform='NRF52_PLATFORM', profile='auto',
|
||||
embedded_bootloader=item['manifest'].get('embedded_bootloader'),
|
||||
files=[str(p.relative_to(directory)) for p in item['files']]) for item in records])
|
||||
bundle = directory / ('esp32-partition-migration-' + version + '-deadbeef-release.zip')
|
||||
with zipfile.ZipFile(bundle, 'w') as archive:
|
||||
archive.writestr('release-manifest.json', '{}')
|
||||
def write_inventory():
|
||||
(directory / 'manifest.json').write_text(json.dumps(manifest))
|
||||
(directory / 'SHA256SUMS.txt').write_text(''.join(
|
||||
hashlib.sha256(path.read_bytes()).hexdigest() + ' ' + str(path.relative_to(directory)) + '\n'
|
||||
for path in sorted(directory.rglob('*')) if path.is_file() and path.name != 'SHA256SUMS.txt'))
|
||||
with patch.object(package, 'collect_artifacts', return_value=records), \
|
||||
patch('package_esp32_partition_migration.BOARDS', {}), \
|
||||
patch('package_nrf52_bootloaders.validate_bootloader_catalog', return_value=catalog_receipt):
|
||||
write_inventory()
|
||||
qualified, extras, _ = package.collect_local_release(directory, version, source)
|
||||
self.assertEqual(qualified, records)
|
||||
self.assertIn(standalone / 'verified-inventory.json', extras)
|
||||
for fault in ('drop_variants', 'drop_catalog', 'drop_both', 'wrong_variants', 'wrong_catalog', 'entry'):
|
||||
saved = deepcopy(manifest)
|
||||
if fault in ('drop_variants', 'drop_both'):
|
||||
manifest.pop('nrf52_bootloader_variants')
|
||||
if fault in ('drop_catalog', 'drop_both'):
|
||||
manifest.pop('nrf52_bootloaders')
|
||||
if fault == 'wrong_variants':
|
||||
manifest['nrf52_bootloader_variants']['firmware_count'] += 1
|
||||
elif fault == 'wrong_catalog':
|
||||
manifest['nrf52_bootloaders'] = {'version': '2.4.11'}
|
||||
elif fault == 'entry':
|
||||
manifest['firmware'][2]['embedded_bootloader'] = None
|
||||
write_inventory()
|
||||
with self.subTest(fault=fault), self.assertRaisesRegex(ValueError,
|
||||
'inventor|manifest disagrees'):
|
||||
package.collect_local_release(directory, version, source)
|
||||
manifest = saved
|
||||
|
||||
def matrix_package_command(self, directory):
|
||||
commit = 'deadbeef' + '0' * 32
|
||||
label = 'v1.17.1.5-halo-keymind-cascade-dev'
|
||||
|
||||
@@ -495,7 +495,7 @@ class MigrationMetadataTest(unittest.TestCase):
|
||||
archive, = (output_root / "packages").glob("*.zip")
|
||||
self.fixture.check_archive(archive, "heltec-v4", expected, identity)
|
||||
|
||||
def test_local_release_main_passes_one_canonical_directory_to_both_later_phases(self):
|
||||
def test_local_release_main_passes_one_canonical_directory_to_all_later_phases(self):
|
||||
import build_local_release as recipe
|
||||
environment = self.environment(MIGRATION_TEST_CONFIGURED_DIR=str(self.fixture.custom))
|
||||
captured = []
|
||||
@@ -505,20 +505,22 @@ class MigrationMetadataTest(unittest.TestCase):
|
||||
mock.patch.dict(os.environ, environment, clear=True), \
|
||||
mock.patch.object(recipe, "run_logged", side_effect=lambda command, log, env:
|
||||
captured.append(("matrix", env.copy()))), \
|
||||
mock.patch.object(recipe, "build_embedded_bootloader_artifacts", side_effect=lambda *args:
|
||||
captured.append(("embedded", args[4].copy()))), \
|
||||
mock.patch.object(recipe, "build_migration_artifacts", side_effect=lambda *args:
|
||||
captured.append(("migration", args[4].copy(), args[5]))), \
|
||||
mock.patch.object(recipe, "stage_release", side_effect=lambda *args:
|
||||
mock.patch.object(recipe, "stage_release", side_effect=lambda *args, **kwargs:
|
||||
captured.append(("package", args[5]))), \
|
||||
mock.patch.object(sys, "argv", ["local-release"]), \
|
||||
redirect_stdout(io.StringIO()):
|
||||
recipe.main()
|
||||
self.assertEqual(len(self.queries()), 1)
|
||||
self.assertEqual([value[0] for value in captured], ["matrix", "migration", "package"])
|
||||
for item in captured[:2]:
|
||||
self.assertEqual([value[0] for value in captured], ["matrix", "embedded", "migration", "package"])
|
||||
for item in captured[:3]:
|
||||
self.assertEqual(item[1]["PLATFORMIO_BUILD_DIR"], str(self.fixture.custom.resolve()))
|
||||
self.assertEqual(item[1]["MIGRATION_TEST_OTHER"], "preserved-option")
|
||||
self.assertEqual(captured[1][2], self.fixture.custom.resolve())
|
||||
self.assertEqual(captured[2][1], self.fixture.custom.resolve())
|
||||
self.assertEqual(captured[2][2], self.fixture.custom.resolve())
|
||||
self.assertEqual(captured[3][1], self.fixture.custom.resolve())
|
||||
|
||||
def test_local_utility_builder_preserves_environment_and_never_requeries_pinned_directory(self):
|
||||
import build_local_release as recipe
|
||||
|
||||
@@ -2,12 +2,19 @@
|
||||
"""Full selection preserves qualified transports and board capacity exceptions."""
|
||||
|
||||
from copy import deepcopy
|
||||
from contextlib import redirect_stderr, redirect_stdout
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from unittest import mock
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
|
||||
from build_local_release import select_ordinary_full_records
|
||||
import build_local_release as release
|
||||
|
||||
|
||||
def record(target: str, profile: str = "full", platform: str = "ESP32_PLATFORM",
|
||||
@@ -655,5 +662,275 @@ class ReleaseFullSelectionTest(unittest.TestCase):
|
||||
select_ordinary_full_records([primary, legacy])
|
||||
|
||||
|
||||
class BootloaderReleaseOrchestrationTest(unittest.TestCase):
|
||||
PROFILE = {"id": "test_board", "files": {"zip": {"sha256": "a" * 64}}}
|
||||
|
||||
def catalog(self):
|
||||
return mock.patch.multiple(release, load_bootloader_manifest=mock.Mock(return_value={}),
|
||||
select_bootloader_profile=mock.Mock(return_value=(self.PROFILE, {})),
|
||||
target_profiles=mock.Mock(side_effect=lambda targets: {target: {
|
||||
"role": "room" if "room_" in target else "repeater",
|
||||
"sourceHardware": "source_" + target, "hardware": "hardware_" + target}
|
||||
for target in targets}))
|
||||
|
||||
def embedded(self, ordinary):
|
||||
result = deepcopy(ordinary)
|
||||
for item in result:
|
||||
manifest = item["manifest"]
|
||||
sensor = release.nrf52_sensor_profile(manifest)
|
||||
manifest["artifact_target"] = (manifest["target"] + "-with-bootloader-2.4.12-"
|
||||
+ sensor + "-ota")
|
||||
manifest["embedded_bootloader"] = dict(release="2.4.12", profile=self.PROFILE["id"],
|
||||
manifest_sha256=release.BOOTLOADER_MANIFEST_SHA256, asset_sha256="a" * 64,
|
||||
legacy_sha256=None)
|
||||
return result
|
||||
|
||||
def test_target_selection_is_exact_role_platform_sorted_and_unique(self):
|
||||
eligible = sensor_pair("z_repeater") + sensor_pair("a_room_server")
|
||||
excluded = [record("n_companion_radio_full", platform="NRF52_PLATFORM"),
|
||||
record("n_sensor", platform="NRF52_PLATFORM"), record("esp_repeater"),
|
||||
record("rp_room_server", platform="RP2040_PLATFORM")]
|
||||
with self.catalog():
|
||||
self.assertEqual(release.embedded_bootloader_targets(eligible + excluded),
|
||||
["a_room_server", "z_repeater"])
|
||||
self.assertEqual([call.args[1] for call in release.select_bootloader_profile.call_args_list],
|
||||
["a_room_server", "z_repeater"])
|
||||
with mock.patch.object(release, "load_bootloader_manifest") as load:
|
||||
self.assertEqual(release.embedded_bootloader_targets(excluded), [])
|
||||
load.assert_not_called()
|
||||
|
||||
def test_unsupported_requested_infrastructure_fails_instead_of_being_omitted(self):
|
||||
with self.catalog(), mock.patch.object(release, "select_bootloader_profile",
|
||||
side_effect=ValueError("unsupported exact board")):
|
||||
with self.assertRaisesRegex(ValueError, "unsupported exact board"):
|
||||
release.embedded_bootloader_targets(sensor_pair("missing_repeater"))
|
||||
|
||||
def test_only_unique_exact_source_hardware_catalog_exclusions_are_allowed(self):
|
||||
target = "pending_repeater"
|
||||
records = sensor_pair(target)
|
||||
unavailable = dict(id="pending_board", meshcoreHardware=["source_" + target],
|
||||
qualification={"status": "source-pending"}, reason="Exact hardware is not qualified.")
|
||||
catalog = {"profiles": [], "unavailableProfiles": [unavailable]}
|
||||
expected = dict(target=target, profile="pending_board", source_hardware="source_" + target,
|
||||
status="source-pending", reason=unavailable["reason"])
|
||||
with self.catalog(), mock.patch.object(release, "load_bootloader_manifest", return_value=catalog):
|
||||
self.assertEqual(release.embedded_bootloader_selection(records), ([], [expected]))
|
||||
release.select_bootloader_profile.assert_not_called()
|
||||
receipt = release.validate_embedded_bootloader_records(records, [])
|
||||
self.assertEqual(receipt["targets"], [])
|
||||
self.assertEqual(receipt["firmware_count"], 0)
|
||||
self.assertEqual(receipt["exclusions"], [expected])
|
||||
for fault in ("alias_only", "duplicate", "available_conflict", "unknown_status", "empty_reason"):
|
||||
invalid = deepcopy(catalog)
|
||||
if fault == "alias_only":
|
||||
invalid["unavailableProfiles"][0]["meshcoreHardware"] = ["hardware_" + target]
|
||||
elif fault == "duplicate":
|
||||
invalid["unavailableProfiles"].append(deepcopy(unavailable))
|
||||
elif fault == "available_conflict":
|
||||
invalid["profiles"] = [{"meshcoreHardware": ["hardware_" + target]}]
|
||||
elif fault == "unknown_status":
|
||||
invalid["unavailableProfiles"][0]["qualification"]["status"] = "unknown"
|
||||
else:
|
||||
invalid["unavailableProfiles"][0]["reason"] = " "
|
||||
with self.subTest(fault=fault), self.catalog(), \
|
||||
mock.patch.object(release, "load_bootloader_manifest", return_value=invalid), \
|
||||
mock.patch.object(release, "select_bootloader_profile", side_effect=ValueError("unmapped")):
|
||||
with self.assertRaises(ValueError):
|
||||
release.embedded_bootloader_selection(records)
|
||||
|
||||
def test_embedded_builds_are_sequential_resumable_and_in_separate_scrubbed_output(self):
|
||||
ordinary = sensor_pair("z_repeater") + sensor_pair("a_room_server")
|
||||
environment = {"OUTPUT_DIR": "old", "OTHER": "keep", "PLATFORMIO_BUILD_DIR": "/pinned",
|
||||
"MESHCORE_NRF52_EMBED_BOOTLOADER": "wrong",
|
||||
"MESHCORE_NRF52_LEGACY_BOOTLOADER": "/unrelated"}
|
||||
previous = environment.copy()
|
||||
calls = []
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
root = Path(temp)
|
||||
def run(command, log, child):
|
||||
self.assertFalse(calls and calls[-1][0] == "running")
|
||||
calls.append(("running", command, log, child.copy()))
|
||||
self.assertEqual(child["OUTPUT_DIR"], str(root / "embedded"))
|
||||
self.assertEqual(child["PLATFORMIO_BUILD_DIR"], "/pinned")
|
||||
self.assertEqual(child["OTHER"], "keep")
|
||||
self.assertFalse(set(release.BOOTLOADER_ENVIRONMENT) & child.keys())
|
||||
calls[-1] = ("finished", command, log, child.copy())
|
||||
with self.catalog(), mock.patch.object(release, "collect_artifacts", return_value=ordinary) as collect, \
|
||||
mock.patch.object(release, "run_logged", side_effect=run):
|
||||
release.build_embedded_bootloader_artifacts(root / "ordinary", root / "embedded",
|
||||
release.DEFAULT_VERSION, "deadbeef", environment)
|
||||
collect.assert_called_once_with(root / "ordinary", release.DEFAULT_VERSION + "-deadbeef")
|
||||
self.assertEqual([item[1][3] for item in calls], ["a_room_server", "z_repeater"])
|
||||
for _, command, log, _ in calls:
|
||||
self.assertEqual(command, ["bash", "build_legacy.sh", "build-firmware", command[3],
|
||||
"--with-bootloader", "2.4.12", "--firmware-version", release.DEFAULT_VERSION,
|
||||
"--radio-preset", "usa-cascade-fixed", "--profile", "cascade",
|
||||
"--require-ota", "--resume"])
|
||||
self.assertEqual(log.parent, root / "embedded/build-logs")
|
||||
self.assertEqual(environment, previous)
|
||||
for ordinary_dir, embedded_dir in ((root, root / "."), (root, root / "child"),
|
||||
(root / "child", root)):
|
||||
with mock.patch.object(release, "collect_artifacts") as collect:
|
||||
with self.assertRaisesRegex(ValueError, "separate output"):
|
||||
release.build_embedded_bootloader_artifacts(ordinary_dir, embedded_dir, "v", "sha", {})
|
||||
collect.assert_not_called()
|
||||
|
||||
def test_embedded_build_failure_stops_the_next_target_and_variant_contamination_rejected(self):
|
||||
ordinary = sensor_pair("a_repeater") + sensor_pair("z_repeater")
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
root = Path(temp)
|
||||
with self.catalog(), mock.patch.object(release, "collect_artifacts", return_value=ordinary), \
|
||||
mock.patch.object(release, "run_logged", side_effect=RuntimeError("capacity rejected")) as run:
|
||||
with self.assertRaisesRegex(RuntimeError, "capacity rejected"):
|
||||
release.build_embedded_bootloader_artifacts(root / "ordinary", root / "embedded", "v", "sha", {})
|
||||
self.assertEqual(run.call_count, 1)
|
||||
for contaminant in self.embedded(sensor_pair("a_repeater")):
|
||||
contaminant["manifest"].pop("embedded_bootloader")
|
||||
with mock.patch.object(release, "collect_artifacts", return_value=[contaminant]), \
|
||||
mock.patch.object(release, "run_logged") as run:
|
||||
with self.assertRaisesRegex(ValueError, "ordinary firmware directory"):
|
||||
release.build_embedded_bootloader_artifacts(root / "ordinary", root / "embedded", "v", "sha", {})
|
||||
run.assert_not_called()
|
||||
# A resumed stale Standard image would be discarded by ordinary
|
||||
# selection. It must not hide an embedded image in the ordinary root.
|
||||
filtered = record("heltec_v4_repeater", "standard")
|
||||
filtered["manifest"]["artifact_target"] = "heltec_v4_repeater-with-bootloader-2.4.12"
|
||||
with mock.patch.object(release, "collect_artifacts", return_value=ordinary + [filtered]), \
|
||||
mock.patch.object(release, "run_logged") as run, \
|
||||
mock.patch.object(release, "resolve_pio_build_dir", return_value=root / "pinned"), \
|
||||
mock.patch.object(release, "git", return_value="a" * 40):
|
||||
with self.assertRaisesRegex(ValueError, "ordinary firmware directory"):
|
||||
release.build_embedded_bootloader_artifacts(root / "ordinary", root / "embedded", "v", "sha", {})
|
||||
with self.assertRaisesRegex(ValueError, "ordinary firmware directory"):
|
||||
release.stage_release(root / "ordinary", root / "migration", root / "release", "v", "a" * 40,
|
||||
root / "pinned", embedded_work=root / "embedded")
|
||||
run.assert_not_called()
|
||||
|
||||
def test_embedded_receipt_requires_each_ordinary_profile_exactly_once(self):
|
||||
ordinary = sensor_pair("board_repeater")
|
||||
embedded = self.embedded(ordinary)
|
||||
before = deepcopy(ordinary + embedded)
|
||||
with self.catalog():
|
||||
receipt = release.validate_embedded_bootloader_records(ordinary, list(reversed(embedded)))
|
||||
self.assertEqual(receipt, dict(release="2.4.12", manifest_sha256=release.BOOTLOADER_MANIFEST_SHA256,
|
||||
targets=["board_repeater"], firmware_count=2, exclusions=[]))
|
||||
for wrong in ([], embedded[:1], embedded + embedded[:1], self.embedded(sensor_pair("other_repeater"))):
|
||||
with self.subTest(artifacts=[item["manifest"]["artifact_target"] for item in wrong]):
|
||||
with self.assertRaises(ValueError):
|
||||
release.validate_embedded_bootloader_records(ordinary, wrong)
|
||||
for field, value in (("release", "2.4.11"), ("profile", "other"),
|
||||
("manifest_sha256", "b" * 64), ("asset_sha256", "c" * 64), ("legacy_sha256", "d" * 64)):
|
||||
wrong = deepcopy(embedded)
|
||||
wrong[0]["manifest"]["embedded_bootloader"][field] = value
|
||||
with self.subTest(field=field), self.assertRaisesRegex(ValueError, "qualification differs"):
|
||||
release.validate_embedded_bootloader_records(ordinary, wrong)
|
||||
for field, value in (("platform", "ESP32_PLATFORM"), ("target", "other_repeater"),
|
||||
("build_profile", "standard")):
|
||||
wrong = deepcopy(embedded)
|
||||
wrong[0]["manifest"][field] = value
|
||||
with self.subTest(field=field), self.assertRaises(ValueError):
|
||||
release.validate_embedded_bootloader_records(ordinary, wrong)
|
||||
self.assertEqual(ordinary + embedded, before)
|
||||
|
||||
def test_main_default_and_explicit_version_keep_all_four_phases_isolated(self):
|
||||
for version_arg in ([], ["--firmware-version", "v1.18.0.2-halo-keymind-cascade-dev"]):
|
||||
with self.subTest(argv=version_arg), tempfile.TemporaryDirectory() as temp:
|
||||
root, source = Path(temp), "deadbeef" + "a" * 32
|
||||
version = version_arg[-1] if version_arg else "v1.18.0.1-halo-keymind-cascade-dev"
|
||||
label = version + "-deadbeef"
|
||||
phases = []
|
||||
environment = {"OTHER": "keep", "MESHCORE_NRF52_EMBED_BOOTLOADER": "2.4.11",
|
||||
"MESHCORE_NRF52_LEGACY_BOOTLOADER": "wrong"}
|
||||
def capture(name, env):
|
||||
self.assertEqual(env["OTHER"], "keep")
|
||||
self.assertFalse(set(release.BOOTLOADER_ENVIRONMENT) & env.keys())
|
||||
self.assertEqual(env["PLATFORMIO_BUILD_DIR"], str(root / "pinned"))
|
||||
phases.append(name)
|
||||
with mock.patch.object(release, "ROOT", root), \
|
||||
mock.patch.object(release, "git", side_effect=lambda *args: "" if args[0] == "status" else source), \
|
||||
mock.patch.dict(os.environ, environment, clear=True), \
|
||||
mock.patch.object(release, "resolve_pio_build_dir", return_value=root / "pinned"), \
|
||||
mock.patch.object(release, "run_logged", side_effect=lambda command, log, env: capture("matrix", env)) as matrix, \
|
||||
mock.patch.object(release, "build_embedded_bootloader_artifacts", side_effect=lambda *args: capture("embedded", args[4])) as embed, \
|
||||
mock.patch.object(release, "build_migration_artifacts", side_effect=lambda *args: capture("migration", args[4])) as migration, \
|
||||
mock.patch.object(release, "stage_release", side_effect=lambda *args, **kwargs: phases.append("stage")) as stage, \
|
||||
mock.patch.object(sys, "argv", ["release"] + version_arg), redirect_stdout(io.StringIO()):
|
||||
release.main()
|
||||
self.assertEqual(phases, ["matrix", "embedded", "migration", "stage"])
|
||||
ordinary = root / ".releases" / (".build-" + label)
|
||||
embedded = root / ".releases" / (".bootloader-build-" + label)
|
||||
migrated = root / ".releases" / (".migration-build-" + label)
|
||||
self.assertEqual(matrix.call_args.args[2]["OUTPUT_DIR"], str(ordinary))
|
||||
self.assertEqual(embed.call_args.args[:4], (ordinary, embedded, version, "deadbeef"))
|
||||
self.assertEqual(migration.call_args.args[:3], (migrated, version, "deadbeef"))
|
||||
self.assertEqual(stage.call_args.args[:5], (ordinary, migrated, root / ".releases" / label, version, source))
|
||||
self.assertEqual(stage.call_args.kwargs, {"embedded_work": embedded})
|
||||
self.assertEqual(environment["MESHCORE_NRF52_EMBED_BOOTLOADER"], "2.4.11")
|
||||
|
||||
def test_nonempty_embedded_resume_requires_opt_in_and_dry_run_never_builds(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
root, source = Path(temp), "deadbeef" + "a" * 32
|
||||
work = root / ".releases" / (".bootloader-build-" + release.DEFAULT_VERSION + "-deadbeef")
|
||||
work.mkdir(parents=True)
|
||||
proof = work / "prior-artifact"
|
||||
proof.write_bytes(b"preserve")
|
||||
with mock.patch.object(release, "ROOT", root), \
|
||||
mock.patch.object(release, "git", side_effect=lambda *args: "" if args[0] == "status" else source), \
|
||||
mock.patch.object(release, "run_logged") as run, \
|
||||
mock.patch.object(release, "resolve_pio_build_dir") as resolve, \
|
||||
mock.patch.object(sys, "argv", ["release"]), redirect_stdout(io.StringIO()), redirect_stderr(io.StringIO()):
|
||||
with self.assertRaises(SystemExit):
|
||||
release.main()
|
||||
run.assert_not_called()
|
||||
resolve.assert_not_called()
|
||||
with mock.patch.object(sys, "argv", ["release", "--dry-run"]):
|
||||
release.main()
|
||||
run.assert_not_called()
|
||||
resolve.assert_not_called()
|
||||
self.assertEqual(proof.read_bytes(), b"preserve")
|
||||
|
||||
def test_stage_keeps_both_variants_and_auditable_standalone_metadata(self):
|
||||
ordinary = sensor_pair("board_repeater")
|
||||
embedded = self.embedded(ordinary)
|
||||
source = "deadbeef" + "a" * 32
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
root = Path(temp)
|
||||
work, embedded_work = root / "ordinary", root / "embedded"
|
||||
work.mkdir(); embedded_work.mkdir()
|
||||
for item in ordinary + embedded:
|
||||
stem = item["manifest"]["artifact_target"]
|
||||
path = (embedded_work if "embedded_bootloader" in item["manifest"] else work) / (stem + ".zip")
|
||||
path.write_bytes(stem.encode("ascii"))
|
||||
item["files"] = [path]
|
||||
catalog = {"version": "2.4.12", "inventory_path": "inventory.json", "profile_count": 23}
|
||||
def stage_catalog(destination, *, project_root):
|
||||
destination.mkdir()
|
||||
(destination / "inventory.json").write_text(json.dumps(catalog))
|
||||
return catalog
|
||||
with self.catalog(), mock.patch.object(release, "git", return_value=source), \
|
||||
mock.patch.object(release, "resolve_pio_build_dir", return_value=root / "pinned"), \
|
||||
mock.patch.object(release, "collect_artifacts", side_effect=[ordinary, embedded]) as collect, \
|
||||
mock.patch.object(release, "BOARDS", {}), mock.patch.object(release, "bundle_release"), \
|
||||
mock.patch.object(release.subprocess, "run", return_value=mock.Mock(returncode=0)), \
|
||||
mock.patch("package_nrf52_bootloaders.stage_bootloader_catalog", side_effect=stage_catalog), \
|
||||
redirect_stdout(io.StringIO()):
|
||||
release.stage_release(work, root / "migration", root / "release", release.DEFAULT_VERSION,
|
||||
source, root / "pinned", embedded_work=embedded_work)
|
||||
self.assertEqual([call.args[0] for call in collect.call_args_list], [work, embedded_work])
|
||||
manifest = json.loads((root / "release/manifest.json").read_text())
|
||||
self.assertEqual(manifest["firmware_target_count"], 4)
|
||||
self.assertEqual([item["embedded_bootloader"] is not None for item in manifest["firmware"]],
|
||||
[False, False, True, True])
|
||||
self.assertEqual(manifest["nrf52_bootloader_variants"]["firmware_count"], 2)
|
||||
self.assertEqual(manifest["nrf52_bootloaders"], catalog)
|
||||
for entry in manifest["firmware"]:
|
||||
self.assertEqual(len(entry["files"]), 1)
|
||||
path = root / "release" / entry["files"][0]
|
||||
self.assertEqual(path.read_bytes(), entry["artifact_target"].encode("ascii"))
|
||||
sums = (root / "release/SHA256SUMS.txt").read_text()
|
||||
self.assertIn("nrf52-bootloaders/inventory.json", sums)
|
||||
self.assertIn("70 seconds", (root / "release/README.md").read_text())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,305 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Standalone release assets remain exact-board, complete and independently auditable."""
|
||||
|
||||
from copy import deepcopy
|
||||
import hashlib
|
||||
import io
|
||||
import json
|
||||
from pathlib import Path
|
||||
import struct
|
||||
import sys
|
||||
import tempfile
|
||||
from types import SimpleNamespace
|
||||
import unittest
|
||||
from unittest import mock
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
|
||||
from intelhex import IntelHex
|
||||
import package_nrf52_bootloaders as package
|
||||
|
||||
|
||||
def digest(data):
|
||||
return hashlib.sha256(data).hexdigest()
|
||||
|
||||
|
||||
def uf2(candidate, *, omitted=()):
|
||||
"""A bootloader UF2, including independent MBR and UICR records."""
|
||||
writes = [(0, b"M" * 256)]
|
||||
writes += [(package.embedded.BOOT_BASE + offset, candidate[offset:offset + 256])
|
||||
for offset in range(0, len(candidate), 256) if offset not in omitted]
|
||||
writes += [(0x10001000, b"U" * 256)]
|
||||
blocks = []
|
||||
for index, (address, payload) in enumerate(writes):
|
||||
blocks.append(struct.pack("<8I", 0x0A324655, 0x9E5D5157, 0x2000, address,
|
||||
256, index, len(writes), package.BOOTLOADER_UF2_FAMILY)
|
||||
+ payload + b"\0" * 220 + struct.pack("<I", 0x0AB16F30))
|
||||
return b"".join(blocks)
|
||||
|
||||
|
||||
class StandaloneBootloaderCatalogTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temporary = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.temporary.cleanup)
|
||||
self.root = Path(self.temporary.name)
|
||||
self.project = self.root / "project"
|
||||
(self.project / "docs/_data").mkdir(parents=True)
|
||||
self.destination, self.cache = self.root / "stage", self.root / "cache"
|
||||
self.payloads, self.candidates = {}, {}
|
||||
profiles = []
|
||||
for name, value, aliases in (("zeta", 0xA5, ["board_z"]),
|
||||
("alpha", 0x5A, ["board_a", "board_a_qspi"])):
|
||||
candidate = bytes([value]) * (package.embedded.BOOT_SIZE - 512) + b"\xff" * 512
|
||||
self.candidates[name] = candidate
|
||||
image = IntelHex()
|
||||
image.frombytes(candidate, offset=package.embedded.BOOT_BASE)
|
||||
text = io.StringIO()
|
||||
image.write_hex_file(text)
|
||||
contents = {"hex": text.getvalue().encode("ascii"), "uf2": uf2(candidate),
|
||||
"zip": ("qualified exact-profile ZIP: " + name).encode("ascii")}
|
||||
profile = dict(id=name, label=name + " exact board", storage="qspi", deviceName=name,
|
||||
meshcoreHardware=aliases, files={})
|
||||
for kind, payload in contents.items():
|
||||
prefix = name + "_bootloader-" + package.embedded.TAG
|
||||
filename = ("update-" + prefix + "_mbr.uf2" if kind == "uf2" else
|
||||
prefix + "_s140_7.3.0." + kind)
|
||||
url = ("https://github.com/" + package.embedded.REPOSITORY + "/releases/download/"
|
||||
+ package.embedded.TAG + "/" + filename)
|
||||
profile["files"][kind] = dict(name=filename, size=len(payload), sha256=digest(payload), url=url)
|
||||
self.payloads[url] = payload
|
||||
profiles.append(profile)
|
||||
self.manifest = dict(schemaVersion=1, repository=package.embedded.REPOSITORY,
|
||||
tag=package.embedded.TAG, version=package.embedded.VERSION, prerelease=False,
|
||||
releaseUrl="https://github.com/" + package.embedded.REPOSITORY + "/releases/tag/" + package.embedded.TAG,
|
||||
profiles=profiles, coverage=dict(releasedProfiles=2, releasedHardware=3),
|
||||
unavailableProfiles=[dict(id="pending_board", reason="No normal release.")],
|
||||
recoveryProfiles=[dict(id="recovery_only", files={"zip": {"url": "never-download"}})])
|
||||
self.pin = mock.patch.object(package.embedded, "MANIFEST_SHA256", "")
|
||||
self.pin.start()
|
||||
self.addCleanup(self.pin.stop)
|
||||
self.write_manifest()
|
||||
self.requests = []
|
||||
self.download = mock.Mock(side_effect=self.urlopen)
|
||||
for module in (package, package.embedded):
|
||||
patcher = mock.patch.object(module, "urlopen", self.download)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
patcher = mock.patch.object(package.embedded, "validate_candidate_zip", side_effect=self.validate_zip)
|
||||
self.validate = patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def write_manifest(self):
|
||||
raw = (json.dumps(self.manifest, sort_keys=True) + "\n").encode("ascii")
|
||||
(self.project / "docs/_data/bootloader_manifest.json").write_bytes(raw)
|
||||
package.embedded.MANIFEST_SHA256 = digest(raw)
|
||||
|
||||
def urlopen(self, url, *, timeout):
|
||||
self.assertEqual(timeout, 60)
|
||||
self.requests.append(url)
|
||||
return io.BytesIO(self.payloads[url])
|
||||
|
||||
def validate_zip(self, data, profile, project_root):
|
||||
# The production ZIP identity/layout parser has its own real-format suite.
|
||||
# Stub only that boundary while running the real download and HEX/UF2 checks.
|
||||
self.assertEqual(project_root, self.project)
|
||||
self.assertEqual(data, self.payloads[profile["files"]["zip"]["url"]])
|
||||
return self.candidates[profile["id"]], SimpleNamespace(device_name=profile["deviceName"],
|
||||
board_id=123, app_base=0x27000, softdevice_fwid=0x100)
|
||||
|
||||
def stage(self, destination=None):
|
||||
return package.stage_bootloader_catalog(destination or self.destination,
|
||||
project_root=self.project, cache_dir=self.cache)
|
||||
|
||||
def files(self, directory):
|
||||
return {path.name: path.read_bytes() for path in directory.iterdir()}
|
||||
|
||||
def replace_payload(self, profile, kind, payload):
|
||||
asset = profile["files"][kind]
|
||||
self.payloads[asset["url"]] = payload
|
||||
asset.update(size=len(payload), sha256=digest(payload))
|
||||
self.write_manifest()
|
||||
|
||||
def test_complete_catalog_is_deterministic_cached_and_offline_verifiable(self):
|
||||
receipt = self.stage()
|
||||
self.assertEqual(receipt["profile_count"], 2)
|
||||
self.assertEqual(receipt["hardware_count"], 3)
|
||||
self.assertEqual([p["id"] for p in receipt["profiles"]], ["alpha", "zeta"])
|
||||
self.assertEqual(receipt["excluded_profiles"], ["pending_board"])
|
||||
self.assertEqual(len(receipt["assets"]), 6)
|
||||
self.assertEqual(set(self.requests), set(self.payloads))
|
||||
self.assertEqual(len(self.requests), 6)
|
||||
for asset in receipt["assets"]:
|
||||
data = (self.destination / asset["path"]).read_bytes()
|
||||
self.assertEqual(len(data), asset["size"])
|
||||
self.assertEqual(digest(data), asset["sha256"])
|
||||
self.assertEqual(asset["name"], asset["path"])
|
||||
before = self.files(self.destination)
|
||||
self.assertNotIn("recovery_only", " ".join(before))
|
||||
with mock.patch.object(package, "urlopen", side_effect=AssertionError("network forbidden")), \
|
||||
mock.patch.object(package.embedded, "urlopen", side_effect=AssertionError("network forbidden")), \
|
||||
mock.patch.object(package.embedded, "download_zip", side_effect=AssertionError("download forbidden")):
|
||||
self.assertEqual(package.validate_bootloader_catalog(self.destination, project_root=self.project), receipt)
|
||||
second = self.root / "second"
|
||||
self.assertEqual(self.stage(second), receipt)
|
||||
self.assertEqual(self.files(second), before)
|
||||
self.assertEqual(len(self.requests), 6) # Every second download came from verified cache.
|
||||
self.assertNotIn(str(self.root), json.dumps(receipt))
|
||||
self.assertEqual(sorted(self.cache.iterdir()), sorted(path for path in self.cache.iterdir()
|
||||
if any(path.name == asset["sha256"] + "-" + asset["name"] for asset in receipt["assets"])))
|
||||
|
||||
def test_corrupt_cache_is_refetched_and_only_verified_bytes_are_published(self):
|
||||
self.stage()
|
||||
profile = self.manifest["profiles"][0]
|
||||
asset = profile["files"]["hex"]
|
||||
cache = self.cache / (asset["sha256"] + "-" + asset["name"])
|
||||
cache.write_bytes(b"x" * asset["size"])
|
||||
self.stage(self.root / "second")
|
||||
self.assertEqual(self.requests.count(asset["url"]), 2)
|
||||
self.assertEqual(cache.read_bytes(), self.payloads[asset["url"]])
|
||||
|
||||
def test_invalid_catalog_metadata_fails_before_any_asset_download(self):
|
||||
original = deepcopy(self.manifest)
|
||||
for fault in ("traversal", "wrong_url", "zero_size", "bool_size", "bad_hash", "missing_format",
|
||||
"duplicate_profile", "duplicate_hardware", "coverage", "unavailable_overlap"):
|
||||
self.manifest = deepcopy(original)
|
||||
profile = self.manifest["profiles"][0]
|
||||
asset = profile["files"]["hex"]
|
||||
if fault == "traversal":
|
||||
asset["name"] = "../boot.hex"
|
||||
elif fault == "wrong_url":
|
||||
asset["url"] = "https://example.invalid/" + asset["name"]
|
||||
elif fault == "zero_size":
|
||||
asset["size"] = 0
|
||||
elif fault == "bool_size":
|
||||
asset["size"] = True
|
||||
elif fault == "bad_hash":
|
||||
asset["sha256"] = "A" * 64
|
||||
elif fault == "missing_format":
|
||||
profile["files"].pop("uf2")
|
||||
elif fault == "duplicate_profile":
|
||||
self.manifest["profiles"].append(deepcopy(profile))
|
||||
elif fault == "duplicate_hardware":
|
||||
self.manifest["profiles"][1]["meshcoreHardware"].append("board_z")
|
||||
elif fault == "coverage":
|
||||
self.manifest["coverage"]["releasedHardware"] = 4
|
||||
else:
|
||||
self.manifest["unavailableProfiles"][0]["id"] = profile["id"]
|
||||
self.write_manifest()
|
||||
with self.subTest(fault=fault), self.assertRaises(ValueError):
|
||||
self.stage()
|
||||
self.assertEqual(self.requests, [])
|
||||
self.assertFalse(self.destination.exists())
|
||||
|
||||
def test_changed_source_manifest_pin_fails_before_asset_download(self):
|
||||
path = self.project / "docs/_data/bootloader_manifest.json"
|
||||
path.write_bytes(path.read_bytes() + b" ")
|
||||
with self.assertRaisesRegex(ValueError, "pinned OTAFIX"):
|
||||
self.stage()
|
||||
self.assertEqual(self.requests, [])
|
||||
self.assertFalse(self.destination.exists())
|
||||
|
||||
def test_late_bad_download_keeps_output_absent_and_cache_free_of_partial_files(self):
|
||||
profile = self.manifest["profiles"][0] # zeta sorts last, after a complete first profile.
|
||||
asset = profile["files"]["uf2"]
|
||||
self.payloads[asset["url"]] += b"unexpected trailing byte"
|
||||
with self.assertRaisesRegex(ValueError, "size/SHA-256 mismatch"):
|
||||
self.stage()
|
||||
self.assertGreater(len(self.requests), 3)
|
||||
self.assertFalse(self.destination.exists())
|
||||
self.assertFalse((self.cache / (asset["sha256"] + "-" + asset["name"])).exists())
|
||||
self.assertFalse(list(self.cache.glob("otafix-*")))
|
||||
self.assertFalse(list(self.root.glob(".stage-*")))
|
||||
|
||||
def test_paired_formats_must_reproduce_the_zip_candidate_even_when_asset_hashes_match(self):
|
||||
original = deepcopy(self.manifest)
|
||||
original_payloads = self.payloads.copy()
|
||||
for kind in ("hex", "uf2"):
|
||||
self.manifest = deepcopy(original)
|
||||
self.payloads = original_payloads.copy()
|
||||
profile = self.manifest["profiles"][0]
|
||||
other_profile = self.manifest["profiles"][1]
|
||||
other = self.payloads[other_profile["files"][kind]["url"]]
|
||||
self.replace_payload(profile, kind, other)
|
||||
with self.subTest(kind=kind), self.assertRaisesRegex(ValueError, "exact.*profile bootloader"):
|
||||
self.stage()
|
||||
self.assertFalse(self.destination.exists())
|
||||
|
||||
def test_sparse_uf2_erased_tail_is_allowed_but_missing_live_bytes_are_rejected(self):
|
||||
profile = self.manifest["profiles"][0]
|
||||
candidate = self.candidates[profile["id"]]
|
||||
erased = (len(candidate) - 512, len(candidate) - 256)
|
||||
self.replace_payload(profile, "uf2", uf2(candidate, omitted=erased))
|
||||
self.stage()
|
||||
self.replace_payload(profile, "uf2", uf2(candidate, omitted=(0,)))
|
||||
with self.assertRaisesRegex(ValueError, "exact.*profile bootloader"):
|
||||
self.stage(self.root / "bad")
|
||||
self.assertFalse((self.root / "bad").exists())
|
||||
|
||||
def test_uf2_rejects_application_family_unsafe_writes_overlap_and_bad_block_metadata(self):
|
||||
original = deepcopy(self.manifest)
|
||||
profile = original["profiles"][0]
|
||||
data = self.payloads[profile["files"]["uf2"]["url"]]
|
||||
for fault in ("application_family", "unsafe_address", "overlap", "block_index", "block_count", "magic"):
|
||||
self.manifest = deepcopy(original)
|
||||
damaged = bytearray(data)
|
||||
if fault == "application_family":
|
||||
struct.pack_into("<I", damaged, 28, 0xADA52840)
|
||||
elif fault == "unsafe_address":
|
||||
struct.pack_into("<I", damaged, 12, 0x27000)
|
||||
elif fault == "overlap":
|
||||
struct.pack_into("<I", damaged, 512 + 12, 0)
|
||||
elif fault == "block_index":
|
||||
struct.pack_into("<I", damaged, 20, 1)
|
||||
elif fault == "block_count":
|
||||
struct.pack_into("<I", damaged, 24, 1)
|
||||
else:
|
||||
struct.pack_into("<I", damaged, 508, 0)
|
||||
self.replace_payload(self.manifest["profiles"][0], "uf2", bytes(damaged))
|
||||
with self.subTest(fault=fault), self.assertRaisesRegex(ValueError, "UF2 geometry"):
|
||||
self.stage()
|
||||
self.assertFalse(self.destination.exists())
|
||||
|
||||
def test_offline_validator_rejects_missing_extra_mutated_and_symlinked_contents(self):
|
||||
self.stage()
|
||||
original = self.files(self.destination)
|
||||
asset_name = self.manifest["profiles"][0]["files"]["hex"]["name"]
|
||||
for fault in ("missing", "extra", "hash", "inventory", "checksums", "readme", "manifest", "symlink"):
|
||||
directory = self.root / ("tampered-" + fault)
|
||||
directory.mkdir()
|
||||
for name, data in original.items():
|
||||
(directory / name).write_bytes(data)
|
||||
if fault == "missing":
|
||||
(directory / asset_name).unlink()
|
||||
elif fault == "extra":
|
||||
(directory / "unqualified.hex").write_bytes(b"extra")
|
||||
elif fault == "symlink":
|
||||
(directory / asset_name).unlink()
|
||||
(directory / asset_name).symlink_to(self.destination / asset_name)
|
||||
else:
|
||||
path = directory / {"hash": asset_name, "inventory": package.INVENTORY_NAME,
|
||||
"checksums": package.CHECKSUMS_NAME, "readme": package.README_NAME,
|
||||
"manifest": package.MANIFEST_NAME}[fault]
|
||||
data = path.read_bytes()
|
||||
path.write_bytes(bytes([data[0] ^ 1]) + data[1:])
|
||||
with self.subTest(fault=fault), self.assertRaises(ValueError):
|
||||
package.validate_bootloader_catalog(directory, project_root=self.project)
|
||||
self.assertEqual(len(self.requests), 6)
|
||||
|
||||
def test_nonempty_destination_and_symlink_cache_are_refused_without_mutation(self):
|
||||
self.destination.mkdir()
|
||||
marker = self.destination / "keep"
|
||||
marker.write_bytes(b"original")
|
||||
with self.assertRaisesRegex(ValueError, "empty directory"):
|
||||
self.stage()
|
||||
self.assertEqual(marker.read_bytes(), b"original")
|
||||
marker.unlink()
|
||||
target = self.root / "cache-target"
|
||||
target.mkdir()
|
||||
self.cache.symlink_to(target, target_is_directory=True)
|
||||
with self.assertRaisesRegex(ValueError, "cache must not be a symlink"):
|
||||
self.stage()
|
||||
self.assertEqual(list(self.destination.iterdir()), [])
|
||||
self.assertEqual(self.requests, [])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -104,6 +104,55 @@ class ReleasePublicationTest(unittest.TestCase):
|
||||
with self.assertRaisesRegex(ValueError, "different family"):
|
||||
catalogs.read_stage(directory)
|
||||
|
||||
def test_catalog_distinguishes_qualified_bootloader_firmware_from_ordinary_images(self):
|
||||
from nrf52_embedded_bootloader import (BOOT_SIZE, MANIFEST_SHA256, VERSION as BL_VERSION,
|
||||
load_manifest, select_profile)
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
directory = Path(temp)
|
||||
plan = self.stage(directory)
|
||||
target = "RAK_4631_repeater"
|
||||
artifact = target + "-with-bootloader-" + BL_VERSION + "-full-ota"
|
||||
row, _ = self.record(directory / "lora-ota", artifact, "NRF52_PLATFORM", "full")
|
||||
row["target"] = target
|
||||
profile, _ = select_profile(load_manifest(), target)
|
||||
row["capabilities"] = ["bootloader.embedded"]
|
||||
row["verification"] = [{"capability": "bootloader.embedded", "present": True,
|
||||
"source": "packaged application"}]
|
||||
row["embedded_bootloader"] = {
|
||||
"release": BL_VERSION, "profile": profile["id"],
|
||||
"candidate_sha256": "a" * 64,
|
||||
"asset_sha256": profile["files"]["zip"]["sha256"],
|
||||
"manifest_sha256": MANIFEST_SHA256, "legacy_sha256": None,
|
||||
"app_offset": 4, "image_bytes": BOOT_SIZE,
|
||||
"activation": "ota bootloader update", "automatic_delay_seconds": 70}
|
||||
folder = directory / "lora-ota"
|
||||
rows = json.loads((folder / "TARGET-MANIFEST.json").read_text()) + [row]
|
||||
def inventory():
|
||||
(folder / "TARGET-MANIFEST.json").write_text(json.dumps(rows))
|
||||
(folder / "SHA256SUMS.txt").write_text("".join(
|
||||
hashlib.sha256(p.read_bytes()).hexdigest() + " " + p.name + "\n"
|
||||
for p in sorted(folder.iterdir()) if p.name != "SHA256SUMS.txt"))
|
||||
inventory()
|
||||
next(group for group in plan["groups"] if group["key"] == "lora-ota")["target_count"] = 3
|
||||
(directory / "release-plan.json").write_text(json.dumps(plan))
|
||||
plan, family, records = catalogs.read_stage(directory)
|
||||
targets = {r["publication_target"] for r, _, _ in records} | {
|
||||
"Station_G2_companion_radio_full", "Station_G2_repeater", target}
|
||||
result = catalogs.generate(self.template(), plan, family, records,
|
||||
catalogs.target_profiles(targets), "mikecarper/MeshCore")
|
||||
entries = result["device"][1]["firmware"]
|
||||
self.assertEqual(len(entries), 3)
|
||||
embedded = next(item for item in entries if artifact in item["subTitle"])
|
||||
self.assertIn("OTAFIX " + BL_VERSION + " bootloader", embedded["subTitle"])
|
||||
self.assertIn("70 seconds", embedded["version"][FAMILY]["notes"])
|
||||
for ordinary in (item for item in entries if item is not embedded):
|
||||
self.assertIn("preserve the installed bootloader", ordinary["version"][FAMILY]["notes"])
|
||||
# A publication name cannot opt into automatic bootloader changes.
|
||||
row.pop("embedded_bootloader")
|
||||
inventory()
|
||||
with self.assertRaisesRegex(ValueError, "embedded bootloader lacks qualified metadata"):
|
||||
catalogs.read_stage(directory)
|
||||
|
||||
def test_catalog_does_not_guess_an_unknown_hardware_card(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
directory = Path(temp)
|
||||
|
||||
Reference in new issue
Block a user