matthew/ostinato
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
f3f970cb64
ostinato/test/vftest.py

1040 lines
37 KiB
Python
Raw Normal View History

Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
#! /usr/bin/env python
# standard modules
import logging
import os
import subprocess
import sys
import time
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
from harness import Test, TestSuite, extract_column
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
sys.path.insert(1, '../binding')
from core import ost_pb, DroneProxy
from rpc import RpcError
from protocols.mac_pb2 import mac
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
from protocols.arp_pb2 import arp
from protocols.icmp_pb2 import icmp
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
from protocols.ip4_pb2 import ip4, Ip4
from protocols.ip6_pb2 import ip6, Ip6
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
from protocols.payload_pb2 import payload, Payload
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
# initialize defaults
host_name = '127.0.0.1'
tx_port_number = -1
rx_port_number = -1
drone_version = ['0', '0', '0']
if sys.platform == 'win32':
tshark = r'C:\Program Files\Wireshark\tshark.exe'
else:
tshark = 'tshark'
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
fmt_template = 'column.format:"Packet#","%m","Time","%t","Source","%uns","Destination","%und","Protocol","%p","Size","%L",<custom>,"Info","%i","Expert","%a"'
fmt = fmt_template.replace('<custom>', '"Custom","%Cus:XXX"')
fmt2 = fmt_template.replace('<custom>', '"Custom","%Cus:XXX",'*2).replace(',,',',')
fmt4 = fmt_template.replace('<custom>', '"Custom","%Cus:XXX",'*4).replace(',,',',')
fmt_col = 8 # col# in fmt for Custom (col numbers start from 1)
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
# setup logging
log = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
print('')
print('This test uses the following topology -')
print('')
print(' +-------+ ')
print(' | |Tx--->----+')
print(' | Drone | |')
print(' | |Rx---<----+')
print(' +-------+ ')
print('')
print('A loopback port is used as both the Tx and Rx ports')
print('')
suite = TestSuite()
drone = DroneProxy(host_name)
try:
# ----------------------------------------------------------------- #
# Baseline Configuration for subsequent testcases
# ----------------------------------------------------------------- #
# connect to drone
log.info('connecting to drone(%s:%d)'
% (drone.hostName(), drone.portNumber()))
drone.connect()
# retreive port id list
log.info('retreiving port list')
port_id_list = drone.getPortIdList()
# retreive port config list
log.info('retreiving port config for all ports')
port_config_list = drone.getPortConfig(port_id_list)
if len(port_config_list.port) == 0:
log.warning('drone has no ports!')
sys.exit(1)
# iterate port list to find a loopback port to use as the tx/rx port id
print('Port List')
print('---------')
for port in port_config_list.port:
print('%d.%s (%s)' % (port.port_id.id, port.name, port.description))
# use a loopback port as default tx/rx port
if ('lo' in port.name or 'loopback' in port.description.lower()):
tx_port_number = port.port_id.id
rx_port_number = port.port_id.id
if tx_port_number < 0 or rx_port_number < 0:
log.warning('loopback port not found')
sys.exit(1)
print('Using port %d as tx/rx port(s)' % tx_port_number)
tx_port = ost_pb.PortIdList()
tx_port.port_id.add().id = tx_port_number;
rx_port = ost_pb.PortIdList()
rx_port.port_id.add().id = rx_port_number;
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
# delete existing streams, if any, on tx port
sid_list = drone.getStreamIdList(tx_port.port_id[0])
drone.deleteStream(sid_list)
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
# add a stream
stream_id = ost_pb.StreamIdList()
stream_id.port_id.CopyFrom(tx_port.port_id[0])
stream_id.stream_id.add().id = 1
log.info('adding tx_stream %d' % stream_id.stream_id[0].id)
drone.addStream(stream_id)
# configure the stream
stream_cfg = ost_pb.StreamConfigList()
stream_cfg.port_id.CopyFrom(tx_port.port_id[0])
s = stream_cfg.stream.add()
s.stream_id.id = stream_id.stream_id[0].id
s.core.is_enabled = True
s.core.frame_len = 128
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
s.control.packets_per_sec = 100
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
s.control.num_packets = 10
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
# all test cases will use this stream by modifying it as per its needs
# ----------------------------------------------------------------- #
# TESTCASE: Verify decrement counter8 variable field not affecting
# any checksums - IPv6 HopLimit
# ----------------------------------------------------------------- #
# setup stream protocols as mac:eth2:ip6:udp:payload
s.ClearField("protocol")
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kMacFieldNumber
p.Extensions[mac].dst_mac = 0x001122334455
p.Extensions[mac].src_mac = 0x00aabbccddee
s.protocol.add().protocol_id.id = ost_pb.Protocol.kEth2FieldNumber
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kIp6FieldNumber
Feature (contd.): Variable Fields - renamed variable_fields as singular; this makes it consistent with other repeated variables in protocol.proto and in any case the C++/Python generated code "sounds" better with a repeated field named in its singular form, rather than plural
2015-05-31 09:44:32 -05:00
vf = p.variable_field.add()
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
vf.type = ost_pb.VariableField.kCounter8
vf.offset = 7
vf.mask = 0xff
vf.value = 255
vf.mode = ost_pb.VariableField.kDecrement
vf.count = 4
s.protocol.add().protocol_id.id = ost_pb.Protocol.kUdpFieldNumber
s.protocol.add().protocol_id.id = ost_pb.Protocol.kPayloadFieldNumber
log.info('configuring tx_stream %d' % stream_id.stream_id[0].id)
drone.modifyStream(stream_cfg)
# clear tx/rx stats
log.info('clearing tx/rx stats')
drone.clearStats(tx_port)
drone.clearStats(rx_port)
passed = False
suite.test_begin('counter8Decrement[Ip6HopLimit]')
try:
drone.startCapture(rx_port)
drone.startTransmit(tx_port)
log.info('waiting for transmit to finish ...')
time.sleep(3)
drone.stopTransmit(tx_port)
drone.stopCapture(rx_port)
log.info('getting Rx capture buffer')
buff = drone.getCaptureBuffer(rx_port.port_id[0])
drone.saveCaptureBuffer(buff, 'capture.pcap')
log.info('dumping Rx capture buffer')
cap_pkts = subprocess.check_output([tshark, '-n', '-r', 'capture.pcap',
'-R', 'udp && frame.len==124',
'-o', fmt.replace('XXX', 'ipv6.hlim')])
print(cap_pkts)
result = extract_column(cap_pkts, fmt_col)
expected = ['255', '254', '253', '252',
'255', '254', '253', '252',
'255', '254']
log.info('result : %s' % result)
log.info('expected: %s' % expected)
if result == expected:
passed = True
os.remove('capture.pcap')
except RpcError as e:
raise
finally:
drone.stopTransmit(tx_port)
suite.test_end(passed)
# ----------------------------------------------------------------- #
# TESTCASE: Verify increment bitmasked counter8 variable field not
# affecting any checksums - Vlan Prio
# ----------------------------------------------------------------- #
# setup stream protocols as mac:vlan:eth2:ip4:udp:payload
s.ClearField("protocol")
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kMacFieldNumber
p.Extensions[mac].dst_mac = 0x001122334455
p.Extensions[mac].src_mac = 0x00aabbccddee
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kVlanFieldNumber
Feature (contd.): Variable Fields - renamed variable_fields as singular; this makes it consistent with other repeated variables in protocol.proto and in any case the C++/Python generated code "sounds" better with a repeated field named in its singular form, rather than plural
2015-05-31 09:44:32 -05:00
vf = p.variable_field.add()
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
vf.type = ost_pb.VariableField.kCounter8
vf.offset = 2
vf.mask = 0xe0
vf.value = 0x60
vf.mode = ost_pb.VariableField.kIncrement
vf.count = 8
Feature (contd.): Variable Fields - fixed the code to use 'step' while varying fields which was missed out earlier. Updated the test suite and made sure all test cases pass
2015-05-31 07:32:06 -05:00
vf.step = 0x10 # step by 1 and repeat each value twice!!!!!
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
s.protocol.add().protocol_id.id = ost_pb.Protocol.kEth2FieldNumber
s.protocol.add().protocol_id.id = ost_pb.Protocol.kIp4FieldNumber
s.protocol.add().protocol_id.id = ost_pb.Protocol.kUdpFieldNumber
s.protocol.add().protocol_id.id = ost_pb.Protocol.kPayloadFieldNumber
log.info('configuring tx_stream %d' % stream_id.stream_id[0].id)
drone.modifyStream(stream_cfg)
# clear tx/rx stats
log.info('clearing tx/rx stats')
drone.clearStats(tx_port)
drone.clearStats(rx_port)
passed = False
suite.test_begin('counter8BitmaskIncrement[VlanPrio]')
try:
drone.startCapture(rx_port)
drone.startTransmit(tx_port)
log.info('waiting for transmit to finish ...')
time.sleep(3)
drone.stopTransmit(tx_port)
drone.stopCapture(rx_port)
log.info('getting Rx capture buffer')
buff = drone.getCaptureBuffer(rx_port.port_id[0])
drone.saveCaptureBuffer(buff, 'capture.pcap')
log.info('dumping Rx capture buffer')
cap_pkts = subprocess.check_output([tshark, '-n', '-r', 'capture.pcap',
'-R', 'udp && frame.len==124',
'-o', fmt.replace('XXX', 'vlan.priority')])
print(cap_pkts)
result = extract_column(cap_pkts, fmt_col)
Feature (contd.): Variable Fields - fixed the code to use 'step' while varying fields which was missed out earlier. Updated the test suite and made sure all test cases pass
2015-05-31 07:32:06 -05:00
expected = ['Excellent', 'Excellent', 'Controlled', 'Controlled', 'Video,', 'Video,', 'Voice,', 'Voice,', 'Excellent', 'Excellent']
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
log.info('result : %s' % result)
log.info('expected: %s' % expected)
if result == expected:
passed = True
os.remove('capture.pcap')
except RpcError as e:
raise
finally:
drone.stopTransmit(tx_port)
suite.test_end(passed)
# ----------------------------------------------------------------- #
# TESTCASE: Verify increment counter16 variable field not affecting
# any checksums - vlan-id
# ----------------------------------------------------------------- #
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
# setup stream protocols as mac:vlan:eth2:ip4:udp:payload
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
s.ClearField("protocol")
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kMacFieldNumber
p.Extensions[mac].dst_mac = 0x001122334455
p.Extensions[mac].src_mac = 0x00aabbccddee
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kVlanFieldNumber
Feature (contd.): Variable Fields - renamed variable_fields as singular; this makes it consistent with other repeated variables in protocol.proto and in any case the C++/Python generated code "sounds" better with a repeated field named in its singular form, rather than plural
2015-05-31 09:44:32 -05:00
vf = p.variable_field.add()
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
vf.type = ost_pb.VariableField.kCounter16
vf.offset = 2
vf.mask = 0x0fff
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
vf.value = 1234
vf.mode = ost_pb.VariableField.kIncrement
vf.count = 7
s.protocol.add().protocol_id.id = ost_pb.Protocol.kEth2FieldNumber
s.protocol.add().protocol_id.id = ost_pb.Protocol.kIp4FieldNumber
s.protocol.add().protocol_id.id = ost_pb.Protocol.kUdpFieldNumber
s.protocol.add().protocol_id.id = ost_pb.Protocol.kPayloadFieldNumber
log.info('configuring tx_stream %d' % stream_id.stream_id[0].id)
drone.modifyStream(stream_cfg)
# clear tx/rx stats
log.info('clearing tx/rx stats')
drone.clearStats(tx_port)
drone.clearStats(rx_port)
passed = False
suite.test_begin('counter16Increment[vlanid]')
try:
drone.startCapture(rx_port)
drone.startTransmit(tx_port)
log.info('waiting for transmit to finish ...')
time.sleep(3)
drone.stopTransmit(tx_port)
drone.stopCapture(rx_port)
log.info('getting Rx capture buffer')
buff = drone.getCaptureBuffer(rx_port.port_id[0])
drone.saveCaptureBuffer(buff, 'capture.pcap')
log.info('dumping Rx capture buffer')
cap_pkts = subprocess.check_output([tshark, '-n', '-r', 'capture.pcap',
'-R', 'udp && frame.len==124',
'-o', fmt.replace('XXX', 'vlan.id')])
print(cap_pkts)
result = extract_column(cap_pkts, fmt_col)
expected = ['1234', '1235', '1236', '1237', '1238', '1239', '1240',
'1234', '1235', '1236']
log.info('result : %s' % result)
log.info('expected: %s' % expected)
if result == expected:
passed = True
os.remove('capture.pcap')
except RpcError as e:
raise
finally:
drone.stopTransmit(tx_port)
suite.test_end(passed)
# ----------------------------------------------------------------- #
# TESTCASE: Verify decrement counter32 step 3 variable field not
# affecting any checksums - ARP Target IP
# ----------------------------------------------------------------- #
# setup stream protocols as mac:eth2:arp
s.ClearField("protocol")
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kMacFieldNumber
p.Extensions[mac].dst_mac = 0x001122334455
Feature (contd.): Variable Fields - fixed the code to use 'step' while varying fields which was missed out earlier. Updated the test suite and made sure all test cases pass
2015-05-31 07:32:06 -05:00
p.Extensions[mac].src_mac = 0xffffffffffff
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
s.protocol.add().protocol_id.id = ost_pb.Protocol.kEth2FieldNumber
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kArpFieldNumber
Feature (contd.): Variable Fields - fixed the code to use 'step' while varying fields which was missed out earlier. Updated the test suite and made sure all test cases pass
2015-05-31 07:32:06 -05:00
p.Extensions[arp].sender_hw_addr = 0x001122334455
p.Extensions[arp].sender_proto_addr = 0x01020304
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
p.Extensions[arp].target_proto_addr = 0x0a0b0c01
Feature (contd.): Variable Fields - renamed variable_fields as singular; this makes it consistent with other repeated variables in protocol.proto and in any case the C++/Python generated code "sounds" better with a repeated field named in its singular form, rather than plural
2015-05-31 09:44:32 -05:00
vf = p.variable_field.add()
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
vf.type = ost_pb.VariableField.kCounter32
vf.offset = 24
vf.mask = 0x0000ff00
vf.value = 0x00006400
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
vf.mode = ost_pb.VariableField.kDecrement
vf.count = 7
Feature (contd.): Variable Fields - fixed the code to use 'step' while varying fields which was missed out earlier. Updated the test suite and made sure all test cases pass
2015-05-31 07:32:06 -05:00
vf.step = 0x00000300
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
log.info('configuring tx_stream %d' % stream_id.stream_id[0].id)
drone.modifyStream(stream_cfg)
# clear tx/rx stats
log.info('clearing tx/rx stats')
drone.clearStats(tx_port)
drone.clearStats(rx_port)
passed = False
suite.test_begin('counter32BitmaskDecrement[arpTargetIp]')
try:
drone.startCapture(rx_port)
drone.startTransmit(tx_port)
log.info('waiting for transmit to finish ...')
time.sleep(3)
drone.stopTransmit(tx_port)
drone.stopCapture(rx_port)
log.info('getting Rx capture buffer')
buff = drone.getCaptureBuffer(rx_port.port_id[0])
drone.saveCaptureBuffer(buff, 'capture.pcap')
log.info('dumping Rx capture buffer')
cap_pkts = subprocess.check_output([tshark, '-n', '-r', 'capture.pcap',
'-R', 'arp && frame.len==124',
Feature (contd.): Variable Fields - fixed the code to use 'step' while varying fields which was missed out earlier. Updated the test suite and made sure all test cases pass
2015-05-31 07:32:06 -05:00
'-o', fmt.replace('XXX', 'arp.dst.proto_ipv4')
.replace('un', 'uh')])
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
print(cap_pkts)
result = extract_column(cap_pkts, fmt_col)
Feature (contd.): Variable Fields - fixed the code to use 'step' while varying fields which was missed out earlier. Updated the test suite and made sure all test cases pass
2015-05-31 07:32:06 -05:00
expected = ['10.11.100.1', '10.11.97.1', '10.11.94.1', '10.11.91.1',
'10.11.88.1', '10.11.85.1', '10.11.82.1', '10.11.100.1',
'10.11.97.1', '10.11.94.1']
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
log.info('result : %s' % result)
log.info('expected: %s' % expected)
if result == expected:
passed = True
os.remove('capture.pcap')
except RpcError as e:
raise
finally:
drone.stopTransmit(tx_port)
suite.test_end(passed)
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
# ----------------------------------------------------------------- #
# TESTCASE: Verify increment counter8 variable field affecting
# IPv4 checksum - IPv4 TTL
# ----------------------------------------------------------------- #
# setup stream protocols as mac:eth2:ip4:udp:payload
s.ClearField("protocol")
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
p = s.protocol.add()
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
p.protocol_id.id = ost_pb.Protocol.kMacFieldNumber
p.Extensions[mac].dst_mac = 0x001122334455
p.Extensions[mac].src_mac = 0x00aabbccddee
s.protocol.add().protocol_id.id = ost_pb.Protocol.kEth2FieldNumber
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kIp4FieldNumber
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
p.Extensions[ip4].src_ip = 0x01020304
p.Extensions[ip4].dst_ip = 0x05060708
Feature (contd.): Variable Fields - renamed variable_fields as singular; this makes it consistent with other repeated variables in protocol.proto and in any case the C++/Python generated code "sounds" better with a repeated field named in its singular form, rather than plural
2015-05-31 09:44:32 -05:00
vf = p.variable_field.add()
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
vf.type = ost_pb.VariableField.kCounter8
vf.offset = 8
#vf.mask = 0xFF
vf.value = 127
vf.mode = ost_pb.VariableField.kIncrement
vf.count = 8
s.protocol.add().protocol_id.id = ost_pb.Protocol.kUdpFieldNumber
s.protocol.add().protocol_id.id = ost_pb.Protocol.kPayloadFieldNumber
log.info('configuring tx_stream %d' % stream_id.stream_id[0].id)
drone.modifyStream(stream_cfg)
# clear tx/rx stats
log.info('clearing tx/rx stats')
drone.clearStats(tx_port)
drone.clearStats(rx_port)
passed = False
suite.test_begin('counter8IncrementIpCksum[IpTtl]')
try:
drone.startCapture(rx_port)
drone.startTransmit(tx_port)
log.info('waiting for transmit to finish ...')
time.sleep(3)
drone.stopTransmit(tx_port)
drone.stopCapture(rx_port)
log.info('getting Rx capture buffer')
buff = drone.getCaptureBuffer(rx_port.port_id[0])
drone.saveCaptureBuffer(buff, 'capture.pcap')
log.info('dumping Rx capture buffer')
cap_pkts = subprocess.check_output([tshark, '-n', '-r', 'capture.pcap',
'-R', 'udp && frame.len==124',
'-o', fmt.replace('XXX', 'ip.ttl')])
print(cap_pkts)
result = extract_column(cap_pkts, fmt_col)
expected = ['127', '128', '129', '130', '131', '132', '133', '134',
'127', '128']
log.info('result : %s' % result)
log.info('expected: %s' % expected)
if result == expected and 'Error' not in cap_pkts:
passed = True
os.remove('capture.pcap')
except RpcError as e:
raise
finally:
drone.stopTransmit(tx_port)
suite.test_end(passed)
# ----------------------------------------------------------------- #
# TESTCASE: Verify decrement counter16 bitmask variable field affecting
# IPv4 checksum - IPv4 FragOfs
# ----------------------------------------------------------------- #
# setup stream protocols as mac:eth2:ip4:udp:payload
s.ClearField("protocol")
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kMacFieldNumber
p.Extensions[mac].dst_mac = 0x001122334455
p.Extensions[mac].src_mac = 0x00aabbccddee
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
s.protocol.add().protocol_id.id = ost_pb.Protocol.kEth2FieldNumber
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kIp4FieldNumber
p.Extensions[ip4].src_ip = 0x01020304
p.Extensions[ip4].dst_ip = 0x05060708
Feature (contd.): Variable Fields - renamed variable_fields as singular; this makes it consistent with other repeated variables in protocol.proto and in any case the C++/Python generated code "sounds" better with a repeated field named in its singular form, rather than plural
2015-05-31 09:44:32 -05:00
vf = p.variable_field.add()
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
vf.type = ost_pb.VariableField.kCounter16
vf.offset = 6
vf.mask = 0x1FFF
vf.value = 1000
vf.mode = ost_pb.VariableField.kDecrement
vf.count = 6
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
s.protocol.add().protocol_id.id = ost_pb.Protocol.kUdpFieldNumber
s.protocol.add().protocol_id.id = ost_pb.Protocol.kPayloadFieldNumber
log.info('configuring tx_stream %d' % stream_id.stream_id[0].id)
drone.modifyStream(stream_cfg)
# clear tx/rx stats
log.info('clearing tx/rx stats')
drone.clearStats(tx_port)
drone.clearStats(rx_port)
passed = False
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
suite.test_begin('counter16BitmaskDecrementIpCksum[IpFragOfs]')
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
try:
drone.startCapture(rx_port)
drone.startTransmit(tx_port)
log.info('waiting for transmit to finish ...')
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
time.sleep(3)
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
drone.stopTransmit(tx_port)
drone.stopCapture(rx_port)
log.info('getting Rx capture buffer')
buff = drone.getCaptureBuffer(rx_port.port_id[0])
drone.saveCaptureBuffer(buff, 'capture.pcap')
log.info('dumping Rx capture buffer')
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
cap_pkts = subprocess.check_output([tshark, '-n', '-r', 'capture.pcap',
'-R', 'ip && frame.len==124',
'-o', fmt.replace('XXX', 'ip.frag_offset')])
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
print(cap_pkts)
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
result = extract_column(cap_pkts, fmt_col)
expected = ['8000', '7992', '7984', '7976', '7968', '7960',
'8000', '7992', '7984', '7976']
log.info('result : %s' % result)
log.info('expected: %s' % expected)
if result == expected and 'Error' not in cap_pkts:
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
passed = True
os.remove('capture.pcap')
except RpcError as e:
raise
finally:
drone.stopTransmit(tx_port)
suite.test_end(passed)
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
# ----------------------------------------------------------------- #
# TESTCASE: Verify increment counter32 bitmask variable field affecting
# IPv4 checksum - IPv4 Dst Addr
# ----------------------------------------------------------------- #
# setup stream protocols as mac:eth2:ip4:udp:payload
s.ClearField("protocol")
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kMacFieldNumber
p.Extensions[mac].dst_mac = 0x001122334455
p.Extensions[mac].src_mac = 0x00aabbccddee
s.protocol.add().protocol_id.id = ost_pb.Protocol.kEth2FieldNumber
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kIp4FieldNumber
p.Extensions[ip4].src_ip = 0x01020304
p.Extensions[ip4].dst_ip = 0x05060708
Feature (contd.): Variable Fields - renamed variable_fields as singular; this makes it consistent with other repeated variables in protocol.proto and in any case the C++/Python generated code "sounds" better with a repeated field named in its singular form, rather than plural
2015-05-31 09:44:32 -05:00
vf = p.variable_field.add()
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
vf.type = ost_pb.VariableField.kCounter32
vf.offset = 16
vf.mask = 0x00FF0000
vf.value = 0x00ab0000
vf.mode = ost_pb.VariableField.kIncrement
vf.count = 3
Feature (contd.): Variable Fields - fixed the code to use 'step' while varying fields which was missed out earlier. Updated the test suite and made sure all test cases pass
2015-05-31 07:32:06 -05:00
vf.step = 0x00020000
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
s.protocol.add().protocol_id.id = ost_pb.Protocol.kUdpFieldNumber
s.protocol.add().protocol_id.id = ost_pb.Protocol.kPayloadFieldNumber
log.info('configuring tx_stream %d' % stream_id.stream_id[0].id)
drone.modifyStream(stream_cfg)
# clear tx/rx stats
log.info('clearing tx/rx stats')
drone.clearStats(tx_port)
drone.clearStats(rx_port)
passed = False
suite.test_begin('counter32BitmaskDecrementIpCksum[IpDstAddr]')
try:
drone.startCapture(rx_port)
drone.startTransmit(tx_port)
log.info('waiting for transmit to finish ...')
time.sleep(3)
drone.stopTransmit(tx_port)
drone.stopCapture(rx_port)
log.info('getting Rx capture buffer')
buff = drone.getCaptureBuffer(rx_port.port_id[0])
drone.saveCaptureBuffer(buff, 'capture.pcap')
log.info('dumping Rx capture buffer')
cap_pkts = subprocess.check_output([tshark, '-n', '-r', 'capture.pcap',
'-R', 'udp && frame.len==124',
'-o', fmt.replace('XXX', 'ip.dst')])
print(cap_pkts)
result = extract_column(cap_pkts, fmt_col)
expected = ['5.171.7.8', '5.173.7.8', '5.175.7.8',
'5.171.7.8', '5.173.7.8', '5.175.7.8',
'5.171.7.8', '5.173.7.8', '5.175.7.8',
'5.171.7.8']
log.info('result : %s' % result)
log.info('expected: %s' % expected)
if result == expected and 'Error' not in cap_pkts:
passed = True
os.remove('capture.pcap')
except RpcError as e:
raise
finally:
drone.stopTransmit(tx_port)
suite.test_end(passed)
# ----------------------------------------------------------------- #
# TESTCASE: Verify increment counter32 variable field affecting
# UDP checksum - seq# in payload
# ----------------------------------------------------------------- #
# setup stream protocols as mac:eth2:ip4:udp:payload
s.ClearField("protocol")
s.core.frame_len = 64
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kMacFieldNumber
p.Extensions[mac].dst_mac = 0x001122334455
p.Extensions[mac].src_mac = 0x00aabbccddee
s.protocol.add().protocol_id.id = ost_pb.Protocol.kVlanFieldNumber
s.protocol.add().protocol_id.id = ost_pb.Protocol.kVlanFieldNumber
s.protocol.add().protocol_id.id = ost_pb.Protocol.kVlanFieldNumber
s.protocol.add().protocol_id.id = ost_pb.Protocol.kEth2FieldNumber
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kIp4FieldNumber
p.Extensions[ip4].src_ip = 0x01020304
p.Extensions[ip4].dst_ip = 0x05060708
s.protocol.add().protocol_id.id = ost_pb.Protocol.kUdpFieldNumber
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kPayloadFieldNumber
Feature (contd.): Variable Fields - renamed variable_fields as singular; this makes it consistent with other repeated variables in protocol.proto and in any case the C++/Python generated code "sounds" better with a repeated field named in its singular form, rather than plural
2015-05-31 09:44:32 -05:00
vf = p.variable_field.add()
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
vf.type = ost_pb.VariableField.kCounter32
vf.offset = 0
vf.mode = ost_pb.VariableField.kIncrement
vf.count = 100
log.info('configuring tx_stream %d' % stream_id.stream_id[0].id)
drone.modifyStream(stream_cfg)
# clear tx/rx stats
log.info('clearing tx/rx stats')
drone.clearStats(tx_port)
drone.clearStats(rx_port)
passed = False
suite.test_begin('counter32IncrementUdpCksum[PayloadSeq]')
try:
drone.startCapture(rx_port)
drone.startTransmit(tx_port)
log.info('waiting for transmit to finish ...')
time.sleep(3)
drone.stopTransmit(tx_port)
drone.stopCapture(rx_port)
log.info('getting Rx capture buffer')
buff = drone.getCaptureBuffer(rx_port.port_id[0])
drone.saveCaptureBuffer(buff, 'capture.pcap')
log.info('dumping Rx capture buffer')
cap_pkts = subprocess.check_output([tshark, '-n', '-r', 'capture.pcap',
'-R', 'udp && frame.len==60',
'-o', fmt.replace('XXX', 'data.data')])
print(cap_pkts)
result = extract_column(cap_pkts, fmt_col)
expected = ['000000000000', '000000010000', '000000020000',
'000000030000', '000000040000', '000000050000',
'000000060000', '000000070000', '000000080000',
'000000090000']
log.info('result : %s' % result)
log.info('expected: %s' % expected)
if result == expected and 'Error' not in cap_pkts:
passed = True
os.remove('capture.pcap')
except RpcError as e:
raise
finally:
drone.stopTransmit(tx_port)
s.core.frame_len = 128 # restore frame length
suite.test_end(passed)
# ----------------------------------------------------------------- #
# TESTCASE: Verify increment counter32 variable field affecting
# TCP checksum - TCP seq
# ----------------------------------------------------------------- #
# setup stream protocols as mac:eth2:ip4:tcp:payload
s.ClearField("protocol")
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kMacFieldNumber
p.Extensions[mac].dst_mac = 0x001122334455
p.Extensions[mac].src_mac = 0x00aabbccddee
s.protocol.add().protocol_id.id = ost_pb.Protocol.kEth2FieldNumber
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kIp4FieldNumber
p.Extensions[ip4].src_ip = 0x01020304
p.Extensions[ip4].dst_ip = 0x05060708
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kTcpFieldNumber
Feature (contd.): Variable Fields - renamed variable_fields as singular; this makes it consistent with other repeated variables in protocol.proto and in any case the C++/Python generated code "sounds" better with a repeated field named in its singular form, rather than plural
2015-05-31 09:44:32 -05:00
vf = p.variable_field.add()
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
vf.type = ost_pb.VariableField.kCounter32
vf.offset = 4
vf.value = 1000
vf.mode = ost_pb.VariableField.kIncrement
vf.count = 5
vf.step = 5
s.protocol.add().protocol_id.id = ost_pb.Protocol.kPayloadFieldNumber
log.info('configuring tx_stream %d' % stream_id.stream_id[0].id)
drone.modifyStream(stream_cfg)
# clear tx/rx stats
log.info('clearing tx/rx stats')
drone.clearStats(tx_port)
drone.clearStats(rx_port)
passed = False
suite.test_begin('counter32IncrementTcpCksum[TcpSeq]')
try:
drone.startCapture(rx_port)
drone.startTransmit(tx_port)
log.info('waiting for transmit to finish ...')
time.sleep(3)
drone.stopTransmit(tx_port)
drone.stopCapture(rx_port)
log.info('getting Rx capture buffer')
buff = drone.getCaptureBuffer(rx_port.port_id[0])
drone.saveCaptureBuffer(buff, 'capture.pcap')
log.info('dumping Rx capture buffer')
cap_pkts = subprocess.check_output([tshark, '-n', '-r', 'capture.pcap',
'-R', 'tcp && frame.len==124',
'-o', 'tcp.relative_sequence_numbers:0',
'-o', fmt.replace('XXX', 'tcp.seq')])
print(cap_pkts)
result = extract_column(cap_pkts, fmt_col)
expected = ['1000', '1005', '1010', '1015', '1020',
'1000', '1005', '1010', '1015', '1020']
log.info('result : %s' % result)
log.info('expected: %s' % expected)
if result == expected and 'Error' not in cap_pkts:
passed = True
os.remove('capture.pcap')
except RpcError as e:
raise
finally:
drone.stopTransmit(tx_port)
suite.test_end(passed)
# ----------------------------------------------------------------- #
# TESTCASE: Verify increment counter16 variable field affecting
# ICMP checksum - ICMP seq
# ----------------------------------------------------------------- #
# setup stream protocols as mac:eth2:ip4:icmp:payload
s.ClearField("protocol")
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kMacFieldNumber
p.Extensions[mac].dst_mac = 0x001122334455
p.Extensions[mac].src_mac = 0x00aabbccddee
s.protocol.add().protocol_id.id = ost_pb.Protocol.kEth2FieldNumber
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kIp4FieldNumber
p.Extensions[ip4].src_ip = 0x01020304
p.Extensions[ip4].dst_ip = 0x05060708
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kIcmpFieldNumber
p.Extensions[icmp].identifier = 0xabcd
Feature (contd.): Variable Fields - renamed variable_fields as singular; this makes it consistent with other repeated variables in protocol.proto and in any case the C++/Python generated code "sounds" better with a repeated field named in its singular form, rather than plural
2015-05-31 09:44:32 -05:00
vf = p.variable_field.add()
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
vf.type = ost_pb.VariableField.kCounter16
vf.offset = 6
vf.value = 1
vf.count = 10
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kPayloadFieldNumber
p.Extensions[payload].pattern_mode = Payload.e_dp_inc_byte
log.info('configuring tx_stream %d' % stream_id.stream_id[0].id)
drone.modifyStream(stream_cfg)
# clear tx/rx stats
log.info('clearing tx/rx stats')
drone.clearStats(tx_port)
drone.clearStats(rx_port)
passed = False
suite.test_begin('counter16IncrementIcmpCksum[IcmpSeq]')
try:
drone.startCapture(rx_port)
drone.startTransmit(tx_port)
log.info('waiting for transmit to finish ...')
time.sleep(3)
drone.stopTransmit(tx_port)
drone.stopCapture(rx_port)
log.info('getting Rx capture buffer')
buff = drone.getCaptureBuffer(rx_port.port_id[0])
drone.saveCaptureBuffer(buff, 'capture.pcap')
log.info('dumping Rx capture buffer')
cap_pkts = subprocess.check_output([tshark, '-n', '-r', 'capture.pcap',
'-R', 'icmp && frame.len==124',
'-o', fmt.replace('XXX', 'icmp.seq')])
print(cap_pkts)
result = extract_column(cap_pkts, fmt_col)
expected = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
log.info('result : %s' % result)
log.info('expected: %s' % expected)
if result == expected and 'Error' not in cap_pkts:
passed = True
os.remove('capture.pcap')
except RpcError as e:
raise
finally:
drone.stopTransmit(tx_port)
suite.test_end(passed)
# ----------------------------------------------------------------- #
# TESTCASE: Verify xcrement counter16 variable fields affecting
# UDP checksum - UDP src/dst port
# ----------------------------------------------------------------- #
# setup stream protocols as mac:eth2:ip6:udp:payload
s.ClearField("protocol")
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kMacFieldNumber
p.Extensions[mac].dst_mac = 0x001122334455
p.Extensions[mac].src_mac = 0x00aabbccddee
s.protocol.add().protocol_id.id = ost_pb.Protocol.kEth2FieldNumber
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kIp6FieldNumber
ip = p.Extensions[ip6]
ip.src_addr_hi = 0x2002000000000000
ip.src_addr_lo = 0x1001
ip.dst_addr_hi = 0x4004000000000000
ip.dst_addr_lo = 0x1001
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kUdpFieldNumber
Feature (contd.): Variable Fields - renamed variable_fields as singular; this makes it consistent with other repeated variables in protocol.proto and in any case the C++/Python generated code "sounds" better with a repeated field named in its singular form, rather than plural
2015-05-31 09:44:32 -05:00
vf = p.variable_field.add()
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
vf.type = ost_pb.VariableField.kCounter16
vf.offset = 0
vf.value = 5000
vf.mode = ost_pb.VariableField.kIncrement
vf.count = 10
Feature (contd.): Variable Fields - renamed variable_fields as singular; this makes it consistent with other repeated variables in protocol.proto and in any case the C++/Python generated code "sounds" better with a repeated field named in its singular form, rather than plural
2015-05-31 09:44:32 -05:00
vf = p.variable_field.add()
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
vf.type = ost_pb.VariableField.kCounter16
vf.offset = 2
vf.value = 6000
vf.mode = ost_pb.VariableField.kDecrement
vf.count = 10
s.protocol.add().protocol_id.id = ost_pb.Protocol.kPayloadFieldNumber
log.info('configuring tx_stream %d' % stream_id.stream_id[0].id)
drone.modifyStream(stream_cfg)
# clear tx/rx stats
log.info('clearing tx/rx stats')
drone.clearStats(tx_port)
drone.clearStats(rx_port)
passed = False
suite.test_begin('counter16XcrementUdpCksum[UdpSrcDstPort]')
try:
drone.startCapture(rx_port)
drone.startTransmit(tx_port)
log.info('waiting for transmit to finish ...')
time.sleep(3)
drone.stopTransmit(tx_port)
drone.stopCapture(rx_port)
log.info('getting Rx capture buffer')
buff = drone.getCaptureBuffer(rx_port.port_id[0])
drone.saveCaptureBuffer(buff, 'capture.pcap')
log.info('dumping Rx capture buffer')
cap_pkts = subprocess.check_output([tshark, '-n', '-r', 'capture.pcap',
'-R', 'udp && frame.len==124',
'-o', fmt2.replace('XXX', 'udp.srcport', 1)
.replace('XXX', 'udp.dstport')])
print(cap_pkts)
result1 = extract_column(cap_pkts, fmt_col)
expected1 = ['5000', '5001', '5002', '5003', '5004',
'5005', '5006', '5007', '5008', '5009']
log.info('result1 : %s' % result1)
log.info('expected1: %s' % expected1)
result2 = extract_column(cap_pkts, fmt_col+1)
expected2 = ['6000', '5999', '5998', '5997', '5996',
'5995', '5994', '5993', '5992', '5991']
log.info('result2 : %s' % result2)
log.info('expected2: %s' % expected2)
if result1 == expected1 and result2 == expected2 \
and 'Error' not in cap_pkts:
passed = True
os.remove('capture.pcap')
except RpcError as e:
raise
finally:
drone.stopTransmit(tx_port)
suite.test_end(passed)
# ----------------------------------------------------------------- #
# TESTCASE: Verify multiple Xcrement counterX variable fields affecting
# IP, UDP checksum - VlanId, SrcIp, TcpDstPort, PayloadSeq
# ----------------------------------------------------------------- #
s.core.frame_len = 64
# setup stream protocols as mac:vlan:eth2:ip4:udp:payload
s.ClearField("protocol")
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kMacFieldNumber
p.Extensions[mac].dst_mac = 0x001122334455
p.Extensions[mac].src_mac = 0x00aabbccddee
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kVlanFieldNumber
Feature (contd.): Variable Fields - renamed variable_fields as singular; this makes it consistent with other repeated variables in protocol.proto and in any case the C++/Python generated code "sounds" better with a repeated field named in its singular form, rather than plural
2015-05-31 09:44:32 -05:00
vf = p.variable_field.add()
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
vf.type = ost_pb.VariableField.kCounter16
vf.offset = 2
vf.value = 3
vf.mask = 0x0FFF
vf.mode = ost_pb.VariableField.kDecrement
vf.count = 10
s.protocol.add().protocol_id.id = ost_pb.Protocol.kEth2FieldNumber
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kIp4FieldNumber
p.Extensions[ip4].src_ip = 0x01020304
p.Extensions[ip4].dst_ip = 0x05060708
Feature (contd.): Variable Fields - renamed variable_fields as singular; this makes it consistent with other repeated variables in protocol.proto and in any case the C++/Python generated code "sounds" better with a repeated field named in its singular form, rather than plural
2015-05-31 09:44:32 -05:00
vf = p.variable_field.add()
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
vf.type = ost_pb.VariableField.kCounter32
vf.offset = 12
vf.mask = 0x0000ff00
vf.value = 0x00000100
vf.mode = ost_pb.VariableField.kIncrement
vf.count = 10
Feature (contd.): Variable Fields - fixed the code to use 'step' while varying fields which was missed out earlier. Updated the test suite and made sure all test cases pass
2015-05-31 07:32:06 -05:00
vf.step = 0x00000100
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kTcpFieldNumber
Feature (contd.): Variable Fields - renamed variable_fields as singular; this makes it consistent with other repeated variables in protocol.proto and in any case the C++/Python generated code "sounds" better with a repeated field named in its singular form, rather than plural
2015-05-31 09:44:32 -05:00
vf = p.variable_field.add()
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
vf.type = ost_pb.VariableField.kCounter16
vf.offset = 2
vf.value = 6666
vf.mode = ost_pb.VariableField.kDecrement
vf.count = 10
p = s.protocol.add()
p.protocol_id.id = ost_pb.Protocol.kPayloadFieldNumber
Feature (contd.): Variable Fields - renamed variable_fields as singular; this makes it consistent with other repeated variables in protocol.proto and in any case the C++/Python generated code "sounds" better with a repeated field named in its singular form, rather than plural
2015-05-31 09:44:32 -05:00
vf = p.variable_field.add()
Feature (contd.): Variable fields - filled in the placeholder with the actual test suite; some tests are failing - need to fix the code
2015-05-30 02:56:14 -05:00
vf.type = ost_pb.VariableField.kCounter8
vf.offset = 0
vf.mode = ost_pb.VariableField.kIncrement
vf.count = 10
log.info('configuring tx_stream %d' % stream_id.stream_id[0].id)
drone.modifyStream(stream_cfg)
# clear tx/rx stats
log.info('clearing tx/rx stats')
drone.clearStats(tx_port)
drone.clearStats(rx_port)
passed = False
suite.test_begin('counterXcrementIpTcpCksum[Multiple]')
try:
drone.startCapture(rx_port)
drone.startTransmit(tx_port)
log.info('waiting for transmit to finish ...')
time.sleep(3)
drone.stopTransmit(tx_port)
drone.stopCapture(rx_port)
log.info('getting Rx capture buffer')
buff = drone.getCaptureBuffer(rx_port.port_id[0])
drone.saveCaptureBuffer(buff, 'capture.pcap')
log.info('dumping Rx capture buffer')
cap_pkts = subprocess.check_output([tshark, '-n', '-r', 'capture.pcap',
'-R', 'tcp && frame.len==60',
'-o', fmt4.replace('XXX', 'vlan.id', 1)
.replace('XXX', 'ip.src', 1)
.replace('XXX', 'tcp.dstport', 1)
.replace('XXX', 'data.data', 1)])
print(cap_pkts)
result = []
expected = []
expected.append(['3', '2', '1', '0', '4095',
'4094', '4093', '4092', '4091', '4090'])
expected.append(['1.2.1.4', '1.2.2.4', '1.2.3.4', '1.2.4.4', '1.2.5.4',
'1.2.6.4', '1.2.7.4', '1.2.8.4', '1.2.9.4', '1.2.10.4'])
expected.append(['6666', '6665', '6664', '6663', '6662',
'6661', '6660', '6659', '6658', '6657'])
expected.append(['0000', '0100', '0200', '0300', '0400',
'0500', '0600', '0700', '0800', '0900'])
passed = True
for i in range(4):
result.append(extract_column(cap_pkts, fmt_col+i))
log.info('result[%d] : %s' % (i, result[i]))
log.info('expected[%d]: %s' % (i, expected[i]))
if result[i] != expected[i]:
passed = False
if 'Error' in cap_pkts:
passed = False
os.remove('capture.pcap')
except RpcError as e:
raise
finally:
drone.stopTransmit(tx_port)
s.core.frame_len = 128
suite.test_end(passed)
Feature: Variable Fields - any field of any protocol can now be varied by specifying it as a generic 8/16/32 bit field at a specified offset (relative to the protocol frame value) with a certain mask and a (initial) value alongwith count and step; this is working code - but incomplete. Bunch of FIXME/TODOs and testing pending
2015-05-26 11:13:37 -05:00
suite.complete()
# delete streams
log.info('deleting tx_stream %d' % stream_id.stream_id[0].id)
drone.deleteStream(stream_id)
# bye for now
drone.disconnect()
except Exception as ex:
log.exception(ex)
finally:
suite.report()
if not suite.passed:
sys.exit(2);
Reference in New Issue Copy Permalink