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)