wiliot-certificate 1.3.0a1__py3-none-any.whl → 1.4.0a2__py3-none-any.whl

gw_certificate/interface/mqtt.py

@@ -11,16 +11,21 @@ import ssl
 import base64
 from google.protobuf.message import DecodeError
 from google.protobuf.json_format import MessageToDict, Parse, ParseError, ParseDict
+import random
+import re
 
-from gw_certificate.ag.ut_defines import PACKETS, PAYLOAD, MGMT_PKT, SIDE_INFO_PKT, GW_ID, NFPKT, GW_LOGS, UNIFIED_PKT
+from gw_certificate.ag.ut_defines import PACKETS, PAYLOAD, MGMT_PKT, SIDE_INFO_PKT, GW_ID, NFPKT, GW_LOGS, UNIFIED_PKT, STATUS_CODE_STR
 from gw_certificate.ag.wlt_types_ag import GROUP_ID_BRG2GW, GROUP_ID_SIDE_INFO, GROUP_ID_UNIFIED_PKT
 from gw_certificate.ag.wlt_types_data import DATA_DEFAULT_GROUP_ID, DataPacket
 from gw_certificate.common.debug import debug_print
 from gw_certificate.common import wltPb_pb2
 
 
-
 DATA_PKT = 'data_pkt'
+ACTIONSTATUS = 'actionStatus'
+GATEWAYSTATUS = 'gatewayStatus'
+
+TOPIC_SUFFIX_PB = '-v2'
 
 class CustomBrokers(Enum):
     HIVE = 'broker.hivemq.com'
@@ -144,6 +149,14 @@ class MqttClient:
         self.status_topic = f"status{topic_suffix}/{owner_id}/{gw_id}"
         debug_print(f'Subscribe to {self.status_topic}...')
         self.client.subscribe(self.status_topic)
+
+        self.data_topic_pb = f"data{TOPIC_SUFFIX_PB}{topic_suffix}/{owner_id}/{gw_id}"
+        debug_print(f'Subscribe to {self.data_topic_pb}...')
+        self.client.subscribe(self.data_topic_pb)
+        self.status_topic_pb = f"status{TOPIC_SUFFIX_PB}{topic_suffix}/{owner_id}/{gw_id}"
+        debug_print(f'Subscribe to {self.status_topic_pb}...')
+        self.client.subscribe(self.status_topic_pb)
+
         self.client.loop_start()
         while(not self.client.is_connected()):
             debug_print(f'Waiting for MQTT connection...')
@@ -168,7 +181,6 @@ class MqttClient:
             raw_payload = json.dumps({"action": action.value})
             self.userdata['published'].append(raw_payload.encode('utf-8'))
             message_info = self.client.publish(self.update_topic, payload=raw_payload)
-            print('PublishJSON')
         # PB
         if self.get_serialization() in {Serialization.UNKNOWN, Serialization.PB}:
             payload = wltPb_pb2.DownlinkMessage()
@@ -176,10 +188,51 @@ class MqttClient:
             raw_payload = payload.SerializeToString()
             self.userdata['published'].append(raw_payload)
             message_info = self.client.publish(self.update_topic, payload=raw_payload)
-            print('PublishPB')
         message_info.wait_for_publish()
         return message_info
     
+    def send_bridge_ota_action(self, target_bridge, version, tx_max_duration, upgrade_bl_sd,
+                               gw_id, cloud="aws", env='prod'):
+        """
+        VersionUUID generated here - Consistent per (version + upgrade_bl_sd) combination.
+        ImageDirUrl generated here - Consistent per (cloud + env + version) combination. Bridge type remain the same.
+        RebootPacket generated here - using given targer_bridge and random seq_id.
+        """
+        CLOUD_MAP = {"aws": f"https://api.us-east-2.{env}.wiliot.cloud",
+                     "gcp": f"https://api.us-central1.{env}.gcp.wiliot.cloud"}
+        GW_TYPE_UNKNOWN = 254
+
+        image_dir_url = f"{CLOUD_MAP[cloud]}/v1/bridge/type/{GW_TYPE_UNKNOWN}/version/{version}/binary/"
+        version_uuid = f"{version}1337{upgrade_bl_sd}"
+        seq_id = f"{random.randint(0, 255):02X}"
+        debug_print(f"Bridge file URL: {image_dir_url}")
+
+        reboot_packet = f"1E16C6FC0000ED070C{seq_id}{target_bridge}01"
+        reboot_packet = reboot_packet.ljust(62, '0')
+
+        if self.get_serialization() in {Serialization.UNKNOWN, Serialization.JSON}:
+            message = {
+                "action": 1,
+                "gatewayId": gw_id,
+                "imageDirUrl": image_dir_url,
+                "versionUUID": version_uuid,
+                "txPacket": reboot_packet,
+                "txMaxRetries": tx_max_duration // 100,
+                "txMaxDurationMs": tx_max_duration,
+                "bridgeId": target_bridge
+            }
+            self.send_payload(message, topic='update')
+        if self.get_serialization() in {Serialization.UNKNOWN, Serialization.PB}:
+            message = wltPb_pb2.DownlinkMessage()
+            message.bridgeUpgrade.rebootPacket = bytes.fromhex(reboot_packet)
+            message.bridgeUpgrade.txMaxDurationMs = tx_max_duration
+            message.bridgeUpgrade.txMaxRetries = tx_max_duration // 100
+            message.bridgeUpgrade.bridgeId = target_bridge
+            message.bridgeUpgrade.versionUuid = version_uuid
+            message.bridgeUpgrade.upgradeBlSd = upgrade_bl_sd
+            message.bridgeUpgrade.imageDirUrl = image_dir_url
+            self.send_payload(message, topic='update')
+    
     def send_payload(self, payload, topic:Literal['update', 'data', 'status']='update'):
         """
         Send a payload to the gateway
@@ -284,20 +337,13 @@ class MqttClient:
     def check_gw_seen(self):
         return self.userdata['gw_seen']
     
-    def get_gw_info(self):
-        self.flush_messages()
-        self.send_action(GwAction.GET_GW_INFO)
-        time.sleep(5)
-        debug_print('---GW INFO---')
-        try:
-            gw_info = self.userdata['messages'].status[0]
-            debug_print(gw_info)
-            self.flush_messages()
-            return gw_info
-        except IndexError:
-            debug_print('No GW INFO')
-            self.flush_messages()
-            return False
+    def get_gw_info_message(self):
+        messages = self.get_all_messages_from_topic('status')
+        for message in messages:
+            if GW_LOGS not in message.body_ex.keys():
+                if 'gatewayInfo' in message.body_ex.keys():
+                    return message.body_ex
+        return None
         
     def get_gw_configuration(self):
         self.flush_messages()
@@ -354,7 +400,23 @@ class MqttClient:
         messages = self.get_all_messages_from_topic('status')
         for message in messages:
             if GW_LOGS not in message.body_ex.keys():
-                return message.body_ex
+                if 'gatewayConf' in message.body_ex.keys():
+                    return message.body_ex
+                elif GATEWAYSTATUS in message.body_ex.keys():
+                    return message.body_ex[GATEWAYSTATUS]
+        return None
+
+    def get_action_status_message(self):
+        messages = self.get_all_messages_from_topic('status')
+        for message in messages:
+            if GW_LOGS not in message.body_ex.keys():
+                if STATUS_CODE_STR in message.body_ex.keys():
+                    return message.body_ex
+                elif ACTIONSTATUS in message.body_ex.keys():
+                    if 'status' not in message.body_ex[ACTIONSTATUS].keys():
+                        # Default values are omitted in protobuf, set 0 for explicitness
+                        message.body_ex[ACTIONSTATUS]['status'] = 0
+                    return message.body_ex[ACTIONSTATUS]
         return None
     
     def get_coupled_tags_pkts(self):
@@ -365,6 +427,21 @@ class MqttClient:
     
     def get_all_tags_pkts(self):
         return [p for p in self.get_all_pkts_from_topic('data')]
+    
+    # Validate topic
+    def validate_serialization_topic(self, topic:Literal['status', 'data', 'update']):
+        messages = self.get_all_messages_from_topic(topic)
+        
+        if self.get_serialization() == Serialization.JSON:
+            for message in messages:
+                if TOPIC_SUFFIX_PB in message.mqtt_topic:
+                    return (False, message.body_ex, message.mqtt_topic)
+        elif self.get_serialization() == Serialization.PB:
+            for message in messages:
+                if TOPIC_SUFFIX_PB not in message.mqtt_topic:
+                    return (False, message.body_ex, message.mqtt_topic)
+        return (True, None, None)
+
 
 # MQTT Client callbacks
 

gw_certificate/interface/pkt_generator.py

@@ -1,7 +1,6 @@
 import binascii
 import datetime
 from typing import Literal, List
-import numpy as np
 import random
 import os
 
@@ -17,13 +16,11 @@ from gw_certificate.ag.wlt_types import *
 from gw_certificate.ag.wlt_types_ag import (
     GROUP_ID_SIDE_INFO,
     GROUP_ID_BRG2GW,
-    GROUP_ID_GW2BRG,
     Hdr,
     SideInfo,
 )
 from gw_certificate.ag.wlt_types_data import DataPacket
 
-# TODO Find a relevant place for this define that is not auto-generated.
 BRG_LATENCY =                   "brg_latency"
 
 # Shared Functions
@@ -623,23 +620,6 @@ class BrgPktGeneratorNetwork:
         for brg in self.secondary_brgs:
             brg.set_tag_list(self.primary_brg.tag_list)
     
-    def get_new_pkt_pairs(self) -> list:
-        """Get data/si pairs for all bridges in bridge network
-
-        :return: List of dictionaries containing {bridge_id, data_packet, si_packet} key:value pairs
-        :rtype: list[dict]
-        """
-        pkts = []
-        new_pkt_primary = self.primary_brg.get_new_data_si()
-        pkts.append(new_pkt_primary)
-        for brg in self.secondary_brgs:
-            brg.update_si_list()
-            brg.randomize_si_rssi_nfpkt()
-            pkts.append(brg.get_existing_data_si())
-        for idx, pkt in enumerate(pkts):
-            pkt.update({'bridge_id': self.brg_list[idx].bridge_id})
-        return pkts
-    
     def get_new_pkt_unified(self) -> list:
         """Get new unified pkt for all bridges in bridge network
 
@@ -656,65 +636,3 @@ class BrgPktGeneratorNetwork:
         for idx, pkt in enumerate(pkts):
             pkt.update({'bridge_id': self.brg_list[idx].bridge_id})
         return pkts    
-      
-    def get_scattered_pkt_pairs(self, delay):
-        """Get data/si pairs with scattered time delays
-
-        :param delay: bridges rxTxPeriod equivalent (millisecond)
-        :type delay: int
-        """
-        assert delay / len(self.brg_list) >= 10, 'Cannot get scattered PKT pairs for parameters! decrease num of brgs or increase delay'
-        start_times = sorted(random.sample(list(np.arange(0, delay-10+1, 10)), k=len(self.brg_list)))
-        start_times.append((start_times[0] + delay))
-        pkts = self.get_new_pkt_pairs()
-        
-        for idx, pkt in enumerate(pkts):
-            # minimum time between UART packet commands = 10ms
-            pkt['time_delay'] = max(start_times[idx+1] - start_times[idx], 10)
-        return pkts
-
-class CloudPktGenerator:
-    """Cloud Packet Generator - Represents """
-    def __init__(self):
-        self.bridge_id, self.bridge_id_int = generate_random_bridge_id()
-        pass
-
-    def generate_config_pkt(self, seq_id=None, bridge_id=None):
-        if seq_id == None:
-            seq_id = int.from_bytes(os.urandom(1), 'big')
-        if bridge_id is not None:
-            bridge_id_int = int.from_bytes(binascii.unhexlify(bridge_id), "big")
-
-        pkt = WltPkt(Hdr(group_id=GROUP_ID_GW2BRG), generic=Gw2BrgCfgV7(
-            msg_type=BRG_MGMT_MSG_TYPE_CFG_SET,
-            global_pacing_group=random.getrandbits(4),
-            output_power_sub_1_ghz=random.getrandbits(4),
-            seq_id=random.getrandbits(8),
-            brg_mac=bridge_id_int,
-            unused0=0,
-            pkt_types_mask=random.getrandbits(5),
-            unused1=0,
-            rxtx_period=random.getrandbits(8),
-            tx_period=random.getrandbits(8),
-            energy_pattern_idx=random.getrandbits(8),
-            output_power_2_4=random.getrandbits(8),
-            pacer_interval=random.getrandbits(16),
-            unused2=0,
-            tx_prob=random.getrandbits(3),
-            tx_repetition=random.getrandbits(4),
-            transmit_time_sub_1_ghz=random.getrandbits(4),
-            sub1g_freq_profile=random.getrandbits(4),
-            ))
-        return pkt.dump()
-
-    # def generate_action_pkt(self, action: Literal["blink", "reboot"], seq_id=None, bridge_id=None):
-    #     if seq_id == None:
-    #         seq_id = int.from_bytes(os.urandom(1), 'big')
-    #     if bridge_id is not None:
-    #         bridge_id_int = int.from_bytes(binascii.unhexlify(bridge_id), "big")
-
-    #     pkt = WltPkt(Hdr(group_id=GROUP_ID_GW2BRG), generic=ActionV7(
-    #         msg_type=BRG_MGMT_MSG_TYPE_ACTION,
-    #         seq_id=seq_id,
-    #         action_id=
-    #                                                                  )

gw_certificate/interface/uart_if.py

@@ -3,7 +3,8 @@ import subprocess
 import serial
 import serial.tools.list_ports
 import time
-import os.path
+import os
+import stat
 import platform
 from packaging import version
 import pkg_resources
@@ -11,24 +12,31 @@ import pkg_resources
 from gw_certificate.common.debug import debug_print
 from gw_certificate.interface.if_defines import *
 
-LATEST_VERSION = '4.4.15'
-LATEST_VERSION_FILE = f'{LATEST_VERSION}_app.zip'
+LATEST_VERSION = '4.4.52'
+LATEST_VERSION_FILE = f'{LATEST_VERSION}_sd_bl_app.zip'
 LATEST_VERSION_PATH = pkg_resources.resource_filename(__name__, LATEST_VERSION_FILE)
+LATEST_VERSION_FILE_APP = f'{LATEST_VERSION}_app.zip'
+LATEST_VERSION_PATH_APP = pkg_resources.resource_filename(__name__, LATEST_VERSION_FILE_APP)
 
-LATEST_VERSION_SNIFFING_KIT = '4.1.19'
-LATEST_VERSION_FILE_SNIFFING_KIT = f'{LATEST_VERSION_SNIFFING_KIT}_app.zip'
-LATEST_VERSION_PATH_SNIFFING_KIT = pkg_resources.resource_filename(__name__, LATEST_VERSION_FILE_SNIFFING_KIT)
+FIRST_UNIFIED_BL_VERSION = version.parse('4.4.44')
+
+NRFUTIL_FW_TOO_LOW_ERROR = 'Error 0x05: The firmware version is too low'
 
 class UARTError(Exception):
     pass
 
 class UARTInterface:
-    def __init__(self, comport, update_fw=True, sniffing_kit_flag=False):
+    def __init__(self, comport, update_fw=True):
         self.comport = comport
         self.serial = serial.Serial(port=comport, baudrate=921600, timeout=SERIAL_TIMEOUT)
         self.serial.flushInput()
         self.gw_app_rx = None
-        self.sniffing_kit_flag = sniffing_kit_flag
+        self.fw_version, self.mac = self.get_version_mac()
+
+        if self.fw_version is None:
+            raise UARTError("Cannot initialize board! Please try disconnecting and connecting USB cable")
+        self.fw_version = version.parse(self.fw_version)
+
         version_supported = self.check_fw_supported()
         if not version_supported and update_fw:
             update_status = self.update_firmware()
@@ -73,28 +81,26 @@ class UARTInterface:
     
     def flush(self):
         self.serial.close()
+        time.sleep(2)
         self.serial.open()
         self.serial.flushInput()
         self.serial.flush()
         self.serial.reset_output_buffer()
 
-    def reset_gw(self):
+    def reset_gw(self, stop_advertising=True):
         self.flush()
         self.write_ble_command(RESET_GW)
         self.gw_app_rx = None
         time.sleep(3)
-        self.write_ble_command(STOP_ADVERTISING)
-        time.sleep(3)
-
+        if stop_advertising:
+            self.write_ble_command(STOP_ADVERTISING)
+            time.sleep(3)
 
     def cancel(self):
         self.write_ble_command(CANCEL)
 
     def set_rx(self, rx_channel):
-        if self.sniffing_kit_flag:
-            assert rx_channel in RX_CHANNELS_SNIFFING_KIT
-        else:
-            assert rx_channel in RX_CHANNELS
+        assert rx_channel in RX_CHANNELS
         if self.gw_app_rx is None:
             self.reset_gw()
 
@@ -102,9 +108,6 @@ class UARTInterface:
             # from 3.17.0, only full_cfg can be used to configure channels. sending it with:
             # Data coupling(DC) off, wifi(NW) and mqtt(MQ) on.
             rx_ch_to_fw_enums = {37: 2, 38: 3, 39: 4}
-            if self.sniffing_kit_flag:
-                my_dict = {i: 5 + i for i in range(37)}
-                rx_ch_to_fw_enums.update(my_dict)
             cmd = f'!full_cfg DM {rx_ch_to_fw_enums[rx_channel]} DC 0 NW 1 MQ 1 CH {rx_channel}'
             # cmd = '!gateway_app'
         else:
@@ -128,6 +131,17 @@ class UARTInterface:
         self.write_ble_command(CANCEL_SNIFFER)
         self.flush()
 
+    def get_version_mac(self):
+        self.reset_gw()
+        self.flush()
+        timeout = datetime.datetime.now() + datetime.timedelta(seconds=15)
+        while datetime.datetime.now() < timeout:
+            raw_version = self.write_ble_command(VERSION, read=True)
+            if raw_version is not None:
+                if GW_APP_VERSION_HEADER in raw_version:
+                    return (raw_version.split(' ')[0].split('=')[1], raw_version.split(' ')[1].split('=')[1])
+        return None, None
+
     def get_version(self):
         self.reset_gw()
         self.flush()
@@ -139,36 +153,57 @@ class UARTInterface:
                     return raw_version.split(' ')[0].split('=')[1]
         return None
     
+    def get_mac(self):
+        self.reset_gw()
+        self.flush()
+        timeout = datetime.datetime.now() + datetime.timedelta(seconds=15)
+        while datetime.datetime.now() < timeout:
+            reply = self.write_ble_command(VERSION, read=True)
+            if reply is not None:
+                if GW_MAC_ADDRESS_HEADER in reply:
+                    return reply.split(' ')[1].split('=')[1]
+        return None
+    
     def check_fw_supported(self):
-        current_version = self.get_version()
-        if current_version is None:
-            raise UARTError("Cannot initialize board! Please try disconnecting and connecting USB cable")
-        current_version = version.parse(current_version)
         hex_version = version.parse(os.path.splitext(os.path.basename(LATEST_VERSION_PATH))[0].split('_')[0])
-        self.fw_version = current_version
-        if current_version >= hex_version:
-            debug_print(f'GW Running version {current_version}')
-            self.fw_version = current_version
+        if self.fw_version >= hex_version:
+            debug_print(f'GW Running version {self.fw_version}')
             return True
         return False
+    
+    def make_executable(self, file_path):
+        """Set execute permissions for a file (chmod +x).
+        For windows, having the file suffix as .exe is enough. """
+        # Get current file permissions
+        current_permissions = os.stat(file_path).st_mode
+        # Add execute permissions for the user, group, and others
+        os.chmod(file_path, current_permissions | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
 
     def update_firmware(self):
         NRFUTIL_MAP = {"Linux": "nrfutil-linux", "Darwin": "nrfutil-mac", "Windows": "nrfutil.exe"}
         nrfutil_file = pkg_resources.resource_filename(__name__, NRFUTIL_MAP[platform.system()])
+        if platform.system() != "Windows":
+            self.make_executable(nrfutil_file)
         # In order to support NRF UART FW update with protobuf > 3.20.0
         os.environ['PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION'] = 'python'
         
-        self.write_ble_command('!reset', read=True)
+        self.reset_gw()
         self.write_ble_command('!move_to_bootloader', read=True)
         self.serial.close()
         p = None
-        if self.sniffing_kit_flag:
-            p = subprocess.Popen(f'{nrfutil_file} dfu serial --package "{LATEST_VERSION_PATH_SNIFFING_KIT}" -p {self.comport} -fc 0 -b 115200 -t 10', shell=True)
-        else:
-            p = subprocess.Popen(f'{nrfutil_file} dfu serial --package "{LATEST_VERSION_PATH}" -p {self.comport} -fc 0 -b 115200 -t 10', shell=True)
-        p.wait()
-        return_code = p.returncode
-        debug_print('Waiting for device to update...')
+        dfu_full_process = subprocess.Popen(f'{nrfutil_file} dfu serial --package "{LATEST_VERSION_PATH}" -p {self.comport} -fc 0 -b 115200 -t 10',
+                            stderr=subprocess.PIPE, shell=True, text=True)
+        dfu_full_process.wait()
+        return_code = dfu_full_process.returncode
+        for line in dfu_full_process.stderr:
+            if NRFUTIL_FW_TOO_LOW_ERROR in line:
+                debug_print(f"DFU failed due to firmware (bootloader/application) version being too low.")
+                debug_print(f"Probably since bootloader is already upgraded. Attempting to upgrade application only..")
+                dfu_app_process = subprocess.Popen(f'{nrfutil_file} dfu serial --package "{LATEST_VERSION_PATH_APP}" -p {self.comport} -fc 0 -b 115200 -t 10',
+                                    stderr=subprocess.PIPE, shell=True, text=True)
+                dfu_app_process.wait()
+                return_code = dfu_app_process.returncode
+        debug_print('Waiting for the certificate kit to apply the update and boot...')
         timeout = datetime.datetime.now() + datetime.timedelta(minutes=2)
         current_ver = ''
         time.sleep(15)
@@ -179,15 +214,10 @@ class UARTInterface:
             if current_ver is None:
                 current_ver = ''
             time.sleep(1)
-        if self.sniffing_kit_flag:
-            if current_ver.split(' ')[0].split('=')[1] != LATEST_VERSION_SNIFFING_KIT:
-                return False
-        else:
-            if current_ver.split(' ')[0].split('=')[1] != LATEST_VERSION:
-                return False
+        if current_ver.split(' ')[0].split('=')[1] != LATEST_VERSION:
+            return False
         if return_code == 0:
             self.fw_version = version.parse(current_ver.split(' ')[0].split('=')[1])
+            debug_print(f"Certification kit upgraded to {LATEST_VERSION} successfully")
             return True
         return False
-
-        ### TODO: Sequence List

gw_certificate/templates/results.html

@@ -39,7 +39,7 @@
     </div>
     <br>
         <div class="container">
-            <h1> GW Certificate | version {{version}} | {{ gw_id }} | {{ datetime }}</h1>
+            <h1> GW Certificate | Version {{version}} | {{ gw_id }} | {{ datetime }}</h1>
             <div class="card">
                 <div class="card-header">
                     Tests Summary

gw_certificate/tests/__init__.py

@@ -7,5 +7,4 @@ from gw_certificate.tests.throughput import StressTest
 
 TESTS = [RegistrationTest, ConnectionTest, UplinkTest, DownlinkTest, ActionsTest, StressTest]
 
-TESTS_DEFAULT = [ConnectionTest, UplinkTest, DownlinkTest, ActionsTest, StressTest]
-TESTS_NO_UART = [RegistrationTest, ActionsTest]
+TESTS_NO_UART = [RegistrationTest]