/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019-2020 Nordix Foundation.
+ * Copyright (C) 2019-2020, 2022-2023 Nordix Foundation.
+ * Modifications Copyright (C) 2020-2021 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
package org.onap.policy.models.tosca.simple.provider;
+import jakarta.ws.rs.core.Response;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
-
-import javax.ws.rs.core.Response;
-
+import java.util.Map;
+import java.util.Optional;
import lombok.NonNull;
-
import org.apache.commons.collections4.CollectionUtils;
+import org.onap.policy.common.parameters.BeanValidationResult;
import org.onap.policy.models.base.PfConcept;
import org.onap.policy.models.base.PfConceptFilter;
import org.onap.policy.models.base.PfConceptKey;
import org.onap.policy.models.base.PfKey;
import org.onap.policy.models.base.PfModelException;
import org.onap.policy.models.base.PfModelRuntimeException;
-import org.onap.policy.models.base.PfValidationResult;
import org.onap.policy.models.dao.PfDao;
import org.onap.policy.models.tosca.authorative.concepts.ToscaEntity;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaEntityKey;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate;
import org.onap.policy.models.tosca.simple.concepts.JpaToscaDataType;
import org.onap.policy.models.tosca.simple.concepts.JpaToscaDataTypes;
import org.onap.policy.models.tosca.simple.concepts.JpaToscaEntityType;
+import org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTemplate;
+import org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTemplates;
+import org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeType;
+import org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTypes;
import org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicies;
import org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicy;
import org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicyType;
import org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicyTypes;
import org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate;
+import org.onap.policy.models.tosca.simple.concepts.JpaToscaTopologyTemplate;
import org.onap.policy.models.tosca.utils.ToscaServiceTemplateUtils;
import org.onap.policy.models.tosca.utils.ToscaUtils;
import org.slf4j.Logger;
* @throws PfModelException on errors appending a service template to the template in the database
*/
public JpaToscaServiceTemplate appendToServiceTemplate(@NonNull final PfDao dao,
- @NonNull final JpaToscaServiceTemplate incomingServiceTemplateFragment) throws PfModelException {
+ @NonNull final JpaToscaServiceTemplate incomingServiceTemplateFragment) throws PfModelException {
LOGGER.debug("->appendServiceTemplateFragment: incomingServiceTemplateFragment={}",
- incomingServiceTemplateFragment);
+ incomingServiceTemplateFragment);
JpaToscaServiceTemplate dbServiceTemplate = new SimpleToscaServiceTemplateProvider().read(dao);
serviceTemplateToWrite = incomingServiceTemplateFragment;
} else {
serviceTemplateToWrite =
- ToscaServiceTemplateUtils.addFragment(dbServiceTemplate, incomingServiceTemplateFragment);
+ ToscaServiceTemplateUtils.addFragment(dbServiceTemplate, incomingServiceTemplateFragment);
}
- PfValidationResult result = serviceTemplateToWrite.validate(new PfValidationResult());
+ BeanValidationResult result = serviceTemplateToWrite.validate("service template");
if (!result.isValid()) {
- throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE, result.toString());
+ throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE, result.getResult());
}
new SimpleToscaServiceTemplateProvider().write(dao, serviceTemplateToWrite);
return serviceTemplateToWrite;
}
+ /**
+ * Delete service template.
+ *
+ * @param dao the DAO to use to access the database
+ * @return the TOSCA service template that was deleted
+ * @throws PfModelException on errors deleting the service template
+ */
+ public JpaToscaServiceTemplate deleteServiceTemplate(@NonNull final PfDao dao) throws PfModelException {
+ LOGGER.debug("->deleteServiceTemplate");
+
+ JpaToscaServiceTemplate serviceTemplate = getServiceTemplate(dao);
+
+ dao.delete(serviceTemplate);
+
+ LOGGER.debug("->deleteServiceTemplate: serviceTemplate={}", serviceTemplate);
+ return serviceTemplate;
+ }
+
/**
* Get data types.
*
* @throws PfModelException on errors getting data types
*/
public JpaToscaServiceTemplate getDataTypes(@NonNull final PfDao dao, final String name, final String version)
- throws PfModelException {
+ throws PfModelException {
LOGGER.debug("->getDataTypes: name={}, version={}", name, version);
- JpaToscaServiceTemplate serviceTemplate = getServiceTemplate(dao);
+ final JpaToscaServiceTemplate dbServiceTemplate = getServiceTemplate(dao);
- if (!ToscaUtils.doDataTypesExist(serviceTemplate)) {
+ if (!ToscaUtils.doDataTypesExist(dbServiceTemplate)) {
throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
- "data types for " + name + ":" + version + DO_NOT_EXIST);
+ "data types for " + name + ":" + version + DO_NOT_EXIST);
}
+ JpaToscaServiceTemplate serviceTemplate = getCascadedDataTypes(dbServiceTemplate, name, version);
+
+ LOGGER.debug("<-getDataTypes: name={}, version={}, serviceTemplate={}", name, version, serviceTemplate);
+ return serviceTemplate;
+ }
+
+ /**
+ * Get the cascaded data types for a data type name and version.
+ *
+ * @param dbServiceTemplate the service template to search for the cascaded data types
+ * @param name the data type name we are searching for
+ * @param version the data type version we are searching for
+ * @return a service template containing the cascaded data types
+ * @throws PfModelException on errors getting the data types
+ */
+ public JpaToscaServiceTemplate getCascadedDataTypes(@NonNull final JpaToscaServiceTemplate dbServiceTemplate,
+ final String name, final String version) throws PfModelException {
+
+ var serviceTemplate = new JpaToscaServiceTemplate(dbServiceTemplate);
serviceTemplate.setPolicyTypes(null);
serviceTemplate.setTopologyTemplate(null);
if (!ToscaUtils.doDataTypesExist(serviceTemplate)) {
throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
- "data types for " + name + ":" + version + DO_NOT_EXIST);
+ "data types for " + name + ":" + version + DO_NOT_EXIST);
}
for (JpaToscaDataType dataType : serviceTemplate.getDataTypes().getConceptMap().values()) {
Collection<PfConceptKey> referencedDataTypeKeys = dataType.getReferencedDataTypes();
for (PfConceptKey referencedDataTypeKey : referencedDataTypeKeys) {
- JpaToscaServiceTemplate dataTypeEntityTreeServiceTemplate =
- getDataTypes(dao, referencedDataTypeKey.getName(), referencedDataTypeKey.getVersion());
+ JpaToscaServiceTemplate dataTypeEntityTreeServiceTemplate = getCascadedDataTypes(dbServiceTemplate,
+ referencedDataTypeKey.getName(), referencedDataTypeKey.getVersion());
serviceTemplate =
- ToscaServiceTemplateUtils.addFragment(serviceTemplate, dataTypeEntityTreeServiceTemplate);
+ ToscaServiceTemplateUtils.addFragment(serviceTemplate, dataTypeEntityTreeServiceTemplate);
}
}
-
- LOGGER.debug("<-getDataTypes: name={}, version={}, serviceTemplate={}", name, version, serviceTemplate);
return serviceTemplate;
}
* @throws PfModelException on errors creating data types
*/
public JpaToscaServiceTemplate createDataTypes(@NonNull final PfDao dao,
- @NonNull final JpaToscaServiceTemplate incomingServiceTemplate) throws PfModelException {
+ @NonNull final JpaToscaServiceTemplate incomingServiceTemplate) throws PfModelException {
LOGGER.debug("->createDataTypes: incomingServiceTemplate={}", incomingServiceTemplate);
ToscaUtils.assertDataTypesExist(incomingServiceTemplate);
JpaToscaServiceTemplate writtenServiceTemplate = appendToServiceTemplate(dao, incomingServiceTemplate);
- LOGGER.debug("<-createDataTypes: returnServiceTempalate={}", writtenServiceTemplate);
- return writtenServiceTemplate;
+ LOGGER.debug("<-createDataTypes: writtenServiceTemplate={}", writtenServiceTemplate);
+ return incomingServiceTemplate;
}
/**
* @throws PfModelException on errors updating Data types
*/
public JpaToscaServiceTemplate updateDataTypes(@NonNull final PfDao dao,
- @NonNull final JpaToscaServiceTemplate serviceTemplate) throws PfModelException {
+ @NonNull final JpaToscaServiceTemplate serviceTemplate) throws PfModelException {
LOGGER.debug("->updateDataTypes: serviceTempalate={}", serviceTemplate);
ToscaUtils.assertDataTypesExist(serviceTemplate);
}
// Return the created data types
- JpaToscaDataTypes returnDataTypes = new JpaToscaDataTypes();
+ var returnDataTypes = new JpaToscaDataTypes();
for (PfConceptKey dataTypeKey : serviceTemplate.getDataTypes().getConceptMap().keySet()) {
returnDataTypes.getConceptMap().put(dataTypeKey, dao.get(JpaToscaDataType.class, dataTypeKey));
}
- JpaToscaServiceTemplate returnServiceTemplate = new JpaToscaServiceTemplate();
+ var returnServiceTemplate = new JpaToscaServiceTemplate();
returnServiceTemplate.setDataTypes(returnDataTypes);
LOGGER.debug("<-updateDataTypes: returnServiceTempalate={}", returnServiceTemplate);
* @throws PfModelException on errors deleting data types
*/
public JpaToscaServiceTemplate deleteDataType(@NonNull final PfDao dao, @NonNull final PfConceptKey dataTypeKey)
- throws PfModelException {
+ throws PfModelException {
LOGGER.debug("->deleteDataType: key={}", dataTypeKey);
JpaToscaServiceTemplate serviceTemplate = getServiceTemplate(dao);
for (JpaToscaDataType dataType : serviceTemplate.getDataTypes().getAll(null)) {
if (dataType.getReferencedDataTypes().contains(dataTypeKey)) {
- throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE, DATA_TYPE + dataTypeKey.getId()
- + " is in use, it is referenced in data type " + dataType.getId());
+ throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE,
+ DATA_TYPE + dataTypeKey.getId() + " is in use, it is referenced in data type " + dataType.getId());
}
}
for (JpaToscaPolicyType policyType : serviceTemplate.getPolicyTypes().getAll(null)) {
if (policyType.getReferencedDataTypes().contains(dataTypeKey)) {
throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE, DATA_TYPE + dataTypeKey.getId()
- + " is in use, it is referenced in policy type " + policyType.getId());
+ + " is in use, it is referenced in policy type " + policyType.getId());
}
}
}
- dao.delete(JpaToscaDataType.class, dataTypeKey);
+ serviceTemplate.getDataTypes().getConceptMap().remove(dataTypeKey);
+ new SimpleToscaServiceTemplateProvider().write(dao, serviceTemplate);
+ dao.delete(dataType4Deletion);
- LOGGER.debug("<-deleteDataType: key={}, serviceTempalate={}", dataTypeKey, serviceTemplate);
- return serviceTemplate;
+ var deletedServiceTemplate = new JpaToscaServiceTemplate();
+ deletedServiceTemplate.setDataTypes(new JpaToscaDataTypes());
+ deletedServiceTemplate.getDataTypes().getConceptMap().put(dataTypeKey, dataType4Deletion);
+
+ LOGGER.debug("<-deleteDataType: key={}, serviceTempalate={}", dataTypeKey, deletedServiceTemplate);
+ return deletedServiceTemplate;
}
/**
* @throws PfModelException on errors getting policy types
*/
public JpaToscaServiceTemplate getPolicyTypes(@NonNull final PfDao dao, final String name, final String version)
- throws PfModelException {
+ throws PfModelException {
LOGGER.debug("->getPolicyTypes: name={}, version={}", name, version);
- JpaToscaServiceTemplate serviceTemplate = getServiceTemplate(dao);
-
- serviceTemplate.setDataTypes(null);
- serviceTemplate.setTopologyTemplate(null);
+ final JpaToscaServiceTemplate dbServiceTemplate = getServiceTemplate(dao);
- if (!ToscaUtils.doPolicyTypesExist(serviceTemplate)) {
+ if (!ToscaUtils.doPolicyTypesExist(dbServiceTemplate)) {
throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
- "policy types for " + name + ":" + version + DO_NOT_EXIST);
+ "policy types for " + name + ":" + version + DO_NOT_EXIST);
}
+ JpaToscaServiceTemplate serviceTemplate = getCascadedPolicyTypes(dbServiceTemplate, name, version);
+
+ LOGGER.debug("<-getPolicyTypes: name={}, version={}, serviceTemplate={}", name, version, serviceTemplate);
+ return serviceTemplate;
+ }
+
+ /**
+ * Get the cascaded policy types for a policy type name and version.
+ *
+ * @param dbServiceTemplate the service template to search for the cascaded policy types
+ * @param name the policy type name we are searching for
+ * @param version the policy type version we are searching for
+ * @return a service template containing the cascaded policy types
+ * @throws PfModelException on errors getting the policy types
+ */
+ public JpaToscaServiceTemplate getCascadedPolicyTypes(final JpaToscaServiceTemplate dbServiceTemplate,
+ final String name, final String version) throws PfModelException {
+
+ var serviceTemplate = new JpaToscaServiceTemplate(dbServiceTemplate);
+
+ serviceTemplate.setDataTypes(null);
+ serviceTemplate.setTopologyTemplate(null);
+
ToscaUtils.getEntityTree(serviceTemplate.getPolicyTypes(), name, version);
if (!ToscaUtils.doPolicyTypesExist(serviceTemplate)) {
throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
- "policy types for " + name + ":" + version + DO_NOT_EXIST);
+ "policy types for " + name + ":" + version + DO_NOT_EXIST);
}
- JpaToscaServiceTemplate dataTypeServiceTemplate = new JpaToscaServiceTemplate(serviceTemplate);
+ var dataTypeServiceTemplate = new JpaToscaServiceTemplate(serviceTemplate);
dataTypeServiceTemplate.setPolicyTypes(null);
for (JpaToscaPolicyType policyType : serviceTemplate.getPolicyTypes().getConceptMap().values()) {
Collection<PfConceptKey> referencedDataTypeKeys = policyType.getReferencedDataTypes();
for (PfConceptKey referencedDataTypeKey : referencedDataTypeKeys) {
- JpaToscaServiceTemplate dataTypeEntityTreeServiceTemplate =
- getDataTypes(dao, referencedDataTypeKey.getName(), referencedDataTypeKey.getVersion());
+ JpaToscaServiceTemplate dataTypeEntityTreeServiceTemplate = getCascadedDataTypes(dbServiceTemplate,
+ referencedDataTypeKey.getName(), referencedDataTypeKey.getVersion());
- dataTypeServiceTemplate = ToscaServiceTemplateUtils.addFragment(dataTypeServiceTemplate,
- dataTypeEntityTreeServiceTemplate);
+ dataTypeServiceTemplate =
+ ToscaServiceTemplateUtils.addFragment(dataTypeServiceTemplate, dataTypeEntityTreeServiceTemplate);
}
}
serviceTemplate = ToscaServiceTemplateUtils.addFragment(serviceTemplate, dataTypeServiceTemplate);
-
- LOGGER.debug("<-getPolicyTypes: name={}, version={}, serviceTemplate={}", name, version, serviceTemplate);
return serviceTemplate;
}
* @throws PfModelException on errors creating policy types
*/
public JpaToscaServiceTemplate createPolicyTypes(@NonNull final PfDao dao,
- @NonNull final JpaToscaServiceTemplate incomingServiceTemplate) throws PfModelException {
+ @NonNull final JpaToscaServiceTemplate incomingServiceTemplate) throws PfModelException {
LOGGER.debug("->createPolicyTypes: serviceTempalate={}", incomingServiceTemplate);
ToscaUtils.assertPolicyTypesExist(incomingServiceTemplate);
JpaToscaServiceTemplate writtenServiceTemplate = appendToServiceTemplate(dao, incomingServiceTemplate);
- LOGGER.debug("<-createPolicyTypes: returnServiceTempalate={}", writtenServiceTemplate);
- return writtenServiceTemplate;
+ LOGGER.debug("<-createPolicyTypes: writtenServiceTemplate={}", writtenServiceTemplate);
+ return incomingServiceTemplate;
}
/**
* @throws PfModelException on errors updating policy types
*/
public JpaToscaServiceTemplate updatePolicyTypes(@NonNull final PfDao dao,
- @NonNull final JpaToscaServiceTemplate serviceTemplate) throws PfModelException {
+ @NonNull final JpaToscaServiceTemplate serviceTemplate) throws PfModelException {
LOGGER.debug("->updatePolicyTypes: serviceTempalate={}", serviceTemplate);
ToscaUtils.assertPolicyTypesExist(serviceTemplate);
}
// Return the created policy types
- JpaToscaPolicyTypes returnPolicyTypes = new JpaToscaPolicyTypes();
+ var returnPolicyTypes = new JpaToscaPolicyTypes();
for (PfConceptKey policyTypeKey : serviceTemplate.getPolicyTypes().getConceptMap().keySet()) {
returnPolicyTypes.getConceptMap().put(policyTypeKey, dao.get(JpaToscaPolicyType.class, policyTypeKey));
}
- JpaToscaServiceTemplate returnServiceTemplate = new JpaToscaServiceTemplate();
+ var returnServiceTemplate = new JpaToscaServiceTemplate();
returnServiceTemplate.setPolicyTypes(returnPolicyTypes);
LOGGER.debug("<-updatePolicyTypes: returnServiceTempalate={}", returnServiceTemplate);
* @throws PfModelException on errors deleting policy types
*/
public JpaToscaServiceTemplate deletePolicyType(@NonNull final PfDao dao, @NonNull final PfConceptKey policyTypeKey)
- throws PfModelException {
+ throws PfModelException {
LOGGER.debug("->deletePolicyType: key={}", policyTypeKey);
JpaToscaServiceTemplate serviceTemplate = getServiceTemplate(dao);
throw new PfModelRuntimeException(Response.Status.NOT_FOUND, "no policy types found");
}
- JpaToscaEntityType<? extends ToscaEntity> policyType4Deletion =
- serviceTemplate.getPolicyTypes().get(policyTypeKey);
+ JpaToscaPolicyType policyType4Deletion = serviceTemplate.getPolicyTypes().get(policyTypeKey);
if (policyType4Deletion == null) {
throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
- POLICY_TYPE + policyTypeKey.getId() + NOT_FOUND);
+ POLICY_TYPE + policyTypeKey.getId() + NOT_FOUND);
}
+ var result = new BeanValidationResult("policy types", serviceTemplate);
+
for (JpaToscaPolicyType policyType : serviceTemplate.getPolicyTypes().getAll(null)) {
Collection<JpaToscaEntityType<ToscaEntity>> ancestorList = ToscaUtils
- .getEntityTypeAncestors(serviceTemplate.getPolicyTypes(), policyType, new PfValidationResult());
+ .getEntityTypeAncestors(serviceTemplate.getPolicyTypes(), policyType, result);
if (ancestorList.contains(policyType4Deletion)) {
throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE, POLICY_TYPE + policyTypeKey.getId()
- + " is in use, it is referenced in policy type " + policyType.getId());
+ + " is in use, it is referenced in policy type " + policyType.getId());
}
}
for (JpaToscaPolicy policy : serviceTemplate.getTopologyTemplate().getPolicies().getAll(null)) {
if (policyTypeKey.equals(policy.getType())) {
throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE, POLICY_TYPE
- + policyTypeKey.getId() + " is in use, it is referenced in policy " + policy.getId());
+ + policyTypeKey.getId() + " is in use, it is referenced in policy " + policy.getId());
}
}
}
- dao.delete(JpaToscaPolicyType.class, policyTypeKey);
+ serviceTemplate.getPolicyTypes().getConceptMap().remove(policyTypeKey);
+ new SimpleToscaServiceTemplateProvider().write(dao, serviceTemplate);
+ dao.delete(policyType4Deletion);
- LOGGER.debug("<-deletePolicyType: key={}, serviceTempalate={}", policyTypeKey, serviceTemplate);
- return serviceTemplate;
+ var deletedServiceTemplate = new JpaToscaServiceTemplate();
+ deletedServiceTemplate.setPolicyTypes(new JpaToscaPolicyTypes());
+ deletedServiceTemplate.getPolicyTypes().getConceptMap().put(policyTypeKey, policyType4Deletion);
+
+ LOGGER.debug("<-deletePolicyType: key={}, serviceTemplate={}", policyTypeKey, deletedServiceTemplate);
+ return deletedServiceTemplate;
}
/**
* @throws PfModelException on errors getting policies
*/
public JpaToscaServiceTemplate getPolicies(@NonNull final PfDao dao, final String name, final String version)
- throws PfModelException {
+ throws PfModelException {
LOGGER.debug("->getPolicies: name={}, version={}", name, version);
JpaToscaServiceTemplate dbServiceTemplate = getServiceTemplate(dao);
- JpaToscaServiceTemplate serviceTemplate = new JpaToscaServiceTemplate(dbServiceTemplate);
- serviceTemplate.setDataTypes(new JpaToscaDataTypes());
- serviceTemplate.setPolicyTypes(new JpaToscaPolicyTypes());
-
- if (!ToscaUtils.doPoliciesExist(serviceTemplate)) {
+ if (!ToscaUtils.doPoliciesExist(dbServiceTemplate)) {
throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
- "policies for " + name + ":" + version + DO_NOT_EXIST);
+ "policies for " + name + ":" + version + DO_NOT_EXIST);
}
+ JpaToscaServiceTemplate returnServiceTemplate = getCascadedPolicies(dbServiceTemplate, name, version);
+
+ LOGGER.debug("<-getPolicies: name={}, version={}, serviceTemplate={}", name, version, returnServiceTemplate);
+ return returnServiceTemplate;
+ }
+
+ /**
+ * Get the cascaded policies for a policy name and version.
+ *
+ * @param dbServiceTemplate the service template to search for the cascaded policy
+ * @param name the policy name we are searching for
+ * @param version the policy version we are searching for
+ * @return a service template containing the cascaded policy
+ * @throws PfModelException on errors getting the policy
+ */
+ public JpaToscaServiceTemplate getCascadedPolicies(final JpaToscaServiceTemplate dbServiceTemplate,
+ final String name, final String version) throws PfModelException {
+
+ var serviceTemplate = new JpaToscaServiceTemplate(dbServiceTemplate);
+ serviceTemplate.setDataTypes(new JpaToscaDataTypes());
+ serviceTemplate.setPolicyTypes(new JpaToscaPolicyTypes());
+
ToscaUtils.getEntityTree(serviceTemplate.getTopologyTemplate().getPolicies(), name, version);
if (!ToscaUtils.doPoliciesExist(serviceTemplate)) {
throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
- "policies for " + name + ":" + version + DO_NOT_EXIST);
+ "policies for " + name + ":" + version + DO_NOT_EXIST);
}
- JpaToscaServiceTemplate returnServiceTemplate = new JpaToscaServiceTemplate(serviceTemplate);
+ var returnServiceTemplate = new JpaToscaServiceTemplate(serviceTemplate);
returnServiceTemplate.getTopologyTemplate().setPolicies(new JpaToscaPolicies());
for (JpaToscaPolicy policy : serviceTemplate.getTopologyTemplate().getPolicies().getConceptMap().values()) {
JpaToscaServiceTemplate referencedEntitiesServiceTemplate =
- getPolicyTypes(dao, policy.getType().getName(), policy.getType().getVersion());
+ getCascadedPolicyTypes(dbServiceTemplate, policy.getType().getName(), policy.getType().getVersion());
returnServiceTemplate.getTopologyTemplate().getPolicies().getConceptMap().put(policy.getKey(), policy);
returnServiceTemplate =
- ToscaServiceTemplateUtils.addFragment(returnServiceTemplate, referencedEntitiesServiceTemplate);
+ ToscaServiceTemplateUtils.addFragment(returnServiceTemplate, referencedEntitiesServiceTemplate);
}
- LOGGER.debug("<-getPolicies: name={}, version={}, serviceTemplate={}", name, version, returnServiceTemplate);
return returnServiceTemplate;
}
* @throws PfModelException on errors creating policies
*/
public JpaToscaServiceTemplate createPolicies(@NonNull final PfDao dao,
- @NonNull final JpaToscaServiceTemplate incomingServiceTemplate) throws PfModelException {
+ @NonNull final JpaToscaServiceTemplate incomingServiceTemplate) throws PfModelException {
LOGGER.debug("->createPolicies: incomingServiceTemplate={}", incomingServiceTemplate);
ToscaUtils.assertPoliciesExist(incomingServiceTemplate);
JpaToscaServiceTemplate writtenServiceTemplate = appendToServiceTemplate(dao, incomingServiceTemplate);
- LOGGER.debug("<-createPolicies: serviceTemplate={}", writtenServiceTemplate);
- return writtenServiceTemplate;
+ LOGGER.debug("<-createPolicies: writtenServiceTemplate={}", writtenServiceTemplate);
+ return incomingServiceTemplate;
}
/**
* @throws PfModelException on errors updating policies
*/
public JpaToscaServiceTemplate updatePolicies(@NonNull final PfDao dao,
- @NonNull final JpaToscaServiceTemplate serviceTemplate) throws PfModelException {
+ @NonNull final JpaToscaServiceTemplate serviceTemplate) throws PfModelException {
LOGGER.debug("->updatePolicies: serviceTempalate={}", serviceTemplate);
ToscaUtils.assertPoliciesExist(serviceTemplate);
}
// Return the created policy types
- JpaToscaPolicies returnPolicies = new JpaToscaPolicies();
+ var returnPolicies = new JpaToscaPolicies();
returnPolicies.setKey(serviceTemplate.getTopologyTemplate().getPolicies().getKey());
for (PfConceptKey policyKey : serviceTemplate.getTopologyTemplate().getPolicies().getConceptMap().keySet()) {
* @throws PfModelException on errors deleting policies
*/
public JpaToscaServiceTemplate deletePolicy(@NonNull final PfDao dao, @NonNull final PfConceptKey policyKey)
- throws PfModelException {
+ throws PfModelException {
LOGGER.debug("->deletePolicy: key={}", policyKey);
JpaToscaServiceTemplate serviceTemplate = getServiceTemplate(dao);
throw new PfModelRuntimeException(Response.Status.NOT_FOUND, "policy " + policyKey.getId() + NOT_FOUND);
}
- dao.delete(JpaToscaPolicy.class, policyKey);
+ serviceTemplate.getTopologyTemplate().getPolicies().getConceptMap().remove(policyKey);
+ new SimpleToscaServiceTemplateProvider().write(dao, serviceTemplate);
+ dao.delete(policy4Deletion);
+
+ var deletedServiceTemplate = new JpaToscaServiceTemplate();
+ deletedServiceTemplate.setTopologyTemplate(new JpaToscaTopologyTemplate());
+ deletedServiceTemplate.getTopologyTemplate().setPolicies(new JpaToscaPolicies());
+ deletedServiceTemplate.getTopologyTemplate().getPolicies().getConceptMap().put(policyKey, policy4Deletion);
+
+ LOGGER.debug("<-deletePolicy: key={}, serviceTempalate={}", policyKey, deletedServiceTemplate);
+ return deletedServiceTemplate;
+ }
+
+
+ /**
+ * Get metadata of tosca node templates.
+ *
+ * @param dao the DAO to use to access the database
+ * @param name the name of the nodeTemplate to get, set to null to get all node templates
+ * @param version the version of the metadataSet to get, set to null to get all versions
+ * @return the list of maps with node template key and metadata values found
+ * @throws PfModelException on errors getting metadataSets
+ */
+ public List<Map<ToscaEntityKey, Map<String, Object>>> getNodeTemplateMetadata(
+ @NonNull final PfDao dao, final String name, final String version)
+ throws PfModelException {
+ LOGGER.debug("->getNodeTemplateMetadataSet: name={}, version={}", name, version);
+
+ List<Map<ToscaEntityKey, Map<String, Object>>> metadataSets = new ArrayList<>();
+
+ JpaToscaServiceTemplate dbServiceTemplate = getServiceTemplate(dao);
+
+ //Return empty list if no node templates present in db
+ if (!ToscaUtils.doNodeTemplatesExist(dbServiceTemplate)) {
+ return metadataSets;
+ }
+ var returnServiceTemplate = new JpaToscaServiceTemplate(dbServiceTemplate);
+ List<ToscaNodeTemplate> toscaNodeTemplates = new ArrayList<>();
+ returnServiceTemplate.getTopologyTemplate()
+ .getNodeTemplates().getConceptMap().forEach((key, value) -> toscaNodeTemplates.add(value
+ .toAuthorative()));
+
+ //Filter metadataSet for specific node template
+ if (name != null && version != null) {
+ var filterKey = new ToscaEntityKey(name, version);
+ toscaNodeTemplates.removeIf(entity -> !entity.getKey().equals(filterKey));
+ }
+ toscaNodeTemplates.forEach(e -> metadataSets.add(Map.of(e.getKey(), e.getMetadata())));
+ LOGGER.debug("<-getNodeTemplateMetadataSet: name={}, version={}, metadataSets={}", name, version,
+ metadataSets);
+
+ return metadataSets;
+ }
+
+ /**
+ * Get tosca node templates.
+ *
+ * @param dao the DAO to use to access the database
+ * @param name the name of the node template to get, set to null to get all node templates
+ * @param version the version of the node template to get, set to null to get all versions
+ * @return the node templates with the specified key
+ * @throws PfModelException on errors getting node templates
+ */
+ public JpaToscaNodeTemplates getToscaNodeTemplates(@NonNull final PfDao dao, final String name,
+ final String version)
+ throws PfModelException {
+ LOGGER.debug("->getNodeTemplate: name={}, version={}", name, version);
+
+ var nodeTemplates = new JpaToscaNodeTemplates();
+
+ JpaToscaServiceTemplate dbServiceTemplate = getServiceTemplate(dao);
+
+ //Return empty if no nodeTemplates present in db
+ if (!ToscaUtils.doNodeTemplatesExist(dbServiceTemplate)) {
+ return nodeTemplates;
+ }
+ var returnServiceTemplate = new JpaToscaServiceTemplate(dbServiceTemplate);
+ nodeTemplates = returnServiceTemplate.getTopologyTemplate().getNodeTemplates();
+
+ //Filter specific nodeTemplates
+ if (name != null && version != null) {
+ var filterKey = new PfConceptKey(name, version);
+ nodeTemplates.getConceptMap().entrySet().removeIf(entity -> !entity.getKey().equals(filterKey));
+ }
+ LOGGER.debug("<-getNodeTemplateMetadataSet: name={}, version={}, nodeTemplates={}", name, version,
+ nodeTemplates);
+
+ return nodeTemplates;
+ }
+
+
+ /**
+ * Update tosca node template.
+ *
+ * @param dao the DAO to use to access the database
+ * @param serviceTemplate the service template containing the definitions of the node templates to be updated.
+ * @return the TOSCA service template containing the node templates that were updated
+ * @throws PfModelRuntimeException on errors updating node templates
+ */
+ public JpaToscaServiceTemplate updateToscaNodeTemplates(@NonNull final PfDao dao,
+ @NonNull final JpaToscaServiceTemplate serviceTemplate)
+ throws PfModelException {
+ LOGGER.debug("->updateToscaNodeTemplates: serviceTemplate={}", serviceTemplate);
+
+ ToscaUtils.assertNodeTemplatesExist(serviceTemplate);
+ for (JpaToscaNodeTemplate nodeTemplate : serviceTemplate.getTopologyTemplate().getNodeTemplates()
+ .getAll(null)) {
+
+ //verify if the node template is referenced in the metadata of created policies
+ assertNodeTemplateNotUsedInPolicy(dao, nodeTemplate.getName(), nodeTemplate.getVersion());
+ verifyNodeTypeInDbTemplate(dao, nodeTemplate);
+
+ dao.update(nodeTemplate);
+ }
+ // Return the service template with updated node templates
+ var updatedNodeTemplates = new JpaToscaNodeTemplates();
+ updatedNodeTemplates.setKey(serviceTemplate.getTopologyTemplate().getNodeTemplates().getKey());
+
+ for (PfConceptKey metadataSetKey : serviceTemplate.getTopologyTemplate().getNodeTemplates().getConceptMap()
+ .keySet()) {
+ updatedNodeTemplates.getConceptMap().put(metadataSetKey, dao.get(JpaToscaNodeTemplate.class,
+ metadataSetKey));
+ }
+ serviceTemplate.getTopologyTemplate().setNodeTemplates(updatedNodeTemplates);
+
+ LOGGER.debug("<-updatedToscaNodeTemplates: serviceTemplate={}", serviceTemplate);
+ return serviceTemplate;
+ }
+
+ /**
+ * Delete a tosca node template.
+ *
+ * @param dao the DAO to use to access the database
+ * @param nodeTemplateKey the node template key
+ * @return the TOSCA service template containing the node templates that were deleted
+ * @throws PfModelException on errors deleting node templates
+ */
+ public JpaToscaServiceTemplate deleteToscaNodeTemplate(@NonNull final PfDao dao,
+ @NonNull final PfConceptKey nodeTemplateKey)
+ throws PfModelException {
+ LOGGER.debug("->deleteToscaNodeTemplate: key={}", nodeTemplateKey);
+
+ JpaToscaServiceTemplate dbServiceTemplate = getServiceTemplate(dao);
+
+ if (!ToscaUtils.doNodeTemplatesExist(dbServiceTemplate)) {
+ throw new PfModelRuntimeException(Response.Status.NOT_FOUND, "no node templates found");
+ }
+ JpaToscaNodeTemplate nodeTemplate4Deletion = dbServiceTemplate.getTopologyTemplate().getNodeTemplates()
+ .get(nodeTemplateKey);
+ if (nodeTemplate4Deletion == null) {
+ throw new PfModelRuntimeException(Response.Status.NOT_FOUND, "node template " + nodeTemplateKey.getId()
+ + NOT_FOUND);
+ }
+
+ //Verify if the node template is referenced in the metadata of created policies
+ assertNodeTemplateNotUsedInPolicy(dao, nodeTemplateKey.getName(), nodeTemplateKey.getVersion());
+
+ dbServiceTemplate.getTopologyTemplate().getNodeTemplates().getConceptMap().remove(nodeTemplateKey);
+ new SimpleToscaServiceTemplateProvider().write(dao, dbServiceTemplate);
+ dao.delete(nodeTemplate4Deletion);
+
+ var deletedServiceTemplate = new JpaToscaServiceTemplate();
+ deletedServiceTemplate.setTopologyTemplate(new JpaToscaTopologyTemplate());
+ deletedServiceTemplate.getTopologyTemplate().setNodeTemplates(new JpaToscaNodeTemplates());
+ deletedServiceTemplate.getTopologyTemplate().getNodeTemplates().getConceptMap()
+ .put(nodeTemplateKey, nodeTemplate4Deletion);
+
+ LOGGER.debug("<-deleteToscaNodeTemplate: key={}, serviceTemplate={}", nodeTemplateKey, deletedServiceTemplate);
+ return deletedServiceTemplate;
+ }
+
+ /**
+ * Write a node template to the database.
+ *
+ * @param dao the DAO to use to access the database
+ * @param serviceTemplate the service template to be written
+ * @return the service template created by this method
+ * @throws PfModelException on errors writing the metadataSets
+ */
+ public JpaToscaServiceTemplate createToscaNodeTemplates(@NonNull final PfDao dao,
+ @NonNull final JpaToscaServiceTemplate serviceTemplate)
+ throws PfModelException {
+
+ LOGGER.debug("->write: tosca nodeTemplates={}", serviceTemplate);
+
+ ToscaUtils.assertNodeTemplatesExist(serviceTemplate);
+
+ Optional<JpaToscaNodeTypes> nodeTypes = Optional.ofNullable(serviceTemplate.getNodeTypes());
+ for (JpaToscaNodeTemplate nodeTemplate : serviceTemplate.getTopologyTemplate().getNodeTemplates()
+ .getAll(null)) {
+
+ // verify node types in the db if mismatch/empty entities in the template
+ if (! (nodeTypes.isPresent() && nodeTypes.get().getKeys().contains(nodeTemplate.getType()))) {
+ verifyNodeTypeInDbTemplate(dao, nodeTemplate);
+ }
+ }
+ JpaToscaServiceTemplate writtenServiceTemplate = appendToServiceTemplate(dao, serviceTemplate);
+ LOGGER.debug("<-createdToscaNodeTemplates: writtenServiceTemplate={}", writtenServiceTemplate);
- LOGGER.debug("<-deletePolicy: key={}, serviceTempalate={}", policyKey, serviceTemplate);
return serviceTemplate;
}
if (policyType == null) {
String errorMessage =
- POLICY_TYPE + policyTypeKey.getId() + " for policy " + policy.getId() + " does not exist";
+ POLICY_TYPE + policyTypeKey.getId() + " for policy " + policy.getId() + " does not exist";
throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE, errorMessage);
}
}
+ /**
+ * Verify the node type for a toscaNodeTemplate metadataSet.
+ *
+ * @param dao the DAO to use to access toscaNodeTemplate types in the database
+ * @param toscaNodeTemplate the toscaNodeTemplate to check the toscaNodeTemplate type for
+ */
+ private void verifyNodeTypeInDbTemplate(final PfDao dao, final JpaToscaNodeTemplate toscaNodeTemplate) throws
+ PfModelException {
+ PfConceptKey nodeTypeKey = toscaNodeTemplate.getType();
+
+ JpaToscaNodeType nodeType = null;
+
+ nodeType = dao.get(JpaToscaNodeType.class, nodeTypeKey);
+
+ if (nodeType == null) {
+ String errorMessage =
+ "NODE_TYPE " + nodeTypeKey + " for toscaNodeTemplate " + toscaNodeTemplate.getId()
+ + " does not exist";
+ throw new PfModelException(Response.Status.NOT_ACCEPTABLE, errorMessage);
+ }
+ }
+
/**
* Get the latest version of the policy type for the given policy type name.
*
}
// Create a filter to get the latest version of the policy type
- PfConceptFilter pfConceptFilter = PfConceptFilter.builder().version(PfConceptFilter.LATEST_VERSION).build();
+ var pfConceptFilter = PfConceptFilter.builder().version(PfConceptFilter.LATEST_VERSION).build();
// FIlter the returned policy type list
List<PfConcept> policyTypeKeyList = new ArrayList<>(jpaPolicyTypeList);
return (JpaToscaPolicyType) filterdPolicyTypeList.get(0);
}
+
+ /**
+ * Assert that the node template is not referenced in any Tosca policy.
+ *
+ * @param name the name of node template
+ * @param version the version of node template
+ * @throws PfModelException if node template referenced in a policy
+ */
+ private void assertNodeTemplateNotUsedInPolicy(PfDao dao, String name, String version)
+ throws PfModelException {
+ JpaToscaServiceTemplate dbTemplate;
+ try {
+ //Retrieve all the policies from db, return if policies doesn't exist
+ dbTemplate = getPolicies(dao, null, null);
+ } catch (PfModelRuntimeException e) {
+ LOGGER.debug("Could not verify the node template reference in created policies ", e);
+ return;
+ }
+ for (JpaToscaPolicy policy : dbTemplate.getTopologyTemplate().getPolicies().getConceptMap().values()) {
+ if (policy.getMetadata().getOrDefault("metadataSetName", "").equals(name)
+ && policy.getMetadata().getOrDefault("metadataSetVersion", "").equals(version)) {
+ throw new PfModelException(Response.Status.NOT_ACCEPTABLE,
+ "Node template is in use, it is referenced in Tosca Policy " + policy.getName() + " version "
+ + policy.getVersion());
+ }
+ }
+ }
}