models-provider/src/main/java/org/onap/policy/models/provider/impl/AbstractPolicyModelsProvider.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021 Nordix Foundation.
   4  * ================================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.models.provider.impl;
  22
  23 import java.time.Instant;
  24 import java.util.Collection;
  25 import java.util.List;
  26 import javax.ws.rs.core.Response;
  27 import lombok.NonNull;
  28 import org.onap.policy.models.base.PfModelException;
  29 import org.onap.policy.models.base.PfModelRuntimeException;
  30 import org.onap.policy.models.dao.PfDao;
  31 import org.onap.policy.models.pap.concepts.PolicyAudit;
  32 import org.onap.policy.models.pap.persistence.provider.PolicyAuditProvider;
  33 import org.onap.policy.models.pap.persistence.provider.PolicyAuditProvider.AuditFilter;
  34 import org.onap.policy.models.pdp.concepts.Pdp;
  35 import org.onap.policy.models.pdp.concepts.PdpGroup;
  36 import org.onap.policy.models.pdp.concepts.PdpGroupFilter;
  37 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus;
  38 import org.onap.policy.models.pdp.concepts.PdpStatistics;
  39 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
  40 import org.onap.policy.models.pdp.persistence.provider.PdpFilterParameters;
  41 import org.onap.policy.models.pdp.persistence.provider.PdpProvider;
  42 import org.onap.policy.models.pdp.persistence.provider.PdpStatisticsProvider;
  43 import org.onap.policy.models.provider.PolicyModelsProvider;
  44 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  45 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifierOptVersion;
  46 import org.onap.policy.models.tosca.authorative.concepts.ToscaEntityFilter;
  47 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
  48 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType;
  49 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  50 import org.onap.policy.models.tosca.authorative.concepts.ToscaTypedEntityFilter;
  51 import org.onap.policy.models.tosca.authorative.provider.AuthorativeToscaProvider;
  52
  53 public abstract class AbstractPolicyModelsProvider implements PolicyModelsProvider {
  54
  55     protected abstract PfDao getPfDao();
  56
  57     @Override
  58     public List<ToscaServiceTemplate> getServiceTemplateList(final String name, final String version)
  59             throws PfModelException {
  60         assertInitialized();
  61         return new AuthorativeToscaProvider().getServiceTemplateList(getPfDao(), name, version);
  62     }
  63
  64
  65     @Override
  66     public List<ToscaServiceTemplate> getFilteredServiceTemplateList(
  67             @NonNull ToscaEntityFilter<ToscaServiceTemplate> filter) throws PfModelException {
  68         assertInitialized();
  69         return new AuthorativeToscaProvider().getFilteredServiceTemplateList(getPfDao(), filter);
  70     }
  71
  72     @Override
  73     public ToscaServiceTemplate createServiceTemplate(@NonNull final ToscaServiceTemplate serviceTemplate)
  74             throws PfModelException {
  75         assertInitialized();
  76         return new AuthorativeToscaProvider().createServiceTemplate(getPfDao(), serviceTemplate);
  77     }
  78
  79     @Override
  80     public ToscaServiceTemplate updateServiceTemplate(@NonNull final ToscaServiceTemplate serviceTemplate)
  81             throws PfModelException {
  82         assertInitialized();
  83         return new AuthorativeToscaProvider().updateServiceTemplate(getPfDao(), serviceTemplate);
  84     }
  85
  86     @Override
  87     public ToscaServiceTemplate deleteServiceTemplate(@NonNull final String name, @NonNull final String version)
  88             throws PfModelException {
  89         assertInitialized();
  90
  91         return new AuthorativeToscaProvider().deleteServiceTemplate(getPfDao(), name, version);
  92     }
  93
  94     @Override
  95     public ToscaServiceTemplate getPolicyTypes(final String name, final String version) throws PfModelException {
  96         assertInitialized();
  97         return new AuthorativeToscaProvider().getPolicyTypes(getPfDao(), name, version);
  98     }
  99
 100     @Override
 101     public List<ToscaPolicyType> getPolicyTypeList(final String name, final String version) throws PfModelException {
 102         assertInitialized();
 103         return new AuthorativeToscaProvider().getPolicyTypeList(getPfDao(), name, version);
 104     }
 105
 106     @Override
 107     public ToscaServiceTemplate getFilteredPolicyTypes(@NonNull ToscaEntityFilter<ToscaPolicyType> filter)
 108             throws PfModelException {
 109         assertInitialized();
 110         return new AuthorativeToscaProvider().getFilteredPolicyTypes(getPfDao(), filter);
 111     }
 112
 113     @Override
 114     public List<ToscaPolicyType> getFilteredPolicyTypeList(@NonNull ToscaEntityFilter<ToscaPolicyType> filter)
 115             throws PfModelException {
 116         assertInitialized();
 117         return new AuthorativeToscaProvider().getFilteredPolicyTypeList(getPfDao(), filter);
 118     }
 119
 120     @Override
 121     public ToscaServiceTemplate createPolicyTypes(@NonNull final ToscaServiceTemplate serviceTemplate)
 122             throws PfModelException {
 123         assertInitialized();
 124         return new AuthorativeToscaProvider().createPolicyTypes(getPfDao(), serviceTemplate);
 125     }
 126
 127     @Override
 128     public ToscaServiceTemplate updatePolicyTypes(@NonNull final ToscaServiceTemplate serviceTemplate)
 129             throws PfModelException {
 130         assertInitialized();
 131         return new AuthorativeToscaProvider().updatePolicyTypes(getPfDao(), serviceTemplate);
 132     }
 133
 134     @Override
 135     public ToscaServiceTemplate deletePolicyType(@NonNull final String name, @NonNull final String version)
 136             throws PfModelException {
 137         assertInitialized();
 138
 139         var policyTypeIdentifier = new ToscaConceptIdentifier(name, version);
 140         assertPolicyTypeNotSupportedInPdpGroup(policyTypeIdentifier);
 141
 142         return new AuthorativeToscaProvider().deletePolicyType(getPfDao(), name, version);
 143     }
 144
 145     @Override
 146     public ToscaServiceTemplate getPolicies(final String name, final String version) throws PfModelException {
 147         assertInitialized();
 148         return new AuthorativeToscaProvider().getPolicies(getPfDao(), name, version);
 149     }
 150
 151     @Override
 152     public List<ToscaPolicy> getPolicyList(final String name, final String version) throws PfModelException {
 153         assertInitialized();
 154         return new AuthorativeToscaProvider().getPolicyList(getPfDao(), name, version);
 155     }
 156
 157     @Override
 158     public ToscaServiceTemplate getFilteredPolicies(@NonNull ToscaTypedEntityFilter<ToscaPolicy> filter)
 159             throws PfModelException {
 160         assertInitialized();
 161         return new AuthorativeToscaProvider().getFilteredPolicies(getPfDao(), filter);
 162     }
 163
 164     @Override
 165     public List<ToscaPolicy> getFilteredPolicyList(@NonNull ToscaTypedEntityFilter<ToscaPolicy> filter)
 166             throws PfModelException {
 167         assertInitialized();
 168         return new AuthorativeToscaProvider().getFilteredPolicyList(getPfDao(), filter);
 169     }
 170
 171     @Override
 172     public ToscaServiceTemplate createPolicies(@NonNull final ToscaServiceTemplate serviceTemplate)
 173             throws PfModelException {
 174         assertInitialized();
 175         return new AuthorativeToscaProvider().createPolicies(getPfDao(), serviceTemplate);
 176     }
 177
 178     @Override
 179     public ToscaServiceTemplate updatePolicies(@NonNull final ToscaServiceTemplate serviceTemplate)
 180             throws PfModelException {
 181         assertInitialized();
 182         return new AuthorativeToscaProvider().updatePolicies(getPfDao(), serviceTemplate);
 183     }
 184
 185     @Override
 186     public ToscaServiceTemplate deletePolicy(@NonNull final String name, @NonNull final String version)
 187             throws PfModelException {
 188         assertInitialized();
 189
 190         var policyIdentifier = new ToscaConceptIdentifier(name, version);
 191         assertPolicyNotDeployedInPdpGroup(policyIdentifier);
 192
 193         return new AuthorativeToscaProvider().deletePolicy(getPfDao(), name, version);
 194     }
 195
 196     @Override
 197     public List<PdpGroup> getPdpGroups(final String name) throws PfModelException {
 198         assertInitialized();
 199         return new PdpProvider().getPdpGroups(getPfDao(), name);
 200     }
 201
 202     @Override
 203     public List<PdpGroup> getFilteredPdpGroups(@NonNull PdpGroupFilter filter) throws PfModelException {
 204         assertInitialized();
 205         return new PdpProvider().getFilteredPdpGroups(getPfDao(), filter);
 206     }
 207
 208     @Override
 209     public List<PdpGroup> createPdpGroups(@NonNull final List<PdpGroup> pdpGroups) throws PfModelException {
 210         assertInitialized();
 211         return new PdpProvider().createPdpGroups(getPfDao(), pdpGroups);
 212     }
 213
 214     @Override
 215     public List<PdpGroup> updatePdpGroups(@NonNull final List<PdpGroup> pdpGroups) throws PfModelException {
 216         assertInitialized();
 217         return new PdpProvider().updatePdpGroups(getPfDao(), pdpGroups);
 218     }
 219
 220     @Override
 221     public void updatePdpSubGroup(@NonNull final String pdpGroupName, @NonNull final PdpSubGroup pdpSubGroup)
 222             throws PfModelException {
 223         assertInitialized();
 224         new PdpProvider().updatePdpSubGroup(getPfDao(), pdpGroupName, pdpSubGroup);
 225     }
 226
 227     @Override
 228     public void updatePdp(@NonNull String pdpGroupName, @NonNull String pdpSubGroup, @NonNull Pdp pdp)
 229             throws PfModelException {
 230         new PdpProvider().updatePdp(getPfDao(), pdpGroupName, pdpSubGroup, pdp);
 231     }
 232
 233     @Override
 234     public PdpGroup deletePdpGroup(@NonNull final String name) throws PfModelException {
 235         assertInitialized();
 236         return new PdpProvider().deletePdpGroup(getPfDao(), name);
 237     }
 238
 239     @Override
 240     public List<PdpStatistics> getFilteredPdpStatistics(PdpFilterParameters filterParams) throws PfModelException {
 241         assertInitialized();
 242         return new PdpStatisticsProvider().getFilteredPdpStatistics(getPfDao(), filterParams);
 243     }
 244
 245     @Override
 246     public List<PdpStatistics> createPdpStatistics(@NonNull final List<PdpStatistics> pdpStatisticsList)
 247             throws PfModelException {
 248         assertInitialized();
 249         return new PdpStatisticsProvider().createPdpStatistics(getPfDao(), pdpStatisticsList);
 250     }
 251
 252     @Override
 253     public List<PdpStatistics> updatePdpStatistics(@NonNull final List<PdpStatistics> pdpStatisticsList)
 254             throws PfModelException {
 255         assertInitialized();
 256         return new PdpStatisticsProvider().updatePdpStatistics(getPfDao(), pdpStatisticsList);
 257     }
 258
 259     @Override
 260     public List<PdpStatistics> deletePdpStatistics(@NonNull final String name, final Instant timestamp)
 261             throws PfModelException {
 262         assertInitialized();
 263         return new PdpStatisticsProvider().deletePdpStatistics(getPfDao(), name, timestamp);
 264     }
 265
 266     @Override
 267     public List<PdpPolicyStatus> getAllPolicyStatus() throws PfModelException {
 268         assertInitialized();
 269         return new PdpProvider().getAllPolicyStatus(getPfDao());
 270     }
 271
 272     @Override
 273     public List<PdpPolicyStatus> getAllPolicyStatus(@NonNull ToscaConceptIdentifierOptVersion policy)
 274             throws PfModelException {
 275         assertInitialized();
 276         return new PdpProvider().getAllPolicyStatus(getPfDao(), policy);
 277     }
 278
 279     @Override
 280     public List<PdpPolicyStatus> getGroupPolicyStatus(@NonNull String groupName) throws PfModelException {
 281         assertInitialized();
 282         return new PdpProvider().getGroupPolicyStatus(getPfDao(), groupName);
 283     }
 284
 285     @Override
 286     public void cudPolicyStatus(Collection<PdpPolicyStatus> createObjs, Collection<PdpPolicyStatus> updateObjs,
 287             Collection<PdpPolicyStatus> deleteObjs) {
 288         assertInitialized();
 289         new PdpProvider().cudPolicyStatus(getPfDao(), createObjs, updateObjs, deleteObjs);
 290     }
 291
 292     @Override
 293     public void createAuditRecords(List<PolicyAudit> auditRecords) {
 294         assertInitialized();
 295         new PolicyAuditProvider().createAuditRecords(getPfDao(), auditRecords);
 296     }
 297
 298     @Override
 299     public List<PolicyAudit> getAuditRecords(AuditFilter auditFilter) {
 300         assertInitialized();
 301         return new PolicyAuditProvider().getAuditRecords(getPfDao(), auditFilter);
 302     }
 303
 304     /**
 305      * Check if the model provider is initialized.
 306      */
 307     private void assertInitialized() {
 308         if (getPfDao() == null) {
 309             var errorMessage = "policy models provider is not initilaized";
 310             throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, errorMessage);
 311         }
 312     }
 313
 314     /**
 315      * Assert that the policy type is not supported in any PDP group.
 316      *
 317      * @param policyTypeIdentifier the policy type identifier
 318      * @throws PfModelException if the policy type is supported in a PDP group
 319      */
 320     private void assertPolicyTypeNotSupportedInPdpGroup(ToscaConceptIdentifier policyTypeIdentifier)
 321             throws PfModelException {
 322         for (PdpGroup pdpGroup : getPdpGroups(null)) {
 323             for (PdpSubGroup pdpSubGroup : pdpGroup.getPdpSubgroups()) {
 324                 if (pdpSubGroup.getSupportedPolicyTypes().contains(policyTypeIdentifier)) {
 325                     throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE,
 326                             "policy type is in use, it is referenced in PDP group " + pdpGroup.getName() + " subgroup "
 327                                     + pdpSubGroup.getPdpType());
 328                 }
 329             }
 330         }
 331     }
 332
 333     /**
 334      * Assert that the policy is not deployed in a PDP group.
 335      *
 336      * @param policyIdentifier the identifier of the policy
 337      * @throws PfModelException thrown if the policy is deployed in a PDP group
 338      */
 339     private void assertPolicyNotDeployedInPdpGroup(final ToscaConceptIdentifier policyIdentifier)
 340             throws PfModelException {
 341         for (PdpGroup pdpGroup : getPdpGroups(null)) {
 342             for (PdpSubGroup pdpSubGroup : pdpGroup.getPdpSubgroups()) {
 343                 if (pdpSubGroup.getPolicies().contains(policyIdentifier)) {
 344                     throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE,
 345                             "policy is in use, it is deployed in PDP group " + pdpGroup.getName() + " subgroup "
 346                                     + pdpSubGroup.getPdpType());
 347                 }
 348             }
 349         }
 350     }
 351
 352 }