From 776bc795aee63844916171c727f09bdff8f83c8f Mon Sep 17 00:00:00 2001 From: Matthew Stidham Date: Wed, 24 Nov 2021 15:15:15 -0800 Subject: [PATCH] lf_dfs_test: Fix whitespace error Signed-off-by: Matthew Stidham --- py-scripts/lf_dfs_test.py | 2382 +++++++++++++++++++++---------------- 1 file changed, 1387 insertions(+), 995 deletions(-) diff --git a/py-scripts/lf_dfs_test.py b/py-scripts/lf_dfs_test.py index afdfc249..6db17b14 100755 --- a/py-scripts/lf_dfs_test.py +++ b/py-scripts/lf_dfs_test.py @@ -15,10 +15,10 @@ if sys.version_info[0] != 3: print("This script requires Python 3") exit(1) - sys.path.append(os.path.join(os.path.abspath(__file__ + "../../../"))) import argparse + LFUtils = importlib.import_module("py-json.LANforge.LFUtils") realm = importlib.import_module("py-json.realm") Realm = realm.Realm @@ -28,15 +28,18 @@ Realm = realm.Realm FORMAT = '%(asctime)s %(name)s %(levelname)s: %(message)s' + # see https://stackoverflow.com/a/13306095/11014343 class FileAdapter(object): def __init__(self, logger): self.logger = logger + def write(self, data): # NOTE: data can be a partial line, multiple lines - data = data.strip() # ignore leading/trailing whitespace - if data: # non-blank - self.logger.info(data) + data = data.strip() # ignore leading/trailing whitespace + if data: # non-blank + self.logger.info(data) + def flush(self): pass # leave it to logging to flush properly @@ -46,27 +49,27 @@ class FileAdapter(object): # Scaling and Performance to be self contained and not impact other tests ################################################################################ -class CreateCtlr(): +class CreateCtlr: def __init__(self, - _scheme, - _port, - _series, - _ctlr, - _prompt, - _user, - _passwd, - _ap, - _band, - _chan_5ghz, - _chan_24ghz, - _chan_width, - _ap_mode, - _tx_power, - _client_density, - _cap_ctl_out): + _scheme, + _port, + _series, + _ctlr, + _prompt, + _user, + _passwd, + _ap, + _band, + _chan_5ghz, + _chan_24ghz, + _chan_width, + _ap_mode, + _tx_power, + _client_density, + _cap_ctl_out): self.scheme = _scheme - self.port = _port + self.port = _port self.series = _series self.ctlr = _ctlr self.prompt = _prompt @@ -82,44 +85,50 @@ class CreateCtlr(): self.cap_ctl_out = _cap_ctl_out self.client_density = 0 - def verify_controller(self,client_density): + def verify_controller(self, client_density): self.client_density = client_density try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user, - self.passwd,self.ap,self.series,self.band,"summary")) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, + self.passwd, self.ap, self.series, self.band, "summary")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series,"--action", "summary"], capture_output=True) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--action", "summary"], capture_output=True) pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}" - .format(process_error.returncode, process_error.output)) + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}" + .format(process_error.returncode, process_error.output)) time.sleep(1) exit(1) - + # Find our station count searchap = False for line in pss.splitlines(): - if (line.startswith("---------")): + if line.startswith("---------"): searchap = True continue - #TODO need to test with 9800 series to chelck the values - if (searchap): - pat = "%s\s+\S+\s+\S+\s+\S+\s+\S+.* \S+\s+\S+\s+(\S+)\s+\["%(self.ap) - #logg.info("AP line: %s"%(line)) + # TODO need to test with 9800 series to chelck the values + if searchap: + pat = "%s\s+\S+\s+\S+\s+\S+\s+\S+.* \S+\s+\S+\s+(\S+)\s+\[" % self.ap + # logg.info("AP line: %s"%(line)) m = re.search(pat, line) - if (m != None): + if m != None: sta_count = m.group(1) - logg.info("AP line: %s"%(line)) - logg.info("sta-count: %s"%(sta_count)) - if (int(sta_count) != int(self.client_density)): - logg.info("WARNING: Controller reported %s stations, should be %s"%(sta_count, self.client_density)) + logg.info("AP line: %s" % line) + logg.info("sta-count: %s" % sta_count) + if int(sta_count) != int(self.client_density): + logg.info( + "WARNING: Controller reported %s stations, should be %s" % (sta_count, self.client_density)) - #show summary (to get AP) (3400/9800) - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 --action summary --series 9800 --log stdout + # show summary (to get AP) (3400/9800) + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 --action summary --series 9800 --log stdout def controller_show_summary(self): pss = "" try: @@ -134,589 +143,697 @@ class CreateCtlr(): series: {} \ band: {} \ action: {}".format( - self.scheme, - self.ctlr, - self.port, - self.prompt, - self.user, - self.passwd, - self.ap, - self.series, - self.band, - "summary")) + self.scheme, + self.ctlr, + self.port, + self.prompt, + self.user, + self.passwd, + self.ap, + self.series, + self.band, + "summary")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", - "--scheme", self.scheme, - "--prompt", self.prompt, - "--port", self.port, - "-d", self.ctlr, - "-u", self.user, - "-p", self.passwd, - "-a", self.ap, - "--series", self.series, - "--band", self.band, - "--action", "summary"], - capture_output=self.cap_ctl_out, + ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", + "--scheme", self.scheme, + "--prompt", self.prompt, + "--port", self.port, + "-d", self.ctlr, + "-u", self.user, + "-p", self.passwd, + "-a", self.ap, + "--series", self.series, + "--band", self.band, + "--action", "summary"], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}" - .format(process_error.returncode, process_error.output)) - time.sleep(1) - exit(1) + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}" + .format(process_error.returncode, process_error.output)) + time.sleep(1) + exit(1) return pss - #show ap dot11 5ghz summary (band defaults to 5ghz) --band a - #show ap dot11 24ghz summary use --band b for 2.4 ghz - #action advanced (3400/9800) - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 --action advanced --series 9800 --log stdout + # show ap dot11 5ghz summary (band defaults to 5ghz) --band a + # show ap dot11 24ghz summary use --band b for 2.4 ghz + # action advanced (3400/9800) + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 --action advanced --series 9800 --log stdout def controller_show_ap_summary(self): pss = "" try: logg.info("\ - scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user, - self.passwd,self.ap,self.series,self.band,"advanced")) + scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, + self.passwd, self.ap, self.series, self.band, "advanced")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, "--action", "advanced"], - capture_output=True, check=True) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, "--action", "advanced"], + capture_output=True, check=True) pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) return pss - #show wlan summary + # show wlan summary def controller_show_wlan_summary(self): try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user, - self.passwd,self.ap,self.series,self.band,"show wlan summary")) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, + self.passwd, self.ap, self.series, self.band, "show wlan summary")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, "--action", "show_wlan_summary"], - capture_output=self.cap_ctl_out, check=True) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, "--action", "show_wlan_summary"], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) - #disable AP - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action disable --series 9800 + # disable AP + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action disable --series 9800 def controller_disable_ap(self): try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user, - self.passwd,self.ap,self.series,self.band,"disable")) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, + self.passwd, self.ap, self.series, self.band, "disable")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", - self.ctlr, "-u",self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, "--action", "disable"], - capture_output=self.cap_ctl_out, check=True) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", + self.ctlr, "-u", self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, "--action", "disable"], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) - - #disable wlan - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action disable_wlan --series 9800 + # disable wlan + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action disable_wlan --series 9800 def controller_disable_wlan(self): try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} wlan: {} action: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user, - self.passwd,self.ap,self.series,self.band,self.wlan,"disable_wlan")) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} wlan: {} action: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, + self.passwd, self.ap, self.series, self.band, self.wlan, "disable_wlan")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band,"--wlan", self.wlan, "--action", "disable_wlan"], - capture_output=self.cap_ctl_out, check=True) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, "--wlan", self.wlan, "--action", + "disable_wlan"], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) - - #disable network 5ghz - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action disable_network_5ghz --series 9800 + # disable network 5ghz + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action disable_network_5ghz --series 9800 def controller_disable_network_5ghz(self): if self.series == "9800": try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user, - self.passwd,self.ap,self.series,self.band,"disable_network_5ghz")) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, + self.passwd, self.ap, self.series, self.band, "disable_network_5ghz")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, "--action", "disable_network_5ghz"], - capture_output=self.cap_ctl_out, check=True) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, "--action", "disable_network_5ghz"], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) else: try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} value: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user,self.passwd, self.ap, self.series, - self.band,"cmd","config 802.11a disable network")) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} value: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, self.passwd, self.ap, self.series, + self.band, "cmd", "config 802.11a disable network")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, "--action", "cmd", "--value", "config 802.11a disable network"], - capture_output=self.cap_ctl_out, check=True) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, "--action", "cmd", "--value", + "config 802.11a disable network"], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) - - #disable network 24ghz - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action disable_network_24ghz --series 9800 + # disable network 24ghz + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action disable_network_24ghz --series 9800 def controller_disable_network_24ghz(self): if self.series == "9800": try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user, - self.passwd,self.ap,self.series,self.band,"disable_network_24ghz")) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, + self.passwd, self.ap, self.series, self.band, "disable_network_24ghz")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, "--action", "disable_network_24ghz"], - capture_output=self.cap_ctl_out, check=True) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, "--action", "disable_network_24ghz"], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) else: try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} value: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user,self.passwd, self.ap, self.series, - self.band,"cmd","config 802.11b disable network")) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} value: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, self.passwd, self.ap, self.series, + self.band, "cmd", "config 802.11b disable network")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, "--action", "cmd", "--value", "config 802.11b disable network"], - capture_output=self.cap_ctl_out, check=True) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, "--action", "cmd", "--value", + "config 802.11b disable network"], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) - - - #set manual mode - Series 9800 must be set to manual mode - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action manual --series 9800 + # set manual mode - Series 9800 must be set to manual mode + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action manual --series 9800 # ap name dot11 5ghz radio role manual client-serving def controller_role_manual(self): if self.series == "9800": try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user, - self.passwd,self.ap,self.series,self.band,"manual")) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, + self.passwd, self.ap, self.series, self.band, "manual")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, "--action", "manual"], - capture_output=self.cap_ctl_out, check=True) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, "--action", "manual"], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) else: - logg.info("Check the controller scheme used attemping 9800 series on 3504 controller: {}".format(self.scheme)) + logg.info( + "Check the controller scheme used attemping 9800 series on 3504 controller: {}".format(self.scheme)) - #set manual mode - Series 9800 must be set to auto mode - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action auto --series 9800 + # set manual mode - Series 9800 must be set to auto mode + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action auto --series 9800 # ap name dot11 5ghz radio role manual client-serving def controller_role_auto(self): if self.series == "9800": try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user, - self.passwd,self.ap,self.series,self.band,"auto")) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, + self.passwd, self.ap, self.series, self.band, "auto")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, "--action", "auto"], - capture_output=self.cap_ctl_out, check=True) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, "--action", "auto"], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) else: - logg.info("Check the controller scheme used attemping 9800 series on 3504 controller: {}".format(self.scheme)) + logg.info( + "Check the controller scheme used attemping 9800 series on 3504 controller: {}".format(self.scheme)) - #test parameters summary (txPower 1-8) - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action txPower --value 5 --series 9800 + # test parameters summary (txPower 1-8) + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action txPower --value 5 --series 9800 def controller_set_tx_power(self): try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} value {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user,self.passwd, self.ap, self.series, - self.band,"txPower", self.tx_power )) # TODO fix txPower to tx_power in wifi_ctl_9800_3504.py - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, - "--action", "txPower","--value", self.tx_power], - capture_output=self.cap_ctl_out, check=True) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} value {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, self.passwd, self.ap, self.series, + self.band, "txPower", self.tx_power)) # TODO fix txPower to tx_power in wifi_ctl_9800_3504.py + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, + "--action", "txPower", "--value", self.tx_power], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) - #set channel [36, 64, 100] - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action channel --value 36 --series 9800 + # set channel [36, 64, 100] + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action channel --value 36 --series 9800 # 9800 : ap name dot11 [5ghz | 24ghz] channel # 3504 : (controller Controller) >config 802.11a channel ap APA453.0E7B.CF9C 52 def controller_set_channel(self): try: - if (self.band == "a"): + if self.band == "a": controller_channel = self.chan_5ghz else: controller_channel = self.chan_24ghz - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} value {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user,self.passwd, self.ap, self.series, - self.band,"channel", controller_channel )) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, - "--action", "channel","--value", controller_channel], - capture_output=self.cap_ctl_out, check=True) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} value {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, self.passwd, self.ap, self.series, + self.band, "channel", controller_channel)) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, + "--action", "channel", "--value", controller_channel], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) def controller_set_bandwidth_20(self): controller_chan_width_20 = "20" try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} value {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user,self.passwd, self.ap, self.series, - self.band,"channel", controller_chan_width_20 )) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, - "--action", "channel","--value", controller_chan_width_20], - capture_output=self.cap_ctl_out, check=True) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} value {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, self.passwd, self.ap, self.series, + self.band, "channel", controller_chan_width_20)) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, + "--action", "channel", "--value", controller_chan_width_20], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) - + except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) - - #set bandwidth [20 40 80 160] - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action bandwidth --value 40 --series 9800 + # set bandwidth [20 40 80 160] + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action bandwidth --value 40 --series 9800 def controller_set_bandwidth(self): try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} value {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user,self.passwd, self.ap, self.series, - self.band,"channel", self.chan_width )) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, - "--action", "channel","--value", self.chan_width], - capture_output=self.cap_ctl_out, check=True) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} value {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, self.passwd, self.ap, self.series, + self.band, "channel", self.chan_width)) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, + "--action", "channel", "--value", self.chan_width], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) - + except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) - - #create wlan - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action create_wlan --wlan "open-wlan" --wlanID 1 --series 9800 + # create wlan + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action create_wlan --wlan "open-wlan" --wlanID 1 --series 9800 def controller_create_wlan(self): if self.series == "9800": try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} wlan {} wlanID {} wlanSSID {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user,self.passwd, self.ap, self.series, - self.band,"create_wlan", self.wlan, self.wlanID, self.wlanSSID )) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, - "--action", "create_wlan","--wlan", self.wlan, "--wlanID", self.wlanID, "--wlanSSID", self.wlanSSID], - capture_output=self.cap_ctl_out, check=True) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} wlan {} wlanID {} wlanSSID {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, self.passwd, self.ap, self.series, + self.band, "create_wlan", self.wlan, self.wlanID, self.wlanSSID)) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, + "--action", "create_wlan", "--wlan", self.wlan, "--wlanID", self.wlanID, "--wlanSSID", + self.wlanSSID], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) - + except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) else: - logg.info("Check the controller_scheme used attemping 9800 series on 3504 controller: {}".format(self.scheme)) + logg.info( + "Check the controller_scheme used attemping 9800 series on 3504 controller: {}".format(self.scheme)) - #create wireless tag policy --9800 series needs to have wireless tag policy set - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action wireless_tag_policy --series 9800 + # create wireless tag policy --9800 series needs to have wireless tag policy set + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action wireless_tag_policy --series 9800 def controller_set_wireless_tag_policy(self): if self.series == "9800": try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user,self.passwd, self.ap, self.series, - self.band,"wireless_tag_policy" )) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, - "--action", "wireless_tag_policy"], - capture_output=self.cap_ctl_out, check=True) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, self.passwd, self.ap, self.series, + self.band, "wireless_tag_policy")) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, + "--action", "wireless_tag_policy"], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) else: - logg.info("Check the controller_scheme used attemping 9800 series on 3504 controller: {}".format(self.scheme)) + logg.info( + "Check the controller_scheme used attemping 9800 series on 3504 controller: {}".format(self.scheme)) - - #enable wlan - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action enable_wlan --series 9800 + # enable wlan + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action enable_wlan --series 9800 def controller_enable_wlan(self): try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} wlan: {} action: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user,self.passwd, self.ap, self.series, - self.band, self.wlan,"enable_wlan")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, "--wlan", self.wlan, - "--action", "enable_wlan"], - capture_output=self.cap_ctl_out, check=True) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} wlan: {} action: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, self.passwd, self.ap, self.series, + self.band, self.wlan, "enable_wlan")) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, "--wlan", self.wlan, + "--action", "enable_wlan"], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) - + except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) - - #enable 5ghz - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action enable_network_5ghz --series 9800 + # enable 5ghz + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action enable_network_5ghz --series 9800 def controller_enable_network_5ghz(self): if self.series == "9800": try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user,self.passwd, self.ap, self.series, - self.band,"enable_network_5ghz")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, - "--action", "enable_network_5ghz"], - capture_output=self.cap_ctl_out, check=True) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, self.passwd, self.ap, self.series, + self.band, "enable_network_5ghz")) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, + "--action", "enable_network_5ghz"], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) - + except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) else: try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} value: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user,self.passwd, self.ap, self.series, - self.band,"cmd","config 802.11a enable network")) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} value: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, self.passwd, self.ap, self.series, + self.band, "cmd", "config 802.11a enable network")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, "--action", "cmd", "--value", "config 802.11a enable network"], - capture_output=self.cap_ctl_out, check=True) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, "--action", "cmd", "--value", + "config 802.11a enable network"], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) - - - #enable 24ghz - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action enable_network_24ghz --series 9800 + # enable 24ghz + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action enable_network_24ghz --series 9800 def controller_enable_network_24ghz(self): if self.series == "9800": try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user,self.passwd, self.ap, self.series, - self.band,"enable_network_24ghz")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, - "--action", "enable_network_24ghz"], - capture_output=self.cap_ctl_out, check=True) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, self.passwd, self.ap, self.series, + self.band, "enable_network_24ghz")) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, + "--action", "enable_network_24ghz"], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) else: try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} value: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user,self.passwd, self.ap, self.series, - self.band,"cmd","config 802.11b enable network")) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {} value: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, self.passwd, self.ap, self.series, + self.band, "cmd", "config 802.11b enable network")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, "--action", "cmd", "--value", "config 802.11b enable network"], - capture_output=self.cap_ctl_out, check=True) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, "--action", "cmd", "--value", + "config 802.11b enable network"], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) - - - #enable (band a) - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action enable --series 9800 + # enable (band a) + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action enable --series 9800 def controller_enable_ap(self): try: - logg.info("scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user,self.passwd, self.ap, self.series, - self.band,"enable")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, - "--action", "enable"], - capture_output=self.cap_ctl_out, check=True) + logg.info( + "scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, self.passwd, self.ap, self.series, + self.band, "enable")) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, + "--action", "enable"], + capture_output=self.cap_ctl_out, check=True) if self.cap_ctl_out: pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) - - #advanced (showes summary) - #./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action advanced --series 9800 + # advanced (showes summary) + # ./wifi_ctl_9800_3504.py --scheme ssh -d 172.19.36.168 -p --port 23 -a "9120-Chamber-1" --band a --action advanced --series 9800 def controller_show_ap_channel(self): - advanced = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--action", "ap_channel"], capture_output=True) + advanced = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", + self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--action", "ap_channel"], capture_output=True) pss = advanced.stdout.decode('utf-8', 'ignore') logg.info(pss) if self.series == "9800": - if (self.band == "a"): + if self.band == "a": controller_channel = self.chan_5ghz else: controller_channel = self.chan_24ghz @@ -726,45 +843,53 @@ class CreateCtlr(): logg.info("line {}".format(line)) element_list = line.lstrip().split() logg.info("element_list {}".format(element_list)) - if (line.lstrip().startswith(search_str)): + if line.lstrip().startswith(search_str): logg.info("line {}".format(line)) element_list = line.lstrip().split() logg.info("element_list {}".format(element_list)) # AP Name (0) mac (1) slot (2) Admin State [enable/disable] (3) Oper State [Up/Down] (4) Width (5) Txpwr (6,7) channel (8) mode (9) - logg.info("ap: {} slof {} channel {} chan_width {}".format(element_list[0],element_list[2],element_list[8],element_list[5])) - if (str(controller_channel) in str(element_list[8])) and (str(self.chan_width) in str(element_list[5])): - logg.info("ap {} configuration successful: channel {} in expected {} chan_width {} in expected {}" - .format(element_list[0],controller_channel,element_list[8],self.chan_width,element_list[5])) + logg.info("ap: {} slof {} channel {} chan_width {}".format(element_list[0], element_list[2], + element_list[8], element_list[5])) + if (str(controller_channel) in str(element_list[8])) and ( + str(self.chan_width) in str(element_list[5])): + logg.info( + "ap {} configuration successful: channel {} in expected {} chan_width {} in expected {}" + .format(element_list[0], controller_channel, element_list[8], self.chan_width, + element_list[5])) else: logg.info("WARNING ap {} configuration: channel {} in expected {} chan_width {} in expected {}" - .format(element_list[0],controller_channel,element_list[8],self.chan_width,element_list[5])) + .format(element_list[0], controller_channel, element_list[8], self.chan_width, + element_list[5])) break else: logg.info("checking for 802.11{}".format(self.band)) - if (self.band == "a"): + if self.band == "a": controller_channel = self.chan_5ghz else: controller_channel = self.chan_24ghz for line in pss.splitlines(): - #logg.info("line {}".format(line)) + # logg.info("line {}".format(line)) search_str = "802.11{}".format(self.band) - if (line.lstrip().startswith(search_str)): + if line.lstrip().startswith(search_str): logg.info("line {}".format(line)) element_list = line.lstrip().split() logg.info("element_list {}".format(element_list)) - logg.info("ap: {} channel {} chan_width {}".format(self.ap,element_list[4],element_list[5])) - if (str(controller_channel) in str(element_list[4])) and (str(self.chan_width) in str(element_list[5])): + logg.info("ap: {} channel {} chan_width {}".format(self.ap, element_list[4], element_list[5])) + if (str(controller_channel) in str(element_list[4])) and ( + str(self.chan_width) in str(element_list[5])): logg.info("ap configuration successful: channel {} in expected {} chan_width {} in expected {}" - .format(controller_channel,element_list[4],self.chan_width,element_list[5])) + .format(controller_channel, element_list[4], self.chan_width, element_list[5])) else: logg.info("AP WARNING: channel {} expected {} chan_width {} expected {}" - .format(element_list[4],controller_channel,element_list[5],self.chan_width)) + .format(element_list[4], controller_channel, element_list[5], self.chan_width)) break - - logg.info("configure ap {} channel {} chan_width {}".format(self.ap,self.channel,self.chan_width)) + + logg.info("configure ap {} channel {} chan_width {}".format(self.ap, self.channel, self.chan_width)) # Verify channel and channel width. -########################################## + + +########################################## # End of controller controller class ########################################## @@ -773,68 +898,68 @@ class CreateCtlr(): ########################################## class L3VariableTime(Realm): - def __init__(self, - args, - _dfs, - _dfs_time, - _radar_duration, - _scheme, - _port, - _series, - _ctlr, - _prompt, - _user, - _passwd, - _ap, - _ap_slot, - _band, - _chan_5ghz, - _chan_24ghz, - _chan_width, - _ap_mode, - _tx_power, - _client_density, - _cap_ctl_out, - _ap_dict, - endp_type, - tos, - side_b, - radio_name_list, - number_of_stations_per_radio_list, - ssid_list, - ssid_password_list, - ssid_security_list, - wifimode_list, - station_lists, - name_prefix, - debug_on, - outfile, - results, - test_keys, - test_config, - reset_port_enable_list, - reset_port_time_min_list, - reset_port_time_max_list, - csv_started=False, - side_a_min_bps=560000, - side_a_max_bps=0, - side_a_min_pdu=1518, - side_a_max_pdu=0, - side_b_min_bps=560000, - side_b_max_bps=0, - side_b_min_pdu=1518, - side_b_max_pdu=0, - number_template="00", - test_duration="256s", - polling_interval="60s", - lfclient_host="localhost", - lfclient_port=8080, - debug=False, - wait_timeout=120, - _exit_on_error=False, - _exit_on_fail=False, - _proxy_str=None, - _capture_signal_list=[]): + def __init__(self, + args, + _dfs, + _dfs_time, + _radar_duration, + _scheme, + _port, + _series, + _ctlr, + _prompt, + _user, + _passwd, + _ap, + _ap_slot, + _band, + _chan_5ghz, + _chan_24ghz, + _chan_width, + _ap_mode, + _tx_power, + _client_density, + _cap_ctl_out, + _ap_dict, + endp_type, + tos, + side_b, + radio_name_list, + number_of_stations_per_radio_list, + ssid_list, + ssid_password_list, + ssid_security_list, + wifimode_list, + station_lists, + name_prefix, + debug_on, + outfile, + results, + test_keys, + test_config, + reset_port_enable_list, + reset_port_time_min_list, + reset_port_time_max_list, + csv_started=False, + side_a_min_bps=560000, + side_a_max_bps=0, + side_a_min_pdu=1518, + side_a_max_pdu=0, + side_b_min_bps=560000, + side_b_max_bps=0, + side_b_min_pdu=1518, + side_b_max_pdu=0, + number_template="00", + test_duration="256s", + polling_interval="60s", + lfclient_host="localhost", + lfclient_port=8080, + debug=False, + wait_timeout=120, + _exit_on_error=False, + _exit_on_fail=False, + _proxy_str=None, + _capture_signal_list=[]): super().__init__(lfclient_host=lfclient_host, lfclient_port=lfclient_port, debug_=debug, @@ -848,16 +973,16 @@ class L3VariableTime(Realm): self.radar_duration_seconds = self.duration_time_to_seconds(_radar_duration) self.dfs_time_seconds = self.duration_time_to_seconds(_dfs_time) self.scheme = _scheme - self.port = _port + self.port = _port self.series = _series - self.ctlr = _ctlr + self.ctlr = _ctlr self.prompt = _prompt - self.user = _user + self.user = _user self.passwd = _passwd - self.ap = _ap + self.ap = _ap self.ap_slot = _ap_slot - self.band = _band - self.chan_5ghz = _chan_5ghz + self.band = _band + self.chan_5ghz = _chan_5ghz self.chan_24ghz = _chan_24ghz self.chan_width = _chan_width self.ap_mode = _ap_mode @@ -870,7 +995,7 @@ class L3VariableTime(Realm): self.side_b = side_b self.ssid_list = ssid_list self.ssid_password_list = ssid_password_list - self.station_lists = station_lists + self.station_lists = station_lists self.ssid_security_list = ssid_security_list self.wifimode_list = wifimode_list self.reset_port_enable_list = reset_port_enable_list @@ -880,8 +1005,8 @@ class L3VariableTime(Realm): self.name_prefix = name_prefix self.test_duration = test_duration self.radio_name_list = radio_name_list - self.number_of_stations_per_radio_list = number_of_stations_per_radio_list - #self.local_realm = realm.Realm(lfclient_host=self.host, lfclient_port=self.port, debug_=debug_on) + self.number_of_stations_per_radio_list = number_of_stations_per_radio_list + # self.local_realm = realm.Realm(lfclient_host=self.host, lfclient_port=self.port, debug_=debug_on) self.polling_interval_seconds = self.duration_time_to_seconds(polling_interval) self.cx_profile = self.new_l3_cx_profile() self.multicast_profile = self.new_multicast_profile() @@ -892,13 +1017,13 @@ class L3VariableTime(Realm): self.results = results self.csv_started = csv_started self.epoch_time = int(time.time()) - self.dfs_epoch_start = 0 + self.dfs_epoch_start = 0 self.dfs_epoch_detect = 0 - #[*07/07/2020 23:37:48.1460] changed to DFS channel 52, running CAC for 60 seconds. + # [*07/07/2020 23:37:48.1460] changed to DFS channel 52, running CAC for 60 seconds. self.CAC_TIMER = "" - #[*07/07/2020 23:38:48.7240] CAC_EXPIRY_EVT: CAC finished on DFS channel 52 + # [*07/07/2020 23:38:48.7240] CAC_EXPIRY_EVT: CAC finished on DFS channel 52 self.CAC_EXPIRY_EVT = "" - #[*07/07/2020 23:44:27.8060] DOT11_DRV[1]: set_dfs Channel set to 36/20, CSA count 10 + # [*07/07/2020 23:44:27.8060] DOT11_DRV[1]: set_dfs Channel set to 36/20, CSA count 10 self.CSA_COUNT = "" self.BLACK_LIST = "" self.debug = debug_on @@ -906,36 +1031,39 @@ class L3VariableTime(Realm): self.test_keys = test_keys self.test_config = test_config - self.test_config_dict = dict(map(lambda x: x.split('=='), str(self.test_config).replace('[','').replace(']','').replace("'","").split())) - + self.test_config_dict = dict(map(lambda x: x.split('=='), + str(self.test_config).replace('[', '').replace(']', '').replace("'", + "").split())) # Full spread-sheet data if self.outfile is not None: - self.csv_file = open(self.outfile, "a+") + self.csv_file = open(self.outfile, "a+") self.csv_writer = csv.writer(self.csv_file, delimiter=",") - + if self.results is not None: - self.csv_results = open(self.results, "a+") + self.csv_results = open(self.results, "a+") self.csv_results_writer = csv.writer(self.csv_results, delimiter=",") - for (radio_, ssid_, ssid_password_, ssid_security_, wifimode_,\ - reset_port_enable_, reset_port_time_min_, reset_port_time_max_) \ - in zip(radio_name_list, ssid_list, ssid_password_list, ssid_security_list, wifimode_list,\ - reset_port_enable_list, reset_port_time_min_list, reset_port_time_max_list): + for (radio_, ssid_, ssid_password_, ssid_security_, wifimode_, + reset_port_enable_, reset_port_time_min_, reset_port_time_max_) \ + in zip(radio_name_list, ssid_list, ssid_password_list, ssid_security_list, wifimode_list, + reset_port_enable_list, reset_port_time_min_list, reset_port_time_max_list): self.station_profile = self.new_station_profile() self.station_profile.lfclient_url = self.lfclient_url self.station_profile.ssid = ssid_ self.station_profile.ssid_pass = ssid_password_ self.station_profile.security = ssid_security_ - self.station_profile.mode = wifimode_ + self.station_profile.mode = wifimode_ self.station_profile.number_template = self.number_template - self.station_profile.mode = wifimode_ - self.station_profile.set_reset_extra(reset_port_enable=reset_port_enable_,\ - test_duration=self.duration_time_to_seconds(self.test_duration),\ - reset_port_min_time=self.duration_time_to_seconds(reset_port_time_min_),\ - reset_port_max_time=self.duration_time_to_seconds(reset_port_time_max_)) + self.station_profile.mode = wifimode_ + self.station_profile.set_reset_extra(reset_port_enable=reset_port_enable_, + test_duration=self.duration_time_to_seconds(self.test_duration), + reset_port_min_time=self.duration_time_to_seconds( + reset_port_time_min_), + reset_port_max_time=self.duration_time_to_seconds( + reset_port_time_max_)) self.station_profiles.append(self.station_profile) - + self.multicast_profile.host = self.lfclient_host self.cx_profile.host = self.lfclient_host self.cx_profile.port = self.lfclient_port @@ -974,14 +1102,14 @@ class L3VariableTime(Realm): def time_stamp(self): return time.strftime('%Y-%m-%d %H %M %S', time.localtime(self.epoch_time)) - def __record_rx_dropped_percent(self,rx_drop_percent): + def __record_rx_dropped_percent(self, rx_drop_percent): csv_rx_drop_percent_data = [] print("test_keys {}".format(self.test_keys)) print("self.test_config_dict {}".format(self.test_config_dict)) for key in self.test_keys: csv_rx_drop_percent_data.append(self.test_config_dict[key]) - csv_rx_drop_percent_data.extend([self.epoch_time, self.time_stamp(),'rx_drop_percent']) + csv_rx_drop_percent_data.extend([self.epoch_time, self.time_stamp(), 'rx_drop_percent']) # remove multi cast since downstream only if selected for key in [key for key in rx_drop_percent if "mtx" in key]: del rx_drop_percent[key] @@ -990,25 +1118,25 @@ class L3VariableTime(Realm): elif "downstream" in self.test_config_dict.values(): for key in [key for key in rx_drop_percent if "-B" in key]: del rx_drop_percent[key] - - filtered_values = [v for _, v in rx_drop_percent.items() if v !=0] + filtered_values = [v for _, v in rx_drop_percent.items() if v != 0] average_rx_drop_percent = sum(filtered_values) / len(filtered_values) if len(filtered_values) != 0 else 0 - csv_performance_rx_drop_percent_values=sorted(rx_drop_percent.items(), key=lambda x: (x[1],x[0]), reverse=False) - csv_performance_rx_drop_percent_values=self.csv_validate_list(csv_performance_rx_drop_percent_values,5) + csv_performance_rx_drop_percent_values = sorted(rx_drop_percent.items(), key=lambda x: (x[1], x[0]), + reverse=False) + csv_performance_rx_drop_percent_values = self.csv_validate_list(csv_performance_rx_drop_percent_values, 5) for i in range(5): - csv_rx_drop_percent_data.append(str(csv_performance_rx_drop_percent_values[i]).replace(',',';')) - for i in range(-1,-6,-1): - csv_rx_drop_percent_data.append(str(csv_performance_rx_drop_percent_values[i]).replace(',',';')) + csv_rx_drop_percent_data.append(str(csv_performance_rx_drop_percent_values[i]).replace(',', ';')) + for i in range(-1, -6, -1): + csv_rx_drop_percent_data.append(str(csv_performance_rx_drop_percent_values[i]).replace(',', ';')) csv_rx_drop_percent_data.append(average_rx_drop_percent) for item, value in rx_drop_percent.items(): - #logg.info(item, "rx drop percent: ", rx_drop_percent[item]) + # logg.info(item, "rx drop percent: ", rx_drop_percent[item]) csv_rx_drop_percent_data.append(rx_drop_percent[item]) - self.csv_add_row(csv_rx_drop_percent_data,self.csv_writer,self.csv_file) - self.csv_add_row(csv_rx_drop_percent_data,self.csv_results_writer,self.csv_results) + self.csv_add_row(csv_rx_drop_percent_data, self.csv_writer, self.csv_file) + self.csv_add_row(csv_rx_drop_percent_data, self.csv_results_writer, self.csv_results) def __compare_vals(self, old_list, new_list): passes = 0 @@ -1021,27 +1149,26 @@ class L3VariableTime(Realm): csv_rx_delta_dict = {} test_id = "" - #for key in self.test_keys: + # for key in self.test_keys: # csv_rx_row_data.append(self.test_config_dict[key]) # csv_rx_delta_row_data.append(self.test_config_dict[key]) - for key in [key for key in old_list if "mtx" in key]: del old_list[key] for key in [key for key in new_list if "mtx" in key]: del new_list[key] - filtered_values = [v for _, v in new_list.items() if v !=0] - average_rx= sum(filtered_values) / len(filtered_values) if len(filtered_values) != 0 else 0 + filtered_values = [v for _, v in new_list.items() if v != 0] + average_rx = sum(filtered_values) / len(filtered_values) if len(filtered_values) != 0 else 0 # only evaluate upstream or downstream new_evaluate_list = new_list.copy() - print("new_evaluate_list before",new_evaluate_list) + print("new_evaluate_list before", new_evaluate_list) if "upstream" in self.test_config_dict.values(): for key in [key for key in new_evaluate_list if "-A" in key]: del new_evaluate_list[key] print("upstream in dictionary values") - elif "downstream" in self.test_config_dict.values(): + elif "downstream" in self.test_config_dict.values(): for key in [key for key in new_evaluate_list if "-B" in key]: del new_evaluate_list[key] print("downstream in dictionary values") - #follow code left in for now, provides the best 5 worst 5 + # follow code left in for now, provides the best 5 worst 5 '''print("new_evaluate_list after",new_evaluate_list) csv_performance_values=sorted(new_evaluate_list.items(), key=lambda x: (x[1],x[0]), reverse=False) csv_performance_values=self.csv_validate_list(csv_performance_values,5) @@ -1056,24 +1183,24 @@ class L3VariableTime(Realm): if "upstream" in self.test_config_dict.values(): for key in [key for key in old_evaluate_list if "-A" in key]: del old_evaluate_list[key] print("upstream in dictionary values") - elif "downstream" in self.test_config_dict.values(): + elif "downstream" in self.test_config_dict.values(): for key in [key for key in old_evaluate_list if "-B" in key]: del old_evaluate_list[key] print("downstream in dictionary values") if len(old_evaluate_list) == len(new_evaluate_list): for item, value in old_evaluate_list.items(): - expected_passes +=1 + expected_passes += 1 print("ITEM: {} VALUE: {}".format(item, value)) if new_evaluate_list[item] > old_evaluate_list[item]: passes += 1 - #if self.debug: logg.info(item, new_evaluate_list[item], old_evaluate_list[item], " Difference: ", new_evaluate_list[item] - old_evaluate_list[item]) - print(item, new_evaluate_list[item], old_evaluate_list[item], " Difference: ", new_evaluate_list[item] - old_evaluate_list[item]) + # if self.debug: logg.info(item, new_evaluate_list[item], old_evaluate_list[item], " Difference: ", new_evaluate_list[item] - old_evaluate_list[item]) + print(item, new_evaluate_list[item], old_evaluate_list[item], " Difference: ", + new_evaluate_list[item] - old_evaluate_list[item]) else: print("Failed to increase rx data: ", item, new_evaluate_list[item], old_evaluate_list[item]) if not self.csv_started: csv_rx_headers.append(item) - csv_rx_delta_dict.update({item:(new_evaluate_list[item] - old_evaluate_list[item])}) - + csv_rx_delta_dict.update({item: (new_evaluate_list[item] - old_evaluate_list[item])}) if not self.csv_started: csv_header = self.csv_generate_column_headers() @@ -1081,7 +1208,7 @@ class L3VariableTime(Realm): logg.info(csv_header) self.csv_add_column_headers(csv_header) csv_results = self.csv_generate_column_results_headers() - #csv_results += csv_rx_headers + # csv_results += csv_rx_headers self.csv_add_column_headers_results(csv_results) print("###################################") print(csv_results) @@ -1090,24 +1217,23 @@ class L3VariableTime(Realm): self.csv_started = True # need to generate list first to determine worst and best - filtered_values = [v for _, v in csv_rx_delta_dict.items() if v !=0] - #average_rx_delta= sum(filtered_values) / len(filtered_values) if len(filtered_values) != 0 else 0 + filtered_values = [v for _, v in csv_rx_delta_dict.items() if v != 0] + # average_rx_delta= sum(filtered_values) / len(filtered_values) if len(filtered_values) != 0 else 0 for key in self.test_keys: csv_rx_row_data.append(self.test_config_dict[key]) csv_result_row_data.append(self.test_config_dict[key]) csv_rx_delta_row_data.append(self.test_config_dict[key]) - - max_tp_mbps = sum(filtered_values) + + max_tp_mbps = sum(filtered_values) csv_rx_row_data.append(max_tp_mbps) csv_result_row_data.append(max_tp_mbps) - #To do needs to be read or passed in based on test type - expected_tp_mbps = max_tp_mbps + # To do needs to be read or passed in based on test type + expected_tp_mbps = max_tp_mbps csv_rx_row_data.append(expected_tp_mbps) csv_result_row_data.append(expected_tp_mbps) - - #Generate TestID + # Generate TestID for key in self.test_keys: test_id = test_id + "_" + self.test_config_dict[key] @@ -1125,11 +1251,11 @@ class L3VariableTime(Realm): csv_rx_row_data.append("fail") csv_result_row_data.append("fail")''' - csv_rx_row_data.extend([self.epoch_time, self.time_stamp(),'rx_delta']) + csv_rx_row_data.extend([self.epoch_time, self.time_stamp(), 'rx_delta']) csv_result_row_data.extend([self.epoch_time, self.time_stamp()]) print("csv_rx_row_data {}".format(csv_rx_row_data)) - #TODO: may want to pass in the information that needs to be in the csv file into the class + # TODO: may want to pass in the information that needs to be in the csv file into the class ''' csv_rx_row_data.extend([self.epoch_time, self.time_stamp(),'rx']) csv_rx_delta_row_data.extend([self.epoch_time, self.time_stamp(),'rx_delta']) @@ -1142,55 +1268,65 @@ class L3VariableTime(Realm): csv_rx_delta_row_data.append(str(csv_performance_delta_values[i]).replace(',',';')) csv_rx_delta_row_data.append(average_rx_delta)''' - + for item, value in old_evaluate_list.items(): - expected_passes +=1 + expected_passes += 1 if new_evaluate_list[item] > old_evaluate_list[item]: passes += 1 - #if self.debug: logg.info(item, new_evaluate_list[item], old_evaluate_list[item], " Difference: ", new_evaluate_list[item] - old_evaluate_list[item]) - print(item, new_evaluate_list[item], old_evaluate_list[item], " Difference: ", new_evaluate_list[item] - old_evaluate_list[item]) + # if self.debug: logg.info(item, new_evaluate_list[item], old_evaluate_list[item], " Difference: ", new_evaluate_list[item] - old_evaluate_list[item]) + print(item, new_evaluate_list[item], old_evaluate_list[item], " Difference: ", + new_evaluate_list[item] - old_evaluate_list[item]) else: print("Failed to increase rx data: ", item, new_evaluate_list[item], old_evaluate_list[item]) if not self.csv_started: csv_rx_headers.append(item) # note need to have all upstream and downstream in the csv table thus new_list and old_list - #csv_rx_row_data.append(new_list[item]) + # csv_rx_row_data.append(new_list[item]) # provide delta csv_rx_row_data.append(new_list[item] - old_list[item]) - self.csv_add_row(csv_rx_row_data,self.csv_writer,self.csv_file) - #self.csv_add_row(csv_rx_row_data,self.csv_results_writer,self.csv_results) + self.csv_add_row(csv_rx_row_data, self.csv_writer, self.csv_file) + # self.csv_add_row(csv_rx_row_data,self.csv_results_writer,self.csv_results) - #self.csv_add_row(csv_rx_delta_row_data,self.csv_writer,self.csv_file) + # self.csv_add_row(csv_rx_delta_row_data,self.csv_writer,self.csv_file) if passes == expected_passes: return True, max_tp_mbps, csv_result_row_data else: return False, max_tp_mbps, csv_result_row_data else: - print("Old-list length: %i new: %i does not match in compare-vals."%(len(old_list), len(new_list))) - print("old-list:",old_list) - print("new-list:",new_list) - return False, None, None # check to see if this is valid + print("Old-list length: %i new: %i does not match in compare-vals." % (len(old_list), len(new_list))) + print("old-list:", old_list) + print("new-list:", new_list) + return False, None, None # check to see if this is valid def reset_port_check(self): for station_profile in self.station_profiles: if station_profile.reset_port_extra_data['reset_port_enable']: if not station_profile.reset_port_extra_data['reset_port_timer_started']: - logg.info("reset_port_time_min: {}".format(station_profile.reset_port_extra_data['reset_port_time_min'])) - logg.info("reset_port_time_max: {}".format(station_profile.reset_port_extra_data['reset_port_time_max'])) + logg.info( + "reset_port_time_min: {}".format(station_profile.reset_port_extra_data['reset_port_time_min'])) + logg.info( + "reset_port_time_max: {}".format(station_profile.reset_port_extra_data['reset_port_time_max'])) station_profile.reset_port_extra_data['seconds_till_reset'] = \ - random.randint(station_profile.reset_port_extra_data['reset_port_time_min'],\ - station_profile.reset_port_extra_data['reset_port_time_max']) + random.randint(station_profile.reset_port_extra_data['reset_port_time_min'], + station_profile.reset_port_extra_data['reset_port_time_max']) station_profile.reset_port_extra_data['reset_port_timer_started'] = True - logg.info("on radio {} seconds_till_reset {}".format(station_profile.add_sta_data['radio'],station_profile.reset_port_extra_data['seconds_till_reset'])) + logg.info("on radio {} seconds_till_reset {}".format(station_profile.add_sta_data['radio'], + station_profile.reset_port_extra_data[ + 'seconds_till_reset'])) else: - station_profile.reset_port_extra_data['seconds_till_reset'] = station_profile.reset_port_extra_data['seconds_till_reset'] - 1 - if self.debug: logg.info("radio: {} countdown seconds_till_reset {}".format(station_profile.add_sta_data['radio'] ,station_profile.reset_port_extra_data['seconds_till_reset'])) - if ((station_profile.reset_port_extra_data['seconds_till_reset'] <= 0)): + station_profile.reset_port_extra_data['seconds_till_reset'] = station_profile.reset_port_extra_data[ + 'seconds_till_reset'] - 1 + if self.debug: logg.info( + "radio: {} countdown seconds_till_reset {}".format(station_profile.add_sta_data['radio'], + station_profile.reset_port_extra_data[ + 'seconds_till_reset'])) + if station_profile.reset_port_extra_data['seconds_till_reset'] <= 0: station_profile.reset_port_extra_data['reset_port_timer_started'] = False - port_to_reset = random.randint(0,len(station_profile.station_names)-1) - logg.info("reset on radio {} station: {}".format(station_profile.add_sta_data['radio'],station_profile.station_names[port_to_reset])) + port_to_reset = random.randint(0, len(station_profile.station_names) - 1) + logg.info("reset on radio {} station: {}".format(station_profile.add_sta_data['radio'], + station_profile.station_names[port_to_reset])) self.reset_port(station_profile.station_names[port_to_reset]) def pre_cleanup(self): @@ -1204,12 +1340,12 @@ class L3VariableTime(Realm): # Make sure they are gone count = 0 - while (count < 10): + while count < 10: more = False for station_list in self.station_lists: for sta in station_list: rv = self.rm_port(sta, check_exists=True) - if (rv): + if rv: more = True if not more: break @@ -1223,32 +1359,35 @@ class L3VariableTime(Realm): station_profile.set_number_template(station_profile.number_template) logg.info("Creating stations") - station_profile.create(radio=self.radio_name_list[index], sta_names_=self.station_lists[index], debug=self.debug, sleep_time=0) + station_profile.create(radio=self.radio_name_list[index], sta_names_=self.station_lists[index], + debug=self.debug, sleep_time=0) index += 1 # 12/4/2020 put back in multi cast - #for etype in self.endp_types: + # for etype in self.endp_types: # if etype == "mc_udp" or etype == "mc_udp6": # logg.info("Creating Multicast connections for endpoint type: %s"%(etype)) # self.multicast_profile.create_mc_tx(etype, self.side_b, etype) # self.multicast_profile.create_mc_rx(etype, side_rx=station_profile.station_names) - + for _tos in self.tos: - logg.info("Creating connections for endpoint type: {} TOS: {} stations_names {}".format(self.endp_type, _tos, station_profile.station_names)) - self.cx_profile.create(endp_type=self.endp_type, side_a=station_profile.station_names, side_b=self.side_b, sleep_time=0, tos=_tos) - self._pass("PASS: Stations build finished") - + logg.info( + "Creating connections for endpoint type: {} TOS: {} stations_names {}".format(self.endp_type, _tos, + station_profile.station_names)) + self.cx_profile.create(endp_type=self.endp_type, side_a=station_profile.station_names, + side_b=self.side_b, sleep_time=0, tos=_tos) + self._pass("PASS: Stations build finished") + def station_bringup(self): client_density = 0 logg.info("Bringing up stations") - self.admin_up(self.side_b) + self.admin_up(self.side_b) for station_profile in self.station_profiles: for sta in station_profile.station_names: - logg.info("Bringing up station %s"%(sta)) + logg.info("Bringing up station %s" % sta) self.admin_up(sta) client_density += 1 - temp_stations_list = [] temp_stations_list.append(self.side_b) for station_profile in self.station_profiles: @@ -1258,8 +1397,8 @@ class L3VariableTime(Realm): logg.info("ip's acquired") else: logg.info("print failed to get IP's") - exit(1) # why continue - + exit(1) # why continue + return client_density def read_channel(self): @@ -1268,22 +1407,26 @@ class L3VariableTime(Realm): pss = "" try: logg.info("\ - scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user, - self.passwd,self.ap,self.series,self.band,"advanced")) + scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, + self.passwd, self.ap, self.series, self.band, "advanced")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, "--action", "advanced"], - capture_output=True, check=True) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, "--action", "advanced"], + capture_output=True, check=True) pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) logg.info("controller_show_ap_summary::: pss {}".format(pss)) @@ -1295,25 +1438,28 @@ class L3VariableTime(Realm): cc_power = "" cc_dbm = "" for line in pss.splitlines(): - if (line.startswith("---------")): + if line.startswith("---------"): searchap = True continue # if the pattern changes save the output of the advanced command and re parse https://regex101.com - if (searchap): - pat = "%s\s+(\S+)\s+(%s)\s+\S+\s+\S+\s+(\S+)\s+(\S+)\s+(\S+)\s+dBm\)+\s+(\S+)+\s"%(self.ap,self.ap_slot) + if searchap: + pat = "%s\s+(\S+)\s+(%s)\s+\S+\s+\S+\s+(\S+)\s+(\S+)\s+(\S+)\s+dBm\)+\s+(\S+)+\s" % ( + self.ap, self.ap_slot) m = re.search(pat, line) - if (m != None): - if(m.group(2) == self.ap_slot): + if m != None: + if m.group(2) == self.ap_slot: cc_mac = m.group(1) cc_slot = m.group(2) - cc_ch = m.group(6); # (132,136,140,144) + cc_ch = m.group(6) # (132,136,140,144) cc_power = m.group(4) - cc_power = cc_power.replace("/", " of ") # spread-sheets turn 1/8 into a date + cc_power = cc_power.replace("/", " of ") # spread-sheets turn 1/8 into a date cc_dbm = m.group(5) - cc_dbm = cc_dbm.replace("(","") + cc_dbm = cc_dbm.replace("(", "") cc_ch_count = cc_ch.count(",") + 1 cc_bw = m.group(3) - logg.info("group 1: {} 2: {} 3: {} 4: {} 5: {} 6: {}".format(m.group(1),m.group(2),m.group(3),m.group(4),m.group(5),m.group(6))) + logg.info( + "group 1: {} 2: {} 3: {} 4: {} 5: {} 6: {}".format(m.group(1), m.group(2), m.group(3), + m.group(4), m.group(5), m.group(6))) logg.info("9800 test_parameters cc_mac: read : {}".format(cc_mac)) logg.info("9800 test_parameters cc_slot: read : {}".format(cc_slot)) logg.info("9800 test_parameters cc_count: read : {}".format(cc_ch_count)) @@ -1331,22 +1477,22 @@ class L3VariableTime(Realm): cc_dbm = "" ch_count = "" for line in pss.splitlines(): - if (line.startswith("---------")): + if line.startswith("---------"): searchap = True continue - - if (searchap): - pat = "%s\s+(\S+)\s+\S+\s+\S+\s+\S+\s+(\S+)\s+(\S+)\s+\(\s*(\S+)\s+dBm"%(self.ap) + + if searchap: + pat = "%s\s+(\S+)\s+\S+\s+\S+\s+\S+\s+(\S+)\s+(\S+)\s+\(\s*(\S+)\s+dBm" % self.ap m = re.search(pat, line) - if (m != None): + if m != None: cc_mac = m.group(1) - cc_ch = m.group(2); # (132,136,140,144) + cc_ch = m.group(2) # (132,136,140,144) cc_power = m.group(3) - cc_power = cc_power.replace("/", " of ", 1) # spread-sheets turn 1/8 into a date + cc_power = cc_power.replace("/", " of ", 1) # spread-sheets turn 1/8 into a date cc_dbm = m.group(4) ch_count = cc_ch.count(",") cc_bw = 20 * (ch_count + 1) - + logg.info("3504 test_parameters cc_mac: read : {}".format(cc_mac)) logg.info("3504 test_parameters cc_count: read : {}".format(ch_count)) logg.info("3504 test_parameters cc_bw: read : {}".format(cc_bw)) @@ -1354,7 +1500,7 @@ class L3VariableTime(Realm): logg.info("3504 test_parameters cc_dbm: read : {}".format(cc_dbm)) logg.info("3504 test_parameters cc_ch: read : {}".format(cc_ch)) - return cc_ch + return cc_ch def read_auto_rf(self): @@ -1362,34 +1508,38 @@ class L3VariableTime(Realm): pss = "" try: logg.info("\ - scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format(self.scheme, - self.ctlr,self.port,self.prompt,self.user, - self.passwd,self.ap,self.series,self.band,"advanced")) + scheme: {} ctlr: {} port: {} prompt: {} user: {} passwd: {} AP: {} series: {} band: {} action: {}".format( + self.scheme, + self.ctlr, self.port, self.prompt, self.user, + self.passwd, self.ap, self.series, self.band, "advanced")) - ctl_output = subprocess.run(["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, "-d", self.ctlr, "-u", - self.user, "-p", self.passwd, - "-a", self.ap,"--series", self.series, "--band", self.band, "--action", "auto_rf"], - capture_output=True, check=True) + ctl_output = subprocess.run( + ["../wifi_ctl_9800_3504.py", "--scheme", self.scheme, "--prompt", self.prompt, "--port", self.port, + "-d", self.ctlr, "-u", + self.user, "-p", self.passwd, + "-a", self.ap, "--series", self.series, "--band", self.band, "--action", "auto_rf"], + capture_output=True, check=True) pss = ctl_output.stdout.decode('utf-8', 'ignore') logg.info(pss) except subprocess.CalledProcessError as process_error: - logg.info("Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". + logg.info( + "Command Error, Controller unable to commicate to AP or unable to communicate to controller error code: {} output {}". format(process_error.returncode, process_error.output)) - time.sleep(1) + time.sleep(1) exit(1) blacklist_time = "" for line in pss.splitlines(): - pat = 'Channel\s+%s\S+\s+(\S+)\s+\S+\s+remaining'%(self.chan_5ghz) + pat = 'Channel\s+%s\S+\s+(\S+)\s+\S+\s+remaining' % self.chan_5ghz m = re.search(pat, line) - if ( m != None ): + if m != None: blacklist_time = m.group(1) - logg.info("dfs_channel: {} blacklist_time: {}".format(self.chan_5ghz,blacklist_time)) + logg.info("dfs_channel: {} blacklist_time: {}".format(self.chan_5ghz, blacklist_time)) return blacklist_time - def dfs_waveforms(self,waveform): + def dfs_waveforms(self, waveform): # 1, 2, 3, 4, 5, 11, 12, 13, 14, 15, 16 # "FCCO" , "FCC1" , "FCC2" , "FCC3", "FCC4", "FCC5", "ETSI1", "ETSI2", "ETSI3", "ETSI4", "ETSI5", "ETSI6" if waveform == "FCCO": @@ -1443,10 +1593,10 @@ class L3VariableTime(Realm): return width, interval, count - def dfs_get_frequency(self,channel): + def dfs_get_frequency(self, channel): # possibly have a dictionary - if channel == "36": + if channel == "36": frequency = "5180000" elif channel == "38": frequency = "5190000" @@ -1511,15 +1661,14 @@ class L3VariableTime(Realm): logg.info("Invalid Channel") exit(1) return frequency - - def dfs_send_radar(self,channel): + def dfs_send_radar(self, channel): # Hard coded to FCC0 - need to support others width_ = "1" interval_ = "1428" count_ = "18" frequency_ = "5260000" # channel 52 - #sweep_time_ = "1000" + # sweep_time_ = "1000" sweep_time_ = "0" if_gain_ = "40" bb_gain_ = "20" @@ -1537,7 +1686,7 @@ class L3VariableTime(Realm): time.sleep(0.4) # for testing bash - i = child.expect([r'\$',pexpect.TIMEOUT],timeout=2) + i = child.expect([r'\$', pexpect.TIMEOUT], timeout=2) if i == 0: logg.info("i: {} received bash prompt for hackrf command".format(i)) if i == 1: @@ -1574,65 +1723,91 @@ class L3VariableTime(Realm): ################################# # With timeouts ################################# - command_hackRF = "sudo python lf_hackrf.py --pulse_width {} --pulse_interval {} --pulse_count {} --sweep_time {} --freq {} --if_gain {} --bb_gain {} --gain {}".format(width_,interval_,count_,sweep_time_,frequency_,if_gain_,bb_gain_,gain_) + command_hackRF = "sudo python lf_hackrf.py --pulse_width {} --pulse_interval {} --pulse_count {} --sweep_time {} --freq {} --if_gain {} --bb_gain {} --gain {}".format( + width_, interval_, count_, sweep_time_, frequency_, if_gain_, bb_gain_, gain_) logg.info("hackrf command {}".format(command_hackRF)) child.sendline(command_hackRF) time.sleep(0.4) - i = child.expect(['lanforge:',pexpect.TIMEOUT], timeout=2) + i = child.expect(['lanforge:', pexpect.TIMEOUT], timeout=2) if i == 0: - logg.info("lanforge prompt received i: {} before {} after {}".format(i,child.before.decode('utf-8', 'ignore'),child.after.decode('utf-8', 'ignore'))) + logg.info( + "lanforge prompt received i: {} before {} after {}".format(i, child.before.decode('utf-8', 'ignore'), + child.after.decode('utf-8', 'ignore'))) child.sendline('lanforge') time.sleep(0.4) self.dfs_epoch_start = int(time.time()) - j = child.expect(['>>>',pexpect.TIMEOUT], timeout=5) + j = child.expect(['>>>', pexpect.TIMEOUT], timeout=5) if j == 0: - logg.info(">>> prompt received i: {} j: {} before {} after {}".format(i,j,child.before.decode('utf-8', 'ignore'),child.after.decode('utf-8', 'ignore'))) + logg.info(">>> prompt received i: {} j: {} before {} after {}".format(i, j, child.before.decode('utf-8', + 'ignore'), + child.after.decode('utf-8', + 'ignore'))) logg.info("Let the radar run for {}".format(self.radar_duration_seconds)) time.sleep(self.radar_duration_seconds) - child.sendline('s') # stop + child.sendline('s') # stop time.sleep(0.4) - k = child.expect(['>>>',pexpect.TIMEOUT], timeout=2) + k = child.expect(['>>>', pexpect.TIMEOUT], timeout=2) if k == 0: - logg.info(">>> prompt received i: {} j: {} k: {} before {} after {}".format(i,j,k,child.before.decode('utf-8', 'ignore'),child.after.decode('utf-8', 'ignore'))) + logg.info(">>> prompt received i: {} j: {} k: {} before {} after {}".format(i, j, k, + child.before.decode( + 'utf-8', 'ignore'), + child.after.decode( + 'utf-8', 'ignore'))) logg.info("send q - for quit") child.sendline('q') time.sleep(1) if k == 1: - logg.info("TIMEOUT hackrf >>> prompt i: {} j: {} k: {} before {} after {}".format(i,j,k,child.before.decode('utf-8', 'ignore'),child.after)) + logg.info("TIMEOUT hackrf >>> prompt i: {} j: {} k: {} before {} after {}".format(i, j, k, + child.before.decode( + 'utf-8', + 'ignore'), + child.after)) if j == 1: - logg.info("TIMEOUT hackrf >>> prompt i: {} j: {} before {} after {}".format(i,j,child.before.decode('utf-8', 'ignore'),child.after)) + logg.info("TIMEOUT hackrf >>> prompt i: {} j: {} before {} after {}".format(i, j, + child.before.decode('utf-8', + 'ignore'), + child.after)) if i == 1: - logg.info("TIMEOUT lanforge password prompt i: {} before {} after {}".format(i,child.before.decode('utf-8', 'ignore'),child.after)) - + logg.info("TIMEOUT lanforge password prompt i: {} before {} after {}".format(i, child.before.decode('utf-8', + 'ignore'), + child.after)) + time.sleep(2) def ap_cac_verify(self): - if(bool(self.ap_dict)): + if bool(self.ap_dict): pss = "" # will need to verify that timer has timed out on AP - need in results logg.info("DFS channel 5ghz {} done waiting CAC time, 2.4 ghz: {}".format(self.chan_5ghz, self.chan_24ghz)) - logg.info("##################################################################") + logg.info("##################################################################") logg.info("# READ changed to DFS channel {}, running CAC for 60 seconds.".format(self.chan_5ghz)) - logg.info("# READ AP CAC_EXPIRY_EVT: CAC finished on DFS channel ") + logg.info("# READ AP CAC_EXPIRY_EVT: CAC finished on DFS channel ") logg.info("##################################################################") logg.info("ap_dict {}".format(self.ap_dict)) - logg.info("Read AP action: {} ap_scheme: {} ap_ip: {} ap_port: {} ap_user: {} ap_pw: {} ap_tty: {} ap_baud: {}".format("show_log",self.ap_dict['ap_scheme'],self.ap_dict['ap_ip'],self.ap_dict["ap_port"], - self.ap_dict['ap_user'],self.ap_dict['ap_pw'],self.ap_dict['ap_tty'],self.ap_dict['ap_baud'])) + logg.info( + "Read AP action: {} ap_scheme: {} ap_ip: {} ap_port: {} ap_user: {} ap_pw: {} ap_tty: {} ap_baud: {}".format( + "show_log", self.ap_dict['ap_scheme'], self.ap_dict['ap_ip'], self.ap_dict["ap_port"], + self.ap_dict['ap_user'], self.ap_dict['ap_pw'], self.ap_dict['ap_tty'], self.ap_dict['ap_baud'])) try: logg.info("ap_ctl.py: read for CAC timer and CAC_EXPIRY_EVT") # TODO remove position dependence if in tree - ap_info= subprocess.run(["./../ap_ctl.py", "--scheme", self.ap_dict['ap_scheme'], "--prompt", self.ap_dict['ap_prompt'],"--dest", self.ap_dict['ap_ip'], "--port", self.ap_dict["ap_port"], - "--user", self.ap_dict['ap_user'], "--passwd", self.ap_dict['ap_pw'],"--tty", self.ap_dict['ap_tty'],"--baud", self.ap_dict['ap_baud'],"--action", "show_log"],capture_output=True, check=True) + ap_info = subprocess.run( + ["./../ap_ctl.py", "--scheme", self.ap_dict['ap_scheme'], "--prompt", self.ap_dict['ap_prompt'], + "--dest", self.ap_dict['ap_ip'], "--port", self.ap_dict["ap_port"], + "--user", self.ap_dict['ap_user'], "--passwd", self.ap_dict['ap_pw'], "--tty", + self.ap_dict['ap_tty'], "--baud", self.ap_dict['ap_baud'], "--action", "show_log"], + capture_output=True, check=True) try: pss = ap_info.stdout.decode('utf-8', 'ignore') except: logg.info("ap_info was of type NoneType will set pss empty") - + except subprocess.CalledProcessError as process_error: - logg.info("###################################################") - logg.info("# CHECK IF AP HAS CONNECTION ALREADY ACTIVE") - logg.info("###################################################") - logg.info("# Unable to commicate to AP error code: {} output {}".format(process_error.returncode, process_error.output)) + logg.info("###################################################") + logg.info("# CHECK IF AP HAS CONNECTION ALREADY ACTIVE") + logg.info("###################################################") + logg.info("# Unable to commicate to AP error code: {} output {}".format(process_error.returncode, + process_error.output)) logg.info("###################################################") logg.info(pss) # fine CAC_TIMER @@ -1640,10 +1815,10 @@ class L3VariableTime(Realm): logg.info("ap: CAC_EXPIRY_EVT {}".format(line)) pat = 'changed to DFS channel\s+(\S+),\s+\S+\s+\S+\s+\S+\s+(\S+)' m = re.search(pat, line) - if (m != None): + if m != None: dfs_channel = m.group(1) cac_time = m.group(2) - logg.info("dfs_channel: {} cac_time: {}".format(dfs_channel,cac_time)) + logg.info("dfs_channel: {} cac_time: {}".format(dfs_channel, cac_time)) logg.info("dfs_cac line: {}".format(line)) self.CAC_TIMER = line break @@ -1653,7 +1828,7 @@ class L3VariableTime(Realm): logg.info("ap: CAC_EXPIRY_EVT {}".format(line)) pat = 'CAC_EXPIRY_EVT:\s+\S+\s+\S+\s+\S+\s\S+\s\S+\s(\S+)' m = re.search(pat, line) - if (m != None): + if m != None: dfs_channel = m.group(1) logg.info("dfs_channel: {}".format(dfs_channel)) logg.info("dfs_channel line: {}".format(line)) @@ -1661,15 +1836,13 @@ class L3VariableTime(Realm): else: logg.info("ap_dict not set") - def start(self, print_pass=False, print_fail=False): + def start(self, print_pass=False, print_fail=False): best_max_tp_mbps = 0 best_csv_rx_row_data = " " max_tp_mbps = 0 csv_rx_row_data = " " Result = False - - # verify the AP CAC timer and experation self.ap_cac_verify() @@ -1680,13 +1853,14 @@ class L3VariableTime(Realm): logg.info("# INITIAL CHANNEL: {}".format(initial_channel)) logg.info("###########################################") - if (initial_channel != self.chan_5ghz): + if initial_channel != self.chan_5ghz: logg.info("##################################################################") - logg.info("# DFS LOCKOUT? COMMAND LINE CHANNEL: {} NOT EQUAL INITIAL CONTROLLER CHANNEL: {}".format(self.chan_5ghz,initial_channel)) + logg.info("# DFS LOCKOUT? COMMAND LINE CHANNEL: {} NOT EQUAL INITIAL CONTROLLER CHANNEL: {}".format( + self.chan_5ghz, initial_channel)) logg.info("##################################################################") time.sleep(30) - + logg.info("Starting multicast traffic (if any configured)") self.multicast_profile.start_mc(debug_=self.debug) self.multicast_profile.refresh_mc(debug_=self.debug) @@ -1700,7 +1874,7 @@ class L3VariableTime(Realm): end_time = self.parse_time(self.test_duration) + cur_time - logg.info("Monitoring throughput for duration: %s"%(self.test_duration)) + logg.info("Monitoring throughput for duration: %s" % self.test_duration) passes = 0 expected_passes = 0 @@ -1725,7 +1899,7 @@ class L3VariableTime(Realm): logg.info("################################################################") time.sleep(1) - + self.epoch_time = int(time.time()) new_rx_values, rx_drop_percent = self.__get_rx_values() @@ -1752,39 +1926,39 @@ class L3VariableTime(Realm): self._fail("FAIL: Not all stations increased traffic", print_fail) old_rx_values = new_rx_values - #percentage dropped not needed for scaling and performance , needed for longevity - #self.__record_rx_dropped_percent(rx_drop_percent) + # percentage dropped not needed for scaling and performance , needed for longevity + # self.__record_rx_dropped_percent(rx_drop_percent) cur_time = datetime.datetime.now() - final_channel = self.read_channel() logg.info("###########################################") logg.info("# FINAL CHANNEL : {}".format(final_channel)) logg.info("###########################################") - dfs_channel_bw20_values = [52, 56, 60, 64, 68, 96, 100, 104, 108, 112, 116, 120, 124 ,128, 132, 136, 140, 144] + dfs_channel_bw20_values = [52, 56, 60, 64, 68, 96, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144] pass_fail = "pass" if int(final_channel) in dfs_channel_bw20_values: logg.info("FAIL: The DFS channel did not change or initial channel was not DFS") pass_fail = "fail" - if (initial_channel != self.chan_5ghz): - logg.info("FAIL: channel set on command line: {} not configured in controller: {} is there a DFS lockout condition".format(self.chan_5ghz,initial_channel)) + if initial_channel != self.chan_5ghz: + logg.info( + "FAIL: channel set on command line: {} not configured in controller: {} is there a DFS lockout condition".format( + self.chan_5ghz, initial_channel)) pass_fail = "fail" blacklist_time = self.read_auto_rf() - best_csv_rx_row_data.append(initial_channel) best_csv_rx_row_data.append(final_channel) best_csv_rx_row_data.append(pass_fail) best_csv_rx_row_data.append(self.CAC_TIMER) best_csv_rx_row_data.append(self.CAC_EXPIRY_EVT) best_csv_rx_row_data.append(blacklist_time) - self.csv_add_row(best_csv_rx_row_data,self.csv_results_writer,self.csv_results) + self.csv_add_row(best_csv_rx_row_data, self.csv_results_writer, self.csv_results) # TO DO check to see if the data is still being transmitted if passes == expected_passes: @@ -1802,12 +1976,10 @@ class L3VariableTime(Realm): self.multicast_profile.cleanup() for station_profile in self.station_profiles: station_profile.cleanup() - - + def csv_generate_column_headers(self): - csv_rx_headers = self.test_keys.copy() - csv_rx_headers.extend - csv_rx_headers.extend(['max_tp_mbps','expected_tp','test_id','epoch_time','time','monitor','pass_fail']) + csv_rx_headers = self.test_keys.copy() + csv_rx_headers.extend(['max_tp_mbps', 'expected_tp', 'test_id', 'epoch_time', 'time', 'monitor', 'pass_fail']) '''for i in range(1,6): csv_rx_headers.append("least_rx_data {}".format(i)) for i in range(1,6): @@ -1816,9 +1988,10 @@ class L3VariableTime(Realm): return csv_rx_headers def csv_generate_column_results_headers(self): - csv_rx_headers = self.test_keys.copy() - csv_rx_headers.extend - csv_rx_headers.extend(['max_tp_mbps','expected_tp','test_id','epoch_time','time','initial_channel','final_channel','pass_fail','cac_timer','cac_expiry_evt','blacklist_time_sec_remaining']) + csv_rx_headers = self.test_keys.copy() + csv_rx_headers.extend( + ['max_tp_mbps', 'expected_tp', 'test_id', 'epoch_time', 'time', 'initial_channel', 'final_channel', + 'pass_fail', 'cac_timer', 'cac_expiry_evt', 'blacklist_time_sec_remaining']) '''for i in range(1,6): csv_rx_headers.append("least_rx_data {}".format(i)) for i in range(1,6): @@ -1826,27 +1999,27 @@ class L3VariableTime(Realm): csv_rx_headers.append("average_rx_data")''' return csv_rx_headers - - def csv_add_column_headers(self,headers): + def csv_add_column_headers(self, headers): if self.csv_file is not None: self.csv_writer.writerow(headers) self.csv_file.flush() - def csv_add_column_headers_results(self,headers): + def csv_add_column_headers_results(self, headers): if self.csv_results is not None: self.csv_results_writer.writerow(headers) - self.csv_results.flush() + self.csv_results.flush() def csv_validate_list(self, csv_list, length): if len(csv_list) < length: - csv_list = csv_list + [('no data','no data')] * (length - len(csv_list)) + csv_list = csv_list + [('no data', 'no data')] * (length - len(csv_list)) return csv_list - def csv_add_row(self,row,writer,csv_file): # can make two calls eventually + def csv_add_row(self, row, writer, csv_file): # can make two calls eventually if csv_file is not None: writer.writerow(row) csv_file.flush() + ######################################### # # AP helper functions @@ -1856,13 +2029,15 @@ class L3VariableTime(Realm): def valid_endp_types(_endp_type): etypes = _endp_type.split() for endp_type in etypes: - valid_endp_type=['lf_udp','lf_udp6','lf_tcp','lf_tcp6','mc_udp','mc_udp6'] + valid_endp_type = ['lf_udp', 'lf_udp6', 'lf_tcp', 'lf_tcp6', 'mc_udp', 'mc_udp6'] if not (str(endp_type) in valid_endp_type): - logg.info('invalid endp_type: %s. Valid types lf_udp, lf_udp6, lf_tcp, lf_tcp6, mc_udp, mc_udp6' % endp_type) + logg.info( + 'invalid endp_type: %s. Valid types lf_udp, lf_udp6, lf_tcp, lf_tcp6, mc_udp, mc_udp6' % endp_type) exit(1) return _endp_type -########################################## + +########################################## # Traffic Generation End ########################################## @@ -1876,12 +2051,12 @@ def main(): parser = argparse.ArgumentParser( prog='lf_dfs_test.py', - #formatter_class=argparse.RawDescriptionHelpFormatter, + # formatter_class=argparse.RawDescriptionHelpFormatter, formatter_class=argparse.RawTextHelpFormatter, epilog='''\ Scaling and Performance ''', - + description='''\ lf_dfs_test.py: -------------------- @@ -2095,95 +2270,136 @@ Sample script 2/11/2021 # reorder to follow looping - parser.add_argument('-cca' ,'--controller_ap', help='--controller_ap List of APs to test default: Axel',default="APA453.0E7B.CF9C") - parser.add_argument('-ccf' ,'--controller_band', help='--controller_band default a',default="a") + parser.add_argument('-cca', '--controller_ap', help='--controller_ap List of APs to test default: Axel', + default="APA453.0E7B.CF9C") + parser.add_argument('-ccf', '--controller_band', help='--controller_band default a', default="a") # controller wanted 11ax , 11ac, 11n, 11gb - parser.add_argument('-cwm' ,'--controller_wifimode', help='List of of wifi mode to test <11ax 11ac 11n 11gb> default: an',default="an", - choices=[ "auto", "a", "b", "g", "abg", "abgn", "bgn", "bg", "abgnAC", "anAC", "an", "bgnAC", "abgnAX", "bgnAX", "anAX"]) + parser.add_argument('-cwm', '--controller_wifimode', + help='List of of wifi mode to test <11ax 11ac 11n 11gb> default: an', default="an", + choices=["auto", "a", "b", "g", "abg", "abgn", "bgn", "bg", "abgnAC", "anAC", "an", "bgnAC", + "abgnAX", "bgnAX", "anAX"]) - parser.add_argument('-cc5','--controller_chan_5ghz', help='--controller_chan_5ghz <36 40 ...> default 36',default="36") - parser.add_argument('-cc2','--controller_chan_24ghz', help='--controller_chan_24ghz <1 2 ...> default 1',default="1") - parser.add_argument('-ccw','--controller_chan_width', help='--controller_chan_width <20 40 80 160> default: 20',default="20") - parser.add_argument('-cam','--controller_ap_mode', help='--controller_ap_mode default local',default="local") - parser.add_argument('-cps','--controller_packet_size', help='--controller_packet_size List of packet sizes <88 512 1370 1518> default 1518 ',default="1518" ) - parser.add_argument('-ctd','--controller_directions', help='--controller_directions default: upstream downstream ',default="upstream downstream" ) - parser.add_argument('-ccd','--controller_client_density', help='--controller_client_density List of client densities <1 10 20 50 100 200> default 1 ', - default="1" ) - #TODO set str for ones that are str - parser.add_argument('-cde','--controller_data_encryption', help='--controller_data_encryption \"enable disable\"',default="disable" ) - parser.add_argument('-cs' ,'--controller_series', help='--controller_series <9800 | 3504>',default="3504",choices=["9800","3504"]) - parser.add_argument('-ccp','--controller_prompt', type=str,help="controller prompt default WLC",default="WLC") - parser.add_argument('-cas','--controller_ap_slot', type=str,help="AP slot, default 1",default="1") + parser.add_argument('-cc5', '--controller_chan_5ghz', help='--controller_chan_5ghz <36 40 ...> default 36', + default="36") + parser.add_argument('-cc2', '--controller_chan_24ghz', help='--controller_chan_24ghz <1 2 ...> default 1', + default="1") + parser.add_argument('-ccw', '--controller_chan_width', help='--controller_chan_width <20 40 80 160> default: 20', + default="20") + parser.add_argument('-cam', '--controller_ap_mode', help='--controller_ap_mode default local', + default="local") + parser.add_argument('-cps', '--controller_packet_size', + help='--controller_packet_size List of packet sizes <88 512 1370 1518> default 1518 ', + default="1518") + parser.add_argument('-ctd', '--controller_directions', + help='--controller_directions default: upstream downstream ', + default="upstream downstream") + parser.add_argument('-ccd', '--controller_client_density', + help='--controller_client_density List of client densities <1 10 20 50 100 200> default 1 ', + default="1") + # TODO set str for ones that are str + parser.add_argument('-cde', '--controller_data_encryption', help='--controller_data_encryption \"enable disable\"', + default="disable") + parser.add_argument('-cs', '--controller_series', help='--controller_series <9800 | 3504>', default="3504", + choices=["9800", "3504"]) + parser.add_argument('-ccp', '--controller_prompt', type=str, help="controller prompt default WLC", default="WLC") + parser.add_argument('-cas', '--controller_ap_slot', type=str, help="AP slot, default 1", default="1") - parser.add_argument('-cc' ,'--controller_ip', help='--controller_ip default 192.168.100.178',default="192.168.100.178") - parser.add_argument('-cp' ,'--controller_port', help='--controller_port ssh default 22',default="22") - parser.add_argument('-cu' ,'--controller_user', help='--controller_user ',default="admin") - parser.add_argument('-cpw','--controller_passwd', help='--controller_passwd ',default="controller123") - parser.add_argument('-ccs','--controller_scheme', help='--controller_scheme (serial|telnet|ssh): connect via serial, ssh or telnet',default="ssh",choices=["serial","telnet","ssh"]) - parser.add_argument('-cw' ,'--controller_wlan', help='--controller_wlan ',required=True) - parser.add_argument('-cwi','--controller_wlanID', help='--controller_wlanID ',required=True) - parser.add_argument('-cws' ,'--controller_wlanSSID', help='--controller_wlanSSID ',required=True) + parser.add_argument('-cc', '--controller_ip', + help='--controller_ip default 192.168.100.178', + default="192.168.100.178") + parser.add_argument('-cp', '--controller_port', + help='--controller_port ssh default 22', default="22") + parser.add_argument('-cu', '--controller_user', help='--controller_user ', + default="admin") + parser.add_argument('-cpw', '--controller_passwd', help='--controller_passwd ', + default="controller123") + parser.add_argument('-ccs', '--controller_scheme', + help='--controller_scheme (serial|telnet|ssh): connect via serial, ssh or telnet', + default="ssh", choices=["serial", "telnet", "ssh"]) + parser.add_argument('-cw', '--controller_wlan', help='--controller_wlan ', required=True) + parser.add_argument('-cwi', '--controller_wlanID', help='--controller_wlanID ', required=True) + parser.add_argument('-cws', '--controller_wlanSSID', help='--controller_wlanSSID ', required=True) - parser.add_argument('-ctp','--controller_tx_power', help='--controller_tx_power <1 | 2 | 3 | 4 | 5 | 6 | 7 | 8> 1 is highest power default NA NA means no change',default="NA" - ,choices=["1","2","3","4","5","6","7","8","NA"]) - parser.add_argument('-dfs','--controller_dfs', help='--controller_dfs, switch to enable dfs testing', action='store_true') - parser.add_argument('-dft','--controller_dfs_time', help='--controller_dfs_time, time to wait prior to sending radar signal default 30s', default='30s') - parser.add_argument('-hrd','--radar_duration', help='--radar_duration, hack rf radar duration default 5s', default='5s') - parser.add_argument('-cco','--cap_ctl_out', help='--cap_ctl_out , switch the controller controller output will be captured', action='store_true') - + parser.add_argument('-ctp', '--controller_tx_power', + help='--controller_tx_power <1 | 2 | 3 | 4 | 5 | 6 | 7 | 8> 1 is highest power default NA NA means no change', + default="NA" + , choices=["1", "2", "3", "4", "5", "6", "7", "8", "NA"]) + parser.add_argument('-dfs', '--controller_dfs', help='--controller_dfs, switch to enable dfs testing', + action='store_true') + parser.add_argument('-dft', '--controller_dfs_time', + help='--controller_dfs_time, time to wait prior to sending radar signal default 30s', + default='30s') + parser.add_argument('-hrd', '--radar_duration', help='--radar_duration, hack rf radar duration default 5s', + default='5s') + parser.add_argument('-cco', '--cap_ctl_out', + help='--cap_ctl_out , switch the controller controller output will be captured', + action='store_true') - parser.add_argument('-apr','--amount_ports_to_reset', help='--amount_ports_to_reset \" \" ', default=None) - parser.add_argument('-prs','--port_reset_seconds', help='--ports_reset_seconds \" \" ', default="10 30") + parser.add_argument('-apr', '--amount_ports_to_reset', + help='--amount_ports_to_reset \" \" ', default=None) + parser.add_argument('-prs', '--port_reset_seconds', help='--ports_reset_seconds \" \" ', + default="10 30") - parser.add_argument('-lm','--mgr', help='--mgr ',default='localhost') - parser.add_argument('-d','--test_duration', help='--test_duration example --time 5d (5 days) default: 2m options: number followed by d, h, m or s',default='2m') - parser.add_argument('-pi','--polling_interval', help="--polling_interval ", default='30s') - parser.add_argument('--tos', help='--tos: Support different ToS settings: BK | BE | VI | VO | numeric',default="BE") - parser.add_argument('-db','--debug', help='--debug: Enable debugging',action='store_true') - parser.add_argument('-t', '--endp_type', help='--endp_type example --endp_type \"lf_udp lf_tcp mc_udp\" Default: lf_tcp, options: lf_udp, lf_udp6, lf_tcp, lf_tcp6, mc_udp, mc_udp6', + parser.add_argument('-lm', '--mgr', help='--mgr ', default='localhost') + parser.add_argument('-d', '--test_duration', + help='--test_duration example --time 5d (5 days) default: 2m options: number followed by d, h, m or s', + default='2m') + parser.add_argument('-pi', '--polling_interval', help="--polling_interval ", default='30s') + parser.add_argument('--tos', help='--tos: Support different ToS settings: BK | BE | VI | VO | numeric', + default="BE") + parser.add_argument('-db', '--debug', help='--debug: Enable debugging', action='store_true') + parser.add_argument('-t', '--endp_type', + help='--endp_type example --endp_type \"lf_udp lf_tcp mc_udp\" Default: lf_tcp, options: lf_udp, lf_udp6, lf_tcp, lf_tcp6, mc_udp, mc_udp6', default='lf_tcp', type=valid_endp_types) - parser.add_argument('-u', '--upstream_port', help='--upstream_port example: --upstream_port eth1',default='eth1') - parser.add_argument('-o','--csv_outfile', help="--csv_outfile ", default='dfs') - parser.add_argument("-l", "--log", action='store_true', help="create logfile for messages, default stdout") - parser.add_argument('-c','--csv_output', help="Generate csv output", default=True) + parser.add_argument('-u', '--upstream_port', + help='--upstream_port example: --upstream_port eth1', + default='eth1') + parser.add_argument('-o', '--csv_outfile', help="--csv_outfile ", default='dfs') + parser.add_argument("-l", "--log", action='store_true', help="create logfile for messages, default stdout") + parser.add_argument('-c', '--csv_output', help="Generate csv output", default=True) - #to do add wifimode - parser.add_argument('-r','--radio', action='append', nargs=1, help='--radio \ - \"radio== ssid== ssid_pw== security== wifimode==\" '\ + # to do add wifimode + parser.add_argument('-r', '--radio', action='append', nargs=1, help='--radio \ + \"radio== ssid== ssid_pw== security== wifimode==\" ' , required=False) - parser.add_argument('-amr','--side_a_min_bps', help='--side_a_min_bps, station min tx bits per second default 9600', default=9600) - parser.add_argument('-amp','--side_a_min_pdu', help='--side_a_min_pdu , station ipdu size default 1518', default=1518) - parser.add_argument('-bmr','--side_b_min_bps', help='--side_b_min_bps , upstream min tx rate default 256000', default=9600) - parser.add_argument('-bmp','--side_b_min_pdu', help='--side_b_min_pdu , upstream pdu size default 1518', default=1518) + parser.add_argument('-amr', '--side_a_min_bps', + help='--side_a_min_bps, station min tx bits per second default 9600', default=9600) + parser.add_argument('-amp', '--side_a_min_pdu', help='--side_a_min_pdu , station ipdu size default 1518', + default=1518) + parser.add_argument('-bmr', '--side_b_min_bps', help='--side_b_min_bps , upstream min tx rate default 256000', + default=9600) + parser.add_argument('-bmp', '--side_b_min_pdu', help='--side_b_min_pdu , upstream pdu size default 1518', + default=1518) # AP parameters - parser.add_argument('-api','--ap_info', action='append', nargs=1, type=str, \ - help='(enter 0 if does not apply) --ap_info \"ap_scheme== ap_prompt== ap_ip== ap_port== ap_user== ap_pw== ap_tty==\" ') - #--ap_info "ap_scheme==serial ap_prompt==APA53.0E7B.CF9C ap_ip==0 ap_port==0 ap_user==admin ap_pw==Admin123 ap_tty==/dev/ttyUSB2" + parser.add_argument('-api', '--ap_info', action='append', nargs=1, type=str, + help='(enter 0 if does not apply) --ap_info \"ap_scheme== ap_prompt== ap_ip== ap_port== ap_user== ap_pw== ap_tty==\" ') + # --ap_info "ap_scheme==serial ap_prompt==APA53.0E7B.CF9C ap_ip==0 ap_port==0 ap_user==admin ap_pw==Admin123 ap_tty==/dev/ttyUSB2" '''./lf_dfs_test.py -cc 192.168.100.112 -cu admin -cpw controller123 -cca APA453.0E7B.CF9C -ccf "a" -cwm "auto" -cc5 "36" \ -ccw "20" -ccd "1" -cs "3504" --endp_type 'lf_udp' --upstream_port eth2 --controller_wlan "test_candela" --controller_wlanID 1 \ --controller_wlanSSID "test_candela" --controller_directions "upstream" --controller_prompt "(controller Controller)" \ --radio "radio==1.wiphy0 stations==1 ssid==test_candela ssid_pw==[BLANK] security==open wifimode==auto" \ - --ap_info "ap_scheme==serial ap_prompt--APA53.0E7B.EF9C ap_ip==0 ap_port==0 ap_baud==9600 ap_user==admin ap_pw==Admin123 ap_tty==/dev/ttyUSB2" ''' - + --ap_info "ap_scheme==serial ap_prompt--APA53.0E7B.EF9C ap_ip==0 ap_port==0 ap_baud==9600 ap_user==admin ap_pw==Admin123 ap_tty==/dev/ttyUSB2" ''' # Parameters that allow for testing - parser.add_argument('-noc','--no_controller', help='--no_controller no configuration of the controller', action='store_true') - parser.add_argument('-nos','--no_stations', help='--no_stations , no stations', action='store_true') - parser.add_argument('-wto','--wait_timeout', help='--wait_timeout , time to wait for stations to get IP ', default="120") + parser.add_argument('-noc', '--no_controller', help='--no_controller no configuration of the controller', + action='store_true') + parser.add_argument('-nos', '--no_stations', help='--no_stations , no stations', action='store_true') + parser.add_argument('-wto', '--wait_timeout', help='--wait_timeout , time to wait for stations to get IP ', + default="120") args = parser.parse_args() controller_args = args - #logg.info("args: {}".format(args)) + # logg.info("args: {}".format(args)) debug_on = args.debug ################################################################## # Gather Test Data ################################################################# - + if args.test_duration: test_duration = args.test_duration @@ -2204,19 +2420,19 @@ Sample script 2/11/2021 if args.csv_outfile != None: current_time = time.strftime("%m_%d_%Y_%H_%M_%S", time.localtime()) - csv_outfile = "{}_{}.csv".format(args.csv_outfile,current_time) - csv_results = "results_{}_{}.csv".format(args.csv_outfile,current_time) + csv_outfile = "{}_{}.csv".format(args.csv_outfile, current_time) + csv_results = "results_{}_{}.csv".format(args.csv_outfile, current_time) print("csv output file : {}".format(csv_outfile)) - + if args.log: - outfile_log = "{}_{}_output_log.log".format(args.outfile,current_time) + outfile_log = "{}_{}_output_log.log".format(args.outfile, current_time) print("output file log: {}".format(outfile_log)) else: outfile_log = "stdout" - print("output file log: {}".format(outfile_log)) + print("output file log: {}".format(outfile_log)) if args.wait_timeout: - wait_timeout = int(args.wait_timeout) + wait_timeout = int(args.wait_timeout) if args.controller_scheme: __scheme = args.controller_scheme @@ -2231,7 +2447,7 @@ Sample script 2/11/2021 __prompt = args.controller_prompt if args.controller_series: - __series = args.controller_series + __series = args.controller_series if args.controller_user: __user = args.controller_user @@ -2243,7 +2459,7 @@ Sample script 2/11/2021 __cap_ctl_out = args.cap_ctl_out else: __cap_ctl_out = False - + if args.controller_ap_slot: __ap_slot = args.controller_ap_slot @@ -2263,27 +2479,27 @@ Sample script 2/11/2021 ap_info = args.ap_info for _ap_info in ap_info: print("ap_info {}".format(_ap_info)) - ap_keys = ['ap_scheme','ap_prompt','ap_ip','ap_port','ap_user','ap_pw', 'ap_tty', 'ap_baud'] - ap_dict = dict(map(lambda x: x.split('=='), str(_ap_info).replace('[','').replace(']','').replace("'","").split())) + ap_keys = ['ap_scheme', 'ap_prompt', 'ap_ip', 'ap_port', 'ap_user', 'ap_pw', 'ap_tty', 'ap_baud'] + ap_dict = dict( + map(lambda x: x.split('=='), str(_ap_info).replace('[', '').replace(']', '').replace("'", "").split())) for key in ap_keys: if key not in ap_dict: - print("missing ap config, for the {}, all these need to be set {} ".format(key,ap_keys)) + print("missing ap config, for the {}, all these need to be set {} ".format(key, ap_keys)) exit(1) print("ap_dict: {}".format(ap_dict)) - console_handler = logging.StreamHandler() formatter = logging.Formatter(FORMAT) logg = logging.getLogger(__name__) logg.setLevel(logging.DEBUG) file_handler = None - if (args.log): + if args.log: file_handler = logging.FileHandler(outfile_log, "w") file_handler.setLevel(logging.DEBUG) file_handler.setFormatter(formatter) logg.addHandler(file_handler) - logg.addHandler(logging.StreamHandler(sys.stdout)) # allows to logging to file and stderr + logg.addHandler(logging.StreamHandler(sys.stdout)) # allows to logging to file and stderr # if loggin.basicConfig is called this will result in duplicating log entries # logging.basicConfig(format=FORMAT, handlers=[file_handler]) else: @@ -2291,7 +2507,7 @@ Sample script 2/11/2021 logging.basicConfig(format=FORMAT, handlers=[console_handler]) MAX_NUMBER_OF_STATIONS = 200 - + radio_name_list = [] number_of_stations_per_radio_list = [] ssid_list = [] @@ -2299,58 +2515,56 @@ Sample script 2/11/2021 ssid_security_list = [] wifimode_list = [] - #optional radio configuration + # optional radio configuration reset_port_enable_list = [] reset_port_time_min_list = [] reset_port_time_max_list = [] wifi_mode_dict = { - "auto" : "0", - "a" : "1", - "b" : "2", - "g" : "3", - "abg" : "4", - "abgn" : "5", - "bgn" : "6", - "bg" : "7", - "abgnAC" : "8", - "anAC" : "9", - "an" : "10", - "bgnAC" : "11", - "abgnAX" : "12", - "bgnAX" : "13", - "anAX" : "14" - } + "auto": "0", + "a": "1", + "b": "2", + "g": "3", + "abg": "4", + "abgn": "5", + "bgn": "6", + "bg": "7", + "abgnAC": "8", + "anAC": "9", + "an": "10", + "bgnAC": "11", + "abgnAX": "12", + "bgnAX": "13", + "anAX": "14" + } - dfs_channel_bw20_values = [52, 56, 60, 64, 68, 96, 100, 104, 108, 112, 116, 120, 124 ,128, 132, 136, 140, 144] + dfs_channel_bw20_values = [52, 56, 60, 64, 68, 96, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144] - - - - controller_aps = args.controller_ap.split() - controller_bands = args.controller_band.split() - controller_wifimodes = args.controller_wifimode.split() + controller_aps = args.controller_ap.split() + controller_bands = args.controller_band.split() + controller_wifimodes = args.controller_wifimode.split() for mode in controller_wifimodes: if mode in wifi_mode_dict.keys(): pass else: - logg.info("wifimode [{}] not recognised. Please use: auto, a, b, g, abg, abgn, bgn, bg, abgnAC, anAC, an, bgnAC, abgnAX, bgnAX, anAX".format(mode)) + logg.info( + "wifimode [{}] not recognised. Please use: auto, a, b, g, abg, abgn, bgn, bg, abgnAC, anAC, an, bgnAC, abgnAX, bgnAX, anAX".format( + mode)) exit(1) - controller_tx_powers = "3".split() - controller_chan_5ghzs = args.controller_chan_5ghz.split() - controller_chan_24ghzs = args.controller_chan_24ghz.split() - controller_chan_widths = args.controller_chan_width.split() - controller_ap_modes = args.controller_ap_mode.split() - controller_client_densities = args.controller_client_density.split() - controller_packet_types = args.endp_type.split() - controller_directions = args.controller_directions.split() - #controller_directions = "upstream".split() - controller_packet_sizes = args.controller_packet_size.split() - controller_data_encryptions = args.controller_data_encryption.split() - controller_side_a_min_bps = args.side_a_min_bps - controller_side_b_min_bps = args.side_b_min_bps + controller_tx_powers = "3".split() + controller_chan_5ghzs = args.controller_chan_5ghz.split() + controller_chan_24ghzs = args.controller_chan_24ghz.split() + controller_chan_widths = args.controller_chan_width.split() + controller_ap_modes = args.controller_ap_mode.split() + controller_client_densities = args.controller_client_density.split() + controller_packet_types = args.endp_type.split() + controller_directions = args.controller_directions.split() + # controller_directions = "upstream".split() + controller_packet_sizes = args.controller_packet_size.split() + controller_data_encryptions = args.controller_data_encryption.split() + controller_side_a_min_bps = args.side_a_min_bps + controller_side_b_min_bps = args.side_b_min_bps - logg.info(controller_aps) logg.info(controller_bands) logg.info(controller_wifimodes) @@ -2368,18 +2582,17 @@ Sample script 2/11/2021 else: logg.info("AP NO login information") + __ap_set = None + __band_set = None + __chan_width_set = None + __ap_mode_set = None + __tx_power_set = None + __chan_5ghz_set = None + __chan_24ghz_set = None + __csv_started = False - __ap_set = None - __band_set = None - __chan_width_set = None - __ap_mode_set = None - __tx_power_set = None - __chan_5ghz_set = None - __chan_24ghz_set = None - __csv_started = False - - __dfs_channel = None - __cac_timer_time = 0 + __dfs_channel = None + __cac_timer_time = 0 __dfs_chan_switch_to = None for controller_ap in controller_aps: @@ -2387,79 +2600,96 @@ Sample script 2/11/2021 for controller_wifimode in controller_wifimodes: # check for valid frequency and wifi_mode combination put here to simplify logic since all radios do not support all modes # "an anAX anAC abgn bg" - if((controller_band == "a" and controller_wifimode == "bg") or (controller_band == "b" and controller_wifimode == "anAC")): + if ((controller_band == "a" and controller_wifimode == "bg") or ( + controller_band == "b" and controller_wifimode == "anAC")): logg.info("#######################################################################") - logg.info("# Skipping combination controller_band {} controller_wifimode {}".format(controller_band,controller_wifimode)) + logg.info("# Skipping combination controller_band {} controller_wifimode {}".format(controller_band, + controller_wifimode)) logg.info("#######################################################################") - pass # invalid combination continue + pass # invalid combination continue else: # TODO the following - #[(x, y, z) for x in [1,2,3] for y in [4,5,6] for z in [7,8,9] if x != z]: + # [(x, y, z) for x in [1,2,3] for y in [4,5,6] for z in [7,8,9] if x != z]: for controller_tx_power in controller_tx_powers: for controller_chan_5ghz in controller_chan_5ghzs: for controller_chan_24ghz in controller_chan_24ghzs: - for controller_chan_width in controller_chan_widths: #bandwidth + for controller_chan_width in controller_chan_widths: # bandwidth for controller_data_encryption in controller_data_encryptions: for controller_ap_mode in controller_ap_modes: for controller_client_density in controller_client_densities: for controller_packet_type in controller_packet_types: for controller_direction in controller_directions: for controller_packet_size in controller_packet_sizes: - logg.info("#####################################################") - logg.info("# TEST RUNNING , TEST RUNNING ######################") - logg.info("#####################################################") + logg.info( + "#####################################################") + logg.info( + "# TEST RUNNING , TEST RUNNING ######################") + logg.info( + "#####################################################") test_config = "AP=={} Band=={} chan_5ghz=={} chan_24ghz=={} wifi_mode=={} BW=={} encryption=={} ap_mode=={} clients=={} packet_type=={} direction=={} packet_size=={}".format( - controller_ap,controller_band,controller_chan_5ghz,controller_chan_24ghz,controller_wifimode,controller_chan_width,controller_data_encryption,controller_ap_mode,controller_client_density, - controller_packet_type,controller_direction,controller_packet_size) - test_keys = ['AP','Band','wifi_mode','chan_5ghz','chan_24ghz','BW','encryption','ap_mode','clients','packet_type','direction','packet_size'] - logg.info("# controller run settings: {}".format(test_config)) - if(args.no_controller): - logg.info("################################################") + controller_ap, controller_band, controller_chan_5ghz, + controller_chan_24ghz, controller_wifimode, + controller_chan_width, controller_data_encryption, + controller_ap_mode, controller_client_density, + controller_packet_type, controller_direction, + controller_packet_size) + test_keys = ['AP', 'Band', 'wifi_mode', 'chan_5ghz', + 'chan_24ghz', 'BW', 'encryption', 'ap_mode', + 'clients', 'packet_type', 'direction', + 'packet_size'] + logg.info( + "# controller run settings: {}".format(test_config)) + if args.no_controller: + logg.info( + "################################################") logg.info("# NO CONTROLLER SET , TEST MODE") - logg.info("################################################") + logg.info( + "################################################") else: - if( controller_ap != __ap_set or - controller_band != __band_set or - controller_chan_width != __chan_width_set or - controller_ap_mode != __ap_mode_set or - controller_tx_power != __tx_power_set or - controller_chan_5ghz != __chan_5ghz_set or - controller_chan_24ghz != __chan_24ghz_set - ): - logg.info("###############################################") + if (controller_ap != __ap_set or + controller_band != __band_set or + controller_chan_width != __chan_width_set or + controller_ap_mode != __ap_mode_set or + controller_tx_power != __tx_power_set or + controller_chan_5ghz != __chan_5ghz_set or + controller_chan_24ghz != __chan_24ghz_set + ): + logg.info( + "###############################################") logg.info("# NEW CONTROLLER CONFIG") - logg.info("###############################################") - __ap_set = controller_ap - __band_set = controller_band - __chan_width_set = controller_chan_width - __ap_mode_set = controller_ap_mode - __tx_power_set = controller_tx_power - __chan_5ghz_set = controller_chan_5ghz - __chan_24ghz_set = controller_chan_24ghz - __client_density = controller_client_density + logg.info( + "###############################################") + __ap_set = controller_ap + __band_set = controller_band + __chan_width_set = controller_chan_width + __ap_mode_set = controller_ap_mode + __tx_power_set = controller_tx_power + __chan_5ghz_set = controller_chan_5ghz + __chan_24ghz_set = controller_chan_24ghz + __client_density = controller_client_density controller = CreateCtlr( - _scheme=__scheme, - _port=__port, - _series=__series, - _ctlr=__ctlr, - _prompt=__prompt, - _user=__user, - _passwd=__passwd, - _ap=__ap_set, - _band=__band_set, - _chan_5ghz=__chan_5ghz_set, - _chan_24ghz=__chan_24ghz_set, - _chan_width=__chan_width_set, - _ap_mode=__ap_mode_set, - _tx_power=__tx_power_set, - _client_density=__client_density, - _cap_ctl_out=__cap_ctl_out - ) - #Disable AP + _scheme=__scheme, + _port=__port, + _series=__series, + _ctlr=__ctlr, + _prompt=__prompt, + _user=__user, + _passwd=__passwd, + _ap=__ap_set, + _band=__band_set, + _chan_5ghz=__chan_5ghz_set, + _chan_24ghz=__chan_24ghz_set, + _chan_width=__chan_width_set, + _ap_mode=__ap_mode_set, + _tx_power=__tx_power_set, + _client_density=__client_density, + _cap_ctl_out=__cap_ctl_out + ) + # Disable AP # # Controller Configuration # - #if controller_args.controller_series == "9800": + # if controller_args.controller_series == "9800": # controller_controller_no_loggin_console() pss = controller.controller_show_ap_summary() logg.info("pss {}".format(pss)) @@ -2480,54 +2710,98 @@ Sample script 2/11/2021 controller.controller_create_wlan() controller.controller_set_wireless_tag_policy() controller.controller_enable_wlan() - if controller_band == "a": + if controller_band == "a": controller.controller_enable_network_5ghz() - else: + else: controller.controller_enable_network_24ghz() # clear logs on AP /dev/ttyUSB2 - candelatech - if(bool(ap_dict)): + if bool(ap_dict): logg.info("ap_dict {}".format(ap_dict)) - logg.info("Read AP action: {} ap_scheme: {} ap_ip: {} ap_port: {} ap_user: {} ap_pw: {} ap_tty: {} ap_baud: {}".format("show_log",ap_dict['ap_scheme'],ap_dict['ap_ip'],ap_dict["ap_port"], - ap_dict['ap_user'],ap_dict['ap_pw'],ap_dict['ap_tty'],ap_dict['ap_baud'])) + logg.info( + "Read AP action: {} ap_scheme: {} ap_ip: {} ap_port: {} ap_user: {} ap_pw: {} ap_tty: {} ap_baud: {}".format( + "show_log", ap_dict['ap_scheme'], + ap_dict['ap_ip'], ap_dict["ap_port"], + ap_dict['ap_user'], ap_dict['ap_pw'], + ap_dict['ap_tty'], ap_dict['ap_baud'])) # clear log (AP) try: logg.info("ap_ctl.py: clear log") # TODO remove position dependence if in tree - ap_info= subprocess.run(["./../ap_ctl.py", "--scheme", ap_dict['ap_scheme'], "--prompt", ap_dict['ap_prompt'],"--dest", ap_dict['ap_ip'], "--port", ap_dict["ap_port"], - "--user", ap_dict['ap_user'], "--passwd", ap_dict['ap_pw'],"--tty", ap_dict['ap_tty'],"--baud", ap_dict['ap_baud'],"--action", "clear_log"],capture_output=True, check=True)#stdout=subprocess.PIPE) + ap_info = subprocess.run( + ["./../ap_ctl.py", "--scheme", + ap_dict['ap_scheme'], "--prompt", + ap_dict['ap_prompt'], "--dest", + ap_dict['ap_ip'], "--port", + ap_dict["ap_port"], + "--user", ap_dict['ap_user'], + "--passwd", ap_dict['ap_pw'], "--tty", + ap_dict['ap_tty'], "--baud", + ap_dict['ap_baud'], "--action", + "clear_log"], capture_output=True, + check=True) # stdout=subprocess.PIPE) try: - pss = ap_info.stdout.decode('utf-8', 'ignore') + pss = ap_info.stdout.decode('utf-8', + 'ignore') except: - logg.info("ap_info was of type NoneType will set pss empty") + logg.info( + "ap_info was of type NoneType will set pss empty") pss = "empty" except subprocess.CalledProcessError as process_error: - logg.info("####################################################################################################") - logg.info("# CHECK IF AP HAS CONNECTION ALREADY ACTIVE") - logg.info("####################################################################################################") - logg.info("####################################################################################################") - logg.info("# Unable to commicate to AP error code: {} output {}".format(process_error.returncode, process_error.output)) - logg.info("####################################################################################################") + logg.info( + "####################################################################################################") + logg.info( + "# CHECK IF AP HAS CONNECTION ALREADY ACTIVE") + logg.info( + "####################################################################################################") + logg.info( + "####################################################################################################") + logg.info( + "# Unable to commicate to AP error code: {} output {}".format( + process_error.returncode, + process_error.output)) + logg.info( + "####################################################################################################") logg.info(pss) # show log (AP) try: logg.info("ap_ctl.py: show log") # TODO remove position dependence if in tree - ap_info= subprocess.run(["./../ap_ctl.py", "--scheme", ap_dict['ap_scheme'], "--prompt", ap_dict['ap_prompt'],"--dest", ap_dict['ap_ip'], "--port", ap_dict["ap_port"], - "--user", ap_dict['ap_user'], "--passwd", ap_dict['ap_pw'],"--tty", ap_dict['ap_tty'],"--baud", ap_dict['ap_baud'],"--action", "show_log"],capture_output=True, check=True) #stdout=subprocess.PIPE + ap_info = subprocess.run( + ["./../ap_ctl.py", "--scheme", + ap_dict['ap_scheme'], "--prompt", + ap_dict['ap_prompt'], "--dest", + ap_dict['ap_ip'], "--port", + ap_dict["ap_port"], + "--user", ap_dict['ap_user'], + "--passwd", ap_dict['ap_pw'], "--tty", + ap_dict['ap_tty'], "--baud", + ap_dict['ap_baud'], "--action", + "show_log"], capture_output=True, + check=True) # stdout=subprocess.PIPE try: - pss = ap_info.stdout.decode('utf-8', 'ignore') + pss = ap_info.stdout.decode('utf-8', + 'ignore') except: - logg.info("ap_info was of type NoneType will set pss empty") + logg.info( + "ap_info was of type NoneType will set pss empty") pss = "empty" except subprocess.CalledProcessError as process_error: - logg.info("####################################################################################################") - logg.info("# CHECK IF AP HAS CONNECTION ALREADY ACTIVE") - logg.info("####################################################################################################") - logg.info("####################################################################################################") - logg.info("# Unable to commicate to AP error code: {} output {}".format(process_error.returncode, process_error.output)) - logg.info("####################################################################################################") + logg.info( + "####################################################################################################") + logg.info( + "# CHECK IF AP HAS CONNECTION ALREADY ACTIVE") + logg.info( + "####################################################################################################") + logg.info( + "####################################################################################################") + logg.info( + "# Unable to commicate to AP error code: {} output {}".format( + process_error.returncode, + process_error.output)) + logg.info( + "####################################################################################################") logg.info(pss) controller.controller_enable_ap() @@ -2535,48 +2809,87 @@ Sample script 2/11/2021 time.sleep(10) # When the AP moves to another DFS channel, the wait time is 60 second # the CAC (Channel Avaiability Check Time) - if (int(__chan_5ghz_set) in dfs_channel_bw20_values): - logg.info("DFS 5ghz channel {} being set wait CAC time 60, 2.4 ghz: {} : ".format(__chan_5ghz_set, __chan_24ghz_set)) + if ( + int(__chan_5ghz_set) in dfs_channel_bw20_values): + logg.info( + "DFS 5ghz channel {} being set wait CAC time 60, 2.4 ghz: {} : ".format( + __chan_5ghz_set, __chan_24ghz_set)) # read AP to verify CAC timer set # will need to use time to verify CAC from AP - need in results - cac_sleeptime = "65" # 65 - logg.info("CAC start sleeptime: {}".format(cac_sleeptime)) + cac_sleeptime = "65" # 65 + logg.info("CAC start sleeptime: {}".format( + cac_sleeptime)) time.sleep(int(cac_sleeptime)) - logg.info("CAC done sleeptime: {}".format(cac_sleeptime)) - if(bool(ap_dict)): + logg.info("CAC done sleeptime: {}".format( + cac_sleeptime)) + if bool(ap_dict): # will need to verify that timer has timed out on AP - need in results - logg.info("DFS channel 5ghz {} done waiting CAC time, 2.4 ghz: {}".format(__chan_5ghz_set, __chan_24ghz_set)) - logg.info("####################################################################################################") - logg.info("# READ changed to DFS channel {}, running CAC for 60 seconds.".format(__chan_5ghz_set)) - logg.info("# READ AP CAC_EXPIRY_EVT: CAC finished on DFS channel ") - logg.info("####################################################################################################") + logg.info( + "DFS channel 5ghz {} done waiting CAC time, 2.4 ghz: {}".format( + __chan_5ghz_set, __chan_24ghz_set)) + logg.info( + "####################################################################################################") + logg.info( + "# READ changed to DFS channel {}, running CAC for 60 seconds.".format( + __chan_5ghz_set)) + logg.info( + "# READ AP CAC_EXPIRY_EVT: CAC finished on DFS channel ") + logg.info( + "####################################################################################################") logg.info("ap_dict {}".format(ap_dict)) - logg.info("Read AP action: {} ap_scheme: {} ap_ip: {} ap_port: {} ap_user: {} ap_pw: {} ap_tty: {} ap_baud: {}".format("show_log",ap_dict['ap_scheme'],ap_dict['ap_ip'],ap_dict["ap_port"], - ap_dict['ap_user'],ap_dict['ap_pw'],ap_dict['ap_tty'],ap_dict['ap_baud'],)) + logg.info( + "Read AP action: {} ap_scheme: {} ap_ip: {} ap_port: {} ap_user: {} ap_pw: {} ap_tty: {} ap_baud: {}".format( + "show_log", ap_dict['ap_scheme'], + ap_dict['ap_ip'], + ap_dict["ap_port"], + ap_dict['ap_user'], + ap_dict['ap_pw'], ap_dict['ap_tty'], + ap_dict['ap_baud'], )) try: - logg.info("ap_ctl.py: read for CAC timer and CAC_EXPIRY_EVT") + logg.info( + "ap_ctl.py: read for CAC timer and CAC_EXPIRY_EVT") # TODO remove position dependence if in tree - #ap_info= subprocess.run(["./../ap_ctl.py", "--scheme", ap_dict['ap_scheme'], "--prompt", ap_dict['ap_prompt'],"--dest", ap_dict['ap_ip'], "--port", ap_dict["ap_port"], + # ap_info= subprocess.run(["./../ap_ctl.py", "--scheme", ap_dict['ap_scheme'], "--prompt", ap_dict['ap_prompt'],"--dest", ap_dict['ap_ip'], "--port", ap_dict["ap_port"], # "--user", ap_dict['ap_user'], "--passwd", ap_dict['ap_pw'],"--tty", ap_dict['ap_tty'],"--baud", ap_dict['ap_baud'],"--action", "cac_expiry_evt"],capture_output=True, check=True) - ap_info= subprocess.run(["./../ap_ctl.py", "--scheme", ap_dict['ap_scheme'], "--prompt", ap_dict['ap_prompt'],"--dest", ap_dict['ap_ip'], "--port", ap_dict["ap_port"], - "--user", ap_dict['ap_user'], "--passwd", ap_dict['ap_pw'],"--tty", ap_dict['ap_tty'],"--baud", ap_dict['ap_baud'],"--action", "show_log"],capture_output=True, check=True) + ap_info = subprocess.run( + ["./../ap_ctl.py", "--scheme", + ap_dict['ap_scheme'], "--prompt", + ap_dict['ap_prompt'], "--dest", + ap_dict['ap_ip'], "--port", + ap_dict["ap_port"], + "--user", ap_dict['ap_user'], + "--passwd", ap_dict['ap_pw'], + "--tty", ap_dict['ap_tty'], + "--baud", ap_dict['ap_baud'], + "--action", "show_log"], + capture_output=True, check=True) try: - pss = ap_info.stdout.decode('utf-8', 'ignore') + pss = ap_info.stdout.decode('utf-8', + 'ignore') except: - logg.info("ap_info was of type NoneType will set pss empty") + logg.info( + "ap_info was of type NoneType will set pss empty") pss = "empty" except subprocess.CalledProcessError as process_error: - logg.info("####################################################################################################") - logg.info("# CHECK IF AP HAS CONNECTION ALREADY ACTIVE") - logg.info("####################################################################################################") + logg.info( + "####################################################################################################") + logg.info( + "# CHECK IF AP HAS CONNECTION ALREADY ACTIVE") + logg.info( + "####################################################################################################") - logg.info("####################################################################################################") - logg.info("# Unable to commicate to AP error code: {} output {}".format(process_error.returncode, process_error.output)) - logg.info("####################################################################################################") + logg.info( + "####################################################################################################") + logg.info( + "# Unable to commicate to AP error code: {} output {}".format( + process_error.returncode, + process_error.output)) + logg.info( + "####################################################################################################") logg.info(pss) # find the DFS Channel @@ -2584,29 +2897,47 @@ Sample script 2/11/2021 logg.info("ap: {}".format(line)) pat = 'CAC_EXPIRY_EVT:\s+\S+\s+\S+\s+\S+\s\S+\s\S+\s(\S+)' m = re.search(pat, line) - if (m != None): + if m != None: __dfs_channel = m.group(1) - logg.info("__dfs_channel: {}".format(__dfs_channel)) - logg.info("__dfs_channel line: {}".format(line)) + logg.info( + "__dfs_channel: {}".format( + __dfs_channel)) + logg.info( + "__dfs_channel line: {}".format( + line)) break else: - logg.info("Non-DFS 5ghz channel {} being set sleep 30, 2.4 ghz: {} ".format(__chan_5ghz_set, __chan_24ghz_set)) + logg.info( + "Non-DFS 5ghz channel {} being set sleep 30, 2.4 ghz: {} ".format( + __chan_5ghz_set, __chan_24ghz_set)) time.sleep(30) ########################################## # end of controller controller code ########################################## - + else: - logg.info("###############################################") + logg.info( + "###############################################") logg.info("# NO CHANGE TO CONTROLLER CONFIG") - logg.info("###############################################") - logg.info("controller_ap: {} controller_band: {} controller_chan_width: {} controller_ap_mode: {} controller_tx_power: {} controller_chan_5ghz: {} controller_chan_24ghz: {}" - .format(controller_ap,controller_band, controller_chan_width, controller_ap_mode, controller_tx_power, controller_chan_5ghz, controller_chan_24ghz)) - logg.info("__ap_set: {} __band_set: {} __chan_width_set: {} __ap_mode_set: {} __tx_power_set: {} __chan_5ghz_set: {} __chan_24ghz_set: {}" - .format(__ap_set,__band_set, __chan_width_set, __ap_mode_set, __tx_power_set, __chan_5ghz_set, __chan_24ghz_set)) - logg.info("controller_wifi_mode {}".format(controller_wifimode)) + logg.info( + "###############################################") + logg.info( + "controller_ap: {} controller_band: {} controller_chan_width: {} controller_ap_mode: {} controller_tx_power: {} controller_chan_5ghz: {} controller_chan_24ghz: {}" + .format(controller_ap, controller_band, + controller_chan_width, + controller_ap_mode, controller_tx_power, + controller_chan_5ghz, + controller_chan_24ghz)) + logg.info( + "__ap_set: {} __band_set: {} __chan_width_set: {} __ap_mode_set: {} __tx_power_set: {} __chan_5ghz_set: {} __chan_24ghz_set: {}" + .format(__ap_set, __band_set, __chan_width_set, + __ap_mode_set, __tx_power_set, + __chan_5ghz_set, __chan_24ghz_set)) + logg.info("controller_wifi_mode {}".format( + controller_wifimode)) pss = controller.controller_show_ap_summary() - logg.info("controller_show_ap_summary::: pss {}".format(pss)) + logg.info( + "controller_show_ap_summary::: pss {}".format(pss)) if args.controller_series == "9800": searchap = False cc_mac = "" @@ -2615,34 +2946,55 @@ Sample script 2/11/2021 cc_power = "" cc_dbm = "" for line in pss.splitlines(): - if (line.startswith("---------")): + if line.startswith("---------"): searchap = True continue # if the pattern changes save the output of the advanced command and re parse https://regex101.com - if (searchap): - pat = "%s\s+(\S+)\s+(%s)\s+\S+\s+\S+\s+(\S+)\s+(\S+)\s+(\S+)\s+dBm\)+\s+(\S+)+\s"%(__ap_set,__ap_slot) + if searchap: + pat = "%s\s+(\S+)\s+(%s)\s+\S+\s+\S+\s+(\S+)\s+(\S+)\s+(\S+)\s+dBm\)+\s+(\S+)+\s" % ( + __ap_set, __ap_slot) m = re.search(pat, line) - if (m != None): - if(m.group(2) == __ap_slot): + if m != None: + if m.group(2) == __ap_slot: cc_mac = m.group(1) cc_slot = m.group(2) - cc_ch = m.group(6); # (132,136,140,144) + cc_ch = m.group( + 6) # (132,136,140,144) cc_power = m.group(4) - cc_power = cc_power.replace("/", " of ") # spread-sheets turn 1/8 into a date + cc_power = cc_power.replace("/", + " of ") # spread-sheets turn 1/8 into a date cc_dbm = m.group(5) - cc_dbm = cc_dbm.replace("(","") - + cc_dbm = cc_dbm.replace("(", "") + cc_ch_count = cc_ch.count(",") + 1 cc_bw = m.group(3) - logg.info("group 1: {} 2: {} 3: {} 4: {} 5: {} 6: {}".format(m.group(1),m.group(2),m.group(3),m.group(4),m.group(5),m.group(6))) - - logg.info("9800 test_parameters cc_mac: read : {}".format(cc_mac)) - logg.info("9800 test_parameters cc_slot: read : {}".format(cc_slot)) - logg.info("9800 test_parameters cc_count: read : {}".format(cc_ch_count)) - logg.info("9800 test_parameters cc_bw: read : {}".format(cc_bw)) - logg.info("9800 test_parameters cc_power: read : {}".format(cc_power)) - logg.info("9800 test_parameters cc_dbm: read : {}".format(cc_dbm)) - logg.info("9800 test_parameters cc_ch: read : {}".format(cc_ch)) + logg.info( + "group 1: {} 2: {} 3: {} 4: {} 5: {} 6: {}".format( + m.group(1), m.group(2), + m.group(3), m.group(4), + m.group(5), m.group(6))) + + logg.info( + "9800 test_parameters cc_mac: read : {}".format( + cc_mac)) + logg.info( + "9800 test_parameters cc_slot: read : {}".format( + cc_slot)) + logg.info( + "9800 test_parameters cc_count: read : {}".format( + cc_ch_count)) + logg.info( + "9800 test_parameters cc_bw: read : {}".format( + cc_bw)) + logg.info( + "9800 test_parameters cc_power: read : {}".format( + cc_power)) + logg.info( + "9800 test_parameters cc_dbm: read : {}".format( + cc_dbm)) + logg.info( + "9800 test_parameters cc_ch: read : {}".format( + cc_ch)) break else: searchap = False @@ -2653,33 +3005,49 @@ Sample script 2/11/2021 cc_dbm = "" ch_count = "" for line in pss.splitlines(): - if (line.startswith("---------")): + if line.startswith("---------"): searchap = True continue - - if (searchap): - pat = "%s\s+(\S+)\s+\S+\s+\S+\s+\S+\s+(\S+)\s+(\S+)\s+\(\s*(\S+)\s+dBm"%(__ap_set) + + if searchap: + pat = "%s\s+(\S+)\s+\S+\s+\S+\s+\S+\s+(\S+)\s+(\S+)\s+\(\s*(\S+)\s+dBm" % ( + __ap_set) m = re.search(pat, line) - if (m != None): + if m != None: cc_mac = m.group(1) - cc_ch = m.group(2); # (132,136,140,144) + cc_ch = m.group(2) # (132,136,140,144) cc_power = m.group(3) - cc_power = cc_power.replace("/", " of ", 1) # spread-sheets turn 1/8 into a date + cc_power = cc_power.replace("/", " of ", + 1) # spread-sheets turn 1/8 into a date cc_dbm = m.group(4) - + ch_count = cc_ch.count(",") cc_bw = 20 * (ch_count + 1) - - logg.info("3504 test_parameters cc_mac: read : {}".format(cc_mac)) - logg.info("3504 test_parameters cc_count: read : {}".format(ch_count)) - logg.info("3504 test_parameters cc_bw: read : {}".format(cc_bw)) - logg.info("3504 test_parameters cc_power: read : {}".format(cc_power)) - logg.info("3504 test_parameters cc_dbm: read : {}".format(cc_dbm)) - logg.info("3504 test_parameters cc_ch: read : {}".format(cc_ch)) + + logg.info( + "3504 test_parameters cc_mac: read : {}".format( + cc_mac)) + logg.info( + "3504 test_parameters cc_count: read : {}".format( + ch_count)) + logg.info( + "3504 test_parameters cc_bw: read : {}".format( + cc_bw)) + logg.info( + "3504 test_parameters cc_power: read : {}".format( + cc_power)) + logg.info( + "3504 test_parameters cc_dbm: read : {}".format( + cc_dbm)) + logg.info( + "3504 test_parameters cc_ch: read : {}".format( + cc_ch)) break - if(cc_ch != controller_chan_5ghz): - logg.info("configured channel {} not equal controller channel {}".format(controller_chan_5ghz,cc_ch)) + if cc_ch != controller_chan_5ghz: + logg.info( + "configured channel {} not equal controller channel {}".format( + controller_chan_5ghz, cc_ch)) ###################################################### # end of controller controller code no change to controller ###################################################### @@ -2687,131 +3055,156 @@ Sample script 2/11/2021 radios = args.radio logg.info("radios {}".format(radios)) for radio_ in radios: - radio_keys = ['radio','stations','ssid','ssid_pw','security','wifimode'] - radio_info_dict = dict(map(lambda x: x.split('=='), str(radio_).replace('[','').replace(']','').replace("'","").split())) + radio_keys = ['radio', 'stations', 'ssid', + 'ssid_pw', 'security', 'wifimode'] + radio_info_dict = dict(map(lambda x: x.split('=='), + str(radio_).replace('[', + '').replace( + ']', '').replace("'", + "").split())) logg.info("radio_dict {}".format(radio_info_dict)) for key in radio_keys: if key not in radio_info_dict: - logg.info("missing config, for the {}, all of the following need to be present {} ".format(key,radio_keys)) + logg.info( + "missing config, for the {}, all of the following need to be present {} ".format( + key, radio_keys)) exit(1) radio_name_list.append(radio_info_dict['radio']) ssid_list.append(radio_info_dict['ssid']) - ssid_password_list.append(radio_info_dict['ssid_pw']) - ssid_security_list.append(radio_info_dict['security']) + ssid_password_list.append( + radio_info_dict['ssid_pw']) + ssid_security_list.append( + radio_info_dict['security']) if args.radio: - number_of_stations_per_radio_list.append(radio_info_dict['stations']) - wifimode_list.append(int(wifi_mode_dict[radio_info_dict['wifimode']])) - else: - number_of_stations_per_radio_list.append(radio_info_dict['stations']) - wifimode_list.append(int(wifi_mode_dict[radio_info_dict['wifimode']])) + number_of_stations_per_radio_list.append( + radio_info_dict['stations']) + wifimode_list.append(int(wifi_mode_dict[ + radio_info_dict[ + 'wifimode']])) + else: + number_of_stations_per_radio_list.append( + radio_info_dict['stations']) + wifimode_list.append(int(wifi_mode_dict[ + radio_info_dict[ + 'wifimode']])) optional_radio_reset_keys = ['reset_port_enable'] radio_reset_found = True for key in optional_radio_reset_keys: if key not in radio_info_dict: - #logg.info("port reset test not enabled") + # logg.info("port reset test not enabled") radio_reset_found = False break - + if radio_reset_found: reset_port_enable_list.append(True) - reset_port_time_min_list.append(radio_info_dict['reset_port_time_min']) - reset_port_time_max_list.append(radio_info_dict['reset_port_time_max']) + reset_port_time_min_list.append( + radio_info_dict['reset_port_time_min']) + reset_port_time_max_list.append( + radio_info_dict['reset_port_time_max']) else: reset_port_enable_list.append(False) reset_port_time_min_list.append('0s') reset_port_time_max_list.append('0s') # no stations for testing reconfiguration of the controller - - if(args.no_stations): + if args.no_stations: logg.info("##################################") logg.info("# NO STATIONS") logg.info("##################################") else: index = 0 station_lists = [] - for (radio_name_, number_of_stations_per_radio_) in zip(radio_name_list,number_of_stations_per_radio_list): - number_of_stations = int(number_of_stations_per_radio_) + for (radio_name_, number_of_stations_per_radio_) in zip( + radio_name_list, + number_of_stations_per_radio_list): + number_of_stations = int( + number_of_stations_per_radio_) if number_of_stations > MAX_NUMBER_OF_STATIONS: - logg.info("number of stations per radio exceeded max of : {}".format(MAX_NUMBER_OF_STATIONS)) + logg.info( + "number of stations per radio exceeded max of : {}".format( + MAX_NUMBER_OF_STATIONS)) quit(1) - station_list = LFUtils.portNameSeries(prefix_="sta", start_id_= 1 + index*1000, end_id_= number_of_stations + index*1000, - padding_number_=10000, radio=radio_name_) + station_list = LFUtils.portNameSeries(prefix_="sta", + start_id_=1 + index * 1000, + end_id_=number_of_stations + index * 1000, + padding_number_=10000, + radio=radio_name_) station_lists.append(station_list) index += 1 # Run Traffic Upstream (STA to AP) - if(controller_direction == "upstream"): - side_a_min_bps = controller_side_a_min_bps - side_b_min_bps = 0 - # Run Traffic Downstream (AP to STA) + if controller_direction == "upstream": + side_a_min_bps = controller_side_a_min_bps + side_b_min_bps = 0 + # Run Traffic Downstream (AP to STA) else: - side_a_min_bps = 0 - side_b_min_bps = controller_side_b_min_bps - # current default is to have a values + side_a_min_bps = 0 + side_b_min_bps = controller_side_b_min_bps + # current default is to have a values ip_var_test = L3VariableTime( - args=args, - _dfs=__dfs, - _dfs_time=__dfs_time, - _radar_duration=__radar_duration, - _scheme=__scheme, - _port=__port, - _series=__series, - _ctlr=__ctlr, - _prompt=__prompt, - _user=__user, - _passwd=__passwd, - _ap=__ap_set, - _ap_slot=__ap_slot, - _band=__band_set, - _chan_5ghz=__chan_5ghz_set, - _chan_24ghz=__chan_24ghz_set, - _chan_width=__chan_width_set, - _ap_mode=__ap_mode_set, - _tx_power=__tx_power_set, - _client_density=__client_density, - _cap_ctl_out=__cap_ctl_out, - _ap_dict = ap_dict, - endp_type=controller_packet_type, - tos=args.tos, - side_b=side_b, - radio_name_list=radio_name_list, - number_of_stations_per_radio_list=number_of_stations_per_radio_list, - ssid_list=ssid_list, - ssid_password_list=ssid_password_list, - ssid_security_list=ssid_security_list, - wifimode_list=wifimode_list, - station_lists= station_lists, - name_prefix="LT-", - debug_on=debug_on, - wait_timeout=wait_timeout, - outfile=csv_outfile, - results=csv_results, - test_keys=test_keys, - test_config=test_config, - reset_port_enable_list=reset_port_enable_list, - reset_port_time_min_list=reset_port_time_min_list, - reset_port_time_max_list=reset_port_time_max_list, - csv_started=__csv_started, - side_a_min_bps =side_a_min_bps, - side_a_max_bps =0, - side_a_min_pdu =controller_packet_size, - side_a_max_pdu =0, - side_b_min_bps =side_b_min_bps, - side_b_max_bps =0, - side_b_min_pdu =controller_packet_size, - side_b_max_pdu = 0, - number_template="00", - test_duration=test_duration, - polling_interval= polling_interval, - lfclient_host=lfjson_host, - lfclient_port=lfjson_port) + args=args, + _dfs=__dfs, + _dfs_time=__dfs_time, + _radar_duration=__radar_duration, + _scheme=__scheme, + _port=__port, + _series=__series, + _ctlr=__ctlr, + _prompt=__prompt, + _user=__user, + _passwd=__passwd, + _ap=__ap_set, + _ap_slot=__ap_slot, + _band=__band_set, + _chan_5ghz=__chan_5ghz_set, + _chan_24ghz=__chan_24ghz_set, + _chan_width=__chan_width_set, + _ap_mode=__ap_mode_set, + _tx_power=__tx_power_set, + _client_density=__client_density, + _cap_ctl_out=__cap_ctl_out, + _ap_dict=ap_dict, + endp_type=controller_packet_type, + tos=args.tos, + side_b=side_b, + radio_name_list=radio_name_list, + number_of_stations_per_radio_list=number_of_stations_per_radio_list, + ssid_list=ssid_list, + ssid_password_list=ssid_password_list, + ssid_security_list=ssid_security_list, + wifimode_list=wifimode_list, + station_lists=station_lists, + name_prefix="LT-", + debug_on=debug_on, + wait_timeout=wait_timeout, + outfile=csv_outfile, + results=csv_results, + test_keys=test_keys, + test_config=test_config, + reset_port_enable_list=reset_port_enable_list, + reset_port_time_min_list=reset_port_time_min_list, + reset_port_time_max_list=reset_port_time_max_list, + csv_started=__csv_started, + side_a_min_bps=side_a_min_bps, + side_a_max_bps=0, + side_a_min_pdu=controller_packet_size, + side_a_max_pdu=0, + side_b_min_bps=side_b_min_bps, + side_b_max_bps=0, + side_b_min_pdu=controller_packet_size, + side_b_max_pdu=0, + number_template="00", + test_duration=test_duration, + polling_interval=polling_interval, + lfclient_host=lfjson_host, + lfclient_port=lfjson_port) __csv_started = True ip_var_test.pre_cleanup() ip_var_test.build() if not ip_var_test.passes(): logg.info("build step failed.") logg.info(ip_var_test.get_fail_message()) - exit(1) - client_density = ip_var_test.station_bringup() - #controller.verify_controller(client_density) + exit(1) + client_density = ip_var_test.station_bringup() + # controller.verify_controller(client_density) ip_var_test.start(False, False) ip_var_test.stop() if not ip_var_test.passes(): @@ -2825,16 +3218,16 @@ Sample script 2/11/2021 ssid_security_list = [] wifimode_list = [] ip_var_test.cleanup() - if ( args.no_stations): + if args.no_stations: pass else: ip_var_test.passes() logg.info("Test Complete") + if __name__ == "__main__": main() - ''' SAMPLE Command 2/15/2021 ./lf_dfs_test.py -cc 192.168.100.112 -cu admin -cpw Controller123 -cca APA453.0E7B.CF9C -ccf "a" -cwm "auto" -cc5 "52 56 60 64 68 96 100 104 108 112 116 120 124 128 132 136 140 144" -ccw "20" -ccd "1" -cs "3504" --endp_type 'lf_udp' --upstream_port eth2 --controller_wlan "test_candela" --controller_wlanID 1 --controller_wlanSSID "test_candela" --controller_directions "upstream" --controller_prompt "(controller Controller)" --radio "radio==1.wiphy0 stations==1 ssid==test_candela ssid_pw==[BLANK] security==open wifimode==auto" @@ -2842,4 +3235,3 @@ SAMPLE Command 2/15/2021 SAMPLE Command with AP (need root if using serial) sudo ./lf_dfs_test.py -cc 192.168.100.112 -cu admin -cpw Controller123 -cca APA453.0E7B.CF9C -ccf "a" -cwm "auto" -cc5 "56" -ccw "20" -ccd "1" -cs "3504" --endp_type 'lf_udp' --upstream_port eth2 --controller_wlan "test_candela" --controller_wlanID 1 --controller_wlanSSID "test_candela" --controller_directions "upstream" --controller_prompt "(controller Controller)" --radio "radio==1.wiphy0 stations==1 ssid==test_candela ssid_pw==[BLANK] security==open wifimode==auto" --ap_info "ap_scheme==serial ap_prompt==APA453.0E7B.CF9C ap_ip==0 ap_port==0 ap_user==admin ap_pw==Admin123 ap_tty==/dev/ttyUSB2 ap_baud==9600" --controller_dfs ''' -