def open_file(self, extension, normalize=False):
# Create the target directory if not already exists.
target_directory = self.create_target_directory()
# Compute the file path.
# TODO: call sefl.compute_filename()
template_yaml = self.tosca_service_template.get_yaml()
metadata = template_yaml.get("metadata")
if metadata is None:
metadata = template_yaml
template_name = metadata.get("template_name")
if template_name is not None:
filename = template_name
template_version = metadata.get("template_version")
if template_version is not None:
filename = filename + "-" + str(template_version)
if normalize:
filename = normalize_name(filename)
if extension is not None:
filename = filename + ".ext"
else:
filename = self.tosca_service_template.get_filename()
if extension is not None:
filename = filename[: filename.rfind(".")]
if normalize:
filename = normalize_name(filename)
filepath = target_directory + "/" + filename + extension
else:
filepath = target_directory + "/" + filename
# Open the file.
self.file = open(filepath, "w")
self.logger.info(filepath + " opened.")
def generate_container(self, container_name, containeds):
node_template = node_templates.get(container_name)
node_template_type = node_template.get(TYPE)
uml2_kind = get_uml2_kind(node_template_type)
node_template_artifacts = get_dict(node_template, ARTIFACTS)
if len(containeds) == 0 and len(node_template_artifacts) == 0:
self.generate(
uml2_kind,
' "',
container_name,
": ",
short_type_name(node_template_type),
'" as node_',
normalize_name(container_name),
sep="",
)
else:
self.generate(
uml2_kind,
' "',
container_name,
": ",
short_type_name(node_template_type),
'" as node_',
normalize_name(container_name),
" {",
sep="",
)
for contained_name, contained_dict in containeds.items():
generate_container(self, contained_name, contained_dict)
for artifact_name, artifact_yaml in node_template_artifacts.items(
):
artifact_type = syntax.get_artifact_type(artifact_yaml)
if artifact_type is None:
artifact_type = "Artifact"
self.generate(
'artifact "',
syntax.get_artifact_file(artifact_yaml),
'" <<',
artifact_type,
">> as node_",
normalize_name(container_name),
"_artifact_",
normalize_name(artifact_name),
sep="",
)
self.generate("}")
def open_file(self, extension, normalize=False):
# Create the target directory if not already exists.
target_directory = self.create_target_directory()
# Compute the file path.
# TODO: call self.compute_filename()
format = self.configuration.get("Generator", "filename-format")
if format == "fullname":
filename = self.get_filename(self.tosca_service_template)
filename = filename[:filename.rfind(".")]
if normalize:
filename = normalize_name(filename)
filepath = target_directory + "/" + filename
if extension != None:
filepath += extension
else: # else format is shortname
template_yaml = self.tosca_service_template.get_yaml()
metadata = template_yaml.get("metadata")
if metadata == None:
metadata = template_yaml
template_name = metadata.get("template_name")
if template_name != None:
filename = template_name
template_version = metadata.get("template_version")
if template_version != None:
filename = filename + "-" + str(template_version)
if normalize:
filename = normalize_name(filename)
if extension != None:
filename = filename + ".ext"
else:
filename = self.get_filename(self.tosca_service_template)
if extension != None:
filename = filename[:filename.rfind(".")]
if normalize:
filename = normalize_name(filename)
filepath = target_directory + "/" + filename + extension
else:
filepath = target_directory + "/" + filename
# Open the file.
self.file = open(filepath, "w")
self.info(filepath + " opened.")
def generate_node_template(self, steps, node_name, node_template):
templated_steps = \
self.get_config_for_a_type("node_types", node_template.get('type'))
if templated_steps is None:
return
# duplicate templated_steps
templated_steps = copy.deepcopy(templated_steps.get('steps', {}))
if isinstance(templated_steps, dict):
for step_name, step_def in templated_steps.items():
# the target of steps is the node name
step_def["target"] = node_name
# rename on_success steps
on_success_steps = step_def.get("on_success")
if on_success_steps != None:
for idx in range(0, len(on_success_steps)):
on_success_step_name = on_success_steps[idx]
if on_success_step_name in templated_steps:
on_success_steps[
idx] = on_success_step_name + '_' + utils.normalize_name(
node_name)
# add the step to the workflow steps
steps[step_name + '_' +
utils.normalize_name(node_name)] = step_def
elif isinstance(templated_steps, list):
previous_step = {}
for templated_step in templated_steps:
for step_name, step_def in templated_step.items():
# the target of steps is the node name
step_def["target"] = node_name
# link previous step with this step
previous_step["on_success"] = [
step_name + '_' + utils.normalize_name(node_name)
]
previous_step = step_def
# add the step to the workflow steps
steps[step_name + '_' +
utils.normalize_name(node_name)] = step_def
def generate_relationship_weave_steps(self, steps, relationship):
weave_steps = \
self.get_config_for_a_type( \
"relationship_types", \
relationship.relationship_type_name)
if weave_steps is None:
return
format_args = {
'SOURCE':
utils.normalize_name(relationship.source_node_template_name),
'TARGET':
utils.normalize_name(relationship.target_node_template_name),
}
for weave_step in weave_steps.get("weave_steps", []):
weave_step = weave_step.format_map(format_args)
self.processor.debug(" weave " + weave_step)
tmp = weave_step.split(' ')
if steps.get(tmp[0]) is None:
self.processor.debug("- no %r step" % tmp[0])
continue # next weave_step
if steps.get(tmp[2]) is None:
self.processor.debug("- no %r step" % tmp[2])
continue # next weave_step
on_success = steps[tmp[0]].get("on_success")
if on_success is None:
on_success = []
steps[tmp[0]]["on_success"] = on_success
if tmp[1] == "before":
if tmp[2] not in on_success:
on_success.append(tmp[2])
elif tmp[1] == "follow":
if steps[tmp[2]].get("on_success") != None:
for s in steps[tmp[2]]["on_success"]:
if s not in on_success:
on_success.append(s)
steps[tmp[2]]["on_success"] = [] # TODO or [ tmp[0] ] ???
else:
raise Exception(weave_step)
def compute_filename(self, tosca_service_template, normalize=True):
# Compute the file path.
template_yaml = tosca_service_template.get_yaml()
metadata = template_yaml.get("metadata")
if metadata is None:
metadata = template_yaml
template_name = metadata.get("template_name")
if template_name is not None:
filename = template_name
template_version = metadata.get("template_version")
if template_version is not None:
filename = filename + "-" + str(template_version)
else:
tmp = tosca_service_template.get_filename()
filename = tmp[: tmp.rfind(".")]
if normalize:
filename = normalize_name(filename)
return filename
def compute_filename(self, tosca_service_template, normalize=True):
# Compute the file path.
format = self.configuration.get("Generator", "filename-format")
if format == "fullname":
filename = self.get_filename(tosca_service_template)
return filename[:filename.rfind('.')]
# else format is shortname
template_yaml = tosca_service_template.get_yaml()
metadata = template_yaml.get("metadata")
if metadata is None:
metadata = template_yaml
template_name = metadata.get("template_name")
if template_name is not None:
filename = template_name
template_version = metadata.get("template_version")
if template_version is not None:
filename = filename + "-" + str(template_version)
else:
tmp = self.get_filename(tosca_service_template)
filename = tmp[:tmp.rfind(".")]
if normalize:
filename = normalize_name(filename)
return filename
def generation(self):
self.info("TOSCA diagram generation")
topology_template = syntax.get_topology_template(
self.tosca_service_template.get_yaml())
# Generate only for TOSCA topology template.
if topology_template is None:
return
# Generate the TOSCA diagram.
self.open_file(".dot")
self.generate("graph ToscaDiagram {")
self.generate(' rankdir="LR"')
target_capability_ids = {
} # map<requirement_assignment_id,capability_id>
connected_capabilities = set() # set<node_name.capability_name>
connected_requirements = set() # set<node_name.requirement_name>
substitution_mappings = syntax.get_substitution_mappings(
topology_template)
if substitution_mappings is not None:
for capability_name, capability_yaml in syntax.get_capabilities(
substitution_mappings).items():
if capability_yaml:
if not isinstance(capability_yaml, list):
continue # TODO something when capability_yaml is not a list
capability_name_id = "topology_template_substitution_mappings_capability_" + normalize_name(
capability_name)
self.generate(
" ",
capability_name_id,
'[label="',
capability_name,
'" shape=cds style=filled fillcolor=orange]',
sep="",
)
self.generate(
" ",
capability_name_id,
" -- ",
normalize_name(capability_yaml[0]),
"_capability_",
normalize_name(capability_yaml[1]),
"[style=dotted]",
sep="",
)
connected_capabilities.add(capability_yaml[0] + "." +
capability_yaml[1])
for (
requirement_name,
requirement_yaml,
) in syntax.get_substitution_mappings_requirements(
substitution_mappings).items():
if requirement_yaml:
connected_requirements.add(requirement_yaml[0] + "." +
requirement_yaml[1])
substitution_mappings_node_type = syntax.get_node_type(
substitution_mappings)
self.generate(" subgraph clusterSubstitutionMappings {")
self.generate(' label="',
substitution_mappings_node_type,
'"',
sep="")
node_templates = syntax.get_node_templates(topology_template)
for node_name, node_yaml in node_templates.items():
node_type_requirements = syntax.get_requirements_dict(
self.type_system.merge_type(syntax.get_type(node_yaml)))
for requirement in syntax.get_requirements_list(node_yaml):
for requirement_name, requirement_yaml in requirement.items():
# ACK for Alien4Cloud
requirement_name = syntax.get_type_requirement(
requirement_yaml, requirement_name)
if requirement_yaml:
requirement_capability = syntax.get_requirement_capability(
node_type_requirements.get(requirement_name))
if requirement_capability is None:
self.error(
requirement_name + ": capability undefined",
requirement_name,
)
continue
requirement_node = syntax.get_requirement_node_template(
requirement_yaml)
if requirement_node is None:
continue
capability_found = False
requirement_node_template = node_templates.get(
requirement_node)
if requirement_node_template is None:
self.error(
requirement_node + " node template undefined",
requirement_node,
)
continue
for capability_name, capability_yaml in syntax.get_capabilities(
self.type_system.merge_node_type(
syntax.get_type(
requirement_node_template))).items():
if self.type_system.is_derived_from(
syntax.get_capability_type(
capability_yaml),
requirement_capability,
):
capability_found = True
break
if capability_found:
target_capability_ids[id(requirement)] = (
self.get_node_name_id(requirement_node) +
"_capability_" +
normalize_name(capability_name))
connected_capabilities.add(requirement_node + "." +
capability_name)
connected_requirements.add(node_name + "." +
requirement_name)
else:
self.error(
' capability of type "' +
requirement_capability + '" not found',
requirement_node_template,
)
for node_name, node_yaml in node_templates.items():
node_name_id = self.get_node_name_id(node_name)
node_type = syntax.get_type(node_yaml)
merged_node_type = self.type_system.merge_type(node_type)
self.generate(" subgraph cluster", node_name_id, " {", sep="")
self.generate(" color=white")
self.generate(' label=""')
self.generate(
" ",
node_name_id,
'[label="',
node_name,
": ",
short_type_name(node_type),
'|\l\l\l\l" shape=record style=rounded]',
sep="",
)
for capability_name, capability_yaml in syntax.get_capabilities(
merged_node_type).items():
if (node_name + "." + capability_name in connected_capabilities
or node_yaml.get("capabilities",
{}).get(capability_name) is not None):
self.generate(
" ",
node_name_id,
"_capability_",
normalize_name(capability_name),
'[label="',
capability_name,
'" shape=cds style=filled fillcolor=orange]',
sep="",
)
self.generate(
" ",
node_name_id,
"_capability_",
normalize_name(capability_name),
" -- ",
node_name_id,
sep="",
)
for requirement_name, requirement_yaml in syntax.get_requirements_dict(
merged_node_type).items():
if (node_name + "." + requirement_name
in connected_requirements
or requirement_yaml.get("occurrences", [1, 1])[0] > 0):
self.generate(
" ",
node_name_id,
"_requirement_",
normalize_name(requirement_name),
'[label="',
requirement_name,
'" shape=cds style=filled fillcolor=turquoise]',
sep="",
)
self.generate(
" ",
node_name_id,
" -- ",
node_name_id,
"_requirement_",
normalize_name(requirement_name),
sep="",
)
self.generate(" }")
for node_name, node_yaml in node_templates.items():
node_name_id = self.get_node_name_id(node_name)
for requirement in syntax.get_requirements_list(node_yaml):
for requirement_name, requirement_yaml in requirement.items():
# ACK for Alien4Cloud
requirement_name = syntax.get_type_requirement(
requirement_yaml, requirement_name)
capability_id = target_capability_ids.get(id(requirement))
if capability_id is not None:
self.generate(
" ",
node_name_id,
"_requirement_",
normalize_name(requirement_name),
" -- ",
capability_id,
"[style=dotted]",
sep="",
)
if substitution_mappings is not None:
self.generate(" }")
for (
requirement_name,
requirement_yaml,
) in syntax.get_substitution_mappings_requirements(
substitution_mappings).items():
if requirement_yaml:
requirement_name_id = "topology_template_substitution_mappings_requirement_" + normalize_name(
requirement_name)
self.generate(
" ",
requirement_name_id,
'[label="',
requirement_name,
'" shape=cds style=filled fillcolor=turquoise]',
sep="",
)
self.generate(
" ",
normalize_name(requirement_yaml[0]),
"_requirement_",
normalize_name(requirement_yaml[1]),
" -- ",
requirement_name_id,
"[style=dotted]",
sep="",
)
self.generate("}")
self.close_file()
def get_node_name_id(self, node_name):
node_name_id = normalize_name(node_name)
if node_name_id == "node": # 'node' is a dot keyword
node_name_id = "node_node" # rename to 'node_node' to avoid dot error.
return node_name_id
def generate_UML2_deployment_diagram(self, topology_template):
self.generate("@startuml")
self.generate("skinparam componentStyle uml2")
self.generate()
node_templates = get_dict(topology_template, NODE_TEMPLATES)
non_containeds = list(node_templates.keys())
containers = {}
contained_containers = []
# Iterate over all node templates to find containers.
for node_template_name, node_template_yaml in node_templates.items():
merged_node_template_type = self.type_system.merge_node_type(
node_template_yaml.get(TYPE))
# Iterate over all capabilities of the node template type.
for capability_name, capability_yaml in get_dict(
merged_node_template_type, CAPABILITIES).items():
capability_type = get_capability_type(capability_yaml)
if self.type_system.is_derived_from(
capability_type, "tosca.capabilities.Container"):
containers[node_template_name] = containers.get(
node_template_name, dict())
try:
non_containeds.remove(node_template_name)
except ValueError:
pass
# Iterate over all node templates to find containeds.
for node_template_name, node_template_yaml in node_templates.items():
merged_node_template_type = self.type_system.merge_node_type(
node_template_yaml.get(TYPE))
# Iterate over all requirements of the node template.
for requirement in get_list(node_template_yaml, REQUIREMENTS):
for requirement_name, requirement_yaml in requirement.items():
requirement_definition = get_dict(
merged_node_template_type,
REQUIREMENTS).get(requirement_name)
requirement_relationship = syntax.get_requirement_relationship(
requirement_definition)
requirement_relationship_type = syntax.get_relationship_type(
requirement_relationship)
if self.type_system.is_derived_from(
requirement_relationship_type,
"tosca.relationships.HostedOn"):
requirement_node = get_requirement_node_template(
requirement_yaml)
if requirement_node is not None:
try:
containers[requirement_node][
node_template_name] = containers.get(
node_template_name, dict())
except KeyError as e:
self.error(e)
contained_containers.append(node_template_name)
try:
non_containeds.remove(node_template_name)
except ValueError:
pass
# TODO: Remove containers contained by other containers.
for contained_container_name in contained_containers:
if containers.get(contained_container_name) is not None:
del containers[contained_container_name]
# Iterate over all containers.
def get_uml2_kind(tosca_type):
uml2_kind = "component"
for tt, kind in self.configuration.get(UML2, "kinds").items():
if self.type_system.is_derived_from(tosca_type, tt):
uml2_kind = kind
break
return uml2_kind
def generate_container(self, container_name, containeds):
node_template = node_templates.get(container_name)
node_template_type = node_template.get(TYPE)
uml2_kind = get_uml2_kind(node_template_type)
node_template_artifacts = get_dict(node_template, ARTIFACTS)
if len(containeds) == 0 and len(node_template_artifacts) == 0:
self.generate(
uml2_kind,
' "',
container_name,
": ",
short_type_name(node_template_type),
'" as node_',
normalize_name(container_name),
sep="",
)
else:
self.generate(
uml2_kind,
' "',
container_name,
": ",
short_type_name(node_template_type),
'" as node_',
normalize_name(container_name),
" {",
sep="",
)
for contained_name, contained_dict in containeds.items():
generate_container(self, contained_name, contained_dict)
for artifact_name, artifact_yaml in node_template_artifacts.items(
):
artifact_type = syntax.get_artifact_type(artifact_yaml)
if artifact_type is None:
artifact_type = "Artifact"
self.generate(
'artifact "',
syntax.get_artifact_file(artifact_yaml),
'" <<',
artifact_type,
">> as node_",
normalize_name(container_name),
"_artifact_",
normalize_name(artifact_name),
sep="",
)
self.generate("}")
substitution_mappings = topology_template.get(SUBSTITUTION_MAPPINGS)
if substitution_mappings:
# Create components connected to the capabilities of the substitition mapping.
for capability_name, capability_yaml in get_dict(
substitution_mappings, CAPABILITIES).items():
self.generate(
'component "a node" as substitution_mappings_capability_',
normalize_name(capability_name),
sep="",
)
substitution_mappings_node_type = substitution_mappings.get(
NODE_TYPE)
self.generate(
get_uml2_kind(substitution_mappings_node_type),
' ": ',
substitution_mappings_node_type,
'" as substitution_mappings {',
sep="",
)
for container_name, containeds in containers.items():
generate_container(self, container_name, containeds)
for node_template_name in non_containeds:
generate_container(self, node_template_name, {})
relationship_templates = get_dict(topology_template,
RELATIONSHIP_TEMPLATES)
# Iterate over all node templates to draw relationships.
for node_template_name, node_template_yaml in node_templates.items():
merged_node_template_type = self.type_system.merge_node_type(
node_template_yaml.get(TYPE))
# Iterate over all requirements of the node template.
for requirement in get_list(node_template_yaml, REQUIREMENTS):
for requirement_name, requirement_yaml in requirement.items():
requirement_relationship_type = None
if type(requirement_yaml) == dict:
requirement_relationship = syntax.get_requirement_relationship(
requirement_yaml)
if type(requirement_relationship) == dict:
requirement_relationship_type = syntax.get_relationship_type(
requirement_relationship)
else:
relationship_template = relationship_templates.get(
requirement_relationship)
if relationship_template:
requirement_relationship_type = relationship_template.get(
TYPE)
else:
requirement_relationship_type = requirement_relationship
if requirement_relationship_type is None:
requirement = get_dict(merged_node_template_type,
REQUIREMENTS).get(
requirement_name, {})
tmp = syntax.get_requirement_relationship(requirement)
requirement_relationship_type = syntax.get_relationship_type(
tmp)
if requirement_relationship_type is None:
continue
if not self.type_system.is_derived_from(
requirement_relationship_type,
"tosca.relationships.HostedOn"):
requirement_node = get_requirement_node_template(
requirement_yaml)
if requirement_node:
self.generate(
"node_",
normalize_name(node_template_name),
' "',
requirement_name,
'" ..> node_',
normalize_name(requirement_node),
" : <<",
short_type_name(requirement_relationship_type),
">>",
sep="",
)
if substitution_mappings:
self.generate("}")
# Connect created components to the nodes exported by the capabilities of the substitition mapping.
for capability_name, capability_yaml in get_dict(
substitution_mappings, CAPABILITIES).items():
if type(capability_yaml) != list:
continue # TODO
target_node_name = capability_yaml[0]
target_capability_name = capability_yaml[1]
self.generate(
"substitution_mappings_capability_",
normalize_name(capability_name),
' "',
capability_name,
'" ..> node_',
normalize_name(target_node_name),
sep="",
)
merged_substitution_mappings_node_type = self.type_system.merge_node_type(
substitution_mappings_node_type)
# Get all requirements of the node type of the substitution mapping.
all_requirement_declarations = get_dict(
merged_substitution_mappings_node_type, REQUIREMENTS)
req_idx = 0
# Iterate over all requirements of the substitution mapping.
for (
requirement_name,
requirement_yaml,
) in syntax.get_substitution_mappings_requirements(
substitution_mappings).items():
requirement_capability = syntax.get_requirement_capability(
all_requirement_declarations.get(requirement_name))
if requirement_capability is None:
continue
self.generate(
get_uml2_kind(requirement_capability),
' ": ',
short_type_name(requirement_capability),
'" as substitution_mappings_requirement_',
req_idx,
sep="",
)
requirement_node = requirement_yaml[0]
requirement_node_capability = requirement_yaml[1]
self.generate(
"node_",
normalize_name(requirement_node),
' "',
normalize_name(requirement_node_capability),
'" ..> "',
requirement_name,
'" substitution_mappings_requirement_',
req_idx,
sep="",
)
req_idx = req_idx + 1
self.generate("@enduml")
def generate_UML2_component_diagram(self, topology_template,
with_relationships):
self.generate("@startuml")
self.generate("skinparam componentStyle uml2")
if with_relationships:
self.generate("skinparam component {")
self.generate(" backgroundColor<<relationship>> White")
self.generate("}")
self.generate()
substitution_mappings = topology_template.get(SUBSTITUTION_MAPPINGS)
if substitution_mappings:
substitution_mappings_uml_id = SUBSTITUTION_MAPPINGS
substitution_mappings_node_type = substitution_mappings.get(
NODE_TYPE)
merged_substitution_mappings_type = self.type_system.merge_node_type(
substitution_mappings_node_type)
for capability_name, capability_yaml in get_dict(
merged_substitution_mappings_type, CAPABILITIES).items():
capability_uml_id = (substitution_mappings_uml_id + "_" +
normalize_name(capability_name))
# Declare an UML interface for the substitution_mappings capability.
self.generate('interface "',
capability_name,
'" as ',
capability_uml_id,
sep="")
self.generate(
'component ": ',
substitution_mappings_node_type,
'" <<node>> as ',
substitution_mappings_uml_id,
" {",
sep="",
)
relationship_templates = get_dict(topology_template,
RELATIONSHIP_TEMPLATES)
already_generated_interfaces = {}
# Iterate over all node templates.
node_templates = get_dict(topology_template, NODE_TEMPLATES)
for node_template_name, node_template_yaml in node_templates.items():
node_template_type = node_template_yaml.get(TYPE)
merged_node_template_type = self.type_system.merge_node_type(
node_template_type)
node_template_uml_id = "node_" + normalize_name(node_template_name)
# Declare an UML component for the node template.
self.generate(
'component "',
node_template_name,
": ",
short_type_name(node_template_type),
'" <<node>> as ',
node_template_uml_id,
sep="",
)
# Iterate over all capabilities of the node template.
for capability_name, capability_yaml in get_dict(
merged_node_template_type, CAPABILITIES).items():
if type(capability_yaml) == dict:
capability_occurrences = capability_yaml.get(OCCURRENCES)
else:
capability_occurrences = None
if with_relationships or (capability_occurrences
and capability_occurrences[0] > 0):
capability_uml_id = (node_template_uml_id + "_" +
normalize_name(capability_name))
# Declare an UML interface for the node template capability.
self.generate(
'interface "',
capability_name,
'" as ',
capability_uml_id,
sep="",
)
# Connect the capability UML interface to the node template UML component.
self.generate(capability_uml_id, "--",
node_template_uml_id)
already_generated_interfaces[
capability_uml_id] = capability_uml_id
if with_relationships:
# Iterate over all requirements of the node template.
index = 0
for requirement in get_list(node_template_yaml, REQUIREMENTS):
for requirement_name, requirement_yaml in requirement.items(
):
requirement_uml_id = (
node_template_uml_id + "_" +
normalize_name(requirement_name) +
"_relationship" + str(index))
index = index + 1
requirement_node = get_requirement_node_template(
requirement_yaml)
if requirement_node is None:
continue
relationship_component_name = "" # No name.
relationship_component_type = None
if type(requirement_yaml) == dict:
requirement_relationship = syntax.get_requirement_relationship(
requirement_yaml)
if type(requirement_relationship) == dict:
relationship_component_type = syntax.get_relationship_type(
requirement_relationship)
else:
relationship_template = relationship_templates.get(
requirement_relationship)
if relationship_template:
relationship_component_name = (
requirement_relationship)
relationship_component_type = relationship_template.get(
TYPE)
else:
relationship_component_type = (
requirement_relationship)
if relationship_component_type is None:
requirement = get_dict(merged_node_template_type,
REQUIREMENTS).get(
requirement_name, {})
tmp = syntax.get_requirement_relationship(
requirement)
relationship_component_type = syntax.get_relationship_type(
tmp)
if relationship_component_type is None:
continue
# Declare an UML component for the node template requirement relationship.
self.generate(
'component "',
relationship_component_name,
": ",
short_type_name(relationship_component_type),
'" <<relationship>> as ',
requirement_uml_id,
sep="",
)
# Declare an UML interface for the node template requirement relationship.
self.generate('interface " " as ',
requirement_uml_id,
"_source",
sep="")
# Connect the UML interface to the relationship UML component.
self.generate(
requirement_uml_id,
"_source",
" -- ",
requirement_uml_id,
sep="",
)
# Connect the node template UML component to the relationship UML component.
self.generate(
node_template_uml_id,
" --( ",
requirement_uml_id,
"_source",
" : ",
requirement_name,
sep="",
)
self.generate()
# Iterate over all node templates.
for node_template_name, node_template_yaml in node_templates.items():
node_template_uml_id = "node_" + normalize_name(node_template_name)
node_template_type = node_template_yaml.get(TYPE)
merged_node_template_type = self.type_system.merge_node_type(
node_template_type)
# Iterate over all requirements of the node template.
index = 0
for requirement in get_list(node_template_yaml, REQUIREMENTS):
for requirement_name, requirement_yaml in requirement.items():
source_uml_id = node_template_uml_id
if with_relationships:
source_uml_id = (source_uml_id + "_" +
normalize_name(requirement_name) +
"_relationship" + str(index))
index = index + 1
requirement_node = get_requirement_node_template(
requirement_yaml)
if requirement_node is None:
continue
requirement_node_template = node_templates.get(
requirement_node)
if requirement_node_template is None:
continue
requirement_node_type_name = requirement_node_template.get(
TYPE)
if requirement_node_type_name is None:
continue
requirement_capability = syntax.get_requirement_capability(
get_dict(merged_node_template_type,
REQUIREMENTS).get(requirement_name))
capability_found = False
for (capability_name, capability_yaml) in get_dict(
self.type_system.merge_node_type(
requirement_node_type_name),
CAPABILITIES,
).items():
if self.type_system.is_derived_from(
syntax.get_capability_type(capability_yaml),
requirement_capability,
):
capability_found = True
break
if capability_found:
target_node_uml_id = "node_" + normalize_name(
requirement_node)
target_capability_uml_id = (
target_node_uml_id + "_" +
normalize_name(capability_name))
if with_relationships:
self.generate(source_uml_id,
" --( ",
target_capability_uml_id,
sep="")
else:
if (already_generated_interfaces.get(
target_capability_uml_id) is None):
self.generate(
'interface "',
capability_name,
'" as ',
target_capability_uml_id,
sep="",
)
# Connect the capability UML interface to the node template UML component.
self.generate(target_capability_uml_id, "--",
target_node_uml_id)
already_generated_interfaces[
target_capability_uml_id] = target_capability_uml_id
self.generate(
source_uml_id,
" --( ",
target_capability_uml_id,
" : ",
requirement_name,
sep="",
)
if substitution_mappings:
capabilities = get_dict(substitution_mappings, CAPABILITIES)
for capability_name, capability_yaml in get_dict(
merged_substitution_mappings_type, CAPABILITIES).items():
capability = capabilities.get(capability_name)
if capability is not None:
if type(capability) != list:
continue # TODO when capability is not a list
target_node_uml_id = "node_" + capability[0]
target_uml_id = (target_node_uml_id + "_" +
normalize_name(capability[1]))
if already_generated_interfaces.get(target_uml_id) is None:
self.generate(
'interface "',
capability_name,
'" as ',
target_uml_id,
sep="",
)
# Connect the capability UML interface to the node template UML component.
self.generate(target_uml_id, "--", target_node_uml_id)
already_generated_interfaces[
target_uml_id] = target_uml_id
self.generate("}")
for capability_name, capability_yaml in get_dict(
merged_substitution_mappings_type, CAPABILITIES).items():
capability_uml_id = (substitution_mappings_uml_id + "_" +
normalize_name(capability_name))
# Connect the capability UML interface to the node template UML component.
capability = capabilities.get(capability_name)
if capability is not None:
if type(capability) != list:
continue # TODO when capability is not a list
target_node_uml_id = "node_" + capability[0]
target_uml_id = (target_node_uml_id + "_" +
normalize_name(capability[1]))
self.generate(capability_uml_id, "--(", target_uml_id)
else:
self.generate(capability_uml_id, "--",
substitution_mappings_uml_id)
index = 0
for (
requirement_name,
requirement_yaml,
) in syntax.get_substitution_mappings_requirements(
substitution_mappings).items():
interface_uml_id = (substitution_mappings_uml_id + "_" +
normalize_name(requirement_name) +
str(index))
index = index + 1
self.generate('interface "', requirement_name, '" as ',
interface_uml_id)
if requirement_yaml:
source_uml_id = "node_" + normalize_name(
requirement_yaml[0])
self.generate(
source_uml_id,
" --( ",
interface_uml_id,
" : ",
requirement_yaml[1],
sep="",
)
else:
self.generate(
substitution_mappings_uml_id,
" -- ",
interface_uml_id,
" : ",
requirement_name,
)
self.generate("@enduml")
