def execute_resource(self, host, resource, handlers=False):
"""
This handles the plan/apply intercharge for a given resource in the resource tree.
It is called recursively via walk_children to run against all resources.
"""
assert host is not None
# we only care about processing leaf node objects
if self.is_collection(resource):
return
# if in handler mode we do not process the handler unless it was signaled
if handlers and not Context.has_seen_any_signal(host, resource.all_handles()):
Callbacks.on_skipped(resource, is_handler=handlers)
return
# tell the callbacks we are about to process a resource
# they may use this to print information about the resource
Callbacks.on_resource(resource, handlers)
# plan always, apply() only if not in check mode, else assume
# the plan was executed.
provider = self.do_plan(resource)
assert provider is not None
if Context.is_apply():
self.do_apply(host, provider, handlers)
else: # is_check
self.do_simulate(host, provider)
# if anything has changed, let the callbacks know about it
self.signal_changes(host=host, provider=provider, resource=resource)
def process_role_internal(self, host, policy, role, local=True, sender=None):
if not local:
from opsmop.callbacks.event_stream import EventStreamStreamCallbacks
from opsmop.callbacks.common import CommonCallbacks
Context.set_callbacks([ EventStreamCallbacks(sender=sender), CommonCallbacks() ])
role.pre()
# set up the variable scope - this is done later by walk_handlers for lower-level objects in the tree
policy.attach_child_scope_for(role)
# tell the callbacks we are in validate mode - this may alter or quiet their output
Callbacks.on_validate()
# always validate the role in every mode (VALIDATE, CHECK ,or APPLY)
self.validate_role(role)
# skip the role if we need to
if not role.conditions_true():
Callbacks.on_skipped(role)
return
# process the tree for real for non-validate modes
if not Context.is_validate():
self.execute_role_resources(host, role)
self.execute_role_handlers(host, role)
# run any user hooks
role.post()