| # TopoPerfNext |
| # |
| # Topology Performance test for ONOS-next |
| # |
| # andrew@onlab.us |
| # |
| # If your machine does not come with numpy |
| # run the following command: |
| # sudo apt-get install python-numpy python-scipy |
| |
| import time |
| import sys |
| import os |
| import re |
| |
| |
| class TopoPerfNext: |
| |
| def __init__( self ): |
| self.default = '' |
| |
| def CASE1( self, main ): |
| """ |
| ONOS startup sequence |
| """ |
| import time |
| |
| cell_name = main.params[ 'ENV' ][ 'cellName' ] |
| |
| git_pull = main.params[ 'GIT' ][ 'autoPull' ] |
| checkout_branch = main.params[ 'GIT' ][ 'checkout' ] |
| |
| ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ] |
| ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ] |
| ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ] |
| |
| #### Hardcoded ONOS nodes particular to my env #### |
| ONOS4_ip = "10.128.174.4" |
| ONOS5_ip = "10.128.174.5" |
| ONOS6_ip = "10.128.174.6" |
| ONOS7_ip = "10.128.174.7" |
| #### #### |
| |
| MN1_ip = main.params[ 'MN' ][ 'ip1' ] |
| BENCH_ip = main.params[ 'BENCH' ][ 'ip' ] |
| |
| topo_cfg_file = main.params[ 'TEST' ][ 'topo_config_file' ] |
| topo_cfg_name = main.params[ 'TEST' ][ 'topo_config_name' ] |
| |
| main.case( "Setting up test environment" ) |
| main.log.info( "Copying topology event accumulator config" + |
| " to ONOS /package/etc" ) |
| main.ONOSbench.handle.sendline( "cp ~/" + |
| topo_cfg_file + |
| " ~/ONOS/tools/package/etc/" + |
| topo_cfg_name ) |
| main.ONOSbench.handle.expect( "\$" ) |
| |
| main.log.report( "Setting up test environment" ) |
| |
| main.step( "Cleaning previously installed ONOS if any" ) |
| main.ONOSbench.onos_uninstall( node_ip=ONOS4_ip ) |
| main.ONOSbench.onos_uninstall( node_ip=ONOS5_ip ) |
| main.ONOSbench.onos_uninstall( node_ip=ONOS6_ip ) |
| main.ONOSbench.onos_uninstall( node_ip=ONOS7_ip ) |
| |
| main.step( "Creating cell file" ) |
| cell_file_result = main.ONOSbench.create_cell_file( |
| BENCH_ip, cell_name, MN1_ip, "onos-core,onos-app-metrics", |
| ONOS1_ip, ONOS2_ip, ONOS3_ip ) |
| |
| main.step( "Applying cell file to environment" ) |
| cell_apply_result = main.ONOSbench.set_cell( cell_name ) |
| verify_cell_result = main.ONOSbench.verify_cell() |
| |
| # NOTE: This step may be removed after proper |
| # copy cat log functionality |
| main.step( "Removing raft/copy-cat logs from ONOS nodes" ) |
| main.ONOSbench.onos_remove_raft_logs() |
| time.sleep( 30 ) |
| |
| main.step( "Git checkout and pull " + checkout_branch ) |
| if git_pull == 'on': |
| checkout_result = \ |
| main.ONOSbench.git_checkout( checkout_branch ) |
| pull_result = main.ONOSbench.git_pull() |
| else: |
| checkout_result = main.TRUE |
| pull_result = main.TRUE |
| main.log.info( "Skipped git checkout and pull" ) |
| |
| # TODO: Uncomment when wiki posting works |
| #main.log.report( "Commit information - " ) |
| # main.ONOSbench.get_version( report=True ) |
| |
| main.step( "Using mvn clean & install" ) |
| #mvn_result = main.ONOSbench.clean_install() |
| mvn_result = main.TRUE |
| |
| main.step( "Set cell for ONOS cli env" ) |
| main.ONOS1cli.set_cell( cell_name ) |
| main.ONOS2cli.set_cell( cell_name ) |
| main.ONOS3cli.set_cell( cell_name ) |
| |
| main.step( "Creating ONOS package" ) |
| package_result = main.ONOSbench.onos_package() |
| |
| main.step( "Installing ONOS package" ) |
| install1_result = main.ONOSbench.onos_install( node=ONOS1_ip ) |
| install2_result = main.ONOSbench.onos_install( node=ONOS2_ip ) |
| install3_result = main.ONOSbench.onos_install( node=ONOS3_ip ) |
| |
| time.sleep( 10 ) |
| |
| main.step( "Start onos cli" ) |
| cli1 = main.ONOS1cli.start_onos_cli( ONOS1_ip ) |
| cli2 = main.ONOS2cli.start_onos_cli( ONOS2_ip ) |
| cli3 = main.ONOS3cli.start_onos_cli( ONOS3_ip ) |
| |
| utilities.assert_equals( expect=main.TRUE, |
| actual=cell_file_result and cell_apply_result and |
| verify_cell_result and checkout_result and |
| pull_result and mvn_result and |
| install1_result and install2_result and |
| install3_result, |
| onpass="Test Environment setup successful", |
| onfail="Failed to setup test environment" ) |
| |
| def CASE2( self, main ): |
| """ |
| Assign s1 to ONOS1 and measure latency |
| |
| There are 4 levels of latency measurements to this test: |
| 1 ) End-to-end measurement: Complete end-to-end measurement |
| from TCP ( SYN/ACK ) handshake to Graph change |
| 2 ) OFP-to-graph measurement: 'ONOS processing' snippet of |
| measurement from OFP Vendor message to Graph change |
| 3 ) OFP-to-device measurement: 'ONOS processing without |
| graph change' snippet of measurement from OFP vendor |
| message to Device change timestamp |
| 4 ) T0-to-device measurement: Measurement that includes |
| the switch handshake to devices timestamp without |
| the graph view change. ( TCP handshake -> Device |
| change ) |
| """ |
| import time |
| import subprocess |
| import json |
| import requests |
| import os |
| import numpy |
| |
| ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ] |
| ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ] |
| ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ] |
| ONOS_user = main.params[ 'CTRL' ][ 'user' ] |
| |
| default_sw_port = main.params[ 'CTRL' ][ 'port1' ] |
| |
| # Number of iterations of case |
| num_iter = main.params[ 'TEST' ][ 'numIter' ] |
| # Number of first 'x' iterations to ignore: |
| iter_ignore = int( main.params[ 'TEST' ][ 'iterIgnore' ] ) |
| |
| # Timestamp 'keys' for json metrics output. |
| # These are subject to change, hence moved into params |
| deviceTimestamp = main.params[ 'JSON' ][ 'deviceTimestamp' ] |
| graphTimestamp = main.params[ 'JSON' ][ 'graphTimestamp' ] |
| |
| debug_mode = main.params[ 'TEST' ][ 'debugMode' ] |
| onos_log = main.params[ 'TEST' ][ 'onosLogFile' ] |
| |
| # Threshold for the test |
| threshold_str = main.params[ 'TEST' ][ 'singleSwThreshold' ] |
| threshold_obj = threshold_str.split( "," ) |
| threshold_min = int( threshold_obj[ 0 ] ) |
| threshold_max = int( threshold_obj[ 1 ] ) |
| |
| # List of switch add latency collected from |
| # all iterations |
| latency_end_to_end_list = [] |
| latency_ofp_to_graph_list = [] |
| latency_ofp_to_device_list = [] |
| latency_t0_to_device_list = [] |
| latency_tcp_to_ofp_list = [] |
| |
| # Directory/file to store tshark results |
| tshark_of_output = "/tmp/tshark_of_topo.txt" |
| tshark_tcp_output = "/tmp/tshark_tcp_topo.txt" |
| |
| # String to grep in tshark output |
| tshark_tcp_string = "TCP 74 " + default_sw_port |
| tshark_of_string = "OFP 86 Vendor" |
| |
| # Initialize assertion to TRUE |
| assertion = main.TRUE |
| |
| local_time = time.strftime( '%x %X' ) |
| local_time = local_time.replace( "/", "" ) |
| local_time = local_time.replace( " ", "_" ) |
| local_time = local_time.replace( ":", "" ) |
| if debug_mode == 'on': |
| main.ONOS1.tshark_pcap( "eth0", |
| "/tmp/single_sw_lat_pcap_" + local_time ) |
| |
| main.log.info( "TEST" ) |
| |
| main.log.report( "Latency of adding one switch to controller" ) |
| main.log.report( |
| "First " + |
| str( iter_ignore ) + |
| " iterations ignored" + |
| " for jvm warmup time" ) |
| main.log.report( "Total iterations of test: " + str( num_iter ) ) |
| |
| for i in range( 0, int( num_iter ) ): |
| main.log.info( "Starting tshark capture" ) |
| |
| #* TCP [ ACK, SYN ] is used as t0_a, the |
| # very first "exchange" between ONOS and |
| # the switch for end-to-end measurement |
| #* OFP [ Stats Reply ] is used for t0_b |
| # the very last OFP message between ONOS |
| # and the switch for ONOS measurement |
| main.ONOS1.tshark_grep( tshark_tcp_string, |
| tshark_tcp_output ) |
| main.ONOS1.tshark_grep( tshark_of_string, |
| tshark_of_output ) |
| |
| # Wait and ensure tshark is started and |
| # capturing |
| time.sleep( 10 ) |
| |
| main.log.info( "Assigning s1 to controller" ) |
| |
| main.Mininet1.assign_sw_controller( |
| sw="1", |
| ip1=ONOS1_ip, |
| port1=default_sw_port ) |
| |
| # Wait and ensure switch is assigned |
| # before stopping tshark |
| time.sleep( 30 ) |
| |
| main.log.info( "Stopping all Tshark processes" ) |
| main.ONOS1.stop_tshark() |
| |
| # tshark output is saved in ONOS. Use subprocess |
| # to copy over files to TestON for parsing |
| main.log.info( "Copying over tshark files" ) |
| |
| # TCP CAPTURE **** |
| # Copy the tshark output from ONOS machine to |
| # TestON machine in tshark_tcp_output directory>file |
| os.system( "scp " + ONOS_user + "@" + ONOS1_ip + ":" + |
| tshark_tcp_output + " /tmp/" ) |
| tcp_file = open( tshark_tcp_output, 'r' ) |
| temp_text = tcp_file.readline() |
| temp_text = temp_text.split( " " ) |
| |
| main.log.info( "Object read in from TCP capture: " + |
| str( temp_text ) ) |
| if len( temp_text ) > 1: |
| t0_tcp = float( temp_text[ 1 ] ) * 1000.0 |
| else: |
| main.log.error( "Tshark output file for TCP" + |
| " returned unexpected results" ) |
| t0_tcp = 0 |
| assertion = main.FALSE |
| |
| tcp_file.close() |
| #**************** |
| |
| # OF CAPTURE **** |
| os.system( "scp " + ONOS_user + "@" + ONOS1_ip + ":" + |
| tshark_of_output + " /tmp/" ) |
| of_file = open( tshark_of_output, 'r' ) |
| |
| line_ofp = "" |
| # Read until last line of file |
| while True: |
| temp_text = of_file.readline() |
| if temp_text != '': |
| line_ofp = temp_text |
| else: |
| break |
| obj = line_ofp.split( " " ) |
| |
| main.log.info( "Object read in from OFP capture: " + |
| str( line_ofp ) ) |
| |
| if len( line_ofp ) > 1: |
| t0_ofp = float( obj[ 1 ] ) * 1000.0 |
| else: |
| main.log.error( "Tshark output file for OFP" + |
| " returned unexpected results" ) |
| t0_ofp = 0 |
| assertion = main.FALSE |
| |
| of_file.close() |
| #**************** |
| |
| json_str_1 = main.ONOS1cli.topology_events_metrics() |
| json_str_2 = main.ONOS2cli.topology_events_metrics() |
| json_str_3 = main.ONOS3cli.topology_events_metrics() |
| |
| json_obj_1 = json.loads( json_str_1 ) |
| json_obj_2 = json.loads( json_str_2 ) |
| json_obj_3 = json.loads( json_str_3 ) |
| |
| # Obtain graph timestamp. This timestsamp captures |
| # the epoch time at which the topology graph was updated. |
| graph_timestamp_1 = \ |
| json_obj_1[ graphTimestamp ][ 'value' ] |
| graph_timestamp_2 = \ |
| json_obj_2[ graphTimestamp ][ 'value' ] |
| graph_timestamp_3 = \ |
| json_obj_3[ graphTimestamp ][ 'value' ] |
| |
| # Obtain device timestamp. This timestamp captures |
| # the epoch time at which the device event happened |
| device_timestamp_1 = \ |
| json_obj_1[ deviceTimestamp ][ 'value' ] |
| device_timestamp_2 = \ |
| json_obj_2[ deviceTimestamp ][ 'value' ] |
| device_timestamp_3 = \ |
| json_obj_3[ deviceTimestamp ][ 'value' ] |
| |
| # t0 to device processing latency |
| delta_device_1 = int( device_timestamp_1 ) - int( t0_tcp ) |
| delta_device_2 = int( device_timestamp_2 ) - int( t0_tcp ) |
| delta_device_3 = int( device_timestamp_3 ) - int( t0_tcp ) |
| |
| # Get average of delta from all instances |
| avg_delta_device = \ |
| ( int( delta_device_1 ) + |
| int( delta_device_2 ) + |
| int( delta_device_3 ) ) / 3 |
| |
| # Ensure avg delta meets the threshold before appending |
| if avg_delta_device > 0.0 and avg_delta_device < 10000\ |
| and int( i ) > iter_ignore: |
| latency_t0_to_device_list.append( avg_delta_device ) |
| else: |
| main.log.info( |
| "Results for t0-to-device ignored" + |
| "due to excess in threshold / warmup iteration." ) |
| |
| # t0 to graph processing latency ( end-to-end ) |
| delta_graph_1 = int( graph_timestamp_1 ) - int( t0_tcp ) |
| delta_graph_2 = int( graph_timestamp_2 ) - int( t0_tcp ) |
| delta_graph_3 = int( graph_timestamp_3 ) - int( t0_tcp ) |
| |
| # Get average of delta from all instances |
| avg_delta_graph = \ |
| ( int( delta_graph_1 ) + |
| int( delta_graph_2 ) + |
| int( delta_graph_3 ) ) / 3 |
| |
| # Ensure avg delta meets the threshold before appending |
| if avg_delta_graph > 0.0 and avg_delta_graph < 10000\ |
| and int( i ) > iter_ignore: |
| latency_end_to_end_list.append( avg_delta_graph ) |
| else: |
| main.log.info( "Results for end-to-end ignored" + |
| "due to excess in threshold" ) |
| |
| # ofp to graph processing latency ( ONOS processing ) |
| delta_ofp_graph_1 = int( graph_timestamp_1 ) - int( t0_ofp ) |
| delta_ofp_graph_2 = int( graph_timestamp_2 ) - int( t0_ofp ) |
| delta_ofp_graph_3 = int( graph_timestamp_3 ) - int( t0_ofp ) |
| |
| avg_delta_ofp_graph = \ |
| ( int( delta_ofp_graph_1 ) + |
| int( delta_ofp_graph_2 ) + |
| int( delta_ofp_graph_3 ) ) / 3 |
| |
| if avg_delta_ofp_graph > threshold_min \ |
| and avg_delta_ofp_graph < threshold_max\ |
| and int( i ) > iter_ignore: |
| latency_ofp_to_graph_list.append( avg_delta_ofp_graph ) |
| elif avg_delta_ofp_graph > ( -10 ) and \ |
| avg_delta_ofp_graph < 0.0 and\ |
| int( i ) > iter_ignore: |
| main.log.info( "Sub-millisecond result likely; " + |
| "negative result was rounded to 0" ) |
| # NOTE: Current metrics framework does not |
| # support sub-millisecond accuracy. Therefore, |
| # if the result is negative, we can reasonably |
| # conclude sub-millisecond results and just |
| # append the best rounded effort - 0 ms. |
| latency_ofp_to_graph_list.append( 0 ) |
| else: |
| main.log.info( "Results for ofp-to-graph " + |
| "ignored due to excess in threshold" ) |
| |
| # ofp to device processing latency ( ONOS processing ) |
| delta_ofp_device_1 = float( device_timestamp_1 ) - float( t0_ofp ) |
| delta_ofp_device_2 = float( device_timestamp_2 ) - float( t0_ofp ) |
| delta_ofp_device_3 = float( device_timestamp_3 ) - float( t0_ofp ) |
| |
| avg_delta_ofp_device = \ |
| ( float( delta_ofp_device_1 ) + |
| float( delta_ofp_device_2 ) + |
| float( delta_ofp_device_3 ) ) / 3 |
| |
| # NOTE: ofp - delta measurements are occasionally negative |
| # due to system time misalignment. |
| latency_ofp_to_device_list.append( avg_delta_ofp_device ) |
| |
| delta_ofp_tcp = int( t0_ofp ) - int( t0_tcp ) |
| if delta_ofp_tcp > threshold_min \ |
| and delta_ofp_tcp < threshold_max and\ |
| int( i ) > iter_ignore: |
| latency_tcp_to_ofp_list.append( delta_ofp_tcp ) |
| else: |
| main.log.info( "Results fo tcp-to-ofp " + |
| "ignored due to excess in threshold" ) |
| |
| # TODO: |
| # Fetch logs upon threshold excess |
| |
| main.log.info( "ONOS1 delta end-to-end: " + |
| str( delta_graph_1 ) + " ms" ) |
| main.log.info( "ONOS2 delta end-to-end: " + |
| str( delta_graph_2 ) + " ms" ) |
| main.log.info( "ONOS3 delta end-to-end: " + |
| str( delta_graph_3 ) + " ms" ) |
| |
| main.log.info( "ONOS1 delta OFP - graph: " + |
| str( delta_ofp_graph_1 ) + " ms" ) |
| main.log.info( "ONOS2 delta OFP - graph: " + |
| str( delta_ofp_graph_2 ) + " ms" ) |
| main.log.info( "ONOS3 delta OFP - graph: " + |
| str( delta_ofp_graph_3 ) + " ms" ) |
| |
| main.log.info( "ONOS1 delta device - t0: " + |
| str( delta_device_1 ) + " ms" ) |
| main.log.info( "ONOS2 delta device - t0: " + |
| str( delta_device_2 ) + " ms" ) |
| main.log.info( "ONOS3 delta device - t0: " + |
| str( delta_device_3 ) + " ms" ) |
| |
| main.log.info( "TCP to OFP delta: " + |
| str( delta_ofp_tcp ) + " ms" ) |
| # main.log.info( "ONOS1 delta OFP - device: "+ |
| # str( delta_ofp_device_1 ) + " ms" ) |
| # main.log.info( "ONOS2 delta OFP - device: "+ |
| # str( delta_ofp_device_2 ) + " ms" ) |
| # main.log.info( "ONOS3 delta OFP - device: "+ |
| # str( delta_ofp_device_3 ) + " ms" ) |
| |
| main.step( "Remove switch from controller" ) |
| main.Mininet1.delete_sw_controller( "s1" ) |
| |
| time.sleep( 5 ) |
| |
| # END of for loop iteration |
| |
| # If there is at least 1 element in each list, |
| # pass the test case |
| if len( latency_end_to_end_list ) > 0 and\ |
| len( latency_ofp_to_graph_list ) > 0 and\ |
| len( latency_ofp_to_device_list ) > 0 and\ |
| len( latency_t0_to_device_list ) > 0 and\ |
| len( latency_tcp_to_ofp_list ) > 0: |
| assertion = main.TRUE |
| elif len( latency_end_to_end_list ) == 0: |
| # The appending of 0 here is to prevent |
| # the min,max,sum functions from failing |
| # below |
| latency_end_to_end_list.append( 0 ) |
| assertion = main.FALSE |
| elif len( latency_ofp_to_graph_list ) == 0: |
| latency_ofp_to_graph_list.append( 0 ) |
| assertion = main.FALSE |
| elif len( latency_ofp_to_device_list ) == 0: |
| latency_ofp_to_device_list.append( 0 ) |
| assertion = main.FALSE |
| elif len( latency_t0_to_device_list ) == 0: |
| latency_t0_to_device_list.append( 0 ) |
| assertion = main.FALSE |
| elif len( latency_tcp_to_ofp_list ) == 0: |
| latency_tcp_to_ofp_list.append( 0 ) |
| assertion = main.FALSE |
| |
| # Calculate min, max, avg of latency lists |
| latency_end_to_end_max = \ |
| int( max( latency_end_to_end_list ) ) |
| latency_end_to_end_min = \ |
| int( min( latency_end_to_end_list ) ) |
| latency_end_to_end_avg = \ |
| ( int( sum( latency_end_to_end_list ) ) / |
| len( latency_end_to_end_list ) ) |
| latency_end_to_end_std_dev = \ |
| str( round( numpy.std( latency_end_to_end_list ), 1 ) ) |
| |
| latency_ofp_to_graph_max = \ |
| int( max( latency_ofp_to_graph_list ) ) |
| latency_ofp_to_graph_min = \ |
| int( min( latency_ofp_to_graph_list ) ) |
| latency_ofp_to_graph_avg = \ |
| ( int( sum( latency_ofp_to_graph_list ) ) / |
| len( latency_ofp_to_graph_list ) ) |
| latency_ofp_to_graph_std_dev = \ |
| str( round( numpy.std( latency_ofp_to_graph_list ), 1 ) ) |
| |
| latency_ofp_to_device_max = \ |
| int( max( latency_ofp_to_device_list ) ) |
| latency_ofp_to_device_min = \ |
| int( min( latency_ofp_to_device_list ) ) |
| latency_ofp_to_device_avg = \ |
| ( int( sum( latency_ofp_to_device_list ) ) / |
| len( latency_ofp_to_device_list ) ) |
| latency_ofp_to_device_std_dev = \ |
| str( round( numpy.std( latency_ofp_to_device_list ), 1 ) ) |
| |
| latency_t0_to_device_max = \ |
| int( max( latency_t0_to_device_list ) ) |
| latency_t0_to_device_min = \ |
| int( min( latency_t0_to_device_list ) ) |
| latency_t0_to_device_avg = \ |
| ( int( sum( latency_t0_to_device_list ) ) / |
| len( latency_t0_to_device_list ) ) |
| latency_ofp_to_device_std_dev = \ |
| str( round( numpy.std( latency_t0_to_device_list ), 1 ) ) |
| |
| latency_tcp_to_ofp_max = \ |
| int( max( latency_tcp_to_ofp_list ) ) |
| latency_tcp_to_ofp_min = \ |
| int( min( latency_tcp_to_ofp_list ) ) |
| latency_tcp_to_ofp_avg = \ |
| ( int( sum( latency_tcp_to_ofp_list ) ) / |
| len( latency_tcp_to_ofp_list ) ) |
| latency_tcp_to_ofp_std_dev = \ |
| str( round( numpy.std( latency_tcp_to_ofp_list ), 1 ) ) |
| |
| main.log.report( |
| "Switch add - End-to-end latency: " + |
| "Avg: " + |
| str( latency_end_to_end_avg ) + |
| " ms " + |
| "Std Deviation: " + |
| latency_end_to_end_std_dev + |
| " ms" ) |
| main.log.report( |
| "Switch add - OFP-to-Graph latency: " + |
| "Note: results are not accurate to sub-millisecond. " + |
| "Any sub-millisecond results are rounded to 0 ms. " ) |
| main.log.report( |
| "Avg: " + |
| str( latency_ofp_to_graph_avg ) + |
| " ms " + |
| "Std Deviation: " + |
| latency_ofp_to_graph_std_dev + |
| " ms" ) |
| main.log.report( |
| "Switch add - TCP-to-OFP latency: " + |
| "Avg: " + |
| str( latency_tcp_to_ofp_avg ) + |
| " ms " + |
| "Std Deviation: " + |
| latency_tcp_to_ofp_std_dev + |
| " ms" ) |
| |
| if debug_mode == 'on': |
| main.ONOS1.cp_logs_to_dir( "/opt/onos/log/karaf.log", |
| "/tmp/", copy_file_name="sw_lat_karaf" ) |
| |
| utilities.assert_equals( expect=main.TRUE, actual=assertion, |
| onpass="Switch latency test successful", |
| onfail="Switch latency test failed" ) |
| |
| def CASE3( self, main ): |
| """ |
| Bring port up / down and measure latency. |
| Port enable / disable is simulated by ifconfig up / down |
| |
| In ONOS-next, we must ensure that the port we are |
| manipulating is connected to another switch with a valid |
| connection. Otherwise, graph view will not be updated. |
| """ |
| import time |
| import subprocess |
| import os |
| import requests |
| import json |
| import numpy |
| |
| ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ] |
| ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ] |
| ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ] |
| ONOS_user = main.params[ 'CTRL' ][ 'user' ] |
| |
| default_sw_port = main.params[ 'CTRL' ][ 'port1' ] |
| |
| assertion = main.TRUE |
| # Number of iterations of case |
| num_iter = main.params[ 'TEST' ][ 'numIter' ] |
| |
| # Timestamp 'keys' for json metrics output. |
| # These are subject to change, hence moved into params |
| deviceTimestamp = main.params[ 'JSON' ][ 'deviceTimestamp' ] |
| graphTimestamp = main.params[ 'JSON' ][ 'graphTimestamp' ] |
| |
| debug_mode = main.params[ 'TEST' ][ 'debugMode' ] |
| |
| local_time = time.strftime( '%x %X' ) |
| local_time = local_time.replace( "/", "" ) |
| local_time = local_time.replace( " ", "_" ) |
| local_time = local_time.replace( ":", "" ) |
| if debug_mode == 'on': |
| main.ONOS1.tshark_pcap( "eth0", |
| "/tmp/port_lat_pcap_" + local_time ) |
| |
| # Threshold for this test case |
| up_threshold_str = main.params[ 'TEST' ][ 'portUpThreshold' ] |
| down_threshold_str = main.params[ 'TEST' ][ 'portDownThreshold' ] |
| |
| up_threshold_obj = up_threshold_str.split( "," ) |
| down_threshold_obj = down_threshold_str.split( "," ) |
| |
| up_threshold_min = int( up_threshold_obj[ 0 ] ) |
| up_threshold_max = int( up_threshold_obj[ 1 ] ) |
| |
| down_threshold_min = int( down_threshold_obj[ 0 ] ) |
| down_threshold_max = int( down_threshold_obj[ 1 ] ) |
| |
| # NOTE: Some hardcoded variables you may need to configure |
| # besides the params |
| |
| tshark_port_status = "OFP 130 Port Status" |
| |
| tshark_port_up = "/tmp/tshark_port_up.txt" |
| tshark_port_down = "/tmp/tshark_port_down.txt" |
| interface_config = "s1-eth1" |
| |
| main.log.report( "Port enable / disable latency" ) |
| main.log.report( "Simulated by ifconfig up / down" ) |
| main.log.report( "Total iterations of test: " + str( num_iter ) ) |
| |
| main.step( "Assign switches s1 and s2 to controller 1" ) |
| main.Mininet1.assign_sw_controller( sw="1", ip1=ONOS1_ip, |
| port1=default_sw_port ) |
| main.Mininet1.assign_sw_controller( sw="2", ip1=ONOS1_ip, |
| port1=default_sw_port ) |
| |
| # Give enough time for metrics to propagate the |
| # assign controller event. Otherwise, these events may |
| # carry over to our measurements |
| time.sleep( 15 ) |
| |
| port_up_device_to_ofp_list = [] |
| port_up_graph_to_ofp_list = [] |
| port_down_device_to_ofp_list = [] |
| port_down_graph_to_ofp_list = [] |
| |
| for i in range( 0, int( num_iter ) ): |
| main.step( "Starting wireshark capture for port status down" ) |
| main.ONOS1.tshark_grep( tshark_port_status, |
| tshark_port_down ) |
| |
| time.sleep( 5 ) |
| |
| # Disable interface that is connected to switch 2 |
| main.step( "Disable port: " + interface_config ) |
| main.Mininet1.handle.sendline( "sh ifconfig " + |
| interface_config + " down" ) |
| main.Mininet1.handle.expect( "mininet>" ) |
| |
| time.sleep( 3 ) |
| main.ONOS1.tshark_stop() |
| |
| main.step( "Obtain t1 by metrics call" ) |
| json_str_up_1 = main.ONOS1cli.topology_events_metrics() |
| json_str_up_2 = main.ONOS2cli.topology_events_metrics() |
| json_str_up_3 = main.ONOS3cli.topology_events_metrics() |
| |
| json_obj_1 = json.loads( json_str_up_1 ) |
| json_obj_2 = json.loads( json_str_up_2 ) |
| json_obj_3 = json.loads( json_str_up_3 ) |
| |
| # Copy tshark output file from ONOS to TestON instance |
| #/tmp directory |
| os.system( "scp " + ONOS_user + "@" + ONOS1_ip + ":" + |
| tshark_port_down + " /tmp/" ) |
| |
| f_port_down = open( tshark_port_down, 'r' ) |
| # Get first line of port down event from tshark |
| f_line = f_port_down.readline() |
| obj_down = f_line.split( " " ) |
| if len( f_line ) > 0: |
| timestamp_begin_pt_down = int( float( obj_down[ 1 ] ) * 1000 ) |
| main.log.info( "Port down begin timestamp: " + |
| str( timestamp_begin_pt_down ) ) |
| else: |
| main.log.info( "Tshark output file returned unexpected" + |
| " results: " + str( obj_down ) ) |
| timestamp_begin_pt_down = 0 |
| |
| f_port_down.close() |
| |
| main.log.info( "TEST tshark obj: " + str( obj_down ) ) |
| |
| time.sleep( 3 ) |
| |
| # Obtain graph timestamp. This timestsamp captures |
| # the epoch time at which the topology graph was updated. |
| graph_timestamp_1 = \ |
| json_obj_1[ graphTimestamp ][ 'value' ] |
| graph_timestamp_2 = \ |
| json_obj_2[ graphTimestamp ][ 'value' ] |
| graph_timestamp_3 = \ |
| json_obj_3[ graphTimestamp ][ 'value' ] |
| |
| main.log.info( "TEST graph timestamp ONOS1: " + |
| str( graph_timestamp_1 ) ) |
| |
| # Obtain device timestamp. This timestamp captures |
| # the epoch time at which the device event happened |
| device_timestamp_1 = \ |
| json_obj_1[ deviceTimestamp ][ 'value' ] |
| device_timestamp_2 = \ |
| json_obj_2[ deviceTimestamp ][ 'value' ] |
| device_timestamp_3 = \ |
| json_obj_3[ deviceTimestamp ][ 'value' ] |
| |
| # Get delta between graph event and OFP |
| pt_down_graph_to_ofp_1 = int( graph_timestamp_1 ) -\ |
| int( timestamp_begin_pt_down ) |
| pt_down_graph_to_ofp_2 = int( graph_timestamp_2 ) -\ |
| int( timestamp_begin_pt_down ) |
| pt_down_graph_to_ofp_3 = int( graph_timestamp_3 ) -\ |
| int( timestamp_begin_pt_down ) |
| |
| # Get delta between device event and OFP |
| pt_down_device_to_ofp_1 = int( device_timestamp_1 ) -\ |
| int( timestamp_begin_pt_down ) |
| pt_down_device_to_ofp_2 = int( device_timestamp_2 ) -\ |
| int( timestamp_begin_pt_down ) |
| pt_down_device_to_ofp_3 = int( device_timestamp_3 ) -\ |
| int( timestamp_begin_pt_down ) |
| |
| # Caluclate average across clusters |
| pt_down_graph_to_ofp_avg =\ |
| ( int( pt_down_graph_to_ofp_1 ) + |
| int( pt_down_graph_to_ofp_2 ) + |
| int( pt_down_graph_to_ofp_3 ) ) / 3 |
| pt_down_device_to_ofp_avg = \ |
| ( int( pt_down_device_to_ofp_1 ) + |
| int( pt_down_device_to_ofp_2 ) + |
| int( pt_down_device_to_ofp_3 ) ) / 3 |
| |
| if pt_down_graph_to_ofp_avg > down_threshold_min and \ |
| pt_down_graph_to_ofp_avg < down_threshold_max: |
| port_down_graph_to_ofp_list.append( |
| pt_down_graph_to_ofp_avg ) |
| main.log.info( "Port down: graph to ofp avg: " + |
| str( pt_down_graph_to_ofp_avg ) + " ms" ) |
| else: |
| main.log.info( "Average port down graph-to-ofp result" + |
| " exceeded the threshold: " + |
| str( pt_down_graph_to_ofp_avg ) ) |
| |
| if pt_down_device_to_ofp_avg > 0 and \ |
| pt_down_device_to_ofp_avg < 1000: |
| port_down_device_to_ofp_list.append( |
| pt_down_device_to_ofp_avg ) |
| main.log.info( "Port down: device to ofp avg: " + |
| str( pt_down_device_to_ofp_avg ) + " ms" ) |
| else: |
| main.log.info( "Average port down device-to-ofp result" + |
| " exceeded the threshold: " + |
| str( pt_down_device_to_ofp_avg ) ) |
| |
| # Port up events |
| main.step( "Enable port and obtain timestamp" ) |
| main.step( "Starting wireshark capture for port status up" ) |
| main.ONOS1.tshark_grep( tshark_port_status, tshark_port_up ) |
| time.sleep( 5 ) |
| |
| main.Mininet1.handle.sendline( "sh ifconfig " + |
| interface_config + " up" ) |
| main.Mininet1.handle.expect( "mininet>" ) |
| |
| # Allow time for tshark to capture event |
| time.sleep( 3 ) |
| main.ONOS1.tshark_stop() |
| |
| # Obtain metrics shortly afterwards |
| # This timestsamp captures |
| # the epoch time at which the topology graph was updated. |
| main.step( "Obtain t1 by REST call" ) |
| json_str_up_1 = main.ONOS1cli.topology_events_metrics() |
| json_str_up_2 = main.ONOS2cli.topology_events_metrics() |
| json_str_up_3 = main.ONOS3cli.topology_events_metrics() |
| |
| json_obj_1 = json.loads( json_str_up_1 ) |
| json_obj_2 = json.loads( json_str_up_2 ) |
| json_obj_3 = json.loads( json_str_up_3 ) |
| |
| os.system( "scp " + ONOS_user + "@" + ONOS1_ip + ":" + |
| tshark_port_up + " /tmp/" ) |
| |
| f_port_up = open( tshark_port_up, 'r' ) |
| f_line = f_port_up.readline() |
| obj_up = f_line.split( " " ) |
| if len( f_line ) > 0: |
| timestamp_begin_pt_up = int( float( obj_up[ 1 ] ) * 1000 ) |
| main.log.info( "Port up begin timestamp: " + |
| str( timestamp_begin_pt_up ) ) |
| else: |
| main.log.info( "Tshark output file returned unexpected" + |
| " results." ) |
| timestamp_begin_pt_up = 0 |
| |
| f_port_up.close() |
| |
| graph_timestamp_1 = \ |
| json_obj_1[ graphTimestamp ][ 'value' ] |
| graph_timestamp_2 = \ |
| json_obj_2[ graphTimestamp ][ 'value' ] |
| graph_timestamp_3 = \ |
| json_obj_3[ graphTimestamp ][ 'value' ] |
| |
| # Obtain device timestamp. This timestamp captures |
| # the epoch time at which the device event happened |
| device_timestamp_1 = \ |
| json_obj_1[ deviceTimestamp ][ 'value' ] |
| device_timestamp_2 = \ |
| json_obj_2[ deviceTimestamp ][ 'value' ] |
| device_timestamp_3 = \ |
| json_obj_3[ deviceTimestamp ][ 'value' ] |
| |
| # Get delta between graph event and OFP |
| pt_up_graph_to_ofp_1 = int( graph_timestamp_1 ) -\ |
| int( timestamp_begin_pt_up ) |
| pt_up_graph_to_ofp_2 = int( graph_timestamp_2 ) -\ |
| int( timestamp_begin_pt_up ) |
| pt_up_graph_to_ofp_3 = int( graph_timestamp_3 ) -\ |
| int( timestamp_begin_pt_up ) |
| |
| # Get delta between device event and OFP |
| pt_up_device_to_ofp_1 = int( device_timestamp_1 ) -\ |
| int( timestamp_begin_pt_up ) |
| pt_up_device_to_ofp_2 = int( device_timestamp_2 ) -\ |
| int( timestamp_begin_pt_up ) |
| pt_up_device_to_ofp_3 = int( device_timestamp_3 ) -\ |
| int( timestamp_begin_pt_up ) |
| |
| main.log.info( "ONOS1 delta G2O: " + str( pt_up_graph_to_ofp_1 ) ) |
| main.log.info( "ONOS2 delta G2O: " + str( pt_up_graph_to_ofp_2 ) ) |
| main.log.info( "ONOS3 delta G2O: " + str( pt_up_graph_to_ofp_3 ) ) |
| |
| main.log.info( "ONOS1 delta D2O: " + str( pt_up_device_to_ofp_1 ) ) |
| main.log.info( "ONOS2 delta D2O: " + str( pt_up_device_to_ofp_2 ) ) |
| main.log.info( "ONOS3 delta D2O: " + str( pt_up_device_to_ofp_3 ) ) |
| |
| pt_up_graph_to_ofp_avg = \ |
| ( int( pt_up_graph_to_ofp_1 ) + |
| int( pt_up_graph_to_ofp_2 ) + |
| int( pt_up_graph_to_ofp_3 ) ) / 3 |
| |
| pt_up_device_to_ofp_avg = \ |
| ( int( pt_up_device_to_ofp_1 ) + |
| int( pt_up_device_to_ofp_2 ) + |
| int( pt_up_device_to_ofp_3 ) ) / 3 |
| |
| if pt_up_graph_to_ofp_avg > up_threshold_min and \ |
| pt_up_graph_to_ofp_avg < up_threshold_max: |
| port_up_graph_to_ofp_list.append( |
| pt_up_graph_to_ofp_avg ) |
| main.log.info( "Port down: graph to ofp avg: " + |
| str( pt_up_graph_to_ofp_avg ) + " ms" ) |
| else: |
| main.log.info( "Average port up graph-to-ofp result" + |
| " exceeded the threshold: " + |
| str( pt_up_graph_to_ofp_avg ) ) |
| |
| if pt_up_device_to_ofp_avg > up_threshold_min and \ |
| pt_up_device_to_ofp_avg < up_threshold_max: |
| port_up_device_to_ofp_list.append( |
| pt_up_device_to_ofp_avg ) |
| main.log.info( "Port up: device to ofp avg: " + |
| str( pt_up_device_to_ofp_avg ) + " ms" ) |
| else: |
| main.log.info( "Average port up device-to-ofp result" + |
| " exceeded the threshold: " + |
| str( pt_up_device_to_ofp_avg ) ) |
| |
| # END ITERATION FOR LOOP |
| |
| # Check all list for latency existence and set assertion |
| if ( port_down_graph_to_ofp_list and port_down_device_to_ofp_list |
| and port_up_graph_to_ofp_list and port_up_device_to_ofp_list ): |
| assertion = main.TRUE |
| |
| # Calculate and report latency measurements |
| port_down_graph_to_ofp_min = min( port_down_graph_to_ofp_list ) |
| port_down_graph_to_ofp_max = max( port_down_graph_to_ofp_list ) |
| port_down_graph_to_ofp_avg = \ |
| ( sum( port_down_graph_to_ofp_list ) / |
| len( port_down_graph_to_ofp_list ) ) |
| port_down_graph_to_ofp_std_dev = \ |
| str( round( numpy.std( port_down_graph_to_ofp_list ), 1 ) ) |
| |
| main.log.report( |
| "Port down graph-to-ofp " + |
| "Avg: " + |
| str( port_down_graph_to_ofp_avg ) + |
| " ms " + |
| "Std Deviation: " + |
| port_down_graph_to_ofp_std_dev + |
| " ms" ) |
| |
| port_down_device_to_ofp_min = min( port_down_device_to_ofp_list ) |
| port_down_device_to_ofp_max = max( port_down_device_to_ofp_list ) |
| port_down_device_to_ofp_avg = \ |
| ( sum( port_down_device_to_ofp_list ) / |
| len( port_down_device_to_ofp_list ) ) |
| port_down_device_to_ofp_std_dev = \ |
| str( round( numpy.std( port_down_device_to_ofp_list ), 1 ) ) |
| |
| main.log.report( |
| "Port down device-to-ofp " + |
| "Avg: " + |
| str( port_down_device_to_ofp_avg ) + |
| " ms " + |
| "Std Deviation: " + |
| port_down_device_to_ofp_std_dev + |
| " ms" ) |
| |
| port_up_graph_to_ofp_min = min( port_up_graph_to_ofp_list ) |
| port_up_graph_to_ofp_max = max( port_up_graph_to_ofp_list ) |
| port_up_graph_to_ofp_avg = \ |
| ( sum( port_up_graph_to_ofp_list ) / |
| len( port_up_graph_to_ofp_list ) ) |
| port_up_graph_to_ofp_std_dev = \ |
| str( round( numpy.std( port_up_graph_to_ofp_list ), 1 ) ) |
| |
| main.log.report( |
| "Port up graph-to-ofp " + |
| "Avg: " + |
| str( port_up_graph_to_ofp_avg ) + |
| " ms " + |
| "Std Deviation: " + |
| port_up_graph_to_ofp_std_dev + |
| " ms" ) |
| |
| port_up_device_to_ofp_min = min( port_up_device_to_ofp_list ) |
| port_up_device_to_ofp_max = max( port_up_device_to_ofp_list ) |
| port_up_device_to_ofp_avg = \ |
| ( sum( port_up_device_to_ofp_list ) / |
| len( port_up_device_to_ofp_list ) ) |
| port_up_device_to_ofp_std_dev = \ |
| str( round( numpy.std( port_up_device_to_ofp_list ), 1 ) ) |
| |
| main.log.report( |
| "Port up device-to-ofp " + |
| "Avg: " + |
| str( port_up_device_to_ofp_avg ) + |
| " ms " + |
| "Std Deviation: " + |
| port_up_device_to_ofp_std_dev + |
| " ms" ) |
| |
| utilities.assert_equals( |
| expect=main.TRUE, |
| actual=assertion, |
| onpass="Port discovery latency calculation successful", |
| onfail="Port discovery test failed" ) |
| |
| def CASE4( self, main ): |
| """ |
| Link down event using loss rate 100% |
| |
| Important: |
| Use a simple 2 switch topology with 1 link between |
| the two switches. Ensure that mac addresses of the |
| switches are 1 / 2 respectively |
| """ |
| import time |
| import subprocess |
| import os |
| import requests |
| import json |
| import numpy |
| |
| ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ] |
| ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ] |
| ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ] |
| ONOS_user = main.params[ 'CTRL' ][ 'user' ] |
| |
| default_sw_port = main.params[ 'CTRL' ][ 'port1' ] |
| |
| # Number of iterations of case |
| num_iter = main.params[ 'TEST' ][ 'numIter' ] |
| |
| # Timestamp 'keys' for json metrics output. |
| # These are subject to change, hence moved into params |
| deviceTimestamp = main.params[ 'JSON' ][ 'deviceTimestamp' ] |
| linkTimestamp = main.params[ 'JSON' ][ 'linkTimestamp' ] |
| graphTimestamp = main.params[ 'JSON' ][ 'graphTimestamp' ] |
| |
| debug_mode = main.params[ 'TEST' ][ 'debugMode' ] |
| |
| local_time = time.strftime( '%x %X' ) |
| local_time = local_time.replace( "/", "" ) |
| local_time = local_time.replace( " ", "_" ) |
| local_time = local_time.replace( ":", "" ) |
| if debug_mode == 'on': |
| main.ONOS1.tshark_pcap( "eth0", |
| "/tmp/link_lat_pcap_" + local_time ) |
| |
| # Threshold for this test case |
| up_threshold_str = main.params[ 'TEST' ][ 'linkUpThreshold' ] |
| down_threshold_str = main.params[ 'TEST' ][ 'linkDownThreshold' ] |
| |
| up_threshold_obj = up_threshold_str.split( "," ) |
| down_threshold_obj = down_threshold_str.split( "," ) |
| |
| up_threshold_min = int( up_threshold_obj[ 0 ] ) |
| up_threshold_max = int( up_threshold_obj[ 1 ] ) |
| |
| down_threshold_min = int( down_threshold_obj[ 0 ] ) |
| down_threshold_max = int( down_threshold_obj[ 1 ] ) |
| |
| assertion = main.TRUE |
| # Link event timestamp to system time list |
| link_down_link_to_system_list = [] |
| link_up_link_to_system_list = [] |
| # Graph event timestamp to system time list |
| link_down_graph_to_system_list = [] |
| link_up_graph_to_system_list = [] |
| |
| main.log.report( "Link up / down discovery latency between " + |
| "two switches" ) |
| main.log.report( "Simulated by setting loss-rate 100%" ) |
| main.log.report( "'tc qdisc add dev <intfs> root netem loss 100%'" ) |
| main.log.report( "Total iterations of test: " + str( num_iter ) ) |
| |
| main.step( "Assign all switches" ) |
| main.Mininet1.assign_sw_controller( |
| sw="1", |
| ip1=ONOS1_ip, |
| port1=default_sw_port ) |
| main.Mininet1.assign_sw_controller( |
| sw="2", |
| ip1=ONOS1_ip, |
| port1=default_sw_port ) |
| |
| main.step( "Verifying switch assignment" ) |
| result_s1 = main.Mininet1.get_sw_controller( sw="s1" ) |
| result_s2 = main.Mininet1.get_sw_controller( sw="s2" ) |
| |
| # Allow time for events to finish before taking measurements |
| time.sleep( 10 ) |
| |
| link_down1 = False |
| link_down2 = False |
| link_down3 = False |
| # Start iteration of link event test |
| for i in range( 0, int( num_iter ) ): |
| main.step( "Getting initial system time as t0" ) |
| |
| timestamp_link_down_t0 = time.time() * 1000 |
| # Link down is simulated by 100% loss rate using traffic |
| # control command |
| main.Mininet1.handle.sendline( |
| "sh tc qdisc add dev s1-eth1 root netem loss 100%" ) |
| |
| # TODO: Iterate through 'links' command to verify that |
| # link s1 -> s2 went down ( loop timeout 30 seconds ) |
| # on all 3 ONOS instances |
| main.log.info( "Checking ONOS for link update" ) |
| loop_count = 0 |
| while( not ( link_down1 and link_down2 and link_down3 ) |
| and loop_count < 30 ): |
| json_str1 = main.ONOS1cli.links() |
| json_str2 = main.ONOS2cli.links() |
| json_str3 = main.ONOS3cli.links() |
| |
| if not ( json_str1 and json_str2 and json_str3 ): |
| main.log.error( "CLI command returned error " ) |
| break |
| else: |
| json_obj1 = json.loads( json_str1 ) |
| json_obj2 = json.loads( json_str2 ) |
| json_obj3 = json.loads( json_str3 ) |
| for obj1 in json_obj1: |
| if '01' not in obj1[ 'src' ][ 'device' ]: |
| link_down1 = True |
| main.log.info( "Link down from " + |
| "s1 -> s2 on ONOS1 detected" ) |
| for obj2 in json_obj2: |
| if '01' not in obj2[ 'src' ][ 'device' ]: |
| link_down2 = True |
| main.log.info( "Link down from " + |
| "s1 -> s2 on ONOS2 detected" ) |
| for obj3 in json_obj3: |
| if '01' not in obj3[ 'src' ][ 'device' ]: |
| link_down3 = True |
| main.log.info( "Link down from " + |
| "s1 -> s2 on ONOS3 detected" ) |
| |
| loop_count += 1 |
| # If CLI doesn't like the continuous requests |
| # and exits in this loop, increase the sleep here. |
| # Consequently, while loop timeout will increase |
| time.sleep( 1 ) |
| |
| # Give time for metrics measurement to catch up |
| # NOTE: May need to be configured more accurately |
| time.sleep( 10 ) |
| # If we exited the while loop and link down 1,2,3 are still |
| # false, then ONOS has failed to discover link down event |
| if not ( link_down1 and link_down2 and link_down3 ): |
| main.log.info( "Link down discovery failed" ) |
| |
| link_down_lat_graph1 = 0 |
| link_down_lat_graph2 = 0 |
| link_down_lat_graph3 = 0 |
| link_down_lat_device1 = 0 |
| link_down_lat_device2 = 0 |
| link_down_lat_device3 = 0 |
| |
| assertion = main.FALSE |
| else: |
| json_topo_metrics_1 =\ |
| main.ONOS1cli.topology_events_metrics() |
| json_topo_metrics_2 =\ |
| main.ONOS2cli.topology_events_metrics() |
| json_topo_metrics_3 =\ |
| main.ONOS3cli.topology_events_metrics() |
| json_topo_metrics_1 = json.loads( json_topo_metrics_1 ) |
| json_topo_metrics_2 = json.loads( json_topo_metrics_2 ) |
| json_topo_metrics_3 = json.loads( json_topo_metrics_3 ) |
| |
| main.log.info( "Obtaining graph and device timestamp" ) |
| graph_timestamp_1 = \ |
| json_topo_metrics_1[ graphTimestamp ][ 'value' ] |
| graph_timestamp_2 = \ |
| json_topo_metrics_2[ graphTimestamp ][ 'value' ] |
| graph_timestamp_3 = \ |
| json_topo_metrics_3[ graphTimestamp ][ 'value' ] |
| |
| link_timestamp_1 = \ |
| json_topo_metrics_1[ linkTimestamp ][ 'value' ] |
| link_timestamp_2 = \ |
| json_topo_metrics_2[ linkTimestamp ][ 'value' ] |
| link_timestamp_3 = \ |
| json_topo_metrics_3[ linkTimestamp ][ 'value' ] |
| |
| if graph_timestamp_1 and graph_timestamp_2 and\ |
| graph_timestamp_3 and link_timestamp_1 and\ |
| link_timestamp_2 and link_timestamp_3: |
| link_down_lat_graph1 = int( graph_timestamp_1 ) -\ |
| int( timestamp_link_down_t0 ) |
| link_down_lat_graph2 = int( graph_timestamp_2 ) -\ |
| int( timestamp_link_down_t0 ) |
| link_down_lat_graph3 = int( graph_timestamp_3 ) -\ |
| int( timestamp_link_down_t0 ) |
| |
| link_down_lat_link1 = int( link_timestamp_1 ) -\ |
| int( timestamp_link_down_t0 ) |
| link_down_lat_link2 = int( link_timestamp_2 ) -\ |
| int( timestamp_link_down_t0 ) |
| link_down_lat_link3 = int( link_timestamp_3 ) -\ |
| int( timestamp_link_down_t0 ) |
| else: |
| main.log.error( "There was an error calculating" + |
| " the delta for link down event" ) |
| link_down_lat_graph1 = 0 |
| link_down_lat_graph2 = 0 |
| link_down_lat_graph3 = 0 |
| |
| link_down_lat_device1 = 0 |
| link_down_lat_device2 = 0 |
| link_down_lat_device3 = 0 |
| |
| main.log.info( "Link down latency ONOS1 iteration " + |
| str( i ) + " (end-to-end): " + |
| str( link_down_lat_graph1 ) + " ms" ) |
| main.log.info( "Link down latency ONOS2 iteration " + |
| str( i ) + " (end-to-end): " + |
| str( link_down_lat_graph2 ) + " ms" ) |
| main.log.info( "Link down latency ONOS3 iteration " + |
| str( i ) + " (end-to-end): " + |
| str( link_down_lat_graph3 ) + " ms" ) |
| |
| main.log.info( "Link down latency ONOS1 iteration " + |
| str( i ) + " (link-event-to-system-timestamp): " + |
| str( link_down_lat_link1 ) + " ms" ) |
| main.log.info( "Link down latency ONOS2 iteration " + |
| str( i ) + " (link-event-to-system-timestamp): " + |
| str( link_down_lat_link2 ) + " ms" ) |
| main.log.info( "Link down latency ONOS3 iteration " + |
| str( i ) + " (link-event-to-system-timestamp): " + |
| str( link_down_lat_link3 ) ) |
| |
| # Calculate avg of node calculations |
| link_down_lat_graph_avg =\ |
| ( link_down_lat_graph1 + |
| link_down_lat_graph2 + |
| link_down_lat_graph3 ) / 3 |
| link_down_lat_link_avg =\ |
| ( link_down_lat_link1 + |
| link_down_lat_link2 + |
| link_down_lat_link3 ) / 3 |
| |
| # Set threshold and append latency to list |
| if link_down_lat_graph_avg > down_threshold_min and\ |
| link_down_lat_graph_avg < down_threshold_max: |
| link_down_graph_to_system_list.append( |
| link_down_lat_graph_avg ) |
| else: |
| main.log.info( "Link down latency exceeded threshold" ) |
| main.log.info( "Results for iteration " + str( i ) + |
| "have been omitted" ) |
| if link_down_lat_link_avg > down_threshold_min and\ |
| link_down_lat_link_avg < down_threshold_max: |
| link_down_link_to_system_list.append( |
| link_down_lat_link_avg ) |
| else: |
| main.log.info( "Link down latency exceeded threshold" ) |
| main.log.info( "Results for iteration " + str( i ) + |
| "have been omitted" ) |
| |
| # NOTE: To remove loss rate and measure latency: |
| # 'sh tc qdisc del dev s1-eth1 root' |
| timestamp_link_up_t0 = time.time() * 1000 |
| main.Mininet1.handle.sendline( "sh tc qdisc del dev " + |
| "s1-eth1 root" ) |
| main.Mininet1.handle.expect( "mininet>" ) |
| |
| main.log.info( "Checking ONOS for link update" ) |
| |
| link_down1 = True |
| link_down2 = True |
| link_down3 = True |
| loop_count = 0 |
| while( ( link_down1 and link_down2 and link_down3 ) |
| and loop_count < 30 ): |
| json_str1 = main.ONOS1cli.links() |
| json_str2 = main.ONOS2cli.links() |
| json_str3 = main.ONOS3cli.links() |
| if not ( json_str1 and json_str2 and json_str3 ): |
| main.log.error( "CLI command returned error " ) |
| break |
| else: |
| json_obj1 = json.loads( json_str1 ) |
| json_obj2 = json.loads( json_str2 ) |
| json_obj3 = json.loads( json_str3 ) |
| |
| for obj1 in json_obj1: |
| if '01' in obj1[ 'src' ][ 'device' ]: |
| link_down1 = False |
| main.log.info( "Link up from " + |
| "s1 -> s2 on ONOS1 detected" ) |
| for obj2 in json_obj2: |
| if '01' in obj2[ 'src' ][ 'device' ]: |
| link_down2 = False |
| main.log.info( "Link up from " + |
| "s1 -> s2 on ONOS2 detected" ) |
| for obj3 in json_obj3: |
| if '01' in obj3[ 'src' ][ 'device' ]: |
| link_down3 = False |
| main.log.info( "Link up from " + |
| "s1 -> s2 on ONOS3 detected" ) |
| |
| loop_count += 1 |
| time.sleep( 1 ) |
| |
| if ( link_down1 and link_down2 and link_down3 ): |
| main.log.info( "Link up discovery failed" ) |
| |
| link_up_lat_graph1 = 0 |
| link_up_lat_graph2 = 0 |
| link_up_lat_graph3 = 0 |
| link_up_lat_device1 = 0 |
| link_up_lat_device2 = 0 |
| link_up_lat_device3 = 0 |
| |
| assertion = main.FALSE |
| else: |
| json_topo_metrics_1 =\ |
| main.ONOS1cli.topology_events_metrics() |
| json_topo_metrics_2 =\ |
| main.ONOS2cli.topology_events_metrics() |
| json_topo_metrics_3 =\ |
| main.ONOS3cli.topology_events_metrics() |
| json_topo_metrics_1 = json.loads( json_topo_metrics_1 ) |
| json_topo_metrics_2 = json.loads( json_topo_metrics_2 ) |
| json_topo_metrics_3 = json.loads( json_topo_metrics_3 ) |
| |
| main.log.info( "Obtaining graph and device timestamp" ) |
| graph_timestamp_1 = \ |
| json_topo_metrics_1[ graphTimestamp ][ 'value' ] |
| graph_timestamp_2 = \ |
| json_topo_metrics_2[ graphTimestamp ][ 'value' ] |
| graph_timestamp_3 = \ |
| json_topo_metrics_3[ graphTimestamp ][ 'value' ] |
| |
| link_timestamp_1 = \ |
| json_topo_metrics_1[ linkTimestamp ][ 'value' ] |
| link_timestamp_2 = \ |
| json_topo_metrics_2[ linkTimestamp ][ 'value' ] |
| link_timestamp_3 = \ |
| json_topo_metrics_3[ linkTimestamp ][ 'value' ] |
| |
| if graph_timestamp_1 and graph_timestamp_2 and\ |
| graph_timestamp_3 and link_timestamp_1 and\ |
| link_timestamp_2 and link_timestamp_3: |
| link_up_lat_graph1 = int( graph_timestamp_1 ) -\ |
| int( timestamp_link_up_t0 ) |
| link_up_lat_graph2 = int( graph_timestamp_2 ) -\ |
| int( timestamp_link_up_t0 ) |
| link_up_lat_graph3 = int( graph_timestamp_3 ) -\ |
| int( timestamp_link_up_t0 ) |
| |
| link_up_lat_link1 = int( link_timestamp_1 ) -\ |
| int( timestamp_link_up_t0 ) |
| link_up_lat_link2 = int( link_timestamp_2 ) -\ |
| int( timestamp_link_up_t0 ) |
| link_up_lat_link3 = int( link_timestamp_3 ) -\ |
| int( timestamp_link_up_t0 ) |
| else: |
| main.log.error( "There was an error calculating" + |
| " the delta for link down event" ) |
| link_up_lat_graph1 = 0 |
| link_up_lat_graph2 = 0 |
| link_up_lat_graph3 = 0 |
| |
| link_up_lat_device1 = 0 |
| link_up_lat_device2 = 0 |
| link_up_lat_device3 = 0 |
| |
| if debug_mode == 'on': |
| main.log.info( "Link up latency ONOS1 iteration " + |
| str( i ) + " (end-to-end): " + |
| str( link_up_lat_graph1 ) + " ms" ) |
| main.log.info( "Link up latency ONOS2 iteration " + |
| str( i ) + " (end-to-end): " + |
| str( link_up_lat_graph2 ) + " ms" ) |
| main.log.info( "Link up latency ONOS3 iteration " + |
| str( i ) + " (end-to-end): " + |
| str( link_up_lat_graph3 ) + " ms" ) |
| |
| main.log.info( |
| "Link up latency ONOS1 iteration " + |
| str( i ) + |
| " (link-event-to-system-timestamp): " + |
| str( link_up_lat_link1 ) + |
| " ms" ) |
| main.log.info( |
| "Link up latency ONOS2 iteration " + |
| str( i ) + |
| " (link-event-to-system-timestamp): " + |
| str( link_up_lat_link2 ) + |
| " ms" ) |
| main.log.info( |
| "Link up latency ONOS3 iteration " + |
| str( i ) + |
| " (link-event-to-system-timestamp): " + |
| str( link_up_lat_link3 ) ) |
| |
| # Calculate avg of node calculations |
| link_up_lat_graph_avg =\ |
| ( link_up_lat_graph1 + |
| link_up_lat_graph2 + |
| link_up_lat_graph3 ) / 3 |
| link_up_lat_link_avg =\ |
| ( link_up_lat_link1 + |
| link_up_lat_link2 + |
| link_up_lat_link3 ) / 3 |
| |
| # Set threshold and append latency to list |
| if link_up_lat_graph_avg > up_threshold_min and\ |
| link_up_lat_graph_avg < up_threshold_max: |
| link_up_graph_to_system_list.append( |
| link_up_lat_graph_avg ) |
| else: |
| main.log.info( "Link up latency exceeded threshold" ) |
| main.log.info( "Results for iteration " + str( i ) + |
| "have been omitted" ) |
| if link_up_lat_link_avg > up_threshold_min and\ |
| link_up_lat_link_avg < up_threshold_max: |
| link_up_link_to_system_list.append( |
| link_up_lat_link_avg ) |
| else: |
| main.log.info( "Link up latency exceeded threshold" ) |
| main.log.info( "Results for iteration " + str( i ) + |
| "have been omitted" ) |
| |
| # Calculate min, max, avg of list and report |
| link_down_min = min( link_down_graph_to_system_list ) |
| link_down_max = max( link_down_graph_to_system_list ) |
| link_down_avg = sum( link_down_graph_to_system_list ) / \ |
| len( link_down_graph_to_system_list ) |
| link_up_min = min( link_up_graph_to_system_list ) |
| link_up_max = max( link_up_graph_to_system_list ) |
| link_up_avg = sum( link_up_graph_to_system_list ) / \ |
| len( link_up_graph_to_system_list ) |
| link_down_std_dev = \ |
| str( round( numpy.std( link_down_graph_to_system_list ), 1 ) ) |
| link_up_std_dev = \ |
| str( round( numpy.std( link_up_graph_to_system_list ), 1 ) ) |
| |
| main.log.report( "Link down latency " + |
| "Avg: " + str( link_down_avg ) + " ms " + |
| "Std Deviation: " + link_down_std_dev + " ms" ) |
| main.log.report( "Link up latency " + |
| "Avg: " + str( link_up_avg ) + " ms " + |
| "Std Deviation: " + link_up_std_dev + " ms" ) |
| |
| utilities.assert_equals( |
| expect=main.TRUE, |
| actual=assertion, |
| onpass="Link discovery latency calculation successful", |
| onfail="Link discovery latency case failed" ) |
| |
| def CASE5( self, main ): |
| """ |
| 100 Switch discovery latency |
| |
| Important: |
| This test case can be potentially dangerous if |
| your machine has previously set iptables rules. |
| One of the steps of the test case will flush |
| all existing iptables rules. |
| Note: |
| You can specify the number of switches in the |
| params file to adjust the switch discovery size |
| ( and specify the corresponding topology in Mininet1 |
| .topo file ) |
| """ |
| import time |
| import subprocess |
| import os |
| import requests |
| import json |
| |
| ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ] |
| ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ] |
| ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ] |
| MN1_ip = main.params[ 'MN' ][ 'ip1' ] |
| ONOS_user = main.params[ 'CTRL' ][ 'user' ] |
| |
| default_sw_port = main.params[ 'CTRL' ][ 'port1' ] |
| |
| # Number of iterations of case |
| num_iter = main.params[ 'TEST' ][ 'numIter' ] |
| num_sw = main.params[ 'TEST' ][ 'numSwitch' ] |
| |
| # Timestamp 'keys' for json metrics output. |
| # These are subject to change, hence moved into params |
| deviceTimestamp = main.params[ 'JSON' ][ 'deviceTimestamp' ] |
| graphTimestamp = main.params[ 'JSON' ][ 'graphTimestamp' ] |
| |
| debug_mode = main.params[ 'TEST' ][ 'debugMode' ] |
| |
| local_time = time.strftime( '%X' ) |
| local_time = local_time.replace( "/", "" ) |
| local_time = local_time.replace( " ", "_" ) |
| local_time = local_time.replace( ":", "" ) |
| if debug_mode == 'on': |
| main.ONOS1.tshark_pcap( "eth0", |
| "/tmp/100_sw_lat_pcap_" + local_time ) |
| |
| # Threshold for this test case |
| sw_disc_threshold_str = main.params[ 'TEST' ][ 'swDisc100Threshold' ] |
| sw_disc_threshold_obj = sw_disc_threshold_str.split( "," ) |
| sw_disc_threshold_min = int( sw_disc_threshold_obj[ 0 ] ) |
| sw_disc_threshold_max = int( sw_disc_threshold_obj[ 1 ] ) |
| |
| tshark_ofp_output = "/tmp/tshark_ofp_" + num_sw + "sw.txt" |
| tshark_tcp_output = "/tmp/tshark_tcp_" + num_sw + "sw.txt" |
| |
| tshark_ofp_result_list = [] |
| tshark_tcp_result_list = [] |
| |
| sw_discovery_lat_list = [] |
| |
| main.case( num_sw + " Switch discovery latency" ) |
| main.step( "Assigning all switches to ONOS1" ) |
| for i in range( 1, int( num_sw ) + 1 ): |
| main.Mininet1.assign_sw_controller( |
| sw=str( i ), |
| ip1=ONOS1_ip, |
| port1=default_sw_port ) |
| |
| # Ensure that nodes are configured with ptpd |
| # Just a warning message |
| main.log.info( "Please check ptpd configuration to ensure" + |
| " All nodes' system times are in sync" ) |
| time.sleep( 5 ) |
| |
| for i in range( 0, int( num_iter ) ): |
| |
| main.step( "Set iptables rule to block incoming sw connections" ) |
| # Set iptables rule to block incoming switch connections |
| # The rule description is as follows: |
| # Append to INPUT rule, |
| # behavior DROP that matches following: |
| # * packet type: tcp |
| # * source IP: MN1_ip |
| # * destination PORT: 6633 |
| main.ONOS1.handle.sendline( |
| "sudo iptables -A INPUT -p tcp -s " + MN1_ip + |
| " --dport " + default_sw_port + " -j DROP" ) |
| main.ONOS1.handle.expect( "\$" ) |
| # Append to OUTPUT rule, |
| # behavior DROP that matches following: |
| # * packet type: tcp |
| # * source IP: MN1_ip |
| # * destination PORT: 6633 |
| main.ONOS1.handle.sendline( |
| "sudo iptables -A OUTPUT -p tcp -s " + MN1_ip + |
| " --dport " + default_sw_port + " -j DROP" ) |
| main.ONOS1.handle.expect( "\$" ) |
| # Give time to allow rule to take effect |
| # NOTE: Sleep period may need to be configured |
| # based on the number of switches in the topology |
| main.log.info( "Please wait for switch connection to " + |
| "time out" ) |
| time.sleep( 60 ) |
| |
| # Gather vendor OFP with tshark |
| main.ONOS1.tshark_grep( "OFP 86 Vendor", |
| tshark_ofp_output ) |
| main.ONOS1.tshark_grep( "TCP 74 ", |
| tshark_tcp_output ) |
| |
| # NOTE: Remove all iptables rule quickly ( flush ) |
| # Before removal, obtain TestON timestamp at which |
| # removal took place |
| # ( ensuring nodes are configured via ptp ) |
| # sudo iptables -F |
| |
| t0_system = time.time() * 1000 |
| main.ONOS1.handle.sendline( |
| "sudo iptables -F" ) |
| |
| # Counter to track loop count |
| counter_loop = 0 |
| counter_avail1 = 0 |
| counter_avail2 = 0 |
| counter_avail3 = 0 |
| onos1_dev = False |
| onos2_dev = False |
| onos3_dev = False |
| while counter_loop < 60: |
| # Continue to check devices for all device |
| # availability. When all devices in all 3 |
| # ONOS instances indicate that devices are available |
| # obtain graph event timestamp for t1. |
| device_str_obj1 = main.ONOS1cli.devices() |
| device_str_obj2 = main.ONOS2cli.devices() |
| device_str_obj3 = main.ONOS3cli.devices() |
| |
| device_json1 = json.loads( device_str_obj1 ) |
| device_json2 = json.loads( device_str_obj2 ) |
| device_json3 = json.loads( device_str_obj3 ) |
| |
| for device1 in device_json1: |
| if device1[ 'available' ]: |
| counter_avail1 += 1 |
| if counter_avail1 == int( num_sw ): |
| onos1_dev = True |
| main.log.info( "All devices have been " + |
| "discovered on ONOS1" ) |
| else: |
| counter_avail1 = 0 |
| for device2 in device_json2: |
| if device2[ 'available' ]: |
| counter_avail2 += 1 |
| if counter_avail2 == int( num_sw ): |
| onos2_dev = True |
| main.log.info( "All devices have been " + |
| "discovered on ONOS2" ) |
| else: |
| counter_avail2 = 0 |
| for device3 in device_json3: |
| if device3[ 'available' ]: |
| counter_avail3 += 1 |
| if counter_avail3 == int( num_sw ): |
| onos3_dev = True |
| main.log.info( "All devices have been " + |
| "discovered on ONOS3" ) |
| else: |
| counter_avail3 = 0 |
| |
| if onos1_dev and onos2_dev and onos3_dev: |
| main.log.info( "All devices have been discovered " + |
| "on all ONOS instances" ) |
| json_str_topology_metrics_1 =\ |
| main.ONOS1cli.topology_events_metrics() |
| json_str_topology_metrics_2 =\ |
| main.ONOS2cli.topology_events_metrics() |
| json_str_topology_metrics_3 =\ |
| main.ONOS3cli.topology_events_metrics() |
| |
| # Exit while loop if all devices discovered |
| break |
| |
| counter_loop += 1 |
| # Give some time in between CLI calls |
| #( will not affect measurement ) |
| time.sleep( 3 ) |
| |
| main.ONOS1.tshark_stop() |
| |
| os.system( "scp " + ONOS_user + "@" + ONOS1_ip + ":" + |
| tshark_ofp_output + " /tmp/" ) |
| os.system( "scp " + ONOS_user + "@" + ONOS1_ip + ":" + |
| tshark_tcp_output + " /tmp/" ) |
| |
| # TODO: Automate OFP output analysis |
| # Debug mode - print out packets captured at runtime |
| if debug_mode == 'on': |
| ofp_file = open( tshark_ofp_output, 'r' ) |
| main.log.info( "Tshark OFP Vendor output: " ) |
| for line in ofp_file: |
| tshark_ofp_result_list.append( line ) |
| main.log.info( line ) |
| ofp_file.close() |
| |
| tcp_file = open( tshark_tcp_output, 'r' ) |
| main.log.info( "Tshark TCP 74 output: " ) |
| for line in tcp_file: |
| tshark_tcp_result_list.append( line ) |
| main.log.info( line ) |
| tcp_file.close() |
| |
| json_obj_1 = json.loads( json_str_topology_metrics_1 ) |
| json_obj_2 = json.loads( json_str_topology_metrics_2 ) |
| json_obj_3 = json.loads( json_str_topology_metrics_3 ) |
| |
| graph_timestamp_1 = \ |
| json_obj_1[ graphTimestamp ][ 'value' ] |
| graph_timestamp_2 = \ |
| json_obj_2[ graphTimestamp ][ 'value' ] |
| graph_timestamp_3 = \ |
| json_obj_3[ graphTimestamp ][ 'value' ] |
| |
| graph_lat_1 = int( graph_timestamp_1 ) - int( t0_system ) |
| graph_lat_2 = int( graph_timestamp_2 ) - int( t0_system ) |
| graph_lat_3 = int( graph_timestamp_3 ) - int( t0_system ) |
| |
| avg_graph_lat = \ |
| ( int( graph_lat_1 ) + |
| int( graph_lat_2 ) + |
| int( graph_lat_3 ) ) / 3 |
| |
| if avg_graph_lat > sw_disc_threshold_min \ |
| and avg_graph_lat < sw_disc_threshold_max: |
| sw_discovery_lat_list.append( |
| avg_graph_lat ) |
| else: |
| main.log.info( "100 Switch discovery latency " + |
| "exceeded the threshold." ) |
| |
| # END ITERATION FOR LOOP |
| |
| sw_lat_min = min( sw_discovery_lat_list ) |
| sw_lat_max = max( sw_discovery_lat_list ) |
| sw_lat_avg = sum( sw_discovery_lat_list ) /\ |
| len( sw_discovery_lat_list ) |
| |
| main.log.report( "100 Switch discovery lat " + |
| "Min: " + str( sw_lat_min ) + " ms" + |
| "Max: " + str( sw_lat_max ) + " ms" + |
| "Avg: " + str( sw_lat_avg ) + " ms" ) |