exit(1)
print("** Existing CXs **")
try:
cx_list = localrealm.cx_list()
print("%s CXs:" % len(cx_list))
pprint(cx_list)
except Exception as x:
localrealm.error(x)
exit(1)
print("** Removing previous CXs **")
print("** Creating Layer 3 CXs **")
try:
cx_profile = localrealm.new_l3_cx_profile()
# set attributes of cxProfile
cx_profile.create("lf_udp",
side_a="1.1.eth1",
side_b=list(localrealm.find_ports_like("sta+")))
except Exception as x:
pprint(x)
exit(1)
try:
cx_profile = localrealm.new_l3_cx_profile()
# set attributes of cxProfile
cx_profile.create("lf_udp",
side_a=list(localrealm.find_ports_like("sta+")),
side_b="1.1.eth1")
except Exception as x:
class SingleClientEAP(LFCliBase):
def __init__(self,
host,
port,
security=None,
ssid=None,
sta_list=None,
number_template="00000",
_debug_on=False,
_dut_bssid="",
_exit_on_error=False,
_sta_name=None,
_resource=1,
radio="wiphy0",
key_mgmt="WPA-EAP",
eap="",
identity="",
ttls_passwd="",
hessid=None,
ttls_realm="",
domain="",
_exit_on_fail=False,
_cleanup_on_exit=True):
super().__init__(host,
port,
_debug=_debug_on,
_halt_on_error=_exit_on_error,
_exit_on_fail=_exit_on_fail)
self.host = host
self.port = port
self.ssid = ssid
self.radio = radio
self.security = security
#self.password = password
self.sta_list = sta_list
self.key_mgmt = key_mgmt
self.eap = eap
self.identity = identity
self.ttls_passwd = ttls_passwd
self.ttls_realm = ttls_realm
self.domain = domain
self.hessid = hessid
self.dut_bssid = _dut_bssid
self.timeout = 120
self.number_template = number_template
self.debug = _debug_on
self.local_realm = realm.Realm(lfclient_host=self.host,
lfclient_port=self.port)
self.station_profile = self.local_realm.new_station_profile()
self.station_profile.lfclient_url = self.lfclient_url
self.station_profile.ssid = self.ssid
self.station_profile.security = self.security
self.station_profile.number_template_ = self.number_template
self.station_profile.mode = 0
#Added to test_ipv4_ttls code
self.upstream_url = None # defer construction
self.sta_url_map = None
self.upstream_resource = None
self.upstream_port = None
self.station_names = []
if _sta_name is not None:
self.station_names = [_sta_name]
self.localrealm = Realm(lfclient_host=host, lfclient_port=port)
self.resource = _resource
self.cleanup_on_exit = _cleanup_on_exit
self.resulting_stations = {}
self.resulting_endpoints = {}
self.station_profile = None
self.l3_udp_profile = None
self.l3_tcp_profile = None
# def get_realm(self) -> Realm: # py > 3.6
def get_realm(self):
return self.localrealm
def get_station_url(self, sta_name_=None):
if sta_name_ is None:
raise ValueError("get_station_url wants a station name")
if self.sta_url_map is None:
self.sta_url_map = {}
for sta_name in self.station_names:
self.sta_url_map[sta_name] = "port/1/%s/%s" % (self.resource,
sta_name)
return self.sta_url_map[sta_name_]
def get_upstream_url(self):
if self.upstream_url is None:
self.upstream_url = "port/1/%s/%s" % (self.upstream_resource,
self.upstream_port)
return self.upstream_url
# Compare pre-test values to post-test values
def compare_vals(self, name, postVal, print_pass=False, print_fail=True):
# print(f"Comparing {name}")
if postVal > 0:
self._pass("%s %s" % (name, postVal), print_pass)
else:
self._fail("%s did not report traffic: %s" % (name, postVal),
print_fail)
def remove_stations(self):
for name in self.station_names:
LFUtils.removePort(self.resource, name, self.lfclient_url)
def num_associated(self, bssid):
counter = 0
# print("there are %d results" % len(self.station_results))
fields = "_links,port,alias,ip,ap,port+type"
self.station_results = self.localrealm.find_ports_like("eap*",
fields,
debug_=False)
if (self.station_results is None) or (len(self.station_results) < 1):
self.get_failed_result_list()
for eid, record in self.station_results.items():
#print("-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ")
#pprint(eid)
#pprint(record)
if record["ap"] == bssid:
counter += 1
#print("-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ")
return counter
def clear_test_results(self):
self.resulting_stations = {}
self.resulting_endpoints = {}
super().clear_test_results()
#super(StaConnect, self).clear_test_results().test_results.clear()
def setup(self):
self.clear_test_results()
self.check_connect()
upstream_json = self.json_get("%s?fields=alias,phantom,down,port,ip" %
self.get_upstream_url(),
debug_=False)
if upstream_json is None:
self._fail(message="Unable to query %s, bye" % self.upstream_port,
print_=True)
return False
if upstream_json['interface']['ip'] == "0.0.0.0":
if self.debug:
pprint.pprint(upstream_json)
self._fail("Warning: %s lacks ip address" %
self.get_upstream_url(),
print_=True)
return False
# remove old stations
print("Removing old stations")
for sta_name in self.station_names:
sta_url = self.get_station_url(sta_name)
response = self.json_get(sta_url)
if (response is not None) and (response["interface"] is not None):
for sta_name in self.station_names:
LFUtils.removePort(self.resource, sta_name,
self.lfclient_url)
LFUtils.wait_until_ports_disappear(self.lfclient_url,
self.station_names)
# Create stations and turn dhcp on
self.station_profile = self.localrealm.new_station_profile()
# Build stations
self.station_profile.use_security(self.security,
self.ssid,
passwd="[BLANK]")
self.station_profile.set_number_template(self.number_template)
print("Creating stations")
self.station_profile.set_command_flag("add_sta", "create_admin_down",
1)
self.station_profile.set_command_param("set_port", "report_timer",
1500)
self.station_profile.set_command_flag("set_port", "rpt_timer", 1)
self.station_profile.set_wifi_extra(key_mgmt=self.key_mgmt,
eap=self.eap,
identity=self.identity,
passwd=self.ttls_passwd,
realm=self.ttls_realm,
domain=self.domain,
hessid=self.hessid)
self.station_profile.create(radio=self.radio,
sta_names_=self.sta_list,
debug=self.debug,
use_radius=True,
hs20_enable=False)
self._pass("PASS: Station build finished")
def start(self):
if self.station_profile is None:
self._fail("Incorrect setup")
pprint.pprint(self.station_profile)
if self.station_profile.up is None:
self._fail("Incorrect station profile, missing profile.up")
if self.station_profile.up == False:
print("\nBringing ports up...")
data = {
"shelf": 1,
"resource": self.resource,
"port": "ALL",
"probe_flags": 1
}
self.json_post("/cli-json/nc_show_ports", data)
self.station_profile.admin_up()
LFUtils.waitUntilPortsAdminUp(self.resource, self.lfclient_url,
self.station_names)
# station_info = self.jsonGet(self.mgr_url, "%s?fields=port,ip,ap" % (self.getStaUrl()))
duration = 0
maxTime = 30
ip = "0.0.0.0"
ap = ""
print("Waiting for %s stations to associate to AP: " %
len(self.station_names),
end="")
connected_stations = {}
while (len(connected_stations.keys()) < len(
self.station_names)) and (duration < maxTime):
duration += 3
time.sleep(10)
print(".", end="")
for sta_name in self.station_names:
sta_url = self.get_station_url(sta_name)
station_info = self.json_get(sta_url + "?fields=port,ip,ap")
# LFUtils.debug_printer.pprint(station_info)
if (station_info is not None) and ("interface"
in station_info):
if "ip" in station_info["interface"]:
ip = station_info["interface"]["ip"]
if "ap" in station_info["interface"]:
ap = station_info["interface"]["ap"]
if (ap == "Not-Associated") or (ap == ""):
if self.debug:
print(" -%s," % sta_name, end="")
else:
if ip == "0.0.0.0":
if self.debug:
print(" %s (0.0.0.0)" % sta_name, end="")
else:
connected_stations[sta_name] = sta_url
data = {
"shelf": 1,
"resource": self.resource,
"port": "ALL",
"probe_flags": 1
}
self.json_post("/cli-json/nc_show_ports", data)
for sta_name in self.station_names:
sta_url = self.get_station_url(sta_name)
station_info = self.json_get(sta_url) # + "?fields=port,ip,ap")
if station_info is None:
print("unable to query %s" % sta_url)
self.resulting_stations[sta_url] = station_info
ap = station_info["interface"]["ap"]
ip = station_info["interface"]["ip"]
if (ap != "") and (ap != "Not-Associated"):
print(" %s +AP %s, " % (sta_name, ap), end="")
if self.dut_bssid != "":
if self.dut_bssid.lower() == ap.lower():
self._pass(sta_name + " connected to BSSID: " + ap)
# self.test_results.append("PASSED: )
# print("PASSED: Connected to BSSID: "+ap)
else:
self._fail(
"%s connected to wrong BSSID, requested: %s Actual: %s"
% (sta_name, self.dut_bssid, ap))
else:
self._fail(sta_name + " did not connect to AP")
return False
if ip == "0.0.0.0":
self._fail("%s did not get an ip. Ending test" % sta_name)
else:
self._pass("%s connected to AP: %s With IP: %s" %
(sta_name, ap, ip))
if self.passes() == False:
if self.cleanup_on_exit:
print("Cleaning up...")
self.remove_stations()
return False
def udp_profile(self, side_a_min_bps, side_b_min_bps, side_a_min_pdu,
side_b_min_pdu):
# Create UDP endpoint - Alex's code!
self.l3_udp_tput_profile = self.localrealm.new_l3_cx_profile()
self.l3_udp_tput_profile.side_a_min_bps = side_a_min_bps
self.l3_udp_tput_profile.side_b_min_bps = side_b_min_bps
self.l3_udp_tput_profile.side_a_min_pdu = side_a_min_pdu
self.l3_udp_tput_profile.side_b_min_pdu = side_b_min_pdu
self.l3_udp_tput_profile.report_timer = 1000
self.l3_udp_tput_profile.name_prefix = "udp"
self.l3_udp_tput_profile.create(
endp_type="lf_udp",
side_a=list(self.localrealm.find_ports_like("tput+")),
side_b="%d.%s" % (self.resource, self.upstream_port),
suppress_related_commands=True)
def tcp_profile(self, side_a_min_bps, side_b_min_bps):
# Create TCP endpoints - original code!
self.l3_tcp_tput_profile = self.localrealm.new_l3_cx_profile()
self.l3_tcp_tput_profile.side_a_min_bps = side_a_min_bps
self.l3_tcp_tput_profile.side_b_min_bps = side_b_min_bps
self.l3_tcp_tput_profile.name_prefix = "tcp"
self.l3_tcp_tput_profile.report_timer = 1000
self.l3_tcp_tput_profile.create(
endp_type="lf_tcp",
side_a=list(self.localrealm.find_ports_like("tput+")),
side_b="%d.%s" % (self.resource, self.upstream_port),
suppress_related_commands=True)
# Start UDP Downstream Traffic
def udp_throughput(self):
print("\nStarting UDP Traffic")
self.l3_udp_tput_profile.start_cx()
time.sleep(1)
self.l3_udp_tput_profile.refresh_cx()
def tcp_throughput(self):
print("\nStarting TCP Traffic")
self.l3_tcp_tput_profile.start_cx()
time.sleep(1)
self.l3_tcp_tput_profile.refresh_cx()
def udp_stop(self):
# stop cx traffic
print("Stopping CX Traffic")
self.l3_udp_tput_profile.stop_cx()
# Refresh stats
print("\nRefresh CX stats")
self.l3_udp_tput_profile.refresh_cx()
print("Sleeping for 5 seconds")
time.sleep(5)
# get data for endpoints JSON
return self.collect_client_stats(self.l3_udp_tput_profile.created_cx)
# print("\n")
def tcp_stop(self):
# stop cx traffic
print("Stopping CX Traffic")
self.l3_tcp_tput_profile.stop_cx()
# Refresh stats
print("\nRefresh CX stats")
self.l3_tcp_tput_profile.refresh_cx()
print("Sleeping for 5 seconds")
time.sleep(5)
# get data for endpoints JSON
return self.collect_client_stats(self.l3_tcp_tput_profile.created_cx)
# print("\n")
# New Endpoint code to print TX and RX numbers
def collect_client_stats(self, endp_map):
print("Collecting Data")
fields = "?fields=name,tx+bytes,rx+bytes"
for (cx_name, endps) in endp_map.items():
try:
endp_url = "/endp/%s%s" % (endps[0], fields)
endp_json = self.json_get(endp_url)
self.resulting_endpoints[endp_url] = endp_json
ptest_a_tx = endp_json['endpoint']['tx bytes']
ptest_a_rx = endp_json['endpoint']['rx bytes']
# ptest = self.json_get("/endp/%s?fields=tx+bytes,rx+bytes" % cx_names[cx_name]["b"])
endp_url = "/endp/%s%s" % (endps[1], fields)
endp_json = self.json_get(endp_url)
self.resulting_endpoints[endp_url] = endp_json
ptest_b_tx = endp_json['endpoint']['tx bytes']
ptest_b_rx = endp_json['endpoint']['rx bytes']
byte_values = []
byte_values.append("Station TX: " + str(ptest_a_tx))
byte_values.append("Station RX: " + str(ptest_a_rx))
byte_values.append("AP TX: " + str(ptest_b_tx))
byte_values.append("AP RX: " + str(ptest_b_rx))
return byte_values
except Exception as e:
self.error(e)
def cleanup_udp(self):
# remove all endpoints and cxs
if self.cleanup_on_exit:
for sta_name in self.station_names:
LFUtils.removePort(self.resource, sta_name, self.lfclient_url)
curr_endp_names = []
removeCX(self.lfclient_url,
self.l3_udp_tput_profile.get_cx_names())
for (cx_name,
endp_names) in self.l3_udp_tput_profile.created_cx.items():
curr_endp_names.append(endp_names[0])
curr_endp_names.append(endp_names[1])
removeEndps(self.lfclient_url, curr_endp_names, debug=self.debug)
def cleanup_tcp(self):
# remove all endpoints and cxs
if self.cleanup_on_exit:
for sta_name in self.station_names:
LFUtils.removePort(self.resource, sta_name, self.lfclient_url)
curr_endp_names = []
removeCX(self.lfclient_url,
self.l3_tcp_tput_profile.get_cx_names())
for (cx_name,
endp_names) in self.l3_tcp_tput_profile.created_cx.items():
curr_endp_names.append(endp_names[0])
curr_endp_names.append(endp_names[1])
removeEndps(self.lfclient_url, curr_endp_names, debug=self.debug)
def cleanup(self):
# remove all endpoints and cxs
if self.cleanup_on_exit:
for sta_name in self.station_names:
LFUtils.removePort(self.resource, sta_name, self.lfclient_url)
curr_endp_names = []
removeCX(self.lfclient_url,
self.l3_tcp_tput_profile.get_cx_names())
removeCX(self.lfclient_url,
self.l3_udp_tput_profile.get_cx_names())
for (cx_name,
endp_names) in self.l3_tcp_tput_profile.created_cx.items():
curr_endp_names.append(endp_names[0])
curr_endp_names.append(endp_names[1])
for (cx_name,
endp_names) in self.l3_udp_tput_profile.created_cx.items():
curr_endp_names.append(endp_names[0])
curr_endp_names.append(endp_names[1])
removeEndps(self.lfclient_url, curr_endp_names, debug=self.debug)
def udp_unidirectional(self, side_a_min_bps, side_b_min_bps,
side_a_min_pdu, side_b_min_pdu, direction,
values_line):
self.udp_profile(side_a_min_bps, side_b_min_bps, side_a_min_pdu,
side_b_min_pdu)
self.start()
print("Running", direction,
"Traffic for %s seconds" % self.runtime_secs)
self.udp_throughput()
print("napping %f sec" % self.runtime_secs)
time.sleep(self.runtime_secs)
values = self.udp_stop()
print(values)
# Get value required for measurement
bytes = values[values_line]
# Get value in Bits and convert to Mbps
bits = (int(bytes.split(": ", 1)[1])) * 8
mpbs = round((bits / 1000000) / self.runtime_secs, 2)
return mpbs
def tcp_unidirectional(self, side_a_min_bps, side_b_min_bps, direction,
values_line):
self.tcp_profile(side_a_min_bps, side_b_min_bps)
self.start()
print("Running", direction,
"Traffic for %s seconds" % self.runtime_secs)
self.tcp_throughput()
print("napping %f sec" % self.runtime_secs)
time.sleep(self.runtime_secs)
values = self.tcp_stop()
print(values)
# Get value required for measurement
bytes = values[values_line]
# Get value in Bits and convert to Mbps
bits = (int(bytes.split(": ", 1)[1])) * 8
mpbs = round((bits / 1000000) / self.runtime_secs, 2)
return mpbs
class CreateSTA_CX(LFCliBase):
def __init__(self,
host,
port,
radio,
num_sta,
sta_id,
ssid,
security,
password,
upstream,
protocol,
min_bps,
max_bps,
security_debug_on=True,
_exit_on_error=True,
_exit_on_fail=True):
super().__init__(host,
port,
_debug=security_debug_on,
_halt_on_error=_exit_on_error,
_exit_on_fail=_exit_on_fail)
self.host = host
self.port = port
self.radio = radio
self.num_sta = num_sta
self.sta_id = sta_id
self.ssid = ssid
self.security = security
self.password = password
self.upstream = upstream
self.protocol = protocol
self.min_bps = min_bps
self.max_bps = max_bps
#Creating a Realm Object
self.local_realm = Realm(lfclient_host=host, lfclient_port=port)
#Creating Profile Objects
self.station_profile = self.local_realm.new_station_profile()
self.cx_profile = self.local_realm.new_l3_cx_profile()
#Setting CX Name
self.cx_profile.name_prefix_ = "Connection"
self.cx_names = []
self.sta_list = []
self.endp = []
for i in range(sta_id, sta_id + num_sta):
self.sta_list.append("sta00")
#portDhcpUpRequest
'''
upstream_dhcp = LFRequest.LFRequest("http://"+str(host)+":"+str(port)+"/"+"/cli-form/set_port")
upstream_dhcp.addPostData( LFUtils.portSetDhcpDownRequest(1, upstream))
upstream_dhcp.formPost()
time.sleep(2)
upstream_dhcp.addPostData( LFUtils.portUpRequest(1, upstream))
upstream_dhcp.formPost()
print(upstream + "Set to DHCP For Cross Connects")
'''
def build(self):
#Creating Stations of Given Profile Settings
self.station_profile.use_security(self.security,
self.ssid,
passwd=self.password)
self.station_profile.create(self.radio,
num_stations=self.num_sta,
sta_names_=self.sta_list)
self.station_profile.admin_up()
#Wait for a while
time.sleep(15)
#Setting up the Parameters for CX
self.cx_profile.side_a_min_bps = self.min_bps
self.cx_profile.side_b_min_bps = self.min_bps
self.cx_profile.side_a_max_bps = self.max_bps
self.cx_profile.side_b_max_bps = self.max_bps
self.cx_profile.side_a_min_pdu = 'Auto'
self.cx_profile.side_b_min_pdu = 'Auto'
self.cx_profile.report_timer = 1000
self.cx_profile.side_a_min_pkt = 'Same'
self.cx_profile.side_a_max_pkt = 'Same'
#Create Connections of Given Parameters
self.cx_profile.create(self.protocol,
side_a="1.1." + self.upstream,
side_b=list(
self.local_realm.find_ports_like("sta0+")))
time.sleep(15)
# Getting all the Endpoint Names for measuring Throughput Later
for i in self.cx_profile.get_cx_names():
self.cx_names.append(i)
for j in self.cx_names:
x = self.local_realm.json_get("/cx/" + j)
self.endp.append(x.get(j).get('endpoints')[1])
#print(self.endp)
return 0
def start(self):
#self.station_profile.admin_up()
self.cx_profile.start_cx()
time.sleep(5)
return 0
def stop(self):
self.cx_profile.stop_cx()
time.sleep(5)
self.lf_stations.admin_down()
time.sleep(5)
return 0
def cleanup(self):
# Removing Connections
self.local_realm.cleanup_cxe_prefix(self.cx_profile.name_prefix)
vap = self.local_realm.find_ports_like("vap+")
bridges = self.local_realm.find_ports_like("br+")
station_map = self.local_realm.find_ports_like("sta+")
#Removing Bridges
for eid, record in bridges.items():
self.local_realm.remove_vlan_by_eid(eid)
time.sleep(0.03)
#Removing VAP
for eid, record in vap.items():
self.local_realm.remove_vlan_by_eid(eid)
time.sleep(0.03)
#Removing stations
for eid, record in station_map.items():
self.local_realm.remove_vlan_by_eid(eid)
time.sleep(0.03)
del_sta_names = []
try:
for eid, value in station_map.items():
tname = eid[eid.rfind('.'):]
del_sta_names.append(tname)
except Exception as x:
self.local_realm.error(x)
try:
LFUtils.waitUntilPortsDisappear(
base_url=self.local_realm.lfclient_url,
port_list=del_sta_names,
debug=True)
print("Ports Successfully Cleaned up")
return 0
except:
print("Ports Successfully Cleaned up")
time.sleep(5)
return 0
class SingleClient(LFCliBase):
def __init__(self,
host,
port,
_dut_ssid="jedway-open-1",
_dut_passwd="NA",
_dut_bssid="",
_user="",
_passwd="",
_sta_mode="0",
_radio="wiphy0",
_resource=1,
_upstream_resource=1,
_upstream_port="eth1",
_sta_name=None,
debug_=False,
_dut_security=OPEN,
_exit_on_error=False,
_cleanup_on_exit=True,
_runtime_sec=60,
_exit_on_fail=False):
# do not use `super(LFCLiBase,self).__init__(self, host, port, _debugOn)
# that is py2 era syntax and will force self into the host variable, making you
# very confused.
super().__init__(host,
port,
_debug=debug_,
_halt_on_error=_exit_on_error,
_exit_on_fail=_exit_on_fail)
self.debug = debug_
self.dut_security = _dut_security
self.dut_ssid = _dut_ssid
self.dut_passwd = _dut_passwd
self.dut_bssid = _dut_bssid
self.user = _user
self.passwd = _passwd
self.sta_mode = _sta_mode # See add_sta LANforge CLI users guide entry
self.radio = _radio
self.resource = _resource
self.upstream_resource = _upstream_resource
self.upstream_port = _upstream_port
self.runtime_secs = _runtime_sec
self.cleanup_on_exit = _cleanup_on_exit
self.sta_url_map = None # defer construction
self.upstream_url = None # defer construction
self.station_names = []
if _sta_name is not None:
self.station_names = [_sta_name]
# self.localrealm :Realm = Realm(lfclient_host=host, lfclient_port=port) # py > 3.6
self.localrealm = Realm(lfclient_host=host,
lfclient_port=port) # py > 3.6
self.resulting_stations = {}
self.resulting_endpoints = {}
self.station_profile = None
self.l3_udp_profile = None
self.l3_tcp_profile = None
# def get_realm(self) -> Realm: # py > 3.6
def get_realm(self):
return self.localrealm
def get_station_url(self, sta_name_=None):
if sta_name_ is None:
raise ValueError("get_station_url wants a station name")
if self.sta_url_map is None:
self.sta_url_map = {}
for sta_name in self.station_names:
self.sta_url_map[sta_name] = "port/1/%s/%s" % (self.resource,
sta_name)
return self.sta_url_map[sta_name_]
def get_upstream_url(self):
if self.upstream_url is None:
self.upstream_url = "port/1/%s/%s" % (self.upstream_resource,
self.upstream_port)
return self.upstream_url
# Compare pre-test values to post-test values
def compare_vals(self, name, postVal, print_pass=False, print_fail=True):
# print(f"Comparing {name}")
if postVal > 0:
self._pass("%s %s" % (name, postVal), print_pass)
else:
self._fail("%s did not report traffic: %s" % (name, postVal),
print_fail)
def remove_stations(self):
for name in self.station_names:
LFUtils.removePort(self.resource, name, self.lfclient_url)
def num_associated(self, bssid):
counter = 0
# print("there are %d results" % len(self.station_results))
fields = "_links,port,alias,ip,ap,port+type"
self.station_results = self.localrealm.find_ports_like("sta*",
fields,
debug_=False)
if (self.station_results is None) or (len(self.station_results) < 1):
self.get_failed_result_list()
for eid, record in self.station_results.items():
#print("-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ")
#pprint(eid)
#pprint(record)
if record["ap"] == bssid:
counter += 1
#print("-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ")
return counter
def clear_test_results(self):
self.resulting_stations = {}
self.resulting_endpoints = {}
super().clear_test_results()
#super(StaConnect, self).clear_test_results().test_results.clear()
def setup(self):
self.clear_test_results()
self.check_connect()
upstream_json = self.json_get("%s?fields=alias,phantom,down,port,ip" %
self.get_upstream_url(),
debug_=False)
if upstream_json is None:
self._fail(message="Unable to query %s, bye" % self.upstream_port,
print_=True)
return False
if upstream_json['interface']['ip'] == "0.0.0.0":
if self.debug:
pprint.pprint(upstream_json)
self._fail("Warning: %s lacks ip address" %
self.get_upstream_url(),
print_=True)
return False
# remove old stations
print("Removing old stations")
for sta_name in self.station_names:
sta_url = self.get_station_url(sta_name)
response = self.json_get(sta_url)
if (response is not None) and (response["interface"] is not None):
for sta_name in self.station_names:
LFUtils.removePort(self.resource, sta_name,
self.lfclient_url)
LFUtils.wait_until_ports_disappear(self.lfclient_url,
self.station_names)
# Create stations and turn dhcp on
self.station_profile = self.localrealm.new_station_profile()
if self.dut_security == WPA2:
self.station_profile.use_security(security_type="wpa2",
ssid=self.dut_ssid,
passwd=self.dut_passwd)
elif self.dut_security == WPA:
self.station_profile.use_security(security_type="wpa",
ssid=self.dut_ssid,
passwd=self.dut_passwd)
elif self.dut_security == OPEN:
self.station_profile.use_security(security_type="open",
ssid=self.dut_ssid,
passwd="[BLANK]")
elif self.dut_security == WPA:
self.station_profile.use_security(security_type="wpa",
ssid=self.dut_ssid,
passwd=self.dut_passwd)
elif self.dut_security == WEP:
self.station_profile.use_security(security_type="wep",
ssid=self.dut_ssid,
passwd=self.dut_passwd)
self.station_profile.set_command_flag("add_sta", "create_admin_down",
1)
print("Adding new stations ", end="")
self.station_profile.create(radio=self.radio,
sta_names_=self.station_names,
up_=False,
debug=self.debug,
suppress_related_commands_=True)
LFUtils.wait_until_ports_appear(self.lfclient_url,
self.station_names,
debug=self.debug)
def start(self):
if self.station_profile is None:
self._fail("Incorrect setup")
pprint.pprint(self.station_profile)
if self.station_profile.up is None:
self._fail("Incorrect station profile, missing profile.up")
if self.station_profile.up == False:
print("\nBringing ports up...")
data = {
"shelf": 1,
"resource": self.resource,
"port": "ALL",
"probe_flags": 1
}
self.json_post("/cli-json/nc_show_ports", data)
self.station_profile.admin_up()
LFUtils.waitUntilPortsAdminUp(self.resource, self.lfclient_url,
self.station_names)
# station_info = self.jsonGet(self.mgr_url, "%s?fields=port,ip,ap" % (self.getStaUrl()))
duration = 0
maxTime = 100
ip = "0.0.0.0"
ap = ""
print("Waiting for %s stations to associate to AP: " %
len(self.station_names),
end="")
connected_stations = {}
while (len(connected_stations.keys()) < len(
self.station_names)) and (duration < maxTime):
duration += 3
time.sleep(10)
print(".", end="")
for sta_name in self.station_names:
sta_url = self.get_station_url(sta_name)
station_info = self.json_get(sta_url + "?fields=port,ip,ap")
# LFUtils.debug_printer.pprint(station_info)
if (station_info is not None) and ("interface"
in station_info):
if "ip" in station_info["interface"]:
ip = station_info["interface"]["ip"]
if "ap" in station_info["interface"]:
ap = station_info["interface"]["ap"]
if (ap == "Not-Associated") or (ap == ""):
if self.debug:
print(" -%s," % sta_name, end="")
else:
if ip == "0.0.0.0":
if self.debug:
print(" %s (0.0.0.0)" % sta_name, end="")
else:
connected_stations[sta_name] = sta_url
data = {
"shelf": 1,
"resource": self.resource,
"port": "ALL",
"probe_flags": 1
}
self.json_post("/cli-json/nc_show_ports", data)
for sta_name in self.station_names:
sta_url = self.get_station_url(sta_name)
station_info = self.json_get(sta_url) # + "?fields=port,ip,ap")
if station_info is None:
print("unable to query %s" % sta_url)
self.resulting_stations[sta_url] = station_info
ap = station_info["interface"]["ap"]
ip = station_info["interface"]["ip"]
if (ap != "") and (ap != "Not-Associated"):
print(" %s +AP %s, " % (sta_name, ap), end="")
if self.dut_bssid != "":
if self.dut_bssid.lower() == ap.lower():
self._pass(sta_name + " connected to BSSID: " + ap)
# self.test_results.append("PASSED: )
# print("PASSED: Connected to BSSID: "+ap)
else:
self._fail(
"%s connected to wrong BSSID, requested: %s Actual: %s"
% (sta_name, self.dut_bssid, ap))
else:
self._fail(sta_name + " did not connect to AP")
return False
if ip == "0.0.0.0":
self._fail("%s did not get an ip. Ending test" % sta_name)
else:
self._pass("%s connected to AP: %s With IP: %s" %
(sta_name, ap, ip))
if self.passes() == False:
if self.cleanup_on_exit:
print("Cleaning up...")
self.remove_stations()
return False
def udp_profile(self, side_a_min_bps, side_b_min_bps, side_a_min_pdu,
side_b_min_pdu):
# Create UDP endpoint - Alex's code!
self.l3_udp_tput_profile = self.localrealm.new_l3_cx_profile()
self.l3_udp_tput_profile.side_a_min_bps = side_a_min_bps
self.l3_udp_tput_profile.side_b_min_bps = side_b_min_bps
self.l3_udp_tput_profile.side_a_min_pdu = side_a_min_pdu
self.l3_udp_tput_profile.side_b_min_pdu = side_b_min_pdu
self.l3_udp_tput_profile.report_timer = 1000
self.l3_udp_tput_profile.name_prefix = "udp"
self.l3_udp_tput_profile.create(
endp_type="lf_udp",
side_a=list(self.localrealm.find_ports_like("tput+")),
side_b="%d.%s" % (self.resource, self.upstream_port),
suppress_related_commands=True)
def tcp_profile(self, side_a_min_bps, side_b_min_bps):
# Create TCP endpoints - original code!
self.l3_tcp_tput_profile = self.localrealm.new_l3_cx_profile()
self.l3_tcp_tput_profile.side_a_min_bps = side_a_min_bps
self.l3_tcp_tput_profile.side_b_min_bps = side_b_min_bps
self.l3_tcp_tput_profile.name_prefix = "tcp"
self.l3_tcp_tput_profile.report_timer = 1000
self.l3_tcp_tput_profile.create(
endp_type="lf_tcp",
side_a=list(self.localrealm.find_ports_like("tput+")),
side_b="%d.%s" % (self.resource, self.upstream_port),
suppress_related_commands=True)
# Start UDP Downstream Traffic
def udp_throughput(self):
print("\nStarting UDP Traffic")
self.l3_udp_tput_profile.start_cx()
time.sleep(1)
self.l3_udp_tput_profile.refresh_cx()
def tcp_throughput(self):
print("\nStarting TCP Traffic")
self.l3_tcp_tput_profile.start_cx()
time.sleep(1)
self.l3_tcp_tput_profile.refresh_cx()
def udp_stop(self):
# stop cx traffic
print("Stopping CX Traffic")
self.l3_udp_tput_profile.stop_cx()
# Refresh stats
print("\nRefresh CX stats")
self.l3_udp_tput_profile.refresh_cx()
print("Sleeping for 5 seconds")
time.sleep(5)
# get data for endpoints JSON
return self.collect_client_stats(self.l3_udp_tput_profile.created_cx)
# print("\n")
def tcp_stop(self):
# stop cx traffic
print("Stopping CX Traffic")
self.l3_tcp_tput_profile.stop_cx()
# Refresh stats
print("\nRefresh CX stats")
self.l3_tcp_tput_profile.refresh_cx()
print("Sleeping for 5 seconds")
time.sleep(5)
# get data for endpoints JSON
return self.collect_client_stats(self.l3_tcp_tput_profile.created_cx)
# print("\n")
# New Endpoint code to print TX and RX numbers
def collect_client_stats(self, endp_map):
print("Collecting Data")
fields = "?fields=name,tx+bytes,rx+bytes"
for (cx_name, endps) in endp_map.items():
try:
endp_url = "/endp/%s%s" % (endps[0], fields)
endp_json = self.json_get(endp_url)
self.resulting_endpoints[endp_url] = endp_json
ptest_a_tx = endp_json['endpoint']['tx bytes']
ptest_a_rx = endp_json['endpoint']['rx bytes']
# ptest = self.json_get("/endp/%s?fields=tx+bytes,rx+bytes" % cx_names[cx_name]["b"])
endp_url = "/endp/%s%s" % (endps[1], fields)
endp_json = self.json_get(endp_url)
self.resulting_endpoints[endp_url] = endp_json
ptest_b_tx = endp_json['endpoint']['tx bytes']
ptest_b_rx = endp_json['endpoint']['rx bytes']
byte_values = []
byte_values.append("Station TX: " + str(ptest_a_tx))
byte_values.append("Station RX: " + str(ptest_a_rx))
byte_values.append("AP TX: " + str(ptest_b_tx))
byte_values.append("AP RX: " + str(ptest_b_rx))
return byte_values
except Exception as e:
self.error(e)
def cleanup_udp(self):
# remove all endpoints and cxs
if self.cleanup_on_exit:
for sta_name in self.station_names:
LFUtils.removePort(self.resource, sta_name, self.lfclient_url)
curr_endp_names = []
removeCX(self.lfclient_url,
self.l3_udp_tput_profile.get_cx_names())
for (cx_name,
endp_names) in self.l3_udp_tput_profile.created_cx.items():
curr_endp_names.append(endp_names[0])
curr_endp_names.append(endp_names[1])
removeEndps(self.lfclient_url, curr_endp_names, debug=self.debug)
def cleanup_tcp(self):
# remove all endpoints and cxs
if self.cleanup_on_exit:
for sta_name in self.station_names:
LFUtils.removePort(self.resource, sta_name, self.lfclient_url)
curr_endp_names = []
removeCX(self.lfclient_url,
self.l3_tcp_tput_profile.get_cx_names())
for (cx_name,
endp_names) in self.l3_tcp_tput_profile.created_cx.items():
curr_endp_names.append(endp_names[0])
curr_endp_names.append(endp_names[1])
removeEndps(self.lfclient_url, curr_endp_names, debug=self.debug)
def cleanup(self):
# remove all endpoints and cxs
if self.cleanup_on_exit:
for sta_name in self.station_names:
LFUtils.removePort(self.resource, sta_name, self.lfclient_url)
curr_endp_names = []
removeCX(self.lfclient_url,
self.l3_tcp_tput_profile.get_cx_names())
removeCX(self.lfclient_url,
self.l3_udp_tput_profile.get_cx_names())
for (cx_name,
endp_names) in self.l3_tcp_tput_profile.created_cx.items():
curr_endp_names.append(endp_names[0])
curr_endp_names.append(endp_names[1])
for (cx_name,
endp_names) in self.l3_udp_tput_profile.created_cx.items():
curr_endp_names.append(endp_names[0])
curr_endp_names.append(endp_names[1])
removeEndps(self.lfclient_url, curr_endp_names, debug=self.debug)
def udp_unidirectional(self, side_a_min_bps, side_b_min_bps,
side_a_min_pdu, side_b_min_pdu, direction,
values_line):
self.udp_profile(side_a_min_bps, side_b_min_bps, side_a_min_pdu,
side_b_min_pdu)
self.start()
print("Running", direction,
"Traffic for %s seconds" % self.runtime_secs)
self.udp_throughput()
print("napping %f sec" % self.runtime_secs)
time.sleep(self.runtime_secs)
values = self.udp_stop()
print(values)
# Get value required for measurement
bytes = values[values_line]
# Get value in Bits and convert to Mbps
bits = (int(bytes.split(": ", 1)[1])) * 8
mpbs = round((bits / 1000000) / self.runtime_secs, 2)
return mpbs
def tcp_unidirectional(self, side_a_min_bps, side_b_min_bps, direction,
values_line):
self.tcp_profile(side_a_min_bps, side_b_min_bps)
self.start()
print("Running", direction,
"Traffic for %s seconds" % self.runtime_secs)
self.tcp_throughput()
print("napping %f sec" % self.runtime_secs)
time.sleep(self.runtime_secs)
values = self.tcp_stop()
print(values)
# Get value required for measurement
bytes = values[values_line]
# Get value in Bits and convert to Mbps
bits = (int(bytes.split(": ", 1)[1])) * 8
mpbs = round((bits / 1000000) / self.runtime_secs, 2)
return mpbs
def throughput_csv(csv_file, ssid_name, ap_model, firmware, security,
udp_ds, udp_us, tcp_ds, tcp_us):
# Find band for CSV ---> This code is not great, it SHOULD get that info from LANForge!
if "5G" in ssid_name:
frequency = "5 GHz"
elif "2dot4G" in ssid_name:
frequency = "2.4 GHz"
else:
frequency = "Unknown"
# Append row to top of CSV file
row = [
ap_model, firmware, frequency, security, udp_ds, udp_us, tcp_ds,
tcp_us
]
with open(csv_file, 'r') as readFile:
reader = csv.reader(readFile)
lines = list(reader)
lines.insert(1, row)
with open(csv_file, 'w') as writeFile:
writer = csv.writer(writeFile)
writer.writerows(lines)
readFile.close()
writeFile.close()
class StaConnect2(LFCliBase):
def __init__(self,
host,
port,
_dut_ssid="jedway-open-1",
_dut_passwd="NA",
_dut_bssid="",
_user="",
_passwd="",
_sta_mode="0",
_radio="wiphy0",
_resource=1,
_upstream_resource=1,
_upstream_port="eth1",
_sta_name=None,
_sta_prefix='sta',
_bringup_time_sec=300,
debug_=False,
_dut_security=OPEN,
_exit_on_error=False,
_cleanup_on_exit=True,
_clean_all_sta=False,
_runtime_sec=60,
_exit_on_fail=False):
# do not use `super(LFCLiBase,self).__init__(self, host, port, _debugOn)
# that is py2 era syntax and will force self into the host variable, making you
# very confused.
super().__init__(host,
port,
_debug=debug_,
_halt_on_error=_exit_on_error,
_exit_on_fail=_exit_on_fail)
self.debug = debug_
self.dut_security = _dut_security
self.dut_ssid = _dut_ssid
self.dut_passwd = _dut_passwd
self.dut_bssid = _dut_bssid
self.user = _user
self.passwd = _passwd
self.sta_mode = _sta_mode # See add_sta LANforge CLI users guide entry
self.radio = _radio
self.resource = _resource
self.upstream_resource = _upstream_resource
self.upstream_port = _upstream_port
self.runtime_secs = _runtime_sec
self.cleanup_on_exit = _cleanup_on_exit
self.clean_all_sta = _clean_all_sta
self.sta_url_map = None # defer construction
self.upstream_url = None # defer construction
self.station_names = []
if _sta_name is not None:
self.station_names = [_sta_name]
self.sta_prefix = _sta_prefix
self.bringup_time_sec = _bringup_time_sec
# self.localrealm :Realm = Realm(lfclient_host=host, lfclient_port=port) # py > 3.6
self.localrealm = Realm(lfclient_host=host,
lfclient_port=port) # py > 3.6
self.resulting_stations = {}
self.resulting_endpoints = {}
self.station_profile = None
self.l3_udp_profile = None
self.l3_tcp_profile = None
# def get_realm(self) -> Realm: # py > 3.6
def get_realm(self):
return self.localrealm
def get_station_url(self, sta_name_=None):
if sta_name_ is None:
raise ValueError("get_station_url wants a station name")
if self.sta_url_map is None:
self.sta_url_map = {}
for sta_name in self.station_names:
self.sta_url_map[sta_name] = "port/1/%s/%s" % (self.resource,
sta_name)
return self.sta_url_map[sta_name_]
def get_upstream_url(self):
if self.upstream_url is None:
self.upstream_url = "port/1/%s/%s" % (self.upstream_resource,
self.upstream_port)
return self.upstream_url
# Compare pre-test values to post-test values
def compare_vals(self, name, postVal, print_pass=False, print_fail=True):
# print(f"Comparing {name}")
if postVal > 0:
self._pass("%s %s" % (name, postVal), print_pass)
else:
self._fail("%s did not report traffic: %s" % (name, postVal),
print_fail)
def remove_stations(self):
for name in self.station_names:
LFUtils.removePort(self.resource, name, self.lfclient_url)
def num_associated(self, bssid):
counter = 0
# print("there are %d results" % len(self.station_results))
fields = "_links,port,alias,ip,ap,port+type"
self.station_results = self.localrealm.find_ports_like("%s*" %
self.sta_prefix,
fields,
debug_=False)
if (self.station_results is None) or (len(self.station_results) < 1):
self.get_failed_result_list()
for eid, record in self.station_results.items():
#print("-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ")
#pprint(eid)
#pprint(record)
if record["ap"] == bssid:
counter += 1
#print("-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ")
return counter
def clear_test_results(self):
self.resulting_stations = {}
self.resulting_endpoints = {}
super().clear_test_results()
#super(StaConnect, self).clear_test_results().test_results.clear()
def setup(self):
self.clear_test_results()
self.check_connect()
upstream_json = self.json_get("%s?fields=alias,phantom,down,port,ip" %
self.get_upstream_url(),
debug_=False)
if upstream_json is None:
self._fail(message="Unable to query %s, bye" % self.upstream_port,
print_=True)
return False
if upstream_json['interface']['ip'] == "0.0.0.0":
if self.debug:
pprint.pprint(upstream_json)
self._fail("Warning: %s lacks ip address" %
self.get_upstream_url(),
print_=True)
return False
# remove old stations
if self.clean_all_sta:
print("Removing all stations on resource.")
self.localrealm.remove_all_stations(self.resource)
else:
print("Removing old stations to be created by this test.")
for sta_name in self.station_names:
sta_url = self.get_station_url(sta_name)
response = self.json_get(sta_url)
if (response is not None) and (response["interface"]
is not None):
for sta_name in self.station_names:
LFUtils.removePort(self.resource, sta_name,
self.lfclient_url)
LFUtils.wait_until_ports_disappear(self.lfclient_url,
self.station_names)
# Create stations and turn dhcp on
self.station_profile = self.localrealm.new_station_profile()
if self.dut_security == WPA2:
self.station_profile.use_security(security_type="wpa2",
ssid=self.dut_ssid,
passwd=self.dut_passwd)
elif self.dut_security == OPEN:
self.station_profile.use_security(security_type="open",
ssid=self.dut_ssid,
passwd="[BLANK]")
elif self.dut_security == WPA:
self.station_profile.use_security(security_type="wpa",
ssid=self.dut_ssid,
passwd=self.dut_passwd)
elif self.dut_security == WEP:
self.station_profile.use_security(security_type="wep",
ssid=self.dut_ssid,
passwd=self.dut_passwd)
self.station_profile.set_command_flag("add_sta", "create_admin_down",
1)
print("Adding new stations ", end="")
self.station_profile.create(radio=self.radio,
sta_names_=self.station_names,
up_=False,
debug=self.debug,
suppress_related_commands_=True)
LFUtils.wait_until_ports_appear(self.lfclient_url,
self.station_names,
debug=self.debug)
# Create UDP endpoints
self.l3_udp_profile = self.localrealm.new_l3_cx_profile()
self.l3_udp_profile.side_a_min_bps = 128000
self.l3_udp_profile.side_b_min_bps = 128000
self.l3_udp_profile.side_a_min_pdu = 1200
self.l3_udp_profile.side_b_min_pdu = 1500
self.l3_udp_profile.report_timer = 1000
self.l3_udp_profile.name_prefix = "udp"
port_list = list(
self.localrealm.find_ports_like("%s+" % self.sta_prefix))
if (port_list is None) or (len(port_list) < 1):
raise ValueError("Unable to find ports named '%s'+" %
self.sta_prefix)
self.l3_udp_profile.create(endp_type="lf_udp",
side_a=port_list,
side_b="%d.%s" %
(self.resource, self.upstream_port),
suppress_related_commands=True)
# Create TCP endpoints
self.l3_tcp_profile = self.localrealm.new_l3_cx_profile()
self.l3_tcp_profile.side_a_min_bps = 128000
self.l3_tcp_profile.side_b_min_bps = 56000
self.l3_tcp_profile.name_prefix = "tcp"
self.l3_tcp_profile.report_timer = 1000
self.l3_tcp_profile.create(
endp_type="lf_tcp",
side_a=list(
self.localrealm.find_ports_like("%s+" % self.sta_prefix)),
side_b="%d.%s" % (self.resource, self.upstream_port),
suppress_related_commands=True)
def start(self):
if self.station_profile is None:
self._fail("Incorrect setup")
pprint.pprint(self.station_profile)
if self.station_profile.up is None:
self._fail("Incorrect station profile, missing profile.up")
if self.station_profile.up == False:
print("\nBringing ports up...")
data = {
"shelf": 1,
"resource": self.resource,
"port": "ALL",
"probe_flags": 1
}
self.json_post("/cli-json/nc_show_ports", data)
self.station_profile.admin_up()
LFUtils.waitUntilPortsAdminUp(self.resource, self.lfclient_url,
self.station_names)
# station_info = self.jsonGet(self.mgr_url, "%s?fields=port,ip,ap" % (self.getStaUrl()))
duration = 0
maxTime = self.bringup_time_sec
ip = "0.0.0.0"
ap = ""
print("Waiting for %s stations to associate to AP: " %
len(self.station_names),
end="")
connected_stations = {}
while (len(connected_stations.keys()) < len(
self.station_names)) and (duration < maxTime):
duration += 3
time.sleep(3)
print(".", end="")
for sta_name in self.station_names:
sta_url = self.get_station_url(sta_name)
station_info = self.json_get(sta_url + "?fields=port,ip,ap")
# LFUtils.debug_printer.pprint(station_info)
if (station_info is not None) and ("interface"
in station_info):
if "ip" in station_info["interface"]:
ip = station_info["interface"]["ip"]
if "ap" in station_info["interface"]:
ap = station_info["interface"]["ap"]
if (ap == "Not-Associated") or (ap == ""):
if self.debug:
print(" -%s," % sta_name, end="")
else:
if ip == "0.0.0.0":
if self.debug:
print(" %s (0.0.0.0)" % sta_name, end="")
else:
connected_stations[sta_name] = sta_url
data = {
"shelf": 1,
"resource": self.resource,
"port": "ALL",
"probe_flags": 1
}
self.json_post("/cli-json/nc_show_ports", data)
for sta_name in self.station_names:
sta_url = self.get_station_url(sta_name)
station_info = self.json_get(sta_url) # + "?fields=port,ip,ap")
if station_info is None:
print("unable to query %s" % sta_url)
self.resulting_stations[sta_url] = station_info
ap = station_info["interface"]["ap"]
ip = station_info["interface"]["ip"]
if (ap != "") and (ap != "Not-Associated"):
print(" %s +AP %s, " % (sta_name, ap), end="")
if self.dut_bssid != "":
if self.dut_bssid.lower() == ap.lower():
self._pass(sta_name + " connected to BSSID: " + ap)
# self.test_results.append("PASSED: )
# print("PASSED: Connected to BSSID: "+ap)
else:
self._fail(
"%s connected to wrong BSSID, requested: %s Actual: %s"
% (sta_name, self.dut_bssid, ap))
else:
self._fail(sta_name + " did not connect to AP")
return False
if ip == "0.0.0.0":
self._fail("%s did not get an ip. Ending test" % sta_name)
else:
self._pass("%s connected to AP: %s With IP: %s" %
(sta_name, ap, ip))
if self.passes() == False:
if self.cleanup_on_exit:
print("Cleaning up...")
self.remove_stations()
return False
# start cx traffic
print("\nStarting CX Traffic")
self.l3_udp_profile.start_cx()
self.l3_tcp_profile.start_cx()
time.sleep(1)
# Refresh stats
self.l3_udp_profile.refresh_cx()
self.l3_tcp_profile.refresh_cx()
def collect_endp_stats(self, endp_map):
print("Collecting Data")
fields = "?fields=name,tx+bytes,rx+bytes"
for (cx_name, endps) in endp_map.items():
try:
endp_url = "/endp/%s%s" % (endps[0], fields)
endp_json = self.json_get(endp_url)
self.resulting_endpoints[endp_url] = endp_json
ptest_a_tx = endp_json['endpoint']['tx bytes']
ptest_a_rx = endp_json['endpoint']['rx bytes']
#ptest = self.json_get("/endp/%s?fields=tx+bytes,rx+bytes" % cx_names[cx_name]["b"])
endp_url = "/endp/%s%s" % (endps[1], fields)
endp_json = self.json_get(endp_url)
self.resulting_endpoints[endp_url] = endp_json
ptest_b_tx = endp_json['endpoint']['tx bytes']
ptest_b_rx = endp_json['endpoint']['rx bytes']
self.compare_vals("testTCP-A TX", ptest_a_tx)
self.compare_vals("testTCP-A RX", ptest_a_rx)
self.compare_vals("testTCP-B TX", ptest_b_tx)
self.compare_vals("testTCP-B RX", ptest_b_rx)
except Exception as e:
self.error(e)
def stop(self):
# stop cx traffic
print("Stopping CX Traffic")
self.l3_udp_profile.stop_cx()
self.l3_tcp_profile.stop_cx()
# Refresh stats
print("\nRefresh CX stats")
self.l3_udp_profile.refresh_cx()
self.l3_tcp_profile.refresh_cx()
print("Sleeping for 5 seconds")
time.sleep(5)
# get data for endpoints JSON
self.collect_endp_stats(self.l3_udp_profile.created_cx)
self.collect_endp_stats(self.l3_tcp_profile.created_cx)
# print("\n")
def cleanup(self):
# remove all endpoints and cxs
if self.cleanup_on_exit:
for sta_name in self.station_names:
LFUtils.removePort(self.resource, sta_name, self.lfclient_url)
curr_endp_names = []
removeCX(self.lfclient_url, self.l3_udp_profile.get_cx_names())
removeCX(self.lfclient_url, self.l3_tcp_profile.get_cx_names())
for (cx_name,
endp_names) in self.l3_udp_profile.created_cx.items():
curr_endp_names.append(endp_names[0])
curr_endp_names.append(endp_names[1])
for (cx_name,
endp_names) in self.l3_tcp_profile.created_cx.items():
curr_endp_names.append(endp_names[0])
curr_endp_names.append(endp_names[1])
removeEndps(self.lfclient_url, curr_endp_names, debug=self.debug)
