X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=models-tosca%2Fsrc%2Fmain%2Fjava%2Forg%2Fonap%2Fpolicy%2Fmodels%2Ftosca%2Fsimple%2Fprovider%2FSimpleToscaProvider.java;h=9c7d6d305c9a430ed73db42f7d11ced112bd8ab1;hb=88bcb550c2efd5e43ad3d256fe075a6bf7e90538;hp=761a47c9a24cdaa9e25af500ef02d3354e55f48d;hpb=d034de615965ca8214396e30c85191a5aa4aa37b;p=policy%2Fmodels.git diff --git a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/provider/SimpleToscaProvider.java b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/provider/SimpleToscaProvider.java index 761a47c9a..9c7d6d305 100644 --- a/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/provider/SimpleToscaProvider.java +++ b/models-tosca/src/main/java/org/onap/policy/models/tosca/simple/provider/SimpleToscaProvider.java @@ -1,6 +1,6 @@ /*- * ============LICENSE_START======================================================= - * Copyright (C) 2019 Nordix Foundation. + * Copyright (C) 2019-2020 Nordix Foundation. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -21,27 +21,30 @@ package org.onap.policy.models.tosca.simple.provider; import java.util.ArrayList; -import java.util.LinkedHashMap; +import java.util.Collection; import java.util.List; -import java.util.Map; import javax.ws.rs.core.Response; import lombok.NonNull; +import org.apache.commons.collections4.CollectionUtils; 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.simple.concepts.JpaToscaDataType; +import org.onap.policy.models.tosca.simple.concepts.JpaToscaDataTypes; 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; import org.slf4j.LoggerFactory; @@ -54,6 +57,183 @@ import org.slf4j.LoggerFactory; public class SimpleToscaProvider { private static final Logger LOGGER = LoggerFactory.getLogger(SimpleToscaProvider.class); + // Recurring string constants + private static final String SERVICE_TEMPLATE_NOT_FOUND_IN_DATABASE = "service template not found in database"; + private static final String DO_NOT_EXIST = " do not exist"; + + /** + * Get Service Template. + * + * @param dao the DAO to use to access the database + * @return the service template + * @throws PfModelException on errors getting the service template + */ + public JpaToscaServiceTemplate getServiceTemplate(@NonNull final PfDao dao) throws PfModelException { + LOGGER.debug("->getServiceTemplate"); + + JpaToscaServiceTemplate serviceTemplate = new SimpleToscaServiceTemplateProvider().read(dao); + if (serviceTemplate == null) { + throw new PfModelRuntimeException(Response.Status.NOT_FOUND, SERVICE_TEMPLATE_NOT_FOUND_IN_DATABASE); + } + + LOGGER.debug("<-getServiceTemplate: serviceTemplate={}", serviceTemplate); + return serviceTemplate; + } + + /** + * Append a service template fragment to the service template in the database. + * + * @param dao the DAO to use to access the database + * @param incomingServiceTemplateFragment the service template containing the definition of the entities to be + * created + * @return the TOSCA service template in the database after the operation + * @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 { + LOGGER.debug("->appendServiceTemplateFragment: incomingServiceTemplateFragment={}", + incomingServiceTemplateFragment); + + JpaToscaServiceTemplate dbServiceTemplate = new SimpleToscaServiceTemplateProvider().read(dao); + + JpaToscaServiceTemplate serviceTemplateToWrite; + if (dbServiceTemplate == null) { + serviceTemplateToWrite = incomingServiceTemplateFragment; + } else { + serviceTemplateToWrite = + ToscaServiceTemplateUtils.addFragment(dbServiceTemplate, incomingServiceTemplateFragment); + } + + PfValidationResult result = serviceTemplateToWrite.validate(new PfValidationResult()); + if (!result.isValid()) { + throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, result.toString()); + } + + new SimpleToscaServiceTemplateProvider().write(dao, serviceTemplateToWrite); + + LOGGER.debug("<-appendServiceTemplateFragment: returnServiceTempalate={}", serviceTemplateToWrite); + return serviceTemplateToWrite; + } + + /** + * Get data types. + * + * @param dao the DAO to use to access the database + * @param name the name of the data type to get, set to null to get all policy types + * @param version the version of the data type to get, set to null to get all versions + * @return the data types found + * @throws PfModelException on errors getting data types + */ + public JpaToscaServiceTemplate getDataTypes(@NonNull final PfDao dao, final String name, final String version) + throws PfModelException { + LOGGER.debug("->getDataTypes: name={}, version={}", name, version); + + JpaToscaServiceTemplate serviceTemplate = getServiceTemplate(dao); + + if (!ToscaUtils.doDataTypesExist(serviceTemplate)) { + throw new PfModelRuntimeException(Response.Status.NOT_FOUND, + "data types for " + name + ":" + version + DO_NOT_EXIST); + } + + serviceTemplate.setPolicyTypes(null); + serviceTemplate.setTopologyTemplate(null); + + ToscaUtils.getEntityTree(serviceTemplate.getDataTypes(), name, version); + + if (!ToscaUtils.doDataTypesExist(serviceTemplate)) { + throw new PfModelRuntimeException(Response.Status.NOT_FOUND, + "data types for " + name + ":" + version + DO_NOT_EXIST); + } + + for (JpaToscaDataType dataType : serviceTemplate.getDataTypes().getConceptMap().values()) { + Collection referencedDataTypeKeys = dataType.getReferencedDataTypes(); + + for (PfConceptKey referencedDataTypeKey : referencedDataTypeKeys) { + JpaToscaServiceTemplate dataTypeEntityTreeServiceTemplate = + getDataTypes(dao, referencedDataTypeKey.getName(), referencedDataTypeKey.getVersion()); + + serviceTemplate = + ToscaServiceTemplateUtils.addFragment(serviceTemplate, dataTypeEntityTreeServiceTemplate); + } + } + + LOGGER.debug("<-getDataTypes: name={}, version={}, serviceTemplate={}", name, version, serviceTemplate); + return serviceTemplate; + } + + /** + * Create data types. + * + * @param dao the DAO to use to access the database + * @param incomingServiceTemplate the service template containing the definition of the data types to be created + * @return the TOSCA service template containing the created data types + * @throws PfModelException on errors creating data types + */ + public JpaToscaServiceTemplate createDataTypes(@NonNull final PfDao dao, + @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; + } + + /** + * Update Data types. + * + * @param dao the DAO to use to access the database + * @param serviceTemplate the service template containing the definition of the data types to be modified + * @return the TOSCA service template containing the modified data types + * @throws PfModelException on errors updating Data types + */ + public JpaToscaServiceTemplate updateDataTypes(@NonNull final PfDao dao, + @NonNull final JpaToscaServiceTemplate serviceTemplate) throws PfModelException { + LOGGER.debug("->updateDataTypes: serviceTempalate={}", serviceTemplate); + + ToscaUtils.assertDataTypesExist(serviceTemplate); + + for (JpaToscaDataType dataType : serviceTemplate.getDataTypes().getAll(null)) { + dao.update(dataType); + } + + // Return the created data types + JpaToscaDataTypes returnDataTypes = new JpaToscaDataTypes(); + + for (PfConceptKey dataTypeKey : serviceTemplate.getDataTypes().getConceptMap().keySet()) { + returnDataTypes.getConceptMap().put(dataTypeKey, dao.get(JpaToscaDataType.class, dataTypeKey)); + } + + JpaToscaServiceTemplate returnServiceTemplate = new JpaToscaServiceTemplate(); + returnServiceTemplate.setDataTypes(returnDataTypes); + + LOGGER.debug("<-updateDataTypes: returnServiceTempalate={}", returnServiceTemplate); + return returnServiceTemplate; + } + + /** + * Delete Data types. + * + * @param dao the DAO to use to access the database + * @param dataTypeKey the data type key for the Data types to be deleted, if the version of the key is null, all + * versions of the data type are deleted. + * @return the TOSCA service template containing the data types that were deleted + * @throws PfModelException on errors deleting data types + */ + public JpaToscaServiceTemplate deleteDataType(@NonNull final PfDao dao, @NonNull final PfConceptKey dataTypeKey) + throws PfModelException { + LOGGER.debug("->deleteDataType: key={}", dataTypeKey); + + JpaToscaServiceTemplate serviceTemplate = getDataTypes(dao, dataTypeKey.getName(), dataTypeKey.getVersion()); + + dao.delete(JpaToscaDataType.class, dataTypeKey); + + LOGGER.debug("<-deleteDataType: key={}, serviceTempalate={}", dataTypeKey, serviceTemplate); + return serviceTemplate; + } + /** * Get policy types. * @@ -65,15 +245,38 @@ public class SimpleToscaProvider { */ public JpaToscaServiceTemplate getPolicyTypes(@NonNull final PfDao dao, final String name, final String version) throws PfModelException { + LOGGER.debug("->getPolicyTypes: name={}, version={}", name, version); + + JpaToscaServiceTemplate serviceTemplate = getServiceTemplate(dao); + + serviceTemplate.setDataTypes(null); + serviceTemplate.setTopologyTemplate(null); + + if (!ToscaUtils.doPolicyTypesExist(serviceTemplate)) { + throw new PfModelRuntimeException(Response.Status.NOT_FOUND, + "policy types for " + name + ":" + version + DO_NOT_EXIST); + } + + 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); + } - // Create the structure of the TOSCA service template to contain the policy type - JpaToscaServiceTemplate serviceTemplate = new JpaToscaServiceTemplate(); - serviceTemplate.setPolicyTypes(new JpaToscaPolicyTypes()); + for (JpaToscaPolicyType policyType : serviceTemplate.getPolicyTypes().getConceptMap().values()) { + Collection referencedDataTypeKeys = policyType.getReferencedDataTypes(); - // Add the policy type to the TOSCA service template - List jpaPolicyTypeList = dao.getFiltered(JpaToscaPolicyType.class, name, version); - serviceTemplate.getPolicyTypes().getConceptMap().putAll(asConceptMap(jpaPolicyTypeList)); + for (PfConceptKey referencedDataTypeKey : referencedDataTypeKeys) { + JpaToscaServiceTemplate dataTypeEntityTreeServiceTemplate = + getDataTypes(dao, referencedDataTypeKey.getName(), referencedDataTypeKey.getVersion()); + serviceTemplate = + ToscaServiceTemplateUtils.addFragment(serviceTemplate, dataTypeEntityTreeServiceTemplate); + } + } + + LOGGER.debug("<-getPolicyTypes: name={}, version={}, serviceTemplate={}", name, version, serviceTemplate); return serviceTemplate; } @@ -81,34 +284,24 @@ public class SimpleToscaProvider { * Create policy types. * * @param dao the DAO to use to access the database - * @param serviceTemplate the service template containing the definition of the policy types to be created + * @param incomingServiceTemplate the service template containing the definition of the policy types to be created * @return the TOSCA service template containing the created policy types * @throws PfModelException on errors creating policy types */ public JpaToscaServiceTemplate createPolicyTypes(@NonNull final PfDao dao, - @NonNull final JpaToscaServiceTemplate serviceTemplate) throws PfModelException { - - ToscaUtils.assertPolicyTypesExist(serviceTemplate); - - for (JpaToscaPolicyType policyType : serviceTemplate.getPolicyTypes().getAll(null)) { - dao.create(policyType); - } - - // Return the created policy types - JpaToscaPolicyTypes returnPolicyTypes = new JpaToscaPolicyTypes(); + @NonNull final JpaToscaServiceTemplate incomingServiceTemplate) throws PfModelException { + LOGGER.debug("->createPolicyTypes: serviceTempalate={}", incomingServiceTemplate); - for (PfConceptKey policyTypeKey : serviceTemplate.getPolicyTypes().getConceptMap().keySet()) { - returnPolicyTypes.getConceptMap().put(policyTypeKey, dao.get(JpaToscaPolicyType.class, policyTypeKey)); - } + ToscaUtils.assertPolicyTypesExist(incomingServiceTemplate); - JpaToscaServiceTemplate returnServiceTemplate = new JpaToscaServiceTemplate(); - returnServiceTemplate.setPolicyTypes(returnPolicyTypes); + JpaToscaServiceTemplate writtenServiceTemplate = appendToServiceTemplate(dao, incomingServiceTemplate); - return returnServiceTemplate; + LOGGER.debug("<-createPolicyTypes: returnServiceTempalate={}", writtenServiceTemplate); + return writtenServiceTemplate; } /** - * Create policy types. + * Update policy types. * * @param dao the DAO to use to access the database * @param serviceTemplate the service template containing the definition of the policy types to be modified @@ -117,9 +310,15 @@ public class SimpleToscaProvider { */ public JpaToscaServiceTemplate updatePolicyTypes(@NonNull final PfDao dao, @NonNull final JpaToscaServiceTemplate serviceTemplate) throws PfModelException { + LOGGER.debug("->updatePolicyTypes: serviceTempalate={}", serviceTemplate); ToscaUtils.assertPolicyTypesExist(serviceTemplate); + // Update the data types on the policy type + if (ToscaUtils.doDataTypesExist(serviceTemplate)) { + updateDataTypes(dao, serviceTemplate); + } + for (JpaToscaPolicyType policyType : serviceTemplate.getPolicyTypes().getAll(null)) { dao.update(policyType); } @@ -134,6 +333,7 @@ public class SimpleToscaProvider { JpaToscaServiceTemplate returnServiceTemplate = new JpaToscaServiceTemplate(); returnServiceTemplate.setPolicyTypes(returnPolicyTypes); + LOGGER.debug("<-updatePolicyTypes: returnServiceTempalate={}", returnServiceTemplate); return returnServiceTemplate; } @@ -148,12 +348,14 @@ public class SimpleToscaProvider { */ public JpaToscaServiceTemplate deletePolicyType(@NonNull final PfDao dao, @NonNull final PfConceptKey policyTypeKey) throws PfModelException { + LOGGER.debug("->deletePolicyType: key={}", policyTypeKey); JpaToscaServiceTemplate serviceTemplate = getPolicyTypes(dao, policyTypeKey.getName(), policyTypeKey.getVersion()); dao.delete(JpaToscaPolicyType.class, policyTypeKey); + LOGGER.debug("<-deletePolicyType: key={}, serviceTempalate={}", policyTypeKey, serviceTemplate); return serviceTemplate; } @@ -168,15 +370,33 @@ public class SimpleToscaProvider { */ public JpaToscaServiceTemplate getPolicies(@NonNull final PfDao dao, final String name, final String version) throws PfModelException { + LOGGER.debug("->getPolicies: name={}, version={}", name, version); + + JpaToscaServiceTemplate serviceTemplate = getServiceTemplate(dao); + + if (!ToscaUtils.doPoliciesExist(serviceTemplate)) { + throw new PfModelRuntimeException(Response.Status.NOT_FOUND, + "policies for " + name + ":" + version + DO_NOT_EXIST); + } + + 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); + } + + for (JpaToscaPolicy policy : serviceTemplate.getTopologyTemplate().getPolicies().getConceptMap().values()) { + if (policy.getDerivedFrom() != null) { + JpaToscaServiceTemplate referencedEntitiesServiceTemplate = + getPolicyTypes(dao, policy.getDerivedFrom().getName(), policy.getDerivedFrom().getVersion()); - // Create the structure of the TOSCA service template to contain the policy type - JpaToscaServiceTemplate serviceTemplate = new JpaToscaServiceTemplate(); - serviceTemplate.setTopologyTemplate(new JpaToscaTopologyTemplate()); - serviceTemplate.getTopologyTemplate().setPolicies(new JpaToscaPolicies()); + serviceTemplate = + ToscaServiceTemplateUtils.addFragment(serviceTemplate, referencedEntitiesServiceTemplate); + } + } - // Add the policy type to the TOSCA service template - List jpaPolicyList = dao.getFiltered(JpaToscaPolicy.class, name, version); - serviceTemplate.getTopologyTemplate().getPolicies().getConceptMap().putAll(asConceptMap(jpaPolicyList)); + LOGGER.debug("<-getPolicies: name={}, version={}, serviceTemplate={}", name, version, serviceTemplate); return serviceTemplate; } @@ -184,31 +404,20 @@ public class SimpleToscaProvider { * Create policies. * * @param dao the DAO to use to access the database - * @param serviceTemplate the service template containing the definitions of the new policies to be created. + * @param incomingServiceTemplate the service template containing the definitions of the new policies to be created. * @return the TOSCA service template containing the policy types that were created * @throws PfModelException on errors creating policies */ public JpaToscaServiceTemplate createPolicies(@NonNull final PfDao dao, - @NonNull final JpaToscaServiceTemplate serviceTemplate) throws PfModelException { + @NonNull final JpaToscaServiceTemplate incomingServiceTemplate) throws PfModelException { + LOGGER.debug("->createPolicies: incomingServiceTemplate={}", incomingServiceTemplate); - ToscaUtils.assertPoliciesExist(serviceTemplate); + ToscaUtils.assertPoliciesExist(incomingServiceTemplate); - for (JpaToscaPolicy policy : serviceTemplate.getTopologyTemplate().getPolicies().getAll(null)) { - verifyPolicyTypeForPolicy(dao, policy); - dao.create(policy); - } + JpaToscaServiceTemplate writtenServiceTemplate = appendToServiceTemplate(dao, incomingServiceTemplate); - // Return the created policy types - JpaToscaPolicies returnPolicies = new JpaToscaPolicies(); - returnPolicies.setKey(serviceTemplate.getTopologyTemplate().getPolicies().getKey()); - - for (PfConceptKey policyKey : serviceTemplate.getTopologyTemplate().getPolicies().getConceptMap().keySet()) { - returnPolicies.getConceptMap().put(policyKey, dao.get(JpaToscaPolicy.class, policyKey)); - } - - serviceTemplate.getTopologyTemplate().setPolicies(returnPolicies); - - return serviceTemplate; + LOGGER.debug("<-createPolicies: serviceTemplate={}", writtenServiceTemplate); + return writtenServiceTemplate; } /** @@ -221,6 +430,7 @@ public class SimpleToscaProvider { */ public JpaToscaServiceTemplate updatePolicies(@NonNull final PfDao dao, @NonNull final JpaToscaServiceTemplate serviceTemplate) throws PfModelException { + LOGGER.debug("->updatePolicies: serviceTempalate={}", serviceTemplate); ToscaUtils.assertPoliciesExist(serviceTemplate); @@ -239,6 +449,7 @@ public class SimpleToscaProvider { serviceTemplate.getTopologyTemplate().setPolicies(returnPolicies); + LOGGER.debug("<-updatePolicies: serviceTemplate={}", serviceTemplate); return serviceTemplate; } @@ -252,29 +463,16 @@ public class SimpleToscaProvider { */ public JpaToscaServiceTemplate deletePolicy(@NonNull final PfDao dao, @NonNull final PfConceptKey policyKey) throws PfModelException { + LOGGER.debug("->deletePolicy: key={}", policyKey); JpaToscaServiceTemplate serviceTemplate = getPolicies(dao, policyKey.getName(), policyKey.getVersion()); dao.delete(JpaToscaPolicy.class, policyKey); + LOGGER.debug("<-deletePolicy: key={}, serviceTempalate={}", policyKey, serviceTemplate); return serviceTemplate; } - /** - * Convert a list of concepts to a map of concepts. - * - * @param conceptList the concept list - * @return the concept map - */ - private Map asConceptMap(List conceptList) { - Map conceptMap = new LinkedHashMap<>(); - for (T concept : conceptList) { - conceptMap.put((PfConceptKey) concept.getKey(), concept); - } - - return conceptMap; - } - /** * Verify the policy type for a policy exists. * @@ -288,7 +486,10 @@ public class SimpleToscaProvider { if (PfKey.NULL_KEY_VERSION.equals(policyTypeKey.getVersion())) { policyType = getLatestPolicyTypeVersion(dao, policyTypeKey.getName()); - policy.getType().setVersion(policyType.getKey().getVersion()); + + if (policyType != null) { + policy.getType().setVersion(policyType.getKey().getVersion()); + } } else { policyType = dao.get(JpaToscaPolicyType.class, policyTypeKey); } @@ -296,7 +497,6 @@ public class SimpleToscaProvider { if (policyType == null) { String errorMessage = "policy type " + policyTypeKey.getId() + " for policy " + policy.getId() + " does not exist"; - LOGGER.warn(errorMessage); throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, errorMessage); } } @@ -310,10 +510,9 @@ public class SimpleToscaProvider { */ private JpaToscaPolicyType getLatestPolicyTypeVersion(final PfDao dao, final String policyTypeName) { // Policy type version is not specified, get the latest version from the database - List jpaPolicyTypeList = - dao.getFiltered(JpaToscaPolicyType.class, policyTypeName, null); + List jpaPolicyTypeList = dao.getFiltered(JpaToscaPolicyType.class, policyTypeName, null); - if (jpaPolicyTypeList.isEmpty()) { + if (CollectionUtils.isEmpty(jpaPolicyTypeList)) { return null; } @@ -325,10 +524,8 @@ public class SimpleToscaProvider { List filterdPolicyTypeList = pfConceptFilter.filter(policyTypeKeyList); // We should have one and only one returned entry - if (filterdPolicyTypeList.size() != 1 ) { - String errorMessage = - "search for lates policy type " + policyTypeName + " returned more than one entry"; - LOGGER.warn(errorMessage); + if (filterdPolicyTypeList.size() != 1) { + String errorMessage = "search for latest policy type " + policyTypeName + " returned more than one entry"; throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, errorMessage); }