wiliot-certificate 4.4.3__py3-none-any.whl → 4.5.0__py3-none-any.whl

{brg_certificate → certificate}/cert_mqtt.py

@@ -8,28 +8,40 @@ import datetime
 import base64
 import copy
 import traceback
-import brg_certificate.wltPb_pb2 as wpb
+import common.wltPb_pb2 as wpb
 from google.protobuf.message import DecodeError
 from google.protobuf.json_format import MessageToDict
 
 # Local imports
-from brg_certificate.wlt_types import *
-from brg_certificate.cert_data_sim import PIXEL_SIM_INDICATOR, TAG_ID_OFFSET
-from brg_certificate.cert_prints import *
-from brg_certificate.cert_defines import *
+from certificate.wlt_types import *
+from certificate.cert_data_sim import PIXEL_SIM_INDICATOR, TAG_ID_OFFSET
+from certificate.cert_prints import *
+from certificate.cert_defines import *
 
 
 SENSORS_DATA_SI_DUP = 6
-
+# Custom MQTT brokers' configuration jsons' paths
+EMQX = os.path.join(BASE_DIR, "config/emqx.json")
+WILIOT_DEV = os.path.join(BASE_DIR, "config/wiliot-dev.json")
 class WltMqttPkt:
     def __init__(self, body, topic, userdata):
         self.body = body
         self.mqtt_topic = topic
-        self.mqtt_timestamp = datetime.datetime.now()
+        self.mqtt_timestamp = int(time.time() * 1000)
         self.body_ex = {}
         if "data" in self.mqtt_topic:
             self.body_ex = copy.deepcopy(body)
             self.body_ex['undecrypted'] = 0
+
+            # Split aggregated packets into multiple packets
+            split_pkts = []
+            for pkt in self.body_ex[PACKETS]:
+                if len(pkt[PAYLOAD])/2 > (int(pkt[PAYLOAD][0:2], 16) + 1): # Aggregated packet since the length is larger than the header length
+                    split_pkts += split_aggregated_pkt(pkt)
+                else: # Not an aggregated packet
+                    split_pkts += [pkt]
+            self.body_ex[PACKETS] = split_pkts
+
             for pkt in self.body_ex[PACKETS]:
                 # if packet is not a mgmt packet or a side info packet it is a data packet
                 wlt_pkt = WltPkt(pkt[PAYLOAD])
@@ -45,7 +57,12 @@ class WltMqttPkt:
                     elif wlt_pkt.hdr.group_id == ag.GROUP_ID_SIDE_INFO_SENSOR:
                         pkt[SIDE_INFO_SENSOR_PKT] = copy.deepcopy(wlt_pkt)
                     elif wlt_pkt.hdr.uuid_lsb == ag.HDR_DEFAULT_BRG_SENSOR_UUID_LSB and wlt_pkt.hdr.uuid_msb == ag.HDR_DEFAULT_BRG_SENSOR_UUID_MSB:
-                        pkt[SENSOR_PKT] = copy.deepcopy(wlt_pkt)
+                        if isinstance(wlt_pkt.pkt, ag.UnifiedSensorPkt):
+                            pkt[UNIFIED_SENSOR_PKT] = copy.deepcopy(wlt_pkt)
+                            if (wlt_pkt.hdr.group_id == ag.GROUP_ID_SIGNAL_INDICATOR):
+                                pkt[UNIFIED_SENSOR_PKT].pkt.signal_indicator_payload = ag.SignalIndicatorDataV1(pkt[PAYLOAD][8:62])
+                        else:
+                            pkt[SENSOR_PKT] = copy.deepcopy(wlt_pkt)
                         pkt[DECODED_DATA] = {TAG_ID: None, PACKET_CNTR: None, PACKET_TYPE: None}
                 else:
                     if userdata["data"] != DATA_SIMULATION:
@@ -91,7 +108,7 @@ class WltMqttPkts:
         self.status = []
 
 def local_resolve(p):
-    import brg_certificate.ut.ut_resolve as ut_resolve
+    import certificate.ut.ut_resolve as ut_resolve
     irresolvable_payloads = ["1E16C6FC0000EE", "1E16AFFD0000EC", "1E16C6FC0000EC"]
     try:
         if any(substring in p for substring in irresolvable_payloads):
@@ -115,6 +132,39 @@ def local_resolve(p):
         print(e)
         print(f"Failed in local_resolve with packet: {p}\n")
         return None
+    
+def split_aggregated_pkt(pkt):
+    hex_str = pkt[PAYLOAD]
+    idx = 0
+    fragments = []
+
+    # walk through the hex string
+    while idx < len(hex_str):
+        # parse length byte
+        length = int(hex_str[idx:idx+2], 16)
+        if length < ag.HDR_DEFAULT_PKT_SIZE:
+            # The sensor packet itself is built from small segments, the smallest payload is of size 31 bytes
+            length = ag.HDR_DEFAULT_PKT_SIZE
+        end = idx + 2 + length*2
+        if end > len(hex_str):
+            raise ValueError(
+                f"Packet at position {idx} says {length} bytes, "
+                f"but only {(len(hex_str)-idx-2)//2} are available. pkt : {pkt[PAYLOAD]}"
+            )
+        # slice out this packet (including the length byte itself)
+        fragment = hex_str[idx:end]
+
+        # build new packet dict
+        fragments.append({
+            PAYLOAD: fragment,
+            TIMESTAMP: pkt[TIMESTAMP],
+            SEQUENCE_ID: pkt[SEQUENCE_ID],
+            RSSI: pkt[RSSI],
+            ALIAS_BRIDGE_ID: pkt[ALIAS_BRIDGE_ID],
+            AGGREGATED_PAYLOAD: pkt[PAYLOAD]
+        })
+        idx = end
+    return fragments
 
 def is_json(msg):
     is_utf = True
@@ -148,7 +198,8 @@ def on_message_json(mqttc, userdata, message):
     wlt_mqtt_pkts = userdata[PKTS]
     data = json.loads(message.payload.decode("utf-8"))
     wlt_mqtt_pkts.insert(WltMqttPkt(data, message.topic, userdata))
-    write_to_mqtt_log_file("// JSON message received at {}, topic={}:\n{}\n".format(datetime.datetime.now().strftime("%d/%m/%Y, %H:%M:%S"), message.topic, str(message.payload.decode("utf-8"))))
+    text = json.dumps(json.loads(message.payload.decode("utf-8")), indent=4)
+    write_to_mqtt_log_file("// JSON message received at {}, topic={}:\n{}\n".format(datetime.datetime.now().strftime("%d/%m/%Y, %H:%M:%S"), message.topic, text))
 
 def on_message_protobuf(mqttc, userdata, message):
     pb_msg = None
@@ -165,19 +216,21 @@ def on_message_protobuf(mqttc, userdata, message):
         pb_msg.ParseFromString(message.payload)
         pb_decoded = True
     except DecodeError as e: 
-        print(f'ERROR: failed decoding {message.topic} message: \n{e}\n')
+        print(f'ERROR: failed decoding {message.topic} message: {e}\npayload: {message.payload}')
 
     if pb_decoded is True:
         pb_msg_dict = MessageToDict(pb_msg)
         # Align formats with JSON (bytes to hex strings)
         if 'status' in message.topic:
             if ACTION_STATUS in pb_msg_dict:
-                pb_msg_dict[ACTION_STATUS][BRIDGE_ID] = base64.b64decode(pb_msg_dict[ACTION_STATUS][BRIDGE_ID]).hex().upper()
+                if BRIDGE_ID in pb_msg_dict[ACTION_STATUS].keys():
+                    pb_msg_dict[ACTION_STATUS][BRIDGE_ID] = base64.b64decode(pb_msg_dict[ACTION_STATUS][BRIDGE_ID]).hex().upper()
             if GW_STATUS in pb_msg_dict and ACL_IDS in pb_msg_dict[GW_STATUS][CONFIG][ACL][ACL_VALUE]:
                 ids_list = pb_msg_dict[GW_STATUS][CONFIG][ACL][ACL_VALUE][ACL_IDS]
                 for idx, id in enumerate(ids_list):
                     ids_list[idx] = base64.b64decode(id).hex().upper()
         if 'data' in message.topic and PACKETS in pb_msg_dict.keys():
+            pb_msg_dict[TIMESTAMP] = (int(pb_msg_dict[TIMESTAMP]))
             for idx, pkt in enumerate(pb_msg_dict[PACKETS]):
                 pb_msg_dict[PACKETS][idx][PAYLOAD] = base64.b64decode(pkt[PAYLOAD]).hex().upper()
                 pb_msg_dict[PACKETS][idx][TIMESTAMP] = int(pkt[TIMESTAMP])
@@ -196,37 +249,36 @@ def on_message_protobuf(mqttc, userdata, message):
 def pkts_to_log(pkts):
     text = ""
     for p in pkts:
-        text += "// {} topic={}".format(p.mqtt_timestamp.strftime("%d/%m/%Y, %H:%M:%S"), p.mqtt_topic)
+        dt = datetime.datetime.fromtimestamp(p.mqtt_timestamp / 1000)
+        text += "// {} topic={}".format(dt.strftime("%d/%m/%Y, %H:%M:%S"), p.mqtt_topic)
         text += "\n"+json.dumps(p.body, indent=4)+"\n"
     return text
 
-def write_to_log_file(file_name, pkts):
-    f = open(os.path.join(BASE_DIR, file_name), "w")
-    f.write(pkts_to_log(pkts))
-    f.close()
+def write_pkts_to_log_file(file, pkts):
+    write_to_log_file(file, pkts_to_log(pkts), "w")
 
 def write_to_mqtt_log_file(txt):
-    f = open(os.path.join(BASE_DIR, CERT_MQTT_LOG_FILE), "a")
-    f.write(txt)
-    f.close()
-
-def load_custom_broker(gw, rel_path="."):
-    f = open(os.path.join(BASE_DIR, rel_path, "config", "eclipse.json"))
-    # f = open(os.path.join(BASE_DIR, rel_path, "config", "hivemq.json"))
-    # f = open(os.path.join(BASE_DIR, rel_path, "config", "mosquitto.json"))
-    # f = open(os.path.join(BASE_DIR, rel_path, "config", "wiliot-dev.json"))
+    write_to_log_file(CERT_MQTT_LOG_FILE, txt, "a")
+
+def load_custom_broker(broker_filepath, gw):
+    try:
+        f = open(str(broker_filepath).strip("'"))
+    except FileNotFoundError:
+        raise FileNotFoundError(f"No such file: {broker_filepath}")
     data = json.load(f)
-    data[CUSTOM_BROKER_UPDATE_TOPIC] += gw
-    data[CUSTOM_BROKER_STATUS_TOPIC] += gw
-    data[CUSTOM_BROKER_DATA_TOPIC] += gw
+    data[CUSTOM_BROKER_UPDATE_TOPIC] = data[CUSTOM_BROKER_UPDATE_TOPIC].replace(f'<{GW_ID}>', gw)
+    data[CUSTOM_BROKER_STATUS_TOPIC] = data[CUSTOM_BROKER_STATUS_TOPIC].replace(f'<{GW_ID}>', gw)
+    data[CUSTOM_BROKER_DATA_TOPIC] = data[CUSTOM_BROKER_DATA_TOPIC].replace(f'<{GW_ID}>', gw)
     return data
 
-def mqttc_init(gw_id, userdata={PKTS: WltMqttPkts()}, rel_path=".", data=DATA_REAL_TAGS):
-
-    custom_broker = load_custom_broker(gw=gw_id, rel_path=rel_path)
+def mqttc_init(gw_id, custom_broker, data=DATA_REAL_TAGS):
+    # Ensure each MQTT client gets its own userdata for logging and getting pkts
+    userdata = {PKTS: WltMqttPkts()}  
+    custom_broker = load_custom_broker(broker_filepath=custom_broker, gw=gw_id)
     client_id = '{}-republish'.format(gw_id)
     userdata["data"] = data
     mqttc = mqtt.Client(mqtt.CallbackAPIVersion.VERSION1, client_id, userdata=userdata)
+    print(f"Connecting to MQTT broker at {custom_broker[CUSTOM_BROKER_BROKER_URL]}:{custom_broker[CUSTOM_BROKER_PORT]} with client ID: {client_id}")
     mqttc.username_pw_set(custom_broker[CUSTOM_BROKER_USERNAME], custom_broker[CUSTOM_BROKER_PASSWORD])
     mqttc.on_message = on_message
     mqttc.on_connect = on_connect
@@ -240,10 +292,21 @@ def mqttc_init(gw_id, userdata={PKTS: WltMqttPkts()}, rel_path=".", data=DATA_RE
 
     mqttc.update_topic = custom_broker[CUSTOM_BROKER_UPDATE_TOPIC]
     mqttc.subscribe(mqttc.update_topic)
+    print(f"Subscribed to update topic: {mqttc.update_topic}")
     mqttc.data_topic = custom_broker[CUSTOM_BROKER_DATA_TOPIC]
     mqttc.subscribe(mqttc.data_topic)
+    print(f"Subscribed to data topic: {mqttc.data_topic}")
     mqttc.status_topic = custom_broker[CUSTOM_BROKER_STATUS_TOPIC]
     mqttc.subscribe(mqttc.status_topic)
+    print(f"Subscribed to status topic: {mqttc.status_topic}")
+
+    # v2 protobuf topics
+    mqttc.data_topic_pb = re.sub(r'^([^/]+)', r'\1-v2', custom_broker[CUSTOM_BROKER_DATA_TOPIC])
+    mqttc.subscribe(mqttc.data_topic_pb)
+    print(f"Subscribed to data topic: {mqttc.data_topic_pb}")
+    mqttc.status_topic_pb = re.sub(r'^([^/]+)', r'\1-v2', custom_broker[CUSTOM_BROKER_STATUS_TOPIC])
+    mqttc.subscribe(mqttc.status_topic_pb)
+    print(f"Subscribed to status topic: {mqttc.status_topic_pb}")
 
     mqttc.flush_pkts = mqttc._userdata[PKTS].flush
     mqttc.flush_data_pkts = mqttc._userdata[PKTS].flush_data
@@ -252,33 +315,65 @@ def mqttc_init(gw_id, userdata={PKTS: WltMqttPkts()}, rel_path=".", data=DATA_RE
 
     return mqttc
 
-def dump_pkts(test, log):
-    write_to_log_file(os.path.join(test.dir, MQTT_LOG_PRE_STR+log+"_all.json"), test.mqttc._userdata[PKTS].all)
-    write_to_log_file(os.path.join(test.dir, MQTT_LOG_PRE_STR+log+"_data.json"), test.mqttc._userdata[PKTS].data)
-    write_to_log_file(os.path.join(test.dir, MQTT_LOG_PRE_STR+log+"_status.json"), test.mqttc._userdata[PKTS].status)
-    write_to_log_file(os.path.join(test.dir, MQTT_LOG_PRE_STR+log+"_update.json"), test.mqttc._userdata[PKTS].update)
+def dump_pkts(test, log, target=DUT):
+    mqttc = test.get_mqttc_by_target(target)
+    write_pkts_to_log_file(os.path.join(test.dir, MQTT_LOG_PRE_STR+log+"_all.json"), mqttc._userdata[PKTS].all)
+    write_pkts_to_log_file(os.path.join(test.dir, MQTT_LOG_PRE_STR+log+"_data.json"), mqttc._userdata[PKTS].data)
+    write_pkts_to_log_file(os.path.join(test.dir, MQTT_LOG_PRE_STR+log+"_status.json"), mqttc._userdata[PKTS].status)
+    write_pkts_to_log_file(os.path.join(test.dir, MQTT_LOG_PRE_STR+log+"_update.json"), mqttc._userdata[PKTS].update)
+
+def generate_log_file(test, val, target=DUT):
+    if type(val) == int or type(val) == str:
+        log_string = str(val)
+    else:
+        log_string = str(val[0])
+        for i in range(1,len(val)):
+            log_string += ","+ str(val[i])
+    if test.internal_brg:
+        log_string += "_internal_brg"
+    dump_pkts(test, log_string, target)
+
+def mqtt_scan_n_create_log_file(test, duration, phase, target=DUT):
+    test.flush_all_mqtt_packets()
+    mqtt_scan_wait(test, duration=duration, target=target)
+    generate_log_file(test, phase, DUT)
+    generate_log_file(test, phase + "_tester", TESTER)
 
 # Get data/tags functions
-def get_all_data_pkts(mqttc):
+def get_all_data_pkts(mqttc, indicator=None):
     data_pkts = []
+    gw_id = mqttc.update_topic.split("/")[-1]
     for p in mqttc._userdata[PKTS].data:
-        gw_id = p.body_ex[GW_ID] if GW_ID in p.body_ex else ""
         if PACKETS in p.body_ex:
             for pkt in p.body_ex[PACKETS]:
+                if indicator and indicator not in pkt[PAYLOAD]: continue
                 pkt[GW_ID] = gw_id
                 data_pkts += [pkt]
     return data_pkts
 
-def get_all_sim_data_pkts(mqttc):
-    data_pkts = []
+def get_all_aggregated_data_pkts(mqttc, indicator =""):
+    aggregated_data_pkts = []
+    seen_aggregated_payloads = set()
+    gw_id = mqttc.update_topic.split("/")[-1]
     for p in mqttc._userdata[PKTS].data:
-        gw_id = p.body_ex[GW_ID] if GW_ID in p.body_ex else ""
         if PACKETS in p.body_ex:
             for pkt in p.body_ex[PACKETS]:
-                if PIXEL_SIM_INDICATOR in pkt[PAYLOAD]:
-                    pkt[GW_ID] = gw_id
-                    data_pkts += [pkt]
-    return data_pkts
+                if indicator and indicator not in pkt[PAYLOAD]: continue
+                if AGGREGATED_PAYLOAD in pkt:
+                    # Deduplicate based on AGGREGATED_PAYLOAD (since for each packet in the aggregated packet, we have another element with the same AGGREGATED_PAYLOAD)
+                    aggregated_payload = pkt[AGGREGATED_PAYLOAD]
+                    if aggregated_payload not in seen_aggregated_payloads:
+                        seen_aggregated_payloads.add(aggregated_payload)
+                        pkt[GW_ID] = gw_id
+                        aggregated_data_pkts += [pkt]
+    return aggregated_data_pkts
+
+def get_all_status_pkts(mqttc, status_type=None):
+    status_pkts = []
+    for p in mqttc._userdata[PKTS].status:
+        if status_type and status_type not in p.body: continue
+        status_pkts += [p.body]
+    return status_pkts
 
 def get_undecrypted_data_pkts_count(mqttc):
     undecrypted = 0
@@ -287,13 +382,30 @@ def get_undecrypted_data_pkts_count(mqttc):
             undecrypted += p.body_ex['undecrypted']
     return undecrypted
 
-def get_all_sensor_pkts(test, is_embedded=False):
-    all_sensor_pkts = couple_sensor_data_si_coupling(test)
-    all_sensor_pkts = [p for p in all_sensor_pkts if test.active_brg.id_str == p[BRIDGE_ID] and (p[IS_EMBEDDED] == is_embedded)]
+def get_embedded_sensor_pkts(sensor_pkts):
+    embedded_sensor_pkts = []
+    embedded_sensor_uuid_list = [ag.SENSOR_SERVICE_ID_BATTERY_SENSOR, ag.SENSOR_SERVICE_ID_LIS2DW12, ag.SENSOR_SERVICE_ID_POF_DATA]
+    for uuid in embedded_sensor_uuid_list:
+        for p in sensor_pkts:
+            _uuid = (f"{p[UNIFIED_SENSOR_PKT].pkt.sensor_ad_type:02X}"
+                     f"{p[UNIFIED_SENSOR_PKT].pkt.sensor_uuid_msb:02X}"
+                     f"{p[UNIFIED_SENSOR_PKT].pkt.sensor_uuid_lsb:02X}")
+            if UNIFIED_SENSOR_PKT in p and (f"{uuid:06X}" == f"{_uuid}"):
+                embedded_sensor_pkts += [p]
+    return embedded_sensor_pkts
+
+def get_all_sensor_pkts(test, is_unified=False, remove_embedded=False, target=DUT):
+    all_pkts = get_all_data_pkts(test.get_mqttc_by_target(target))
+    all_unified_sensor_pkts = [p for p in all_pkts if UNIFIED_SENSOR_PKT in p and test.active_brg.id_alias == p[ALIAS_BRIDGE_ID]
+                               and is_unified]
+    all_coupled_sensor_pkts = couple_sensor_data_si_coupling(test, all_pkts)
+    all_sensor_pkts = [p for p in all_coupled_sensor_pkts if test.active_brg.id_str == p[BRIDGE_ID]] + all_unified_sensor_pkts
+    if remove_embedded:
+        embedded_sensor_pkts = get_embedded_sensor_pkts(all_unified_sensor_pkts)
+        all_sensor_pkts = [p for p in all_sensor_pkts if p not in embedded_sensor_pkts]
     return all_sensor_pkts
 
-def couple_sensor_data_si_coupling(test):
-    all_pkts = get_all_data_pkts(test.mqttc)
+def couple_sensor_data_si_coupling(test, all_pkts):
     all_sensor_data_pkts = [p for p in all_pkts if SENSOR_PKT in p]
     all_sensor_side_info_pkts = [p for p in all_pkts if SIDE_INFO_SENSOR_PKT in p]
     # Couple data and side info
@@ -342,27 +454,29 @@ def count_pkt_id_duplications(test, all_sensor_data_pkts, all_sensor_side_info_p
             #TODO: logging print(debug)
             # test.reason = f'Warning: {coupled_pkt[PKT_ID_CTR]} sensor data and si with pkt id 0x{_pkt_id:08X}'
 
-def get_all_brg1_ext_sensor_pkts(test=None):
+def get_all_brg1_ext_sensor_pkts(test=None, is_unified=False, target=DUT):
+    original_active_brg = test.active_brg
     test.active_brg = test.brg1
-    pkts = get_all_sensor_pkts(test)
-    test.active_brg = test.brg0
+    pkts = get_all_sensor_pkts(test, is_unified, target=target)
+    test.active_brg = original_active_brg
     return pkts
 
 def get_all_custom_pkts(test=None):
-    return get_all_sensor_pkts(test, is_embedded=True)
+    return get_all_sensor_pkts(test, is_unified=True)
 
-def get_all_mgmt_pkts(mqttc):
-    all_data_pkts = get_all_data_pkts(mqttc)
+def get_all_mgmt_pkts(mqttc, indicator=""):
+    all_data_pkts = get_all_data_pkts(mqttc, indicator)
     return [p for p in all_data_pkts if MGMT_PKT in p]
 
-def get_brg2gw_mgmt_pkts(mqttc, test=None, mgmt_types=[]):
+def get_brg2gw_mgmt_pkts(mqttc, brg, mgmt_types=[]):
     brg2gw_mgmt_pkts = [p for p in get_all_mgmt_pkts(mqttc) if ((p[MGMT_PKT].hdr.group_id == ag.GROUP_ID_BRG2GW) and
                                                                 (not mgmt_types or type(p[MGMT_PKT].pkt) in mgmt_types))]
-    pkts = [p for p in brg2gw_mgmt_pkts if test.active_brg.id_str in p[PAYLOAD]]
+    pkts = [p for p in brg2gw_mgmt_pkts if brg.id_str in p[PAYLOAD]]
     return pkts
 
-def get_unified_data_pkts(test, only_active_brg=True):
-    all_unified_pkts, pkts = [], get_all_sim_data_pkts(test.mqttc) if test.data == DATA_SIMULATION else get_all_data_pkts(test.mqttc)
+def get_unified_data_pkts(test, only_active_brg=True, target=DUT, indicator=PIXEL_SIM_INDICATOR):
+    mqttc = test.get_mqttc_by_target(target)
+    all_unified_pkts, pkts = [], get_all_data_pkts(mqttc, indicator) if test.data == DATA_SIMULATION else get_all_data_pkts(mqttc)
     for p in pkts:
         if UNIFIED_PKT in p:
             all_unified_pkts += [p]
@@ -372,11 +486,12 @@ def get_unified_data_pkts(test, only_active_brg=True):
     print(f"\nCollected {len(pkts)} unified data pkts")
     return pkts
 
-def get_internal_brg_unified_data_pkts(test):
-    all_unified_pkts, pkts = [], get_all_sim_data_pkts(test.mqttc) if test.data == DATA_SIMULATION else get_all_data_pkts(test.mqttc)
+def get_internal_brg_unified_data_pkts(test, target=DUT):
+    mqttc = test.get_mqttc_by_target(target)
+    all_unified_pkts, pkts = [], get_all_data_pkts(mqttc, indicator=PIXEL_SIM_INDICATOR) if test.data == DATA_SIMULATION else get_all_data_pkts(mqttc)
     for p in pkts:
         if UNIFIED_PKT in p:
             all_unified_pkts += [p]
     pkts = [p for p in all_unified_pkts if p[ALIAS_BRIDGE_ID] == test.internal_id_alias()]
     print(f"\nCollected {len(pkts)} unified gw_tag_pkts")
-    return pkts
+    return pkts

{brg_certificate → certificate}/cert_prints.py

@@ -1,9 +1,7 @@
-from brg_certificate.cert_defines import *
+from certificate.cert_defines import *
 import time, datetime
 import sys
 import json
-import brg_certificate.cert_mqtt as cert_mqtt
-import brg_certificate.cert_data_sim as cert_data_sim
 import os
 import re
 
@@ -20,6 +18,7 @@ COLORS = {
 }
 color = lambda c, t : COLORS["BOLD"]+COLORS[c]+t+COLORS["ENDC"]
 pipeline_running = lambda : True if 'BITBUCKET_BUILD_NUMBER' in os.environ else False
+is_quiet_setup_running = lambda : True if 'CI_GW' in os.environ else False
 camelcase_to_title = lambda s: ' '.join(word.capitalize() for word in re.split('(?=[A-Z])', s))
 SEP = '\n' + '#'*100 + '\n'
 SEP2 = '\n' + '#'*100 + '\n' + '#'*100 + '\n'
@@ -33,7 +32,14 @@ WIL_CERT_TEXT = r'''
 '''
 
 hex_str2int = lambda s : int(s, 16)
-print_brg = lambda brg: brg.__dict__ if brg else None
+
+def write_to_log_file(file, txt, mode):
+    file_path = os.path.join(ARTIFACTS_DIR, file)
+    if not os.path.exists(os.path.dirname(file_path)):
+        os.makedirs(os.path.dirname(file_path))
+    f = open(file_path, mode)
+    f.write(txt)
+    f.close()
 
 def print_pkt(p):
     print(datetime.datetime.now().strftime("%d/%m/%Y, %H:%M:%S"))
@@ -43,12 +49,16 @@ def print_warn(txt):
     if txt:
         utPrint(f"WARNING: {txt}","WARNING")
 
-def mqtt_scan_start(test, duration):
-    utPrint("Scanning mqtt packets on {} for {} seconds...".format(test.gw, duration), "WARNING")
+def mqtt_scan_start(test, duration, target=DUT):
+    gw = test.dut if target == DUT else test.tester
+    utPrint("Scanning mqtt packets on {} for {} seconds...".format(gw.id_str, duration), "WARNING")
     sys.stdout.flush()
 
-def mqtt_scan_wait(test, duration):
-    utPrint("Scanning mqtt packets on {} for {} seconds...".format(test.gw, duration), "WARNING")
+
+def mqtt_scan_wait(test, duration, target=DUT):
+    mqttc = test.get_mqttc_by_target(target)
+    gw = test.dut if target == DUT else test.tester
+    utPrint("Scanning mqtt packets on {} for {} seconds...".format(gw.id_str, duration), "WARNING")
     sys.stdout.flush()
     chars = ["|", "/", "-", "\\"]
     start_time = datetime.datetime.now()
@@ -60,22 +70,26 @@ def mqtt_scan_wait(test, duration):
         if pipeline_running():
             sys.stdout.write(".")
         else:
-            sys.stdout.write("\r"+chars[i%4]*20+" "+str(cur_duration)+" "+chars[i%4]*20+" {} pkts captured".format(len(test.mqttc._userdata["pkts"].data)))
+            sys.stdout.write("\r"+chars[i%4]*20+" "+str(cur_duration)+" "+chars[i%4]*20+" {} pkts captured".format(len(mqttc._userdata[PKTS].data)))
         sys.stdout.flush()
         time.sleep(0.25)
         i += 1
     print("\n")
 
-def mqtt_scan_n_create_log_file(test, duration, phase):
-    test.mqttc.flush_pkts()
-    mqtt_scan_wait(test, duration=duration)
-    generate_log_file(test, phase)
 
 def print_update_wait(secs=1):
     sys.stdout.write(".")
     sys.stdout.flush()
     time.sleep(secs)
 
+def wait_time_n_print(secs, txt=""):
+    if txt:
+        utPrint(txt, "CYAN")
+    utPrint(f"Waiting for {secs} seconds", "CYAN")
+    while secs:
+        print_update_wait()
+        secs -= 1
+
 def field_functionality_pass_fail_print(test, field, value=""):
     print_string = f"{field}={value}"
     if value == "":
@@ -105,11 +119,11 @@ def test_run_print(test):
     test_json_print(test)
     utPrint("Test Configuration:", "HEADER")
     params = [{'name':p.name, 'value':p.value} for p in test.params]
-    utPrint(f"""    - internal_brg={test.internal_brg}\n    - brg0={print_brg(test.brg0)}
-    - brg1={print_brg(test.brg1)}\n    - active_brg={print_brg(test.active_brg)}
+    utPrint(f"""    - internal_brg={test.internal_brg}\n    - tester={test.tester}
+    - dut={test.dut}\n    - brg1={test.brg1}\n    - active_brg={test.active_brg}
     - params={params}\n""")
-    cert_mqtt.write_to_mqtt_log_file(log_txt)
-    cert_data_sim.write_to_data_sim_log_file(log_txt)
+    write_to_log_file(DATA_SIM_LOG_FILE, log_txt, "a")
+    write_to_log_file(CERT_MQTT_LOG_FILE, log_txt, "a")
 
 def test_json_print(test):
     for key, value in test.test_json.items():
@@ -131,14 +145,14 @@ def test_epilog_print(test):
 def functionality_run_print(func):
     txt = "{0}==>> Running {1}\n".format(SEP, func)
     utPrint(txt, "CYAN")
-    cert_mqtt.write_to_mqtt_log_file(txt)
-    cert_data_sim.write_to_data_sim_log_file(txt)
+    write_to_log_file(DATA_SIM_LOG_FILE, txt, "a")
+    write_to_log_file(CERT_MQTT_LOG_FILE, txt, "a")
 
 def phase_run_print(func):
     txt = f"{SEP2}==>> Phase {func}{SEP2}\n"
     utPrint(txt, "CYAN")
-    cert_mqtt.write_to_mqtt_log_file(txt)
-    cert_data_sim.write_to_data_sim_log_file(txt)
+    write_to_log_file(DATA_SIM_LOG_FILE, txt, "a")
+    write_to_log_file(CERT_MQTT_LOG_FILE, txt, "a")
 
 
 def generate_print_string(fields_and_values):
@@ -147,18 +161,6 @@ def generate_print_string(fields_and_values):
         list_to_print.append(str(f) + "=" + str(fields_and_values[f]))
     return " & ".join(list_to_print)
 
-def generate_log_file(test, val):
-    if type(val) == int or type(val) == str:
-        log_string = str(val)
-    else:
-        log_string = str(val[0])
-        for i in range(1,len(val)):
-            log_string += ","+ str(val[i])
-    if test.internal_brg:
-        log_string += "_internal_brg"
-
-    cert_mqtt.dump_pkts(test, log=log_string)
-
 ENERGY_GRAPH_HTML = """
 <h1 style="color:blue;text-align:center;">{}</h1>
 <div style="width:80%;margin:auto;"><canvas id="myChart"></canvas></div>

{brg_certificate → certificate}/cert_protobuf.py

@@ -1,7 +1,7 @@
 
-from brg_certificate.cert_defines import *
+from certificate.cert_defines import *
 
-import brg_certificate.wltPb_pb2 as wpb
+import common.wltPb_pb2 as wpb
 
 def action_pb(msg: dict):
     pb_msg = wpb.DownlinkMessage()
@@ -15,6 +15,13 @@ def tx_pkt_pb(msg: dict):
     pb_msg.txPacket.maxRetries = int(msg[TX_MAX_RETRIES])
     return pb_msg.SerializeToString()
 
+def gw_ota_pb(msg: dict):
+    pb_msg = wpb.DownlinkMessage()
+    pb_msg.gatewayUpgrade.imageDirUrl = msg[IMG_DIR_URL]
+    pb_msg.gatewayUpgrade.interfaceSwVersion = msg[WIFI_VERSION]
+    pb_msg.gatewayUpgrade.bleSwVersion = msg[BLE_VERSION]
+    return pb_msg.SerializeToString()
+
 def brg_ota_pb(msg: dict):
     pb_msg = wpb.DownlinkMessage()
     pb_msg.bridgeUpgrade.bridgeId = msg[BRIDGE_ID]
@@ -36,8 +43,8 @@ def gw_cfg_pb(msg: dict):
         pb_msg.gatewayConfig.bleSwVersion = msg[BLE_VERSION]
 
     for key, val in msg[ADDITIONAL].items():
-        # Skip GW_MODE since it doesn't exist today and harm the parsing in PB, and skip lat & lng to create duplicate values
-        if key == GW_MODE or key == LAT or key == LNG:
+        # Skip lat & lng to create duplicate values
+        if key == LAT or key == LNG:
             continue
         pb_value = wpb.GatewayConfigValue()
         if type(val) is int:
@@ -79,10 +86,12 @@ def custom_message_pb(msg: dict):
 
 def downlink_to_pb(msg: dict):
     if ACTION in msg.keys():
-        if msg[ACTION] == 0:
+        if msg[ACTION] == ACTION_ADVERTISING:
             return tx_pkt_pb(msg)
-        elif msg[ACTION] == 1:
+        elif msg[ACTION] == ACTION_BRG_OTA:
             return brg_ota_pb(msg)
+        elif msg[ACTION] == ACTION_GW_OTA:
+            return gw_ota_pb(msg)
         else:
             return action_pb(msg)
     elif GW_CONF in msg.keys():