async def test_other_peering_objects_are_ignored(mocker, k8s_mocked, settings,
replenished, peering_resource,
peering_namespace):
status = mocker.Mock()
status.items.side_effect = Exception("This should not be called.")
event = bodies.RawEvent(
type='ADDED', # irrelevant
object={
'metadata': {
'name': 'their-name'
},
'status': status,
})
wait_for = mocker.patch('asyncio.wait_for')
settings.peering.name = 'our-name'
await process_peering_event(
raw_event=event,
freeze_toggle=primitives.Toggle(),
replenished=replenished,
autoclean=False,
identity='id',
settings=settings,
namespace=peering_namespace,
resource=peering_resource,
)
assert not status.items.called
assert not k8s_mocked.patch_obj.called
assert wait_for.call_count == 0
async def test_ignored_for_higher_priority_peer_when_already_on(caplog, assert_logs):
event = bodies.RawEvent(
type='ADDED', # irrelevant
object={
'metadata': {'name': 'name', 'namespace': 'namespace'}, # for matching
'status': {
'higher-prio': {
'priority': 101,
'lifetime': 10,
'lastseen': '2020-12-31T23:59:59'
},
},
})
replenished = asyncio.Event()
freeze_mode = primitives.Toggle(True)
ourselves = Peer(id='id', name='name', namespace='namespace', priority=100)
caplog.set_level(0)
assert freeze_mode.is_on()
await process_peering_event(
raw_event=event,
freeze_mode=freeze_mode,
ourselves=ourselves,
replenished=replenished,
autoclean=False,
)
assert freeze_mode.is_on()
assert_logs([], prohibited=[
"Possibly conflicting operators",
"Freezing all operators, including self",
"Freezing operations in favour of",
"Resuming operations after the freeze",
])
async def test_other_peering_objects_are_ignored(mocker, settings, our_name,
our_namespace, their_name,
their_namespace):
status = mocker.Mock()
status.items.side_effect = Exception("This should not be called.")
event = bodies.RawEvent(
type='ADDED', # irrelevant
object={
'metadata': {
'name': their_name,
'namespace': their_namespace
},
'status': status,
})
settings.peering.name = our_name
await process_peering_event(
raw_event=event,
freeze_mode=primitives.Toggle(),
replenished=asyncio.Event(),
autoclean=False,
identity='id',
settings=settings,
namespace=our_namespace,
)
assert not status.items.called
async def test_ignored_for_same_priority_peer_when_already_on(
mocker, k8s_mocked, replenished, caplog, assert_logs, settings,
peering_resource, peering_namespace):
event = bodies.RawEvent(
type='ADDED', # irrelevant
object={
'metadata': {
'name': 'name',
'namespace': peering_namespace
}, # for matching
'status': {
'higher-prio': {
'priority': 100,
'lifetime': 10,
'lastseen': '2020-12-31T23:59:59'
},
},
})
settings.peering.name = 'name'
settings.peering.priority = 100
freeze_toggle = primitives.Toggle(True)
wait_for = mocker.patch('asyncio.wait_for')
caplog.set_level(0)
assert freeze_toggle.is_on()
await process_peering_event(
raw_event=event,
freeze_toggle=freeze_toggle,
replenished=replenished,
autoclean=False,
namespace=peering_namespace,
resource=peering_resource,
identity='id',
settings=settings,
)
assert freeze_toggle.is_on()
assert wait_for.call_count == 1
assert 9 < wait_for.call_args[1]['timeout'] < 10
assert not k8s_mocked.patch_obj.called
assert_logs([
"Possibly conflicting operators",
],
prohibited=[
"Freezing all operators, including self",
"Freezing operations in favour of",
"Resuming operations after the freeze",
])
async def test_ignored_for_same_priority_peer_when_already_on(
k8s_mocked, caplog, assert_logs, settings, peering_resource,
peering_namespace):
event = bodies.RawEvent(
type='ADDED', # irrelevant
object={
'metadata': {
'name': 'name',
'namespace': peering_namespace
}, # for matching
'status': {
'higher-prio': {
'priority': 100,
'lifetime': 10,
'lastseen': '2020-12-31T23:59:59'
},
},
})
settings.peering.name = 'name'
settings.peering.priority = 100
conflicts_found = primitives.Toggle(True)
k8s_mocked.sleep_or_wait.return_value = 1 # as if interrupted by stream pressure
caplog.set_level(0)
assert conflicts_found.is_on()
await process_peering_event(
raw_event=event,
conflicts_found=conflicts_found,
autoclean=False,
namespace=peering_namespace,
resource=peering_resource,
identity='id',
settings=settings,
)
assert conflicts_found.is_on()
assert k8s_mocked.sleep_or_wait.call_count == 1
assert 9 < k8s_mocked.sleep_or_wait.call_args[0][0][0] < 10
assert not k8s_mocked.patch_obj.called
assert_logs([
"Possibly conflicting operators",
],
prohibited=[
"Pausing all operators, including self",
"Pausing operations in favour of",
"Resuming operations after the pause",
])
async def test_toggled_on_for_same_priority_peer_when_initially_off(
caplog, assert_logs, settings):
event = bodies.RawEvent(
type='ADDED', # irrelevant
object={
'metadata': {
'name': 'name',
'namespace': 'namespace'
}, # for matching
'status': {
'higher-prio': {
'priority': 100,
'lifetime': 10,
'lastseen': '2020-12-31T23:59:59'
},
},
})
settings.peering.name = 'name'
settings.peering.priority = 100
replenished = asyncio.Event()
freeze_mode = primitives.Toggle(False)
caplog.set_level(0)
assert freeze_mode.is_off()
await process_peering_event(
raw_event=event,
freeze_mode=freeze_mode,
replenished=replenished,
autoclean=False,
namespace='namespace',
identity='id',
settings=settings,
)
assert freeze_mode.is_on()
assert_logs([
"Possibly conflicting operators",
"Freezing all operators, including self",
],
prohibited=[
"Freezing operations in favour of",
"Resuming operations after the freeze",
])
async def test_resumes_immediately_on_expiration_of_blocking_peers(
mocker, k8s_mocked, replenished, caplog, assert_logs, settings,
priority, peering_resource, peering_namespace):
event = bodies.RawEvent(
type='ADDED', # irrelevant
object={
'metadata': {
'name': 'name',
'namespace': peering_namespace
}, # for matching
'status': {
'higher-prio': {
'priority': priority,
'lifetime': 10,
'lastseen': '2020-12-31T23:59:59'
},
},
})
settings.peering.name = 'name'
settings.peering.priority = 100
freeze_toggle = primitives.Toggle(True)
wait_for = mocker.patch('asyncio.wait_for',
side_effect=asyncio.TimeoutError)
caplog.set_level(0)
assert freeze_toggle.is_on()
await process_peering_event(
raw_event=event,
freeze_toggle=freeze_toggle,
replenished=replenished,
autoclean=False,
namespace=peering_namespace,
resource=peering_resource,
identity='id',
settings=settings,
)
assert freeze_toggle.is_on()
assert wait_for.call_count == 1
assert 9 < wait_for.call_args[1]['timeout'] < 10
assert k8s_mocked.patch_obj.called
def revise_namespaces(
*,
insights: references.Insights,
namespaces: Collection[references.NamespacePattern],
raw_events: Collection[bodies.RawEvent] = (),
raw_bodies: Collection[bodies.RawBody] = (),
) -> None:
all_events = list(raw_events) + [
bodies.RawEvent(type=None, object=obj) for obj in raw_bodies
]
for raw_event in all_events:
namespace = references.NamespaceName(
raw_event['object']['metadata']['name'])
matched = any(
references.match_namespace(namespace, pattern)
for pattern in namespaces)
deleted = is_deleted(raw_event)
if deleted:
insights.namespaces.discard(namespace)
elif matched:
insights.namespaces.add(namespace)
async def test_resumes_immediately_on_expiration_of_blocking_peers(
k8s_mocked, caplog, assert_logs, settings, priority, peering_resource,
peering_namespace):
event = bodies.RawEvent(
type='ADDED', # irrelevant
object={
'metadata': {
'name': 'name',
'namespace': peering_namespace
}, # for matching
'status': {
'higher-prio': {
'priority': priority,
'lifetime': 10,
'lastseen': '2020-12-31T23:59:59'
},
},
})
settings.peering.name = 'name'
settings.peering.priority = 100
conflicts_found = primitives.Toggle(True)
k8s_mocked.sleep_or_wait.return_value = None # as if finished sleeping uninterrupted
caplog.set_level(0)
assert conflicts_found.is_on()
await process_peering_event(
raw_event=event,
conflicts_found=conflicts_found,
autoclean=False,
namespace=peering_namespace,
resource=peering_resource,
identity='id',
settings=settings,
)
assert conflicts_found.is_on()
assert k8s_mocked.sleep_or_wait.call_count == 1
assert 9 < k8s_mocked.sleep_or_wait.call_args[0][0][0] < 10
assert k8s_mocked.patch_obj.called
