class IxeResourceGroup(IxeCardObj, metaclass=ixe_obj_meta):
__tcl_command__ = 'resourceGroupEx'
__tcl_members__ = [
TclMember('mode', type=int),
TclMember('activePortList'),
TclMember('resourcePortList'),
TclMember('activeCapturePortList'),
TclMember('ppm')
]
rePortInList = re.compile(r"(?:{((?:\d+\s*){3})})")
def __init__(self, parent, rg_num, mode, ppm, active_ports, capture_ports,
resource_ports):
super().__init__(parent=parent,
uri=parent.uri.replace('/', ' ') + ' ' + rg_num)
self._update_uri(
parent.uri.replace('/', ' ') + ' ' + str(active_ports[0]))
self.active_ports = active_ports
self.capture_ports = capture_ports
self.resource_ports = resource_ports
def enable_capture_state(self, state, writeToHw=False):
"""
Enable/Disable capture on resource group
"""
if state:
activePorts = self.rePortInList.findall(self.activePortList)
self.activeCapturePortList = "{{" + activePorts[0] + "}}"
else:
self.activeCapturePortList = "{{" "}}"
if (writeToHw):
self.ix_command('write')
def change_mode(self, mode, writeToHw=False):
mode = int(mode)
if mode == self.mode:
return None
allPorts = self.rePortInList.findall(self.resourcePortList)
self.set_auto_set(False)
self.mode = mode
self.set_auto_set(True)
if mode == 100000 or mode == 40000:
self.activePortList = "{{" + allPorts[0] + "}}"
activeIndex = 0
elif mode == 10000 or mode == 25000:
self.activePortList = "{{" + allPorts[1] + "}{" + allPorts[2] + "}{" + allPorts[3] + "}{" + \
allPorts[4] + "}}"
activeIndex = 1
elif mode == 50000:
self.activePortList = "{{" + allPorts[5] + "}{" + allPorts[6] + "}}"
activeIndex = 5
else:
return None
if (writeToHw):
self.ix_command('write')
self._update_uri(allPorts[activeIndex])
return True
def _update_uri(self, value):
self._data['uri'] = value
class IxeStreamTxStats(IxeObject, metaclass=ixe_obj_meta):
__tcl_command__ = 'streamTransmitStats'
__tcl_members__ = [
TclMember('framesSent', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('frameRate', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
]
__get_command__ = 'getGroup'
def __init__(self, parent, group_id):
super().__init__(parent=parent, uri=group_id)
class IxeWeightedRandomFramesize(IxeStreamObj):
__tcl_command__ = 'weightedRandomFramesize'
__tcl_members__ = [
TclMember('center', type=float),
TclMember('pairList', flags=FLAG_RDONLY),
TclMember('randomType', type=int),
TclMember('weight', type=int),
TclMember('widthAtHalf', type=float),
]
__tcl_commands__ = ['addPair', 'delPair', 'updateQuadGaussianCurve']
class IxeStreamTxStats(IxeObject):
__tcl_command__ = 'streamTransmitStats'
__tcl_members__ = [
TclMember('framesSent', type=int, flags=FLAG_RDONLY),
TclMember('frameRate', type=int, flags=FLAG_RDONLY),
]
__get_command__ = 'getGroup'
def __init__(self, parent, group_id):
super(self.__class__, self).__init__(uri=group_id, parent=parent)
class IxeSplitPacketGroup(IxePortObj, metaclass=ixe_obj_meta):
__tcl_command__ = 'splitPacketGroup'
__tcl_members__ = [
TclMember('groupIdOffset', type=int),
TclMember('groupIdOffsetBaseType'),
TclMember('groupIdWidth', type=int),
TclMember('groupIdMask')
]
def __init__(self, parent):
super(self.__class__, self).__init__(parent)
self.ix_set_default()
class IxeProtocol(IxeStreamObj):
__tcl_command__ = 'protocol'
__tcl_members__ = [
TclMember('appName'),
TclMember('ethernetType'),
TclMember('enable802dot1qTag', type=int),
TclMember('name'),
]
def ix_get(self, member=None, force=False):
self.parent.ix_get(member, force)
def ix_set(self, member=None):
self.parent.ix_set(member)
class IxeDataIntegrityPort(IxePortObj):
__tcl_command__ = 'dataIntegrity'
__tcl_members__ = [
TclMember('enableTimeStamp'),
TclMember('insertSignature'),
TclMember('signature'),
TclMember('signatureOffset'),
]
__get_command__ = 'getRx'
__set_command__ = 'setRx'
__tcl_commands__ = ['config', 'getCircuitRx', 'getQueueRx', 'setCircuitRx', 'setQueueRx']
def __init__(self, parent):
super(IxePortObj, self).__init__(uri=parent.uri, parent=parent)
class IxeCapture(IxePortObj, metaclass=ixe_obj_meta):
__tcl_command__ = 'capture'
__tcl_members__ = [
TclMember('afterTriggerFilter'),
TclMember('beforeTriggerFilter'),
TclMember('captureMode'),
TclMember('continuousFilter'),
TclMember('enableSmallPacketCapture'),
TclMember('fullAction'),
TclMember('nPackets', type=int, flags=FLAG_RDONLY),
TclMember('sliceSize'),
TclMember('triggerPosition')
]
class IxeCapture(IxeObject):
__tcl_command__ = 'capture'
__tcl_members__ = [
TclMember('nPackets', type=int, flags=FLAG_RDONLY),
]
def __init__(self, parent):
super(self.__class__, self).__init__(uri=parent.uri, parent=parent)
class IxeVlan(IxeStreamObj):
__tcl_command__ = 'vlan'
__tcl_members__ = [
TclMember('cfi', type=int),
TclMember('maskval'),
TclMember('mode'),
TclMember('name', flags=FLAG_RDONLY),
TclMember('repeat', type=int),
TclMember('step', type=int),
TclMember('userPriority', type=int),
TclMember('vlanID', type=int),
TclMember('protocolTagId'),
]
__tcl_commands__ = ['setDefault']
class IxeStackedVlan(IxeStreamObj, metaclass=ixe_obj_meta):
__tcl_command__ = 'stackedVlan'
__tcl_members__ = [
TclMember('numVlans', flags=FLAG_RDONLY),
]
__tcl_commands__ = [
'setDefault', 'addVlan', 'delVlan', 'getFirstVlan', 'getNextVlan',
'getVlan', 'setVlan'
]
class IxeUdp(IxeStreamObj):
__tcl_command__ = 'udp'
__tcl_members__ = [
TclMember('checksum'),
TclMember('checksumMode'),
TclMember('destPort'),
TclMember('enableChecksumOverride'),
TclMember('enableChecksum'),
TclMember('length'),
TclMember('lengthOverride'),
TclMember('sourcePort'),
]
class IxeAutoDetectInstrumentationStream(IxeStreamTxObj):
__tcl_command__ = 'autoDetectInstrumentation'
__tcl_members__ = [
TclMember('enableMisdirectedPacketMask', type=bool),
TclMember('enablePRBS', type=bool),
TclMember('enableSignatureMask', type=bool),
TclMember('enableTxAutomaticInstrumentation', type=bool),
TclMember('misdirectedPacketMask'),
TclMember('signature'),
TclMember('signatureMask'),
TclMember('startOfScan', type=int),
]
class IxePacketGroupStream(IxeStreamObj):
__tcl_command__ = 'packetGroup'
__tcl_members__ = [
TclMember('groupId', type=int),
]
__get_command__ = 'getTx'
__set_command__ = 'setTx'
def __init__(self, parent):
super(IxeStreamObj, self).__init__(uri=parent.uri, parent=parent)
class IxePacketGroupPort(IxePortObj):
__tcl_command__ = 'packetGroup'
__tcl_members__ = [
TclMember('signature'),
]
__get_command__ = 'getRx'
__set_command__ = 'setRx'
def __init__(self, parent):
super(IxePortObj, self).__init__(uri=parent.uri, parent=parent)
class IxeDataIntegrityStream(IxeStreamTxObj):
__tcl_command__ = 'dataIntegrity'
__tcl_members__ = [
TclMember('enableTimestamp', type=bool),
TclMember('insertSignature', type=bool),
TclMember('floatingTimestampAndDataIntegrityMode'),
TclMember('numBytesFromEndOfFrame', type=int),
TclMember('payloadLength', type=int),
TclMember('signature'),
TclMember('signatureOffset', type=int),
]
class IxeAutoDetectInstrumentationPort(IxePortRxObj, metaclass=ixe_obj_meta):
__tcl_command__ = 'autoDetectInstrumentation'
__tcl_members__ = [
TclMember('enableMisdirectedPacketMask', type=bool),
TclMember('enablePRBS', type=bool),
TclMember('enableSignatureMask', type=bool),
TclMember('misdirectedPacketMask'),
TclMember('signature'),
TclMember('signatureMask'),
TclMember('startOfScan', type=int),
]
class IxePgStats(IxeObject):
__tcl_command__ = 'packetGroupStats'
__tcl_members__ = [
TclMember('totalFrames', type=int, flags=FLAG_RDONLY),
TclMember('frameRate', type=int, flags=FLAG_RDONLY),
TclMember('totalByteCount', type=int, flags=FLAG_RDONLY),
TclMember('byteRate', type=int, flags=FLAG_RDONLY),
TclMember('bitRate', type=int, flags=FLAG_RDONLY),
TclMember('minLatency', type=int, flags=FLAG_RDONLY),
TclMember('maxLatency', type=int, flags=FLAG_RDONLY),
TclMember('averageLatency', type=int, flags=FLAG_RDONLY),
]
def __init__(self, parent, pg_id):
super(self.__class__, self).__init__(uri=parent.uri + ' ' +
str(pg_id) + ' ' + str(pg_id),
parent=parent)
class IxeCaptureBuffer(IxeObject, metaclass=ixe_obj_meta):
__tcl_command__ = 'captureBuffer'
__tcl_members__ = [
TclMember('frame', flags=FLAG_RDONLY),
]
__tcl_commands__ = ['export', 'getframe']
def __init__(self, parent):
super().__init__(parent=parent, uri=parent.uri)
if not self.parent.capture.nPackets:
return
self.api.call_rc('captureBuffer get {} 1 {}'.format(
self.uri, self.parent.capture.nPackets))
def ix_command(self, command, *args, **kwargs):
return self.api.call(
('captureBuffer {} ' + len(args) * ' {}').format(command, *args))
def ix_get(self, member=None, force=False):
pass
class IxeFilterPort(IxePortObj):
__tcl_command__ = 'filter'
__tcl_members__ = [
TclMember(''),
TclMember('captureTriggerDA'),
TclMember('captureTriggerSA'),
TclMember('captureTriggerPattern'),
TclMember('captureTriggerError'),
TclMember('captureTriggerFrameSizeEnable'),
TclMember('captureTriggerFrameSizeFrom'),
TclMember('captureTriggerFrameSizeTo'),
TclMember('captureTriggerCircuit'),
TclMember('captureFilterDA'),
TclMember('captureFilterSA'),
TclMember('captureFilterPattern'),
TclMember('captureFilterError'),
TclMember('captureFilterFrameSizeEnable'),
TclMember('captureFilterFrameSizeFrom'),
TclMember('captureFilterFrameSizeTo'),
TclMember('captureFilterCircuit'),
TclMember('userDefinedStat1DA'),
TclMember('userDefinedStat1SA'),
TclMember('userDefinedStat1Pattern'),
TclMember('userDefinedStat1Error'),
TclMember('userDefinedStat1FrameSizeEnable'),
TclMember('userDefinedStat1FrameSizeFrom'),
TclMember('userDefinedStat1FrameSizeTo'),
TclMember('userDefinedStat1Circuit'),
TclMember('userDefinedStat2DA'),
TclMember('userDefinedStat2SA'),
TclMember('userDefinedStat2Pattern'),
TclMember('userDefinedStat2Error'),
TclMember('userDefinedStat2FrameSizeEnable'),
TclMember('userDefinedStat2FrameSizeFrom'),
TclMember('userDefinedStat2FrameSizeTo'),
TclMember('userDefinedStat2Circuit'),
TclMember('asyncTrigger1DA'),
TclMember('asyncTrigger1SA'),
TclMember('asyncTrigger1Pattern'),
TclMember('asyncTrigger1Error'),
TclMember('asyncTrigger1FrameSizeEnable'),
TclMember('asyncTrigger1FrameSizeFrom'),
TclMember('asyncTrigger1FrameSizeTo'),
TclMember('asyncTrigger1Circuit'),
TclMember('asyncTrigger2DA'),
TclMember('asyncTrigger2SA'),
TclMember('asyncTrigger2Pattern'),
TclMember('asyncTrigger2Error'),
TclMember('asyncTrigger2FrameSizeEnable'),
TclMember('asyncTrigger2FrameSizeFrom'),
TclMember('asyncTrigger2FrameSizeTo'),
TclMember('asyncTrigger2Circuit'),
TclMember('captureTriggerEnable'),
TclMember('captureFilterEnable'),
TclMember('userDefinedStat1Enable'),
TclMember('userDefinedStat2Enable'),
TclMember('asyncTrigger1Enable'),
TclMember('asyncTrigger2Enable'),
TclMember('userDefinedStat1PatternExpressionEnable'),
TclMember('userDefinedStat2PatternExpressionEnable'),
TclMember('captureTriggerPatternExpressionEnable'),
TclMember('captureFilterPatternExpressionEnable'),
TclMember('asyncTrigger1PatternExpressionEnable'),
TclMember('asyncTrigger2PatternExpressionEnable'),
TclMember('userDefinedStat1PatternExpression'),
TclMember('userDefinedStat2PatternExpression'),
TclMember('captureTriggerPatternExpression'),
TclMember('captureFilterPatternExpression'),
TclMember('asyncTrigger1PatternExpression'),
TclMember('asyncTrigger2PatternExpression'),
]
__tcl_commands__ = ['setDefault']
__get_command__ = 'get'
__set_command__ = 'set'
def __init__(self, parent):
super(IxePortObj, self).__init__(uri=parent.uri, parent=parent)
class IxeChassis(IxeObject):
__tcl_command__ = 'chassis'
__tcl_members__ = [
TclMember('baseIpAddress'),
TclMember('cableLength', type=int),
TclMember('hostName', flags=FLAG_RDONLY),
TclMember('id', type=int),
TclMember('ipAddress', flags=FLAG_RDONLY),
TclMember('ixServerVersion', flags=FLAG_RDONLY),
TclMember('master', flags=FLAG_RDONLY),
TclMember('maxCardCount', type=int, flags=FLAG_RDONLY),
TclMember('name'),
TclMember('operatingSystem', type=int, flags=FLAG_RDONLY),
TclMember('sequence', type=int),
TclMember('type', type=int, flags=FLAG_RDONLY),
TclMember('typeName', flags=FLAG_RDONLY),
]
__tcl_commands__ = ['add', 'del', 'refresh']
TYPE_1600 = 2
TYPE_200 = 3
TYPE_400 = 4
TYPE_100 = 5
TYPE_400C = 6
TYPE_1600T = 7
TYPE_DEMO = 9
TYPE_OPTIXIA = 10
TYPE_OPIXJR = 11
TYPE_400T = 14
TYPE_250 = 17
TYPE_400TF = 18
TYPE_OPTIXIAX16 = 19
TYPE_OPTIXIAXL10 = 20
TYPE_OPTIXIAXM12 = 22
TYPE_OPTIXIAXV = 24
TYPES = {
2: 'ixia1600',
'ixia1600': 2,
3: 'ixia200',
'ixia200': 3,
4: 'ixia400',
'ixia400': 4,
5: 'ixia100',
'ixia100': 5,
6: 'ixia400C',
'ixia400C': 6,
7: 'ixia1600T',
'ixia1600T': 7,
9: 'ixiaDemo',
'ixiaDemo': 9,
10: 'ixiaOptixia',
'ixiaOptixia': 10,
11: 'ixiaOpixJr',
'ixiaOpixJr': 11,
14: 'ixia400T',
'ixia400T': 14,
17: 'ixia250',
'ixia250': 17,
18: 'ixia400Tf',
'ixia400Tf': 18,
19: 'ixiaOptixiaX16',
'ixiaOptixiaX16': 19,
20: 'ixiaOptixiaXL10',
'ixiaOptixiaXL10': 20,
22: 'ixiaOptixiaXM12',
'ixiaOptixiaXM12': 22,
24: 'ixiaOptixiaXV',
'ixiaOptixiaXV': 24
}
OS_UNKNOWN = 0
OS_WIN95 = 1
OS_WINNT = 2
OS_WIN2000 = 3
OS_WINXP = 4
def __init__(self, parent, host, chassis_id=1):
super(self.__class__, self).__init__(uri=host,
parent=parent,
name=host)
self.chassis_id = chassis_id
def connect(self):
self.add()
self.id = self.chassis_id
def disconnect(self):
self.ix_command('del')
def discover(self):
self.logger.info('Discover chassis {}'.format(self.obj_name()))
for cid in range(1, self.maxCardCount + 1):
# unfortunately there is no config option which cards are used. So
# we have to iterate over all possible card ids and check if we are
# able to get a handle.
card = IxeCard(self, str(self.chassis_id) + '/' + str(cid))
try:
card.discover()
except IxTclHalError:
self.logger.info('slot {} is empty'.format(cid))
card.del_object_from_parent()
def add_vm_card(self, card_ip, card_id, keep_alive=300):
self._api.call_rc('chassis addVirtualCard {} {} {} {}'.format(
self.host, card_ip, card_id, keep_alive))
return IxeCard(self._api, self, card_id)
def remove_vm_card(self, card):
self._api.call_rc('chassis removeVMCard {} {}'.format(
self.host, card.id))
def get_cards(self):
"""
:return: dictionary {name: object} of all cards.
"""
return {
int(c.uri.split()[-1]): c
for c in self.get_objects_by_type('card')
}
cards = property(get_cards)
class IxeCard(IxeObject):
__tcl_command__ = 'card'
__tcl_members__ = [
TclMember('cardOperationMode', type=int, flags=FLAG_RDONLY),
TclMember('clockRxRisingEdge', type=int),
TclMember('clockSelect', type=int),
TclMember('clockTxRisingEdge', type=int),
TclMember('fpgaVersion', type=int, flags=FLAG_RDONLY),
TclMember('hwVersion', type=int, flags=FLAG_RDONLY),
TclMember('portCount', type=int, flags=FLAG_RDONLY),
TclMember('serialNumber', flags=FLAG_RDONLY),
TclMember('txFrequencyDeviation', type=int),
TclMember('type', type=int, flags=FLAG_RDONLY),
TclMember('typeName'),
]
TYPE_NONE = 0
def __init__(self, parent, uri):
super(self.__class__, self).__init__(uri=uri.replace('/', ' '),
parent=parent)
def discover(self):
self.logger.info('Discover card {}'.format(self.obj_name()))
for pid in range(1, self.portCount + 1):
IxePort(self, self.uri + '/' + str(pid))
def add_vm_port(self,
port_id,
nic_id,
mac,
promiscuous=0,
mtu=1500,
speed=1000):
card_id = self._card_id()
self._api.call_rc('card addVMPort {} {} {} {} {} {} {} {}'.format(
card_id[0], card_id[1], port_id, nic_id, promiscuous, mac, mtu,
speed))
return IxePort(self._api, self, port_id)
def remove_vm_port(self, card):
self._api.call_rc('chassis removeVMCard {} {}'.format(
self.host, card.id))
def get_ports(self):
"""
:return: dictionary {name: object} of all ports.
"""
return {
int(p.uri.split()[-1]): p
for p in self.get_objects_by_type('port')
}
ports = property(get_ports)
class IxeStat(IxeObject):
__tcl_command__ = 'stat'
__tcl_members__ = [
TclMember('duplexMode', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('link', type=int, flags=FLAG_RDONLY),
TclMember('lineSpeed', type=int, flags=FLAG_RDONLY),
TclMember('linkFaultState', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('alignmentErrors', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('asynchronousFramesSent', type=int, flags=FLAG_RDONLY),
TclMember('bitsReceived', type=int, flags=FLAG_RDONLY),
TclMember('bitsSent', type=int, flags=FLAG_RDONLY),
TclMember('bytesReceived', type=int, flags=FLAG_RDONLY),
TclMember('bytesSent', type=int, flags=FLAG_RDONLY),
TclMember('captureFilter', type=int, flags=FLAG_RDONLY),
TclMember('captureTrigger', type=int, flags=FLAG_RDONLY),
TclMember('collisionFrames', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('collisions', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('dataIntegrityErrors',
type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('dataIntegrityFrames',
type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('dribbleErrors', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('droppedFrames', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('excessiveCollisionFrames',
type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('fcsErrors', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('flowControlFrames',
type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('framesReceived', type=int, flags=FLAG_RDONLY),
TclMember('framesSent', type=int, flags=FLAG_RDONLY),
TclMember('fragments', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('ipChecksumErrors', type=int, flags=FLAG_RDONLY),
TclMember('ipPackets', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('lateCollisions', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('oversize', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('oversizeAndCrcErrors',
type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('pauseAcknowledge', type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('pauseEndFrames', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('pauseOverwrite', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('prbsErroredBits', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('rxPingReply', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('rxPingRequest', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('scheduledFramesSent', type=int, flags=FLAG_RDONLY),
TclMember('sequenceErrors', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('sequenceFrames', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('symbolErrorFrames',
type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('symbolErrors', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('synchErrorFrames', type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('tcpChecksumErrors',
type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('tcpPackets', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('transmitDuration', type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('txPingReply', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('txPingRequest', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('udpChecksumErrors',
type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('udpPackets', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('undersize', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('userDefinedStat1', type=int, flags=FLAG_RDONLY),
TclMember('userDefinedStat2', type=int, flags=FLAG_RDONLY),
TclMember('vlanTaggedFramesRx',
type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('enableArpStats'),
TclMember('enableDhcpStats'),
TclMember('enableDhcpV6Stats'),
TclMember('enableFcoeStats'),
TclMember('enableIcmpStats'),
TclMember('enableIgmpStats'),
TclMember('enableMacSecStats'),
TclMember('enablePosExtendedStats'),
TclMember('enableProtocolServerStats'),
TclMember('enableValidStats'),
TclMember('fcoeRxSharedStatType1'),
TclMember('fcoeRxSharedStatType2'),
]
__tcl_commands__ = ['write']
__get_command__ = None
def __init__(self, parent):
super(IxeStat, self).__init__(uri=parent.uri, parent=parent)
def set_attributes(self, **attributes):
super(IxeStat, self).set_attributes(**attributes)
self.write()
def read_stats(self, *stats):
if not stats:
stats = [
m.attrname for m in self.__tcl_members__
if m.flags & FLAG_RDONLY
]
stats_values = OrderedDict(zip(stats, [-1] * len(stats)))
for stat in stats:
stats_values[stat] = getattr(self, stat)
return stats_values
class IxePgStats(IxeObject):
__tcl_command__ = 'packetGroupStats'
__tcl_members__ = [
TclMember('averageLatency', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('bigSequenceError', type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('bitRate', type=int, flags=FLAG_RDONLY),
TclMember('byteRate', type=int, flags=FLAG_RDONLY),
TclMember('duplicateFrames', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('firstTimeStamp', type=int, flags=FLAG_RDONLY),
TclMember('frameRate', type=int, flags=FLAG_RDONLY),
TclMember('lastTimeStamp', type=int, flags=FLAG_RDONLY),
TclMember('maxDelayVariation',
type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('maxLatency', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('maxMinDelayVariation',
type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('maxminInterval', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('minDelayVariation',
type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('minLatency', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('numGroups', type=int, flags=FLAG_RDONLY),
TclMember('prbsBerRatio', type=float, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('prbsBitsReceived', type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('prbsErroredBits', type=int, flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('readTimeStamp', type=int, flags=FLAG_RDONLY),
TclMember('reverseSequenceError',
type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('sequenceGaps',
type=int,
flags=FLAG_RDONLY | FLAG_IGERR | FLAG_IGERR),
TclMember('smallSequenceError',
type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('standardDeviation',
type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
TclMember('totalByteCount', type=int, flags=FLAG_RDONLY),
TclMember('totalFrames', type=int, flags=FLAG_RDONLY),
TclMember('totalSequenceError',
type=int,
flags=FLAG_RDONLY | FLAG_IGERR),
]
__get_command__ = 'getGroup'
def __init__(self, parent, group_id):
super(self.__class__, self).__init__(uri=group_id, parent=parent)
def read_stats(self, *stats):
if not stats:
stats = [
m.attrname for m in self.__tcl_members__
if m.flags & FLAG_RDONLY
]
stats_values = OrderedDict(zip(stats, [-1] * len(stats)))
try:
if int(self.get_attribute('totalFrames')):
return self.get_attributes(FLAG_RDONLY, *stats)
except IxTclHalError as _:
pass
# No group or no packets on group.
return stats_values
class IxeUdf(IxeStreamObj):
__tcl_command__ = 'udf'
__tcl_members__ = [
TclMember('bitOffset', type=int),
TclMember('cascadeType', type=int),
TclMember('chainFrom', type=int),
TclMember('continuousCount'),
TclMember('counterMode', type=int),
TclMember('countertype', type=int),
TclMember('enable'),
TclMember('enableCascade'),
TclMember('enableIndexMode'),
TclMember('enableKillBitMode'),
TclMember('enableSkipZerosAndOnes'),
TclMember('initval'),
TclMember('innerLoop'),
TclMember('innerRepeat'),
TclMember('innerStep'),
TclMember('killBitUDFSize'),
TclMember('linearCoefficient'),
TclMember('linearCoefficientEnable'),
TclMember('linearCoefficientLoopCount0'),
TclMember('linearCoefficientLoopCount2'),
TclMember('maskselect'),
TclMember('maskval'),
TclMember('offset'),
TclMember('random'),
TclMember('repeat', type=int),
TclMember('skipMaskBits'),
TclMember('step', type=int),
TclMember('tripleNestedLoop0Increment'),
TclMember('udfSize'),
TclMember('updown', type=int),
TclMember('valueList'),
TclMember('valueRepeatCount'),
]
__tcl_commands__ = ['addRange', 'clearRangeList', 'config', 'getFirstRange', 'getNextRange',
'getRange', 'setDefault']
def ix_get(self, member=None, force=False):
pass
def ix_set(self, member=None):
pass
class IxeSession(IxeObject):
__tcl_command__ = 'session'
__tcl_members__ = [
TclMember('userName', flags=FLAG_RDONLY),
TclMember('captureBufferSegmentSize', type=int),
]
__tcl_commands__ = ['login', 'logout']
port_lists = []
def __init__(self, logger, api):
super(self.__class__, self).__init__(uri='', parent=None)
self.logger = logger
self.api = api
self.session = self
def reserve_ports(self,
ports_locations,
force=False,
clear=True,
phy_mode=IxePhyMode.ignore):
""" Reserve ports and reset factory defaults.
:param ports_locations: list of ports ports_locations <ip, card, port> to reserve
:param force: True - take forcefully, False - fail if port is reserved by other user
:param clear: True - clear port configuration and statistics, False - leave port as is
:param phy_mode: requested PHY mode.
:return: ports dictionary (port uri, port object)
"""
for port_location in ports_locations:
ip, card, port = port_location.split('/')
chassis = self.get_objects_with_attribute('chassis', 'ipAddress',
ip)[0].id
uri = '{} {} {}'.format(chassis, card, port)
port = IxePort(parent=self, uri=uri)
port._data['name'] = port_location
port.reserve(force=force)
if clear:
port.clear()
return self.ports
def wait_for_up(self, timeout=16, ports=None):
""" Wait until ports reach up state.
:param timeout: seconds to wait.
:param ports: list of ports to wait for.
:return:
"""
port_list = []
for port in ports:
port_list.append(self.set_ports_list(port))
t_end = time.time() + timeout
ports_not_in_up = []
ports_in_up = []
while time.time() < t_end:
# ixCheckLinkState can take few seconds on some ports when link is down.
for port in port_list:
call = self.api.call('ixCheckLinkState {}'.format(port))
if call == '0':
ports_in_up.append("{}".format(port))
else:
pass
ports_in_up = list(set(ports_in_up))
if len(port_list) == len(ports_in_up):
return
time.sleep(1)
for port in port_list:
if port not in ports_in_up:
ports_not_in_up.append(port)
raise TgnError('{}'.format(ports_not_in_up))
def clear_all_stats(self, *ports):
""" Clear all statistic counters (port, streams and packet groups) on list of ports.
:param ports: list of ports to clear.
"""
port_list = self.set_ports_list(*ports)
self.api.call_rc('ixClearStats {}'.format(port_list))
self.api.call_rc('ixClearPacketGroups {}'.format(port_list))
def start_transmit(self, blocking=False, start_packet_groups=True, *ports):
""" Start transmit on ports.
:param blocking: True - wait for traffic end, False - return after traffic start.
:param start_packet_groups: True - clear time stamps and start collecting packet groups stats, False - don't.
:param ports: list of ports to start traffic on, if empty start on all ports.
"""
port_list = self.set_ports_list(*ports)
if start_packet_groups:
port_list_for_packet_groups = self.ports.values()
port_list_for_packet_groups = self.set_ports_list(
*port_list_for_packet_groups)
self.api.call_rc(
'ixClearTimeStamp {}'.format(port_list_for_packet_groups))
self.api.call_rc(
'ixStartPacketGroups {}'.format(port_list_for_packet_groups))
self.api.call_rc('ixStartTransmit {}'.format(port_list))
time.sleep(2)
if blocking:
self.wait_transmit(*ports)
def start_packet_groups(self, clear_time_stamps=True, *ports):
""" Start packet groups on ports.
:param clear_time_stamps: True - clear time stamps, False - don't.
:param ports: list of ports to start traffic on, if empty start on all ports.
"""
port_list = self.set_ports_list(*ports)
if clear_time_stamps:
self.api.call_rc('ixClearTimeStamp {}'.format(port_list))
self.api.call_rc('ixStartPacketGroups {}'.format(port_list))
def stop_transmit(self, *ports):
""" Stop traffic on ports.
:param ports: list of ports to stop traffic on, if empty start on all ports.
"""
port_list = self.set_ports_list(*ports)
self.api.call_rc('ixStopTransmit {}'.format(port_list))
time.sleep(2)
def wait_transmit(self, *ports):
""" Wait for traffic end on ports.
:param ports: list of ports to wait for, if empty wait for all ports.
"""
port_list = self.set_ports_list(*ports)
self.api.call_rc('ixCheckTransmitDone {}'.format(port_list))
def start_capture(self, *ports):
""" Start capture on ports.
:param ports: list of ports to start capture on, if empty start on all ports.
"""
IxeCapture.current_object = None
IxeCaptureBuffer.current_object = None
if not ports:
ports = self.ports.values()
for port in ports:
port.captureBuffer = None
port_list = self.set_ports_list(*ports)
self.api.call_rc('ixStartCapture {}'.format(port_list))
def stop_capture(self,
cap_file_name=None,
cap_file_format=IxeCapFileFormat.mem,
*ports):
""" Stop capture on ports.
:param cap_file_name: prefix for the capture file name.
Capture files for each port are saved as individual pcap file named 'prefix' + 'URI'.pcap.
:param cap_file_format: exported file format
:param ports: list of ports to stop traffic on, if empty stop all ports.
:return: dictionary (port, nPackets)
"""
port_list = self.set_ports_list(*ports)
self.api.call_rc('ixStopCapture {}'.format(port_list))
nPackets = {}
for port in (ports if ports else self.ports.values()):
nPackets[port] = port.capture.nPackets
if nPackets[port]:
if cap_file_format is not IxeCapFileFormat.mem:
port.cap_file_name = cap_file_name + '-' + port.uri.replace(
' ', '_') + '.' + cap_file_format.name
port.captureBuffer.export(port.cap_file_name)
return nPackets
def get_cap_files(self, *ports):
"""
:param ports: list of ports to get capture files names for.
:return: dictionary (port, capture file)
"""
cap_files = {}
for port in ports:
if port.cap_file_name:
with open(port.cap_file_name) as f:
cap_files[port] = f.read().splitlines()
else:
cap_files[port] = None
return cap_files
def set_ports_list(self, *ports):
if not ports:
ports = self.ports.values()
port_uris = [p.uri for p in ports]
port_list = 'pl_' + '_'.join(port_uris).replace(' ', '_')
if port_list not in self.port_lists:
self.api.call(('set {} [ list ' + len(port_uris) * '[list {}] ' +
']').format(port_list, *port_uris))
return port_list
def set_stream_stats(self,
rx_ports=None,
tx_ports=None,
start_offset=40,
sequence_checking=True,
data_integrity=True,
timestamp=True):
""" Set TX ports and RX streams for stream statistics.
:param ports: list of ports to set RX pgs. If empty set for all ports.
:type ports: list[ixexplorer.ixe_port.IxePort]
:param tx_ports: list of streams to set TX pgs. If empty set for all streams.
:type tx_ports: dict[ixexplorer.ixe_port.IxePort, list[ixexplorer.ixe_stream.IxeStream]]
:param sequence_checking: True - enable sequence checkbox, False - disable
:param data_integrity: True - enable data integrity checkbox, False - disable
:param timestamp: True - enable timestamp checkbox, False - disable
:param start_offset: start offset for signatures (group ID, signature, sequence)
"""
if not rx_ports:
rx_ports = self.ports.values()
if not tx_ports:
tx_ports = {}
for port in self.ports.values():
tx_ports[port] = port.streams.values()
groupIdOffset = start_offset
signatureOffset = start_offset + 4
next_offset = start_offset + 8
if sequence_checking:
sequenceNumberOffset = next_offset
next_offset += 4
if data_integrity:
di_signatureOffset = next_offset
for port in rx_ports:
modes = []
modes.append(IxeReceiveMode.widePacketGroup)
port.packetGroup.groupIdOffset = groupIdOffset
port.packetGroup.signatureOffset = signatureOffset
if sequence_checking and int(
port.isValidFeature('portFeatureRxSequenceChecking')):
modes.append(IxeReceiveMode.sequenceChecking)
port.packetGroup.sequenceNumberOffset = sequenceNumberOffset
if data_integrity and int(
port.isValidFeature('portFeatureRxDataIntegrity')):
modes.append(IxeReceiveMode.dataIntegrity)
port.dataIntegrity.signatureOffset = di_signatureOffset
if timestamp and int(
port.isValidFeature('portFeatureRxFirstTimeStamp')):
port.dataIntegrity.enableTimeStamp = True
port.set_receive_modes(*modes)
port.write()
for port, streams in tx_ports.items():
for stream in streams:
stream.packetGroup.insertSignature = True
stream.packetGroup.groupIdOffset = groupIdOffset
stream.packetGroup.signatureOffset = signatureOffset
if sequence_checking:
stream.packetGroup.insertSequenceSignature = True
stream.packetGroup.sequenceNumberOffset = sequenceNumberOffset
if data_integrity and int(
port.isValidFeature('portFeatureRxDataIntegrity')):
stream.dataIntegrity.insertSignature = True
stream.dataIntegrity.signatureOffset = di_signatureOffset
if timestamp:
stream.enableTimestamp = True
port.write()
def set_prbs(self, rx_ports=None, tx_ports=None):
""" Set TX ports and RX streams for stream statistics.
:param ports: list of ports to set RX PRBS. If empty set for all ports.
:type ports: list[ixexplorer.ixe_port.IxePort]
:param tx_ports: list of streams to set TX PRBS. If empty set for all streams.
:type tx_ports: dict[ixexplorer.ixe_port.IxePort, list[ixexplorer.ixe_stream.IxeStream]]
"""
if not rx_ports:
rx_ports = self.ports.values()
if not tx_ports:
tx_ports = {}
for port in self.ports.values():
tx_ports[port] = port.streams.values()
for port in rx_ports:
port.set_receive_modes(IxeReceiveMode.widePacketGroup,
IxeReceiveMode.sequenceChecking,
IxeReceiveMode.prbs)
port.enableAutoDetectInstrumentation = True
port.autoDetectInstrumentation.ix_set_default()
port.write()
for port, streams in tx_ports.items():
for stream in streams:
stream.autoDetectInstrumentation.enableTxAutomaticInstrumentation = True
stream.autoDetectInstrumentation.enablePRBS = True
port.write()
#
# Properties.
#
def get_ports(self):
"""
:return: dictionary {name: object} of all reserved ports.
"""
return OrderedDict(
{str(p): p
for p in self.get_objects_by_type('port')})
ports = property(get_ports)
class IxePacketGroupStream(IxeStreamTxObj):
__tcl_command__ = 'packetGroup'
__tcl_members__ = [
TclMember('allocateUdf', type=bool),
TclMember('delayVariationMode'),
TclMember('enable128kBinMode', type=bool),
TclMember('enableGroupIdMask', type=bool),
TclMember('enableInsertPgid', type=bool),
TclMember('enableLastBitTimeStamp', type=bool),
TclMember('enableLatencyBins', type=bool),
TclMember('enableReArmFirstTimeStamp', type=bool),
TclMember('enableRxFilter', type=bool),
TclMember('enableSignatureMask', type=bool),
TclMember('enableTimeBins', type=bool),
TclMember('groupId', type=int),
TclMember('groupIdMask'),
TclMember('groupIdMode'),
TclMember('groupIdOffset', type=int),
TclMember('headerFilter'),
TclMember('headerFilterMask'),
TclMember('ignoreSignature', type=bool),
TclMember('insertSequenceSignature', type=bool),
TclMember('insertSignature', type=bool),
TclMember('latencyBinList'),
TclMember('latencyControl'),
TclMember('maxRxGroupId', type=int),
TclMember('measurementMode'),
TclMember('multiSwitchedPathMode'),
TclMember('numPgidPerTimeBin', type=int),
TclMember('numTimeBins', type=int),
TclMember('preambleSize', type=int),
TclMember('seqAdvTrackingLateThreshold', type=int),
TclMember('sequenceErrorThreshold', type=int),
TclMember('sequenceCheckingMode'),
TclMember('sequenceNumberOffset', type=int),
TclMember('signature'),
TclMember('signatureMask'),
TclMember('signatureOffset', type=int),
TclMember('timeBinDuration', type=int),
]
class IxeFilterPalettePort(IxePortObj):
__tcl_command__ = 'filterPallette'
__tcl_members__ = [
TclMember('DA1'),
TclMember('DAMask1'),
TclMember('DA2'),
TclMember('DAMask2'),
TclMember('SA1'),
TclMember('SAMask1'),
TclMember('SA2'),
TclMember('SAMask2'),
TclMember('pattern1'),
TclMember('patternMask1'),
TclMember('pattern2'),
TclMember('patternMask2'),
TclMember('patternOffset1',type=int),
TclMember('patternOffset2',type=int),
]
__tcl_commands__ = ['setDefault']
__get_command__ = 'get'
__set_command__ = 'set'
def __init__(self, parent):
super(IxePortObj, self).__init__(uri=parent.uri, parent=parent)
class IxePort(IxeObject):
__tcl_command__ = 'port'
__tcl_members__ = [
TclMember('advertise1000FullDuplex', type=bool),
TclMember('advertise100FullDuplex', type=bool),
TclMember('advertise100HalfDuplex', type=bool),
TclMember('advertise10FullDuplex', type=bool),
TclMember('advertise10HalfDuplex', type=bool),
TclMember('advertiseAbilities'),
TclMember('autoDetectInstrumentationMode', type=bool),
TclMember('autonegotiate', type=bool),
TclMember('dataCenterMode', type=bool),
TclMember('DestMacAddress', type=MacStr),
TclMember('directedAddress', type=MacStr),
TclMember('duplex'),
TclMember('enableAutoDetectInstrumentation', type=bool),
TclMember('enableDataCenterMode', type=bool),
TclMember('enableManualAutoNegotiate', type=bool),
TclMember('enablePhyPolling', type=bool),
TclMember('enableRepeatableLastRandomPattern', type=bool),
TclMember('enableSimulateCableDisconnect', type=bool),
TclMember('enableTransparentDynamicRateChange', type=bool),
TclMember('enableTxRxSyncStatsMode', type=bool),
TclMember('flowControl', type=bool),
TclMember('flowControlType', int),
TclMember('ignoreLink', type=bool),
TclMember('linkState', type=int, flags=FLAG_RDONLY),
TclMember('loopback'),
TclMember('MacAddress', type=MacStr),
TclMember('masterSlave', type=bool),
TclMember('multicastPauseAddress'),
TclMember('negotiateMasterSlave', type=bool),
TclMember('operationModeList', type=int),
TclMember('owner'),
TclMember('packetFlowFileName'),
TclMember('pfcEnableValueList'),
TclMember('pfcEnableValueListBitMatrix'),
TclMember('pfcResponseDelayEnabled'),
TclMember('pfcResponseDelayQuanta'),
TclMember('phyMode', flags=FLAG_RDONLY),
TclMember('pmaClock', type=int),
TclMember('portMode', type=int),
TclMember('preEmphasis'),
TclMember('receiveMode'),
TclMember('rxTxMode', type=int),
TclMember('speed', type=int),
TclMember('timeoutEnable'),
TclMember('transmitClockDeviation', type=bool),
TclMember('transmitClockMode', type=int),
TclMember('transmitMode', type=int),
TclMember('txRxSyncInterval', type=int),
TclMember('type', flags=FLAG_RDONLY),
TclMember('typeName', flags=FLAG_RDONLY),
TclMember('usePacketFlowImageFile', type=bool),
TclMember('enableRsFec', type=bool),
TclMember('ieeeL1Defaults', type=int),
TclMember('firecodeRequest', type=int),
TclMember('firecodeAdvertise', type=int),
TclMember('firecodeForceOn', type=int),
TclMember('firecodeForceOff', type=int),
TclMember('reedSolomonRequest', type=int),
TclMember('reedSolomonAdvertise', type=int),
TclMember('reedSolomonForceOn', type=int),
TclMember('reedSolomonForceOff', type=int)
]
__tcl_commands__ = ['export', 'getFeature', 'getStreamCount', 'reset', 'setFactoryDefaults',
'setModeDefaults', 'setDefault', 'restartAutoNegotiation',
'getPortState']
LINK_STATE_DOWN = 0
LINK_STATE_UP = 1
LINK_STATE_LOOPBACK = 2
LINK_STATE_MII_WRITE = 3
LINK_STATE_RESTART_AUTO = 4
LINK_STATE_AUTO_NEGOTIATING = 5
LINK_STATE_MII_FAIL = 6
LINK_STATE_NO_TRANSCEIVER = 7
LINK_STATE_INVALID_ADDRESS = 8
LINK_STATE_READ_LINK_PARTNER = 9
LINK_STATE_NO_LINK_PARTNER = 10
LINK_STATE_RESTART_AUTO_END = 11
LINK_STATE_FPGA_DOWNLOAD_FAILED = 12
LINK_STATE_LOSS_OF_FRAME = 24
LINK_STATE_LOSS_OF_SIGNAL = 25
def __init__(self, parent, uri):
super(self.__class__, self).__init__(uri=uri.replace('/', ' '), parent=parent)
self.cap_file_name = None
def supported_speeds(self):
return re.findall(r'\d+', self.getFeature('ethernetLineRate'))
def reserve(self, force=False):
""" Reserve port.
:param force: True - take forcefully, False - fail if port is reserved by other user
"""
if not force:
try:
self.api.call_rc('ixPortTakeOwnership {}'.format(self.uri))
except Exception as _:
raise TgnError('Failed to take ownership for port {} current owner is {}'.format(self, self.owner))
else:
self.api.call_rc('ixPortTakeOwnership {} force'.format(self.uri))
def release(self):
self.api.call_rc('ixPortClearOwnership {}'.format(self.uri))
def write(self):
self.ix_command('write')
stream_warnings = self.streamRegion.generateWarningList()
warnings_list = (self.api.call('join ' + ' {' + stream_warnings + '} ' + ' LiStSeP').split('LiStSeP')
if self.streamRegion.generateWarningList() else [])
for warning in warnings_list:
if warning:
raise StreamWarningsError(warning)
def load_config(self, config_file_name):
""" Load configuration file from prt or str.
Configuration file type is extracted from the file suffix - prt or str.
:param config_file_name: full path to the configuration file.
IxTclServer must have access to the file location. either:
The config file is on shared folder.
IxTclServer run on the client machine.
"""
config_file_name = config_file_name.replace('\\', '/')
ext = path.splitext(config_file_name)[-1].lower()
if ext == '.prt':
self.api.call_rc('port import {} {}'.format(config_file_name, self.uri))
elif ext == '.str':
self.reset()
self.api.call_rc('stream import {} {}'.format(config_file_name, self.uri))
else:
raise ValueError('Configuration file type {} not supported.'.format(ext))
self.write()
self.discover()
def discover(self):
self.logger.info('Discover port {}'.format(self.obj_name()))
for stream_id in range(1, int(self.getStreamCount()) + 1):
IxeStream(self, self.uri + '/' + str(stream_id))
def clear_port_stats(self):
self.api.call_rc('ixClearPortStats {}'.format(self.uri))
def clear_stats(self):
self.api.call_rc('ixClearPortStats {}'.format(self.uri))
self.api.call_rc('ixClearPortPacketGroups {}'.format(self.uri))
self.api.call_rc('ixClearPerStreamTxStats {}'.format(self.session.set_ports_list(self)))
def add_stream(self, name=None):
stream = IxeStream(self, self.uri + '/' + str(int(self.getStreamCount()) + 1))
stream.ix_set_default()
if not name:
name = str(stream)
stream.name = '{' + name.replace('%', '%%').replace('\\', '\\\\') + '}'
return stream
def get_streams(self):
"""
:return: dictionary {stream id: object} of all streams.
"""
return {int(s.uri.split()[-1]): s for s in self.get_objects_by_type('stream')}
streams = property(get_streams)
def start_transmit(self, blocking=False):
""" Start transmit on port.
:param blocking: True - wait for traffic end, False - return after traffic start.
"""
self.session.start_transmit(blocking, self)
def stop_transmit(self):
""" Stop traffic on port. """
self.session.stop_transmit(self)
def start_capture(self):
""" Start capture on port. """
self.session.start_capture(self)
def stop_capture(self, cap_file_name, cap_file_format=IxeCapFileFormat.enc):
""" Stop capture on port.
:param cap_file_name: prefix for the capture file name.
Capture file will be saved as pcap file named 'prefix' + 'URI'.pcap.
:param cap_file_format: exported file format
:return: full path to pcap file if capture exists else None
"""
self.session.stop_capture(cap_file_name, cap_file_format, self)
def get_cap_file(self):
return self.session.get_cap_files(self).values()[0]
def get_cap_frames(self, *frame_nums):
""" Stop capture on ports.
:param frame_nums: list of frame numbers to read.
:return: list of captured frames.
"""
cap_buffer = IxeCaptureBuffer(parent=self, num_frames=-1)
frames = []
for frame_num in frame_nums:
cap_buffer.getframe(frame_num)
frames.append(cap_buffer.ix_command('cget', '-frame'))
return frames
def read_stats(self, *stats):
return IxePortsStats(self.session, self).read_stats(*stats).values()[0]
def read_stream_stats(self, *stats):
return IxeStreamsStats(self.session, *self.get_objects_by_type('stream')).read_stats(stats)
def get_filter(self):
return self.get_object('_filter', IxeFilterPort)
filter = property(get_filter)
def get_filterPallette(self):
return self.get_object('_filterPallette', IxeFilterPalettePort)
filterPallette = property(get_filterPallette)
def get_dataIntegrity(self):
return self.get_object('_dataIntegrity', IxeDataIntegrityPort)
dataIntegrity = property(get_dataIntegrity)
def get_packetGroup(self):
return self.get_object('_packetGroup', IxePacketGroupPort)
packetGroup = property(get_packetGroup)
def get_streamRegion(self):
return self.get_object('_streamRegion', IxeStreamRegion)
streamRegion = property(get_streamRegion)
def set_phy_mode(self, mode=IxePhyMode.ignore):
""" Set phy mode to copper or fiber.
:param mode: requested PHY mode.
"""
if mode.value:
self.api.call_rc('port setPhyMode {} {}'.format(mode.value, self.uri))
def set_receivemode(self, *modes):
""" set port receive mode
:param modes: requested receive mode list
"""
if modes:
mode_values = [mode.value for mode in modes]
mode_list = "[ expr " + " | ".join(mode_values) + " ]"
self.api.call_rc('port setReceiveMode {} {}'.format(mode_list, self.uri))
class IxeStream(IxeObject):
__tcl_command__ = 'stream'
__tcl_members__ = [
TclMember('asyncIntEnable'),
TclMember('bpsRate', type=float),
TclMember('da', type=MacStr),
TclMember('daMaskSelect'),
TclMember('daMaskValue', type=MacStr),
TclMember('daRepeatCounter'),
TclMember('daStep', type=int),
TclMember('dataPattern'),
TclMember('dma'),
TclMember('enable', type=bool),
TclMember('enableDaContinueFromLastValue'),
TclMember('enableIbg', type=bool),
TclMember('enableIncrFrameBurstOverride', type=bool),
TclMember('enableIsg', type=bool),
TclMember('enableSaContinueFromLastValue'),
TclMember('enableSourceInterface'),
TclMember('enableStatistic'),
TclMember('enableSuspend', type=bool),
TclMember('enableTimestamp', type=bool),
TclMember('enforceMinGap', type=bool),
TclMember('fcs'),
TclMember('fpsRate', type=float),
TclMember('framesize', type=int),
TclMember('frameSizeMAX', type=int),
TclMember('frameSizeMIN', type=int),
TclMember('frameSizeStep', type=int),
TclMember('frameSizeType', type=int),
TclMember('frameType'),
TclMember('gapUnit'),
TclMember('ibg', type=float),
TclMember('ifg', type=float),
TclMember('ifgMAX', type=float),
TclMember('ifgMIN', type=float),
TclMember('ifgType'),
TclMember('isg', type=float),
TclMember('loopCount', type=int),
TclMember('name'),
TclMember('numBursts', type=int),
TclMember('numDA', type=int),
TclMember('numFrames', type=float),
TclMember('numSA', type=int),
TclMember('pattern'),
TclMember('patternType'),
TclMember('percentPacketRate', type=float),
TclMember('preambleData'),
TclMember('preambleSize', type=int),
TclMember('priorityGroup', type=int),
TclMember('rateMode'),
TclMember('returnToId', type=int),
TclMember('rxTriggerEnable'),
TclMember('sa', type=MacStr),
TclMember('saMaskSelect'),
TclMember('saMaskValue', type=MacStr),
TclMember('saRepeatCounter'),
TclMember('saStep', type=int),
TclMember('sourceInterfaceDescription'),
TclMember('startTxDelayUnit'),
TclMember('startTxDelay'),
]
__tcl_commands__ = ['export', 'write']
next_group_id = 0
def __init__(self, parent, uri):
super(self.__class__, self).__init__(uri=uri.replace('/', ' '), parent=parent)
self.rx_ports = []
def create(self, name):
self.ix_set_default()
if not name:
name = self.obj_name()
self.name = '{' + name.replace('%', '%%').replace('\\', '\\\\') + '}'
self.ix_set()
self.packetGroup.groupId = IxeStream.next_group_id
IxeStream.next_group_id += 1
def remove(self):
self.ix_command('remove')
self.ix_command('write')
self.del_object_from_parent()
def ix_set_default(self):
super(self.__class__, self).ix_set_default()
for stream_object in [o for o in self.__dict__.values() if isinstance(o, IxeStreamObj)]:
stream_object.ix_set_default()
def read_stats(self, *stats):
return IxeStreamsStats(self.session, self).read_stats(*stats)[str(self)]
#
# Stream objects.
#
def _set_ip(self, version):
require_set = False
if self.protocol.ethernetType == '0':
self.protocol.ethernetType = 'ethernetII'
require_set = True
if self.protocol.name == '0':
# for some reason (bug?) alias (ip/ipv4) is not acceptable here.
self.protocol.name = str(version)
require_set = True
if require_set and not IxeObject.get_auto_set():
self.ix_set()
def get_ip(self):
self._set_ip(4)
return self._get_object('_ip', IxeIp)
ip = property(get_ip)
def get_ipV6(self):
self._set_ip(31)
return self._get_object('_ipV6', IxeIpv6)
ipV6 = property(get_ipV6)
def get_tcp(self):
return self._get_object('_tcp', IxeTcp)
tcp = property(get_tcp)
def get_udp(self):
return self._get_object('_udp', IxeUdp)
udp = property(get_udp)
def get_protocol(self):
return self._get_object('_protocol', IxeProtocol)
protocol = property(get_protocol)
def get_protocolOffset(self):
return self._get_object('_protocolOffset', IxeProtocolOffset)
protocolOffset = property(get_protocolOffset)
def get_weightedRandomFramesize(self):
return self._get_object('_weightedRandomFramesize', IxeWeightedRandomFramesize)
weightedRandomFramesize = property(get_weightedRandomFramesize)
def get_udf(self):
return self._get_object('_udf', IxeUdf)
udf = property(get_udf)
def get_dataIntegrity(self):
return self._get_object('_dataIntegrity', IxeDataIntegrityStream)
dataIntegrity = property(get_dataIntegrity)
def get_packetGroup(self):
return self._get_object('_packetGroup', IxePacketGroupStream)
packetGroup = property(get_packetGroup)
def get_autoDetectInstrumentation(self):
return self._get_object('_autoDetectInstrumentation', IxeAutoDetectInstrumentationStream)
autoDetectInstrumentation = property(get_autoDetectInstrumentation)
def get_vlan(self):
return self._get_object('_vlan', IxeVlan)
vlan = property(get_vlan)
def get_stacked_vlan(self):
return self._get_object('_stackedVlan', IxeStackedVlan)
stackedVlan = property(get_stacked_vlan)
