/** * Change policies that target the sourceTemplate and make them target the targetTemplate. * * TODO: move elsewhere ? */ public static void changePolicyTarget(Topology topology, NodeTemplate sourceTemplate, NodeTemplate targetTemplate) { Set<PolicyTemplate> policies = TopologyNavigationUtil.getTargetedPolicies(topology, sourceTemplate); policies.forEach(policyTemplate -> { policyTemplate.getTargets().remove(sourceTemplate.getName()); policyTemplate.getTargets().add(targetTemplate.getName()); }); }
private void addDeleteNodeOperation(NodeTemplate template, List<AbstractEditorOperation> recoveryOperations) { DeleteNodeOperation operation = new DeleteNodeOperation(); operation.setNodeName(template.getName()); recoveryOperations.add(operation); }
private void addRebuildNodeOperation(NodeTemplate template, List<AbstractEditorOperation> recoveryOperations) { RebuildNodeOperation operation = new RebuildNodeOperation(); operation.setNodeName(template.getName()); recoveryOperations.add(operation); }
/** * Get the policies that target this node template. */ public static Set<PolicyTemplate> getTargetedPolicies(Topology topology, NodeTemplate nodeTemplate) { return safe(topology.getPolicies()).values().stream() .filter(policyTemplate -> policyTemplate.getTargets() != null && policyTemplate.getTargets().contains(nodeTemplate.getName())) .collect(Collectors.toSet()); }
public static boolean isPolicyTarget(NodeTemplate nodeTemplate, PolicyTemplate policyTemplate) { return safe(policyTemplate.getTargets()).contains(nodeTemplate.getName()); }
public List<ArtifactTask> validate(Topology topology) { // First validate all artifact for all node template then validate artifact for all relationships return Stream.concat( safe(topology.getNodeTemplates()).values().stream().flatMap(nodeTemplate -> validateTemplate(nodeTemplate.getName(), nodeTemplate)), safe(topology.getNodeTemplates()).values().stream().flatMap(nodeTemplate -> safe(nodeTemplate.getRelationships()).entrySet().stream()) .flatMap(relationshipTemplateEntry -> validateTemplate(relationshipTemplateEntry.getKey(), relationshipTemplateEntry.getValue()))) .collect(Collectors.toList()); } }
/** * Returns all the nodes that target this node template with the given requirement. */ public static Set<NodeTemplate> getSourceNodes(Topology topology, NodeTemplate nodeTemplate, String capabilityName) { Set<NodeTemplate> result = Sets.newHashSet(); for (NodeTemplate node : topology.getNodeTemplates().values()) { for (RelationshipTemplate relationshipTemplate : safe(node.getRelationships()).values()) { if (relationshipTemplate.getTargetedCapabilityName().equals(capabilityName) && relationshipTemplate.getTarget().equals(nodeTemplate.getName())) { result.add(node); } } } return result; }
protected NodeTemplate replaceNode(Csar csar, Topology topology, NodeTemplate node, String nodeType, String nodeVersion) { ReplaceNodeOperation replaceNodeOperation = new ReplaceNodeOperation(); replaceNodeOperation.setNodeName(node.getName()); replaceNodeOperation.setNewTypeId(nodeType + ":" + nodeVersion); replaceNodeOperation.setSkipAutoCompletion(true); replaceNodeProcessor.process(csar, topology, replaceNodeOperation); return topology.getNodeTemplates().get(node.getName()); }
private void addRebuildRelationshipOperation(NodeTemplate nodeTemplate, RelationshipTemplate relationshipTemplate, List<AbstractEditorOperation> recoveryOperations) { RebuildRelationshipOperation operation = new RebuildRelationshipOperation(); operation.setNodeName(nodeTemplate.getName()); operation.setRelationshipName(relationshipTemplate.getName()); recoveryOperations.add(operation); }
private void addDeleteRelationshipOperation(NodeTemplate nodeTemplate, RelationshipTemplate relationshipTemplate, List<AbstractEditorOperation> recoveryOperations) { DeleteRelationshipOperation operation = new DeleteRelationshipOperation(); operation.setNodeName(nodeTemplate.getName()); operation.setRelationshipName(relationshipTemplate.getName()); recoveryOperations.add(operation); }
/** * Returns all the nodes that target this node template with a relationship of the given type. */ public static Set<NodeTemplate> getSourceNodesByRelationshipType(Topology topology, NodeTemplate nodeTemplate, String relationshipTypeName) { Set<NodeTemplate> result = Sets.newHashSet(); for (NodeTemplate node : topology.getNodeTemplates().values()) { for (RelationshipTemplate relationshipTemplate : safe(node.getRelationships()).values()) { if (relationshipTemplate.getTarget().equals(nodeTemplate.getName())) { RelationshipType relationshipType = ToscaContext.get(RelationshipType.class, relationshipTemplate.getType()); if (ToscaTypeUtils.isOfType(relationshipType, relationshipTypeName)) { result.add(node); } } } } return result; }
private Map<String, Object> getAggregatedVolumeIds(DeploymentTopology topology, String nodeTemplateId, Map<String, Object> persistentProperties) { NodeTemplate nodeTemplate; try { nodeTemplate = TopologyUtils.getNodeTemplate(topology, nodeTemplateId); } catch (NotFoundException e) { log.warn("Fail to update volumeIds for node " + nodeTemplateId, e); return null; } Map<String, Object> aggregatedProperties = Maps.newHashMap(); Map<String, Object> concernedNodeProperties = extractConcernedNodeProperties(nodeTemplate.getName(), nodeTemplate.getProperties(), persistentProperties.keySet()); List<Map<String, String>> splittedNodeProperties = splitNodePropertiesValue(concernedNodeProperties); if (!persistentPropertiesAlreadyExist(persistentProperties, splittedNodeProperties)) { aggregatedProperties = buildAggregatedProperties(persistentProperties, concernedNodeProperties); } return aggregatedProperties; }
private static String getRootHostNode(String nodeId, TopologyContext topologyContext) { NodeTemplate nodeTemplate = topologyContext.getTopology().getNodeTemplates().get(nodeId); if (nodeTemplate == null) { return null; } NodeTemplate hostTemplate = TopologyNavigationUtil.getImmediateHostTemplate(topologyContext.getTopology(), nodeTemplate, topologyContext); if (hostTemplate == null) { return nodeId; } return getRootHostNode(hostTemplate.getName(), topologyContext); }
protected void removeNode(Topology topology, NodeTemplate nodeTemplate) { // keep track of the hosted nodes List<NodeTemplate> hostedNodes = TopologyNavigationUtil.getHostedNodes(topology, nodeTemplate.getName()); Csar csar = new Csar(topology.getArchiveName(), topology.getArchiveVersion()); DeleteNodeOperation deleteNodeOperation = new DeleteNodeOperation(); deleteNodeOperation.setNodeName(nodeTemplate.getName()); deleteNodeProcessor.process(csar, topology, deleteNodeOperation); // remove all hosted node also safe(hostedNodes).forEach(hostedNodeTemplate -> removeNode(topology, hostedNodeTemplate)); } }
private List<NodeTemplate> getTargets(PolicyTemplate policy, Topology topology, FlowExecutionContext context) { List<NodeTemplate> targets = Lists.newArrayList(); for (String targetName : safe(policy.getTargets())) { NodeTemplate target = safe(topology.getNodeTemplates()).get(targetName); // This modifier is injected after matching phase. Nodes must have been matched against valid type. if (!AWS_MOCK_COMPUTE_TYPE.equals(target.getType())) { context.log().error("Anti-affinity policy {} is not correctly configured, target {} is not an instance of {}.", policy.getName(), target.getName(), AWS_MOCK_COMPUTE_TYPE); return null; } targets.add(target); } return targets; } }
/** * validate that a node still has a capability, by checkibg directly from the related node type * * @param capabilityName The name of the capability to check * @param nodeTemplate The node template in which to check for the capability */ private void checkCapability(String capabilityName, NodeTemplate nodeTemplate) { // FIXME check if the relationship is still valid concerning binded capability // This call should never throw a NotFoundException NodeType indexedNodeType = ToscaContext.getOrFail(NodeType.class, nodeTemplate.getType()); Map<String, CapabilityDefinition> capabilitiesMap = AlienUtils.fromListToMap(indexedNodeType.getCapabilities(), "id", true); if (!AlienUtils.safe(capabilitiesMap).containsKey(capabilityName)) { throw new InvalidStateException("A capability with name [" + capabilityName + "] cannot be found in the node [" + nodeTemplate.getName() + "]."); } }
private void setNodePropertyPathValue(Csar csar, Topology topology, NodeTemplate nodeTemplate, String propertyPath, AbstractPropertyValue propertyValue, boolean lastPropertyIsAList) { Map<String, AbstractPropertyValue> propertyValues = nodeTemplate.getProperties(); String nodePropertyName = feedPropertyValue(propertyValues, propertyPath, propertyValue, lastPropertyIsAList); Object nodePropertyValue = propertyValues.get(nodePropertyName); UpdateNodePropertyValueOperation updateNodePropertyValueOperation = new UpdateNodePropertyValueOperation(); updateNodePropertyValueOperation.setNodeName(nodeTemplate.getName()); updateNodePropertyValueOperation.setPropertyName(nodePropertyName); // TODO: can be necessary to serialize value before setting it in case of different types updateNodePropertyValueOperation.setPropertyValue(nodePropertyValue); updateNodePropertyValueProcessor.process(csar, topology, updateNodePropertyValueOperation); }
private void addWarning(Set<IllegalOperationWarning> warnings, NodeTemplate nodeTemplate, Interface toscaInterface, String operationName, String serviceName, String relationshipType) { IllegalOperationWarning illegalOperationWarning = new IllegalOperationWarning(); illegalOperationWarning.setNodeTemplateName(nodeTemplate.getName()); illegalOperationWarning.setOperationName(operationName); illegalOperationWarning.setServiceName(serviceName); illegalOperationWarning.setRelationshipType(relationshipType); illegalOperationWarning.setInterfaceName(toscaInterface.getType()); warnings.add(illegalOperationWarning); } }
protected void setNodeCappabilityPropertyPathValue(Csar csar, Topology topology, NodeTemplate nodeTemplate, String capabilityName, String propertyPath, AbstractPropertyValue propertyValue, boolean lastPropertyIsAList) { Map<String, AbstractPropertyValue> propertyValues = nodeTemplate.getCapabilities().get(capabilityName).getProperties(); String nodePropertyName = feedPropertyValue(propertyValues, propertyPath, propertyValue, lastPropertyIsAList); Object nodePropertyValue = propertyValues.get(nodePropertyName); UpdateCapabilityPropertyValueOperation operation = new UpdateCapabilityPropertyValueOperation(); operation.setCapabilityName(capabilityName); operation.setNodeName(nodeTemplate.getName()); operation.setPropertyName(nodePropertyName); operation.setPropertyValue(propertyValue); // TODO: can be necessary to serialize value before setting it in case of different types operation.setPropertyValue(nodePropertyValue); updateCapabilityPropertyValueProcessor.process(csar, topology, operation); }
protected RelationshipTemplate addRelationshipTemplate(Csar csar, Topology topology, NodeTemplate sourceNode, String targetNodeName, String relationshipTypeName, String requirementName, String capabilityName) { AddRelationshipOperation addRelationshipOperation = new AddRelationshipOperation(); addRelationshipOperation.setNodeName(sourceNode.getName()); addRelationshipOperation.setTarget(targetNodeName); RelationshipType relationshipType = ToscaContext.get(RelationshipType.class, relationshipTypeName); addRelationshipOperation.setRelationshipType(relationshipType.getElementId()); addRelationshipOperation.setRelationshipVersion(relationshipType.getArchiveVersion()); addRelationshipOperation.setRequirementName(requirementName); addRelationshipOperation.setTargetedCapabilityName(capabilityName); String relationShipName = TopologyCompositionService.ensureNodeNameIsUnique(safe(sourceNode.getRelationships()).keySet(), sourceNode.getName() + "_" + targetNodeName, 0); addRelationshipOperation.setRelationshipName(relationShipName); addRelationshipProcessor.process(csar, topology, addRelationshipOperation); return sourceNode.getRelationships().get(relationShipName); }