X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=models-pdp%2Fsrc%2Fmain%2Fjava%2Forg%2Fonap%2Fpolicy%2Fmodels%2Fpdp%2Fpersistence%2Fprovider%2FPdpProvider.java;h=0cc0eb2679f07c9638e20cbfc3605b7ee8a47b7f;hb=d19537308cbdce440c1faf819eb586983d0a67c9;hp=6af2d211b83f40175396d12ad6e4dfbce6f874cf;hpb=8c57c0f7d3a17bdbdc9b21f5f0d778a299a31df7;p=policy%2Fmodels.git diff --git a/models-pdp/src/main/java/org/onap/policy/models/pdp/persistence/provider/PdpProvider.java b/models-pdp/src/main/java/org/onap/policy/models/pdp/persistence/provider/PdpProvider.java index 6af2d211b..0cc0eb267 100644 --- a/models-pdp/src/main/java/org/onap/policy/models/pdp/persistence/provider/PdpProvider.java +++ b/models-pdp/src/main/java/org/onap/policy/models/pdp/persistence/provider/PdpProvider.java @@ -1,6 +1,8 @@ /*- * ============LICENSE_START======================================================= * Copyright (C) 2019 Nordix Foundation. + * Modifications Copyright (C) 2019-2021 AT&T Intellectual Property. All rights reserved. + * Modifications Copyright (C) 2023 Bell Canada. 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. @@ -21,20 +23,31 @@ package org.onap.policy.models.pdp.persistence.provider; import java.util.ArrayList; -import java.util.LinkedHashMap; +import java.util.Collection; +import java.util.Collections; import java.util.List; import java.util.Map; - +import java.util.stream.Collectors; +import javax.ws.rs.core.Response; import lombok.NonNull; - -import org.apache.commons.lang3.tuple.Pair; +import org.onap.policy.common.parameters.BeanValidationResult; +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.PfReferenceKey; import org.onap.policy.models.dao.PfDao; +import org.onap.policy.models.dao.PfFilterParameters; +import org.onap.policy.models.pdp.concepts.Pdp; import org.onap.policy.models.pdp.concepts.PdpGroup; -import org.onap.policy.models.pdp.concepts.PdpGroups; -import org.onap.policy.models.pdp.concepts.PdpStatistics; +import org.onap.policy.models.pdp.concepts.PdpGroupFilter; +import org.onap.policy.models.pdp.concepts.PdpPolicyStatus; import org.onap.policy.models.pdp.concepts.PdpSubGroup; -import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy; +import org.onap.policy.models.pdp.persistence.concepts.JpaPdp; +import org.onap.policy.models.pdp.persistence.concepts.JpaPdpGroup; +import org.onap.policy.models.pdp.persistence.concepts.JpaPdpPolicyStatus; +import org.onap.policy.models.pdp.persistence.concepts.JpaPdpSubGroup; +import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifierOptVersion; /** * This class provides the provision of information on PAP concepts in the database to callers. @@ -42,43 +55,33 @@ import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy; * @author Liam Fallon (liam.fallon@est.tech) */ public class PdpProvider { + private static final Object statusLock = new Object(); + /** * Get PDP groups. * * @param dao the DAO to use to access the database - * @param name the name of the policy to get, null to get all PDP groups - * @param version the version of the policy to get, null to get all versions of a PDP group + * @param name the name of the PDP group to get, null to get all PDP groups * @return the PDP groups found * @throws PfModelException on errors getting PDP groups */ - public PdpGroups getPdpGroups(@NonNull final PfDao dao, final String name, final String version) - throws PfModelException { - return new PdpGroups(); + public List getPdpGroups(@NonNull final PfDao dao, final String name) throws PfModelException { + + return asPdpGroupList(dao.getFiltered(JpaPdpGroup.class, name, PfKey.NULL_KEY_VERSION)); } /** - * Get latest PDP Groups. + * Get filtered PDP groups. * * @param dao the DAO to use to access the database - * @param name the name of the PDP group to get, null to get all PDP groups + * @param filter the filter for the PDP groups to get * @return the PDP groups found * @throws PfModelException on errors getting policies */ - public PdpGroups getLatestPdpGroups(@NonNull final PfDao dao, final String name) throws PfModelException { - return new PdpGroups(); - } + public List getFilteredPdpGroups(@NonNull final PfDao dao, @NonNull final PdpGroupFilter filter) { - /** - * Get a filtered list of PDP groups. - * - * @param dao the DAO to use to access the database - * @param pdpType The PDP type filter for the returned PDP groups - * @param supportedPolicyTypes a list of policy type name/version pairs that the PDP groups must support. - * @return the PDP groups found - */ - public PdpGroups getFilteredPdpGroups(@NonNull final PfDao dao, @NonNull final String pdpType, - @NonNull final List> supportedPolicyTypes) { - return new PdpGroups(); + return filter.filter( + asPdpGroupList(dao.getFiltered(JpaPdpGroup.class, filter.getName(), PfKey.NULL_KEY_VERSION))); } /** @@ -89,9 +92,30 @@ public class PdpProvider { * @return the PDP groups created * @throws PfModelException on errors creating PDP groups */ - public PdpGroups createPdpGroups(@NonNull final PfDao dao, @NonNull final PdpGroups pdpGroups) + public List createPdpGroups(@NonNull final PfDao dao, @NonNull final List pdpGroups) throws PfModelException { - return new PdpGroups(); + + for (PdpGroup pdpGroup : pdpGroups) { + var jpaPdpGroup = new JpaPdpGroup(); + jpaPdpGroup.fromAuthorative(pdpGroup); + + BeanValidationResult validationResult = jpaPdpGroup.validate("PDP group"); + if (!validationResult.isValid()) { + throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, validationResult.getResult()); + } + + dao.create(jpaPdpGroup); + } + + // Return the created PDP groups + List returnPdpGroups = new ArrayList<>(); + + for (PdpGroup pdpGroup : pdpGroups) { + var jpaPdpGroup = dao.get(JpaPdpGroup.class, new PfConceptKey(pdpGroup.getName(), PfKey.NULL_KEY_VERSION)); + returnPdpGroups.add(jpaPdpGroup.toAuthorative()); + } + + return returnPdpGroups; } /** @@ -102,24 +126,80 @@ public class PdpProvider { * @return the PDP groups updated * @throws PfModelException on errors updating PDP groups */ - public PdpGroups updatePdpGroups(@NonNull final PfDao dao, @NonNull final PdpGroups pdpGroups) + public List updatePdpGroups(@NonNull final PfDao dao, @NonNull final List pdpGroups) throws PfModelException { - return new PdpGroups(); - } + for (PdpGroup pdpGroup : pdpGroups) { + var jpaPdpGroup = new JpaPdpGroup(); + jpaPdpGroup.fromAuthorative(pdpGroup); + + BeanValidationResult validationResult = jpaPdpGroup.validate("PDP group"); + if (!validationResult.isValid()) { + throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, validationResult.getResult()); + } + + dao.update(jpaPdpGroup); + } + + // Return the created PDP groups + List returnPdpGroups = new ArrayList<>(); + + for (PdpGroup pdpGroup : pdpGroups) { + var jpaPdpGroup = + dao.get(JpaPdpGroup.class, new PfConceptKey(pdpGroup.getName(), PfKey.NULL_KEY_VERSION)); + returnPdpGroups.add(jpaPdpGroup.toAuthorative()); + } + + return returnPdpGroups; + } /** * Update a PDP subgroup. * * @param dao the DAO to use to access the database * @param pdpGroupName the name of the PDP group of the PDP subgroup - * @param pdpGroupVersion the version of the PDP group of the PDP subgroup * @param pdpSubGroup the PDP subgroup to be updated * @throws PfModelException on errors updating PDP subgroups */ public void updatePdpSubGroup(@NonNull final PfDao dao, @NonNull final String pdpGroupName, - @NonNull final String pdpGroupVersion, @NonNull final PdpSubGroup pdpSubGroup) throws PfModelException { - // Not implemented yet + @NonNull final PdpSubGroup pdpSubGroup) throws PfModelException { + + final var subGroupKey = + new PfReferenceKey(pdpGroupName, PfKey.NULL_KEY_VERSION, pdpSubGroup.getPdpType()); + final var jpaPdpSubgroup = new JpaPdpSubGroup(subGroupKey); + jpaPdpSubgroup.fromAuthorative(pdpSubGroup); + + BeanValidationResult validationResult = jpaPdpSubgroup.validate("PDP sub group"); + if (!validationResult.isValid()) { + throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, validationResult.getResult()); + } + + dao.update(jpaPdpSubgroup); + } + + /** + * Update a PDP. + * + * @param dao the DAO to use to access the database + * @param pdpGroupName the name of the PDP group of the PDP subgroup + * @param pdpSubGroup the PDP subgroup to be updated + * @param pdp the PDP to be updated + * @throws PfModelException on errors updating PDP subgroups + */ + public void updatePdp(@NonNull final PfDao dao, @NonNull final String pdpGroupName, + @NonNull final String pdpSubGroup, @NonNull final Pdp pdp) { + + final var pdpKey = + new PfReferenceKey(pdpGroupName, PfKey.NULL_KEY_VERSION, pdpSubGroup, pdp.getInstanceId()); + final var jpaPdp = new JpaPdp(pdpKey); + jpaPdp.fromAuthorative(pdp); + + BeanValidationResult validationResult = jpaPdp.validate("PDP"); + if (!validationResult.isValid()) { + throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, validationResult.getResult()); + } + + dao.update(jpaPdp); } /** @@ -127,56 +207,139 @@ public class PdpProvider { * * @param dao the DAO to use to access the database * @param name the name of the policy to get, null to get all PDP groups - * @param version the version of the policy to get, null to get all versions of a PDP group * @return the PDP group deleted * @throws PfModelException on errors deleting PDP groups */ - public PdpGroup deletePdpGroup(@NonNull final PfDao dao, @NonNull final String name, @NonNull final String version) - throws PfModelException { - return new PdpGroup(); + public PdpGroup deletePdpGroup(@NonNull final PfDao dao, @NonNull final String name) { + + var pdpGroupKey = new PfConceptKey(name, PfKey.NULL_KEY_VERSION); + + JpaPdpGroup jpaDeletePdpGroup = dao.get(JpaPdpGroup.class, pdpGroupKey); + + if (jpaDeletePdpGroup == null) { + String errorMessage = + "delete of PDP group \"" + pdpGroupKey.getId() + "\" failed, PDP group does not exist"; + throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, errorMessage); + } + + dao.delete(jpaDeletePdpGroup); + return jpaDeletePdpGroup.toAuthorative(); } /** - * Get PDP statistics. + * Gets all policy deployments. * * @param dao the DAO to use to access the database - * @param name the name of the PDP group to get statistics for, null to get all PDP groups - * @param version the version of the PDP group to get statistics for, null to get all versions of a PDP group - * @return the statistics found - * @throws PfModelException on errors getting statistics + * @return the deployments found + * @throws PfModelException on errors getting PDP groups */ - public List getPdpStatistics(@NonNull final PfDao dao, final String name, final String version) - throws PfModelException { - return new ArrayList<>(); + public List getAllPolicyStatus(@NonNull final PfDao dao) + throws PfModelException { + + return dao.getAll(JpaPdpPolicyStatus.class).stream().map(JpaPdpPolicyStatus::toAuthorative) + .collect(Collectors.toList()); } /** - * Update PDP statistics for a PDP. + * Gets all deployments for a policy. * * @param dao the DAO to use to access the database - * @param pdpGroupName the name of the PDP group containing the PDP that the statistics are for - * @param pdpGroupVersion the version of the PDP group containing the PDP that the statistics are for - * @param pdpType the PDP type of the subgroup containing the PDP that the statistics are for - * @param pdpInstanceId the instance ID of the PDP to update statistics for - * @throws PfModelException on errors updating statistics + * @return the deployments found + * @throws PfModelException on errors getting PDP groups */ - public void updatePdpStatistics(@NonNull final PfDao dao, @NonNull final String pdpGroupName, - @NonNull final String pdpGroupVersion, @NonNull final String pdpType, @NonNull final String pdpInstanceId, - @NonNull final PdpStatistics pdppStatistics) throws PfModelException { - // Not implemented yet + public List getAllPolicyStatus(@NonNull final PfDao dao, + @NonNull ToscaConceptIdentifierOptVersion policy) throws PfModelException { + + if (policy.getVersion() != null) { + return dao.getAll(JpaPdpPolicyStatus.class, new PfConceptKey(policy.getName(), policy.getVersion())) + .stream().map(JpaPdpPolicyStatus::toAuthorative).collect(Collectors.toList()); + + } else { + return dao.getAllVersionsByParent(JpaPdpPolicyStatus.class, policy.getName()).stream() + .map(JpaPdpPolicyStatus::toAuthorative).collect(Collectors.toList()); + } } /** - * Get deployed policies. + * Gets the policy deployments for a PDP group. * * @param dao the DAO to use to access the database - * @param name the name of the policy to get, null to get all policies - * @return the policies deployed as a map of policy lists keyed by PDP group - * @throws PfModelException on errors getting policies + * @param groupName the name of the PDP group of interest, null to get results for all + * PDP groups + * @return the deployments found + * @throws PfModelException on errors getting PDP groups */ - public Map> getDeployedPolicyList(@NonNull final PfDao dao, final String name) - throws PfModelException { - return new LinkedHashMap<>(); + public List getGroupPolicyStatus(@NonNull final PfDao dao, @NonNull final String groupName) + throws PfModelException { + + PfFilterParameters params = PfFilterParameters.builder().filterMap(Map.of("pdpGroup", groupName)).build(); + + return dao.getFiltered(JpaPdpPolicyStatus.class, params) + .stream().map(JpaPdpPolicyStatus::toAuthorative).collect(Collectors.toList()); + } + + /** + * Creates, updates, and deletes collections of policy status. + * + * @param dao the DAO to use to access the database + * @param createObjs the objects to create + * @param updateObjs the objects to update + * @param deleteObjs the objects to delete + */ + public void cudPolicyStatus(@NonNull final PfDao dao, Collection createObjs, + Collection updateObjs, Collection deleteObjs) { + + synchronized (statusLock) { + dao.deleteCollection(fromAuthorativeStatus(deleteObjs, "deletePdpPolicyStatusList")); + dao.createCollection(fromAuthorativeStatus(createObjs, "createPdpPolicyStatusList")); + dao.createCollection(fromAuthorativeStatus(updateObjs, "updatePdpPolicyStatusList")); + } + } + + /** + * Converts a collection of authorative policy status to a collection of JPA policy + * status. Validates the resulting list. + * + * @param objs authorative policy status to convert + * @param fieldName name of the field containing the collection + * @return a collection of JPA policy status + */ + private Collection fromAuthorativeStatus(Collection objs, String fieldName) { + if (objs == null) { + return Collections.emptyList(); + } + + List jpas = objs.stream().map(JpaPdpPolicyStatus::new).collect(Collectors.toList()); + + // validate the objects + var result = new BeanValidationResult(fieldName, jpas); + + var count = 0; + for (JpaPdpPolicyStatus jpa: jpas) { + result.addResult(jpa.validate(String.valueOf(count++))); + } + + if (!result.isValid()) { + throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, result.getResult()); + } + + return jpas; + } + + /** + * Convert JPA PDP group list to an authorative PDP group list. + * + * @param jpaPdpGroupList the list to convert + * @return the authorative list + */ + private List asPdpGroupList(List jpaPdpGroupList) { + List pdpGroupList = new ArrayList<>(jpaPdpGroupList.size()); + + for (JpaPdpGroup jpaPdpGroup : jpaPdpGroupList) { + pdpGroupList.add(jpaPdpGroup.toAuthorative()); + } + + return pdpGroupList; } }