def create_error_chart(): plLogger = PLLogger.GetLogger('Methodology') plLogger.LogDebug('AclBasicChartScript.create_error_chart()') # We want to use the summary (the latter summary with ACL enabled)... db_list = [pu.get_active_result_db_filename()] queries = [('Out Of Seq', 'SELECT SUM (OutSeqFrameCount) FROM RxEotStreamResults'), ('Sequence Errors', 'SELECT SUM (DroppedFrameCount + ReorderedFrameCount + ' 'FcsErrorFrameCount + PrbsBitErrorCount + DuplicateFrameCount + ' 'LateFrameCount) FROM RxEotStreamResults'), ('CRC Errors', 'SELECT SUM(GeneratorCrcErrorFrameCount) FROM GeneratorPortResults'), ('Checksum Errors', 'SELECT SUM(GeneratorL3ChecksumErrorCount + ' 'GeneratorL4ChecksumErrorCount) FROM GeneratorPortResults'), ('Data Error', 'SELECT SUM(PrbsBitErrorCount) FROM AnalyzerPortResults') ] total_error_count = 0 errors = [] captions = [] for caption, query in queries: error_count = get_data_from_query(db_list, query)[0] errors.append(error_count) captions.append(caption) total_error_count += error_count if total_error_count == 0: errors.append(1) captions.append('No Errors') template_error_pie['series'][0]['data'] = zip(captions, errors) template_error_pie['xAxis']['categories'] = captions result_data = init_chart_data_dict("SUMMARY", template_error_pie) pdg.submit_provider_data(result_data) return ""
def Rfc2544ThroughputCreateChart(tagname, b, params): # plLogger = PLLogger.GetLogger('methodology') # plLogger.LogDebug("Running Rfc2544ThroughputCreateChart") db_list = get_dbs(False, True) # Frame size (X axis names) q_xcat = str("SELECT FrameSize From MethRfc2544ThroughputFrameRate") # Found frame rate for each frame size (report 0 if there's dropped frames) q_fps = str("SELECT CASE WHEN DroppedCount > 0 THEN 0 ELSE FPS END " + "From MethRfc2544ThroughputFrameRate") # Get theoretical maximum rate q_maxfps = str("SELECT round(MaxRate,0) From MethRfc2544ThroughputFrameRate") # Run the db queries xcat_data = get_data_from_query(db_list, q_xcat) fps_data = get_data_from_query(db_list, q_fps) theoretical_fps_data = get_data_from_query(db_list, q_maxfps) # Fill in the template with the results base_template['xAxis']['categories'] = xcat_data base_template['series'][0]['data'] = fps_data base_template['series'][1]['data'] = theoretical_fps_data # This fills in the json file with our chart results? result_data = init_chart_data_dict("SUMMARY") pdg.submit_provider_data(result_data) return ""
def run(ChartTemplateJsonFileName, Title, XAxisTitle, XAxisCategories, YAxisTitle, YAxisCategories, Series, SeriesDataType, CustomModifier, UseMultipleResultsDatabases, UseSummary, ReportGroup): logger = PLLogger.GetLogger('ExportDbChartCommand') try: db_list = get_dbs(UseMultipleResultsDatabases, UseSummary) result_data = init_chart_data_dict(ReportGroup) series_data = get_series_data(db_list) add_series_data_list(result_data, series_data) # If any sql queries were passed in, grab results from db sql_result_file_list = [] sql_result_file_list.append(db_list[0]) get_sql_data(result_data, sql_result_file_list) pdg.submit_provider_data(result_data) # Catch most of them here except Exception as e: trace = traceback.format_exc() logger.LogError(trace) pdg.submit_command_execution_error('ExportDbChartCommand', str(e), trace) return False except: trace = traceback.format_exc() logger.LogError(trace) pdg.submit_command_execution_error('ExportDbChartCommand', ProviderConst.UNKNOWN_EXCEPTION_MESSAGE, trace) return False return True
def create_tolerance_chart(): plLogger = PLLogger.GetLogger('Methodology') plLogger.LogDebug('AclPerformanceChartScript.create_tolerance_chart()') from AclPerformanceData import AclPerformanceData exp_maxjitter = AclPerformanceData().get_exp_maxjitter() exp_maxlatency = AclPerformanceData().get_exp_maxlatency() db_list = get_dbs(True, False) q_minjitter = form_query_during_blocking_traffic('MIN(MinJitter)') q_avgjitter = form_query_during_blocking_traffic('AVG(AvgJitter)') q_maxjitter = form_query_during_blocking_traffic('MAX(MaxJitter)') q_minlatency = form_query_during_blocking_traffic('MIN(MinLatency)') q_avglatency = form_query_during_blocking_traffic('AVG(AvgLatency)') q_maxlatency = form_query_during_blocking_traffic('MAX(MaxLatency)') q_blocking = form_query_during_blocking_traffic('COUNT(*)', 'Tag.Name="Bad.ttStreamBlock"') min_jitter_data = get_data_from_query(db_list, q_minjitter) avg_jitter_data = get_data_from_query(db_list, q_avgjitter) max_jitter_data = get_data_from_query(db_list, q_maxjitter) min_latency_data = get_data_from_query(db_list, q_minlatency) avg_latency_data = get_data_from_query(db_list, q_avglatency) max_latency_data = get_data_from_query(db_list, q_maxlatency) nonconformant_data = get_data_from_query(db_list, q_blocking) q_xcat = str('''SELECT DISTINCT Sb.FixedFrameLength FROM RxEotStreamResults As RxStr JOIN StreamBlock AS Sb ON RxStr.ParentStreamBlock == Sb.Handle ''') xcat_data = find_distinct_cats(get_data_from_query(db_list, q_xcat)) count = len(xcat_data) template_tolerances['series'][0]['data'] = find_msdata(nonconformant_data) template_tolerances['series'][1]['data'] = find_msdata(min_jitter_data) template_tolerances['series'][2]['data'] = find_msdata(avg_jitter_data) template_tolerances['series'][3]['data'] = find_msdata(max_jitter_data) template_tolerances['series'][4]['data'] = find_msdata(min_latency_data) template_tolerances['series'][5]['data'] = find_msdata(avg_latency_data) template_tolerances['series'][6]['data'] = find_msdata(max_latency_data) template_tolerances['series'][7]['data'] = line(count, exp_maxjitter) template_tolerances['series'][8]['data'] = line(count, exp_maxlatency) template_tolerances['xAxis']['categories'] = xcat_data result_data = init_chart_data_dict("GROUP_1", template_tolerances) pdg.submit_provider_data(result_data) return ""
def run(ChartTemplateJsonFileName, Title, XAxisTitle, XAxisCategories, YAxisTitle, YAxisCategories, Series, TemplateModifier, SrcDatabase, ReportGroup): logger = PLLogger.GetLogger('methodology') try: db_list = get_dbs(SrcDatabase) result_data = init_chart_data_dict(ReportGroup) series_data = get_series_data(db_list) add_series_data_list(result_data, series_data) get_sql_data(result_data, db_list) pdg.submit_provider_data(result_data) # Catch most of them here except Exception, e: stack_trace = traceback.format_exc() logger.LogError(stack_trace) raise RuntimeError(str(e))
def create_line_rate_chart(): plLogger = PLLogger.GetLogger('Methodology') plLogger.LogDebug('AclPerformanceChartScript.create_line_rate_chart()') db_list = get_dbs(True, False) # The frame size and the frame rates are what we want, the third value is 0 because # find_msdata uses that value to identify which tuple is the most significant (N/A here). q_theo_max = '''SELECT Sb.FixedFrameLength, Round( Theo.FrameRate , 0), 0 FROM TheoreticalMaxLineRate AS Theo JOIN StreamBlock AS Sb ON Theo.FrameSize = Sb.FixedFrameLength WHERE Theo.MbpsLineRate = ( CASE WHEN (SELECT DISTINCT Ec.LineSpeed FROM EthernetCopper AS Ec JOIN TxEotStreamResults AS tx ON Tx.ParentHnd = Ec.ParentHnd WHERE Tx.FrameCount > 0) = 'SPEED_100M' THEN 100 ELSE 1000 END) LIMIT 1 ''' q_real_max = '''SELECT Sb.FixedFrameLength, SUM(Sb.FpsLoad), 0 FROM StreamBlock AS Sb JOIN TxEotStreamResults AS Tx ON Tx.ParentStreamBlock = Sb.Handle WHERE Tx.FrameCount > 0 ''' theo_max = get_data_from_query(db_list, q_theo_max) real_max = get_data_from_query(db_list, q_real_max) q_xcat = str("SELECT DISTINCT Sb.FixedFrameLength " + "FROM RxEotStreamResults As RxStr " + "JOIN StreamBlock AS Sb " + "ON RxStr.ParentStreamBlock == Sb.Handle") xcat_data = get_data_from_query(db_list, q_xcat) template_line_rate['series'][0]['data'] = find_msdata(theo_max) template_line_rate['series'][1]['data'] = find_msdata(real_max) template_line_rate['xAxis']['categories'] = find_distinct_cats(xcat_data) result_data = init_chart_data_dict("GROUP_1", template_line_rate) pdg.submit_provider_data(result_data) return ""
def CreateChart(tagname, b, params): plLogger = PLLogger.GetLogger('Methodology') plLogger.LogDebug("Running custom CreateChart script...") db_list = get_dbs(True, False) q_minjitter = str("SELECT ROUND(MinJitter*1e-3,3) FROM RxEotStreamResults As RxStr " + "JOIN StreamBlock AS Sb " + "ON RxStr.ParentStreamBlock == Sb.Handle") q_avgjitter = str("SELECT ROUND(AvgJitter*1e-3,3) FROM RxEotStreamResults As RxStr " + "JOIN StreamBlock AS Sb " + "ON RxStr.ParentStreamBlock == Sb.Handle") q_maxjitter = str("SELECT ROUND(MaxJitter*1e-3,3) FROM RxEotStreamResults As RxStr " + "JOIN StreamBlock AS Sb " + "ON RxStr.ParentStreamBlock == Sb.Handle") q_minlatency = str("SELECT ROUND(MinLatency*1e-3,3) FROM RxEotStreamResults As RxStr " + "JOIN StreamBlock AS Sb " + "ON RxStr.ParentStreamBlock == Sb.Handle") q_avglatency = str("SELECT ROUND(AvgLatency*1e-3,3) FROM RxEotStreamResults As RxStr " + "JOIN StreamBlock AS Sb " + "ON RxStr.ParentStreamBlock == Sb.Handle") q_maxlatency = str("SELECT ROUND(MaxLatency*1e-3,3) FROM RxEotStreamResults As RxStr " + "JOIN StreamBlock AS Sb " + "ON RxStr.ParentStreamBlock == Sb.Handle") q_pktloss = str("SELECT TxRes.FrameCount - RxRes.FrameCount " + "As 'Packet Loss' From RxEotStreamResults As RxRes " + "JOIN TxEotStreamResults As TxRes " + "JOIN Streamblock As Sb " + "ON RxRes.ParentStreamBlock = TxRes.ParentStreamblock " + "AND TxRes.ParentStreamblock = Sb.Handle") q_ooopkt = str("SELECT OutSeqFrameCount FROM RxEotStreamResults As RxStr " + "JOIN StreamBlock AS Sb " + "ON RxStr.ParentStreamBlock == Sb.Handle") q_latepkt = str("SELECT LateFrameCount FROM RxEotStreamResults As RxStr " + "JOIN StreamBlock AS Sb " + "ON RxStr.ParentStreamBlock == Sb.Handle") q_xcat = str("SELECT Name || '/' || Sb.FixedFrameLength " + "FROM RxEotStreamResults As RxStr " + "JOIN StreamBlock AS Sb " + "ON RxStr.ParentStreamBlock == Sb.Handle") min_jitter_data = get_data_from_query(db_list, q_minjitter) avg_jitter_data = get_data_from_query(db_list, q_avgjitter) max_jitter_data = get_data_from_query(db_list, q_maxjitter) min_latency_data = get_data_from_query(db_list, q_minlatency) avg_latency_data = get_data_from_query(db_list, q_avglatency) max_latency_data = get_data_from_query(db_list, q_maxlatency) pktloss_data = get_data_from_query(db_list, q_pktloss) ooopkt_data = get_data_from_query(db_list, q_ooopkt) latepkt_data = get_data_from_query(db_list, q_latepkt) xcat_data = get_data_from_query(db_list, q_xcat) base_template['series'][0]['data'] = min_jitter_data base_template['series'][1]['data'] = avg_jitter_data base_template['series'][2]['data'] = max_jitter_data base_template['series'][3]['data'] = min_latency_data base_template['series'][4]['data'] = avg_latency_data base_template['series'][5]['data'] = max_latency_data base_template['series'][6]['data'] = pktloss_data base_template['series'][7]['data'] = ooopkt_data base_template['series'][8]['data'] = latepkt_data base_template['xAxis']['categories'] = xcat_data result_data = init_chart_data_dict("GROUP_1") pdg.submit_provider_data(result_data) return ""
def run(ApplyVerdictToSummary, DynamicResultViewName, OperationType, ResultCount, MinResultCount, MaxResultCount, ReportGroup, DisplayName, PassedVerdictExplanation, FailedVerdictExplanation): logger = PLLogger.GetLogger('methodology') global vdrvc_object try: drv = vdrvc_object # subscribe or refresh if drv_utils.subscribe(drv) is False: drv_utils.refresh(drv) # get verdict and text verdict_data = pu.get_comparision_verdict_with_text(OperationType, drv.Get('ResultCount'), ResultCount, 0, 0, 'result count') # generate drill down data prq = drv.GetObject('PresentationResultQuery') col_names = prq.GetCollection('SelectProperties') col_display_names = drv_utils.get_column_display_names(drv, col_names) active_groupby = drv_utils.get_active_groupby(drv) active_view_data = drv_utils.get_drilldown_data(drv, active_groupby, col_names, col_display_names, False) group_order_list = drv_utils.get_export_groupby_ordered(col_names, False) viewdata = [] for groupbyKey in reversed(group_order_list): if active_groupby == groupbyKey: viewdata.append(active_view_data) else: viewdata.append(drv_utils.get_drilldown_data(drv, groupbyKey, col_names, col_display_names, True)) drilldown_data = drv_utils.get_formatted_drilldown_data(viewdata) provider_data = p.get_table_drv_drilldown_data(DynamicResultViewName, verdict_data[pc.VERDICT], verdict_data[pc.VERDICT_TEXT], ApplyVerdictToSummary, drilldown_data, ReportGroup, DisplayName, PassedVerdictExplanation, FailedVerdictExplanation) p.submit_provider_data(provider_data) # revert drv config changes drv_utils.set_groupby(drv, active_groupby) drv_utils.refresh(drv) except Exception, e: stack_trace = traceback.format_exc() logger.LogError(stack_trace) p.submit_command_execution_error(DisplayName, str(e), stack_trace) return False
def CreateChart(tagname, b, params): plLogger = PLLogger.GetLogger("Methodology") plLogger.LogDebug("Running custom CreateChart script...") plLogger.LogDebug(" tagname : " + str(tagname)) db_list = get_dbs(True, False) sb_info = get_active_streamblock_info(db_list) logger.debug(" number of selected streams: " + str(len(sb_info))) q_stream = get_streamblock_query() q_maxjitter = ( str( "SELECT ROUND(MaxJitter*1e-3,3) FROM RxEotStreamResults As RxStr " + "JOIN StreamBlock AS Sb " + "ON RxStr.ParentStreamBlock == Sb.Handle" ) + str(q_stream) + str(" WHERE IsExpectedPort = 1") ) q_maxlatency = ( str( "SELECT ROUND(MaxLatency*1e-3,3) FROM RxEotStreamResults As RxStr " + "JOIN StreamBlock AS Sb " + "ON RxStr.ParentStreamBlock == Sb.Handle" ) + str(q_stream) + str(" WHERE IsExpectedPort = 1") ) q_pktloss = ( str( "SELECT TxRes.FrameCount - RxRes.FrameCount " + "As 'Packet Loss' From RxEotStreamResults As RxRes " + "JOIN TxEotStreamResults As TxRes " + "JOIN Streamblock As Sb " + "ON RxRes.ParentStreamBlock = TxRes.ParentStreamblock " + "AND TxRes.ParentStreamblock = Sb.Handle" ) + str(q_stream) + str(" WHERE IsExpectedPort = 1") ) q_ooopkt = ( str( "SELECT OutSeqFrameCount FROM RxEotStreamResults As RxStr " + "JOIN StreamBlock AS Sb " + "ON RxStr.ParentStreamBlock == Sb.Handle" ) + str(q_stream) + str(" WHERE IsExpectedPort = 1") ) q_latepkt = ( str( "SELECT LateFrameCount FROM RxEotStreamResults As RxStr " + "JOIN StreamBlock AS Sb " + "ON RxStr.ParentStreamBlock == Sb.Handle" ) + str(q_stream) + str(" WHERE IsExpectedPort = 1") ) q_duppkt = ( str( "SELECT DuplicateFrameCount FROM RxEotStreamResults As RxStr " + "JOIN StreamBlock AS Sb " + "ON RxStr.ParentStreamBlock == Sb.Handle" ) + str(q_stream) + str(" WHERE IsExpectedPort = 1") ) max_jitter_data = get_data_from_query(db_list, q_maxjitter) max_latency_data = get_data_from_query(db_list, q_maxlatency) pktloss_data = get_data_from_query(db_list, q_pktloss) ooopkt_data = get_data_from_query(db_list, q_ooopkt) latepkt_data = get_data_from_query(db_list, q_latepkt) duppkt_data = get_data_from_query(db_list, q_duppkt) xcat_data = [x + 1 for x in range(len(db_list))] # jitter get_per_stream_time_from_db(sb_info, max_jitter_data, "Jitter (ms)", xcat_data) result_jitter = init_chart_data_dict("GROUP_1", time_template) pdg.submit_provider_data(result_jitter) # latency get_per_stream_time_from_db(sb_info, max_latency_data, "Latency (ms)", xcat_data) result_latency = init_chart_data_dict("GROUP_1", time_template) pdg.submit_provider_data(result_latency) # packet loss get_per_stream_packet_from_db(sb_info, pktloss_data, "Packet Loss", xcat_data) result_loss = init_chart_data_dict("GROUP_1", packet_template) pdg.submit_provider_data(result_loss) # ooo packet get_per_stream_packet_from_db(sb_info, ooopkt_data, "Out of Order Packet", xcat_data) result_ooo = init_chart_data_dict("GROUP_1", packet_template) pdg.submit_provider_data(result_ooo) # late packet get_per_stream_packet_from_db(sb_info, latepkt_data, "Late Packet", xcat_data) result_late = init_chart_data_dict("GROUP_1", packet_template) pdg.submit_provider_data(result_late) # duplicated packet get_per_stream_packet_from_db(sb_info, duppkt_data, "Duplicated Packet", xcat_data) result_dup = init_chart_data_dict("GROUP_1", packet_template) pdg.submit_provider_data(result_dup) return ""