def test_task04(riot_ctrl):
pinger, pinged = (
riot_ctrl(0, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
riot_ctrl(1, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
)
pinged_netif, pinged_addr = lladdr(pinged.ifconfig_list())
pinged.ifconfig_set(pinged_netif, "channel", 26)
assert pinged_addr.startswith("fe80::")
pinger_netif, _ = lladdr(pinger.ifconfig_list())
pinger.ifconfig_set(pinger_netif, "channel", 26)
# enforce reconnect to pinged's terminal as connection to it in the IoT-LAB
# sometimes get's lost silently in the CI after the 15 min of pinging
# see https://github.com/RIOT-OS/Release-Specs/issues/189
pinged.stop_term()
res = ping6(pinger,
pinged_addr,
count=10000,
interval=100,
packet_size=100)
assert res['stats']['packet_loss'] < 10
pinged.start_term()
assert pktbuf(pinged).is_empty()
assert pktbuf(pinger).is_empty()
def test_task09(riot_ctrl):
nodes = (
riot_ctrl(0, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
riot_ctrl(1, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
riot_ctrl(2, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
)
pinged = nodes[0]
pingers = nodes[1:]
pinged_netif, pinged_addr = lladdr(pinged.ifconfig_list())
pinged.ifconfig_set(pinged_netif, "channel", 26)
assert pinged_addr.startswith("fe80::")
for pinger in pingers:
pinger_netif, _ = lladdr(pinger.ifconfig_list())
pinger.ifconfig_set(pinger_netif, "channel", 26)
futures = []
for pinger in nodes[1:]:
out = pinger.ping6(pinged_addr,
count=200,
interval=0,
packet_size=1232,
async_=True)
futures.append(out)
wait_for_futures(futures)
time.sleep(60)
for node in nodes:
# add print to know which node's packet buffer is not empty on error
print("check pktbuf on", node.riotctrl.env.get("PORT"))
assert pktbuf(node).is_empty()
def test_task11(riot_ctrl):
try:
nodes = (
riot_ctrl(0, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
riot_ctrl(1, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
riot_ctrl(2, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
)
except subprocess.CalledProcessError:
pytest.xfail(
"Experimental task. See also "
# pylint: disable=C0301
"https://github.com/RIOT-OS/Release-Specs/pull/198#issuecomment-758522278" # noqa: E501
)
pinged = nodes[0]
pingers = nodes[1:]
pinged_netif, pinged_addr = lladdr(pinged.ifconfig_list())
pinged.ifconfig_set(pinged_netif, "channel", 26)
assert pinged_addr.startswith("fe80::")
for pinger in pingers:
pinger_netif, _ = lladdr(pinger.ifconfig_list())
pinger.ifconfig_set(pinger_netif, "channel", 26)
futures = []
for pinger in nodes[1:]:
out = pinger.ping6(pinged_addr,
count=200,
interval=0,
packet_size=1232,
async_=True)
futures.append(out)
wait_for_futures(futures)
check_pktbuf(*nodes)
def test_task09(riot_ctrl):
nodes = (
riot_ctrl(0, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
riot_ctrl(1, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
riot_ctrl(2, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
)
pinged = nodes[0]
pingers = nodes[1:]
pinged_netif, pinged_addr = lladdr(pinged.ifconfig_list())
pinged.ifconfig_set(pinged_netif, "channel", 26)
assert pinged_addr.startswith("fe80::")
for pinger in pingers:
pinger_netif, _ = lladdr(pinger.ifconfig_list())
pinger.ifconfig_set(pinger_netif, "channel", 26)
futures = []
for pinger in nodes[1:]:
out = pinger.ping6(pinged_addr,
count=200,
interval=0,
packet_size=1232,
async_=True)
futures.append(out)
wait_for_futures(futures)
check_pktbuf(*nodes)
def test_task10(riot_ctrl):
pinger, pinged = (
riot_ctrl(0, TASK10_APP, Shell, modules=["gnrc_pktbuf_cmd"]),
riot_ctrl(1, TASK10_APP, Shell, modules=["gnrc_pktbuf_cmd"]),
)
pinged_netif, pinged_addr = lladdr(pinged.ifconfig_list())
pinged.ifconfig_set(pinged_netif, "channel", 26)
assert pinged_addr.startswith("fe80::")
pinger_netif, _ = lladdr(pinger.ifconfig_list())
pinger.ifconfig_set(pinger_netif, "channel", 26)
res = ping6(pinger, pinged_addr,
count=200, interval=600, packet_size=2048)
if 10 < res['stats']['packet_loss'] <= 100:
pytest.xfail(
"Experimental task. See also "
# pylint: disable=C0301
"https://github.com/RIOT-OS/Release-Specs/issues/142#issuecomment-561677974" # noqa: E501
)
assert res['stats']['packet_loss'] < 10
time.sleep(60)
assert pktbuf(pinged).is_empty()
assert pktbuf(pinger).is_empty()
def test_task05(riot_ctrl):
pinger, pinged = (
riot_ctrl(0, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
riot_ctrl(1, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
)
pinged_netif, _ = lladdr(pinged.ifconfig_list())
pinged.ifconfig_set(pinged_netif, "channel", 17)
pinger_netif, _ = lladdr(pinger.ifconfig_list())
pinger.ifconfig_set(pinger_netif, "channel", 17)
res = ping6(pinger, "ff02::1", count=1000, interval=100, packet_size=50)
assert res['stats']['packet_loss'] < 10
assert pktbuf(pinged).is_empty()
assert pktbuf(pinger).is_empty()
def test_task05(nodes, riot_ctrl):
nodes = [
riot_ctrl(i, APP, Shell, port='tap{}'.format(i))
for i in range(len(nodes))
]
async def finish_task05(pinger, future):
await future
print(pinger.riotctrl.env.get("PORT"), "done")
_, pinged_addr = lladdr(nodes[0].ifconfig_list())
assert pinged_addr.startswith("fe80::")
futures = []
for pinger in nodes[1:]:
out = pinger.ping6(pinged_addr,
count=100000, interval=0, packet_size=1452,
async_=True)
futures.append(finish_task05(pinger, out))
wait_for_futures(futures)
time.sleep(120)
for node in reversed(nodes):
# add print to know which node's packet buffer is not empty on error
print("check pktbuf on", node.riotctrl.env.get("PORT"))
assert pktbuf(node).is_empty()
def test_task05(riot_ctrl):
node = riot_ctrl(0, 'examples/gcoap', Shell, port=TAP)
node_netif, _ = lladdr(node.ifconfig_list())
node.ifconfig_add(node_netif, NODE_ULA)
responses = []
async def client_server(host):
context = await coap_server()
# pylint: disable=E1101
msg = aiocoap.Message(code=aiocoap.GET,
uri='coap://{0}/cli/stats'.format(host),
observe=0)
req = context.request(msg)
resp = await req.response
responses.append(resp)
res = node.coap_get(HOST_ULA, 5683, "/time", confirmable=True)
assert re.search(r"gcoap_cli: sending msg ID \d+, \d+ bytes", res)
async for resp in req.observation:
responses.append(resp)
req.observation.cancel()
break
await context.shutdown()
timeout_futures([client_server('[{}]'.format(NODE_ULA))], timeout=2)
node.riotctrl.term.expect(r"gcoap: response Success, code 2.05, \d+ bytes")
assert len(responses) == 2
for i, response in enumerate(responses):
assert str(response.code) == "2.05 Content"
assert int(response.payload) == i
def test_task01(riot_ctrl, log_nodes):
node = riot_ctrl(0, 'examples/cord_ep', Shell, port=TAP)
node_netif, _ = lladdr(node.ifconfig_list())
node.ifconfig_add(node_netif, NODE_ULA)
aiocoap_rd = subprocess.Popen(
["aiocoap-rd"],
stdout=None if log_nodes else subprocess.DEVNULL,
stderr=None if log_nodes else subprocess.DEVNULL,
)
try:
res = node.cord_ep_register(HOST_ULA)
parser = CordEPRegisterParser()
core_reg = parser.parse(res)
if core_reg["ltime"] > 300:
pytest.xfail("CoRE RD lifetime is configured for {}s (> 5min). "
"That's way to long for a test!".format(
core_reg["ltiem"]))
time.sleep(core_reg["ltime"])
finally:
aiocoap_rd.terminate()
aiocoap_rd.wait()
node.riotctrl.term.expect_exact(
"RD endpoint event: successfully updated client registration", )
def statically_routed_nodes(riot_ctrl):
nodes = (
riot_ctrl(0, APP, Shell),
riot_ctrl(1, APP, Shell),
riot_ctrl(2, APP, Shell),
riot_ctrl(3, APP, Shell),
)
lladdrs = [
dict(zip(("netif", "lladdr"), lladdr(node.ifconfig_list())))
for node in nodes
]
from_addr = FROM_ADDR + "/64"
to_addr = TO_ADDR + "/64"
nodes[0].ifconfig_add(lladdrs[0]["netif"], from_addr)
nodes[-1].ifconfig_add(lladdrs[-1]["netif"], to_addr)
for i, node in enumerate(nodes):
if i < (len(nodes) - 1):
# set to-route
node.nib_route_add(lladdrs[i]["netif"], to_addr,
lladdrs[i + 1]["lladdr"])
if i > 0:
# set from-route
node.nib_route_add(lladdrs[i]["netif"], from_addr,
lladdrs[i - 1]["lladdr"])
return nodes
def test_task08(riot_ctrl):
gnrc_node, lwip_node = (
riot_ctrl(0, GNRC_APP, Shell),
riot_ctrl(1, LWIP_APP, riotctrl.shell.ShellInteraction),
)
_, gnrc_addr = lladdr(gnrc_node.ifconfig_list())
assert gnrc_addr.startswith("fe80::")
res = lwip_node.cmd("ifconfig")
m = re.search(r"inet6\s+(?P<addr>fe80:[0-9a-f:]+)", res)
assert m is not None
lwip_addr = m.group("addr")
gnrc_node.udp_server_start(61616)
lwip_node.cmd("udp send [{gnrc_addr}]:61616 012345678abcdef".format(
gnrc_addr=gnrc_addr))
packet_loss = gnrc_node.udp_server_check_output(count=1, delay_ms=0)
assert packet_loss == 0
gnrc_node.udp_server_stop()
lwip_node.cmd("udp server start 61617")
gnrc_node.udp_client_send(lwip_addr, 61617, "01234567")
lwip_node.riotctrl.term.expect_exact(
"Received UDP data from [{}]:61617".format(gnrc_addr))
lwip_node.riotctrl.term.expect_exact(
"00000000 " + " ".join(hex(ord(c))[2:] for c in "01234567"),
timeout=3)
def test_task04(riot_ctrl, log_nodes):
node = riot_ctrl(0, APP, Shell, port='tap0')
pingers = [pexpect.replwrap.bash() for _ in range(10)]
_, pinged_addr = lladdr(node.ifconfig_list())
assert pinged_addr.startswith("fe80::")
iface = bridge('tap0')
pinged_addr += "%{}".format(iface)
ping_cmd = get_ping_cmd()
futures = []
try:
for pinger in pingers:
if log_nodes:
pinger.child.logfile = sys.stdout
out = pinger.run_command(
"{ping_cmd} -f -s 1452 {pinged_addr}"
# pipe to /dev/null because output can go
# into MiB of data ;-)
" 2>&1 > /dev/null".format(ping_cmd=ping_cmd,
pinged_addr=pinged_addr),
async_=True,
timeout=60 * 60)
futures.append(out)
timeout_futures(futures, 60 * 60)
finally:
for pinger in pingers:
# interrupt prevailing `ping6`s
pinger.child.sendintr()
check_pktbuf(node)
def test_task01(riot_ctrl, log_nodes):
node = riot_ctrl(0, GNRC_APP, Shell, port='tap0')
linux = pexpect.replwrap.bash()
node_iface, node_addr = lladdr(node.ifconfig_list())
assert node_addr.startswith("fe80::")
linux_iface = bridge('tap0')
linux_addr = get_link_local(linux_iface)
assert linux_addr.startswith("fe80::")
ping_cmd = get_ping_cmd()
if log_nodes:
linux.child.logfile = sys.stdout
out = linux.run_command(
"{ping_cmd} -c 20 -i .5 {node_addr}%{linux_iface}".format(
ping_cmd=ping_cmd, node_addr=node_addr, linux_iface=linux_iface),
timeout=20)
m = re.search(r"\b(\d+)% packet loss", out)
assert m is not None
assert int(m.group(1)) < 1
res = ping6(node,
"{}%{}".format(linux_addr, node_iface),
count=20,
interval=100,
packet_size=8)
assert res["stats"]["packet_loss"] < 1
def test_task06(riot_ctrl):
pinger, pinged = (
riot_ctrl(0, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
riot_ctrl(1, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
)
pinged_netif, pinged_addr = lladdr(pinged.ifconfig_list())
pinged.ifconfig_set(pinged_netif, "channel", 26)
assert pinged_addr.startswith("fe80::")
pinger_netif, _ = lladdr(pinger.ifconfig_list())
pinger.ifconfig_set(pinger_netif, "channel", 26)
res = ping6(pinger, pinged_addr, count=1000, interval=100, packet_size=100)
assert res['stats']['packet_loss'] < 10
assert pktbuf(pinged).is_empty()
assert pktbuf(pinger).is_empty()
def test_task02(riot_ctrl):
pinger, pinged = (
riot_ctrl(0, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
riot_ctrl(1, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
)
pinged_netif, pinged_lladdr = lladdr(pinged.ifconfig_list())
pinged.ifconfig_add(pinged_netif, "beef::1/64")
pinger_netif, pinger_lladdr = lladdr(pinger.ifconfig_list())
pinger.ifconfig_add(pinger_netif, "affe::1/120")
pinged.nib_route_add(pinged_netif, "::", pinger_lladdr)
pinger.nib_route_add(pinger_netif, "::", pinged_lladdr)
res = ping6(pinger, "beef::1", count=100, interval=300, packet_size=1024)
assert res['stats']['packet_loss'] < 10
check_pktbuf(pinged, pinger)
def test_task03(riot_ctrl):
pinger, pinged = (
riot_ctrl(0, APP, Shell, modules=["gnrc_pktbuf_cmd"], port="tap0"),
riot_ctrl(1, APP, Shell, modules=["gnrc_pktbuf_cmd"], port="tap1"),
)
pinged_netif, pinged_lladdr = lladdr(pinged.ifconfig_list())
pinged.ifconfig_flag(pinged_netif, "rtr_adv", False)
pinged.ifconfig_add(pinged_netif, "beef::1/64")
pinger_netif, pinger_lladdr = lladdr(pinger.ifconfig_list())
pinger.ifconfig_flag(pinger_netif, "rtr_adv", False)
pinger.ifconfig_add(pinger_netif, "beef::2/64")
pinged.nib_route_add(pinged_netif, "beef::/64", pinger_lladdr)
pinger.nib_route_add(pinger_netif, "beef::/64", pinged_lladdr)
res = ping6(pinger, "beef::1", count=10, interval=10, packet_size=1024)
assert res['stats']['packet_loss'] < 1
check_pktbuf(pinged, pinger)
def test_task12(riot_ctrl):
try:
pinger, pinged = (
riot_ctrl(0, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
riot_ctrl(1, APP, Shell, modules=["gnrc_pktbuf_cmd"]),
)
except subprocess.CalledProcessError:
pytest.xfail(
"Experimental task. See also "
# pylint: disable=C0301
"https://github.com/RIOT-OS/Release-Specs/pull/198#issuecomment-758522278" # noqa: E501
)
pinged_netif, _ = lladdr(pinged.ifconfig_list())
pinged.ifconfig_set(pinged_netif, "channel", 17)
pinger_netif, _ = lladdr(pinger.ifconfig_list())
pinger.ifconfig_set(pinger_netif, "channel", 17)
res = ping6(pinger, "ff02::1", count=1000, interval=100, packet_size=50)
assert res['stats']['packet_loss'] < 10
check_pktbuf(pinged, pinger)
def test_task06(riot_ctrl):
nodes = (
riot_ctrl(0, APP, Shell),
riot_ctrl(1, APP, Shell),
)
for client, server in zip(nodes, reversed(nodes)):
server_netif, server_addr = lladdr(server.ifconfig_list())
server.ifconfig_set(server_netif, "channel", 26)
assert server_addr.startswith("fe80::")
client_netif, _ = lladdr(client.ifconfig_list())
client.ifconfig_set(client_netif, "channel", 26)
server.udp_server_start(1337)
client.udp_client_send(server_addr, 1337, count=100,
delay_ms=100, payload=0)
packet_loss = server.udp_server_check_output(count=100, delay_ms=100)
assert packet_loss <= 10
server.udp_server_stop()
assert pktbuf(nodes[0]).is_empty()
assert pktbuf(nodes[1]).is_empty()
def test_task03(riot_ctrl):
pinger, pinged = (
riot_ctrl(0, APP, Shell, port='tap0'),
riot_ctrl(1, APP, Shell, port='tap1'),
)
_, pinged_addr = lladdr(pinged.ifconfig_list())
assert pinged_addr.startswith("fe80::")
res = ping6(pinger, pinged_addr,
count=3600, interval=1000, packet_size=1024)
assert res['stats']['packet_loss'] < 1
assert pktbuf(pinged).is_empty()
assert pktbuf(pinger).is_empty()
def test_task02(riot_ctrl, start_server, expected):
node = riot_ctrl(0, 'examples/gcoap', Shell, port=TAP)
node_netif, _ = lladdr(node.ifconfig_list())
node.ifconfig_add(node_netif, NODE_ULA)
res = node.coap_get(HOST_ULA, 5683, "/time", confirmable=True)
time.sleep(1)
if start_server:
# kill server after 10 seconds, then it has enough time to respond to
# first retry
timeout_futures([coap_server()], timeout=10)
res = node.riotctrl.term.expect([
r"gcoap: timeout for msg ID \d+",
r"gcoap: response Success, code 2.05, \d+ bytes",
], timeout=100)
assert res == expected
def test_task06(riot_ctrl):
pinger, pinged = (
riot_ctrl(0, APP, Shell, port='tap0'),
riot_ctrl(1, APP, Shell, port='tap1'),
)
_, pinged_addr = lladdr(pinged.ifconfig_list())
assert pinged_addr.startswith("fe80::")
res = ping6(pinger, pinged_addr,
count=1000, interval=100, packet_size=2048)
if 1 <= res['stats']['packet_loss'] < 100:
pytest.xfail("1 <= packet_loss < 100; "
"this test is prone to fail in CI.")
assert res['stats']['packet_loss'] < 1
time.sleep(60)
assert pktbuf(pinged).is_empty()
assert pktbuf(pinger).is_empty()
def test_task05(riot_ctrl):
nodes = (
riot_ctrl(0, APP, Shell, port="tap0"),
riot_ctrl(1, APP, Shell, port="tap1"),
)
for client, server in zip(nodes, reversed(nodes)):
_, server_addr = lladdr(server.ifconfig_list())
assert server_addr.startswith("fe80::")
server.udp_server_start(1337)
client.udp_client_send(server_addr, 1337, count=100,
delay_ms=100, payload=0)
packet_loss = server.udp_server_check_output(count=100, delay_ms=100)
assert packet_loss <= 10
server.udp_server_stop()
assert pktbuf(nodes[0]).is_empty()
assert pktbuf(nodes[1]).is_empty()
def test_task05(nodes, riot_ctrl):
nodes = [
riot_ctrl(i, APP, Shell, port='tap{}'.format(i))
for i in range(len(nodes))
]
async def finish_task05(pinger, future):
await future
print(pinger.riotctrl.env.get("PORT"), "done")
_, pinged_addr = lladdr(nodes[0].ifconfig_list())
assert pinged_addr.startswith("fe80::")
futures = []
for pinger in nodes[1:]:
out = pinger.ping6(pinged_addr,
count=100000,
interval=0,
packet_size=1452,
async_=True)
futures.append(finish_task05(pinger, out))
wait_for_futures(futures)
check_pktbuf(*nodes)
