def create_tasks(
lifecycle: Optional[Callable] = None,
registry: Optional[BaseRegistry] = None,
standalone: bool = False,
priority: int = 0,
peering: str = PEERING_DEFAULT_NAME,
namespace: Optional[str] = None,
):
"""
Create all the tasks needed to run the operator, but do not spawn/start them.
The tasks are properly inter-connected depending on the runtime specification.
They can be injected into any event loop as needed.
"""
# The freezer and the registry are scoped to this whole task-set, to sync them all.
lifecycle = lifecycle if lifecycle is not None else get_default_lifecycle()
registry = registry if registry is not None else get_default_registry()
freeze = asyncio.Event()
tasks = []
# Monitor the peers, unless explicitly disabled.
ourselves: Optional[Peer] = Peer.detect(
id=detect_own_id(),
priority=priority,
standalone=standalone,
namespace=namespace,
peering=peering,
)
if ourselves:
tasks.extend([
asyncio.Task(peers_keepalive(ourselves=ourselves)),
asyncio.Task(
watcher(namespace=namespace,
resource=ourselves.resource,
handler=functools.partial(
peers_handler, ourselves=ourselves,
freeze=freeze))), # freeze is set/cleared
])
# Resource event handling, only once for every known resource (de-duplicated).
for resource in registry.resources:
tasks.extend([
asyncio.Task(
watcher(namespace=namespace,
resource=resource,
handler=functools.partial(
custom_object_handler,
lifecycle=lifecycle,
registry=registry,
resource=resource,
freeze=freeze))), # freeze is only checked
])
return tasks
def delete(group: str,
version: str,
plural: str,
*,
id: Optional[str] = None,
timeout: Optional[float] = None,
registry: Optional[GlobalRegistry] = None):
""" ``@kopf.on.delete()`` handler for the object deletion. """
registry = registry if registry is not None else get_default_registry()
def decorator(fn):
registry.register(group=group,
version=version,
plural=plural,
event=DELETE,
id=id,
timeout=timeout,
fn=fn)
return fn
return decorator
def field(group: str,
version: str,
plural: str,
field: Union[str, List[str], Tuple[str, ...]],
*,
id: Optional[str] = None,
timeout: Optional[float] = None,
registry: Optional[GlobalRegistry] = None):
""" ``@kopf.on.field()`` handler for the individual field changes. """
registry = registry if registry is not None else get_default_registry()
def decorator(fn):
registry.register(group=group,
version=version,
plural=plural,
event=FIELD,
field=field,
id=id,
timeout=timeout,
fn=fn)
return fn
return decorator