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)