/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019 Nordix Foundation.
+ * Copyright (C) 2019-2020 Nordix Foundation.
+ * Modifications Copyright (C) 2019 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.
import java.util.ArrayList;
import java.util.Collections;
-import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
-
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
import lombok.NonNull;
-
+import org.apache.commons.collections4.CollectionUtils;
import org.onap.policy.models.base.PfConceptKey;
import org.onap.policy.models.base.PfModelException;
+import org.onap.policy.models.base.PfModelRuntimeException;
import org.onap.policy.models.dao.PfDao;
import org.onap.policy.models.tosca.authorative.concepts.ToscaEntity;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyTypeFilter;
import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplateFilter;
import org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate;
import org.onap.policy.models.tosca.simple.provider.SimpleToscaProvider;
+import org.onap.policy.models.tosca.utils.ToscaServiceTemplateUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* This class provides the provision of information on TOSCA concepts in the database to callers.
* @author Liam Fallon (liam.fallon@est.tech)
*/
public class AuthorativeToscaProvider {
+ private static final Logger LOGGER = LoggerFactory.getLogger(AuthorativeToscaProvider.class);
+
+ // TODO: In next release this locking mechanism should be removed and replaced with proper session handling
+ private static final Object providerLockObject = "providerLockObject";
+
+ /**
+ * Get service templates.
+ *
+ * @param dao the DAO to use to access the database
+ * @param name the name of the service template to get.
+ * @param version the version of the service template to get.
+ * @return the service templates found
+ * @throws PfModelException on errors getting service templates
+ */
+ public List<ToscaServiceTemplate> getServiceTemplateList(PfDao dao, String name, String version)
+ throws PfModelException {
+
+ synchronized (providerLockObject) {
+ LOGGER.debug("->getServiceTemplateList: name={}, version={}", name, version);
+
+ List<ToscaServiceTemplate> serviceTemplateList = new ArrayList<>();
+
+ try {
+ ToscaServiceTemplate serviceTemplate =
+ new SimpleToscaProvider().getServiceTemplate(dao).toAuthorative();
+ serviceTemplateList.add(serviceTemplate);
+ } catch (PfModelRuntimeException pfme) {
+ return handlePfModelRuntimeException(pfme);
+ }
+
+ LOGGER.debug("<-getServiceTemplateList: name={}, version={}, serviceTemplateList={}", name, version,
+ serviceTemplateList);
+ return serviceTemplateList;
+ }
+ }
+
+ /**
+ * Get filtered service templates.
+ *
+ * @param pfDao the DAO to use to access the database
+ * @param filter the filter for the service templates to get
+ * @return the service templates found
+ * @throws PfModelException on errors getting service templates
+ */
+ public List<ToscaServiceTemplate> getFilteredServiceTemplateList(PfDao pfDao,
+ @NonNull ToscaServiceTemplateFilter filter) throws PfModelException {
+
+ LOGGER.debug("->getFilteredServiceTemplateList: filter={}", filter);
+
+ List<ToscaServiceTemplate> filteredServiceTemplateList =
+ filter.filter(getServiceTemplateList(pfDao, null, null));
+
+ LOGGER.debug("<-getFilteredServiceTemplateList: filter={}, filteredServiceTemplateList={}", filter,
+ filteredServiceTemplateList);
+
+ return filteredServiceTemplateList;
+ }
+
+ /**
+ * Create a service template.
+ *
+ * @param dao the DAO to use to access the database
+ * @param serviceTemplate the service template to be created.
+ * @return the TOSCA service template that was created
+ * @throws PfModelException on errors creating the service template
+ */
+ public ToscaServiceTemplate createServiceTemplate(@NonNull final PfDao dao,
+ @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
+
+ synchronized (providerLockObject) {
+ LOGGER.debug("->createServiceTemplate: serviceTemplate={}", serviceTemplate);
+
+ ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
+ .appendToServiceTemplate(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
+
+ LOGGER.debug("<-createServiceTemplate: createdServiceTemplate={}", createdServiceTemplate);
+ return createdServiceTemplate;
+ }
+ }
+
+ /**
+ * Update a service template.
+ *
+ * @param dao the DAO to use to access the database
+ * @param serviceTemplate the service template to be updated.
+ * @return the TOSCA service template that was updated
+ * @throws PfModelException on errors updating the service template
+ */
+ public ToscaServiceTemplate updateServiceTemplate(@NonNull final PfDao dao,
+ @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
+
+ synchronized (providerLockObject) {
+ LOGGER.debug("->updateServiceTemplate: serviceTemplate={}", serviceTemplate);
+
+ ToscaServiceTemplate updatedServiceTemplate = new SimpleToscaProvider()
+ .appendToServiceTemplate(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
+
+ LOGGER.debug("<-updateServiceTemplate: updatedServiceTemplate={}", updatedServiceTemplate);
+ return updatedServiceTemplate;
+ }
+ }
+
+ /**
+ * Delete a service template.
+ *
+ * @param dao the DAO to use to access the database
+ * @param name the name of the service template to delete.
+ * @param version the version of the service template to delete.
+ * @return the TOSCA service template that was deleted
+ * @throws PfModelException on errors deleting the control loop
+ */
+ public ToscaServiceTemplate deleteServiceTemplate(@NonNull final PfDao dao, @NonNull final String name,
+ @NonNull final String version) throws PfModelException {
+
+ synchronized (providerLockObject) {
+ LOGGER.debug("->deleteServiceTemplate: name={}, version={}", name, version);
+
+ ToscaServiceTemplate deletedServiceTemplate =
+ new SimpleToscaProvider().deleteServiceTemplate(dao).toAuthorative();
+
+ LOGGER.debug("<-deleteServiceTemplate: name={}, version={}, deletedServiceTemplate={}", name, version,
+ deletedServiceTemplate);
+ return deletedServiceTemplate;
+ }
+ }
+
/**
* Get policy types.
*
public ToscaServiceTemplate getPolicyTypes(@NonNull final PfDao dao, final String name, final String version)
throws PfModelException {
- return new SimpleToscaProvider().getPolicyTypes(dao, name, version).toAuthorative();
+ synchronized (providerLockObject) {
+ LOGGER.debug("->getPolicyTypes: name={}, version={}", name, version);
+
+ JpaToscaServiceTemplate jpaServiceTemplate = new SimpleToscaProvider().getPolicyTypes(dao, name, version);
+
+ ToscaServiceTemplate serviceTemplate = jpaServiceTemplate.toAuthorative();
+
+ LOGGER.debug("<-getPolicyTypes: name={}, version={}, serviceTemplate={}", name, version, serviceTemplate);
+ return serviceTemplate;
+ }
}
/**
public List<ToscaPolicyType> getPolicyTypeList(@NonNull final PfDao dao, final String name, final String version)
throws PfModelException {
- return (asConceptList(
- new SimpleToscaProvider().getPolicyTypes(dao, name, version).toAuthorative().getPolicyTypes()));
+ synchronized (providerLockObject) {
+ LOGGER.debug("->getPolicyTypeList: name={}, version={}", name, version);
+
+ List<ToscaPolicyType> policyTypeList;
+
+ try {
+ policyTypeList = new ArrayList<>(new SimpleToscaProvider().getPolicyTypes(dao, name, version)
+ .toAuthorative().getPolicyTypes().values());
+ } catch (PfModelRuntimeException pfme) {
+ return handlePfModelRuntimeException(pfme);
+ }
+
+ LOGGER.debug("<-getPolicyTypeList: name={}, version={}, policyTypeList={}", name, version, policyTypeList);
+ return policyTypeList;
+ }
}
/**
public ToscaServiceTemplate getFilteredPolicyTypes(@NonNull final PfDao dao,
@NonNull final ToscaPolicyTypeFilter filter) throws PfModelException {
- ToscaServiceTemplate serviceTemplate =
- new SimpleToscaProvider().getPolicyTypes(dao, null, null).toAuthorative();
+ synchronized (providerLockObject) {
+ LOGGER.debug("->getFilteredPolicyTypes: filter={}", filter);
+ SimpleToscaProvider simpleToscaProvider = new SimpleToscaProvider();
- List<ToscaPolicyType> filteredPolicyTypes = asConceptList(serviceTemplate.getPolicyTypes());
- filteredPolicyTypes = filter.filter(filteredPolicyTypes);
+ final JpaToscaServiceTemplate dbServiceTemplate = simpleToscaProvider.getPolicyTypes(dao, null, null);
- serviceTemplate.setPolicyTypes(asConceptMap(filteredPolicyTypes));
+ List<ToscaPolicyType> filteredPolicyTypes = dbServiceTemplate.getPolicyTypes().toAuthorativeList();
+ filteredPolicyTypes = filter.filter(filteredPolicyTypes);
+
+ if (CollectionUtils.isEmpty(filteredPolicyTypes)) {
+ throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
+ "policy types for filter " + filter.toString() + " do not exist");
+ }
- return serviceTemplate;
+ JpaToscaServiceTemplate filteredServiceTemplate = new JpaToscaServiceTemplate();
+
+ for (ToscaPolicyType policyType : filteredPolicyTypes) {
+ JpaToscaServiceTemplate cascadedServiceTemplate = simpleToscaProvider
+ .getCascadedPolicyTypes(dbServiceTemplate, policyType.getName(), policyType.getVersion());
+
+ filteredServiceTemplate =
+ ToscaServiceTemplateUtils.addFragment(filteredServiceTemplate, cascadedServiceTemplate);
+ }
+
+ ToscaServiceTemplate returnServiceTemplate = filteredServiceTemplate.toAuthorative();
+
+ LOGGER.debug("<-getFilteredPolicyTypes: filter={}, serviceTemplate={}", filter, returnServiceTemplate);
+ return returnServiceTemplate;
+ }
}
/**
public List<ToscaPolicyType> getFilteredPolicyTypeList(@NonNull final PfDao dao,
@NonNull final ToscaPolicyTypeFilter filter) throws PfModelException {
- return filter.filter(getPolicyTypeList(dao, null, null));
+ LOGGER.debug("->getFilteredPolicyTypeList: filter={}", filter);
+
+ List<ToscaPolicyType> filteredPolicyTypeList = filter.filter(getPolicyTypeList(dao, null, null));
+
+ LOGGER.debug("<-getFilteredPolicyTypeList: filter={}, filteredPolicyTypeList={}", filter,
+ filteredPolicyTypeList);
+
+ return filteredPolicyTypeList;
}
/**
public ToscaServiceTemplate createPolicyTypes(@NonNull final PfDao dao,
@NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
- return new SimpleToscaProvider().createPolicyTypes(dao, new JpaToscaServiceTemplate(serviceTemplate))
- .toAuthorative();
+ synchronized (providerLockObject) {
+ LOGGER.debug("->createPolicyTypes: serviceTemplate={}", serviceTemplate);
+
+ ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
+ .createPolicyTypes(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
+
+ LOGGER.debug("<-createPolicyTypes: createdServiceTemplate={}", createdServiceTemplate);
+ return createdServiceTemplate;
+ }
}
/**
public ToscaServiceTemplate updatePolicyTypes(@NonNull final PfDao dao,
@NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
- return new SimpleToscaProvider().updatePolicyTypes(dao, new JpaToscaServiceTemplate(serviceTemplate))
- .toAuthorative();
+ synchronized (providerLockObject) {
+ LOGGER.debug("->updatePolicyTypes: serviceTemplate={}", serviceTemplate);
+
+ ToscaServiceTemplate updatedServiceTemplate = new SimpleToscaProvider()
+ .updatePolicyTypes(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
+
+ LOGGER.debug("<-updatePolicyTypes: updatedServiceTemplate={}", updatedServiceTemplate);
+ return updatedServiceTemplate;
+ }
}
/**
public ToscaServiceTemplate deletePolicyType(@NonNull final PfDao dao, @NonNull final String name,
@NonNull final String version) throws PfModelException {
- return new SimpleToscaProvider().deletePolicyType(dao, new PfConceptKey(name, version)).toAuthorative();
+ synchronized (providerLockObject) {
+ LOGGER.debug("->deletePolicyType: name={}, version={}", name, version);
+
+ ToscaServiceTemplate deletedServiceTemplate =
+ new SimpleToscaProvider().deletePolicyType(dao, new PfConceptKey(name, version)).toAuthorative();
+
+ LOGGER.debug("<-deletePolicyType: name={}, version={}, deletedServiceTemplate={}", name, version,
+ deletedServiceTemplate);
+ return deletedServiceTemplate;
+ }
}
/**
public ToscaServiceTemplate getPolicies(@NonNull final PfDao dao, final String name, final String version)
throws PfModelException {
- return new SimpleToscaProvider().getPolicies(dao, name, version).toAuthorative();
+ synchronized (providerLockObject) {
+ LOGGER.debug("->getPolicies: name={}, version={}", name, version);
+
+ ToscaServiceTemplate gotServiceTemplate =
+ new SimpleToscaProvider().getPolicies(dao, name, version).toAuthorative();
+
+ LOGGER.debug("<-getPolicies: name={}, version={}, gotServiceTemplate={}", name, version,
+ gotServiceTemplate);
+ return gotServiceTemplate;
+ }
}
/**
public List<ToscaPolicy> getPolicyList(@NonNull final PfDao dao, final String name, final String version)
throws PfModelException {
- return asConceptList(new SimpleToscaProvider().getPolicies(dao, name, version).toAuthorative()
- .getToscaTopologyTemplate().getPolicies());
+ synchronized (providerLockObject) {
+ LOGGER.debug("->getPolicyList: name={}, version={}", name, version);
+
+ List<ToscaPolicy> policyList;
+
+ try {
+ policyList = asConceptList(new SimpleToscaProvider().getPolicies(dao, name, version).toAuthorative()
+ .getToscaTopologyTemplate().getPolicies());
+ } catch (PfModelRuntimeException pfme) {
+ return handlePfModelRuntimeException(pfme);
+ }
+
+ LOGGER.debug("<-getPolicyList: name={}, version={}, policyList={}", name, version, policyList);
+ return policyList;
+ }
}
/**
public ToscaServiceTemplate getFilteredPolicies(@NonNull final PfDao dao, @NonNull final ToscaPolicyFilter filter)
throws PfModelException {
- ToscaServiceTemplate serviceTemplate = new SimpleToscaProvider().getPolicies(dao, null, null).toAuthorative();
+ synchronized (providerLockObject) {
+ LOGGER.debug("->getFilteredPolicies: filter={}", filter);
+ String version = ToscaPolicyFilter.LATEST_VERSION.equals(filter.getVersion()) ? null : filter.getVersion();
+
+ SimpleToscaProvider simpleToscaProvider = new SimpleToscaProvider();
+ final JpaToscaServiceTemplate dbServiceTemplate =
+ simpleToscaProvider.getPolicies(dao, filter.getName(), version);
- List<ToscaPolicy> filteredPolicies = asConceptList(serviceTemplate.getToscaTopologyTemplate().getPolicies());
- filteredPolicies = filter.filter(filteredPolicies);
+ List<ToscaPolicy> filteredPolicies =
+ dbServiceTemplate.getTopologyTemplate().getPolicies().toAuthorativeList();
+ filteredPolicies = filter.filter(filteredPolicies);
+
+ if (CollectionUtils.isEmpty(filteredPolicies)) {
+ throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
+ "policies for filter " + filter.toString() + " do not exist");
+ }
- serviceTemplate.getToscaTopologyTemplate().setPolicies(asConceptMap(filteredPolicies));
+ JpaToscaServiceTemplate filteredServiceTemplate = new JpaToscaServiceTemplate();
+
+ for (ToscaPolicy policy : filteredPolicies) {
+ JpaToscaServiceTemplate cascadedServiceTemplate = simpleToscaProvider
+ .getCascadedPolicies(dbServiceTemplate, policy.getName(), policy.getVersion());
+
+ filteredServiceTemplate =
+ ToscaServiceTemplateUtils.addFragment(filteredServiceTemplate, cascadedServiceTemplate);
+ }
- return serviceTemplate;
+ ToscaServiceTemplate returnServiceTemplate = filteredServiceTemplate.toAuthorative();
+
+ LOGGER.debug("<-getFilteredPolicies: filter={}, serviceTemplate={}", filter, returnServiceTemplate);
+ return returnServiceTemplate;
+ }
}
/**
public List<ToscaPolicy> getFilteredPolicyList(@NonNull final PfDao dao, @NonNull final ToscaPolicyFilter filter)
throws PfModelException {
- return filter.filter(getPolicyList(dao, null, null));
+ LOGGER.debug("->getFilteredPolicyList: filter={}", filter);
+ String version = ToscaPolicyFilter.LATEST_VERSION.equals(filter.getVersion()) ? null : filter.getVersion();
+
+ List<ToscaPolicy> policyList = filter.filter(getPolicyList(dao, filter.getName(), version));
+
+ LOGGER.debug("<-getFilteredPolicyList: filter={}, policyList={}", filter, policyList);
+ return policyList;
}
/**
public ToscaServiceTemplate createPolicies(@NonNull final PfDao dao,
@NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
- return new SimpleToscaProvider().createPolicies(dao, new JpaToscaServiceTemplate(serviceTemplate))
- .toAuthorative();
+ synchronized (providerLockObject) {
+ LOGGER.debug("->createPolicies: serviceTemplate={}", serviceTemplate);
+
+ ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
+ .createPolicies(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
+
+ LOGGER.debug("<-createPolicies: createdServiceTemplate={}", createdServiceTemplate);
+ return createdServiceTemplate;
+ }
}
/**
public ToscaServiceTemplate updatePolicies(@NonNull final PfDao dao,
@NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
- return new SimpleToscaProvider().updatePolicies(dao, new JpaToscaServiceTemplate(serviceTemplate))
- .toAuthorative();
+ synchronized (providerLockObject) {
+ LOGGER.debug("->updatePolicies: serviceTemplate={}", serviceTemplate);
+
+ ToscaServiceTemplate updatedServiceTemplate = new SimpleToscaProvider()
+ .updatePolicies(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
+
+ LOGGER.debug("<-updatePolicies: updatedServiceTemplate={}", updatedServiceTemplate);
+ return updatedServiceTemplate;
+ }
}
/**
* @param dao the DAO to use to access the database
* @param name the name of the policy to delete.
* @param version the version of the policy to delete.
- * @return the TOSCA service template containing the policy that weas deleted
+ * @return the TOSCA service template containing the policy that was deleted
* @throws PfModelException on errors deleting policies
*/
public ToscaServiceTemplate deletePolicy(@NonNull final PfDao dao, @NonNull final String name,
@NonNull final String version) throws PfModelException {
- return new SimpleToscaProvider().deletePolicy(dao, new PfConceptKey(name, version)).toAuthorative();
+ synchronized (providerLockObject) {
+ LOGGER.debug("->deletePolicy: name={}, version={}", name, version);
+
+ ToscaServiceTemplate deletedServiceTemplate =
+ new SimpleToscaProvider().deletePolicy(dao, new PfConceptKey(name, version)).toAuthorative();
+
+ LOGGER.debug("<-deletePolicy: name={}, version={}, deletedServiceTemplate={}", name, version,
+ deletedServiceTemplate);
+ return deletedServiceTemplate;
+ }
}
/**
}
/**
- * Return the contents of a list of concepts as a list of maps of concepts.
+ * Handle a PfModelRuntimeException on a list call.
*
- * @param comceptList the concept list
- * @return the concept map
+ * @param pfme the model exception
+ * @return an empty list on 404
*/
- private <T extends ToscaEntity> List<Map<String, T>> asConceptMap(List<T> conceptList) {
- Map<String, T> conceptMap = new LinkedHashMap<>();
- for (T concept : conceptList) {
- conceptMap.put(concept.getName(), concept);
+ private <T extends ToscaEntity> List<T> handlePfModelRuntimeException(final PfModelRuntimeException pfme) {
+ if (Status.NOT_FOUND.equals(pfme.getErrorResponse().getResponseCode())) {
+ LOGGER.trace("request did not find any results", pfme);
+ return Collections.emptyList();
+ } else {
+ throw pfme;
}
-
- return Collections.singletonList(conceptMap);
}
}
Code Review / policy / models.git / blobdiff