private void addTheRelationshipsOnSource(Topology topology, Map<String, Map<String, RelationshipTemplate>> relationshipDeleted) { for (String nodeName : relationshipDeleted.keySet()) { NodeTemplate nodeTemplate = safe(topology.getNodeTemplates()).get(nodeName); Map<String, RelationshipTemplate> relationship = relationshipDeleted.get(nodeName); for (String targetId : relationship.keySet()) { nodeTemplate.getRelationships().put(targetId, relationship.get(targetId)); } } } }
/** * Returns all the relationships wired since this this node template's requirement. */ public static Set<RelationshipTemplate> getTargetRelationships(NodeTemplate nodeTemplate, String requirementName) { Set<RelationshipTemplate> result = Sets.newHashSet(); for (RelationshipTemplate relationshipTemplate : safe(nodeTemplate.getRelationships()).values()) { if (relationshipTemplate.getRequirementName().equals(requirementName)) { result.add(relationshipTemplate); } } return result; }
private boolean areRelationshipsArtifactSupported(LocationMatchNodeFilter.NodeMatchContext matchContext) { if (MapUtils.isNotEmpty(matchContext.getTemplate().getRelationships())) { for (RelationshipTemplate relTemplate : matchContext.getTemplate().getRelationships().values()) { if (!isEligible(relTemplate, matchContext)) { return false; } } } return true; } }
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()); } }
private <T extends Topology> Map<String, RelationshipType> getRelationshipTypes(T topology) { Map<String, RelationshipType> types = Maps.newHashMap(); if (topology.getNodeTemplates() != null) { for (NodeTemplate nodeTemplate : topology.getNodeTemplates().values()) { fillTypeMap(RelationshipType.class, types, nodeTemplate.getRelationships(), false, false); } } return types; }
public static boolean hasRelationship(NodeTemplate sourceNode, String targetNodeName, String requirementName, String capabilityName) { for (RelationshipTemplate relationshipTemplate : safe(sourceNode.getRelationships()).values()) { if (relationshipTemplate.getTarget().equals(targetNodeName) && relationshipTemplate.getRequirementName().equals(requirementName) && relationshipTemplate.getTargetedCapabilityName().equals(capabilityName)) { return true; } } return false; }
private Stream<DeploymentArtifact> getDeploymentArtifactStream(PaaSTopologyDeploymentContext deploymentContext) { return Stream.concat( safe(deploymentContext.getDeploymentTopology().getNodeTemplates()).values().stream() .flatMap(nodeTemplate -> safe(nodeTemplate.getArtifacts()).values().stream()), safe(deploymentContext.getDeploymentTopology().getNodeTemplates()).values().stream() .flatMap(nodeTemplate -> safe(nodeTemplate.getRelationships()).values().stream()) .flatMap(relationship -> safe(relationship.getArtifacts()).values().stream())); }
public static void doWithTopologyArtifacts(Topology topology, DoWithArtifact doWithArtifact) { safe(topology.getInputArtifacts()).values().forEach(doWithArtifact::doWithArtifact); safe(topology.getNodeTemplates()).values().forEach(nodeTemplate -> { safe(nodeTemplate.getArtifacts()).values().forEach(doWithArtifact::doWithArtifact); safe(nodeTemplate.getRelationships()).values() .forEach(relationshipTemplate -> safe(relationshipTemplate.getArtifacts()).values().forEach(doWithArtifact::doWithArtifact)); }); }
public static RelationshipTemplate getRelationshipFromType(NodeTemplate template, String type, IRelationshipTypeFinder toscaTypeFinder) { for (RelationshipTemplate relationshipTemplate : safe(template.getRelationships()).values()) { RelationshipType relationshipType = toscaTypeFinder.findElement(relationshipTemplate.getType()); if (relationshipType != null && ToscaTypeUtils.isOfType(relationshipType, type)) { return relationshipTemplate; } } return null; }
@Override protected void processRelationshipOperation(Csar csar, Topology topology, DeleteRelationshipOperation operation, NodeTemplate nodeTemplate, RelationshipTemplate relationshipTemplate) { log.debug("Removing the Relationship template <" + operation.getRelationshipName() + "> from the Node template <" + operation.getNodeName() + ">, Topology <" + topology.getId() + "> ."); topologyService.unloadType(topology, relationshipTemplate.getType()); workflowBuilderService.removeRelationship(topology, csar, operation.getNodeName(), operation.getRelationshipName(), relationshipTemplate); nodeTemplate.getRelationships().remove(operation.getRelationshipName()); } }
@Override protected void processNodeOperation(Csar csar, Topology topology, T operation, NodeTemplate nodeTemplate) { RelationshipTemplate relationshipTemplate = safe(nodeTemplate.getRelationships()).get(operation.getRelationshipName()); if (relationshipTemplate == null) { throw new NotFoundException("The relationship with name [" + operation.getRelationshipName() + "] do not exist for the node [" + operation.getNodeName() + "] of the topology [" + topology.getId() + "]"); } processRelationshipOperation(csar, topology, operation, nodeTemplate, relationshipTemplate); }
public void addRelationship(TopologyContext topologyContext, String nodeTemplateName, String relationshipName) { topologyContext.getTopology().getWorkflows().putAll(topologyContext.getTopology().getUnprocessedWorkflows()); NodeTemplate nodeTemplate = topologyContext.getTopology().getNodeTemplates().get(nodeTemplateName); RelationshipTemplate relationshipTemplate = nodeTemplate.getRelationships().get(relationshipName); for (Workflow wf : topologyContext.getTopology().getWorkflows().values()) { AbstractWorkflowBuilder builder = getWorkflowBuilder(topologyContext.getDSLVersion(), wf); builder.addRelationship(wf, nodeTemplateName, nodeTemplate, relationshipName, relationshipTemplate, topologyContext); WorkflowUtils.fillHostId(wf, topologyContext); } postProcessTopologyWorkflows(topologyContext); debugWorkflow(topologyContext.getTopology()); }
private static String getRelationshipTarget(String source, String relationshipId, TopologyContext topologyContext) { NodeTemplate sourceNode = safe(topologyContext.getTopology().getNodeTemplates()).get(source); if (sourceNode == null) { throw new NotFoundException("Source " + source + " cannot be found in the topology " + topologyContext.getTopology().getId()); } RelationshipTemplate relationshipTemplate = safe(sourceNode.getRelationships()).get(relationshipId); if (relationshipTemplate == null) { throw new NotFoundException( "Source " + source + " does not have the relationship " + relationshipId + " in the topology " + topologyContext.getTopology().getId()); } return relationshipTemplate.getTarget(); }
public ServiceNodeTemplate(NodeTemplate nodeTemplate, Map<String, String> attributeValues) { super(nodeTemplate.getType(), nodeTemplate.getProperties(), nodeTemplate.getAttributes(), nodeTemplate.getRelationships(), nodeTemplate.getRequirements(), nodeTemplate.getCapabilities(), nodeTemplate.getInterfaces(), nodeTemplate.getArtifacts()); this.attributeValues = attributeValues; }
@And("^The topology should have the property \"([^\"]*)\" of relationship \"([^\"]*)\" from the node \"([^\"]*)\" defined as a secret with a secret path \"([^\"]*)\"$") public void theTopologyShouldHaveThePropertyOfRelationshipFromTheNodeDefinedAsASecretWithASecretPath(String propertyName, String relationshipName, String nodeName, String secretPath) throws Throwable { String response = Context.getRestClientInstance().get("/rest/v1/topologies/" + Context.getInstance().getTopologyId()); JavaType restResponseType = Context.getJsonMapper().getTypeFactory().constructParametricType(RestResponse.class, TopologyDTO.class); TopologyDTO topologyDTO = ((RestResponse<TopologyDTO>) Context.getJsonMapper().readValue(response, restResponseType)).getData(); FunctionPropertyValue functionPropertyValue = (FunctionPropertyValue) topologyDTO.getTopology().getNodeTemplates().get(nodeName).getRelationships().get(relationshipName).getProperties().get(propertyName); Assert.assertEquals(secretPath, functionPropertyValue.getParameters().get(0)); }
@Then("^I should not have the relationship \"([^\"]*)\" in \"([^\"]*)\" node template$") public void I_should_not_have_a_relationship_in_node_template(String relName, String nodeTempName) throws Throwable { String topologyJson = Context.getRestClientInstance().get("/rest/v1/topologies/" + Context.getInstance().getTopologyId()); RestResponse<TopologyDTO> topologyResponse = JsonUtil.read(topologyJson, TopologyDTO.class, Context.getJsonMapper()); NodeTemplate sourceNode = topologyResponse.getData().getTopology().getNodeTemplates().get(nodeTempName); Map<String, RelationshipTemplate> rels = sourceNode.getRelationships(); if (rels != null) { assertFalse(rels.containsKey(relName)); } else { log.info("No relationship found in I_should_not_have_a_relationship_in_node_template(String relName, String nodeTempName)"); } }
@Then("^there should not be the relationship \"([^\"]*)\" in \"([^\"]*)\" node template in the topology dto$") public void there_should_not_be_the_relationship_in_node_template_in_the_topology_dto(String relName, String nodeName) throws IOException { TopologyDTO dto = JsonUtil.read(Context.getInstance().getRestResponse(), TopologyDTO.class, Context.getJsonMapper()).getData(); NodeTemplate template = dto.getTopology().getNodeTemplates().get(nodeName); Assert.assertNotNull(template); assertFalse(template.getRelationships().containsKey(relName)); }
@Then("^the node \"([^\"]*)\" in the topology dto should have (\\d+) relationshipTemplates$") public void the_node_in_the_topology_dto_should_have_relationshiptemplates(String nodeName, int count) throws Throwable { TopologyDTO dto = JsonUtil.read(Context.getInstance().getRestResponse(), TopologyDTO.class, Context.getJsonMapper()).getData(); NodeTemplate template = dto.getTopology().getNodeTemplates().get(nodeName); Assert.assertNotNull(template); Assert.assertEquals(count, template.getRelationships().size()); }
@Then("The RestResponse should not contain a relationship of type \"([^\"]*)\" with source \"([^\"]*)\" and target \"([^\"]*)\"") public void The_RestResponse_should_not_contain_a_relationship_of_type_with_source_and_target(String type, String source, String target) throws Throwable { TopologyDTO topologyDTO = JsonUtil.read(Context.getInstance().getRestResponse(), TopologyDTO.class, Context.getJsonMapper()).getData(); assertNotNull(topologyDTO); assertNotNull(topologyDTO.getTopology()); assertNotNull(topologyDTO.getTopology().getNodeTemplates()); assertNotNull(topologyDTO.getTopology().getNodeTemplates().get(source)); assertNotNull(topologyDTO.getTopology().getNodeTemplates().get(source).getRelationships() == null || topologyDTO.getTopology().getNodeTemplates().get(source).getRelationships().get(getRelationShipName(type, target)) == null); }
@Then("^I should have (\\d+) relationship with source \"([^\"]*)\" and target \"([^\"]*)\" for type \"([^\"]*)\" with requirement \"([^\"]*)\" of type \"([^\"]*)\"$") public void I_should_have_relationship_with_source_for_requirement_of_type(int relationshipCount, String source, String target, String relType, String requirementName, String requirementType) throws Throwable { String topologyJson = Context.getRestClientInstance().get("/rest/v1/topologies/" + Context.getInstance().getTopologyId()); RestResponse<TopologyDTO> topologyResponse = JsonUtil.read(topologyJson, TopologyDTO.class, Context.getJsonMapper()); NodeTemplate sourceNode = topologyResponse.getData().getTopology().getNodeTemplates().get(source); RelationshipTemplate rel = sourceNode.getRelationships().get(getRelationShipName(relType, target)); assertNotNull(rel); // Only one relationship of this type for the moment : cardinality check soon assertEquals(rel.getRequirementName(), requirementName); assertEquals(rel.getRequirementType(), requirementType); }