@Override public String getId(TNodeTemplate entity) { return entity.getId(); }
private TNodeTemplate getNodeTemplate(List<TNodeTemplate> nodeTemplates, String id) { return nodeTemplates.stream() .filter(nodeTemplate -> nodeTemplate.getId().equals(id)) .findFirst() .orElseThrow(NotFoundException::new); }
public Map<String, TNodeTemplate> getNTsByIds() { Map<String, TNodeTemplate> ntsByIds = new HashMap<>(); for (TNodeTemplate nodeTemplate : getNodeTemplates()) { ntsByIds.put(nodeTemplate.getId(), nodeTemplate); } return ntsByIds; }
/** * @return node template having the given id. null if not found */ @Nullable public TNodeTemplate getNodeTemplate(String id) { Objects.requireNonNull(id); return this.getNodeTemplates().stream() .filter(x -> id.equals(x.getId())) .findAny() .orElse(null); }
public void setNodeTemplate(TNodeTemplate nodeTemplate) { this.nodeTemplate = nodeTemplate; this.setId(nodeTemplate.getId()); } }
@Override public String toString() { List<String> ids = correspondingNTs.stream().map(HasId::getId).collect(Collectors.toList()); List<String> replacementIds = replacements.stream() .map(tt -> tt.getNodeTemplates().get(0).getId()).collect(Collectors.toList()); return "{NTs: " + ids + ", replacement: " + replacementIds + ", target label: " + targetLabel + "}"; }
public Map<String, TNodeTemplate> getTopLevelNtsByIds() { Map<String, TNodeTemplate> ntsByIds = new HashMap<>(); for (TNodeTemplate nodeTemplate : getTopLevelNTs()) { ntsByIds.put(nodeTemplate.getId(), nodeTemplate); } return ntsByIds; }
@Override public String toString() { List<String> nts = topologyTemplate.getNodeTemplates().stream().map(HasId::getId).collect(Collectors.toList()); List<String> rts = topologyTemplate.getRelationshipTemplates().stream().map(rt -> "{" + getSourceNT(rt).getId() + "--" + rt.getType().getLocalPart() + "-->" + getTargetNT(rt).getId()) .collect(Collectors.toList()); return "NTs: " + nts + "RTs: " + rts; }
public static TNodeTemplate resolveNodeTemplate(TServiceTemplate serviceTemplate, String reference) { TNodeTemplate resolved = null; for (TEntityTemplate tmpl : serviceTemplate.getTopologyTemplate().getNodeTemplateOrRelationshipTemplate()) { if (tmpl instanceof TNodeTemplate) { TNodeTemplate n = (TNodeTemplate) tmpl; if (n.getId().equals(reference)) { resolved = n; } } } return resolved; }
public ArrayList<String> getNodeIdsToBeReplaced() { ArrayList<String> ids = new ArrayList<>(); this.detectorGraph.vertexSet().forEach(toscaNode -> ids.add(graphMapping.getVertexCorrespondence(toscaNode, false).getTemplate().getId()) ); return ids; } }
public List<TopologyWrapper> filter() { List<List<TTopologyTemplate>> fragmentsFulfilling = new ArrayList<>(); // sort topologies by the policies they fulfill for (Map.Entry<TNodeTemplate, List<PolicyWrapper>> entry : policiesForNTs.entrySet()) { if (entry.getValue().isEmpty()) { continue; } List<TNodeTemplate> fragments = new ArrayList<>(); for (TopologyWrapper topology : topologies) { fragments.add(getPolicyFragment(topology, entry.getKey().getId())); } PolicyComparison comparison = new PolicyComparison(entry.getValue(), fragments); fragmentsFulfilling.add(comparison.getFragmentsFulfillingPolicies()); } // get topologies that fulfill all policies List<List<TopologyWrapper>> topologiesFulfilling = toTopologies(fragmentsFulfilling); Iterator<List<TopologyWrapper>> iterator = topologiesFulfilling.iterator(); List<TopologyWrapper> intersection = iterator.next(); while (iterator.hasNext()) { intersection.retainAll(iterator.next()); } return intersection; }
/** * 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; }
public ConnectsToGraph(TopologyWrapper topology) { Map<String, Node> nodesByIds = new HashMap<>(); for (TNodeTemplate topLevelNT : topology.getTopLevelNTs()) { Optional<String> targetLabel = ModelUtilities.getTargetLabel(topLevelNT); Node node; if (targetLabel.isPresent()) { node = new Node(topLevelNT.getId(), targetLabel.get()); } else { node = new Node(topLevelNT.getId()); } nodes.add(node); nodesByIds.put(topLevelNT.getId(), node); } for (TRelationshipTemplate connectsToRT : topology.getConnectsTos(topology.getRelationshipTemplates())) { Node source = nodesByIds.get(topology.getSourceNT(connectsToRT).getId()); Node target = nodesByIds.get(topology.getTargetNT(connectsToRT).getId()); Edge edge = new Edge(source, target); edges.add(edge); if (edge.isContractible()) { edgesForContraction.add(edge); } } }
/** * Remove all not needed nts starting from the ones provided. */ public void removeNotNeededNTs(Set<String> originalTopLevelNTIds) { for (TNodeTemplate topLevelNT : getTopLevelNTs()) { if (!originalTopLevelNTIds.contains(topLevelNT.getId())) { removeNotNeededSuccessors(topLevelNT); removeNT(topLevelNT); } } }
private void prepareSplit() { splitting = new Splitting(); Map<TNodeTemplate, Set<TNodeTemplate>> transitiveClosure = splitting.computeTransitiveClosure(topology.getTopology()); for (TNodeTemplate nodeTemplate : topology.getTopLevelNTs()) { String targetLabel = ModelUtilities.getTargetLabel(nodeTemplate).get(); originalTargetLabels.put(nodeTemplate.getId(), targetLabel); if (topLevelNTsToSplit.contains(nodeTemplate)) { ModelUtilities.setTargetLabel(nodeTemplate, nodeTemplate.getId()); } for (TNodeTemplate successor : transitiveClosure.get(nodeTemplate)) { ModelUtilities.setTargetLabel(successor, "undefined"); } } }
@Override protected Map<String, TTopologyTemplate> toInjectParameter(TopologyWrapper topology, List<PermutationHelper> permutation) { Map<String, TTopologyTemplate> injectParameter = new HashMap<>(); for (PermutationHelper possibility : permutation) { // all predecessors of the nt to replace get the same matching nt TTopologyTemplate clone = AllocationUtils.deepcopy(possibility.getReplacement()); for (TNodeTemplate predecessor : topology.getHostedOnPredecessors(possibility.getCorrespondingNT())) { injectParameter.put(predecessor.getId(), clone); } } return injectParameter; } }
private void resetTargetLabels() { splitting = new Splitting(); Map<TNodeTemplate, Set<TNodeTemplate>> transitiveClosure = splitting.computeTransitiveClosure(topology.getTopology()); for (TNodeTemplate nodeTemplate : topology.getTopLevelNTs()) { String originalTargetLabel = originalTargetLabels.get(nodeTemplate.getId()); ModelUtilities.setTargetLabel(nodeTemplate, originalTargetLabel); for (TNodeTemplate successor : transitiveClosure.get(nodeTemplate)) { ModelUtilities.setTargetLabel(successor, originalTargetLabel); } } } }
public Stream<TRelationshipTemplate> getExternalRelations(TNodeTemplate matchingNode, RefinementCandidate candidate, TTopologyTemplate topology) { return topology.getRelationshipTemplates().stream() .filter(relationship -> // all relationships which have the matchingNode as source or target // -> \pi_1(rm_x) = \pi_2(sgm_i) matchingNode.getId().equals(relationship.getSourceElement().getRef().getId()) || matchingNode.getId().equals(relationship.getTargetElement().getRef().getId()) ).filter(relationship -> { // ignore all relationships which are part of the sub-graph // \nexists sgm_y \in sgms : \pi_1(sgm_y) = r_j return candidate.getDetectorGraph().edgeSet() .stream() .noneMatch(toscaEdge -> { ToscaEdge edgeCorrespondence = candidate.getGraphMapping().getEdgeCorrespondence(toscaEdge, false); return edgeCorrespondence.getTemplate().equals(relationship); }); }); }
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; }
/** * @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; }