/** * @param nodeTemplate which should be cloned * @return copy of nodeTemplate */ public static TNodeTemplate clone(TNodeTemplate nodeTemplate) { TNodeTemplate nodeTemplateClone = new TNodeTemplate(); nodeTemplateClone.setType(nodeTemplate.getType()); nodeTemplateClone.setId(nodeTemplate.getId()); nodeTemplateClone.setDeploymentArtifacts(nodeTemplate.getDeploymentArtifacts()); // returns 1 if null -> !original.equals(cloned) nodeTemplateClone.setMaxInstances(nodeTemplate.getMaxInstances()); nodeTemplateClone.setMinInstances(nodeTemplate.getMinInstances()); nodeTemplateClone.setName(nodeTemplate.getName()); nodeTemplateClone.setPolicies(nodeTemplate.getPolicies()); nodeTemplateClone.setRequirements(nodeTemplate.getRequirements()); nodeTemplateClone.setCapabilities(nodeTemplate.getCapabilities()); nodeTemplateClone.setProperties(nodeTemplate.getProperties()); nodeTemplateClone.setPropertyConstraints(nodeTemplate.getPropertyConstraints()); nodeTemplateClone.setX(nodeTemplate.getX()); nodeTemplateClone.setY(nodeTemplate.getY()); if (ModelUtilities.getTargetLabel(nodeTemplate).isPresent()) { ModelUtilities.setTargetLabel(nodeTemplateClone, ModelUtilities.getTargetLabel(nodeTemplate).get()); } return nodeTemplateClone; }
/** * Clone so that !original.equals(clone). * This is done by changing the name of the clone. */ public static TNodeTemplate cloneNotEqual(TNodeTemplate nodeTemplate) { TNodeTemplate cloned = BackendUtils.clone(nodeTemplate); // name used in equals -> make unique to avoid equals bugs caused by cloning cloned.setName(cloned.getId() + idCounter++); return cloned; }
@Override public void visit(TNodeTemplate nodeTemplate) { final TNodeTemplate.Requirements requirements = nodeTemplate.getRequirements(); if ((requirements != null) && requirements.getRequirement().isEmpty()) { nodeTemplate.setRequirements(null); } final TNodeTemplate.Capabilities capabilities = nodeTemplate.getCapabilities(); if ((capabilities != null) && capabilities.getCapability().isEmpty()) { nodeTemplate.setCapabilities(null); } final TDeploymentArtifacts deploymentArtifacts = nodeTemplate.getDeploymentArtifacts(); if ((deploymentArtifacts != null) && deploymentArtifacts.getDeploymentArtifact().isEmpty()) { nodeTemplate.setDeploymentArtifacts(null); } final TPolicies policies = nodeTemplate.getPolicies(); if ((policies != null) && policies.getPolicy().isEmpty()) { nodeTemplate.setPolicies(null); } super.visit(nodeTemplate); }
public void visit(TNodeTemplate nodeTemplate) { this.visit((RelationshipSourceOrTarget) nodeTemplate); final TNodeTemplate.Requirements requirements = nodeTemplate.getRequirements(); if (requirements != null) { requirements.accept(this); } final TNodeTemplate.Capabilities capabilities = nodeTemplate.getCapabilities(); if (capabilities != null) { capabilities.accept(this); } final TDeploymentArtifacts deploymentArtifacts = nodeTemplate.getDeploymentArtifacts(); if (deploymentArtifacts != null) { for (TDeploymentArtifact deploymentArtifact : deploymentArtifacts.getDeploymentArtifact()) { deploymentArtifact.accept(this); } } final TPolicies policies = nodeTemplate.getPolicies(); if (policies != null) { for (TPolicy policy : policies.getPolicy()) { policy.accept(this); } } // meta model does not offer more children }
@Override public String getId(TNodeTemplate entity) { return entity.getId(); }
@NonNull public Map<String, TNodeTemplate> convert(org.eclipse.winery.model.tosca.TNodeTemplate node, @NonNull List<org.eclipse.winery.model.tosca.TRelationshipTemplate> rTs) { if (Objects.isNull(node)) return new LinkedHashMap<>(); return Collections.singletonMap( node.getIdFromIdOrNameField(), new TNodeTemplate.Builder( convert( node.getType(), new NodeTypeId(node.getType()) )) .setProperties(convert(node, node.getProperties())) .setRequirements(convert(node.getRequirements())) .addRequirements(rTs.stream() .filter(entry -> Objects.nonNull(entry.getSourceElement()) && entry.getSourceElement().getRef().equals(node)) .map(entry -> new LinkedHashMap.SimpleEntry<>( Optional.ofNullable(entry.getName()).orElse(entry.getId()), new TRequirementAssignment.Builder() .setNode(new QName(entry.getTargetElement().getRef().getId())) .build() )) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)) ) .setCapabilities(convert(node.getCapabilities())) .setArtifacts(convert(node.getDeploymentArtifacts())) .build() ); }
TNodeTemplate nodeTemplate = new TNodeTemplate(); nodeTemplate.setId(UUID.randomUUID().toString()); nodeTemplate.setName(nodeType.getName()); nodeTemplate.setType(new QName(nodeType.getTargetNamespace(), nodeType.getName())); capa.setName(cd.getCapabilityType().getLocalPart()); capa.setType(new QName(cd.getCapabilityType().getNamespaceURI(), cd.getCapabilityType().getLocalPart())); nodeTemplate.setCapabilities(new Capabilities()); nodeTemplate.getCapabilities().getCapability().add(capa); nodeTemplate.setRequirements(requirementsNode); for (TRequirementDefinition definition : nodeType.getRequirementDefinitions().getRequirementDefinition()) { TRequirement newRequirement = new TRequirement(); newRequirement.setId(definition.getName()); newRequirement.setType(definition.getRequirementType()); nodeTemplate.getRequirements().getRequirement().add(newRequirement);
.filter(nt -> nt.getId().equals(predecessorOfNewHostId)) .findFirst().orElse(null); LOGGER.debug("Predecessor which get a new host " + predecessorOfNewHost.getId()); TRequirement openHostedOnRequirement = predecessorOfNewHost.getRequirements().getRequirement().stream() .filter(req -> getBasisCapabilityType(getRequiredCapabilityTypeQNameOfRequirement(req)).getName().equals("Container")) .findAny().get(); .filter(nt -> nt.getCapabilities() != null) .filter(nt -> nt.getCapabilities().getCapability().stream().anyMatch(cap -> cap.getType().equals(getRequiredCapabilityTypeQNameOfRequirement(openHostedOnRequirement)))) .findFirst().get(); .anyMatch(nt -> ModelUtilities.getTargetLabel(nt).get().toLowerCase() .equals(ModelUtilities.getTargetLabel(newHostNodeTemplate).get().toLowerCase()) && (nt.getId().equals(Util.makeNCName(newHostNodeTemplate.getId() + "-" + ModelUtilities.getTargetLabel(newHostNodeTemplate).get())) || nt.equals(newHostNodeTemplate))); newMatchingNodeTemplate = matching.stream().filter(nt -> ModelUtilities.getTargetLabel(nt).get().toLowerCase() .equals(ModelUtilities.getTargetLabel(newHostNodeTemplate).get().toLowerCase()) && (nt.getId().equals(Util.makeNCName(newHostNodeTemplate.getId() + "-" + ModelUtilities.getTargetLabel(newHostNodeTemplate).get())) || nt.equals(newHostNodeTemplate))).findAny().get(); List<TRequirement> openRequirements = predecessorOfNewHost.getRequirements().getRequirement(); for (TRequirement requirement : openRequirements) { QName requiredCapabilityTypeQName = getRequiredCapabilityTypeQNameOfRequirement(requirement); List<TCapability> openCapabilities = newMatchingNodeTemplate.getCapabilities().getCapability(); for (TCapability capability : openCapabilities) { TCapabilityType basisCapabilityType = getBasisCapabilityType(capability.getType());
private static void collectIdsOfExistingTopologyElements(TTopologyTemplate topologyTemplateB, Map<String, String> idMapping) { // collect existing node & relationship template ids topologyTemplateB.getNodeTemplateOrRelationshipTemplate() // the existing ids are left unchanged .forEach(x -> idMapping.put(x.getId(), x.getId())); // collect existing requirement ids topologyTemplateB.getNodeTemplates().stream() .filter(nt -> nt.getRequirements() != null) .forEach(nt -> nt.getRequirements().getRequirement() // the existing ids are left unchanged .forEach(x -> idMapping.put(x.getId(), x.getId()))); //collect existing capability ids topologyTemplateB.getNodeTemplates().stream() .filter(nt -> nt.getCapabilities() != null) .forEach(nt -> nt.getCapabilities().getCapability() // the existing ids are left unchanged .forEach(x -> idMapping.put(x.getId(), x.getId()))); }
if (substitutableNodeTemplate.getId().equals(tRelationshipTemplate.getSourceElement().getRef().getId())) { outgoingRelations.add(tRelationshipTemplate); if (substitutableNodeTemplate.getId().equals(tRelationshipTemplate.getTargetElement().getRef().getId())) { ingoingRelations.add(tRelationshipTemplate); .filter(tNodeTemplate -> Objects.nonNull(tNodeTemplate.getCapabilities()) && tNodeTemplate.getCapabilities().getCapability() .stream() .anyMatch(tCapability -> tCapability.equals(tCapabilityRef.getRef())) topologyToImport.getNodeTemplates().stream() .filter(tNodeTemplate -> Objects.nonNull(tNodeTemplate.getRequirements()) && tNodeTemplate.getRequirements().getRequirement() .stream() .anyMatch(tRequirement -> tRequirement.equals(requirementRef.getRef()))
ArtifactTemplateId newArtifactTemplateId = new ArtifactTemplateId( "http://opentosca.org/artifacttemplates", this.getServiceTemplateResource().getServiceTemplate().getName() + "-" + this.nodeTemplate.getId() + "-State" + WineryVersion.WINERY_NAME_FROM_VERSION_SEPARATOR + componentVersion + WineryVersion.WINERY_VERSION_SEPARATOR + WineryVersion.WINERY_VERSION_PREFIX + "1" )); TDeploymentArtifacts list = this.nodeTemplate.getDeploymentArtifacts(); if (Objects.nonNull(list)) { list = new TDeploymentArtifacts(); this.nodeTemplate.setDeploymentArtifacts(list); .onPost(uploadedInputStream, fileDetail, body, uriInfo, this.nodeTemplate.getId() + ".state");
if (!targetLabel.isPresent()) { LOGGER.error("No target label present"); LOGGER.error("id " + predecessor.getId()); duplicatedNode.setId(Util.makeNCName(currentNode.getId() + "-" + targetLabel)); duplicatedNode.setName(Util.makeNCName(currentNode.getName() + "-" + targetLabel)); topologyTemplate.getNodeTemplateOrRelationshipTemplate().add(duplicatedNode); topologyTemplateCopy.getNodeTemplateOrRelationshipTemplate().add(duplicatedNode);
public static Collection<QName> getArtifactTemplatesOfReferencedDeploymentArtifacts(TNodeTemplate nodeTemplate) { List<QName> l = new ArrayList<>(); // DAs may be assigned directly to a node template Collection<QName> allReferencedArtifactTemplates = BackendUtils.getAllReferencedArtifactTemplates(nodeTemplate.getDeploymentArtifacts()); l.addAll(allReferencedArtifactTemplates); // DAs may be assigned via node type implementations QName nodeTypeQName = nodeTemplate.getType(); Collection<NodeTypeImplementationId> allNodeTypeImplementations = RepositoryFactory.getRepository().getAllElementsReferencingGivenType(NodeTypeImplementationId.class, nodeTypeQName); for (NodeTypeImplementationId nodeTypeImplementationId : allNodeTypeImplementations) { TDeploymentArtifacts deploymentArtifacts = RepositoryFactory.getRepository().getElement(nodeTypeImplementationId).getDeploymentArtifacts(); allReferencedArtifactTemplates = BackendUtils.getAllReferencedArtifactTemplates(deploymentArtifacts); l.addAll(allReferencedArtifactTemplates); } return l; }
private Map<String, Map<String, Integer>> calculateNewPositions(ToscaGraph detectorGraph, GraphMapping<ToscaNode, ToscaEdge> mapping, TTopologyTemplate refinementStructure) { HashMap<String, Map<String, Integer>> coordinates = new HashMap<>(); int[] topLeftOriginal = {-1, -1}; int[] topLeftReplacement = {-1, -1}; detectorGraph.vertexSet().forEach(toscaNode -> { ToscaNode node = mapping.getVertexCorrespondence(toscaNode, false); getTopLeft(node.getTemplate().getX(), node.getTemplate().getY(), topLeftOriginal); }); refinementStructure.getNodeTemplates().forEach( tNodeTemplate -> getTopLeft(tNodeTemplate.getX(), tNodeTemplate.getY(), topLeftReplacement) ); refinementStructure.getNodeTemplates().forEach(nodeTemplate -> { int x = Integer.parseInt(nodeTemplate.getX()); int y = Integer.parseInt(nodeTemplate.getY()); HashMap<String, Integer> newCoordinates = new HashMap<>(); newCoordinates.put("x", (x - topLeftReplacement[0]) + topLeftOriginal[0]); newCoordinates.put("y", (y - topLeftReplacement[1]) + topLeftOriginal[1]); coordinates.put(nodeTemplate.getId(), newCoordinates); }); return coordinates; }
.filter(nt -> nt.getRequirements() != null) .forEach(nt -> nt.getRequirements().getRequirement().forEach(oldReq -> { TRequirement req = SerializationUtils.clone(oldReq); generateNewIdOfTemplate(req, idMapping); .filter(nt -> nt.getCapabilities() != null) .forEach(nt -> nt.getCapabilities().getCapability().forEach(oldCap -> { TCapability cap = SerializationUtils.clone(oldCap); generateNewIdOfTemplate(cap, idMapping); ((TNodeTemplate) rtOrNt).setX(Integer.toString(newLeft)); } else if (rtOrNt instanceof TRelationshipTemplate) { newRelationships.add((TRelationshipTemplate) rtOrNt);
public void applyPropertyMappings(RefinementCandidate refinement, String detectorNodeId, TNodeTemplate matchingNode, TTopologyTemplate topology, Map<String, String> idMapping) { TPatternRefinementModel.TPrmPropertyMappings propertyMappings = ((TPatternRefinementModel) refinement.getRefinementModel()).getPropertyMappings(); if (Objects.nonNull(propertyMappings)) { propertyMappings.getPropertyMapping() .stream() .filter(mapping -> mapping.getDetectorNode().getId().equals(detectorNodeId)) .forEach(mapping -> { Map<String, String> sourceProperties = matchingNode.getProperties().getKVProperties(); TEntityTemplate.Properties properties = topology .getNodeTemplate(idMapping.get(mapping.getRefinementNode().getId())) .getProperties(); Map<String, String> targetProperties = properties.getKVProperties(); if (Objects.nonNull(matchingNode.getProperties()) && Objects.nonNull(sourceProperties) && !sourceProperties.isEmpty() && Objects.nonNull(targetProperties)) { if (mapping.getType() == TPrmPropertyMappingType.ALL) { sourceProperties.forEach(targetProperties::replace); } else { // TPrmPropertyMappingType.SELECTIVE String sourceValue = sourceProperties.get(mapping.getDetectorProperty()); targetProperties.put(mapping.getRefinementProperty(), sourceValue); } // because of the dynamical generation of the KV properties, we must set them again to persist them... properties.setKVProperties(targetProperties); } }); } }
if (nodeTemplateCandidate.getRequirements() != null) { if (nodeTemplateCandidate.getRequirements().getRequirement().stream() .anyMatch(req -> getBasisCapabilityType(getRequiredCapabilityTypeQNameOfRequirement(req)).getName().equalsIgnoreCase("Container"))) { nodesToCheck.add(nodeTemplateCandidate); if (!label.isPresent()) { LOGGER.error("No target label present"); LOGGER.error("id " + needHostNode.getId()); throw new SplittingException("No target label present for Node Template " + needHostNode.getId()); List<TRequirement> openHostedOnRequirements = needHostNode.getRequirements().getRequirement().stream() .filter(req -> getBasisCapabilityType(getRequiredCapabilityTypeQNameOfRequirement(req)).getName().equalsIgnoreCase("Container")).collect(Collectors.toList()); injectionOptions.put(needHostNode.getId(), compatibleTopologyFragments); nodesForWhichHostsFound.add(needHostNode); if (!label.isPresent()) { LOGGER.error("No target label present"); LOGGER.error("id " + replacementCandidate.getId()); throw new SplittingException("No target label present for Node Template " + replacementCandidate.getId()); if (predecessor.getRequirements() == null) { nodesForWhichHostsFound.add(predecessor); List<TRequirement> openHostedOnRequirements = predecessor.getRequirements().getRequirement().stream() .filter(req -> getBasisCapabilityType(getRequiredCapabilityTypeQNameOfRequirement(req)).getName().equalsIgnoreCase("Container")).collect(Collectors.toList()); injectionOptions.put(predecessor.getId(), compatibleTopologyFragments); nodesForWhichHostsFound.add(predecessor);
refinement.getRefinementModel().getRefinementTopology().getNodeTemplates() .forEach(node -> { Map<String, Integer> newCoordinates = coordinates.get(node.getId()); TNodeTemplate nodeTemplate = topology.getNodeTemplate(idMapping.get(node.getId())); nodeTemplate.setX(newCoordinates.get("x").toString()); nodeTemplate.setY(newCoordinates.get("y").toString());
public static boolean containsPatterns(List<TNodeTemplate> topologyNodes, Map<QName, TNodeType> nodeTypes) { NamespaceManager namespaceManager = RepositoryFactory.getRepository().getNamespaceManager(); return topologyNodes.stream() .anyMatch(nodeTemplate -> { TNodeType tNodeType = nodeTypes.get(nodeTemplate.getType()); boolean isPattern = namespaceManager.isPatternNamespace(tNodeType.getTargetNamespace()); boolean isAnnotatedByPattern = false; if (Objects.nonNull(nodeTemplate.getPolicies())) { isAnnotatedByPattern = nodeTemplate.getPolicies().getPolicy() .stream() .anyMatch(tPolicy -> namespaceManager.isPatternNamespace(tPolicy.getPolicyType().getNamespaceURI())); } return isPattern || isAnnotatedByPattern; }); } }