generic-cx: code cleanup and return error checking.

Clean up monitor logic in gen_cx profile to remove useless sleeps
and rename a variable that indicated it was msec but which was actually
seconds.

test_generic gets better error checking and also fixes bugs in how it
monitors the connection.  More work yet is needed for making the
monitor do a good pass/fail logic.

Signed-off-by: Ben Greear <greearb@candelatech.com>

py-json/gen_cxprofile.py

@@ -321,13 +321,15 @@ class GenCXProfile(LFCliBase):
             self.json_post("cli-json/add_gen_endp", data, debug_=self.debug)
 
         self.local_realm.json_post("/cli-json/nc_show_endpoints", {"endpoint": "all"})
-        time.sleep(sleep_time)
+        if sleep_time:
+            time.sleep(sleep_time)
 
         for endp_tpl in endp_tpls:
             gen_name_a = endp_tpl[3]
             gen_name_b = endp_tpl[4]
             self.set_flags(gen_name_a, "ClearPortOnStart", 1)
-        time.sleep(sleep_time)
+        if sleep_time:
+            time.sleep(sleep_time)
 
         for endp_tpl in endp_tpls:
             name = endp_tpl[2]
@@ -335,7 +337,8 @@ class GenCXProfile(LFCliBase):
             # gen_name_b  = endp_tpl[4]
             self.parse_command(name, gen_name_a)
             self.set_cmd(gen_name_a, self.cmd)
-        time.sleep(sleep_time)
+        if sleep_time:
+            time.sleep(sleep_time)
 
         for endp_tpl in endp_tpls:
             name = endp_tpl[2]
@@ -353,20 +356,23 @@ class GenCXProfile(LFCliBase):
             self.created_endp.append(gen_name_a)
             self.created_endp.append(gen_name_b)
 
-        time.sleep(sleep_time)
+        if sleep_time:
+            time.sleep(sleep_time)
 
         for data in post_data:
             url = "/cli-json/add_cx"
             logger.info(pformat(data))
             self.local_realm.json_post(url, data, debug_=debug_, suppress_related_commands_=suppress_related_commands_)
-            time.sleep(2)
+            #time.sleep(2)
-        time.sleep(sleep_time)
+        if sleep_time:
+            time.sleep(sleep_time)
+
         for data in post_data:
             self.local_realm.json_post("/cli-json/show_cx", {
                 "test_mgr": "default_tm",
                 "cross_connect": data["alias"]
             })
-        time.sleep(sleep_time)
+        return True
 
     def choose_ping_command(self):
         gen_results = self.json_get("generic/list?fields=name,last+results", debug_=self.debug)
@@ -431,7 +437,7 @@ class GenCXProfile(LFCliBase):
     # TODO monitor is broken
     def monitor(self,
                 duration_sec=60,
-                monitor_interval_ms=1,
+                monitor_interval=2, # seconds
                 sta_list=None,
                 generic_cols=None,
                 port_mgr_cols=None,
@@ -450,7 +456,7 @@ class GenCXProfile(LFCliBase):
             if not duration_sec or (duration_sec <= 1):
                 logger.critical("GenCXProfile::monitor wants duration_sec > 1 second")
                 raise ValueError("GenCXProfile::monitor wants duration_sec > 1 second")
-            if duration_sec <= monitor_interval_ms:
+            if duration_sec <= monitor_interval:
                 logger.critical("GenCXProfile::monitor wants duration_sec > monitor_interval")
                 raise ValueError("GenCXProfile::monitor wants duration_sec > monitor_interval")
         if not report_file:
@@ -462,7 +468,7 @@ class GenCXProfile(LFCliBase):
         if not created_cx:
             logger.critical("Monitor needs a list of Layer 3 connections")
             raise ValueError("Monitor needs a list of Layer 3 connections")
-        if not monitor_interval_ms or (monitor_interval_ms < 1):
+        if not monitor_interval or (monitor_interval < 1):
             logger.critical("GenCXProfile::monitor wants monitor_interval >= 1 second")
             raise ValueError("GenCXProfile::monitor wants monitor_interval >= 1 second")
         if not generic_cols:
@@ -523,17 +529,13 @@ class GenCXProfile(LFCliBase):
         csvwriter = csv.writer(csvfile, delimiter=",")
         csvwriter.writerow(header_row)
 
-        # wait 10 seconds to get proper port data
-        time.sleep(10)
-
         # for x in range(0,int(round(iterations,0))):
         initial_starttime = datetime.datetime.now()
-        logger.info("Starting Test...")
+        logger.info("Starting Test Monitoring for %s seconds..." % duration_sec)
         while datetime.datetime.now() < end_time:
 
             passes = 0
             expected_passes = 0
-            time.sleep(15)
             result = False
             if self.type == "lfping":
                 result = self.choose_ping_command()
@@ -554,7 +556,6 @@ class GenCXProfile(LFCliBase):
                 else:
                     self._fail("%s Failed to ping %s " % (result[1], self.dest))
                     break
-            time.sleep(1)
 
             if passes == expected_passes:
                 self._pass("PASS: All tests passed")
@@ -604,7 +605,9 @@ class GenCXProfile(LFCliBase):
                                             temp_list.append(merge[name])
                 csvwriter.writerow(temp_list)
 
-            time.sleep(monitor_interval_ms)
+            time.sleep(monitor_interval)
+            # End of while loop for duration of monitor period.
+
         csvfile.close()
 
         # comparison to last report / report inputted

py-scripts/test_generic.py

@@ -114,8 +114,14 @@ class GenTest(Realm):
             temp_stas.append(self.name_to_eid(station)[2])
         if self.debug:
             pprint.pprint(self.station_profile.station_names)
-        LFUtils.wait_until_ports_admin_up(base_url=self.lfclient_url, port_list=self.station_profile.station_names,
+
-                                          debug_=self.debug)
+        if LFUtils.wait_until_ports_admin_up(base_url=self.lfclient_url,
+                                             port_list=self.station_profile.station_names,
+                                             debug_=self.debug):
+            self._pass("All stations went admin up.")
+        else:
+            self._fail("All stations did NOT go admin up.")
+
         if self.wait_for_ip(station_list=temp_stas, ipv4=True, debug=self.debug, timeout_sec=-1):
             self._pass("All stations got IPs")
         else:
@@ -137,22 +143,30 @@ class GenTest(Realm):
         self.station_profile.set_command_param("set_port", "report_timer", 1500)
         self.station_profile.set_command_flag("set_port", "rpt_timer", 1)
 
-        self.station_profile.create(radio=self.radio, sta_names_=self.sta_list, debug=self.debug)
+        if self.station_profile.create(radio=self.radio, sleep_time=0, sta_names_=self.sta_list, debug=self.debug):
+            self._pass("Station creation completed.")
+        else:
+            self._fail("Station creation failed.")
 
-        self.generic_endps_profile.create(ports=self.station_profile.station_names, sleep_time=.5)
+        if self.generic_endps_profile.create(ports=self.station_profile.station_names, sleep_time=.5):
-        self._pass("PASS: Station build finished")
+            self._pass("Generic endpoints creation completed.")
+        else:
+            self._fail("Generic endpoints NOT completed.")
 
     def cleanup(self, sta_list):
         self.generic_endps_profile.cleanup()
         self.station_profile.cleanup(sta_list)
-        LFUtils.wait_until_ports_disappear(base_url=self.lfclient_url, port_list=sta_list, debug=self.debug)
+        if LFUtils.wait_until_ports_disappear(base_url=self.lfclient_url, port_list=sta_list, debug=self.debug):
+            self._pass("Ports successfully cleaned up.")
+        else:
+            self._fail("Ports NOT successfully cleaned up.")
 
 
 def main():
     optional = []
     optional.append({'name': '--mode', 'help': 'Used to force mode of stations'})
     optional.append({'name': '--ap', 'help': 'Used to force a connection to a particular AP'})
-    optional.append({'name': '--output_format', 'help': 'choose either csv or xlsx'})
+    optional.append({'name': '--output_format', 'default': 'csv', 'help': 'choose either csv or xlsx'})
     optional.append({'name': '--report_file', 'help': 'where you want to store results', 'default': None})
     optional.append({'name': '--a_min', 'help': '--a_min bps rate minimum for side_a', 'default': 256000})
     optional.append({'name': '--b_min', 'help': '--b_min bps rate minimum for side_b', 'default': 256000})
@@ -258,7 +272,7 @@ python3 ./test_generic.py
             report_f = str(path) + '/data.' + args.output_format
             output = args.output_format
         else:
-            logger.info('Not supporting this report format or cannot find report format provided. Defaulting to csv data file output type, naming it data.csv.')
+            logger.info('Not supporting report format: %s. Defaulting to csv data file output type, naming it data.csv.' % args.output_format)
             report_f = str(path) + '/data.csv'
             output = 'csv'
 
@@ -269,7 +283,7 @@ python3 ./test_generic.py
             output = str(args.report_file).split('.')[-1]
         else:
             output = args.output_format
-    logger.info("Saving final report data in ... " + report_f)
+    logger.warning("Saving final report data in: " + report_f)
 
     # Retrieve last data file
     compared_rept = None
@@ -349,14 +363,17 @@ python3 ./test_generic.py
     except ValueError as error:
         raise ValueError("The time string provided for monitor_interval argument is invalid. Please see supported time stamp increments and inputs for monitor_interval in --help. %s" % error)
 
+    logger.info("Starting connections with 5 second settle time.")
     generic_test.start()
+    time.sleep(5) # give traffic a chance to get started.
+
     generic_test.generic_endps_profile.monitor(generic_cols=generic_cols,
                                                sta_list=station_list,
                                                # port_mgr_cols=port_mgr_cols,
                                                report_file=report_f,
                                                systeminfopath=systeminfopath,
                                                duration_sec=Realm.parse_time(args.test_duration).total_seconds(),
-                                               monitor_interval_ms=monitor_interval,
+                                               monitor_interval=monitor_interval,
                                                created_cx=genconnections,
                                                output_format=output,
                                                compared_report=compared_rept,
@@ -364,12 +381,15 @@ python3 ./test_generic.py
                                                arguments=args,
                                                debug=args.debug)
 
+    logger.info("Running connections for: %s" % args.test_duration)
+    time.sleep(Realm.parse_time(args.test_duration).total_seconds())
     generic_test.stop()
-    time.sleep(30)
+
     generic_test.cleanup(station_list)
     if generic_test.passes():
         generic_test.exit_success()
-
+    else:
+        generic_test.exit_fail()
 
 if __name__ == "__main__":
     main()