/** * Get a {@link NodeTemplate} given its name from a topology * * @param topology the topology * @param nodeTemplateId the name of the node template * @return the found node template, throws NotFoundException if not found */ public static NodeTemplate getNodeTemplate(Topology topology, String nodeTemplateId) { Map<String, NodeTemplate> nodeTemplates = getNodeTemplates(topology); return getNodeTemplate(topology.getId(), nodeTemplateId, nodeTemplates); }
private void updateRuntimeTopology(DeploymentTopology runtimeTopo, PaaSInstancePersistentResourceMonitorEvent persistentResourceEvent, Map<String, Object> persistentProperties) { NodeTemplate nodeTemplate = TopologyUtils.getNodeTemplate(runtimeTopo, persistentResourceEvent.getNodeTemplateId()); log.info("Updating Runtime topology: Storage NodeTemplate <{}.{}> to add a new volumeId", runtimeTopo.getId(), persistentResourceEvent.getNodeTemplateId()); for (String key : persistentProperties.keySet()) { nodeTemplate.getProperties().put(key, getPropertyValue(persistentProperties.get(key))); log.debug("Property [ {} ] to update: [ {} ]. New value is [ {} ]", key, persistentResourceEvent.getPersistentProperties().get(key), persistentProperties.get(key)); } alienMonitorDao.save(runtimeTopo); }
@Override public void process(Csar csar, Topology topology, DuplicateNodeOperation operation) { Map<String, NodeTemplate> nodeTemplates = TopologyUtils.getNodeTemplates(topology); // Retrieve existing node template NodeTemplate nodeTemplateToDuplicate = TopologyUtils.getNodeTemplate(topology.getId(), operation.getNodeName(), nodeTemplates); // map that will contains a mapping of the duplicated node and their new names Map<String, String> duplicatedNodesNameMappings = Maps.newHashMap(); // first duplicate the node templates duplicateNodeTemplate(nodeTemplateToDuplicate, duplicatedNodesNameMappings, nodeTemplates, topology, csar); // then clean the relationships, discarding all that targets a node not in hostedNodes processRelationships(duplicatedNodesNameMappings, nodeTemplates, topology, csar); }
private void fillSubstituteAttributesFromTypeAtttributes(Topology topology, NodeType substituteNodeType) { Map<String, IValue> attributes = substituteNodeType.getAttributes(); Map<String, Set<String>> outputAttributes = topology.getOutputAttributes(); if (outputAttributes != null) { for (Map.Entry<String, Set<String>> oae : outputAttributes.entrySet()) { String nodeName = oae.getKey(); NodeTemplate nodeTemplate = TopologyUtils.getNodeTemplate(topology, nodeName); NodeType nodeTemplateType = ToscaContext.getOrFail(NodeType.class, nodeTemplate.getType()); for (String attributeName : oae.getValue()) { IValue ivalue = nodeTemplateType.getAttributes().get(attributeName); // FIXME we have an issue here : if several nodes have the same attribute name, or if an attribute and a property have the same name, there // is a conflict if (ivalue != null && !attributes.containsKey(attributeName)) { attributes.put(attributeName, ivalue); } } } } }
/** * Rename formattedOldNodeName node template of a topology. * * @param topology * @param nodeTemplateName * @param newNodeTemplateName */ public static void renameNodeTemplate(Topology topology, String nodeTemplateName, String newNodeTemplateName) { Map<String, NodeTemplate> nodeTemplates = getNodeTemplates(topology); NodeTemplate nodeTemplate = getNodeTemplate(topology.getId(), nodeTemplateName, nodeTemplates); nodeTemplate.setName(newNodeTemplateName); nodeTemplates.put(newNodeTemplateName, nodeTemplate); nodeTemplates.remove(nodeTemplateName); refreshNodeTempNameInRelationships(nodeTemplateName, newNodeTemplateName, nodeTemplates); updateOnNodeTemplateNameChange(nodeTemplateName, newNodeTemplateName, topology); updateGroupMembers(topology, nodeTemplate, nodeTemplateName, newNodeTemplateName); updatePolicyMembers(topology, nodeTemplateName, newNodeTemplateName); }
public static Capability getScalableCapability(Topology topology, String nodeTemplateId, boolean throwNotFoundException) { NodeTemplate nodeTemplate = throwNotFoundException ? getNodeTemplate(topology, nodeTemplateId) : safe(topology.getNodeTemplates()).get(nodeTemplateId); if (nodeTemplate == null) { return null; } return throwNotFoundException ? NodeTemplateUtils.getCapabilityByTypeOrFail(nodeTemplate, NormativeCapabilityTypes.SCALABLE) : NodeTemplateUtils.getCapabilityByType(nodeTemplate, NormativeCapabilityTypes.SCALABLE); }
/** * Utility method to get possible replacement indexedNodeTypes for a node template * * @param topologyId The id of the topology for which to find possible nodes replacement. * @param nodeTemplateName The name of the node template for which to get possible nodes replacement. * @return An array of possible replacement for a node template. */ public NodeType[] getReplacementForNode(String topologyId, String nodeTemplateName) { try { editionContextManager.init(topologyId); // check authorization to update a topology topologyService.checkEditionAuthorizations(EditionContextManager.getTopology()); Topology topology = EditionContextManager.getTopology(); TopologyUtils.getNodeTemplate(topologyId, nodeTemplateName, TopologyUtils.getNodeTemplates(topology)); return topologyService.findReplacementForNode(nodeTemplateName, topology); } finally { editionContextManager.destroy(); } } }
private Map<String, Object> getAggregatedVolumeIds(DeploymentTopology topology, String nodeTemplateId, Map<String, Object> persistentProperties) { NodeTemplate nodeTemplate; try { nodeTemplate = TopologyUtils.getNodeTemplate(topology, nodeTemplateId); } catch (NotFoundException e) { log.warn("Fail to update volumeIds for node " + nodeTemplateId, e); return null; } Map<String, Object> aggregatedProperties = Maps.newHashMap(); Map<String, Object> concernedNodeProperties = extractConcernedNodeProperties(nodeTemplate.getName(), nodeTemplate.getProperties(), persistentProperties.keySet()); List<Map<String, String>> splittedNodeProperties = splitNodePropertiesValue(concernedNodeProperties); if (!persistentPropertiesAlreadyExist(persistentProperties, splittedNodeProperties)) { aggregatedProperties = buildAggregatedProperties(persistentProperties, concernedNodeProperties); } return aggregatedProperties; }
private void validateCommand(OperationExecRequest operationRequest, Topology topology) throws ConstraintFunctionalException { NodeTemplate nodeTemplate = TopologyUtils.getNodeTemplate(topology.getId(), operationRequest.getNodeTemplateName(), TopologyUtils.getNodeTemplates(topology)); NodeType indexedNodeType = toscaTypeSearchService.getRequiredElementInDependencies(NodeType.class, nodeTemplate.getType(), topology.getDependencies()); Map<String, Interface> interfaces = IndexedModelUtils.mergeInterfaces(indexedNodeType.getInterfaces(), nodeTemplate.getInterfaces()); if (interfaces == null || interfaces.get(operationRequest.getInterfaceName()) == null) { throw new NotFoundException("Interface [" + operationRequest.getInterfaceName() + "] not found in the node template [" + operationRequest.getNodeTemplateName() + "] related to [" + indexedNodeType.getId() + "]"); } Interface interfass = interfaces.get(operationRequest.getInterfaceName()); validateOperation(interfass, operationRequest, topology.getDependencies()); }
RelationshipWorkflowStep rws = (RelationshipWorkflowStep)workflowStep; String sourceNodeId = rws.getTarget(); NodeTemplate sourceNodeTemplate = TopologyUtils.getNodeTemplate(topology, sourceNodeId); String targetNodeId = sourceNodeTemplate.getRelationships().get(rws.getTargetRelationship()).getTarget(); Integer instanceCount = nodeInstanceCount.get((rws.getOperationHost().equals("SOURCE")) ? sourceNodeId : targetNodeId);
@Override @SneakyThrows public void process(Csar csar, Topology topology, UpdateCapabilityPropertyValueOperation operation) { String propertyName = operation.getPropertyName(); Object propertyValue = operation.getPropertyValue(); Map<String, NodeTemplate> nodeTemplates = TopologyUtils.getNodeTemplates(topology); NodeTemplate nodeTemplate = TopologyUtils.getNodeTemplate(topology.getId(), operation.getNodeName(), nodeTemplates); Capability capability = nodeTemplate.getCapabilities().get(operation.getCapabilityName()); CapabilityType capabilityType = ToscaContext.get(CapabilityType.class, capability.getType()); if (!capabilityType.getProperties().containsKey(propertyName)) { throw new NotFoundException( "Property <" + propertyName + "> doesn't exists for node <" + operation.getNodeName() + "> of type <" + capabilityType + ">"); } log.debug("Updating property [ {} ] of the capability [ {} ] for the Node template [ {} ] from the topology [ {} ]: changing value from [{}] to [{}].", propertyName, capability.getType(), operation.getNodeName(), topology.getId(), capabilityType.getProperties().get(propertyName), propertyValue); try { propertyService.setCapabilityPropertyValue(capability, capabilityType.getProperties().get(propertyName), propertyName, propertyValue); } catch (ConstraintFunctionalException e) { throw new PropertyValueException("Error when setting node " + operation.getNodeName() + " property.", e, propertyName, propertyValue); } } }
nodeTemplate = TopologyUtils.getNodeTemplate(topology, persistentResourceEvent.getNodeTemplateId()); } catch (NotFoundException e) { log.warn("Fail to update persistent resource for node {}", persistentResourceEvent.getNodeTemplateId(), e);
@Override public void process(Csar csar, Topology topology, UpdateNodePropertyValueOperation operation) { Map<String, NodeTemplate> nodeTemplates = TopologyUtils.getNodeTemplates(topology); NodeTemplate nodeTemp = TopologyUtils.getNodeTemplate(topology.getId(), operation.getNodeName(), nodeTemplates); String propertyName = operation.getPropertyName(); Object propertyValue = operation.getPropertyValue(); NodeType node = ToscaContext.getOrFail(NodeType.class, nodeTemp.getType()); PropertyDefinition propertyDefinition = node.getProperties().get(propertyName); if (propertyDefinition == null) { throw new NotFoundException( "Property <" + propertyName + "> doesn't exists for node <" + operation.getNodeName() + "> of type <" + nodeTemp.getType() + ">"); } log.debug("Updating property [ {} ] of the Node template [ {} ] from the topology [ {} ]: changing value from [{}] to [{}].", propertyName, operation.getNodeName(), topology.getId(), nodeTemp.getProperties().get(propertyName), propertyValue); try { propertyService.setPropertyValue(nodeTemp, propertyDefinition, propertyName, propertyValue); } catch (ConstraintFunctionalException e) { throw new PropertyValueException("Error when setting node " + operation.getNodeName() + " property.", e, propertyName, propertyValue); } } }
private void doScale(final String nodeTemplateId, final int instances, final IPaaSCallback<Object> callback, final Deployment deployment, final DeploymentTopology topology, SecretProviderConfigurationAndCredentials secretProviderConfigurationAndCredentials) { NodeTemplate nodeTemplate = TopologyUtils.getNodeTemplate(topology, nodeTemplateId); // get the secret provider configuration from the location Map<String, String> locationIds = TopologyLocationUtils.getLocationIds(topology); Map<String, Location> locations = deploymentTopologyService.getLocations(locationIds); SecretProviderConfigurationAndCredentials authResponse = null; if (secretProviderService.isSecretProvided(secretProviderConfigurationAndCredentials)) { authResponse = secretProviderService.generateToken(locations, secretProviderConfigurationAndCredentials.getSecretProviderConfiguration().getPluginName(), secretProviderConfigurationAndCredentials.getCredentials()); } // Get alien4cloud specific interface to support cluster controller nodes. Capability clusterControllerCapability = NodeTemplateUtils.getCapabilityByType(nodeTemplate, AlienCapabilityTypes.CLUSTER_CONTROLLER); if (clusterControllerCapability == null) { doScaleNode(nodeTemplateId, instances, callback, deployment, topology, nodeTemplate, authResponse); } else { triggerClusterManagerScaleOperation(nodeTemplateId, instances, callback, deployment, topology, clusterControllerCapability, secretProviderConfigurationAndCredentials); } }
@Override public void process(Csar csar, Topology topology, ResetNodeDeploymentArtifactOperation operation) { // Get the node template's artifacts to reset Map<String, NodeTemplate> nodeTemplates = TopologyUtils.getNodeTemplates(topology); NodeTemplate nodeTemplate = TopologyUtils.getNodeTemplate(topology.getId(), operation.getNodeName(), nodeTemplates); DeploymentArtifact currentArtifact = nodeTemplate.getArtifacts() == null ? null : nodeTemplate.getArtifacts().get(operation.getArtifactName()); if (currentArtifact == null) { throw new NotFoundException( "Artifact with key [" + operation.getArtifactName() + "] do not exist in node template [" + nodeTemplate.getName() + "]."); } // Get the node type's artifact Map<String, NodeType> nodeTypes = topologyServiceCore.getIndexedNodeTypesFromTopology(topology, false, false, true); NodeType nodeType = nodeTypes.get(nodeTemplate.getType()); DeploymentArtifact artifactFromNodeType = nodeType.getArtifacts() == null ? null : nodeType.getArtifacts().get(operation.getArtifactName()); if (artifactFromNodeType == null) { throw new NotFoundException("Artifact with key [" + operation.getArtifactName() + "] do not exist in node type [" + nodeType.getId() + "]."); } currentArtifact.setArtifactRef(artifactFromNodeType.getArtifactRef()); currentArtifact.setArtifactName(artifactFromNodeType.getArtifactName()); currentArtifact.setArtifactType(artifactFromNodeType.getArtifactType()); currentArtifact.setArtifactRepository(artifactFromNodeType.getArtifactRepository()); currentArtifact.setRepositoryName(artifactFromNodeType.getRepositoryName()); currentArtifact.setRepositoryURL(artifactFromNodeType.getRepositoryURL()); currentArtifact.setRepositoryCredential(artifactFromNodeType.getRepositoryCredential()); } }
@Override public void process(Csar csar, Topology topology, UpdateNodeDeploymentArtifactOperation operation) { // Get the node template's artifacts to update Map<String, NodeTemplate> nodeTemplates = TopologyUtils.getNodeTemplates(topology); NodeTemplate nodeTemplate = TopologyUtils.getNodeTemplate(topology.getId(), operation.getNodeName(), nodeTemplates); DeploymentArtifact artifact = nodeTemplate.getArtifacts() == null ? null : nodeTemplate.getArtifacts().get(operation.getArtifactName()); if (artifact == null) { throw new NotFoundException("Artifact with key [" + operation.getArtifactName() + "] do not exist"); } if (operation.getArtifactRepository() == null) { // this is an archive file, ensure that the file exists within the archive FileProcessorHelper.getFileTreeNode(operation.getArtifactReference()); artifact.setArtifactRepository(ArtifactRepositoryConstants.ALIEN_TOPOLOGY_REPOSITORY); artifact.setRepositoryName(null); artifact.setRepositoryURL(null); } else { artifact.setArtifactRepository(operation.getArtifactRepository()); artifact.setRepositoryName(operation.getRepositoryName()); artifact.setRepositoryURL(operation.getRepositoryUrl()); } artifact.setArtifactRef(operation.getArtifactReference()); artifact.setArchiveName(operation.getArchiveName()); artifact.setArchiveVersion(operation.getArchiveVersion()); } }
NodeTemplate oldNodeTemplate = TopologyUtils.getNodeTemplate(topology.getId(), operation.getNodeName(), nodeTemplates);
TopologyUtils.getNodeTemplate(topology.getId(), operation.getTarget(), nodeTemplates);