def record(packets: Iterable[Packet],
pcap_path: str,
*,
src_ip: str = "127.0.0.1",
dst_ip: str = "127.0.0.1",
lidar_port: int = 7502,
imu_port: int = 7503,
use_sll_encapsulation: bool = False) -> int:
"""Record a sequence of sensor packets to a pcap file.
Args:
packets: A (finite!) sequence of packets
pcap_path: Path of the output pcap file
src_ip: Source IP to use for all packets
dst_ip: Destination IP to use for all packets
lidar_port: Src/dst port to use for lidar packets
imu_port: Src/dst port to use for imu packets
use_sll_encapsulation: Use sll encapsulaiton for pcaps(ouster studio can not read)
Returns:
Number of packets captured
"""
has_timestamp = None
error = False
buf_size = 2**16
n = 0
handle = _pcap.record_initialize(pcap_path, src_ip, dst_ip, buf_size,
use_sll_encapsulation)
try:
for packet in packets:
if isinstance(packet, LidarPacket):
src_port = lidar_port
dst_port = lidar_port
elif isinstance(packet, ImuPacket):
src_port = imu_port
dst_port = imu_port
else:
raise ValueError("Unexpected packet type")
if has_timestamp is None:
has_timestamp = (packet.capture_timestamp is not None)
elif has_timestamp != (packet.capture_timestamp is not None):
raise ValueError("Mixing timestamped/untimestamped packets")
ts = packet.capture_timestamp or time.time()
_pcap.record_packet(handle, src_port, dst_port, packet._data, ts)
n += 1
except Exception:
error = True
raise
finally:
_pcap.record_uninitialize(handle)
if error and os.path.exists(pcap_path) and n == 0:
os.remove(pcap_path)
return n
def test_imu_guess_error(metadata, tmpdir):
packets = islice(random_imu_packets(metadata), 2)
file_path = os.path.join(tmpdir, "pcap_test.pcap")
buf_size = 2**16
handle = _pcap.record_initialize(file_path, "127.0.0.1", "127.0.0.1",
buf_size)
try:
_pcap.record_packet(handle, 7502, 7502, (next(packets))._data, 1)
_pcap.record_packet(handle, 7503, 7503, (next(packets))._data, 2)
finally:
_pcap.record_uninitialize(handle)
with pytest.raises(ValueError):
pcap.Pcap(file_path, metadata)
def test_imu_guess_ambiguous(fake_meta, tmpdir) -> None:
"""Test reading when there's more than one possible imu port."""
packets = fake_packets(fake_meta, n_imu=2)
file_path = path.join(tmpdir, "pcap_test.pcap")
buf_size = 2**16
handle = _pcap.record_initialize(file_path, "127.0.0.1", "127.0.0.1",
buf_size)
try:
_pcap.record_packet(handle, 7502, 7502, (next(packets))._data, 1)
_pcap.record_packet(handle, 7503, 7503, (next(packets))._data, 2)
finally:
_pcap.record_uninitialize(handle)
source = pcap.Pcap(file_path, fake_meta)
assert len(source._guesses) > 1
assert source.ports == (0, 7503) # arbitrary but deterministic
assert len(list(source)) == 1
def record(packets: Iterable[Packet],
pcap_path: str,
*,
src_ip: str = "127.0.0.1",
dst_ip: str = "127.0.0.1",
lidar_port: int = 7502,
imu_port: int = 7503) -> int:
"""Record a sequence of sensor packets to a pcap file.
Args:
packets: A (finite!) sequence of packets
pcap_path: Path of the output pcap file
src_ip: Source IP to use for all packets
dst_ip: Destination IP to use for all packets
lidar_port: Src/dst port to use for lidar packets
imu_port: Src/dst port to use for imu packets
Returns:
Number of packets captured
"""
buf_size = 2**16
n = 0
handle = _pcap.record_initialize(pcap_path, src_ip, dst_ip, buf_size)
try:
for packet in packets:
if isinstance(packet, LidarPacket):
src_port = lidar_port
dst_port = lidar_port
elif isinstance(packet, ImuPacket):
src_port = imu_port
dst_port = imu_port
else:
raise ValueError("Unexpected packet type")
_pcap.record_packet(handle, src_port, dst_port, packet._data)
n += 1
finally:
_pcap.record_uninitialize(handle)
return n
def write_test_pcap(test_file,
total_complete_packets,
total_size,
frag_size,
port,
dst_port,
record=None):
'''Write bitpatterns of the specified size to a pcap file.
Args:
test_file: The output file to record pcap to
total_complete_packets: The total number of completed packets to record
total_size: The number of bytes to record
frag_size: The fragmentation size in bytes
port: The port to record to
dst_port: The target port to record to
record: If we have a previous record object, dont recreate it
'''
if record is None:
record = _pcap.record_initialize(test_file, "127.0.0.1", "127.0.0.1",
frag_size)
frag_size = min(frag_size, total_size)
frags = max(int(total_size / frag_size), 1)
result = []
for i in range(0, total_complete_packets):
data_out = []
for j in range(0, frags):
data_out.append(i)
data_out.append(j)
for k in range(0, (frag_size - 2)):
data_out.append(k % 255)
_pcap.record_packet(record, port, dst_port, bytearray(data_out))
result.extend(data_out)
result.extend([0 for x in range(len(result), (i + 1) * total_size)])
return (bytearray(result), record)