private void renameNodeTemplateInSubstitutionTargets(Map<String, SubstitutionTarget> substitutionTargets, String oldName, String newName) { if (substitutionTargets != null) { for (SubstitutionTarget s : substitutionTargets.values()) { if (s.getNodeTemplateName().equals(oldName)) { s.setNodeTemplateName(newName); } } } }
private void addRelationshipTypeFromSubstitutionTarget(Topology topology, Map<String, RelationshipType> relationshipTypes, SubstitutionTarget substitutionTarget, boolean failOnTypeNotFound) { if (substitutionTarget.getServiceRelationshipType() != null) { RelationshipType relationshipType = getFromContextIfDefined(RelationshipType.class, substitutionTarget.getServiceRelationshipType(), topology.getDependencies(), failOnTypeNotFound); relationshipTypes.put(substitutionTarget.getServiceRelationshipType(), relationshipType); } }
public void process(Csar csar, Topology topology, SubstitutionTarget substitutionTarget, String relationshipType, String relationshipVersion) { if (StringUtils.isBlank(relationshipType)) { substitutionTarget.setServiceRelationshipType(null); return; } // Check that the relationship type exists RelationshipType indexedRelationshipType = toscaTypeSearchService.find(RelationshipType.class, relationshipType, relationshipVersion); if (indexedRelationshipType == null) { throw new NotFoundException(RelationshipType.class.getName(), relationshipType + ":" + relationshipVersion, "Unable to find relationship type to create template in topology."); } topologyService.loadType(topology, indexedRelationshipType); substitutionTarget.setServiceRelationshipType(relationshipType); } }
private void fillCapabilities(Topology topology, NodeType substituteNodeType) { if (topology.getSubstitutionMapping().getCapabilities() != null) { for (Map.Entry<String, SubstitutionTarget> e : topology.getSubstitutionMapping().getCapabilities().entrySet()) { String key = e.getKey(); String nodeName = e.getValue().getNodeTemplateName(); String capabilityName = e.getValue().getTargetId(); NodeTemplate nodeTemplate = topology.getNodeTemplates().get(nodeName); NodeType nodeTemplateType = ToscaContext.getOrFail(NodeType.class, nodeTemplate.getType()); CapabilityDefinition capabilityDefinition = IndexedModelUtils.getCapabilityDefinitionById(nodeTemplateType.getCapabilities(), capabilityName); // We cannot change the capability definition here or we will change the original one so we need a clone capabilityDefinition = CloneUtil.clone(capabilityDefinition); capabilityDefinition.setId(key); substituteNodeType.getCapabilities().add(capabilityDefinition); } } }
private SubstitutionTarget parseSubstitutionTarget(Node valueNode, ParsingContextExecution context) { List<String> values = (List<String>) stringListParser.parse(valueNode, context); if (values.size() == 3 && (ParsingContextExecution.get().getDefinitionVersion() != null && ALIEN_DSL_140.equals(ParsingContextExecution.get().getDefinitionVersion()))) { // DSL 1.4.0 allows to specify services relationship types return new SubstitutionTarget(values.get(0), values.get(1), values.get(2)); } if (values.size() != 2) { context.getParsingErrors().add(new ParsingError(ErrorCode.SYNTAX_ERROR, null, valueNode.getStartMark(), "Substitution mapping for capabilities and requirements requires 2 arguments.", valueNode.getEndMark(), null)); return null; } return new SubstitutionTarget(values.get(0), values.get(1)); } }
private void removeNodeTemplateSubstitutionTargetMapEntry(String nodeTemplateName, Map<String, SubstitutionTarget> substitutionTargets) { if (substitutionTargets == null) { return; } substitutionTargets.entrySet().removeIf(e -> e.getValue().getNodeTemplateName().equals(nodeTemplateName)); }
private void fillRequirements(Topology topology, NodeType substituteNodeType) { if (topology.getSubstitutionMapping().getRequirements() != null) { for (Map.Entry<String, SubstitutionTarget> e : topology.getSubstitutionMapping().getRequirements().entrySet()) { String key = e.getKey(); String nodeName = e.getValue().getNodeTemplateName(); String requirementName = e.getValue().getTargetId(); NodeTemplate nodeTemplate = topology.getNodeTemplates().get(nodeName); NodeType nodeTemplateType = ToscaContext.getOrFail(NodeType.class, nodeTemplate.getType()); RequirementDefinition requirementDefinition = IndexedModelUtils.getRequirementDefinitionById(nodeTemplateType.getRequirements(), requirementName); // We cannot change the capability definition here or we will change the original one so we need a clone requirementDefinition = CloneUtil.clone(requirementDefinition); requirementDefinition.setId(key); substituteNodeType.getRequirements().add(requirementDefinition); } } }
@Override public void process(Csar csar, Topology topology, AddRequirementSubstitutionTypeOperation operation) { if (topology.getNodeTemplates() == null || !topology.getNodeTemplates().containsKey(operation.getNodeTemplateName())) { throw new NotFoundException("Node " + operation.getNodeTemplateName() + " do not exist"); } NodeTemplate nodeTemplate = topology.getNodeTemplates().get(operation.getNodeTemplateName()); if (nodeTemplate.getRequirements() == null || !nodeTemplate.getRequirements().containsKey(operation.getRequirementId())) { throw new NotFoundException("Requirement " + operation.getRequirementId() + " do not exist for node " + operation.getNodeTemplateName()); } if (topology.getSubstitutionMapping() == null || topology.getSubstitutionMapping().getSubstitutionType() == null) { throw new NotFoundException("No substitution type has been found"); } Map<String, SubstitutionTarget> substitutionRequirements = topology.getSubstitutionMapping().getRequirements(); if (substitutionRequirements == null) { substitutionRequirements = Maps.newHashMap(); topology.getSubstitutionMapping().setRequirements(substitutionRequirements); } else if (substitutionRequirements.containsKey(operation.getSubstitutionRequirementId())) { // ensure name unicity throw new AlreadyExistException(String.format("The substitution requirement <%s> already exists", operation.getSubstitutionRequirementId())); } substitutionRequirements.put(operation.getSubstitutionRequirementId(), new SubstitutionTarget(operation.getNodeTemplateName(), operation.getRequirementId())); } }
private void removeNodeTemplateSubstitutionTargetMapEntry(String nodeTemplateName, Map<String, SubstitutionTarget> substitutionTargets) { if (substitutionTargets == null) { return; } Iterator<Map.Entry<String, SubstitutionTarget>> capabilities = substitutionTargets.entrySet().iterator(); while (capabilities.hasNext()) { Map.Entry<String, SubstitutionTarget> e = capabilities.next(); if (e.getValue().getNodeTemplateName().equals(nodeTemplateName)) { capabilities.remove(); } } }
String requirementName = proxyRelationShip.getRequirementName(); SubstitutionTarget substitutionTarget = compositionCouple.child.getSubstitutionMapping().getRequirements().get(requirementName); NodeTemplate nodeTemplate = compositionCouple.child.getNodeTemplates().get(substitutionTarget.getNodeTemplateName()); if (nodeTemplate.getRelationships() == null) { Map<String, RelationshipTemplate> relationships = Maps.newHashMap(); proxyRelationShip.setRequirementName(substitutionTarget.getTargetId()); SubstitutionTarget st = compositionCouple.child.getSubstitutionMapping().getCapabilities() .get(relationshipTemplate.getTargetedCapabilityName()); relationshipTemplate.setTarget(st.getNodeTemplateName()); relationshipTemplate.setTargetedCapabilityName(st.getTargetId()); for (Entry<String, SubstitutionTarget> substitutionCapabilityEntry : compositionCouple.parent.getSubstitutionMapping().getCapabilities() .entrySet()) { if (substitutionCapabilityEntry.getValue().getNodeTemplateName().equals(compositionCouple.nodeName)) { String targetCapability = substitutionCapabilityEntry.getValue().getTargetId(); if (e.getValue().getNodeTemplateName().equals(compositionCouple.nodeName)) { String targetCapability = e.getValue().getTargetId();
/** * Update properties in a topology */ private static void updateOnNodeTemplateNameChange(String oldNodeTemplateName, String newNodeTemplateName, Topology topology) { // Output properties updateKey(topology.getOutputProperties(), oldNodeTemplateName, newNodeTemplateName); // output capabilities properties updateKey(topology.getOutputCapabilityProperties(), oldNodeTemplateName, newNodeTemplateName); // output attributes updateKey(topology.getOutputAttributes(), oldNodeTemplateName, newNodeTemplateName); // substitution mapping if (topology.getSubstitutionMapping() != null) { if (topology.getSubstitutionMapping().getCapabilities() != null) { for (SubstitutionTarget st : topology.getSubstitutionMapping().getCapabilities().values()) { if (st.getNodeTemplateName().equals(oldNodeTemplateName)) { st.setNodeTemplateName(newNodeTemplateName); } } } if (topology.getSubstitutionMapping().getRequirements() != null) { for (SubstitutionTarget st : topology.getSubstitutionMapping().getRequirements().values()) { if (st.getNodeTemplateName().equals(oldNodeTemplateName)) { st.setNodeTemplateName(newNodeTemplateName); } } } } }
private void initializeSubstitutionTarget(ToscaTypeLoader loader, Map<String, RelationshipType> relationshipTypes, SubstitutionTarget substitutionTarget) { if (substitutionTarget.getServiceRelationshipType() != null) { RelationshipType relationshipType = relationshipTypes.get(substitutionTarget.getServiceRelationshipType()); if (relationshipType != null) { loader.loadType(substitutionTarget.getServiceRelationshipType(), csarDependencyLoader.buildDependencyBean(relationshipType.getArchiveName(), relationshipType.getArchiveVersion())); } } }
@Override public void process(Csar csar, Topology topology, AddCapabilitySubstitutionTypeOperation operation) { if (topology.getNodeTemplates() == null || !topology.getNodeTemplates().containsKey(operation.getNodeTemplateName())) { throw new NotFoundException("Node " + operation.getNodeTemplateName() + " do not exist"); } NodeTemplate nodeTemplate = topology.getNodeTemplates().get(operation.getNodeTemplateName()); if (nodeTemplate.getCapabilities() == null || !nodeTemplate.getCapabilities().containsKey(operation.getCapabilityId())) { throw new NotFoundException("Capability " + operation.getCapabilityId() + " do not exist for node " + operation.getNodeTemplateName()); } if (topology.getSubstitutionMapping() == null || topology.getSubstitutionMapping().getSubstitutionType() == null) { throw new NotFoundException("No substitution type has been found"); } Map<String, SubstitutionTarget> substitutionCapabilities = topology.getSubstitutionMapping().getCapabilities(); if (substitutionCapabilities == null) { substitutionCapabilities = Maps.newHashMap(); topology.getSubstitutionMapping().setCapabilities(substitutionCapabilities); } else if (substitutionCapabilities.containsKey(operation.getSubstitutionCapabilityId())) { // ensure name unicity throw new AlreadyExistException(String.format("A substitution with capability id <%s> already exists", operation.getSubstitutionCapabilityId())); } substitutionCapabilities.put(operation.getSubstitutionCapabilityId(), new SubstitutionTarget(operation.getNodeTemplateName(), operation.getCapabilityId())); } }
Capability deployedCapability = topology.getNodeTemplates().get(capabilityMapping.getValue().getNodeTemplateName()).getCapabilities() .get(capabilityMapping.getValue().getTargetId()); serviceResource.getNodeInstance().getNodeTemplate().getCapabilities().put(capabilityMapping.getKey(), deployedCapability); mapCapabilityRequirementAttributes(serviceResource, instanceInformation, capabilityMapping.getValue().getNodeTemplateName(), "capabilities", capabilityMapping.getValue().getTargetId()); .get(requirementMapping.getValue().getNodeTemplateName()).getRequirements().get(requirementMapping.getValue().getTargetId())); mapCapabilityRequirementAttributes(serviceResource, instanceInformation, requirementMapping.getValue().getNodeTemplateName(), "requirements", requirementMapping.getValue().getTargetId());
private void updateServiceRelationship(ServiceResource serviceResource, Topology topology) { Map<String, RelationshipType> relationshipTypeMap = Maps.newHashMap(); // we also want to configure the service relationships for exposed capabilities for (Entry<String, SubstitutionTarget> substitutionTargetEntry : safe(topology.getSubstitutionMapping().getCapabilities()).entrySet()) { if (serviceResource.getCapabilitiesRelationshipTypes() == null) { serviceResource.setCapabilitiesRelationshipTypes(Maps.newHashMap()); } if (substitutionTargetEntry.getValue().getServiceRelationshipType() == null) { serviceResource.getCapabilitiesRelationshipTypes().remove(substitutionTargetEntry.getKey()); } else { String relationshipId = getRelationshipId(relationshipTypeMap, topology, substitutionTargetEntry.getValue().getServiceRelationshipType()); serviceResource.getCapabilitiesRelationshipTypes().put(substitutionTargetEntry.getKey(), relationshipId); } } for (Entry<String, SubstitutionTarget> substitutionTargetEntry : safe(topology.getSubstitutionMapping().getRequirements()).entrySet()) { if (serviceResource.getRequirementsRelationshipTypes() == null) { serviceResource.setRequirementsRelationshipTypes(Maps.newHashMap()); } if (substitutionTargetEntry.getValue().getServiceRelationshipType() == null) { serviceResource.getRequirementsRelationshipTypes().remove(substitutionTargetEntry.getKey()); } else { String relationshipId = getRelationshipId(relationshipTypeMap, topology, substitutionTargetEntry.getValue().getServiceRelationshipType()); serviceResource.getRequirementsRelationshipTypes().put(substitutionTargetEntry.getKey(), relationshipId); } } serviceResourceService.save(serviceResource); }
@Test public void testServiceRelationshipSubstitution() throws FileNotFoundException, ParsingException { Mockito.reset(csarRepositorySearchService); Mockito.when(csarRepositorySearchService.getArchive("tosca-normative-types", "1.0.0-ALIEN14")).thenReturn(Mockito.mock(Csar.class)); NodeType mockRoot = Mockito.mock(NodeType.class); Mockito.when(mockRoot.isAbstract()).thenReturn(true); Mockito.when(csarRepositorySearchService.getElementInDependencies(Mockito.eq(NodeType.class), Mockito.eq("tosca.nodes.Root"), Mockito.any(Set.class))) .thenReturn(mockRoot); Mockito.when(csarRepositorySearchService.getElementInDependencies(Mockito.eq(CapabilityType.class), Mockito.eq("tosca.capabilities.Root"), Mockito.any(Set.class))).thenReturn(Mockito.mock(CapabilityType.class)); Mockito.when(csarRepositorySearchService.getElementInDependencies(Mockito.eq(RelationshipType.class), Mockito.eq("tosca.relationships.Root"), Mockito.any(Set.class))).thenReturn(Mockito.mock(RelationshipType.class)); ParsingResult<ArchiveRoot> parsingResult = parser.parseFile(Paths.get(getRootDirectory(), "substitution_mapping_service_relationship.yml")); Assert.assertEquals(0, parsingResult.getContext().getParsingErrors().size()); ArchiveRoot archiveRoot = parsingResult.getResult(); Assert.assertNotNull(archiveRoot.getArchive()); Assert.assertEquals(getToscaVersion(), archiveRoot.getArchive().getToscaDefinitionsVersion()); Assert.assertEquals("org.alien4cloud.relationships.test.MyRelationship", archiveRoot.getTopology().getSubstitutionMapping().getCapabilities().get("subst_capa").getServiceRelationshipType()); }