def test_event_groups(self):
with monitor.object_monitor(
timeout=self.TIMEOUT, groups=('ipv4-ifaddr',)
) as mon_a:
with monitor.object_monitor(
timeout=self.TIMEOUT, groups=('link', 'ipv4-route')
) as mon_l_r:
with dummy_device() as dummy:
Interface.from_existing_dev_name(dummy).add_ip(
IP_ADDRESS, IP_CIDR, IpFamily.IPv4
)
for event in mon_a:
assert '_addr' in event['event'], (
"Caught event '%s' is not "
"related to address." % event['event']
)
for event in mon_l_r:
link_or_route = (
'_link' in event['event'] or '_route' in event['event']
)
assert link_or_route, (
"Caught event '%s' is not related "
"to link or route." % event['event']
)
def _down(self):
with monitor.object_monitor(groups=('link', ), timeout=2) as mon:
linkSet(self.devName, ['down'])
for event in mon:
if (event.get('name') == self.devName
and event.get('state') == 'down'):
return
def _waitForKnownOperstate(device, timeout=1):
with monitor.object_monitor(groups=('link',), timeout=timeout) as mon:
if operstate(device) == OPERSTATE_UNKNOWN:
for event in mon:
if (event['name'] == device and
event['state'] != OPERSTATE_UNKNOWN):
break
def test_stopped(self):
with monitor.object_monitor(timeout=self.TIMEOUT) as mon:
with dummy_device() as dummy:
dummy_name = dummy
found = any(event.get('name') == dummy_name for event in mon)
assert found, 'Expected event was not caught.'
def test_iterate_after_events(self):
with monitor.object_monitor(timeout=self.TIMEOUT) as mon:
with dummy_device() as dummy:
dummy_name = dummy
for event in mon:
if event.get('name') == dummy_name:
break
def wait_for_ipv6(iface, wait_for_scopes=None):
"""Wait for iface to get their IPv6 addresses with netlink Monitor"""
logevents = []
if not wait_for_scopes:
wait_for_scopes = ['global', 'link']
try:
with monitor.object_monitor(groups=('ipv6-ifaddr', ),
timeout=20) as mon:
yield
for event in mon:
logevents.append(event)
dev_name = event.get('label')
if (dev_name == iface and event.get('event') == 'new_addr'
and event.get('scope') in wait_for_scopes):
wait_for_scopes.remove(event.get('scope'))
if not wait_for_scopes:
return
except monitor.MonitorError as e:
if e.args[0] == monitor.E_TIMEOUT:
raise Exception(
'IPv6 addresses has not been caught within 20sec.\n'
'Event log: {}\n'.format(logevents))
else:
raise
def test_iterate_after_events(self):
with monitor.object_monitor(timeout=self.TIMEOUT) as mon:
dummy = Dummy()
dummy_name = dummy.create()
dummy.remove()
for event in mon:
if event.get('name') == dummy_name:
break
def test_stopped(self):
with monitor.object_monitor(timeout=self.TIMEOUT) as mon:
dummy = Dummy()
dummy_name = dummy.create()
dummy.remove()
found = any(event.get('name') == dummy_name for event in mon)
assert found, 'Expected event was not caught.'
def _waitForOperstate(device, state, timeout=1):
""" :param state: please use OPERSTATE_* from lib/vdsm/network/netinfo
"""
with monitor.object_monitor(groups=('link',), timeout=timeout) as mon:
if state != operstate(device):
for event in mon:
if event['name'] == device and event['state'] == state:
break
def test_enable_promisc(self, bridge0):
link = ipwrapper.getLink(bridge0)
with monitor.object_monitor(timeout=2, silent_timeout=True) as mon:
link.promisc = True
for event in mon:
if (event['event'] == 'new_link'
and event.get('flags', 0) & IfaceStatus.IFF_PROMISC):
return
assert False, 'Could not enable promiscuous mode.'
def test_timeout_not_triggered(self):
time_start = monotonic_time()
with monitor.object_monitor(timeout=self.TIMEOUT) as mon:
with dummy_device():
pass
for event in mon:
break
assert (monotonic_time() - time_start) <= self.TIMEOUT
assert mon.is_stopped()
def test_timeout(self):
with pytest.raises(monitor.MonitorError):
try:
with monitor.object_monitor(timeout=0.01) as mon:
for event in mon:
pass
except monitor.MonitorError as e:
assert e.args[0] == monitor.E_TIMEOUT
raise
assert mon.is_stopped()
def test_timeout_not_triggered(self):
time_start = monotonic_time()
with monitor.object_monitor(timeout=self.TIMEOUT) as mon:
dummy = Dummy()
dummy.create()
dummy.remove()
for event in mon:
break
assert (monotonic_time() - time_start) <= self.TIMEOUT
assert mon.is_stopped()
def test_event_groups(self):
with monitor.object_monitor(timeout=self.TIMEOUT,
groups=('ipv4-ifaddr', )) as mon_a:
with monitor.object_monitor(timeout=self.TIMEOUT,
groups=('link',
'ipv4-route')) as mon_l_r:
dummy = Dummy()
dummy.create()
dummy.set_ip(IP_ADDRESS, IP_CIDR)
dummy.up()
dummy.remove()
for event in mon_a:
assert '_addr' in event['event'], ("Caught event '%s' is not "
"related to address." %
event['event'])
for event in mon_l_r:
link_or_route = ('_link' in event['event']
or '_route' in event['event'])
assert link_or_route, ("Caught event '%s' is not related "
"to link or route." % event['event'])
def nonChangingOperstate(device):
"""Raises an exception if it detects that the device link state changes."""
originalState = operstate(device).lower()
try:
with monitor.object_monitor(groups=('link',)) as mon:
yield
finally:
changes = [(event['name'], event['state']) for event in mon
if event['name'] == device]
for _, state in changes:
if state != originalState:
raise OperStateChangedError('%s operstate changed: %s -> %r' %
(device, originalState, changes))
def test_iteration(self):
with monitor.object_monitor(timeout=self.TIMEOUT) as mon:
iterator = iter(mon)
# Generate events to avoid blocking
dummy = Dummy()
dummy.create()
next(iterator)
dummy.remove()
next(iterator)
with pytest.raises(StopIteration):
while True:
next(iterator)
def monitor_stable_link_state(device, wait_for_linkup=True):
"""Raises an exception if it detects that the device link state changes."""
if wait_for_linkup:
with waitfor.waitfor_linkup(device):
pass
iface_properties = iface(device).properties()
original_state = iface_properties['state']
try:
with monitor.object_monitor(groups=('link', )) as mon:
yield
finally:
state_changes = (e['state'] for e in mon if e['name'] == device)
for state in state_changes:
if state != original_state:
raise UnexpectedLinkStateChangeError(
'{} link state changed: {} -> {}'.format(
device, original_state, state))
def test_iterate_while_events(self):
"""Tests if monitor is able to catch event while iterating. Before the
iteration we start _set_and_remove_device, which is delayed for .2
seconds. Then iteration starts and wait for new dummy.
"""
dummy = Dummy()
dummy_name = dummy.create()
def _set_and_remove_device():
time.sleep(0.2)
dummy.up()
dummy.remove()
with monitor.object_monitor(timeout=self.TIMEOUT) as mon:
add_device_thread = _start_thread(_set_and_remove_device)
for event in mon:
if event.get('name') == dummy_name:
break
add_device_thread.join()
def test_passing_invalid_groups(self):
with pytest.raises(AttributeError):
monitor.object_monitor(groups=('blablabla', ))
monitor.object_monitor(groups=('link', ))
def test_timeout_silent(self):
with monitor.object_monitor(timeout=0.01, silent_timeout=True) as mon:
for event in mon:
pass
assert mon.is_stopped()
def test_events_keys(self):
def _simplify_event(event):
""" Strips event keys except event, address, name, destination,
family.
"""
allow = set(['event', 'address', 'name', 'destination', 'family'])
return {k: v for (k, v) in event.items() if k in allow}
def _expected_events(nic, address, cidr):
events_add = [
{
'event': 'new_link',
'name': nic
},
{
'event': 'new_addr',
'address': address + '/' + cidr
},
{
'event': 'new_link',
'name': nic
},
]
events_del = [
{
'address': address + '/' + cidr,
'event': 'del_addr'
},
{
'destination': address,
'event': 'del_route'
},
{
'event': 'del_link',
'name': nic
},
]
events_ipv6 = [
{
'event': 'new_addr',
'family': 'inet6'
},
{
'event': 'del_addr',
'family': 'inet6'
},
]
if is_disabled_ipv6():
return deque(events_add + events_del)
else:
return deque(events_add + events_ipv6 + events_del)
with monitor.object_monitor(timeout=self.TIMEOUT,
silent_timeout=True) as mon:
dummy = Dummy()
dummy_name = dummy.create()
dummy.set_ip(IP_ADDRESS, IP_CIDR)
dummy.up()
dummy.remove()
expected_events = _expected_events(dummy_name, IP_ADDRESS, IP_CIDR)
_expected = list(expected_events)
_caught = []
expected = expected_events.popleft()
for event in mon:
_caught.append(event)
if _is_subdict(expected, event):
expected = expected_events.popleft()
if len(expected_events) == 0:
break
assert 0 == len(expected_events), (
'Expected events have not '
'been caught (in the right order).\n'
'Expected:\n%s.\nCaught:\n%s.' % (
'\n'.join([str(d) for d in _expected]),
'\n'.join([str(_simplify_event(d)) for d in _caught]),
), )
def __init__(self):
self._handlers = []
self._nl_monitor = monitor.object_monitor(groups=('ipv4-ifaddr',
'ipv6-ifaddr'))
self._thread = concurrent.thread(self.serve_forever,
name='dhcp-monitor')
