def RpfoAndVerify(device1, device2): active_rp0 = GetActiveRp(device1) active_rp0 = active_rp0 + "/CPU0" #pdb.set_trace() result = device1.rp_xr_exec("redundancy switchover location %s" % active_rp0, answer="y") if re.search("Initiating switch-over.*%s" % active_rp0.upper(), result, re.DOTALL): log.info("Redundancy Switchover Passed from Active RP %s" % active_rp0) else: raise Exception("Redundancy Switchover Failed from Active RP %s" % active_rp0) device1.disconnect() sleep(150) log.info('Disconnected console1\n Connecting Console2....... ') tcl.eval('csccon_add_state_pattern enable {RP/0/RP0/CPU0:ios#}') device2.connect() device2.rp_xr_exec('terminal length 0') device2.rp_xr_exec('terminal width 512') active_rp1 = GetActiveRp(device2) if active_rp1 == active_rp0: log.info( "Active RP switch over did not happen. Active RP is still %s" % active_rp1) return False else: log.info("Active RP switch over successful . %s => %s" % (active_rp0, active_rp1)) return True
def connect_to_Fretta(self): """ common setup subsection: connecting devices """ global g_topo_data log.info(banner("Common Setup: Connection to devices")) #self.script_args['testStep'] = 1 get_test_topo(self.script_args) rtr1_name = g_topo_data['R1'] rtr1 = routers[rtr1_name] rtr2_name = g_topo_data['R2'] rtr2 = routers[rtr2_name] # Step 1 self.script_args['testStep'] = 1 log.info( banner("STEP %s: Device Connection" % (self.script_args['testStep']))) # Create instance of device R1 device_uut = self.script_args['R1'] self.script_args['uut'] = self.script_args['testbed'].devices[ device_uut] tcl.eval('set csccon_default(clear_config_inconsistancy) 0') self.script_args['uut'].connect() log.info("STEP %s: Device Connection Passed" % (self.script_args['testStep'])) rtr1.execute("terminal length 500") rtr1.execute("terminal width 500") response[ "Clear logging buffer \[confirm\] \[y\/n\] \:"] = "econ_sendline y;exp_continue" rtr1.execute("clear logging", reply=response) rtr1.execute("clear context", reply=response) #pdb.set_trace() #rtr1.admin("show platform") self.script_args['testStep'] = 2 log.info( banner("STEP %s: Device Connection" % (self.script_args['testStep']))) device_uut_r2 = self.script_args['R2'] self.script_args['uut_r2'] = self.script_args['testbed'].devices[ device_uut_r2] tcl.eval('set csccon_default(clear_config_inconsistancy) 0') self.script_args['uut_r2'].connect() log.info("STEP %s: Device Connection Passed" % (self.script_args['testStep'])) rtr2.execute("terminal length 500") rtr2.execute("terminal width 500") response[ "Clear logging buffer \[confirm\] \[y\/n\] \:"] = "econ_sendline y;exp_continue" rtr2.execute("clear logging", reply=response) rtr2.execute("clear context", reply=response)
def check_console_msg(device, chk_msg, sleepTime=2, retryCount=20): log.info("Initiating process to check console message- %s" % (chk_msg)) # ret_status = 1 for i in range(0, int(retryCount)): i += 1 get_console_op = None tcl.eval('receive %s "%s"' % (device.handle, chk_msg)) # get_console_op = tcl.eval('set receive_buffer') get_console_op = " ".join(get_console_op.split()) log.info("get_console_op") log.info(get_console_op) # get_cmd_op = get_line_from_output(chk_msg, get_console_op) # print("+" * 10) log.info("chk_msg") log.info(chk_msg) # print("+" * 10) log.info("get_cmd_op") log.info(get_cmd_op) print("+" * 10) # if get_cmd_op != None: log.info("Succesfully verfied message- %s from console o/p" % (chk_msg)) log.info(get_cmd_op) ret_status = 0 break else: log.info( "Attempt %d: Unable to find message- %s from console o/p " % (i, chk_msg)) time.sleep(sleepTime) if i == int(retryCount): log.error("Failed: unable to find message- %s from console o/p " % (chk_msg)) ret_status = 1 # if ret_status == 0: return get_cmd_op else: return False
def get_current_packet_rate(self, first_sample=False): # Get the current packet rate # expect1.1> TGNGetCurrentPacketRate -array test_params result = tcl.eval('TGNGetCurrentPacketRate -array test_params') # Process result if result == '1': log.info( "Successfully got current packet rate on device '{}'".format( self.device.name)) # If this was the first sample of rates, save the timestamp if first_sample: fs_timestamp = tcl.eval('clock seconds') tcl.q.set('test_params(TGN,FirstRateSampleTimeStamp)', fs_timestamp) else: raise GenieTgnError( "Unable to get current packet rate on device '{}'".format( self.device.name))
def stop_traffic(self): # Stop traffic # expect1.1> TGNTraffic -stop result = tcl.eval('TGNTraffic -stop') # Process result if result == '1': log.info("Successfully stopped traffic on device '{}'".format( self.device.name)) else: raise GenieTgnError("Unable to stop traffic on device '{}'".format( self.device.name))
def start_traffic(self): # Start traffic # expect1.1> TGNTraffic result = tcl.eval('TGNTraffic') # Process result if result == '1': log.info("Successfully started traffic on device '{}'".format( self.device.name)) else: raise GenieTgnError( "Failed to start traffic on device '{}'".format( self.device.name))
def start_routing(self): # Start routing # expect1.1> TGNRouting result = tcl.eval('TGNRouting') # Process result if result == '1': log.info("Successfully started routing on device '{}'".format( self.device.name)) else: raise GenieTgnError( "Failed to start routing on device '{}'".format( self.device.name))
def check_traffic_loss(self): # Connect to TGN & load configuration # expect1.1> TGNCheckTrafficLossPercent result = tcl.eval('TGNCheckTrafficLossPercent') # Process result if result == '1': log.info("Successfully checked traffic loss on device '{}'".format( self.device.name)) else: raise GenieTgnError( "Unable to check traffic loss on device '{}'".format( self.device.name))
def clear_stats(self): # Clear TGN statistics # expect1.1> TGNClearAllStats result = tcl.eval('TGNClearAllStats') # Process result if result == '1': log.info("Successfully cleared statistics on device '{}'".format( self.device.name)) else: raise GenieTgnError( "Unable to clear statistics device on '{}'".format( self.device.name))
def calculate_absolute_outage(self, max_outage_ms=5): # Convert from seconds to milliseconds for PSAT TGN max_outage_ms = (max_outage_ms * 1000) # Calculate traffic outage # expect1.1> TGNCalculateAbsoluteOutage -maxOutageMs $maxOutageInMs result = tcl.eval('TGNCalculateAbsoluteOutage -maxOutageMs {}'.\ format(max_outage_ms)) # Process result if result is not '1': raise GenieTgnError("Traffic failure observed on device '{}'".\ format(self.device.name))
def send_arp_on_interface(self): # Send ARP on interface # expect1.1> TGNSendArpOnInterface result = tcl.eval('::psat-ng::TGNSendArpOnInterface') # Process result if result == '1': log.info( "Successfully sent ARP on interface on TGN device '{}'".format( self.device.name)) else: raise GenieTgnError( "Unable to send ARP on interface on TGN device '{}'".format( self.device.name))
def learn_traffic_streams(self): # Learn traffic # expect1.1> LearnTGN result = tcl.eval('LearnTGN') # Process result if result == '1': log.info( "Successfully learned traffic streams on device '{}'".format( self.device.name)) else: raise GenieTgnError( "Unable to learn traffic streams on device '{}'".format( self.device.name))
def get_reference_packet_rate(self): # Get the referecne packet rate # expect1.1> TGNGetReferencePacketRate -maxMinutes $test_params(TGNWaitForRefRateMinutes) result = tcl.eval( 'TGNGetReferencePacketRate -maxMinutes $test_params(TGNWaitForRefRateMinutes)' ) # Process result if result == '1': log.info( "Successfully got reference packet rate on device '{}'".format( self.device.name)) else: raise GenieTgnError( "Unable to get reference packet rate on device '{}'".format( self.device.name))
def poll_traffic_until_traffic_resumes(self, timeout=60, delay_check_traffic=10): # 'timeout' value in seconds [default 60 seconds] # 'delay' value in seconds [default 10 seconds] # Convert from seconds to milliseconds for PSAT TGN delay_check_traffic = delay_check_traffic * 1000 # expect1.1> TGNPollUntilTrafficResumes -timeout $maxOutageTime -delayCheckTraffic $delayCheckTraffic result = tcl.eval('TGNPollUntilTrafficResumes -timeout {timeout}' ' -delayCheckTraffic {delay}'.\ format(timeout=timeout, delay=delay_check_traffic)) # Process result if result is not '1': raise GenieTgnError("Traffic failure observed on device '{}'".\ format(self.device.name))
def connect(self): '''Connect to TGN device''' # Already connected do nothing if self.connected: return # Connect to TGN & load configuration # expect1.1> LoadTGN result = tcl.eval('LoadTGN') # Check connected & config loaded if result == '1': self._is_connected = True log.info("Connected successfully to device '{}'".format( self.device.name)) else: self._is_connected = False raise GenieTgnError("Unable to connect to device '{}'".format( self.device.name))
def initialize_tgn_ArpNdPim(self): # Send arp on interface # expect1.1> TGNSendArpOnInterface self.send_arp_on_interface() # Sleep for wait_time seconds log.info('Sleeping for {} seconds after sending ARP on interfaces'.\ format(self.tgn_arp_wait_time)) time.sleep(self.tgn_arp_wait_time) # Initialize TGN # expect1.1> initializeTGN result = tcl.eval('initializeTGN') # Process result if result == '1': log.info("Successfully initialized TGN device '{}'".format( self.device.name)) else: raise GenieTgnError("Unable to initialize TGN device '{}'".format( self.device.name))
from xCommon_lib import * #from Fretta_pmfc_Scripts.Coh_Libs.Pkt_Libs import * #from Fretta_pmfc_Scripts.Coh_Libs.DWDM_Libs import * #from Fretta_pmfc_Scripts.Coh_Libs.MacSec_Libs import * #from Fretta_pmfc_Scripts.Coh_Libs.utils import * from Fretta_pmfc_Scripts.rsp4_dpfga.rsp4_lib import * from Fretta_pmfc_Scripts.rsp4_dpfga.utils import * from fwd_scripts.fwd_config import * from XVerification import * #from autoparser import pyparse from xNetworkEvents import * global event event = Events() tcl.eval('package require Mpexpr') class ConfigError(Exception): """raised if any config failed""" log = logging.getLogger(__name__) log.setLevel(logging.DEBUG) #the default severity is debug log = XLog(level=logging.DEBUG) def get_test_topo(test_topo): global g_topo_data global response
def __init__(self, *args, **kwargs): '''__init__ instantiates a single connection instance.''' # instantiate BaseConnection super().__init__(*args, **kwargs) # Default self._is_connected = False # Check for env(ENA_TESTS) if 'ENA_TESTS' in os.environ and os.path.isdir( os.environ['ENA_TESTS']): psat_tgn = os.path.join(os.environ['ENA_TESTS'], 'psat/psat_tgn.tcl') psat_lib = os.path.join(os.environ['ENA_TESTS'], 'psat/psat_lib.tcl') else: raise Exception( "env(ENA_TESTS) not set or its path does not exist") # Check for required env vars required_env_vars = [ 'AUTOTEST', 'ATS_EASY', 'IXIA_HOME', 'IXIA_VERSION', 'IXIA_HLTAPI_LIBRARY', 'XBU_SHARED', 'TCLLIBPATH', 'TCL_PKG_PREFER_LATEST' ] for env_var in required_env_vars: if env_var not in os.environ: raise Exception("env({}) has not been set".format(env_var)) # Required TCL Packages tcl.q.package('require', 'cAAs') tcl.q.package('require', 'psat-ng') tcl.q.package('require', 'enaTgnUtils') tcl.eval('namespace import -force ::enaTgnUtils::*') # Source PSAT lib files try: tcl.q.source(psat_tgn) tcl.q.source(psat_lib) except: raise Exception("Unable to source PSAT files required for TGN") # Get arguments from TGN testbed YAML file try: address = self.connection_info['address'] controller = self.connection_info['controller'] handle = self.connection_info['handle'] tgn_type = self.connection_info['tgn_type'] except KeyError as e: raise Exception('Argument not provided in TGN YAML file') from e # TGN configuration file if self.device.tgn_skip_configuration: self.config = "" session_up = True else: try: self.config = kwargs['config'] session_up = False except: raise Exception( "Configuration file not provided for '{d}'".format( d=self.device.name)) # TGN port list if not self.device.tgn_port_list: try: port_list = self.connection_info['port_list'] except KeyError as e: raise Exception( "Aborting: Mandatory argument `port_list` not " "found in TGN YAML file or from Genie job file " "arguments.") from e else: port_list = str(self.device.tgn_port_list) # Genie TGN arguments # -------------------- tgn_enable = int(self.device.tgn_enable) # useTGN tgntcl_enable_arp = int(self.device.tgntcl_enable_arp) # TGNEnableARP tgn_traffic_convergence_threshold = self.device.tgn_traffic_convergence_threshold # TGNWaitConvergence tgn_reference_rate_threshold = self.device.tgn_reference_rate_threshold # TGNMinWaitForReferenceRate tgn_first_sample_threshold = self.device.tgn_first_sample_threshold * 1000 # TGNWaitBeforeFirstSample tgntcl_learn_after_n_samples = self.device.tgntcl_learn_after_n_samples # TGNLearnExcessAfterNSamples tgn_disable_traffic_post_execution = int( self.device.tgn_disable_traffic_post_execution) # TGNStopTraffic tgn_traffic_loss_recovery_threshold = self.device.tgn_traffic_loss_recovery_threshold * 1000 # TGNWaitTimeNoTrafficMs tgn_traffic_loss_tolerance_percentage = self.device.tgn_traffic_loss_tolerance_percentage # trafficLossPercentageTolerance tgn_enable_traffic_loss_check = int( self.device.tgn_enable_traffic_loss_check) # checkTrafficLoss tgntcl_stream_sample_rate_percentage = self.device.tgntcl_stream_sample_rate_percentage # TGNThreshold tgntcl_wait_multiplier = self.device.tgntcl_wait_multiplier # TGNWaitMultiplier tgn_config_post_device_config = int( self.device.tgn_config_post_device_config ) # loadTGNAfterRouterConfig tgn_profile_snapshot_threshold = int( self.device.tgn_profile_snapshot_threshold ) # TGNWaitForRefRateMinutes tgn_routing_threshold = self.device.tgn_routing_threshold # waitAfterTGNRouting self.tgn_arp_wait_time = int(self.device.tgn_arp_wait_time) # Set user configured values # -------------------------- tcl.q.set('test_params(useTGN)', tgn_enable) tcl.q.set('test_params(TGNEnableARP)', tgntcl_enable_arp) tcl.q.set('test_params(loadTGNAfterRouterConfig)', tgn_config_post_device_config) tcl.q.set('test_params(waitAfterTGNRouting)', tgn_routing_threshold) tcl.q.set('test_params(TGNWaitConvergence)', tgn_traffic_convergence_threshold) tcl.q.set('test_params(TGNWaitTimeNoTrafficMs)', tgn_traffic_loss_recovery_threshold) tcl.q.set('test_params(TGNWaitForRefRateMinutes)', tgn_profile_snapshot_threshold) tcl.q.set('test_params(TGNWaitBeforeFirstSample)', tgn_first_sample_threshold) tcl.q.set('test_params(TGNMinWaitForReferenceRate)', tgn_reference_rate_threshold) tcl.q.set('test_params(TGNThreshold)', tgntcl_stream_sample_rate_percentage) tcl.q.set('test_params(checkTrafficLoss)', tgn_enable_traffic_loss_check) tcl.q.set('test_params(trafficLossPercentageTolerance)', tgn_traffic_loss_tolerance_percentage) tcl.q.set('test_params(TGNStopTraffic)', tgn_disable_traffic_post_execution) tcl.q.set('test_params(TGNLearnExcessAfterNSamples)', tgntcl_learn_after_n_samples) tcl.q.set('test_params(TGNWaitMultiplier)', tgntcl_wait_multiplier) # Set default values # ------------------ tcl.q.set('test_params(TGNWaitInterval)', 1) tcl.q.set('test_params(TGNReportWorstStreams)', 0) tcl.q.set('test_params(TGNFeaturePatternMatch)', '{}') tcl.q.set('test_params(TGNretries)', 10) tcl.q.set('test_params(TGNarpTimeout)', 0) tcl.q.set('test_params(TGNarpInterval)', 0) tcl.q.set('test_params(TGNfIndex)', 0) tcl.q.set('test_params(TGNiIndex)', 1) tcl.q.set('test_params(TGNeIndex)', 2) tcl.q.set('test_params(TGNtIndex)', 3) tcl.q.set('test_params(TGNStatisticsSet)', '') tcl.q.set('test_params(TGNPortStatisticsSet)', '') # Build TGN_KEY structure for TCL procs # ------------------------------------- tcl.q.keylset('test_params(TGN_KEY)', 'Session1.Address', address) tcl.q.keylset('test_params(TGN_KEY)', 'Session1.Controller', controller) tcl.q.keylset('test_params(TGN_KEY)', 'Session1.Handle', handle) tcl.q.keylset('test_params(TGN_KEY)', 'Session1.portList', port_list) tcl.q.keylset('test_params(TGN_KEY)', 'Session1.Type', tgn_type) tcl.q.keylset('test_params(TGN_KEY)', 'Session1.SessionFile', self.config) tcl.q.keylset('test_params(TGN_KEY)', 'Session1.SessionAlreadyUp', session_up) tcl.q.keylset('test_params(TGN_KEY)', 'Session1.SessionLabel', tgn_type)