def decorator( # lgtm[py/similar-function]
fn: callbacks.ResourceWatchingFn, ) -> callbacks.ResourceWatchingFn:
_warn_deprecated_signatures(fn)
_warn_deprecated_filters(labels, annotations)
_warn_conflicting_values(field, value)
real_registry = registry if registry is not None else registries.get_default_registry(
)
real_field = dicts.parse_field(
field) or None # to not store tuple() as a no-field case.
real_id = registries.generate_id(fn=fn, id=id)
selector = references.Selector(group, version, plural)
handler = handlers.ResourceWatchingHandler(
fn=fn,
id=real_id,
errors=None,
timeout=None,
retries=None,
backoff=None,
cooldown=None,
selector=selector,
labels=labels,
annotations=annotations,
when=when,
field=real_field,
value=value,
)
real_registry.resource_watching_handlers.append(handler)
return fn
def decorator( # lgtm[py/similar-function]
fn: callbacks.ResourceTimerFn, ) -> callbacks.ResourceTimerFn:
_warn_deprecated_signatures(fn)
_warn_deprecated_filters(labels, annotations)
_warn_conflicting_values(field, value)
real_registry = registry if registry is not None else registries.get_default_registry(
)
real_field = dicts.parse_field(
field) or None # to not store tuple() as a no-field case.
real_id = registries.generate_id(fn=fn, id=id)
selector = references.Selector(group, version, plural)
handler = handlers.ResourceTimerHandler(
fn=fn,
id=real_id,
errors=errors,
timeout=timeout,
retries=retries,
backoff=backoff,
cooldown=cooldown,
selector=selector,
labels=labels,
annotations=annotations,
when=when,
field=real_field,
value=value,
initial_delay=initial_delay,
requires_finalizer=True,
sharp=sharp,
idle=idle,
interval=interval,
)
real_registry.resource_spawning_handlers.append(handler)
return fn
def decorator( # lgtm[py/similar-function]
fn: callbacks.ResourceDaemonFn,
) -> callbacks.ResourceDaemonFn:
_warn_conflicting_values(field, value)
_verify_filters(labels, annotations)
real_registry = registry if registry is not None else registries.get_default_registry()
real_field = dicts.parse_field(field) or None # to not store tuple() as a no-field case.
real_id = registries.generate_id(fn=fn, id=id, suffix=".".join(real_field or []))
selector = references.Selector(
__group_or_groupversion_or_name, __version_or_name, __name,
group=group, version=version,
kind=kind, plural=plural, singular=singular, shortcut=shortcut, category=category,
)
handler = handlers.ResourceDaemonHandler(
fn=fn, id=real_id, param=param,
errors=errors, timeout=timeout, retries=retries, backoff=backoff,
selector=selector, labels=labels, annotations=annotations, when=when,
field=real_field, value=value,
initial_delay=initial_delay, requires_finalizer=True,
cancellation_backoff=cancellation_backoff,
cancellation_timeout=cancellation_timeout,
cancellation_polling=cancellation_polling,
)
real_registry._resource_spawning.append(handler)
return fn
def decorator( # lgtm[py/similar-function]
fn: callbacks.ResourceChangingFn, ) -> callbacks.ResourceChangingFn:
_warn_deprecated_signatures(fn)
_warn_deprecated_filters(labels, annotations)
_warn_conflicting_values(field, value)
real_registry = registry if registry is not None else registries.get_default_registry(
)
real_field = dicts.parse_field(
field) or None # to not store tuple() as a no-field case.
real_id = registries.generate_id(fn=fn, id=id)
selector = references.Selector(group, version, plural)
handler = handlers.ResourceChangingHandler(
fn=fn,
id=real_id,
errors=errors,
timeout=timeout,
retries=retries,
backoff=backoff,
cooldown=cooldown,
selector=selector,
labels=labels,
annotations=annotations,
when=when,
field=real_field,
value=value,
old=None,
new=None,
field_needs_change=False,
initial=None,
deleted=None,
requires_finalizer=bool(not optional),
reason=handlers.Reason.DELETE,
)
real_registry.resource_changing_handlers.append(handler)
return fn
def register_resource_watching_handler(
self,
group: str,
version: str,
plural: str,
fn: callbacks.ResourceWatchingFn,
id: Optional[str] = None,
labels: Optional[filters.MetaFilter] = None,
annotations: Optional[filters.MetaFilter] = None,
when: Optional[callbacks.WhenFilterFn] = None,
) -> callbacks.ResourceWatchingFn:
"""
Register an additional handler function for low-level events.
"""
warnings.warn(
"registry.register_resource_watching_handler() is deprecated; "
"use @kopf.on... decorators with registry= kwarg.",
DeprecationWarning)
return self.resource_watching_handlers.register(
fn=fn,
id=id,
labels=labels,
annotations=annotations,
when=when,
resource=references.Selector(group, version, plural),
)
def register_resource_changing_handler(
self,
group: str,
version: str,
plural: str,
fn: callbacks.ResourceChangingFn,
id: Optional[str] = None,
reason: Optional[handlers.Reason] = None,
event: Optional[str] = None, # deprecated, use `reason`
field: Optional[dicts.FieldSpec] = None,
errors: Optional[handlers.ErrorsMode] = None,
timeout: Optional[float] = None,
retries: Optional[int] = None,
backoff: Optional[float] = None,
cooldown: Optional[float] = None, # deprecated, use `backoff`
initial: Optional[bool] = None,
deleted: Optional[bool] = None,
requires_finalizer: bool = False,
labels: Optional[filters.MetaFilter] = None,
annotations: Optional[filters.MetaFilter] = None,
when: Optional[callbacks.WhenFilterFn] = None,
) -> callbacks.ResourceChangingFn:
"""
Register an additional handler function for the specific resource and specific reason.
"""
warnings.warn(
"registry.register_resource_changing_handler() is deprecated; "
"use @kopf.on... decorators with registry= kwarg.",
DeprecationWarning)
return self.resource_changing_handlers.register(
reason=reason,
event=event,
field=field,
fn=fn,
id=id,
errors=errors,
timeout=timeout,
retries=retries,
backoff=backoff,
cooldown=cooldown,
initial=initial,
deleted=deleted,
requires_finalizer=requires_finalizer,
labels=labels,
annotations=annotations,
when=when,
resource=references.Selector(group, version, plural),
)
def decorator( # lgtm[py/similar-function]
fn: callbacks.ResourceChangingFn, ) -> callbacks.ResourceChangingFn:
_warn_conflicting_values(field, value)
_verify_filters(labels, annotations)
real_registry = registry if registry is not None else registries.get_default_registry(
)
real_field = dicts.parse_field(
field) or None # to not store tuple() as a no-field case.
real_id = registries.generate_id(fn=fn,
id=id,
suffix=".".join(real_field or []))
selector = references.Selector(
__group_or_groupversion_or_name,
__version_or_name,
__name,
group=group,
version=version,
kind=kind,
plural=plural,
singular=singular,
shortcut=shortcut,
category=category,
)
handler = handlers.ResourceChangingHandler(
fn=fn,
id=real_id,
param=param,
errors=errors,
timeout=timeout,
retries=retries,
backoff=backoff,
selector=selector,
labels=labels,
annotations=annotations,
when=when,
field=real_field,
value=value,
old=None,
new=None,
field_needs_change=False,
initial=None,
deleted=None,
requires_finalizer=bool(not optional),
reason=handlers.Reason.DELETE,
)
real_registry._resource_changing.append(handler)
return fn
def decorator( # lgtm[py/similar-function]
fn: callbacks.ResourceWatchingFn,
) -> callbacks.ResourceWatchingFn:
_warn_conflicting_values(field, value)
_verify_filters(labels, annotations)
real_registry = registry if registry is not None else registries.get_default_registry()
real_field = dicts.parse_field(field) or None # to not store tuple() as a no-field case.
real_id = registries.generate_id(fn=fn, id=id)
selector = references.Selector(
__group_or_groupversion_or_name, __version_or_name, __name,
group=group, version=version,
kind=kind, plural=plural, singular=singular, shortcut=shortcut, category=category,
)
handler = handlers.ResourceWatchingHandler(
fn=fn, id=real_id,
errors=None, timeout=None, retries=None, backoff=None,
selector=selector, labels=labels, annotations=annotations, when=when,
field=real_field, value=value,
)
real_registry._resource_watching.append(handler)
return fn
def decorator( # lgtm[py/similar-function]
fn: callbacks.ResourceWebhookFn,
) -> callbacks.ResourceWebhookFn:
_warn_conflicting_values(field, value)
_verify_filters(labels, annotations)
real_registry = registry if registry is not None else registries.get_default_registry()
real_field = dicts.parse_field(field) or None # to not store tuple() as a no-field case.
real_id = registries.generate_id(fn=fn, id=id, suffix=".".join(real_field or []))
selector = references.Selector(
__group_or_groupversion_or_name, __version_or_name, __name,
group=group, version=version,
kind=kind, plural=plural, singular=singular, shortcut=shortcut, category=category,
)
handler = handlers.ResourceWebhookHandler(
fn=fn, id=real_id, param=param,
errors=None, timeout=None, retries=None, backoff=None, # TODO: add some meaning later
selector=selector, labels=labels, annotations=annotations, when=when,
field=real_field, value=value,
reason=handlers.WebhookType.MUTATING, operation=operation,
persistent=persistent, side_effects=side_effects, ignore_failures=ignore_failures,
)
real_registry._resource_webhooks.append(handler)
return fn
def find_resource(
*,
request: reviews.Request,
insights: references.Insights,
) -> references.Resource:
"""
Identify the requested resource by its meta-information (as discovered).
"""
# NB: Absent keys in the request are not acceptable, they must be provided.
request_payload: reviews.RequestPayload = request['request']
request_resource: reviews.RequestResource = request_payload['resource']
group = request_resource['group']
version = request_resource['version']
plural = request_resource['resource']
selector = references.Selector(group=group, version=version, plural=plural)
resources = selector.select(insights.resources)
if not resources:
raise UnknownResourceError(
f"The specified resource has no handlers: {request_resource}")
elif len(resources) > 1:
raise AmbiguousResourceError(
f"The specified resource is ambiguous: {request_resource}")
else:
return list(resources)[0]
