def set_state_task_for_instance(ctx, graph, node_id, instance, state_name, step_id):
#ctx.internal.send_workflow_event(
# event_type='other',
# message="call: set_state_task_for_instance(node_id: {0}, state_name: {1}, step_id: {2}, instance: {3})".format(node_id, state_name, step_id, instance))
task = TaskSequenceWrapper(graph)
task.add(build_wf_event_task(instance, step_id, "in"))
task.add(instance.set_state(state_name))
task.add(build_wf_event_task(instance, step_id, "ok"))
#ctx.internal.send_workflow_event(
# event_type='other',
# message="return: set_state_task_for_instance(node_id: {0}, state_name: {1}, step_id: {2}, instance: {3})".format(node_id, state_name, step_id, instance))
return task
def set_state_task_for_instance(ctx, graph, node_id, instance, state_name,
step_id):
#ctx.internal.send_workflow_event(
# event_type='other',
# message="call: set_state_task_for_instance(node_id: {0}, state_name: {1}, step_id: {2}, instance: {3})".format(node_id, state_name, step_id, instance))
task = TaskSequenceWrapper(graph)
task.add(build_wf_event_task(instance, step_id, "in"))
task.add(instance.set_state(state_name))
task.add(build_wf_event_task(instance, step_id, "ok"))
#ctx.internal.send_workflow_event(
# event_type='other',
# message="return: set_state_task_for_instance(node_id: {0}, state_name: {1}, step_id: {2}, instance: {3})".format(node_id, state_name, step_id, instance))
return task
def _delegate_workflow_event(graph, node_id, step_id, operation_fqname, custom_context, stage):
sequence = None
instances = custom_context.modified_instances_per_node.get(node_id, [])
instance_count = len(instances)
if instance_count == 1:
sequence = build_wf_event_task(instances[0], step_id, stage, operation_fqname)
elif instance_count > 1:
fork = ForkjoinWrapper(graph)
for instance in instances:
instance_task = build_wf_event_task(instance, step_id, stage, operation_fqname)
fork.add(instance_task)
msg = "workflow event for step {0} on all {1} node instances".format(step_id, node_id)
sequence = forkjoin_sequence(graph, fork, instances[0], msg)
return sequence
def operation_task_for_instance(ctx, graph, node_id, instance, operation_fqname, step_id):
sequence = TaskSequenceWrapper(graph)
sequence.add(build_wf_event_task(instance, step_id, "in"))
if operation_fqname == 'cloudify.interfaces.lifecycle.start':
sequence.add(instance.execute_operation(operation_fqname))
if _is_host_node_instance(instance):
sequence.add(*host_post_start(ctx, instance))
sequence.add(instance.execute_operation('cloudify.interfaces.monitoring.start'))
host_instance = None
sequence.add(instance.send_event("Start monitoring on node '{0}' instance '{1}'".format(node_id, instance.id)))
if host_instance is not None and host_instance.id == instance.id:
ctx.logger.info("[MAPPING] Do nothing it is the same instance: host_instance.id={} instance.id={}".format(
host_instance.id, instance.id))
elif 'cloudify.nodes.Compute' in instance.node.type_hierarchy:
# This part is specific to Azure as with the Azure plugin, the relationship is from the Compute to a Volume
for relationship in instance.relationships:
# In the Azure definition types of the Cloudify plugin, the datadisk type doesn't derived from cloudify.nodes.Volume
if 'cloudify.azure.nodes.storage.DataDisk' in relationship.target_node_instance.node.type_hierarchy and 'alien4cloud.mapping.device.execute' in instance.node.operations:
volume_instance_id = relationship.target_id
sequence.add(instance.send_event(
"Updating device attribute for instance {} and volume {} (Azure)".format(instance.id,
volume_instance_id)))
sequence.add(instance.execute_operation("alien4cloud.mapping.device.execute",
kwargs={'volume_instance_id': volume_instance_id}))
elif host_instance is not None and 'alien4cloud.mapping.device.execute' in host_instance.node.operations:
sequence.add(host_instance.send_event(
"Updating device attribute for instance {} and volume {}".format(host_instance.id, instance.id)))
sequence.add(host_instance.execute_operation("alien4cloud.mapping.device.execute",
kwargs={'volume_instance_id': instance.id}))
elif operation_fqname == 'cloudify.interfaces.lifecycle.configure':
# the configure operation call itself
sequence.add(instance.execute_operation(operation_fqname))
persistent_event_tasks = build_persistent_event_tasks(instance)
if persistent_event_tasks is not None:
sequence.add(*persistent_event_tasks)
elif operation_fqname == 'cloudify.interfaces.lifecycle.stop':
if _is_host_node_instance(instance):
sequence.add(*host_pre_stop(instance))
task = instance.execute_operation(operation_fqname)
sequence.add(task)
elif operation_fqname == 'cloudify.interfaces.lifecycle.delete':
task = instance.execute_operation(operation_fqname)
sequence.add(task)
else:
# the default behavior : just do the job
sequence.add(instance.execute_operation(operation_fqname))
sequence.add(build_wf_event_task(instance, step_id, "ok"))
return sequence
def operation_task_for_instance(ctx, graph, node_id, instance, operation_fqname, step_id, custom_context):
sequence = TaskSequenceWrapper(graph)
sequence.add(build_wf_event_task(instance, step_id, "in"))
relationship_count = count_relationships(instance)
if operation_fqname == 'cloudify.interfaces.lifecycle.start':
sequence.add(instance.execute_operation(operation_fqname))
if _is_host_node(instance):
sequence.add(*host_post_start(ctx, instance))
fork = ForkjoinWrapper(graph)
fork.add(instance.execute_operation('cloudify.interfaces.monitoring.start'))
if relationship_count > 0:
for relationship in instance.relationships:
fork.add(relationship.execute_source_operation('cloudify.interfaces.relationship_lifecycle.establish'))
fork.add(relationship.execute_target_operation('cloudify.interfaces.relationship_lifecycle.establish'))
sequence.add(
instance.send_event("Start monitoring on node '{0}' instance '{1}'".format(node_id, instance.id)),
forkjoin_sequence(graph, fork, instance, "establish")
)
elif operation_fqname == 'cloudify.interfaces.lifecycle.configure':
as_target_relationships = custom_context.relationship_targets.get(instance.id, set())
if relationship_count > 0 or len(as_target_relationships) > 0:
preconfigure_tasks = ForkjoinWrapper(graph)
for relationship in instance.relationships:
preconfigure_tasks.add(relationship.execute_source_operation('cloudify.interfaces.relationship_lifecycle.preconfigure'))
for relationship in as_target_relationships:
preconfigure_tasks.add(relationship.execute_target_operation('cloudify.interfaces.relationship_lifecycle.preconfigure'))
sequence.add(forkjoin_sequence(graph, preconfigure_tasks, instance, "preconf for {0}".format(instance.id)))
sequence.add(instance.execute_operation(operation_fqname))
if relationship_count > 0 or len(as_target_relationships) > 0:
postconfigure_tasks = ForkjoinWrapper(graph)
for relationship in instance.relationships:
postconfigure_tasks.add(relationship.execute_source_operation('cloudify.interfaces.relationship_lifecycle.postconfigure'))
for relationship in as_target_relationships:
task = relationship.execute_target_operation('cloudify.interfaces.relationship_lifecycle.postconfigure')
_set_send_node_event_on_error_handler(task, instance, "Error occurred while postconfiguring node as target for relationship {0} - ignoring...".format(relationship))
postconfigure_tasks.add(task)
msg = "postconf for {0}".format(instance.id)
sequence.add(forkjoin_sequence(graph, postconfigure_tasks, instance, msg))
persistent_event_task = build_persistent_event_task(instance)
if persistent_event_task is not None:
sequence.add(persistent_event_task)
elif operation_fqname == 'cloudify.interfaces.lifecycle.stop':
if _is_host_node(instance):
sequence.add(*host_pre_stop(instance))
task = instance.execute_operation(operation_fqname)
_set_send_node_event_on_error_handler(task, instance, "Error occurred while stopping node - ignoring...")
sequence.add(task)
# now call unlink onto relations' target
if relationship_count > 0:
fork = ForkjoinWrapper(graph)
for relationship in instance.relationships:
unlink_task_source = relationship.execute_source_operation('cloudify.interfaces.relationship_lifecycle.unlink')
_set_send_node_event_on_error_handler(unlink_task_source, instance, "Error occurred while unlinking node from target {0} - ignoring...".format(relationship.target_id))
fork.add(unlink_task_source)
unlink_task_target = relationship.execute_target_operation('cloudify.interfaces.relationship_lifecycle.unlink')
_set_send_node_event_on_error_handler(unlink_task_target, instance, "Error occurred while unlinking node from target {0} - ignoring...".format(relationship.target_id))
fork.add(unlink_task_target)
sequence.add(forkjoin_sequence(graph, fork, instance, "unlink"))
elif operation_fqname == 'cloudify.interfaces.lifecycle.delete':
task = instance.execute_operation(operation_fqname)
_set_send_node_event_on_error_handler(task, instance, "Error occurred while deleting node - ignoring...")
sequence.add(task)
else:
# the default behavior : just do the job
sequence.add(instance.execute_operation(operation_fqname))
sequence.add(build_wf_event_task(instance, step_id, "ok"))
return sequence
def set_state_task_for_instance(graph, node_id, instance, state_name, step_id):
task = TaskSequenceWrapper(graph)
task.add(build_wf_event_task(instance, step_id, "in"))
task.add(instance.set_state(state_name))
task.add(build_wf_event_task(instance, step_id, "ok"))
return task
def operation_task_for_instance(ctx, graph, node_id, instance, operation_fqname, step_id, custom_context):
sequence = TaskSequenceWrapper(graph)
sequence.add(build_wf_event_task(instance, step_id, "in"))
relationship_count = count_relationships(instance)
if operation_fqname == 'cloudify.interfaces.lifecycle.start':
sequence.add(instance.execute_operation(operation_fqname))
if _is_host_node_instance(instance):
sequence.add(*host_post_start(ctx, instance))
fork = ForkjoinWrapper(graph)
fork.add(instance.execute_operation('cloudify.interfaces.monitoring.start'))
as_target_relationships = custom_context.relationship_targets.get(instance.id, set())
host_instance = None
if relationship_count > 0 or len(as_target_relationships) > 0:
for relationship in instance.relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
fork.add(relationship.execute_source_operation('cloudify.interfaces.relationship_lifecycle.establish'))
# if the target of the relation is not in modified instances, we should call the target.add_source
#if relationship.target_node_instance.id not in custom_context.modified_instance_ids:
fork.add(relationship.execute_target_operation('cloudify.interfaces.relationship_lifecycle.establish'))
if 'cloudify.nodes.Volume' in instance.node.type_hierarchy:
host_instance = __get_host(ctx, relationship.target_node_instance)
for relationship in as_target_relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
if relationship.node_instance.id not in custom_context.modified_instance_ids:
fork.add(relationship.execute_target_operation('cloudify.interfaces.relationship_lifecycle.establish'))
if relationship.node_instance.id not in custom_context.modified_instance_ids:
fork.add(relationship.execute_source_operation('cloudify.interfaces.relationship_lifecycle.establish'))
sequence.add(
instance.send_event("Start monitoring on node '{0}' instance '{1}'".format(node_id, instance.id)),
forkjoin_sequence(graph, fork, instance, "establish")
)
if host_instance is not None and 'alien4cloud.mapping.device.execute' in host_instance.node.operations:
sequence.add(host_instance.send_event("Updating device attribute for instance {0} and volume {0}".format(host_instance.id, instance.id)))
sequence.add(host_instance.execute_operation("alien4cloud.mapping.device.execute", kwargs={'volume_instance_id': instance.id}))
elif operation_fqname == 'cloudify.interfaces.lifecycle.configure':
as_target_relationships = custom_context.relationship_targets.get(instance.id, set())
if relationship_count > 0 or len(as_target_relationships) > 0:
has_preconfigure_tasks = False
preconfigure_tasks = ForkjoinWrapper(graph)
preconfigure_tasks.add(instance.send_event("preconfiguring task for instance {0}'".format(instance.id)))
for relationship in instance.relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
if __check_and_register_call_config_arround(ctx, custom_context, relationship, 'source', 'pre'):
preconfigure_tasks.add(relationship.execute_source_operation('cloudify.interfaces.relationship_lifecycle.preconfigure'))
has_preconfigure_tasks = True
for relationship in as_target_relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
if __check_and_register_call_config_arround(ctx, custom_context, relationship, 'target', 'pre'):
preconfigure_tasks.add(relationship.execute_target_operation('cloudify.interfaces.relationship_lifecycle.preconfigure'))
has_preconfigure_tasks = True
if has_preconfigure_tasks:
sequence.add(forkjoin_sequence(graph, preconfigure_tasks, instance, "preconf for {0}".format(instance.id)))
# the configure operation call itself
sequence.add(instance.execute_operation(operation_fqname))
if relationship_count > 0 or len(as_target_relationships) > 0:
has_postconfigure_tasks = False
postconfigure_tasks = ForkjoinWrapper(graph)
postconfigure_tasks.add(instance.send_event("postconfiguring task for instance {0}'".format(instance.id)))
for relationship in instance.relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
if __check_and_register_call_config_arround(ctx, custom_context, relationship, 'source', 'post'):
postconfigure_tasks.add(relationship.execute_source_operation('cloudify.interfaces.relationship_lifecycle.postconfigure'))
has_postconfigure_tasks = True
for relationship in as_target_relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
if __check_and_register_call_config_arround(ctx, custom_context, relationship, 'target', 'post'):
task = relationship.execute_target_operation('cloudify.interfaces.relationship_lifecycle.postconfigure')
_set_send_node_event_on_error_handler(task, instance, "Error occurred while postconfiguring node as target for relationship {0} - ignoring...".format(relationship))
postconfigure_tasks.add(task)
has_postconfigure_tasks = True
if has_postconfigure_tasks:
sequence.add(forkjoin_sequence(graph, postconfigure_tasks, instance, "postconf for {0}".format(instance.id)))
persistent_event_tasks = build_persistent_event_tasks(instance)
if persistent_event_tasks is not None:
sequence.add(*persistent_event_tasks)
elif operation_fqname == 'cloudify.interfaces.lifecycle.stop':
if _is_host_node_instance(instance):
sequence.add(*host_pre_stop(instance))
task = instance.execute_operation(operation_fqname)
_set_send_node_event_on_error_handler(task, instance, "Error occurred while stopping node - ignoring...")
sequence.add(task)
as_target_relationships = custom_context.relationship_targets.get(instance.id, set())
# now call unlink onto relations' target
if relationship_count > 0 or len(as_target_relationships) > 0:
fork = ForkjoinWrapper(graph)
for relationship in instance.relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
unlink_task_source = relationship.execute_source_operation('cloudify.interfaces.relationship_lifecycle.unlink')
_set_send_node_event_on_error_handler(unlink_task_source, instance, "Error occurred while unlinking node from target {0} - ignoring...".format(relationship.target_id))
fork.add(unlink_task_source)
# call unlink on the target of the relationship
unlink_task_target = relationship.execute_target_operation('cloudify.interfaces.relationship_lifecycle.unlink')
_set_send_node_event_on_error_handler(unlink_task_target, instance, "Error occurred while unlinking node from target {0} - ignoring...".format(relationship.target_id))
fork.add(unlink_task_target)
for relationship in as_target_relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
if relationship.node_instance.id not in custom_context.modified_instance_ids:
unlink_task_source = relationship.execute_source_operation('cloudify.interfaces.relationship_lifecycle.unlink')
_set_send_node_event_on_error_handler(unlink_task_source, instance, "Error occurred while unlinking node from target {0} - ignoring...".format(relationship.target_id))
fork.add(unlink_task_source)
if fork.is_not_empty():
sequence.add(forkjoin_sequence(graph, fork, instance, "unlink"))
elif operation_fqname == 'cloudify.interfaces.lifecycle.delete':
task = instance.execute_operation(operation_fqname)
_set_send_node_event_on_error_handler(task, instance, "Error occurred while deleting node - ignoring...")
sequence.add(task)
else:
# the default behavior : just do the job
sequence.add(instance.execute_operation(operation_fqname))
sequence.add(build_wf_event_task(instance, step_id, "ok"))
return sequence
def operation_task_for_instance(ctx, graph, node_id, instance,
operation_fqname, step_id, custom_context):
sequence = TaskSequenceWrapper(graph)
sequence.add(build_wf_event_task(instance, step_id, "in"))
relationship_count = count_relationships(instance)
if operation_fqname == 'cloudify.interfaces.lifecycle.start':
sequence.add(instance.execute_operation(operation_fqname))
if _is_host_node_instance(instance):
sequence.add(*host_post_start(ctx, instance))
fork = ForkjoinWrapper(graph)
fork.add(
instance.execute_operation('cloudify.interfaces.monitoring.start'))
as_target_relationships = custom_context.relationship_targets.get(
instance.id, set())
host_instance = None
if relationship_count > 0 or len(as_target_relationships) > 0:
for relationship in instance.relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
fork.add(
relationship.execute_source_operation(
'cloudify.interfaces.relationship_lifecycle.establish'
))
# if the target of the relation is not in modified instances, we should call the target.add_source
#if relationship.target_node_instance.id not in custom_context.modified_instance_ids:
fork.add(
relationship.execute_target_operation(
'cloudify.interfaces.relationship_lifecycle.establish'
))
if 'cloudify.nodes.Volume' in instance.node.type_hierarchy:
host_instance = __get_host(
ctx, relationship.target_node_instance)
for relationship in as_target_relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
if relationship.node_instance.id not in custom_context.modified_instance_ids:
fork.add(
relationship.execute_target_operation(
'cloudify.interfaces.relationship_lifecycle.establish'
))
if relationship.node_instance.id not in custom_context.modified_instance_ids:
fork.add(
relationship.execute_source_operation(
'cloudify.interfaces.relationship_lifecycle.establish'
))
sequence.add(
instance.send_event(
"Start monitoring on node '{0}' instance '{1}'".format(
node_id, instance.id)),
forkjoin_sequence(graph, fork, instance, "establish"))
if host_instance is not None and 'alien4cloud.mapping.device.execute' in host_instance.node.operations:
sequence.add(
host_instance.send_event(
"Updating device attribute for instance {0} and volume {0}"
.format(host_instance.id, instance.id)))
sequence.add(
host_instance.execute_operation(
"alien4cloud.mapping.device.execute",
kwargs={'volume_instance_id': instance.id}))
elif operation_fqname == 'cloudify.interfaces.lifecycle.configure':
as_target_relationships = custom_context.relationship_targets.get(
instance.id, set())
if relationship_count > 0 or len(as_target_relationships) > 0:
has_preconfigure_tasks = False
preconfigure_tasks = ForkjoinWrapper(graph)
preconfigure_tasks.add(
instance.send_event(
"preconfiguring task for instance {0}'".format(
instance.id)))
for relationship in instance.relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
if __check_and_register_call_config_arround(
ctx, custom_context, relationship, 'source',
'pre'):
preconfigure_tasks.add(
relationship.execute_source_operation(
'cloudify.interfaces.relationship_lifecycle.preconfigure'
))
has_preconfigure_tasks = True
for relationship in as_target_relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
if __check_and_register_call_config_arround(
ctx, custom_context, relationship, 'target',
'pre'):
preconfigure_tasks.add(
relationship.execute_target_operation(
'cloudify.interfaces.relationship_lifecycle.preconfigure'
))
has_preconfigure_tasks = True
if has_preconfigure_tasks:
sequence.add(
forkjoin_sequence(graph, preconfigure_tasks, instance,
"preconf for {0}".format(instance.id)))
# the configure operation call itself
sequence.add(instance.execute_operation(operation_fqname))
if relationship_count > 0 or len(as_target_relationships) > 0:
has_postconfigure_tasks = False
postconfigure_tasks = ForkjoinWrapper(graph)
postconfigure_tasks.add(
instance.send_event(
"postconfiguring task for instance {0}'".format(
instance.id)))
for relationship in instance.relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
if __check_and_register_call_config_arround(
ctx, custom_context, relationship, 'source',
'post'):
postconfigure_tasks.add(
relationship.execute_source_operation(
'cloudify.interfaces.relationship_lifecycle.postconfigure'
))
has_postconfigure_tasks = True
for relationship in as_target_relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
if __check_and_register_call_config_arround(
ctx, custom_context, relationship, 'target',
'post'):
task = relationship.execute_target_operation(
'cloudify.interfaces.relationship_lifecycle.postconfigure'
)
_set_send_node_event_on_error_handler(
task, instance,
"Error occurred while postconfiguring node as target for relationship {0} - ignoring..."
.format(relationship))
postconfigure_tasks.add(task)
has_postconfigure_tasks = True
if has_postconfigure_tasks:
sequence.add(
forkjoin_sequence(graph, postconfigure_tasks, instance,
"postconf for {0}".format(instance.id)))
persistent_event_tasks = build_persistent_event_tasks(instance)
if persistent_event_tasks is not None:
sequence.add(*persistent_event_tasks)
elif operation_fqname == 'cloudify.interfaces.lifecycle.stop':
if _is_host_node_instance(instance):
sequence.add(*host_pre_stop(instance))
task = instance.execute_operation(operation_fqname)
_set_send_node_event_on_error_handler(
task, instance, "Error occurred while stopping node - ignoring...")
sequence.add(task)
as_target_relationships = custom_context.relationship_targets.get(
instance.id, set())
# now call unlink onto relations' target
if relationship_count > 0 or len(as_target_relationships) > 0:
fork = ForkjoinWrapper(graph)
for relationship in instance.relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
unlink_task_source = relationship.execute_source_operation(
'cloudify.interfaces.relationship_lifecycle.unlink')
_set_send_node_event_on_error_handler(
unlink_task_source, instance,
"Error occurred while unlinking node from target {0} - ignoring..."
.format(relationship.target_id))
fork.add(unlink_task_source)
if relationship.target_node_instance.id not in custom_context.modified_instance_ids:
unlink_task_target = relationship.execute_target_operation(
'cloudify.interfaces.relationship_lifecycle.unlink'
)
_set_send_node_event_on_error_handler(
unlink_task_target, instance,
"Error occurred while unlinking node from target {0} - ignoring..."
.format(relationship.target_id))
fork.add(unlink_task_target)
for relationship in as_target_relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
unlink_task_target = relationship.execute_target_operation(
'cloudify.interfaces.relationship_lifecycle.unlink')
_set_send_node_event_on_error_handler(
unlink_task_target, instance,
"Error occurred while unlinking node from target {0} - ignoring..."
.format(relationship.target_id))
fork.add(unlink_task_target)
if relationship.node_instance.id not in custom_context.modified_instance_ids:
unlink_task_source = relationship.execute_source_operation(
'cloudify.interfaces.relationship_lifecycle.unlink'
)
_set_send_node_event_on_error_handler(
unlink_task_source, instance,
"Error occurred while unlinking node from target {0} - ignoring..."
.format(relationship.target_id))
fork.add(unlink_task_source)
sequence.add(forkjoin_sequence(graph, fork, instance, "unlink"))
elif operation_fqname == 'cloudify.interfaces.lifecycle.delete':
task = instance.execute_operation(operation_fqname)
_set_send_node_event_on_error_handler(
task, instance, "Error occurred while deleting node - ignoring...")
sequence.add(task)
else:
# the default behavior : just do the job
sequence.add(instance.execute_operation(operation_fqname))
sequence.add(build_wf_event_task(instance, step_id, "ok"))
return sequence
def operation_task_for_native_instance(ctx, graph, node_id, instance, operation_fqname, step_id, custom_context):
sequence = TaskSequenceWrapper(graph)
sequence.add(build_wf_event_task(instance, step_id, "in", operation_fqname))
relationship_count = count_relationships(instance)
if operation_fqname == 'cloudify.interfaces.lifecycle.start':
sequence.add(instance.execute_operation(operation_fqname))
if _is_host_node_instance(instance):
sequence.add(*host_post_start(ctx, instance))
sequence.add(instance.execute_operation('cloudify.interfaces.monitoring.start'))
as_target_relationships = custom_context.relationship_targets.get(instance.id, set())
host_instance = None
if relationship_count > 0 or len(as_target_relationships) > 0:
for relationship in instance.relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
sequence.add(
relationship.execute_source_operation('cloudify.interfaces.relationship_lifecycle.establish'))
# if the target of the relation is not in modified instances, we should call the target.add_source
# if relationship.target_node_instance.id not in custom_context.modified_instance_ids:
sequence.add(
relationship.execute_target_operation('cloudify.interfaces.relationship_lifecycle.establish'))
if 'cloudify.nodes.Volume' in instance.node.type_hierarchy:
ctx.logger.info(
"[MAPPING] instance={} hierarchy={}".format(instance.id, instance.node.type_hierarchy))
host_instance = __get_host(ctx, relationship.target_node_instance)
for relationship in as_target_relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
if relationship.node_instance.id not in custom_context.modified_instance_ids:
sequence.add(relationship.execute_target_operation(
'cloudify.interfaces.relationship_lifecycle.establish'))
if relationship.node_instance.id not in custom_context.modified_instance_ids:
sequence.add(relationship.execute_source_operation(
'cloudify.interfaces.relationship_lifecycle.establish'))
sequence.add(instance.send_event("Start monitoring on node '{0}' instance '{1}'".format(node_id, instance.id)))
if host_instance is not None and host_instance.id == instance.id:
ctx.logger.info("[MAPPING] Do nothing it is the same instance: host_instance.id={} instance.id={}".format(
host_instance.id, instance.id))
elif 'cloudify.nodes.Compute' in instance.node.type_hierarchy:
# This part is specific to Azure as with the Azure plugin, the relationship is from the Compute to a Volume
for relationship in instance.relationships:
# In the Azure definition types of the Cloudify plugin, the datadisk type doesn't derived from cloudify.nodes.Volume
if 'cloudify.azure.nodes.storage.DataDisk' in relationship.target_node_instance.node.type_hierarchy and 'alien4cloud.mapping.device.execute' in instance.node.operations:
volume_instance_id = relationship.target_id
sequence.add(instance.send_event(
"Updating device attribute for instance {} and volume {} (Azure)".format(instance.id,
volume_instance_id)))
sequence.add(instance.execute_operation("alien4cloud.mapping.device.execute",
kwargs={'volume_instance_id': volume_instance_id}))
elif host_instance is not None and 'alien4cloud.mapping.device.execute' in host_instance.node.operations:
sequence.add(host_instance.send_event(
"Updating device attribute for instance {} and volume {}".format(host_instance.id, instance.id)))
sequence.add(host_instance.execute_operation("alien4cloud.mapping.device.execute",
kwargs={'volume_instance_id': instance.id}))
elif operation_fqname == 'cloudify.interfaces.lifecycle.configure':
as_target_relationships = custom_context.relationship_targets.get(instance.id, set())
if relationship_count > 0 or len(as_target_relationships) > 0:
sequence.add(instance.send_event("preconfiguring task for instance {0}'".format(instance.id)))
for relationship in instance.relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
if __check_and_register_call_config_around(ctx, custom_context, relationship, 'source', 'pre'):
sequence.add(relationship.execute_source_operation(
'cloudify.interfaces.relationship_lifecycle.preconfigure'))
for relationship in as_target_relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
if __check_and_register_call_config_around(ctx, custom_context, relationship, 'target', 'pre'):
sequence.add(relationship.execute_target_operation(
'cloudify.interfaces.relationship_lifecycle.preconfigure'))
# the configure operation call itself
sequence.add(instance.execute_operation(operation_fqname))
if relationship_count > 0 or len(as_target_relationships) > 0:
sequence.add(instance.send_event("postconfiguring task for instance {0}'".format(instance.id)))
for relationship in instance.relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
if __check_and_register_call_config_around(ctx, custom_context, relationship, 'source', 'post'):
sequence.add(relationship.execute_source_operation(
'cloudify.interfaces.relationship_lifecycle.postconfigure'))
has_postconfigure_tasks = True
for relationship in as_target_relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
if __check_and_register_call_config_around(ctx, custom_context, relationship, 'target', 'post'):
task = relationship.execute_target_operation(
'cloudify.interfaces.relationship_lifecycle.postconfigure')
_set_send_node_event_on_error_handler(task, instance,
"Error occurred while postconfiguring node as target for relationship {0} - ignoring...".format(
relationship))
sequence.add(task)
persistent_event_tasks = build_persistent_event_tasks(instance)
if persistent_event_tasks is not None:
sequence.add(*persistent_event_tasks)
elif operation_fqname == 'cloudify.interfaces.lifecycle.stop':
if _is_host_node_instance(instance):
sequence.add(*host_pre_stop(instance))
task = instance.execute_operation(operation_fqname)
if custom_context.is_native_node(instance):
def send_node_event_error_handler(tsk):
instance.send_event('ignore stop failure')
return workflow_tasks.HandlerResult.ignore()
task.on_failure = send_node_event_error_handler
sequence.add(task)
as_target_relationships = custom_context.relationship_targets.get(instance.id, set())
# now call unlink onto relations' target
if relationship_count > 0 or len(as_target_relationships) > 0:
for relationship in instance.relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
unlink_task_source = relationship.execute_source_operation(
'cloudify.interfaces.relationship_lifecycle.unlink')
sequence.add(unlink_task_source)
# call unlink on the target of the relationship
unlink_task_target = relationship.execute_target_operation(
'cloudify.interfaces.relationship_lifecycle.unlink')
sequence.add(unlink_task_target)
for relationship in as_target_relationships:
# add a condition in order to test if it's a 1-1 rel
if should_call_relationship_op(ctx, relationship):
if relationship.node_instance.id not in custom_context.modified_instance_ids:
unlink_task_source = relationship.execute_source_operation(
'cloudify.interfaces.relationship_lifecycle.unlink')
sequence.add(unlink_task_source)
unlink_task_target = relationship.execute_target_operation(
'cloudify.interfaces.relationship_lifecycle.unlink')
sequence.add(unlink_task_target)
elif operation_fqname == 'cloudify.interfaces.lifecycle.delete':
task = instance.execute_operation(operation_fqname)
if custom_context.is_native_node(instance):
def send_node_event_error_handler(tsk):
instance.send_event('ignore delete failure')
return workflow_tasks.HandlerResult.ignore()
task.on_failure = send_node_event_error_handler
sequence.add(task)
else:
# the default behavior : just do the job
sequence.add(instance.execute_operation(operation_fqname))
sequence.add(build_wf_event_task(instance, step_id, "ok", operation_fqname))
return sequence
