@Override Map<String, NodeTemplate> getTemplates(Topology topology) { return topology.getNodeTemplates(); } }
private void renameNodes(CompositionCouple compositionCouple) { Topology topology = compositionCouple.child; String[] nodeNames = new String[topology.getNodeTemplates().size()]; nodeNames = topology.getNodeTemplates().keySet().toArray(nodeNames); for (String nodeName : nodeNames) { String newName = ensureNodeNameIsUnique(topology.getNodeTemplates().keySet(), compositionCouple.nodeNamePrefix + nodeName, 0); renameNodeTemplate(topology, nodeName, newName); } }
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()); } }
public static NodeTemplate getImmediateHostTemplate(Topology topology, NodeTemplate template, IToscaTypeFinder toscaTypeFinder) { RelationshipTemplate host = getRelationshipFromType(template, NormativeRelationshipConstants.HOSTED_ON, id -> toscaTypeFinder.findElement(RelationshipType.class, id)); if (host == null) { return null; } return topology.getNodeTemplates().get(host.getTarget()); }
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)); }); }
private void doWithNode(TopologyContext tc, DoWithNodeCallBack callback, Set<String> whiteList) { // Attention: workflows with custom modifications are not processed AlienUtils.safe(tc.getTopology().getWorkflows()).values().stream() .filter(wf -> !wf.isHasCustomModifications() && whiteList.contains(wf.getName())) .forEach(wf -> AlienUtils.safe(tc.getTopology().getNodeTemplates()).keySet().forEach(nodeId -> { SubGraphFilter stepFilter = new NodeSubGraphFilter(wf, nodeId, tc.getTopology()); SubGraph subGraph = new SubGraph(wf, stepFilter); callback.doWithNode(subGraph, wf); })); }
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()); }
@Override public void process(Csar csar, Topology topology, T operation) { NodeTemplate nodeTemplate = AlienUtils.getOrFail(topology.getNodeTemplates(), operation.getNodeName(), "The node with name [ {} ] cannot be found in the topology [ {} ].", operation.getNodeName(), topology.getId()); processNodeOperation(csar, topology, operation, nodeTemplate); }
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(); }
@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); }
@And("^The topology should have the property \"([^\"]*)\" of capability \"([^\"]*)\" of a node \"([^\"]*)\" defined as a secret with a secret path \"([^\"]*)\"$") public void theTopologyShouldHaveThePropertyOfCapabilityOfANodeDefinedAsASecretWithASecretPath(String propertyName, String capabilityName, 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).getCapabilities().get(capabilityName).getProperties().get(propertyName); Assert.assertEquals(secretPath, functionPropertyValue.getParameters().get(0)); }
@And("^The topology should have the property \"([^\"]*)\" of a node \"([^\"]*)\" defined as a secret with a secret path \"([^\"]*)\"$") public void theTopologyShouldHaveThePropertyDefinedAsASecretWithASecretPath(String propertyName, 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).getProperties().get(propertyName); Assert.assertEquals(secretPath, functionPropertyValue.getParameters().get(0)); }
@Then("^The RestResponse should not contain a nodetemplate named \"([^\"]*)\"") public void The_RestResponse_should_not_contain_a_nodetemplate_named(String key) throws Throwable { TopologyDTO topologyDTO = JsonUtil.read(Context.getInstance().getRestResponse(), TopologyDTO.class, Context.getJsonMapper()).getData(); assertNotNull(topologyDTO); assertNotNull(topologyDTO.getTopology()); assertTrue(topologyDTO.getTopology().getNodeTemplates() == null || topologyDTO.getTopology().getNodeTemplates().get(key) == null); }
@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)"); } }
@And("^The topology should contain a nodetemplate named \"([^\"]*)\" with property \"([^\"]*)\" of capability \"([^\"]*)\" set to \"([^\"]*)\"$") public void theTopologyShouldContainANodetemplateNamedWithPropertyOfCapabilitySetToNull(String nodeTemplateName, String propertyName, String capabilityName, String propertyValue) throws Throwable { The_topology_should_contain_a_nodetemplate_named(nodeTemplateName); String topologyResponseText = Context.getInstance().getRestResponse(); NodeTemplate nodeTemp = JsonUtil.read(topologyResponseText, TopologyDTO.class, Context.getJsonMapper()).getData().getTopology().getNodeTemplates() .get(nodeTemplateName); assertNotNull(nodeTemp.getCapabilities().get(capabilityName).getProperties()); if (propertyValue != null) { assertNotNull(nodeTemp.getCapabilities().get(capabilityName).getProperties().get(propertyName)); } assertEquals(propertyValue, PropertyUtil.getScalarValue(nodeTemp.getCapabilities().get(capabilityName).getProperties().get(propertyName))); }
@Then("^the node \"([^\"]*)\" in the topology dto should not have the requirement \"([^\"]*)\"$") public void I_node_in_the_topology_dto_should_not_have_the_requirement(String nodeName, String requirementName) 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.getRequirements().containsKey(requirementName)); } }
@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 node \"([^\"]*)\" in the topology dto should not have the capability \"([^\"]*)\"$") public void I_node_in_the_topology_dto_should_not_have_the_capability(String nodeName, String capabilityName) 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.getCapabilities().containsKey(capabilityName)); }
@Then("^the topology dto should contain (\\d+) nodetemplates$") public void the_topology_dto_should_contain_nodetemplates(int count) throws Throwable { TopologyDTO dto = JsonUtil.read(Context.getInstance().getRestResponse(), TopologyDTO.class, Context.getJsonMapper()).getData(); Assert.assertEquals(count, dto.getTopology().getNodeTemplates().size()); }