def create_tasks(
loop: asyncio.AbstractEventLoop,
lifecycle: Optional[Callable] = None,
registry: Optional[registries.BaseRegistry] = None,
standalone: bool = False,
priority: int = 0,
peering_name: str = peering.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 lifecycles.get_default_lifecycle(
)
registry = registry if registry is not None else registries.get_default_registry(
)
freeze = asyncio.Event()
tasks = []
# Monitor the peers, unless explicitly disabled.
ourselves: Optional[peering.Peer] = peering.Peer.detect(
id=peering.detect_own_id(),
priority=priority,
standalone=standalone,
namespace=namespace,
name=peering_name,
)
if ourselves:
tasks.extend([
loop.create_task(peering.peers_keepalive(ourselves=ourselves)),
loop.create_task(
watcher(namespace=namespace,
resource=ourselves.resource,
handler=functools.partial(
peering.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([
loop.create_task(
watcher(namespace=namespace,
resource=resource,
handler=functools.partial(
handling.custom_object_handler,
lifecycle=lifecycle,
registry=registry,
resource=resource,
freeze=freeze))), # freeze is only checked
])
return tasks
async def spawn_tasks(
*,
lifecycle: Optional[lifecycles.LifeCycleFn] = None,
indexers: Optional[indexing.OperatorIndexers] = None,
registry: Optional[registries.OperatorRegistry] = None,
settings: Optional[configuration.OperatorSettings] = None,
memories: Optional[containers.ResourceMemories] = None,
insights: Optional[references.Insights] = None,
identity: Optional[peering.Identity] = None,
standalone: Optional[bool] = None,
priority: Optional[int] = None,
peering_name: Optional[str] = None,
liveness_endpoint: Optional[str] = None,
clusterwide: bool = False,
namespaces: Collection[references.NamespacePattern] = (),
namespace: Optional[references.NamespacePattern] = None, # deprecated
stop_flag: Optional[primitives.Flag] = None,
ready_flag: Optional[primitives.Flag] = None,
vault: Optional[credentials.Vault] = None,
memo: Optional[ephemera.AnyMemo] = None,
_command: Optional[Coroutine[None, None, None]] = None,
) -> Collection[aiotasks.Task]:
"""
Spawn all the tasks needed to run the operator.
The tasks are properly inter-connected with the synchronisation primitives.
"""
loop = asyncio.get_running_loop()
if namespaces and namespace:
raise TypeError("Either namespaces= or namespace= can be passed. Got both.")
elif namespace:
warnings.warn("namespace= is deprecated; use namespaces=[...]", DeprecationWarning)
namespaces = [namespace]
if clusterwide and namespaces:
raise TypeError("The operator can be either cluster-wide or namespaced, not both.")
if not clusterwide and not namespaces:
warnings.warn("Absence of either namespaces or cluster-wide flag will become an error soon."
" For now, switching to the cluster-wide mode for backward compatibility.",
FutureWarning)
clusterwide = True
# All tasks of the operator are synced via these primitives and structures:
lifecycle = lifecycle if lifecycle is not None else lifecycles.get_default_lifecycle()
registry = registry if registry is not None else registries.get_default_registry()
settings = settings if settings is not None else configuration.OperatorSettings()
memories = memories if memories is not None else containers.ResourceMemories()
indexers = indexers if indexers is not None else indexing.OperatorIndexers()
insights = insights if insights is not None else references.Insights()
identity = identity if identity is not None else peering.detect_own_id(manual=False)
vault = vault if vault is not None else credentials.Vault()
memo = memo if memo is not None else ephemera.Memo()
event_queue: posting.K8sEventQueue = asyncio.Queue()
signal_flag: aiotasks.Future = asyncio.Future()
started_flag: asyncio.Event = asyncio.Event()
operator_paused = primitives.ToggleSet(any)
tasks: MutableSequence[aiotasks.Task] = []
# Map kwargs into the settings object.
settings.peering.clusterwide = clusterwide
if peering_name is not None:
settings.peering.mandatory = True
settings.peering.name = peering_name
if standalone is not None:
settings.peering.standalone = standalone
if priority is not None:
settings.peering.priority = priority
# Prepopulate indexers with empty indices -- to be available startup handlers.
indexers.ensure(registry._resource_indexing.get_all_handlers())
# Global credentials store for this operator, also for CRD-reading & peering mode detection.
auth.vault_var.set(vault)
# Special case: pass the settings container through the user-side handlers (no explicit args).
# Toolkits have to keep the original operator context somehow, and the only way is contextvars.
posting.settings_var.set(settings)
# Few common background forever-running infrastructural tasks (irregular root tasks).
tasks.append(aiotasks.create_task(
name="stop-flag checker",
coro=_stop_flag_checker(
signal_flag=signal_flag,
stop_flag=stop_flag)))
tasks.append(aiotasks.create_task(
name="ultimate termination",
coro=_ultimate_termination(
settings=settings,
stop_flag=stop_flag)))
tasks.append(aiotasks.create_task(
name="startup/cleanup activities",
coro=_startup_cleanup_activities(
root_tasks=tasks, # used as a "live" view, populated later.
ready_flag=ready_flag,
started_flag=started_flag,
registry=registry,
settings=settings,
indices=indexers.indices,
vault=vault,
memo=memo))) # to purge & finalize the caches in the end.
# Kill all the daemons gracefully when the operator exits (so that they are not "hung").
tasks.append(aiotasks.create_guarded_task(
name="daemon killer", flag=started_flag, logger=logger,
coro=daemons.daemon_killer(
settings=settings,
memories=memories,
operator_paused=operator_paused)))
# Keeping the credentials fresh and valid via the authentication handlers on demand.
tasks.append(aiotasks.create_guarded_task(
name="credentials retriever", flag=started_flag, logger=logger,
coro=activities.authenticator(
registry=registry,
settings=settings,
indices=indexers.indices,
vault=vault,
memo=memo)))
# K8s-event posting. Events are queued in-memory and posted in the background.
# NB: currently, it is a global task, but can be made per-resource or per-object.
tasks.append(aiotasks.create_guarded_task(
name="poster of events", flag=started_flag, logger=logger,
coro=posting.poster(
backbone=insights.backbone,
event_queue=event_queue)))
# Liveness probing -- so that Kubernetes would know that the operator is alive.
if liveness_endpoint:
tasks.append(aiotasks.create_guarded_task(
name="health reporter", flag=started_flag, logger=logger,
coro=probing.health_reporter(
registry=registry,
settings=settings,
endpoint=liveness_endpoint,
indices=indexers.indices,
memo=memo)))
# Permanent observation of what resource kinds and namespaces are available in the cluster.
# Spawn and cancel dimensional tasks as they come and go; dimensions = resources x namespaces.
tasks.append(aiotasks.create_guarded_task(
name="resource observer", flag=started_flag, logger=logger,
coro=observation.resource_observer(
insights=insights,
registry=registry,
settings=settings)))
tasks.append(aiotasks.create_guarded_task(
name="namespace observer", flag=started_flag, logger=logger,
coro=observation.namespace_observer(
clusterwide=clusterwide,
namespaces=namespaces,
insights=insights,
settings=settings)))
# Explicit command is a hack for the CLI to run coroutines in an operator-like environment.
# If not specified, then use the normal resource processing. It is not exposed publicly (yet).
if _command is not None:
tasks.append(aiotasks.create_guarded_task(
name="the command", flag=started_flag, logger=logger, finishable=True,
coro=_command))
else:
tasks.append(aiotasks.create_guarded_task(
name="multidimensional multitasker", flag=started_flag, logger=logger,
coro=orchestration.ochestrator(
settings=settings,
insights=insights,
identity=identity,
operator_paused=operator_paused,
processor=functools.partial(processing.process_resource_event,
lifecycle=lifecycle,
registry=registry,
settings=settings,
indexers=indexers,
memories=memories,
memobase=memo,
event_queue=event_queue))))
# Ensure that all guarded tasks got control for a moment to enter the guard.
await asyncio.sleep(0)
# On Ctrl+C or pod termination, cancel all tasks gracefully.
if threading.current_thread() is threading.main_thread():
# Handle NotImplementedError when ran on Windows since asyncio only supports Unix signals
try:
loop.add_signal_handler(signal.SIGINT, signal_flag.set_result, signal.SIGINT)
loop.add_signal_handler(signal.SIGTERM, signal_flag.set_result, signal.SIGTERM)
except NotImplementedError:
logger.warning("OS signals are ignored: can't add signal handler in Windows.")
else:
logger.warning("OS signals are ignored: running not in the main thread.")
return tasks
async def spawn_tasks(
*,
lifecycle: Optional[lifecycles.LifeCycleFn] = None,
registry: Optional[registries.OperatorRegistry] = None,
memories: Optional[containers.ResourceMemories] = None,
standalone: bool = False,
priority: int = 0,
peering_name: Optional[str] = None,
liveness_endpoint: Optional[str] = None,
namespace: Optional[str] = None,
stop_flag: Optional[primitives.Flag] = None,
ready_flag: Optional[primitives.Flag] = None,
vault: Optional[credentials.Vault] = None,
) -> Tasks:
"""
Spawn all the tasks needed to run the operator.
The tasks are properly inter-connected with the synchronisation primitives.
"""
loop = asyncio.get_running_loop()
# The freezer and the registry are scoped to this whole task-set, to sync them all.
lifecycle = lifecycle if lifecycle is not None else lifecycles.get_default_lifecycle()
registry = registry if registry is not None else registries.get_default_registry()
memories = memories if memories is not None else containers.ResourceMemories()
vault = vault if vault is not None else global_vault
vault = vault if vault is not None else credentials.Vault()
event_queue: posting.K8sEventQueue = asyncio.Queue()
freeze_mode: primitives.Toggle = primitives.Toggle()
signal_flag: asyncio_Future = asyncio.Future()
ready_flag = ready_flag if ready_flag is not None else asyncio.Event()
tasks: MutableSequence[asyncio_Task] = []
# Global credentials store for this operator, also for CRD-reading & peering mode detection.
auth.vault_var.set(vault)
# Few common background forever-running infrastructural tasks (irregular root tasks).
tasks.extend([
loop.create_task(_stop_flag_checker(
signal_flag=signal_flag,
stop_flag=stop_flag,
)),
loop.create_task(_startup_cleanup_activities(
root_tasks=tasks, # used as a "live" view, populated later.
ready_flag=ready_flag,
registry=registry,
vault=vault, # to purge & finalize the caches in the end.
)),
])
# Keeping the credentials fresh and valid via the authentication handlers on demand.
tasks.extend([
loop.create_task(_root_task_checker(
name="credentials retriever", ready_flag=ready_flag,
coro=activities.authenticator(
registry=registry,
vault=vault))),
])
# K8s-event posting. Events are queued in-memory and posted in the background.
# NB: currently, it is a global task, but can be made per-resource or per-object.
tasks.extend([
loop.create_task(_root_task_checker(
name="poster of events", ready_flag=ready_flag,
coro=posting.poster(
event_queue=event_queue))),
])
# Liveness probing -- so that Kubernetes would know that the operator is alive.
if liveness_endpoint:
tasks.extend([
loop.create_task(_root_task_checker(
name="health reporter", ready_flag=ready_flag,
coro=probing.health_reporter(
registry=registry,
endpoint=liveness_endpoint))),
])
# Monitor the peers, unless explicitly disabled.
ourselves: Optional[peering.Peer] = await peering.Peer.detect(
id=peering.detect_own_id(), priority=priority,
standalone=standalone, namespace=namespace, name=peering_name,
)
if ourselves:
tasks.extend([
loop.create_task(peering.peers_keepalive(
ourselves=ourselves)),
loop.create_task(_root_task_checker(
name="watcher of peering", ready_flag=ready_flag,
coro=queueing.watcher(
namespace=namespace,
resource=ourselves.resource,
processor=functools.partial(peering.process_peering_event,
ourselves=ourselves,
freeze_mode=freeze_mode)))),
])
# Resource event handling, only once for every known resource (de-duplicated).
for resource in registry.resources:
tasks.extend([
loop.create_task(_root_task_checker(
name=f"watcher of {resource.name}", ready_flag=ready_flag,
coro=queueing.watcher(
namespace=namespace,
resource=resource,
freeze_mode=freeze_mode,
processor=functools.partial(processing.process_resource_event,
lifecycle=lifecycle,
registry=registry,
memories=memories,
resource=resource,
event_queue=event_queue)))),
])
# On Ctrl+C or pod termination, cancel all tasks gracefully.
if threading.current_thread() is threading.main_thread():
# Handle NotImplementedError when ran on Windows since asyncio only supports Unix signals
try:
loop.add_signal_handler(signal.SIGINT, signal_flag.set_result, signal.SIGINT)
loop.add_signal_handler(signal.SIGTERM, signal_flag.set_result, signal.SIGTERM)
except NotImplementedError:
logger.warning("OS signals are ignored: can't add signal handler in Windows.")
else:
logger.warning("OS signals are ignored: running not in the main thread.")
return tasks
async def execute(
*,
fns: Optional[Iterable[callbacks.ResourceChangingFn]] = None,
handlers: Optional[Iterable[handlers_.ResourceChangingHandler]] = None,
registry: Optional[registries.ResourceChangingRegistry] = None,
lifecycle: Optional[lifecycles.LifeCycleFn] = None,
cause: Optional[causation.BaseCause] = None,
) -> None:
"""
Execute the handlers in an isolated lifecycle.
This function is just a public wrapper for `execute` with multiple
ways to specify the handlers: either as the raw functions, or as the
pre-created handlers, or as a registry (as used in the object handling).
If no explicit functions or handlers or registry are passed,
the sub-handlers of the current handler are assumed, as accumulated
in the per-handler registry with ``@kopf.subhandler``.
If the call to this method for the sub-handlers is not done explicitly
in the handler, it is done implicitly after the handler is exited.
One way or another, it is executed for the sub-handlers.
"""
# Restore the current context as set in the handler execution cycle.
lifecycle = lifecycle if lifecycle is not None else sublifecycle_var.get()
lifecycle = lifecycle if lifecycle is not None else lifecycles.get_default_lifecycle(
)
cause = cause if cause is not None else cause_var.get()
parent_handler: handlers_.BaseHandler = handler_var.get()
parent_prefix = parent_handler.id if parent_handler is not None else None
# Validate the inputs; the function signatures cannot put these kind of restrictions, so we do.
if len([v for v in [fns, handlers, registry] if v is not None]) > 1:
raise TypeError(
"Only one of the fns, handlers, registry can be passed. Got more.")
elif fns is not None and isinstance(fns, collections.abc.Mapping):
subregistry = registries.ResourceChangingRegistry()
for id, fn in fns.items():
real_id = registries.generate_id(fn=fn,
id=id,
prefix=parent_prefix)
handler = handlers_.ResourceChangingHandler(
fn=fn,
id=real_id,
errors=None,
timeout=None,
retries=None,
backoff=None,
cooldown=None,
selector=None,
labels=None,
annotations=None,
when=None,
initial=None,
deleted=None,
requires_finalizer=None,
reason=None,
field=None,
value=None,
old=None,
new=None,
field_needs_change=None,
)
subregistry.append(handler)
elif fns is not None and isinstance(fns, collections.abc.Iterable):
subregistry = registries.ResourceChangingRegistry()
for fn in fns:
real_id = registries.generate_id(fn=fn,
id=None,
prefix=parent_prefix)
handler = handlers_.ResourceChangingHandler(
fn=fn,
id=real_id,
errors=None,
timeout=None,
retries=None,
backoff=None,
cooldown=None,
selector=None,
labels=None,
annotations=None,
when=None,
initial=None,
deleted=None,
requires_finalizer=None,
reason=None,
field=None,
value=None,
old=None,
new=None,
field_needs_change=None,
)
subregistry.append(handler)
elif fns is not None:
raise ValueError(
f"fns must be a mapping or an iterable, got {fns.__class__}.")
elif handlers is not None:
subregistry = registries.ResourceChangingRegistry()
for handler in handlers:
subregistry.append(handler)
# Use the registry as is; assume that the caller knows what they do.
elif registry is not None:
subregistry = registry
# Prevent double implicit execution.
elif subexecuted_var.get():
return
# If no explicit args were passed, use the accumulated handlers from `@kopf.subhandler`.
else:
subexecuted_var.set(True)
subregistry = subregistry_var.get()
# The sub-handlers are only for upper-level causes, not for lower-level events.
if not isinstance(cause, causation.ResourceChangingCause):
raise RuntimeError(
"Sub-handlers of event-handlers are not supported and have "
"no practical use (there are no retries or state tracking).")
# Execute the real handlers (all or few or one of them, as per the lifecycle).
settings: configuration.OperatorSettings = subsettings_var.get()
owned_handlers = subregistry.get_resource_handlers(resource=cause.resource)
cause_handlers = subregistry.get_handlers(cause=cause)
storage = settings.persistence.progress_storage
state = states.State.from_storage(body=cause.body,
storage=storage,
handlers=owned_handlers)
state = state.with_purpose(cause.reason).with_handlers(cause_handlers)
outcomes = await execute_handlers_once(
lifecycle=lifecycle,
settings=settings,
handlers=cause_handlers,
cause=cause,
state=state,
)
state = state.with_outcomes(outcomes)
state.store(body=cause.body, patch=cause.patch, storage=storage)
states.deliver_results(outcomes=outcomes, patch=cause.patch)
# Enrich all parents with references to sub-handlers of any level deep (sub-sub-handlers, etc).
# There is at least one container, as this function can be called only from a handler.
subrefs_containers: Iterable[Set[handlers_.HandlerId]] = subrefs_var.get()
for key in state:
for subrefs_container in subrefs_containers:
subrefs_container.add(key)
# Escalate `HandlerChildrenRetry` if the execute should be continued on the next iteration.
if not state.done:
raise HandlerChildrenRetry(delay=state.delay)
async def spawn_tasks(
lifecycle: Optional[Callable] = None,
registry: Optional[registries.GlobalRegistry] = None,
standalone: bool = False,
priority: int = 0,
peering_name: Optional[str] = None,
namespace: Optional[str] = None,
) -> Collection[asyncio.Task]:
"""
Spawn all the tasks needed to run the operator.
The tasks are properly inter-connected with the synchronisation primitives.
"""
loop = asyncio.get_running_loop()
# The freezer and the registry are scoped to this whole task-set, to sync them all.
lifecycle = lifecycle if lifecycle is not None else lifecycles.get_default_lifecycle(
)
registry = registry if registry is not None else registries.get_default_registry(
)
event_queue = asyncio.Queue(loop=loop)
freeze_flag = asyncio.Event(loop=loop)
should_stop = asyncio.Event(loop=loop)
tasks = []
# A top-level task for external stopping by setting a stop-flag. Once set,
# this task will exit, and thus all other top-level tasks will be cancelled.
tasks.extend([
loop.create_task(_stop_flag_checker(should_stop)),
])
# K8s-event posting. Events are queued in-memory and posted in the background.
# NB: currently, it is a global task, but can be made per-resource or per-object.
tasks.extend([
loop.create_task(posting.poster(event_queue=event_queue)),
])
# Monitor the peers, unless explicitly disabled.
ourselves: Optional[peering.Peer] = peering.Peer.detect(
id=peering.detect_own_id(),
priority=priority,
standalone=standalone,
namespace=namespace,
name=peering_name,
)
if ourselves:
tasks.extend([
loop.create_task(peering.peers_keepalive(ourselves=ourselves)),
loop.create_task(
queueing.watcher(
namespace=namespace,
resource=ourselves.resource,
handler=functools.partial(
peering.peers_handler,
ourselves=ourselves,
freeze=freeze_flag))), # freeze is set/cleared
])
# Resource event handling, only once for every known resource (de-duplicated).
for resource in registry.resources:
tasks.extend([
loop.create_task(
queueing.watcher(
namespace=namespace,
resource=resource,
handler=functools.partial(
handling.custom_object_handler,
lifecycle=lifecycle,
registry=registry,
resource=resource,
event_queue=event_queue,
freeze=freeze_flag))), # freeze is only checked
])
# On Ctrl+C or pod termination, cancel all tasks gracefully.
if threading.current_thread() is threading.main_thread():
loop.add_signal_handler(signal.SIGINT, should_stop.set)
loop.add_signal_handler(signal.SIGTERM, should_stop.set)
else:
logger.warning(
"OS signals are ignored: running not in the main thread.")
return tasks
async def spawn_tasks(
*,
lifecycle: Optional[lifecycles.LifeCycleFn] = None,
registry: Optional[registries.OperatorRegistry] = None,
settings: Optional[configuration.OperatorSettings] = None,
memories: Optional[containers.ResourceMemories] = None,
standalone: Optional[bool] = None,
priority: Optional[int] = None,
peering_name: Optional[str] = None,
liveness_endpoint: Optional[str] = None,
namespace: Optional[str] = None,
stop_flag: Optional[primitives.Flag] = None,
ready_flag: Optional[primitives.Flag] = None,
vault: Optional[credentials.Vault] = None,
) -> Collection[aiotasks.Task]:
"""
Spawn all the tasks needed to run the operator.
The tasks are properly inter-connected with the synchronisation primitives.
"""
loop = asyncio.get_running_loop()
# The freezer and the registry are scoped to this whole task-set, to sync them all.
lifecycle = lifecycle if lifecycle is not None else lifecycles.get_default_lifecycle(
)
registry = registry if registry is not None else registries.get_default_registry(
)
settings = settings if settings is not None else configuration.OperatorSettings(
)
memories = memories if memories is not None else containers.ResourceMemories(
)
vault = vault if vault is not None else global_vault
vault = vault if vault is not None else credentials.Vault()
event_queue: posting.K8sEventQueue = asyncio.Queue()
freeze_name = f"{peering_name!r}@{namespace}" if namespace else f"cluster-wide {peering_name!r}"
freeze_checker = primitives.ToggleSet()
freeze_toggle = await freeze_checker.make_toggle(name=freeze_name)
signal_flag: aiotasks.Future = asyncio.Future()
started_flag: asyncio.Event = asyncio.Event()
tasks: MutableSequence[aiotasks.Task] = []
# Map kwargs into the settings object.
if peering_name is not None:
settings.peering.mandatory = True
settings.peering.name = peering_name
if standalone is not None:
settings.peering.standalone = standalone
if priority is not None:
settings.peering.priority = priority
# Global credentials store for this operator, also for CRD-reading & peering mode detection.
auth.vault_var.set(vault)
# Special case: pass the settings container through the user-side handlers (no explicit args).
# Toolkits have to keep the original operator context somehow, and the only way is contextvars.
posting.settings_var.set(settings)
# Few common background forever-running infrastructural tasks (irregular root tasks).
tasks.append(
aiotasks.create_task(name="stop-flag checker",
coro=_stop_flag_checker(signal_flag=signal_flag,
stop_flag=stop_flag)))
tasks.append(
aiotasks.create_task(name="ultimate termination",
coro=_ultimate_termination(settings=settings,
stop_flag=stop_flag)))
tasks.append(
aiotasks.create_task(
name="startup/cleanup activities",
coro=_startup_cleanup_activities(
root_tasks=tasks, # used as a "live" view, populated later.
ready_flag=ready_flag,
started_flag=started_flag,
registry=registry,
settings=settings,
vault=vault))) # to purge & finalize the caches in the end.
# Kill all the daemons gracefully when the operator exits (so that they are not "hung").
tasks.append(
aiotasks.create_guarded_task(
name="daemon killer",
flag=started_flag,
logger=logger,
coro=daemons.daemon_killer(settings=settings, memories=memories)))
# Keeping the credentials fresh and valid via the authentication handlers on demand.
tasks.append(
aiotasks.create_guarded_task(name="credentials retriever",
flag=started_flag,
logger=logger,
coro=activities.authenticator(
registry=registry,
settings=settings,
vault=vault)))
# K8s-event posting. Events are queued in-memory and posted in the background.
# NB: currently, it is a global task, but can be made per-resource or per-object.
tasks.append(
aiotasks.create_guarded_task(
name="poster of events",
flag=started_flag,
logger=logger,
coro=posting.poster(event_queue=event_queue)))
# Liveness probing -- so that Kubernetes would know that the operator is alive.
if liveness_endpoint:
tasks.append(
aiotasks.create_guarded_task(name="health reporter",
flag=started_flag,
logger=logger,
coro=probing.health_reporter(
registry=registry,
settings=settings,
endpoint=liveness_endpoint)))
# Monitor the peers, unless explicitly disabled.
if await peering.detect_presence(namespace=namespace, settings=settings):
identity = peering.detect_own_id(manual=False)
tasks.append(
aiotasks.create_guarded_task(name="peering keepalive",
flag=started_flag,
logger=logger,
coro=peering.keepalive(
namespace=namespace,
settings=settings,
identity=identity)))
tasks.append(
aiotasks.create_guarded_task(
name="watcher of peering",
flag=started_flag,
logger=logger,
coro=queueing.watcher(
namespace=namespace,
settings=settings,
resource=peering.guess_resource(namespace=namespace),
processor=functools.partial(peering.process_peering_event,
namespace=namespace,
settings=settings,
identity=identity,
freeze_toggle=freeze_toggle))))
# Resource event handling, only once for every known resource (de-duplicated).
for resource in registry.resources:
tasks.append(
aiotasks.create_guarded_task(
name=f"watcher of {resource.name}",
flag=started_flag,
logger=logger,
coro=queueing.watcher(namespace=namespace,
settings=settings,
resource=resource,
freeze_checker=freeze_checker,
processor=functools.partial(
processing.process_resource_event,
lifecycle=lifecycle,
registry=registry,
settings=settings,
memories=memories,
resource=resource,
event_queue=event_queue))))
# On Ctrl+C or pod termination, cancel all tasks gracefully.
if threading.current_thread() is threading.main_thread():
# Handle NotImplementedError when ran on Windows since asyncio only supports Unix signals
try:
loop.add_signal_handler(signal.SIGINT, signal_flag.set_result,
signal.SIGINT)
loop.add_signal_handler(signal.SIGTERM, signal_flag.set_result,
signal.SIGTERM)
except NotImplementedError:
logger.warning(
"OS signals are ignored: can't add signal handler in Windows.")
else:
logger.warning(
"OS signals are ignored: running not in the main thread.")
return tasks
