def create_dfu_server(transport, zip_file_path, opts):
'''
Create a DFU server instance.
:param transpoort: A transport to be used.
:param zip_file_path: A path to the firmware package.
:param opts: Optional parameters:
mcast_dfu: An information if multicast DFU is enabled.
rate: Multicast block transfer rate, in blocks per second
reset_suppress: A delay before sending multicast reset command (in milliseconds). -1 means that no reset will be sent.
'''
temp_dir = tempfile.mkdtemp(prefix="nrf_dfu_")
unpacked_zip_path = os.path.join(temp_dir, 'unpacked_zip')
manifest = Package.unpack_package(zip_file_path, unpacked_zip_path)
protocol = piccata.core.Coap(transport)
transport.register_receiver(protocol)
init_file, image_file = _get_file_names(manifest)
with open(os.path.join(unpacked_zip_path, init_file), 'rb') as f:
init_data = f.read()
with open(os.path.join(unpacked_zip_path, image_file), 'rb') as f:
image_data = f.read()
return ThreadDfuServer(protocol, init_data, image_data, opts)
def __init__(self, zip_file_path, dfu_transport):
"""
Initializes the dfu upgrade, unpacks zip and registers callbacks.
@param zip_file_path: Path to the zip file with the firmware to upgrade
@type zip_file_path: str
@param dfu_transport: Transport backend to use to upgrade
@type dfu_transport: nordicsemi.dfu.dfu_transport.DfuTransport
@return
"""
self.zip_file_path = zip_file_path
self.ready_to_send = True
self.response_opcode_received = None
self.temp_dir = tempfile.mkdtemp(prefix="nrf_dfu_")
self.unpacked_zip_path = os.path.join(self.temp_dir, 'unpacked_zip')
self.manifest = Package.unpack_package(self.zip_file_path,
self.unpacked_zip_path)
if dfu_transport:
self.dfu_transport = dfu_transport
self.dfu_transport.register_events_callback(DfuEvent.TIMEOUT_EVENT,
self.timeout_event_handler)
self.dfu_transport.register_events_callback(DfuEvent.ERROR_EVENT,
self.error_event_handler)
def __init__(self, zip_file_path):
"""
@param zip_file_path: Path to the zip file with the firmware to upgrade
"""
zip_file_path = realpath(zip_file_path)
print(zip_file_path)
self.temp_dir = mkdtemp(prefix="nrf_dfu_")
self.unpacked_zip = path_join(self.temp_dir, "unpacked_zip")
self.manifest = Package.unpack_package(zip_file_path,
self.unpacked_zip)
self.images = {}
if self.manifest.softdevice_bootloader:
k = "softdevice_bootloader"
self.images[k] = DfuImage(self.unpacked_zip,
self.manifest.softdevice_bootloader)
if self.manifest.softdevice:
k = "softdevice"
self.images[k] = DfuImage(self.unpacked_zip,
self.manifest.softdevice)
if self.manifest.bootloader:
k = "bootloader"
self.images[k] = DfuImage(self.unpacked_zip,
self.manifest.bootloader)
if self.manifest.application:
k = "application"
self.images[k] = DfuImage(self.unpacked_zip,
self.manifest.application)
def create_dfu_server(transport, zip_file_path, prefix):
temp_dir = tempfile.mkdtemp(prefix="nrf_dfu_")
unpacked_zip_path = os.path.join(temp_dir, 'unpacked_zip')
manifest = Package.unpack_package(zip_file_path, unpacked_zip_path)
init_file, image_file = _get_file_names(manifest)
with open(os.path.join(unpacked_zip_path, init_file), 'rb') as f:
init_data = f.read()
with open(os.path.join(unpacked_zip_path, image_file), 'rb') as f:
image_data = f.read()
return ThreadDfuServer(transport, init_data, image_data, prefix)
def __init__(self, zip_file_path, dfu_transport):
"""
Initializes the dfu upgrade, unpacks zip and registers callbacks.
@param zip_file_path: Path to the zip file with the firmware to upgrade
@type zip_file_path: str
@param dfu_transport: Transport backend to use to upgrade
@type dfu_transport: nordicsemi.dfu.dfu_transport.DfuTransport
@return
"""
self.temp_dir = tempfile.mkdtemp(prefix="nrf_dfu_")
self.unpacked_zip_path = os.path.join(self.temp_dir, 'unpacked_zip')
self.manifest = Package.unpack_package(zip_file_path, self.unpacked_zip_path)
self.dfu_transport = dfu_transport
def __init__(self, zip_file_path, dfu_transport):
"""
Initializes the dfu upgrade, unpacks zip and registers callbacks.
@param zip_file_path: Path to the zip file with the firmware to upgrade
@type zip_file_path: str
@param dfu_transport: Transport backend to use to upgrade
@type dfu_transport: nordicsemi.dfu.dfu_transport.DfuTransport
@return
"""
self.temp_dir = tempfile.mkdtemp(prefix="nrf_dfu_")
self.unpacked_zip_path = os.path.join(self.temp_dir, 'unpacked_zip')
self.manifest = Package.unpack_package(zip_file_path,
self.unpacked_zip_path)
self.dfu_transport = dfu_transport
def __init__(self, zip_file_path, dfu_transport, connect_delay):
"""
Initializes the dfu upgrade, unpacks zip and registers callbacks.
@param zip_file_path: Path to the zip file with the firmware to upgrade
@type zip_file_path: str
@param dfu_transport: Transport backend to use to upgrade
@type dfu_transport: nordicsemi.dfu.dfu_transport.DfuTransport
@param connect_delay: Delay in seconds before each connection to the DFU target
@type connect_delay: int
@return
"""
self.temp_dir = tempfile.mkdtemp(prefix="nrf_dfu_")
self.unpacked_zip_path = os.path.join(self.temp_dir, 'unpacked_zip')
self.manifest = Package.unpack_package(zip_file_path, self.unpacked_zip_path)
self.dfu_transport = dfu_transport
if connect_delay is not None:
self.connect_delay = connect_delay
else:
self.connect_delay = 3
def __init__(self, zip_file_path, dfu_transport):
"""
Initializes the dfu upgrade, unpacks zip and registers callbacks.
@param zip_file_path: Path to the zip file with the firmware to upgrade
@type zip_file_path: str
@param dfu_transport: Transport backend to use to upgrade
@type dfu_transport: nordicsemi.dfu.dfu_transport.DfuTransport
@return
"""
self.zip_file_path = zip_file_path
self.ready_to_send = True
self.response_opcode_received = None
self.temp_dir = tempfile.mkdtemp(prefix="nrf_dfu_")
self.unpacked_zip_path = os.path.join(self.temp_dir, 'unpacked_zip')
self.manifest = Package.unpack_package(self.zip_file_path, self.unpacked_zip_path)
if dfu_transport:
self.dfu_transport = dfu_transport
self.dfu_transport.register_events_callback(DfuEvent.TIMEOUT_EVENT, self.timeout_event_handler)
self.dfu_transport.register_events_callback(DfuEvent.ERROR_EVENT, self.error_event_handler)
def __init__(self, zip_file_path, dfu_transport, connect_delay):
"""
Initializes the dfu upgrade, unpacks zip and registers callbacks.
@param zip_file_path: Path to the zip file with the firmware to upgrade
@type zip_file_path: str
@param dfu_transport: Transport backend to use to upgrade
@type dfu_transport: nordicsemi.dfu.dfu_transport.DfuTransport
@param connect_delay: Delay in seconds before each connection to the DFU target
@type connect_delay: int
@return
"""
self.temp_dir = tempfile.mkdtemp(prefix="nrf_dfu_")
self.unpacked_zip_path = os.path.join(self.temp_dir, 'unpacked_zip')
self.manifest = Package.unpack_package(zip_file_path,
self.unpacked_zip_path)
self.dfu_transport = dfu_transport
if connect_delay is not None:
self.connect_delay = connect_delay
else:
self.connect_delay = 3
class TestPackage(unittest.TestCase):
def setUp(self):
self.work_directory = tempfile.mkdtemp(prefix="nrf_dfu_tests_")
def tearDown(self):
shutil.rmtree(self.work_directory, ignore_errors=True)
def test_generate_package_application(self):
signer = Signing()
signer.load_key('key.pem')
self.p = Package(app_version=100,
sd_req=[0x1000, 0xfffe],
app_fw="firmwares/bar.hex",
signer=signer)
pkg_name = "mypackage.zip"
self.p.generate_package(pkg_name, preserve_work_dir=False)
expected_zip_content = ["manifest.json", "bar.bin", "bar.dat"]
with ZipFile(pkg_name, 'r') as pkg:
infolist = pkg.infolist()
for file_information in infolist:
self.assertTrue(
file_information.filename in expected_zip_content)
self.assertGreater(file_information.file_size, 0)
# Extract all and load json document to see if it is correct regarding to paths
pkg.extractall(self.work_directory)
with open(os.path.join(self.work_directory, 'manifest.json'),
'r') as f:
_json = json.load(f)
self.assertEqual('bar.bin',
_json['manifest']['application']['bin_file'])
self.assertEqual('bar.dat',
_json['manifest']['application']['dat_file'])
self.assertTrue('softdevice' not in _json['manifest'])
self.assertTrue(
'softdevice_bootloader' not in _json['manifest'])
self.assertTrue('bootloader' not in _json['manifest'])
def test_generate_package_sd_bl(self):
signer = Signing()
signer.load_key('key.pem')
self.p = Package(app_version=100,
sd_req=[0x1000, 0xfffe],
softdevice_fw="firmwares/foo.hex",
bootloader_fw="firmwares/bar.hex",
signer=signer)
pkg_name = "mypackage.zip"
self.p.generate_package(pkg_name, preserve_work_dir=False)
expected_zip_content = ["manifest.json", "sd_bl.bin", "sd_bl.dat"]
with ZipFile(pkg_name, 'r') as pkg:
infolist = pkg.infolist()
for file_information in infolist:
self.assertTrue(
file_information.filename in expected_zip_content)
self.assertGreater(file_information.file_size, 0)
# Extract all and load json document to see if it is correct regarding to paths
pkg.extractall(self.work_directory)
with open(os.path.join(self.work_directory, 'manifest.json'),
'r') as f:
_json = json.load(f)
self.assertEqual(
'sd_bl.bin',
_json['manifest']['softdevice_bootloader']['bin_file'])
self.assertEqual(
'sd_bl.dat',
_json['manifest']['softdevice_bootloader']['dat_file'])
def test_unpack_package_a(self):
signer = Signing()
signer.load_key('key.pem')
self.p = Package(app_version=100,
sd_req=[0x1000, 0xffff],
softdevice_fw="firmwares/bar.hex",
signer=signer)
pkg_name = os.path.join(self.work_directory, "mypackage.zip")
self.p.generate_package(pkg_name, preserve_work_dir=False)
unpacked_dir = os.path.join(self.work_directory, "unpacked")
manifest = self.p.unpack_package(
os.path.join(self.work_directory, pkg_name), unpacked_dir)
self.assertIsNotNone(manifest)
self.assertEqual('bar.bin', manifest.softdevice.bin_file)
# self.assertEqual(0, manifest.softdevice.init_packet_data.ext_packet_id)
# self.assertIsNotNone(manifest.softdevice.init_packet_data.firmware_crc16)
def test_unpack_package_b(self):
signer = Signing()
signer.load_key('key.pem')
self.p = Package(app_version=100,
sd_req=[0x1000, 0xffff],
softdevice_fw="firmwares/bar.hex",
signer=signer)
pkg_name = os.path.join(self.work_directory, "mypackage.zip")
self.p.generate_package(pkg_name, preserve_work_dir=False)
unpacked_dir = os.path.join(self.work_directory, "unpacked")
manifest = self.p.unpack_package(
os.path.join(self.work_directory, pkg_name), unpacked_dir)
self.assertIsNotNone(manifest)
self.assertEqual('bar.bin', manifest.softdevice.bin_file)
def test_unpack_package_c(self):
signer = Signing()
signer.load_key('key.pem')
self.p = Package(app_version=100,
sd_req=[0x1000, 0xffff],
softdevice_fw="firmwares/bar.hex",
signer=signer)
pkg_name = os.path.join(self.work_directory, "mypackage.zip")
self.p.generate_package(pkg_name, preserve_work_dir=False)
unpacked_dir = os.path.join(self.work_directory, "unpacked")
manifest = self.p.unpack_package(
os.path.join(self.work_directory, pkg_name), unpacked_dir)
self.assertIsNotNone(manifest)
self.assertEqual('bar.bin', manifest.softdevice.bin_file)
class TestPackage(unittest.TestCase):
def setUp(self):
self.work_directory = tempfile.mkdtemp(prefix="nrf_dfu_tests_")
def tearDown(self):
shutil.rmtree(self.work_directory, ignore_errors=True)
def test_generate_package_application(self):
self.p = Package(
dev_type=1,
dev_rev=2,
app_version=100,
sd_req=[0x1000, 0xfffe],
app_fw="firmwares/bar.hex"
)
pkg_name = "mypackage.zip"
self.p.generate_package(pkg_name, preserve_work_directory=False)
expected_zip_content = ["manifest.json", "bar.bin", "bar.dat"]
with ZipFile(pkg_name, 'r') as pkg:
infolist = pkg.infolist()
for file_information in infolist:
self.assertTrue(file_information.filename in expected_zip_content)
self.assertGreater(file_information.file_size, 0)
# Extract all and load json document to see if it is correct regarding to paths
pkg.extractall(self.work_directory)
with open(os.path.join(self.work_directory, 'manifest.json'), 'r') as f:
_json = json.load(f)
self.assertEqual(u'bar.bin', _json['manifest']['application']['bin_file'])
self.assertEqual(u'bar.dat', _json['manifest']['application']['dat_file'])
self.assertTrue(u'softdevice' not in _json['manifest'])
self.assertTrue(u'softdevice_bootloader' not in _json['manifest'])
self.assertTrue(u'bootloader' not in _json['manifest'])
def test_generate_package_sd_bl(self):
self.p = Package(dev_type=1,
dev_rev=2,
app_version=100,
sd_req=[0x1000, 0xfffe],
softdevice_fw="firmwares/foo.hex",
bootloader_fw="firmwares/bar.hex")
pkg_name = "mypackage.zip"
self.p.generate_package(pkg_name, preserve_work_directory=False)
expected_zip_content = ["manifest.json", "sd_bl.bin", "sd_bl.dat"]
with ZipFile(pkg_name, 'r') as pkg:
infolist = pkg.infolist()
for file_information in infolist:
self.assertTrue(file_information.filename in expected_zip_content)
self.assertGreater(file_information.file_size, 0)
# Extract all and load json document to see if it is correct regarding to paths
pkg.extractall(self.work_directory)
with open(os.path.join(self.work_directory, 'manifest.json'), 'r') as f:
_json = json.load(f)
self.assertEqual(u'sd_bl.bin', _json['manifest']['softdevice_bootloader']['bin_file'])
self.assertEqual(u'sd_bl.dat', _json['manifest']['softdevice_bootloader']['dat_file'])
def test_unpack_package_a(self):
self.p = Package(dev_type=1,
dev_rev=2,
app_version=100,
sd_req=[0x1000, 0xffff],
softdevice_fw="firmwares/bar.hex",
dfu_ver=0.6)
pkg_name = os.path.join(self.work_directory, "mypackage.zip")
self.p.generate_package(pkg_name, preserve_work_directory=False)
unpacked_dir = os.path.join(self.work_directory, "unpacked")
manifest = self.p.unpack_package(os.path.join(self.work_directory, pkg_name), unpacked_dir)
self.assertIsNotNone(manifest)
self.assertEqual(u'bar.bin', manifest.softdevice.bin_file)
self.assertEqual(0, manifest.softdevice.init_packet_data.ext_packet_id)
self.assertIsNotNone(manifest.softdevice.init_packet_data.firmware_crc16)
def test_unpack_package_b(self):
self.p = Package(dev_type=1,
dev_rev=2,
app_version=100,
sd_req=[0x1000, 0xffff],
softdevice_fw="firmwares/bar.hex",
dfu_ver=0.7)
pkg_name = os.path.join(self.work_directory, "mypackage.zip")
self.p.generate_package(pkg_name, preserve_work_directory=False)
unpacked_dir = os.path.join(self.work_directory, "unpacked")
manifest = self.p.unpack_package(os.path.join(self.work_directory, pkg_name), unpacked_dir)
self.assertIsNotNone(manifest)
self.assertEqual(u'bar.bin', manifest.softdevice.bin_file)
self.assertEqual(1, manifest.softdevice.init_packet_data.ext_packet_id)
self.assertIsNone(manifest.softdevice.init_packet_data.firmware_crc16)
self.assertIsNotNone(manifest.softdevice.init_packet_data.firmware_hash)
def test_unpack_package_c(self):
self.p = Package(dev_type=1,
dev_rev=2,
app_version=100,
sd_req=[0x1000, 0xffff],
softdevice_fw="firmwares/bar.hex",
key_file="key.pem")
pkg_name = os.path.join(self.work_directory, "mypackage.zip")
self.p.generate_package(pkg_name, preserve_work_directory=False)
unpacked_dir = os.path.join(self.work_directory, "unpacked")
manifest = self.p.unpack_package(os.path.join(self.work_directory, pkg_name), unpacked_dir)
self.assertIsNotNone(manifest)
self.assertEqual(u'bar.bin', manifest.softdevice.bin_file)
self.assertEqual(2, manifest.softdevice.init_packet_data.ext_packet_id)
self.assertIsNone(manifest.softdevice.init_packet_data.firmware_crc16)
self.assertIsNotNone(manifest.softdevice.init_packet_data.firmware_hash)
self.assertIsNotNone(manifest.softdevice.init_packet_data.init_packet_ecds)
self.assertEqual(manifest.dfu_version, 0.8)
def unpack_package(zip_file_path, unpack_path):
manifest = Package.unpack_package(zip_file_path, unpack_path)
return _get_file_names(manifest)