def test_fails_if_no_zone(self):
v = MagicMock(annotations={
'pv.kubernetes.io/provisioned-by': 'kubernetes.io/gce-pd'
},
labels={})
with pytest.raises(AnnotationError):
rule_from_pv(volume=v, api=None, deltas_annotation_key='test')
def test_rule_from_volume_with_claim(
deltas_annotation_key,
fx_deltas,
volume_zone_label,
provisioner_annotation,
):
ctx = Context({'deltas_annotation_key': deltas_annotation_key})
pv, pvc = make_volume_and_claim(
ctx=ctx,
volume_annotations=provisioner_annotation,
claim_annotations={
ctx.config['deltas_annotation_key']: fx_deltas,
},
volume_zone_label=volume_zone_label,
)
if pvc.namespace and not pvc.namespace == 'default':
expected_rule_name = f'pvc-{pvc.namespace}-{pvc.name}'
else:
expected_rule_name = f'pvc-{pvc.name}'
loop = asyncio.get_event_loop()
with mock_kube([pv, pvc]) as _mocked:
deltas_annotation_key = ctx.config['deltas_annotation_key']
rule = loop.run_until_complete(
rule_from_pv(ctx, pv, deltas_annotation_key))
assert rule.source == pvc.obj['metadata']['selfLink']
assert deltas_annotation_key in pvc.annotations
assert rule.name == expected_rule_name
assert rule.deltas == parse_deltas(fx_deltas)
def sync_get_rules(ctx):
rules = {}
api = ctx.make_kubeclient()
_logger.debug('volume-events.watch')
stream = pykube.objects.PersistentVolume.objects(api).watch().object_stream()
for event in stream:
volume_name = event.object.name
_log = _logger.new(
volume_name=volume_name,
volume_event_type=event.type,
volume=event.object.obj,
)
_log.debug('volume-event.received')
if event.type == 'ADDED' or event.type == 'MODIFIED':
rule = None
try:
rule = rule_from_pv(
event.object,
api,
ctx.config.get('deltas_annotation_key'),
use_claim_name=ctx.config.get('use_claim_name'))
except AnnotationNotFound as exc:
_log.info(
events.Annotation.NOT_FOUND,
exc_info=exc,
)
except AnnotationError:
_log.exception(events.Annotation.ERROR)
if rule:
_log.bind(
rule=rule
)
if event.type == 'ADDED' or volume_name not in rules:
_log.info(events.Rule.ADDED)
else:
_log.info(events.Rule.UPDATED)
rules[volume_name] = rule
else:
if volume_name in rules:
_log.info(events.Rule.REMOVED)
rules.pop(volume_name, False)
elif event.type == 'DELETED':
_log.info(events.Rule.REMOVED)
rules.pop(volume_name, False)
else:
_log.warning('Unhandled event')
yield list(rules.values())
_logger.debug('sync-get-rules.done')
def test_rule_from_volume(fx_context: Context, fx_deltas: str,
label_zone: Optional[Dict[str, str]],
annotation_provisioned_by: Optional[Dict[str, str]],
_spec_gce_persistent_disk: Optional[Dict[str, Any]]):
annotations = {}
annotations.update({
fx_context.config['deltas_annotation_key']: fx_deltas,
})
if annotation_provisioned_by is not None:
annotations.update(annotation_provisioned_by)
labels = {}
if label_zone is not None:
labels.update(label_zone)
spec = {}
if _spec_gce_persistent_disk is not None:
spec.update(_spec_gce_persistent_disk)
source_pv = make_resource(
pykube.objects.PersistentVolume,
'source-pv',
annotations=annotations,
labels=labels,
spec=spec,
)
expected_rule_name = f'pv-{source_pv.name}'
loop = asyncio.get_event_loop()
with mock_kube([source_pv]):
rule: Rule = loop.run_until_complete(
rule_from_pv(fx_context, source_pv,
fx_context.config['deltas_annotation_key']))
assert rule.name == expected_rule_name
assert rule.deltas == parse_deltas(fx_deltas)