From 4c0662180f5f18c3002479a406e2b0fa6df1da62 Mon Sep 17 00:00:00 2001 From: Matthew Stidham Date: Mon, 18 Jan 2021 13:12:27 -0800 Subject: [PATCH] inheritance fixes --- py-json/realm.py | 745 ++++++++++++++------------ py-scripts/test_ipv4_variable_time.py | 1 + 2 files changed, 406 insertions(+), 340 deletions(-) diff --git a/py-json/realm.py b/py-json/realm.py index 20ed4195..26af6817 100755 --- a/py-json/realm.py +++ b/py-json/realm.py @@ -84,7 +84,7 @@ class Realm(LFCliBase): self.freq_to_chan = {} freq = 0 chan = 1 - for freq in range( 2412, 2472, 5): + for freq in range(2412, 2472, 5): self.freq_to_chan[freq] = chan self.chan_to_freq[chan] = freq chan += 1 @@ -245,14 +245,14 @@ class Realm(LFCliBase): data = { "test_mgr": "ALL", "cx_name": cx_name - } + } self.json_post(req_url, data) def rm_endp(self, ename, debug_=False, suppress_related_commands_=True): req_url = "cli-json/rm_endp" data = { "endp_name": ename - } + } self.json_post(req_url, data, debug_=debug_, suppress_related_commands_=suppress_related_commands_) def set_endp_tos(self, ename, _tos, debug_=False, suppress_related_commands_=True): @@ -270,7 +270,7 @@ class Realm(LFCliBase): data = { "name": ename, "tos": tos - } + } self.json_post(req_url, data, debug_=debug_, suppress_related_commands_=suppress_related_commands_) def stop_cx(self, cx_name): @@ -278,7 +278,7 @@ class Realm(LFCliBase): "test_mgr": "ALL", "cx_name": cx_name, "cx_state": "STOPPED" - }, debug_=self.debug) + }, debug_=self.debug) def cleanup_cxe_prefix(self, prefix): cx_list = self.cx_list() @@ -297,7 +297,7 @@ class Realm(LFCliBase): self.rm_endp(endp_name) else: if self.debug: - print("cleanup_cxe_prefix no endpoints: endp_list{}".format(endp_list) ) + print("cleanup_cxe_prefix no endpoints: endp_list{}".format(endp_list)) def channel_freq(self, channel_=0): return self.chan_to_freq[channel_] @@ -307,7 +307,7 @@ class Realm(LFCliBase): # checks for OK or BUSY when querying cli-json/cv+is_built def wait_while_building(self, debug_=False): - response_json=[] + response_json = [] data = { "cmd": "cv is_built" } @@ -317,8 +317,9 @@ class Realm(LFCliBase): dbg_param = "?__debug=1" while (last_response != "YES"): - response = self.json_post("/gui-json/cmd%s" % dbg_param, data, debug_=debug_, response_json_list_=response_json) - #LFUtils.debug_printer.pprint(response_json) + response = self.json_post("/gui-json/cmd%s" % dbg_param, data, debug_=debug_, + response_json_list_=response_json) + # LFUtils.debug_printer.pprint(response_json) last_response = response_json[0]["LAST"]["response"] if (last_response != "YES"): last_response = None @@ -331,12 +332,13 @@ class Realm(LFCliBase): # loads a database def load(self, name): if (name is None) or (name == ""): - raise ValueError("Realm::load: wants a test scenario database name, please find one in the Status tab of the GUI") + raise ValueError( + "Realm::load: wants a test scenario database name, please find one in the Status tab of the GUI") data = { "name": name, - "action":"overwrite", - "clean_dut":"yes", + "action": "overwrite", + "clean_dut": "yes", "clean_chambers": "yes" } self.json_post("/cli-json/load", _data=data, debug_=self.debug) @@ -367,7 +369,7 @@ class Realm(LFCliBase): for req in these_endp: if not req in found_endps: if debug: - print("Waiting on endpoint: %s"%(req)) + print("Waiting on endpoint: %s" % (req)) wait_more = True count += 1 if (count > 100): @@ -396,7 +398,7 @@ class Realm(LFCliBase): for req in these_cx: if not req in found_cxs: if debug: - print("Waiting on CX: %s"%(req)) + print("Waiting on CX: %s" % (req)) wait_more = True count += 1 if (count > 100): @@ -536,8 +538,8 @@ class Realm(LFCliBase): return LFUtils.name_to_eid(eid) def wait_for_ip(self, station_list=None, ipv4=True, ipv6=False, timeout_sec=60, debug=False): - print("Waiting for ips, timeout: %i..."%(timeout_sec)) - #print(station_list) + print("Waiting for ips, timeout: %i..." % (timeout_sec)) + # print(station_list) waiting_states = ["0.0.0.0", "NA", ""] if (station_list is None) or (len(station_list) < 1): @@ -549,12 +551,12 @@ class Realm(LFCliBase): for sta_eid in station_list: if debug: - print("checking sta-eid: %s"%(sta_eid)) + print("checking sta-eid: %s" % (sta_eid)) eid = self.name_to_eid(sta_eid) response = super().json_get("/port/%s/%s/%s?fields=alias,ip,port+type,ipv6+address" % (eid[0], eid[1], eid[2])) - #pprint(response) + # pprint(response) if (response is None) or ("interface" not in response): print("station_list: incomplete response:") @@ -567,22 +569,22 @@ class Realm(LFCliBase): if (v['ip'] in waiting_states): wait_more = True if debug: - print("Waiting for port %s to get IPv4 Address."%(sta_eid)) + print("Waiting for port %s to get IPv4 Address." % (sta_eid)) else: if debug: - print("Found IP: %s on port: %s"%(v['ip'], sta_eid)) + print("Found IP: %s on port: %s" % (v['ip'], sta_eid)) if ipv6: v = response['interface'] - #print(v) + # print(v) if v['ipv6 address'] != 'DELETED' and not v['ipv6 address'].startswith('fe80') \ - and v['ipv6 address'] != 'AUTO': + and v['ipv6 address'] != 'AUTO': if debug: print("Found IPv6: %s on port: %s" % (v['ipv6 address'], sta_eid)) else: wait_more = True if debug: - print("Waiting for port %s to get IPv6 Address."%(sta_eid)) + print("Waiting for port %s to get IPv6 Address." % (sta_eid)) if wait_more: time.sleep(1) @@ -590,7 +592,7 @@ class Realm(LFCliBase): return not wait_more - def get_curr_num_ips(self,num_sta_with_ips=0,station_list=None, ipv4=True, ipv6=False, debug=False): + def get_curr_num_ips(self, num_sta_with_ips=0, station_list=None, ipv4=True, ipv6=False, debug=False): if debug: print("checking number of stations with ips...") waiting_states = ["0.0.0.0", "NA", ""] @@ -598,42 +600,42 @@ class Realm(LFCliBase): raise ValueError("check for num curr ips expects non-empty list of ports") for sta_eid in station_list: if debug: - print("checking sta-eid: %s"%(sta_eid)) + print("checking sta-eid: %s" % (sta_eid)) eid = self.name_to_eid(sta_eid) response = super().json_get("/port/%s/%s/%s?fields=alias,ip,port+type,ipv6+address" % - (eid[0], eid[1], eid[2])) + (eid[0], eid[1], eid[2])) if debug: pprint(response) if (response is None) or ("interface" not in response): print("station_list: incomplete response:") pprint(response) - #wait_more = True + # wait_more = True break if ipv4: v = response['interface'] if (v['ip'] in waiting_states): if debug: - print("Waiting for port %s to get IPv4 Address."%(sta_eid)) + print("Waiting for port %s to get IPv4 Address." % (sta_eid)) else: if debug: - print("Found IP: %s on port: %s"%(v['ip'], sta_eid)) + print("Found IP: %s on port: %s" % (v['ip'], sta_eid)) print("Incrementing stations with IP addresses found") - num_sta_with_ips+=1 + num_sta_with_ips += 1 else: - num_sta_with_ips+=1 + num_sta_with_ips += 1 if ipv6: v = response['interface'] if (v['ip'] in waiting_states): if debug: - print("Waiting for port %s to get IPv6 Address."%(sta_eid)) + print("Waiting for port %s to get IPv6 Address." % (sta_eid)) else: if debug: - print("Found IP: %s on port: %s"%(v['ip'], sta_eid)) + print("Found IP: %s on port: %s" % (v['ip'], sta_eid)) print("Incrementing stations with IP addresses found") - num_sta_with_ips+=1 + num_sta_with_ips += 1 else: - num_sta_with_ips+=1 + num_sta_with_ips += 1 return num_sta_with_ips @@ -701,7 +703,7 @@ class Realm(LFCliBase): endp_list = self.json_get("/endp/list") if "items" in endp_list or "empty" in endp_list: return - if endp_list is not None or endp_list : + if endp_list is not None or endp_list: print("Removing all endps") endp_list = list(endp_list['endpoint']) for endp_name in range(len(endp_list)): @@ -712,7 +714,7 @@ class Realm(LFCliBase): } self.json_post(req_url, data) - def remove_all_cxs(self,remove_all_endpoints=False): + def remove_all_cxs(self, remove_all_endpoints=False): # remove cross connects # remove endpoints # nc show endpoints @@ -738,13 +740,13 @@ class Realm(LFCliBase): self.remove_all_endps() req_url = "cli-json/nc_show_endpoints" data = { - "endpoint":"all" + "endpoint": "all" } self.json_post(req_url, data) req_url = "cli-json/show_cx" - data ={ - "test_mgr":"all", - "cross_connect":"all" + data = { + "test_mgr": "all", + "cross_connect": "all" } def parse_link(self, link): @@ -757,7 +759,7 @@ class Realm(LFCliBase): def new_multicast_profile(self): multi_prof = MULTICASTProfile(self.lfclient_host, self.lfclient_port, - local_realm=self, debug_=self.debug, report_timer_=3000) + local_realm=self, debug_=self.debug, report_timer_=3000) return multi_prof def new_wifi_monitor_profile(self, resource_=1, debug_=False, up_=False): @@ -793,11 +795,13 @@ class Realm(LFCliBase): return cx_prof def new_vap_profile(self): - vap_prof = VAPProfile(lfclient_host=self.lfclient_host, lfclient_port=self.lfclient_port, local_realm=self, debug_=self.debug) + vap_prof = VAPProfile(lfclient_host=self.lfclient_host, lfclient_port=self.lfclient_port, local_realm=self, + debug_=self.debug) return vap_prof def new_vr_profile(self): - vap_prof = VRProfile(lfclient_host=self.lfclient_host, lfclient_port=self.lfclient_port, local_realm=self, debug_=self.debug) + vap_prof = VRProfile(lfclient_host=self.lfclient_host, lfclient_port=self.lfclient_port, local_realm=self, + debug_=self.debug) return vap_prof def new_http_profile(self): @@ -825,43 +829,50 @@ class Realm(LFCliBase): return profile class BaseProfile(LFCliBase): - def __init__(self,local_realm): - self.parent_realm=local_realm + def __init__(self, local_realm): + self.parent_realm = local_realm self.halt_on_error = False self.exit_on_error = False def json_get(self, target): - return self.json_get(target) + return self.parent_realm.json_get(target) - def json_post(self, url,data,debug_,suppress_related_commands_=None): - return self.json_post(url,data,debug_=False,suppress_related_commands_=suppress_related_commands_) + def json_post(self, req_url, data, debug_=False, suppress_related_commands_=None): + return self.parent_realm.json_post(req_url, + data, + suppress_related_commands_=suppress_related_commands_, + debug_=debug_) - def parse_time(self,target): + def parse_time(self, target): return self.parent_realm.parse_time(target) - def stop_cx(self, target): - return self.parent_realm.stop_cx(target) + def stopping_cx(self, name): + return self.parent_realm.stop_cx(name) - def cleanup_cxe_prefix(self,prefix): + def cleanup_cxe_prefix(self, prefix): return self.parent_realm.cleanup_cxe_prefix(prefix) - def rm_cx(self,target): + def rm_cx(self, target): return self.parent_realm.rm_cx(target) - def created_cx(self,target): + def rm_endp(self, ename): + self.parent_realm.rm_endp(ename) + + def created_cx(self, target): return self.parent_realm.created_cx(target) - def name_to_eid(self,target): + def name_to_eid(self, target): return self.parent_realm.name_to_eid(target) - def set_endp_tos(self,target): + def set_endp_tos(self, target): return self.parent_realm.set_endp_tos(target) - def wait_until_endps_appear(self,target,debug=False): - return self.parent_realm.wait_until_endps_appear(target,debug=False) + def wait_until_endps_appear(self, target, debug=False): + return self.parent_realm.wait_until_endps_appear(target, debug=False) + + def wait_until_cxs_appear(self, target, debug=False): + return self.parent_realm.wait_until_cxs_appear(target, debug=False) - def wait_until_cxs_appear(self,target,debug=False): - return self.parent_realm.wait_until_cxs_appear(target,debug=False) class MULTICASTProfile(LFCliBase): def __init__(self, lfclient_host, lfclient_port, local_realm, @@ -875,7 +886,7 @@ class MULTICASTProfile(LFCliBase): :param number_template_: how many zeros wide we padd, possibly a starting integer with left padding :param debug_: """ - super().__init__(lfclient_host, lfclient_port, debug_, _halt_on_error=True) + super().__init__(local_realm) self.lfclient_url = "http://%s:%s" % (lfclient_host, lfclient_port) self.debug = debug_ self.local_realm = local_realm @@ -890,87 +901,88 @@ class MULTICASTProfile(LFCliBase): def refresh_mc(self, debug_=False): for endp_name in self.get_mc_names(): self.json_post("/cli-json/show_endpoints", { - "endpoint": endp_name + "endpoint": endp_name }, debug_=debug_) - def start_mc(self, suppress_related_commands=None, debug_ = False): + def start_mc(self, suppress_related_commands=None, debug_=False): if self.debug: - debug_=True + debug_ = True for endp_name in self.get_mc_names(): - print("Starting mcast endpoint: %s"%(endp_name)) + print("Starting mcast endpoint: %s" % (endp_name)) json_data = { - "endp_name":endp_name + "endp_name": endp_name } url = "cli-json/start_endp" - self.local_realm.json_post(url, json_data, debug_=debug_, suppress_related_commands_=suppress_related_commands) + self.local_realm.json_post(url, json_data, debug_=debug_, + suppress_related_commands_=suppress_related_commands) pass - def stop_mc(self, suppress_related_commands=None, debug_ = False): + def stop_mc(self, suppress_related_commands=None, debug_=False): if self.debug: - debug_=True - + debug_ = True for endp_name in self.get_mc_names(): json_data = { - "endp_name":endp_name + "endp_name": endp_name } url = "cli-json/stop_endp" - self.local_realm.json_post(url, json_data, debug_=debug_, suppress_related_commands_=suppress_related_commands) + self.local_realm.json_post(url, json_data, debug_=debug_, + suppress_related_commands_=suppress_related_commands) pass - def cleanup(self, suppress_related_commands=None, debug_ = False): + def cleanup(self, suppress_related_commands=None, debug_=False): if self.debug: - debug_=True + debug_ = True for endp_name in self.get_mc_names(): self.local_realm.rm_endp(endp_name, debug_=debug_, suppress_related_commands_=suppress_related_commands) def create_mc_tx(self, endp_type, side_tx, suppress_related_commands=None, debug_=False): if self.debug: - debug_=True + debug_ = True side_tx_info = self.local_realm.name_to_eid(side_tx) side_tx_shelf = side_tx_info[0] side_tx_resource = side_tx_info[1] side_tx_port = side_tx_info[2] - side_tx_name = "%smtx-%s-%i"%(self.name_prefix, side_tx_port, len(self.created_mc)) + side_tx_name = "%smtx-%s-%i" % (self.name_prefix, side_tx_port, len(self.created_mc)) json_data = [] - #add_endp mcast-xmit-sta 1 1 side_tx mc_udp -1 NO 4000000 0 NO 1472 0 INCREASING NO 32 0 0 + # add_endp mcast-xmit-sta 1 1 side_tx mc_udp -1 NO 4000000 0 NO 1472 0 INCREASING NO 32 0 0 json_data = { - 'alias':side_tx_name, - 'shelf':side_tx_shelf, - 'resource':side_tx_resource, - 'port':side_tx_port, - 'type':endp_type, - 'ip_port':-1, - 'is_rate_bursty': - 'NO','min_rate':256000, - 'max_rate':0, - 'is_pkt_sz_random':'NO', - 'min_pkt':1472, - 'max_pkt':0, - 'payload_pattern':'INCREASING', - 'use_checksum':'NO', - 'ttl':32, - 'send_bad_crc_per_million':0, - 'multi_conn':0 - } + 'alias': side_tx_name, + 'shelf': side_tx_shelf, + 'resource': side_tx_resource, + 'port': side_tx_port, + 'type': endp_type, + 'ip_port': -1, + 'is_rate_bursty': + 'NO', 'min_rate': 256000, + 'max_rate': 0, + 'is_pkt_sz_random': 'NO', + 'min_pkt': 1472, + 'max_pkt': 0, + 'payload_pattern': 'INCREASING', + 'use_checksum': 'NO', + 'ttl': 32, + 'send_bad_crc_per_million': 0, + 'multi_conn': 0 + } url = "/cli-json/add_endp" self.local_realm.json_post(url, json_data, debug_=debug_, suppress_related_commands_=suppress_related_commands) - #set_mc_endp mcast-xmit-sta 32 224.9.9.9 9999 No # critical + # set_mc_endp mcast-xmit-sta 32 224.9.9.9 9999 No # critical json_data = { - 'name':side_tx_name, - 'ttl':32, - 'mcast_group':'224.9.9.9', - 'mcast_dest_port':9999, - 'rcv_mcast':'No' - } + 'name': side_tx_name, + 'ttl': 32, + 'mcast_group': '224.9.9.9', + 'mcast_dest_port': 9999, + 'rcv_mcast': 'No' + } url = "cli-json/set_mc_endp" self.local_realm.json_post(url, json_data, debug_=debug_, suppress_related_commands_=suppress_related_commands) @@ -980,10 +992,9 @@ class MULTICASTProfile(LFCliBase): these_endp = [side_tx_name] self.local_realm.wait_until_endps_appear(these_endp, debug=debug_) - - def create_mc_rx(self, endp_type, side_rx, suppress_related_commands=None, debug_ = False): + def create_mc_rx(self, endp_type, side_rx, suppress_related_commands=None, debug_=False): if self.debug: - debug_=True + debug_ = True these_endp = [] @@ -992,40 +1003,42 @@ class MULTICASTProfile(LFCliBase): side_rx_shelf = side_rx_info[0] side_rx_resource = side_rx_info[1] side_rx_port = side_rx_info[2] - side_rx_name = "%smrx-%s-%i"%(self.name_prefix, side_rx_port, len(self.created_mc)) + side_rx_name = "%smrx-%s-%i" % (self.name_prefix, side_rx_port, len(self.created_mc)) # add_endp mcast-rcv-sta-001 1 1 sta0002 mc_udp 9999 NO 0 0 NO 1472 0 INCREASING NO 32 0 0 json_data = { - 'alias':side_rx_name, - 'shelf':side_rx_shelf, - 'resource':side_rx_resource, - 'port':side_rx_port, - 'type':endp_type, - 'ip_port':9999, - 'is_rate_bursty':'NO', - 'min_rate':0, - 'max_rate':0, - 'is_pkt_sz_random':'NO', - 'min_pkt':1472, - 'max_pkt':0, - 'payload_pattern':'INCREASING', - 'use_checksum':'NO', - 'ttl':32, - 'send_bad_crc_per_million':0, - 'multi_conn':0 - } + 'alias': side_rx_name, + 'shelf': side_rx_shelf, + 'resource': side_rx_resource, + 'port': side_rx_port, + 'type': endp_type, + 'ip_port': 9999, + 'is_rate_bursty': 'NO', + 'min_rate': 0, + 'max_rate': 0, + 'is_pkt_sz_random': 'NO', + 'min_pkt': 1472, + 'max_pkt': 0, + 'payload_pattern': 'INCREASING', + 'use_checksum': 'NO', + 'ttl': 32, + 'send_bad_crc_per_million': 0, + 'multi_conn': 0 + } url = "cli-json/add_endp" - self.local_realm.json_post(url, json_data, debug_=debug_, suppress_related_commands_=suppress_related_commands) + self.local_realm.json_post(url, json_data, debug_=debug_, + suppress_related_commands_=suppress_related_commands) json_data = { - 'name':side_rx_name, - 'ttl':32, - 'mcast_group':'224.9.9.9', - 'mcast_dest_port':9999, - 'rcv_mcast':'Yes' - } + 'name': side_rx_name, + 'ttl': 32, + 'mcast_group': '224.9.9.9', + 'mcast_dest_port': 9999, + 'rcv_mcast': 'Yes' + } url = "cli-json/set_mc_endp" - self.local_realm.json_post(url, json_data, debug_=debug_, suppress_related_commands_=suppress_related_commands) + self.local_realm.json_post(url, json_data, debug_=debug_, + suppress_related_commands_=suppress_related_commands) self.created_mc[side_rx_name] = side_rx_name these_endp.append(side_rx_name) @@ -1037,17 +1050,26 @@ class MULTICASTProfile(LFCliBase): -class L3CXProfile(LFCliBase): - def __init__(self, lfclient_host, lfclient_port, local_realm, - side_a_min_bps=None, side_b_min_bps=None, - side_a_max_bps=0, side_b_max_bps=0, - side_a_min_pdu=-1, side_b_min_pdu=-1, - side_a_max_pdu=0, side_b_max_pdu=0, - report_timer_=3000, name_prefix_="Unset", number_template_="00000", debug_=False): +class L3CXProfile(BaseProfile): + def __init__(self, + lfclient_host, + lfclient_port, + local_realm, + side_a_min_bps=None, + side_b_min_bps=None, + side_a_max_bps=0, + side_b_max_bps=0, + side_a_min_pdu=-1, + side_b_min_pdu=-1, + side_a_max_pdu=0, + side_b_max_pdu=0, + report_timer_=3000, + name_prefix_="Unset", + number_template_="00000", + debug_=False): """ :param lfclient_host: :param lfclient_port: - :param local_realm: :param side_a_min_bps: :param side_b_min_bps: :param side_a_max_bps: @@ -1060,10 +1082,9 @@ class L3CXProfile(LFCliBase): :param number_template_: how many zeros wide we padd, possibly a starting integer with left padding :param debug_: """ - super().__init__(lfclient_host, lfclient_port, debug_, _halt_on_error=True) + super().__init__(local_realm) self.lfclient_url = "http://%s:%s" % (lfclient_host, lfclient_port) self.debug = debug_ - self.local_realm = local_realm self.side_a_min_pdu = side_a_min_pdu self.side_b_min_pdu = side_b_min_pdu self.side_a_max_pdu = side_a_max_pdu @@ -1088,7 +1109,7 @@ class L3CXProfile(LFCliBase): return self.data def __get_rx_values(self): - cx_list = self.json_get("endp?fields=name,rx+bytes", debug_=self.debug) + cx_list = self.json_get("endp?fields=name,rx+bytes") if self.debug: print(self.created_cx.values()) print("==============\n", cx_list, "\n==============") @@ -1097,8 +1118,8 @@ class L3CXProfile(LFCliBase): if cx_name != 'uri' and cx_name != 'handler': for item, value in cx_name.items(): for value_name, value_rx in value.items(): - if value_name == 'rx bytes' and item in self.created_cx.values(): - cx_rx_map[item] = value_rx + if value_name == 'rx bytes' and item in self.created_cx.values(): + cx_rx_map[item] = value_rx return cx_rx_map def __compare_vals(self, old_list, new_list): @@ -1128,11 +1149,11 @@ class L3CXProfile(LFCliBase): script_name=None, arguments=None): try: - duration_sec=local_realm.parse_time(duration_sec).seconds + duration_sec=self.parse_time(duration_sec).seconds except: if (duration_sec is None) or (duration_sec <= 1): raise ValueError("L3CXProfile::monitor wants duration_sec > 1 second") - if (duration_sec <= monitor_interval ): + if (duration_sec <= monitor_interval): raise ValueError("L3CXProfile::monitor wants duration_sec > monitor_interval") if report_file == None: raise ValueError("Monitor requires an output file to be defined") @@ -1149,18 +1170,20 @@ class L3CXProfile(LFCliBase): else: output_format = report_file.split('.')[-1] - #Step 1, column names - fields=",".join(col_names) - #Step 2, monitor columns + # Step 1, column names + fields = ",".join(col_names) + print(fields) + # Step 2, monitor columns start_time = datetime.datetime.now() end_time = start_time + datetime.timedelta(seconds=duration_sec) + print(end_time) value_map = dict() passes = 0 expected_passes = 0 old_cx_rx_values = self.__get_rx_values() - timestamps=[] - #for x in range(0,int(round(iterations,0))): + timestamps = [] + # for x in range(0,int(round(iterations,0))): while datetime.datetime.now() < end_time: response = self.json_get("/endp/%s?fields=%s" % (created_cx, fields)) if "endpoint" not in response: @@ -1168,9 +1191,9 @@ class L3CXProfile(LFCliBase): raise ValueError("no endpoint?") if show: print(response) - t=datetime.datetime.now() + t = datetime.datetime.now() timestamps.append(t) - value_map[t]=response + value_map[t] = response new_cx_rx_values = self.__get_rx_values() if self.debug: print(old_cx_rx_values, new_cx_rx_values) @@ -1185,82 +1208,83 @@ class L3CXProfile(LFCliBase): self.exit_fail() old_cx_rx_values = new_cx_rx_values time.sleep(monitor_interval) - #print(value_map) + print(value_map) - if passes == expected_passes: - self._pass("PASS: All tests passed") - #step 3 organize data - endpoints=list() + # if passes == expected_passes: + # self._pass("PASS: All tests passed") + # step 3 organize data + endpoints = list() for endpoint in value_map.values(): endpoints.append(endpoint['endpoint']) - endpoints2=[] + endpoints2 = [] for y in range(0, len(endpoints)): for x in range(0, len(endpoints[0])): endpoints2.append(list(list(endpoints[y][x].values())[0].values())) import itertools - timestamps2=list(itertools.chain.from_iterable(itertools.repeat(x, len(created_cx.split(','))) for x in timestamps)) + timestamps2 = list( + itertools.chain.from_iterable(itertools.repeat(x, len(created_cx.split(','))) for x in timestamps)) for point in range(0, len(endpoints2)): endpoints2[point].insert(0, timestamps2[point]) - #step 4 save and close - header_row=col_names - header_row.insert(0,'Timestamp') - if output_format.lower() in ['excel','xlsx'] or report_file.split('.')[-1] == 'xlsx': + # step 4 save and close + header_row = col_names + header_row.insert(0, 'Timestamp') + # print(header_row) + if output_format.lower() in ['excel', 'xlsx'] or report_file.split('.')[-1] == 'xlsx': report_fh = open(report_file, "w+") workbook = xlsxwriter.Workbook(report_file) worksheet = workbook.add_worksheet() - for col_num,data in enumerate(header_row): - worksheet.write(0, col_num,data) + for col_num, data in enumerate(header_row): + worksheet.write(0, col_num, data) row_num = 1 for x in endpoints2: for col_num, data in enumerate(x): - worksheet.write(row_num, col_num, str(data)) - row_num+=1 + worksheet.write(row_num, col_num, str(data)) + row_num += 1 workbook.close() else: - df=pd.DataFrame(endpoints2) - df.columns=header_row + df = pd.DataFrame(endpoints2) + df.columns = header_row import requests import ast systeminfo=ast.literal_eval(requests.get('http://localhost:8080').text) df['LFGUI Release'] = systeminfo['VersionInfo']['BuildVersion'] df['Script Name'] = script_name df['Arguments'] = arguments - for x in ['LFGUI Release','Script Name','Arguments']: + for x in ['LFGUI Release', 'Script Name', 'Arguments']: df[x][1:] = '' if output_format == 'pdf': import matplotlib.pyplot as plt from matplotlib.backends.backend_pdf import PdfPages - fig, ax = plt.subplots(figsize=(12,4)) + fig, ax = plt.subplots(figsize=(12, 4)) ax.axis('tight') ax.axis('off') the_table = ax.table(cellText=df.values, colLabels=df.columns, loc='center') pp = PdfPages(report_file) - pp.savefig(fig, bbox_inches = 'tight') + pp.savefig(fig, bbox_inches='tight') pp.close() if output_format == 'hdf': - df.to_hdf(report_file,'table', append=True) + df.to_hdf(report_file, 'table', append=True) if output_format == 'parquet': - df.to_parquet(report_file,engine='pyarrow') + df.to_parquet(report_file, engine='pyarrow') if output_format == 'png': - fig=df.plot().get_figure() + fig = df.plot().get_figure() fig.savefig(report_file) if output_format == 'html': print('Shivams function') if output_format == 'df': return df - supported_formats = ['csv','json','stata','pickle'] + supported_formats = ['csv', 'json', 'stata', 'pickle'] for x in supported_formats: if output_format.lower() == x or report_file.split('.')[-1] == x: - exec('df.to_'+x+'("'+report_file+'")') + exec('df.to_' + x + '("' + report_file + '")') else: pass - def refresh_cx(self): for cx_name in self.created_cx.keys(): self.json_post("/cli-json/show_cxe", { - "test_mgr": "ALL", - "cross_connect": cx_name + "test_mgr": "ALL", + "cross_connect": cx_name }, debug_=self.debug) print(".", end='') @@ -1268,7 +1292,7 @@ class L3CXProfile(LFCliBase): print("Starting CXs...") for cx_name in self.created_cx.keys(): if self.debug: - print("cx-name: %s"%(cx_name)) + print("cx-name: %s" % (cx_name)) self.json_post("/cli-json/set_cx_state", { "test_mgr": "default_tm", "cx_name": cx_name, @@ -1280,30 +1304,31 @@ class L3CXProfile(LFCliBase): def stop_cx(self): print("Stopping CXs...") for cx_name in self.created_cx.keys(): - self.stop_cx(cx_name) + self.stopping_cx(cx_name) print(".", end='') print("") def cleanup_prefix(self): - self.local_realm.cleanup_cxe_prefix(self.name_prefix) + self.cleanup_cxe_prefix(self.name_prefix) def cleanup(self): print("Cleaning up cxs and endpoints") if len(self.created_cx) != 0: for cx_name in self.created_cx.keys(): if self.debug: - print("Cleaning cx: %s"%(cx_name)) + print("Cleaning cx: %s" % (cx_name)) self.rm_cx(cx_name) for side in range(len(self.created_cx[cx_name])): ename = self.created_cx[cx_name][side] if self.debug: - print("Cleaning endpoint: %s"%(ename)) + print("Cleaning endpoint: %s" % (ename)) self.rm_endp(self.created_cx[cx_name][side]) - def create(self, endp_type, side_a, side_b, sleep_time=0.03, suppress_related_commands=None, debug_=False, tos=None): + def create(self, endp_type, side_a, side_b, sleep_time=0.03, suppress_related_commands=None, debug_=False, + tos=None): if self.debug: - debug_=True + debug_ = True cx_post_data = [] timer_post_data = [] @@ -1316,7 +1341,8 @@ class L3CXProfile(LFCliBase): or (self.side_a_max_bps is None) \ or (self.side_b_min_bps is None) \ or (self.side_b_max_bps is None): - raise ValueError("side_a_min_bps, side_a_max_bps, side_b_min_bps, and side_b_max_bps must all be set to a value") + raise ValueError( + "side_a_min_bps, side_a_max_bps, side_b_min_bps, and side_b_max_bps must all be set to a value") if type(side_a) == list and type(side_b) != list: side_b_info = self.name_to_eid(side_b) @@ -1330,11 +1356,11 @@ class L3CXProfile(LFCliBase): if port_name.find('.') < 0: port_name = "%d.%s" % (side_a_info[1], port_name) - cx_name = "%s%s-%i"%(self.name_prefix, side_a_info[2], len(self.created_cx)) + cx_name = "%s%s-%i" % (self.name_prefix, side_a_info[2], len(self.created_cx)) endp_a_name = cx_name + "-A" endp_b_name = cx_name + "-B" - self.created_cx[ cx_name ] = [endp_a_name, endp_b_name] + self.created_cx[cx_name] = [endp_a_name, endp_b_name] self.created_endp[endp_a_name] = endp_a_name self.created_endp[endp_b_name] = endp_b_name these_cx.append(cx_name) @@ -1366,9 +1392,11 @@ class L3CXProfile(LFCliBase): } url = "/cli-json/add_endp" - self.local_realm.json_post(url, endp_side_a, debug_=debug_, suppress_related_commands_=suppress_related_commands) - self.local_realm.json_post(url, endp_side_b, debug_=debug_, suppress_related_commands_=suppress_related_commands) - #print("napping %f sec"%sleep_time) + self.json_post(url, endp_side_a, debug_=debug_, + suppress_related_commands_=suppress_related_commands) + self.json_post(url, endp_side_b, debug_=debug_, + suppress_related_commands_=suppress_related_commands) + # print("napping %f sec"%sleep_time) time.sleep(sleep_time) url = "cli-json/set_endp_flag" @@ -1377,16 +1405,20 @@ class L3CXProfile(LFCliBase): "flag": "AutoHelper", "val": 1 } - self.local_realm.json_post(url, data, debug_=debug_, suppress_related_commands_=suppress_related_commands) + self.json_post(url, data, debug_=debug_, + suppress_related_commands_=suppress_related_commands) data["name"] = endp_b_name - self.local_realm.json_post(url, data, debug_=debug_, suppress_related_commands_=suppress_related_commands) + self.json_post(url, data, debug_=debug_, + suppress_related_commands_=suppress_related_commands) if (endp_type == "lf_udp") or (endp_type == "udp") or (endp_type == "lf_udp6") or (endp_type == "udp6"): data["name"] = endp_a_name data["flag"] = "UseAutoNAT" - self.local_realm.json_post(url, data, debug_=debug_, suppress_related_commands_=suppress_related_commands) + self.json_post(url, data, debug_=debug_, + suppress_related_commands_=suppress_related_commands) data["name"] = endp_b_name - self.local_realm.json_post(url, data, debug_=debug_, suppress_related_commands_=suppress_related_commands) + self.json_post(url, data, debug_=debug_, + suppress_related_commands_=suppress_related_commands) if tos != None: self.set_endp_tos(endp_a_name, tos) @@ -1398,19 +1430,19 @@ class L3CXProfile(LFCliBase): "tx_endp": endp_a_name, "rx_endp": endp_b_name, } - #pprint(data) + # pprint(data) cx_post_data.append(data) timer_post_data.append({ - "test_mgr":"default_tm", - "cx_name":cx_name, - "milliseconds":self.report_timer + "test_mgr": "default_tm", + "cx_name": cx_name, + "milliseconds": self.report_timer }) elif type(side_b) == list and type(side_a) != list: side_a_info = self.name_to_eid(side_a) side_a_shelf = side_a_info[0] side_a_resource = side_a_info[1] - #side_a_name = side_a_info[2] + # side_a_name = side_a_info[2] for port_name in side_b: print(side_b) @@ -1422,7 +1454,7 @@ class L3CXProfile(LFCliBase): cx_name = "%s%s-%i" % (self.name_prefix, port_name, len(self.created_cx)) endp_a_name = cx_name + "-A" endp_b_name = cx_name + "-B" - self.created_cx[ cx_name ] = [endp_a_name, endp_b_name] + self.created_cx[cx_name] = [endp_a_name, endp_b_name] self.created_endp[endp_a_name] = endp_a_name self.created_endp[endp_b_name] = endp_b_name these_cx.append(cx_name) @@ -1454,9 +1486,11 @@ class L3CXProfile(LFCliBase): } url = "/cli-json/add_endp" - self.local_realm.json_post(url, endp_side_a, debug_=debug_, suppress_related_commands_=suppress_related_commands) - self.local_realm.json_post(url, endp_side_b, debug_=debug_, suppress_related_commands_=suppress_related_commands) - #print("napping %f sec" %sleep_time ) + self.json_post(url, endp_side_a, debug_=debug_, + suppress_related_commands_=suppress_related_commands) + self.json_post(url, endp_side_b, debug_=debug_, + suppress_related_commands_=suppress_related_commands) + # print("napping %f sec" %sleep_time ) time.sleep(sleep_time) url = "cli-json/set_endp_flag" @@ -1474,7 +1508,7 @@ class L3CXProfile(LFCliBase): "val": 1 } self.json_post(url, data, debug_=debug_, suppress_related_commands_=suppress_related_commands) - #print("CXNAME451: %s" % cx_name) + # print("CXNAME451: %s" % cx_name) data = { "alias": cx_name, "test_mgr": "default_tm", @@ -1483,18 +1517,20 @@ class L3CXProfile(LFCliBase): } cx_post_data.append(data) timer_post_data.append({ - "test_mgr":"default_tm", - "cx_name":cx_name, - "milliseconds":self.report_timer + "test_mgr": "default_tm", + "cx_name": cx_name, + "milliseconds": self.report_timer }) else: - raise ValueError("side_a or side_b must be of type list but not both: side_a is type %s side_b is type %s" % (type(side_a), type(side_b))) + raise ValueError( + "side_a or side_b must be of type list but not both: side_a is type %s side_b is type %s" % ( + type(side_a), type(side_b))) self.wait_until_endps_appear(these_endp, debug=debug_) for data in cx_post_data: url = "/cli-json/add_cx" - self.local_realm.json_post(url, data, debug_=debug_, suppress_related_commands_=suppress_related_commands) + self.json_post(url, data, debug_=debug_, suppress_related_commands_=suppress_related_commands) time.sleep(0.01) self.wait_until_cxs_appear(these_cx, debug=debug_) @@ -1569,13 +1605,13 @@ class L4CXProfile(LFCliBase): "cx_name": self.created_cx[cx_name] } self.json_post(req_url, data) - #pprint(data) + # pprint(data) req_url = "cli-json/rm_endp" data = { "endp_name": cx_name } self.json_post(req_url, data) - #pprint(data) + # pprint(data) def create(self, ports=[], sleep_time=.5, debug_=False, suppress_related_commands_=None): cx_post_data = [] @@ -1598,7 +1634,8 @@ class L4CXProfile(LFCliBase): "proxy_auth_type": 0x200 } url = "cli-json/add_l4_endp" - self.local_realm.json_post(url, endp_data, debug_=debug_, suppress_related_commands_=suppress_related_commands_) + self.local_realm.json_post(url, endp_data, debug_=debug_, + suppress_related_commands_=suppress_related_commands_) time.sleep(sleep_time) endp_data = { @@ -1612,7 +1649,8 @@ class L4CXProfile(LFCliBase): for cx_data in cx_post_data: url = "/cli-json/add_cx" - self.local_realm.json_post(url, cx_data, debug_=debug_, suppress_related_commands_=suppress_related_commands_) + self.local_realm.json_post(url, cx_data, debug_=debug_, + suppress_related_commands_=suppress_related_commands_) time.sleep(sleep_time) @@ -1636,7 +1674,7 @@ class GenCXProfile(LFCliBase): if self.type == "lfping": if ((self.dest is not None) or (self.dest != "")) and ((self.interval is not None) or (self.interval > 0)): self.cmd = "%s -i %s -I %s %s" % (self.type, self.interval, sta_name, self.dest) - #print(self.cmd) + # print(self.cmd) else: raise ValueError("Please ensure dest and interval have been set correctly") elif self.type == "generic": @@ -1652,8 +1690,8 @@ class GenCXProfile(LFCliBase): def start_cx(self): print("Starting CXs...") - #print(self.created_cx) - #print(self.created_endp) + # print(self.created_cx) + # print(self.created_endp) for cx_name in self.created_cx: self.json_post("/cli-json/set_cx_state", { "test_mgr": "default_tm", @@ -1711,15 +1749,15 @@ class GenCXProfile(LFCliBase): # this naming convention follows what you see when you use # lf_firemod.pl --action list_endp after creating a generic endpoint - gen_name_a = "%s-%s"%(self.name_prefix, name) - gen_name_b = "D_%s-%s"%(self.name_prefix, name) - endp_tpls.append( (resource, name, gen_name_a, gen_name_b)) + gen_name_a = "%s-%s" % (self.name_prefix, name) + gen_name_b = "D_%s-%s" % (self.name_prefix, name) + endp_tpls.append((resource, name, gen_name_a, gen_name_b)) for endp_tpl in endp_tpls: - resource = endp_tpl[0] - name = endp_tpl[1] - gen_name_a = endp_tpl[2] - #gen_name_b = endp_tpl[3] + resource = endp_tpl[0] + name = endp_tpl[1] + gen_name_a = endp_tpl[2] + # gen_name_b = endp_tpl[3] genl = GenericCx(lfclient_host=self.lfclient_host, lfclient_port=self.lfclient_port, debug_=self.debug) # (self, alias=None, shelf=1, resource=1, port=None, type=None): genl.create_gen_endp(alias=gen_name_a, shelf=shelf, resource=resource, port=name) @@ -1729,26 +1767,26 @@ class GenCXProfile(LFCliBase): time.sleep(sleep_time) for endp_tpl in endp_tpls: - gen_name_a = endp_tpl[2] - gen_name_b = endp_tpl[3] + gen_name_a = endp_tpl[2] + gen_name_b = endp_tpl[3] genl.set_flags(gen_name_a, "ClearPortOnStart", 1) # genl.set_flags(gen_name_b, "ClearPortOnStart", 1) # genl.set_flags(gen_name_b, "Unmanaged", 1) time.sleep(sleep_time) for endp_tpl in endp_tpls: - name = endp_tpl[1] - gen_name_a = endp_tpl[2] + name = endp_tpl[1] + gen_name_a = endp_tpl[2] # gen_name_b = endp_tpl[3] self.parse_command(name) genl.set_cmd(gen_name_a, self.cmd) time.sleep(sleep_time) for endp_tpl in endp_tpls: - name = endp_tpl[1] - gen_name_a = endp_tpl[2] - gen_name_b = endp_tpl[3] - cx_name = "CX_%s-%s"%(self.name_prefix, name) + name = endp_tpl[1] + gen_name_a = endp_tpl[2] + gen_name_b = endp_tpl[3] + cx_name = "CX_%s-%s" % (self.name_prefix, name) data = { "alias": cx_name, "test_mgr": "default_tm", @@ -1771,11 +1809,12 @@ class GenCXProfile(LFCliBase): time.sleep(sleep_time) for data in post_data: self.local_realm.json_post("/cli-json/show_cx", { - "test_mgr":"default_tm", + "test_mgr": "default_tm", "cross_connect": data["alias"] }) time.sleep(sleep_time) + class WifiMonitor: def __init__(self, lfclient_url, local_realm, up=True, debug_=False, resource_=1): self.debug = debug_ @@ -1787,10 +1826,10 @@ class WifiMonitor: self.flag_names = [] self.flag_mask_names = [] self.flags_mask = add_monitor.default_flags_mask - self.aid = "NA" # used when sniffing /ax radios - self.bsssid = "00:00:00:00:00:00" # used when sniffing on /ax radios + self.aid = "NA" # used when sniffing /ax radios + self.bsssid = "00:00:00:00:00:00" # used when sniffing on /ax radios - def create(self, resource_=1, channel=None, radio_="wiphy0", name_="moni0" ): + def create(self, resource_=1, channel=None, radio_="wiphy0", name_="moni0"): print("Creating monitor " + name_) self.monitor_name = name_ computed_flags = 0 @@ -1800,11 +1839,12 @@ class WifiMonitor: # we want to query the existing country code of the radio # there's no reason to change it but we get hollering from server # if we don't provide a value for the parameter - jr = self.local_realm.json_get("/radiostatus/1/%s/%s?fields=channel,frequency,country"%(resource_, radio_), debug_=self.debug) + jr = self.local_realm.json_get("/radiostatus/1/%s/%s?fields=channel,frequency,country" % (resource_, radio_), + debug_=self.debug) if jr is None: - raise ValueError("No radio %s.%s found"%(resource_, radio_)) + raise ValueError("No radio %s.%s found" % (resource_, radio_)) - eid = "1.%s.%s"%(resource_, radio_) + eid = "1.%s.%s" % (resource_, radio_) frequency = 0 country = 0 if eid in jr: @@ -1814,7 +1854,7 @@ class WifiMonitor: "shelf": 1, "resource": resource_, "radio": radio_, - "mode": 0, #"NA", #0 for AUTO or "NA" + "mode": 0, # "NA", #0 for AUTO or "NA" "channel": channel, "country": country, "frequency": self.local_realm.channel_freq(channel_=channel) @@ -1851,18 +1891,18 @@ class WifiMonitor: debug=self.debug) else: names = ",".join(desired_ports) - existing_ports = self.local_realm.json_get("/port/1/%d/%s?fields=alias"%(resource_, names), debug_=False) + existing_ports = self.local_realm.json_get("/port/1/%d/%s?fields=alias" % (resource_, names), debug_=False) if (existing_ports is None) or ("interfaces" not in existing_ports) or ("interface" not in existing_ports): print("No monitor names found to delete") return if ("interfaces" in existing_ports): - for eid,info in existing_ports["interfaces"].items(): + for eid, info in existing_ports["interfaces"].items(): LFUtils.removePort(resource=resource_, port_name=info["alias"], baseurl=self.lfclient_url, debug=self.debug) if ("interface" in existing_ports): - for eid,info in existing_ports["interface"].items(): + for eid, info in existing_ports["interface"].items(): LFUtils.removePort(resource=resource_, port_name=info["alias"], baseurl=self.lfclient_url, @@ -1882,19 +1922,17 @@ class WifiMonitor: if capname is None: raise ValueError("Need a capture file name") data = { - "shelf": 1, - "resource": 1, - "port": self.monitor_name, - "display": "NA", - "flags": 0x2, - "outfile": capname, - "duration": duration_sec - } - self.local_realm.json_post("/cli-json/sniff_port", _data= data) + "shelf": 1, + "resource": 1, + "port": self.monitor_name, + "display": "NA", + "flags": 0x2, + "outfile": capname, + "duration": duration_sec + } + self.local_realm.json_post("/cli-json/sniff_port", _data=data) - # "sniff_port 1 %s %s NA %s %s.pcap %i"%(r, m, sflags, m, int(dur)) - class VAPProfile(LFCliBase): def __init__(self, lfclient_host, lfclient_port, local_realm, vap_name="", @@ -1904,7 +1942,7 @@ class VAPProfile(LFCliBase): debug_=False): super().__init__(_lfjson_host=lfclient_host, _lfjson_port=lfclient_port, _debug=debug_) self.debug = debug_ - #self.lfclient_url = lfclient_url # done in super() + # self.lfclient_url = lfclient_url # done in super() self.ssid = ssid self.ssid_pass = ssid_pass self.mode = mode @@ -2033,7 +2071,9 @@ class VAPProfile(LFCliBase): self.desired_add_vap_flags_mask.append(param_name) elif command_name == "set_port": - if (param_name not in set_port.set_port_current_flags) and (param_name not in set_port.set_port_cmd_flags) and (param_name not in set_port.set_port_interest_flags): + if (param_name not in set_port.set_port_current_flags) and ( + param_name not in set_port.set_port_cmd_flags) and ( + param_name not in set_port.set_port_interest_flags): print("Parameter name [%s] not defined in set_port.py" % param_name) if self.debug: pprint(set_port.set_port_cmd_flags) @@ -2089,18 +2129,19 @@ class VAPProfile(LFCliBase): if self.debug: pprint(command_ref) raise ValueError("flag %s not in map" % name) - #print("add-named-flags: %s %i"%(name, command_ref[name])) + # print("add-named-flags: %s %i"%(name, command_ref[name])) result |= command_ref[name] return result - def create(self, resource, radio, channel=None, up_=None, debug=False, use_ht40=True, use_ht80=True, use_ht160=False, + def create(self, resource, radio, channel=None, up_=None, debug=False, use_ht40=True, use_ht80=True, + use_ht160=False, suppress_related_commands_=True, use_radius=False, hs20_enable=False): port_list = self.local_realm.json_get("port/1/1/list") if port_list is not None: port_list = port_list['interfaces'] for port in port_list: - for k,v in port.items(): + for k, v in port.items(): if v['alias'] == self.vap_name: self.local_realm.rm_port(k, check_exists=True) if use_ht160: @@ -2123,9 +2164,10 @@ class VAPProfile(LFCliBase): self.desired_add_vap_flags.append("hs20_enable") self.desired_add_vap_flags_mask.append("hs20_enable") - #print("MODE ========= ", self.mode) + # print("MODE ========= ", self.mode) - jr = self.local_realm.json_get("/radiostatus/1/%s/%s?fields=channel,frequency,country" % (resource, radio), debug_=self.debug) + jr = self.local_realm.json_get("/radiostatus/1/%s/%s?fields=channel,frequency,country" % (resource, radio), + debug_=self.debug) if jr is None: raise ValueError("No radio %s.%s found" % (resource, radio)) @@ -2139,7 +2181,7 @@ class VAPProfile(LFCliBase): "shelf": 1, "resource": resource, "radio": radio, - "mode": self.mode, #"NA", #0 for AUTO or "NA" + "mode": self.mode, # "NA", #0 for AUTO or "NA" "channel": channel, "country": country, "frequency": self.local_realm.channel_freq(channel_=channel) @@ -2200,12 +2242,11 @@ class VAPProfile(LFCliBase): wifi_extra_r.addPostData(self.wifi_extra_data) json_response = wifi_extra_r.jsonPost(debug) - port_list = self.local_realm.json_get("port/1/1/list") if port_list is not None: port_list = port_list['interfaces'] for port in port_list: - for k,v in port.items(): + for k, v in port.items(): if v['alias'] == 'br0': self.local_realm.rm_port(k, check_exists=True) time.sleep(5) @@ -2228,8 +2269,6 @@ class VAPProfile(LFCliBase): } self.local_realm.json_post("cli-json/set_port", bridge_set_port) - - if (self.up): self.admin_up(1) @@ -2246,10 +2285,11 @@ class VAPProfile(LFCliBase): # And now see if they are gone LFUtils.wait_until_ports_disappear(base_url=self.lfclient_url, port_list=desired_ports) + class VRProfile(LFCliBase): def __init__(self, lfclient_host, lfclient_port, local_realm, ssid="NA", ssid_pass="NA", mode=0, debug_=False): super().__init__(_lfjson_host=lfclient_host, _lfjson_port=lfclient_port, _debug=debug_) - #self.debug = debug_ + # self.debug = debug_ # self.lfclient_url = lfclient_url self.ssid = ssid self.ssid_pass = ssid_pass @@ -2275,8 +2315,8 @@ class VRProfile(LFCliBase): 'shelf': 1, 'resource': 1, 'vr-name': None, - 'local_dev': None, # outer rdd - 'remote_dev': None, # inner rdd + 'local_dev': None, # outer rdd + 'remote_dev': None, # inner rdd "x": 0, "y": 0, "width": 10, @@ -2304,7 +2344,8 @@ class VRProfile(LFCliBase): "peer_ifname": "rdd1" } # print("creating rdd0") - self.local_realm.json_post("add_rdd", rdd_data, suppress_related_commands_=suppress_related_commands_, debug_=debug_) + self.local_realm.json_post("add_rdd", rdd_data, suppress_related_commands_=suppress_related_commands_, + debug_=debug_) rdd_data = { "shelf": 1, @@ -2313,24 +2354,28 @@ class VRProfile(LFCliBase): "peer_ifname": "rdd0" } # print("creating rdd1") - self.local_realm.json_post("add_rdd", rdd_data, suppress_related_commands_=suppress_related_commands_, debug_=debug_) + self.local_realm.json_post("add_rdd", rdd_data, suppress_related_commands_=suppress_related_commands_, + debug_=debug_) self.set_port_data["port"] = "rdd0" self.set_port_data["ip_addr"] = gateway self.set_port_data["netmask"] = netmask self.set_port_data["gateway"] = gateway - self.local_realm.json_post("set_port", self.set_port_data, suppress_related_commands_=suppress_related_commands_, debug_=debug_) + self.local_realm.json_post("set_port", self.set_port_data, + suppress_related_commands_=suppress_related_commands_, debug_=debug_) self.set_port_data["port"] = "rdd1" self.set_port_data["ip_addr"] = ip_addr self.set_port_data["netmask"] = netmask self.set_port_data["gateway"] = gateway - self.local_realm.json_post("set_port", self.set_port_data, suppress_related_commands_=suppress_related_commands_, debug_=debug_) + self.local_realm.json_post("set_port", self.set_port_data, + suppress_related_commands_=suppress_related_commands_, debug_=debug_) self.created_rdds.append("rdd0") self.created_rdds.append("rdd1") - def create_vrcx(self, resource, local_dev, remote_dev, subnets, nexthop, flags, suppress_related_commands_=True, debug_=False): + def create_vrcx(self, resource, local_dev, remote_dev, subnets, nexthop, flags, suppress_related_commands_=True, + debug_=False): if self.vr_name is not None: self.vrcx_data["resource"] = resource self.vrcx_data["vr_name"] = self.vr_name @@ -2339,7 +2384,8 @@ class VRProfile(LFCliBase): self.vrcx_data["subnets"] = subnets self.vrcx_data["nexthop"] = nexthop self.vrcx_data["flags"] = flags - self.local_realm.json_post("add_vrcx", self.vrcx_data, suppress_related_commands_=suppress_related_commands_, debug_=debug_) + self.local_realm.json_post("add_vrcx", self.vrcx_data, + suppress_related_commands_=suppress_related_commands_, debug_=debug_) else: raise ValueError("vr_name must be set. Current name: %s" % self.vr_name) @@ -2357,18 +2403,22 @@ class VRProfile(LFCliBase): else: raise ValueError("vr_name must be set. Current name: %s" % self.vr_name) # Create 1 rdd pair - self.create_rdd(resource=resource, ip_addr=rdd_ip, gateway=rdd_gateway, netmask=rdd_netmask) # rdd0, rdd1; rdd0 gateway, rdd1 connected to network + self.create_rdd(resource=resource, ip_addr=rdd_ip, gateway=rdd_gateway, + netmask=rdd_netmask) # rdd0, rdd1; rdd0 gateway, rdd1 connected to network # connect rdds and upstream - self.create_vrcx(resource=resource, local_dev=upstream_port, remote_dev="NA", subnets=upstream_subnets, nexthop=upstream_nexthop, + self.create_vrcx(resource=resource, local_dev=upstream_port, remote_dev="NA", subnets=upstream_subnets, + nexthop=upstream_nexthop, flags=257, suppress_related_commands_=suppress_related_commands_, debug_=debug) - self.create_vrcx(resource=resource, local_dev="rdd0", remote_dev="rdd1", subnets=local_subnets, nexthop=local_nexthop, + self.create_vrcx(resource=resource, local_dev="rdd0", remote_dev="rdd1", subnets=local_subnets, + nexthop=local_nexthop, flags=1, suppress_related_commands_=suppress_related_commands_, debug_=debug) def cleanup(self, resource, delay=0.03): # TODO: Cleanup for VRProfile pass + class DUTProfile(LFCliBase): def __init__(self, lfclient_host, lfclient_port, local_realm, debug_=False): super().__init__(lfclient_host, lfclient_port, debug_, _halt_on_error=True, _local_realm=local_realm) @@ -2421,13 +2471,13 @@ class DUTProfile(LFCliBase): for param in add_dut.dut_params: if (param.name in self.__dict__): if (self.__dict__[param.name] is not None) \ - and (self.__dict__[param.name] != "NA"): + and (self.__dict__[param.name] != "NA"): data[param.name] = self.__dict__[param.name] else: print("---------------------------------------------------------") pprint(self.__dict__[param.name]) print("---------------------------------------------------------") - raise ValueError("parameter %s not in dut_profile"%param) + raise ValueError("parameter %s not in dut_profile" % param) if (flags is not None) and (int(flags) > -1): data["flags"] = flags @@ -2448,7 +2498,7 @@ class DUTProfile(LFCliBase): print("---------------------------------------------------------") self.json_post(url, data, debug_=self.debug) - if (self.notes is not None) and (len(self.notes)>0): + if (self.notes is not None) and (len(self.notes) > 0): self.json_post("/cli-json/add_dut_notes", { "dut": self.name, "text": "[BLANK]" @@ -2465,7 +2515,7 @@ class DUTProfile(LFCliBase): "dut": self.name, "text-64": notebytes.decode('ascii') }, self.debug) - if (self.append is not None) and (len(self.append)>0): + if (self.append is not None) and (len(self.append) > 0): notebytes = None for line in self.append: notebytes = base64.b64encode(line.encode('ascii')) @@ -2479,6 +2529,7 @@ class DUTProfile(LFCliBase): "text-64": notebytes.decode('ascii') }, self.debug) + class TestGroupProfile(LFCliBase): def __init__(self, lfclient_host, lfclient_port, local_realm, test_group_name=None, debug_=False): super().__init__(lfclient_host, lfclient_port, debug_, _halt_on_error=True) @@ -2494,7 +2545,7 @@ class TestGroupProfile(LFCliBase): def quiesce_group(self): if self.group_name is not None: - self.local_realm.json_post("/cli-json/quiesce_group", {"name": self.group_name}) + self.local_realm.json_post("/cli-json/quiesce_group", {"name": self.group_name}) else: raise ValueError("test_group name must be set.") @@ -2527,7 +2578,7 @@ class TestGroupProfile(LFCliBase): if test_groups is not None and "groups" in test_groups: test_groups = test_groups["groups"] for group in test_groups: - for k,v in group.items(): + for k, v in group.items(): if v['name'] == self.group_name: return True else: @@ -2548,7 +2599,7 @@ class TestGroupProfile(LFCliBase): if test_groups is not None: test_groups = test_groups["groups"] for group in test_groups: - for k,v in group.items(): + for k, v in group.items(): if v['name'] == self.group_name: return v['cross connects'] @@ -2561,6 +2612,7 @@ class FIOEndpProfile(LFCliBase): Very often you will create the FileIO writer profile first so that it creates the data that a reader profile will subsequently use. """ + def __init__(self, lfclient_host, lfclient_port, local_realm, io_direction="write", debug_=False): super().__init__(lfclient_host, lfclient_port, debug_, _halt_on_error=True) self.local_realm = local_realm @@ -2575,8 +2627,8 @@ class FIOEndpProfile(LFCliBase): self.min_write_rate_bps = 1000 * 1000 * 1000 self.max_write_rate_bps = 1000 * 1000 * 1000 - self.file_num = 10 # number of files to write - self.directory = None # directory like /mnt/lf/$endp_name + self.file_num = 10 # number of files to write + self.directory = None # directory like /mnt/lf/$endp_name # this refers to locally mounted directories presently used for writing # you would set this when doing read tests simultaneously to write tests @@ -2585,14 +2637,14 @@ class FIOEndpProfile(LFCliBase): # /mnt/lf/ro_300GB_001, this overwrites a readers directory name to wo_300GB_001 self.mount_dir = "AUTO" - self.server_mount = None # like cifs://10.0.0.1/bashful or 192.168.1.1:/var/tmp + self.server_mount = None # like cifs://10.0.0.1/bashful or 192.168.1.1:/var/tmp self.mount_options = None self.iscsi_vol = None self.retry_timer_ms = 2000 - self.io_direction = io_direction # read / write + self.io_direction = io_direction # read / write self.quiesce_ms = 3000 self.pattern = "increasing" - self.file_prefix = "AUTO" # defaults to endp_name + self.file_prefix = "AUTO" # defaults to endp_name self.cx_prefix = "wo_" self.created_cx = {} @@ -2653,13 +2705,13 @@ class FIOEndpProfile(LFCliBase): "cx_name": self.created_cx[cx_name] } self.json_post(req_url, data) - #pprint(data) + # pprint(data) req_url = "cli-json/rm_endp" data = { "endp_name": cx_name } self.json_post(req_url, data) - #pprint(data) + # pprint(data) def create(self, ports=[], connections_per_port=1, sleep_time=.5, debug_=False, suppress_related_commands_=None): cx_post_data = [] @@ -2672,9 +2724,10 @@ class FIOEndpProfile(LFCliBase): else: raise ValueError("Unexpected name for port_name %s" % port_name) if self.directory is None or self.server_mount is None or self.fs_type is None: - raise ValueError("directory [%s], server_mount [%s], and type [%s] must not be None" % (self.directory, self.server_mount, self.fs_type)) + raise ValueError("directory [%s], server_mount [%s], and type [%s] must not be None" % ( + self.directory, self.server_mount, self.fs_type)) endp_data = { - "alias": self.cx_prefix + name + "_" + str(num_connection) + "_fio" , + "alias": self.cx_prefix + name + "_" + str(num_connection) + "_fio", "shelf": shelf, "resource": resource, "port": name, @@ -2696,11 +2749,12 @@ class FIOEndpProfile(LFCliBase): endp_data["directory"] = "/mnt/lf/wo_" + name + "_" + str(num_connection) + "_fio" url = "cli-json/add_file_endp" - self.local_realm.json_post(url, endp_data, debug_=False, suppress_related_commands_=suppress_related_commands_) + self.local_realm.json_post(url, endp_data, debug_=False, + suppress_related_commands_=suppress_related_commands_) time.sleep(sleep_time) data = { - "name": self.cx_prefix + name + "_" + str(num_connection) + "_fio" , + "name": self.cx_prefix + name + "_" + str(num_connection) + "_fio", "io_direction": self.io_direction, "num_files": 5 } @@ -2716,17 +2770,19 @@ class FIOEndpProfile(LFCliBase): name = self.local_realm.name_to_eid(port_name)[2] endp_data = { - "alias": "CX_" + self.cx_prefix + name + "_" + str(num_connection) + "_fio" , + "alias": "CX_" + self.cx_prefix + name + "_" + str(num_connection) + "_fio", "test_mgr": "default_tm", - "tx_endp": self.cx_prefix + name + "_" + str(num_connection) + "_fio" , + "tx_endp": self.cx_prefix + name + "_" + str(num_connection) + "_fio", "rx_endp": "NA" } cx_post_data.append(endp_data) - self.created_cx[self.cx_prefix + name + "_" + str(num_connection) + "_fio" ] = "CX_" + self.cx_prefix + name + "_" + str(num_connection) + "_fio" + self.created_cx[self.cx_prefix + name + "_" + str( + num_connection) + "_fio"] = "CX_" + self.cx_prefix + name + "_" + str(num_connection) + "_fio" for cx_data in cx_post_data: url = "/cli-json/add_cx" - self.local_realm.json_post(url, cx_data, debug_=debug_, suppress_related_commands_=suppress_related_commands_) + self.local_realm.json_post(url, cx_data, debug_=debug_, + suppress_related_commands_=suppress_related_commands_) time.sleep(sleep_time) @@ -2753,8 +2809,8 @@ class MACVLANProfile(LFCliBase): self.ip_list = [] self.COMMANDS = ["set_port"] self.desired_set_port_cmd_flags = [] - self.desired_set_port_current_flags = [] # do not default down, "if_down" - self.desired_set_port_interest_flags = ["current_flags"] # do not default down, "ifdown" + self.desired_set_port_current_flags = [] # do not default down, "if_down" + self.desired_set_port_interest_flags = ["current_flags"] # do not default down, "ifdown" self.set_port_data = { "shelf": 1, "resource": 1, @@ -2842,7 +2898,8 @@ class MACVLANProfile(LFCliBase): self.desired_set_port_interest_flags.append("ip_address") self.desired_set_port_interest_flags.append("ip_Mask") self.desired_set_port_interest_flags.append("ip_gateway") - self.ip_list = LFUtils.gen_ip_series(ip_addr=self.first_ip_addr, netmask=self.netmask, num_ips=self.num_macvlans) + self.ip_list = LFUtils.gen_ip_series(ip_addr=self.first_ip_addr, netmask=self.netmask, + num_ips=self.num_macvlans) self.set_port_data["current_flags"] = self.add_named_flags(self.desired_set_port_current_flags, set_port.set_port_current_flags) @@ -2861,7 +2918,7 @@ class MACVLANProfile(LFCliBase): "resource": self.resource, "mac": "xx:xx:xx:*:*:xx", "port": self.local_realm.name_to_eid(self.macvlan_parent)[2], - "index": int(self.desired_macvlans[i][self.desired_macvlans[i].index('#')+1:]), + "index": int(self.desired_macvlans[i][self.desired_macvlans[i].index('#') + 1:]), "flags": None } if admin_down: @@ -2869,11 +2926,12 @@ class MACVLANProfile(LFCliBase): else: data["flags"] = 0 self.created_macvlans.append("%s.%s.%s#%d" % (self.shelf, self.resource, - self.macvlan_parent, int(self.desired_macvlans[i][self.desired_macvlans[i].index('#')+1:]))) + self.macvlan_parent, int( + self.desired_macvlans[i][self.desired_macvlans[i].index('#') + 1:]))) self.local_realm.json_post(req_url, data) time.sleep(sleep_time) - LFUtils.wait_until_ports_appear(base_url=self.lfclient_url, port_list=self.created_macvlans) + LFUtils.wait_until_ports_appear(base_url=self.lfclient_url, port_list=self.created_macvlans) print(self.created_macvlans) time.sleep(5) @@ -2909,6 +2967,7 @@ class MACVLANProfile(LFCliBase): for macvlan in self.created_macvlans: self.local_realm.admin_down(macvlan) + class PacketFilter(): def get_filter_wlan_assoc_packets(self, ap_mac, sta_mac): @@ -2933,6 +2992,7 @@ class PacketFilter(): return lines + class PortUtils(): def __init__(self, local_realm): self.local_realm = local_realm @@ -2977,6 +3037,7 @@ class PortUtils(): else: raise ValueError("Port name required") + class HTTPProfile(LFCliBase): def __init__(self, lfclient_host, lfclient_port, local_realm, debug_=False): super().__init__(lfclient_host, lfclient_port, debug_, _halt_on_error=True) @@ -3011,7 +3072,7 @@ class HTTPProfile(LFCliBase): if passes == expected_passes: return True else: - print(list(debug_info), " Endps in this list showed errors getting to its URL") # %s") % self.url) + print(list(debug_info), " Endps in this list showed errors getting to its URL") # %s") % self.url) return False def start_cx(self): @@ -3046,19 +3107,19 @@ class HTTPProfile(LFCliBase): "cx_name": self.created_cx[cx_name] } self.json_post(req_url, data) - #pprint(data) + # pprint(data) req_url = "cli-json/rm_endp" data = { "endp_name": cx_name } self.json_post(req_url, data) - #pprint(data) + # pprint(data) def map_sta_ips(self, sta_list=[]): for sta_eid in sta_list: eid = self.local_realm.name_to_eid(sta_eid) sta_list = self.json_get("/port/%s/%s/%s?fields=alias,ip" % - (eid[0], eid[1], eid[2])) + (eid[0], eid[1], eid[2])) if sta_list['interface'] is not None: self.ip_map[sta_list['interface']['alias']] = sta_list['interface']['ip'] @@ -3070,7 +3131,7 @@ class HTTPProfile(LFCliBase): url = None if i != len(list(self.ip_map)) - 1: port_name = list(self.ip_map)[i] - ip_addr = self.ip_map[list(self.ip_map)[i+1]] + ip_addr = self.ip_map[list(self.ip_map)[i + 1]] else: port_name = list(self.ip_map)[i] ip_addr = self.ip_map[list(self.ip_map)[0]] @@ -3091,7 +3152,7 @@ class HTTPProfile(LFCliBase): if ftp: self.port_util.set_ftp(port_name=name, resource=resource, on=True) if user is not None and passwd is not None and source is not None: - url = "%s ftp://%s:%s@%s%s %s" % (self.direction, user, passwd, ip_addr, source, self.dest) + url = "%s ftp://%s:%s@%s%s %s" % (self.direction, user, passwd, ip_addr, source, self.dest) else: raise ValueError("user: %s, passwd: %s, and source: %s must all be set" % (user, passwd, source)) if not http and not ftp: @@ -3112,7 +3173,8 @@ class HTTPProfile(LFCliBase): "proxy_auth_type": 0x200 } url = "cli-json/add_l4_endp" - self.local_realm.json_post(url, endp_data, debug_=debug_, suppress_related_commands_=suppress_related_commands_) + self.local_realm.json_post(url, endp_data, debug_=debug_, + suppress_related_commands_=suppress_related_commands_) time.sleep(sleep_time) endp_data = { @@ -3126,7 +3188,8 @@ class HTTPProfile(LFCliBase): for cx_data in cx_post_data: url = "/cli-json/add_cx" - self.local_realm.json_post(url, cx_data, debug_=debug_, suppress_related_commands_=suppress_related_commands_) + self.local_realm.json_post(url, cx_data, debug_=debug_, + suppress_related_commands_=suppress_related_commands_) time.sleep(sleep_time) @@ -3159,8 +3222,8 @@ class StationProfile: self.ssid_pass = ssid_pass self.mode = mode self.up = up - self.resource=resource - self.shelf=shelf + self.resource = resource + self.shelf = shelf self.dhcp = dhcp self.security = security self.local_realm = local_realm @@ -3226,7 +3289,7 @@ class StationProfile: pairwise="CCMP TKIP", group="CCMP TKIP", psk="[BLANK]", - wep_key="[BLANK]", #wep key + wep_key="[BLANK]", # wep key ca_cert="[BLANK]", eap="TTLS", identity="testuser", @@ -3302,7 +3365,7 @@ class StationProfile: self.desired_add_sta_flags_mask.remove(name) if security_type != "open": self.desired_add_sta_flags.append(types[security_type]) - #self.set_command_flag("add_sta", types[security_type], 1) + # self.set_command_flag("add_sta", types[security_type], 1) self.desired_add_sta_flags_mask.append(types[security_type]) else: passwd = "[BLANK]" @@ -3312,7 +3375,7 @@ class StationProfile: if security_type == "wpa3": self.set_command_param("add_sta", "ieee80211w", 2) - #self.add_sta_data["key"] = passwd + # self.add_sta_data["key"] = passwd def set_command_param(self, command_name, param_name, param_value): # we have to check what the param name is @@ -3351,7 +3414,9 @@ class StationProfile: self.desired_add_sta_flags_mask.append(param_name) elif command_name == "set_port": - if (param_name not in set_port.set_port_current_flags) and (param_name not in set_port.set_port_cmd_flags) and (param_name not in set_port.set_port_interest_flags): + if (param_name not in set_port.set_port_current_flags) and ( + param_name not in set_port.set_port_cmd_flags) and ( + param_name not in set_port.set_port_interest_flags): print("Parameter name [%s] not defined in set_port.py" % param_name) if self.debug: pprint(set_port.set_port_cmd_flags) @@ -3374,7 +3439,8 @@ class StationProfile: elif value == 0: self.desired_set_port_interest_flags.remove(param_name) else: - raise ValueError("Unknown param name: "+param_name) + raise ValueError("Unknown param name: " + param_name) + # use this for hinting station name; stations begin with 'sta', the # stations created with a prefix '0100' indicate value 10100 + n with # resulting substring(1,) applied; station 900 becomes 'sta1000' @@ -3426,10 +3492,9 @@ class StationProfile: # First, request remove on the list. for port_eid in desired_stations: self.local_realm.rm_port(port_eid, check_exists=True, debug_=debug_) - time.sleep(delay) - # And now see if they are gone - LFUtils.wait_until_ports_disappear(base_url=self.lfclient_url, port_list=desired_stations) + # And now see if they are gone + LFUtils.wait_until_ports_disappear(base_url=self.lfclient_url, port_list=desired_stations) # Checks for errors in initialization values and creates specified number of stations using init parameters def create(self, radio, @@ -3473,7 +3538,7 @@ class StationProfile: self.desired_add_sta_flags.append("create_admin_down") # create stations down, do set_port on them, then set stations up - self.add_sta_data["flags"] = self.add_named_flags(self.desired_add_sta_flags, add_sta.add_sta_flags) + self.add_sta_data["flags"] = self.add_named_flags(self.desired_add_sta_flags, add_sta.add_sta_flags) self.add_sta_data["flags_mask"] = self.add_named_flags(self.desired_add_sta_flags_mask, add_sta.add_sta_flags) self.add_sta_data["radio"] = radio_port @@ -3493,14 +3558,14 @@ class StationProfile: # these are unactivated LFRequest objects that we can modify and # re-use inside a loop, reducing the number of object creations add_sta_r = LFRequest.LFRequest(self.lfclient_url + "/cli-json/add_sta", debug_=debug) - set_port_r = LFRequest.LFRequest(self.lfclient_url + "/cli-json/set_port",debug_=debug) - wifi_extra_r = LFRequest.LFRequest(self.lfclient_url + "/cli-json/set_wifi_extra",debug_=debug) + set_port_r = LFRequest.LFRequest(self.lfclient_url + "/cli-json/set_port", debug_=debug) + wifi_extra_r = LFRequest.LFRequest(self.lfclient_url + "/cli-json/set_wifi_extra", debug_=debug) my_sta_names = [] - #add radio here + # add radio here if (num_stations > 0) and (len(sta_names_) < 1): - #print("CREATING MORE STA NAMES == == == == == == == == == == == == == == == == == == == == == == == ==") + # print("CREATING MORE STA NAMES == == == == == == == == == == == == == == == == == == == == == == == ==") my_sta_names = LFUtils.portNameSeries("sta", 0, num_stations - 1, int("1" + self.number_template)) - #print("CREATING MORE STA NAMES == == == == == == == == == == == == == == == == == == == == == == == ==") + # print("CREATING MORE STA NAMES == == == == == == == == == == == == == == == == == == == == == == == ==") else: my_sta_names = sta_names_ @@ -3540,7 +3605,7 @@ class StationProfile: self.add_sta_data["shelf"] = radio_shelf self.add_sta_data["resource"] = radio_resource self.add_sta_data["radio"] = radio_port - self.add_sta_data["sta_name"] = name # for create station calls + self.add_sta_data["sta_name"] = name # for create station calls self.set_port_data["port"] = name # for set_port calls. self.set_port_data["shelf"] = radio_shelf self.set_port_data["resource"] = radio_resource @@ -3554,7 +3619,7 @@ class StationProfile: pprint(self.set_port_data) print("- ~3254 - - - - - - - - - - - - - - - - - - - ") if dry_run: - print("dry run: not creating "+eidn) + print("dry run: not creating " + eidn) continue # print("- 3264 - ## %s ## add_sta_r.jsonPost - - - - - - - - - - - - - - - - - - "%eidn) @@ -3563,9 +3628,9 @@ class StationProfile: # print("- ~3264 - %s - add_sta_r.jsonPost - - - - - - - - - - - - - - - - - - "%eidn) time.sleep(0.01) set_port_r.addPostData(self.set_port_data) - #print("- 3270 -- %s -- set_port_r.jsonPost - - - - - - - - - - - - - - - - - - "%eidn) + # print("- 3270 -- %s -- set_port_r.jsonPost - - - - - - - - - - - - - - - - - - "%eidn) json_response = set_port_r.jsonPost(debug) - #print("- ~3270 - %s - set_port_r.jsonPost - - - - - - - - - - - - - - - - - - "%eidn) + # print("- ~3270 - %s - set_port_r.jsonPost - - - - - - - - - - - - - - - - - - "%eidn) time.sleep(0.01) self.wifi_extra_data["resource"] = radio_resource @@ -3578,7 +3643,7 @@ class StationProfile: self.station_names.append("%s.%s.%s" % (radio_shelf, radio_resource, name)) time.sleep(sleep_time) - #print("- ~3287 - waitUntilPortsAppear - - - - - - - - - - - - - - - - - - "%eidn) + # print("- ~3287 - waitUntilPortsAppear - - - - - - - - - - - - - - - - - - "%eidn) LFUtils.wait_until_ports_appear(self.lfclient_url, my_sta_names) # and set ports up diff --git a/py-scripts/test_ipv4_variable_time.py b/py-scripts/test_ipv4_variable_time.py index e52ce374..50eabf11 100755 --- a/py-scripts/test_ipv4_variable_time.py +++ b/py-scripts/test_ipv4_variable_time.py @@ -264,6 +264,7 @@ python3 ./test_ipv4_variable_time.py script_name='test_ipv4_variable_time', show=show, arguments=args) + print(ip_var_test.cx_profile.create()) ip_var_test.stop() if not ip_var_test.passes(): print(ip_var_test.get_fail_message())