def _parse_dmesg(self):
funcname = GetFunctionName(self._parse_dmesg)
GlobalLogger.logger.debug(funcname)
try:
match_kw = {}
caller_full_folder_path = inspect.stack()[1][1]
path = "{}{}Tests{}{}".format(
os.path.dirname(
os.path.dirname(
os.path.dirname(
os.path.dirname(caller_full_folder_path)))),
os.sep, os.sep, "dmesg_kw.json")
with open(path) as json_file:
match_kw = json.load(json_file)
# for item in match_kw:
# match_kw[item]["regex"] = str(match_kw[item]["regex"]).replace("\\\\", "\\")
log_lines = ""
buff = GlobalGetterSetter()._getter._("cat /var/log/messages")
if buff:
log_lines = buff.split("\n")
self._process_log_line(log_lines, match_kw)
self._report_log_lines(match_kw)
return True
except Exception as e:
print(e)
GlobalLogger.logger.debug(
"Error - _parse_dmesg had exception:\n{}".format(str(e)))
def __init__(self, switchDevInterface, otherDutChannel, executer=True):
"""
:param switchDevInterface: the interface entity
:type switchDevInterface: SwitchDevDutInterface
:param otherDutChannel: True if other DUT channel exist; False otherwise
"""
self._switchdevInterface = switchDevInterface
self._operstate = ""
self._master = ""
self._ipDetails = {}
glblGetterSetter = GlobalGetterSetter()
if not otherDutChannel:
self._getter, self._setter = (glblGetterSetter.getter,
glblGetterSetter.setter)
else:
self._getter, self._setter = (glblGetterSetter.getterOtherDut,
glblGetterSetter.setterOtherDut)
if executer:
if not otherDutChannel:
glblGetterSetter.setter = self._setter = self._getter
else:
glblGetterSetter.setterOtherDut = self._setter = self._getter
elif isinstance(self._setter, Getter):
self._setter = GlobalGetterSetter().setter = Setter()
def pollTillLinkUp(self, port, timeout=60):
cmd = f"bash -c 'for i in {{1..{timeout}}}; do x=$(ip -o link show {port} | grep -Eo \"state\s\w+\" | tr -d \"state \");" \
f" if [ $x == \"UP\" ]; then break; elif [ $i -eq {timeout} ]; then exit 1; fi; sleep 1; done'"
GlobalGetterSetter().getter.execute(cmd, timeout=timeout * 5)
retCode = GlobalGetterSetter().getter.execute("echo $?")
if retCode != '0':
self.FailTheTest(
f"FAIL: took more than {timeout} for port {port} to be up")
def getLagInfo(cls, otherDut=False):
import json5
if otherDut:
executer = GlobalGetterSetter().getterOtherDut
else:
executer = GlobalGetterSetter().getter
bondDetails = json5.loads(executer.execute('ip -d -j link show'))
for interfaceDits in filter(lambda x: x.get('linkinfo', {}).get('info_slave_kind') == 'bond' or
x.get('linkinfo', {}).get('info_kind') == 'bond', bondDetails):
infoDataKey = 'info_slave_data' if 'info_slave_data' in interfaceDits['linkinfo'] else 'info_data'
cls._bondDetails[interfaceDits['ifname']] = interfaceDits['linkinfo'][infoDataKey]
return cls._bondDetails
def SpecificTestInit(self):
super(BaseTest_SD, self).SpecificTestInit()
if not self.isLoad:
self._AddCleanupRecoveryCrashHandler(self.DutManager.reboot,
software_reset=False)
if self.OtherDutManager:
self._AddCleanupRecoveryCrashHandler(
self.OtherDutManager.reboot, software_reset=False)
self.DutManager.login()
if self.DutManager.host_kernel_version():
self.TestData.DutInfo.Host_kernel_version = self.DutManager.host_kernel_version(
)
if self.DutManager.uboot_version():
self.TestData.DutInfo.UBOOT_Version = self.DutManager.uboot_version(
)
if self.DutManager.software_version():
self.TestData.DutInfo.Software_Version = self.DutManager.software_version(
)
if 'dutsecondaychannel' in self.TestData.Resources.Channels:
self.DutSecondayManager.login(isload=self.isLoad)
GlobalGetterSetter().secondaryDutChannel = self.DutSecondayChannel
self.DutManager.uboot_manager._uboot_channel_host = self.DutSecondayChannel
if 'otherchannel' in self.TestData.Resources.Channels:
self.OtherDutManager.login(isload=self.isLoad)
GlobalGetterSetter().otherDutChannel = self.OtherDutChannel
self.DutManager.uboot_manager._uboot_channel_fw = self.OtherDutChannel
if self.resource:
import os
dir_path = os.path.dirname(os.path.realpath(__file__))
root_folder = os.path.abspath(
os.path.join(os.path.join(dir_path, os.pardir), os.pardir))
json_dir = os.path.join(root_folder, "Tests", "Implementations",
*self.resource.split("/")[:-1])
json_path = os.path.join(
json_dir, "{}.json".format(self.resource.split("/")[-1]))
jsonVersion = json_path if os.path.isfile(
json_path) else json_path + '5'
if os.path.isfile(jsonVersion):
with open(jsonVersion) as json_file:
self.TestCaseData = json5.load(json_file)
GlobalGetterSetter().channel = self.DutMainChannel
self._clear_dmesg()
self._clear_cmd_history()
self.handle_stress_mode()
def getEthtoolConf(cls, ports):
"""
Parses ethtool <DEVNAME> command of ports list passed as argument and puts its output in a dictionary
:param ports: list of L1PortConfig objects
:type ports: L1PortConfig
:return: the result of the output and the
"""
portsIndices = [
port.switchdevInterface.name.replace('sw1p', '') for port in ports
]
cmd = f"for i in {' '.join(portsIndices)}; do ethtool sw1p$i; done"
res, err = GlobalGetterSetter().getter.getCmdOutputAsFile(cmd)
for st in filter(None, res.split('Settings for ')):
cls.__l1PortConfigObjects[re.match(
'sw1p[0-9]+', st).group(0)].getPortEthtoolConf(st)
return res, err
def transmitTraffic(self,
tgManager,
txPorts,
rxPorts=None,
continues=False):
"""
:param tgManager: BastTest.TGManger dict
:param txPorts: BastTest.TGDutLinks dict
:param rxPorts: the receiving ports
:param continues: True if traffic is continues; False otherwise
:return:
"""
# transmit traffic for learning
tgManager.chassis.start_traffic([port.TGPort for port in rxPorts],
blocking=not continues,
wait_up=True,
start_packet_groups=False)
# turn off flooding in case bridging is not working properly
for port in [x.DutDevPort.name for x in txPorts]:
self._bridge.setFlood(port, 'off')
err = GlobalGetterSetter().setter.execute()
if err:
self.FailTheTest(err)
super(GenericVlanUnicastAPI,
self).transmitTraffic(tgManager, txPorts, rxPorts, continues)
def deleteTCFilterSharedBlock(cls, block, pref, handle=None):
"""
delete the ACE from the shared block using the pref number
:param pref: the preference number of the ACE
:return: the error message from the board if received; None otherwise
"""
return GlobalGetterSetter().setter.tc_filter_delete(block=block, pref=pref, handle=handle)
def overflowTable(self,
devOrBlock,
selector='src_ip',
action='pass',
startAddress='',
incStep=1):
listOfRules = []
if isinstance(devOrBlock, int):
devOrBlockSelector = f"block {devOrBlock}"
else:
devOrBlockSelector = f"dev {devOrBlock.DutDevPort.name} ingress"
if selector in ('src_ip', 'dst_ip'): # ipv4 overflowing
import ipaddress
ipAddr = ipaddress.ip_address(startAddress)
for i in range(incStep):
listOfRules.append(
f"tc filter add {devOrBlockSelector} protocol ip flower skip_sw {selector} {ipAddr + i} action {action}"
)
strOfAllRules = '\n'.join(listOfRules)
self.logger.debug(strOfAllRules)
from CLI_GlobalFunctions.SwitchDev.CLICommands.Executer import GlobalGetterSetter
err = GlobalGetterSetter().getter.execAsFile(strOfAllRules)
if err:
self.FailTheTest(err)
def setIpv4Forwarding(cls, v):
ret = GlobalGetterSetter().setter.sysctl('-w',
f'net.ipv4.ip_forward={v}')
# if GlobalGetterSetter().otherDutChannel:
# ret = GlobalGetterSetter().setterOtherDut.sysctl('-w', f'net.ipv4.ip_forward={v}')
if not ret:
cls._ipv4Forwarding = v
return ret
def getFwCpuUtilization(self):
funcname = GetFunctionName(self.getFwCpuUtilization)
GlobalLogger.logger.debug(funcname)
cpu_util = None
ret = GlobalGetterSetter()._getterSecondaryDut.top(" -n 1")
if ret:
cpu_util = float(self._get_from_regex(ret, "CPU:\s+(\d+)", 1))
return cpu_util
def setFwCpuUtilization(self, cpu_count=0):
try:
funcname = GetFunctionName(self.setFwCpuUtilization)
GlobalLogger.logger.debug(funcname)
if cpu_count == 0:
cpu_count = 2
for i in range(cpu_count):
buff = GlobalGetterSetter()._getterSecondaryDut._(
"sha1sum /dev/zero &")
if not buff:
if not GlobalGetterSetter(
).secondaryDutChannel._lastBufferTillPrompt:
raise Exception(
"{} Could not set CPU utilization".format(
funcname))
except Exception as e:
raise Exception("Can't setFwCpuUtilization:\n{}".format(e))
def _clear_cmd_history(self):
funcname = GetFunctionName(self._clear_cmd_history)
GlobalLogger.logger.debug(funcname)
try:
if "Load_ver" not in self.TestData.TestInfo.Suite_Name:
buff = GlobalGetterSetter()._getter._("history -c")
self.Add_Cleanup_Function_To_Stack(self._log_cmd_history)
except Exception as e:
print(e)
def delete(cls):
try:
obs.off('update')
except EventNotFound:
pass
finally:
return GlobalGetterSetter().getter.execute(
f"sed -i \"/^[#]*MANAGE_MSTPD=/ cMANAGE_MSTPD='n'\" /etc/bridge-stp.conf"
)
def unsetCpuUtilization(self):
try:
funcname = GetFunctionName(self.unsetCpuUtilization)
GlobalLogger.logger.debug(funcname)
buff = GlobalGetterSetter()._getter.killall("stress-ng")
if not buff:
raise Exception("{} Could not kill stress-ng".format(funcname))
except Exception as e:
raise Exception("Can't unsetCpuUtilization:\n{}".format(e))
def _clear_dmesg(self):
funcname = GetFunctionName(self._clear_dmesg)
GlobalLogger.logger.debug(funcname)
try:
if "Load_ver" not in self.TestData.TestInfo.Suite_Name:
buff = GlobalGetterSetter()._getter._(
"echo \"\" > /var/log/messages")
self.Add_Cleanup_Function_To_Stack(self._parse_dmesg)
except Exception as e:
print(e)
def _log_cmd_history(self):
funcname = GetFunctionName(self._parse_dmesg)
GlobalLogger.logger.debug(funcname)
try:
buff = GlobalGetterSetter()._getter._("history")
GlobalLogger.logger.debug("commands history:\n{}".format(buff))
return True
except Exception as e:
print(e)
return False
def fillStaticArpEntries(self, index1='', index2='', mac='', dev=''):
ret = GlobalGetterSetter().getter.execAsFile(
f"""for ((i=0; i<={index1}; i++));
do
for ((j=0; j<={index2}; j++));
do ip neigh add 192.0.$i.$j lladdr {mac} dev {dev}
done
done
""")
return ret
def fillStaticRouteEntries(self, index1='', index2='', dev=''):
ret = GlobalGetterSetter().getter.execAsFile(
f"""for ((i=0; i<={index1}; i++));
do
for ((j=0; j<={index2}; j++));
do ip route add 192.0.$i.$j dev {dev};
done
done
""")
return ret
def timeToState(self, bridge, checkStatePort, timeout, expectedState='forwarding', protocolVersion='00'):
if protocolVersion == '00':
getStateCommand = fr"ip -d -j -p link show {checkStatePort} | grep \"state\" | tr -d \"[[:space:],\,,\"]\" | cut -d ':' -f 2"
else:
getStateCommand = f"mstpctl showportdetail {bridge} {checkStatePort} state"
return GlobalGetterSetter().getter.execAsFile(timeToState.format(getStateCommand=getStateCommand,
bridge=bridge,
checkStatePort=checkStatePort,
expectedState=expectedState,
timeout=timeout),
getReturnCode=True)
def getEthtoolStats(cls, ports):
portsIndices = [
port.switchdevInterface.name.replace('sw1p', '') for port in ports
]
res, err = GlobalGetterSetter().getter.getCmdOutputAsFile(
f"for i in {' '.join(portsIndices)};"
"do echo -e \"sw1p$i\n $(ethtool -S sw1p$i)\" | awk '{++n} n!=2'; done"
)
for portName, stats in zip(
*[filter(None, re.split(r'(sw1p[0-9]+)', res))] * 2):
cls.__l1PortConfigObjects[portName].getEthtoolPortStats(stats)
return res, err
def setCpuUtilization(self, cpu_count=0, stress_timeout=10):
try:
funcname = GetFunctionName(self.getCpuUtilization)
GlobalLogger.logger.debug(funcname)
buff = GlobalGetterSetter()._getter._(
"stress-ng --cpu {} --timeout {} &".format(
cpu_count, stress_timeout))
if not buff:
raise Exception(
"{} Could not set CPU utilization on {} cpu count and timeout of {}"
.format(funcname, cpu_count, stress_timeout))
except Exception as e:
raise Exception("Can't setCpuUtilization:\n{}".format(e))
def getStpDetails(cls):
"""
Get the STP details using "ip -d -j link show" command
:return:
"""
import json5
stpDetails = json5.loads(GlobalGetterSetter().getter.execute('ip -d -j link show'))
for interfaceDits in filter(lambda x: x.get('linkinfo', {}).get('info_slave_kind') == 'bridge' or
x.get('linkinfo', {}).get('info_kind') == 'bridge', stpDetails):
infoDataKey = 'info_slave_data' if 'info_slave_data' in interfaceDits['linkinfo'] else 'info_data'
cls._ipDetailedShow[interfaceDits['ifname']] = interfaceDits['linkinfo'][infoDataKey]
obs.trigger("update")
return cls._ipDetailedShow
def getPortNumOfEntries(cls, dev, *args, timeout=10):
"""
returns the number of MAC entries of a port/interface
:param dev: the port/interface to get it's num of entries
:type dev: SwitchDevDutInterface
:param args: more filters on the MAC entries
:type args: list[str]
:return: the number of MAC entries of a port/interface
"""
return GlobalGetterSetter().getter.bridge_fdb_show(
'brport',
dev.name,
*list('| grep %s' % x for x in args),
'| wc -l',
timeout=timeout)
def verifyNoError(self, output, otherDut=False):
if output:
if otherDut:
executer = GlobalGetterSetter().getterOtherDut
else:
executer = GlobalGetterSetter().getter
retCode = executer.execute("echo $?")
if retCode != '0':
lastCommandAndErr = executer.execute("!-2")
self.FailTheTest(f"FAIL: {lastCommandAndErr}")
def initTestParams(self, testParams=None):
"""
Initiate all test params
:param testParams: the test parameters
"""
funcname = GetFunctionName(self.initTestParams)
self.logger.debug(funcname + 'Initiate all relevant test parameters')
self.Add_Cleanup_Function_To_Stack(GlobalGetterSetter().setter.execute)
self._txInterfaces = dict(testParams['tx_interfaces'])
self._interfaceToVlanMapping = [
v for k, v in testParams.items() if str(k).startswith('group')
]
for k in self._txInterfaces.keys():
packetVIDs = [
str(x) for x in self._txInterfaces[k]['packet_vids']
if x != 'X'
]
self._txInterfaces[k]['vlan_tested'] = packetVIDs
def addFilterSharedBlock(cls, block: int, parent=None, protocol=None, pref=None, handle=None, qdisq=None, skipSwOrHw='', **kwargs):
"""
Create a new ACE in the ingress qdisc
:param pref: specify the preference/priority of the rule within the qdisc
:param skipSwOrHw: specify skip_sw/skip_hw selector (or nothing - default behavior)
:param block: the shared block number id
:param parent:
:param protocol:
:param handle:
:param qdisq:
:param kwargs: the flower selectors (e.g., src_ip=1.1.1.1, src_mac=00:00:00:00:00:01, etc.)
:return:
"""
assert skipSwOrHw in ('', 'skip_sw', 'skip_hw')
return GlobalGetterSetter().setter.tc_filter_add(block=block, protocol=protocol, pref=pref,
parent=parent, handle=handle, qdisq=qdisq,
flower=skipSwOrHw + ' ' + ' '.join(
list("%s %s" % x for x in kwargs.items())))
def getVlanSettings(cls):
import json5
vlanTable = json5.loads(GlobalGetterSetter().getter.bridge(
'-j', 'vlan', 'show'))
hasInFlags = lambda x, y: 'flags' in x and not y not in x['flags']
vlanTable = {item['ifname']: item['vlans'] for item in vlanTable}
for k, v in vlanTable.items():
pvid = [
str(vlans['vlan']) for vlans in v
if (hasInFlags(vlans, 'PVID'))
]
cls.__vlanConfiguration[k] = {
**{
'vlans': {
str(vlans['vlan']): 'untagged' if hasInFlags(
vlans, 'Egress Untagged') else 'tagged'
for vlans in v
}
},
**{
'pvid': pvid[0] if pvid else None
}
}
def setIpv6Forwarding(cls, v):
ret = GlobalGetterSetter().setter.sysctl(
'-w', f'net.ipv6.conf.all.forwarding={v}')
if not ret:
cls.__ipv6Forwarding = v
def removeInterfaceFromVlan(cls, dev, vid, *args, otherDut=False):
if otherDut:
executer = GlobalGetterSetter().getterOtherDut
else:
executer = GlobalGetterSetter().getter
return executer.bridge_vlan_del(vid=vid, dev=dev, *args)