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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021-2022 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 java.util.Map;
  27 import javax.ws.rs.core.Response;
  28 import lombok.NonNull;
  29 import org.onap.policy.models.base.PfConceptKey;
  30 import org.onap.policy.models.base.PfModelException;
  31 import org.onap.policy.models.base.PfModelRuntimeException;
  32 import org.onap.policy.models.dao.PfDao;
  33 import org.onap.policy.models.pap.concepts.PolicyAudit;
  34 import org.onap.policy.models.pap.persistence.provider.PolicyAuditProvider;
  35 import org.onap.policy.models.pap.persistence.provider.PolicyAuditProvider.AuditFilter;
  36 import org.onap.policy.models.pdp.concepts.Pdp;
  37 import org.onap.policy.models.pdp.concepts.PdpGroup;
  38 import org.onap.policy.models.pdp.concepts.PdpGroupFilter;
  39 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus;
  40 import org.onap.policy.models.pdp.concepts.PdpStatistics;
  41 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
  42 import org.onap.policy.models.pdp.persistence.provider.PdpFilterParameters;
  43 import org.onap.policy.models.pdp.persistence.provider.PdpProvider;
  44 import org.onap.policy.models.pdp.persistence.provider.PdpStatisticsProvider;
  45 import org.onap.policy.models.provider.PolicyModelsProvider;
  46 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  47 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifierOptVersion;
  48 import org.onap.policy.models.tosca.authorative.concepts.ToscaEntityFilter;
  49 import org.onap.policy.models.tosca.authorative.concepts.ToscaEntityKey;
  50 import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate;
  51 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
  52 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType;
  53 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  54 import org.onap.policy.models.tosca.authorative.concepts.ToscaTypedEntityFilter;
  55 import org.onap.policy.models.tosca.authorative.provider.AuthorativeToscaProvider;
  56
  57 public abstract class AbstractPolicyModelsProvider implements PolicyModelsProvider {
  58
  59     protected abstract PfDao getPfDao();
  60
  61     @Override
  62     public List<ToscaServiceTemplate> getServiceTemplateList(final String name, final String version)
  63             throws PfModelException {
  64         assertInitialized();
  65         return new AuthorativeToscaProvider().getServiceTemplateList(getPfDao(), name, version);
  66     }
  67
  68
  69     @Override
  70     public List<ToscaServiceTemplate> getFilteredServiceTemplateList(
  71             @NonNull ToscaEntityFilter<ToscaServiceTemplate> filter) throws PfModelException {
  72         assertInitialized();
  73         return new AuthorativeToscaProvider().getFilteredServiceTemplateList(getPfDao(), filter);
  74     }
  75
  76     @Override
  77     public ToscaServiceTemplate createServiceTemplate(@NonNull final ToscaServiceTemplate serviceTemplate)
  78             throws PfModelException {
  79         assertInitialized();
  80         return new AuthorativeToscaProvider().createServiceTemplate(getPfDao(), serviceTemplate);
  81     }
  82
  83     @Override
  84     public ToscaServiceTemplate updateServiceTemplate(@NonNull final ToscaServiceTemplate serviceTemplate)
  85             throws PfModelException {
  86         assertInitialized();
  87         return new AuthorativeToscaProvider().updateServiceTemplate(getPfDao(), serviceTemplate);
  88     }
  89
  90     @Override
  91     public ToscaServiceTemplate deleteServiceTemplate(@NonNull final String name, @NonNull final String version)
  92             throws PfModelException {
  93         assertInitialized();
  94
  95         return new AuthorativeToscaProvider().deleteServiceTemplate(getPfDao(), name, version);
  96     }
  97
  98     @Override
  99     public ToscaServiceTemplate getPolicyTypes(final String name, final String version) throws PfModelException {
 100         assertInitialized();
 101         return new AuthorativeToscaProvider().getPolicyTypes(getPfDao(), name, version);
 102     }
 103
 104     @Override
 105     public List<ToscaPolicyType> getPolicyTypeList(final String name, final String version) throws PfModelException {
 106         assertInitialized();
 107         return new AuthorativeToscaProvider().getPolicyTypeList(getPfDao(), name, version);
 108     }
 109
 110     @Override
 111     public ToscaServiceTemplate getFilteredPolicyTypes(@NonNull ToscaEntityFilter<ToscaPolicyType> filter)
 112             throws PfModelException {
 113         assertInitialized();
 114         return new AuthorativeToscaProvider().getFilteredPolicyTypes(getPfDao(), filter);
 115     }
 116
 117     @Override
 118     public List<ToscaPolicyType> getFilteredPolicyTypeList(@NonNull ToscaEntityFilter<ToscaPolicyType> filter)
 119             throws PfModelException {
 120         assertInitialized();
 121         return new AuthorativeToscaProvider().getFilteredPolicyTypeList(getPfDao(), filter);
 122     }
 123
 124     @Override
 125     public ToscaServiceTemplate createPolicyTypes(@NonNull final ToscaServiceTemplate serviceTemplate)
 126             throws PfModelException {
 127         assertInitialized();
 128         return new AuthorativeToscaProvider().createPolicyTypes(getPfDao(), serviceTemplate);
 129     }
 130
 131     @Override
 132     public ToscaServiceTemplate updatePolicyTypes(@NonNull final ToscaServiceTemplate serviceTemplate)
 133             throws PfModelException {
 134         assertInitialized();
 135         return new AuthorativeToscaProvider().updatePolicyTypes(getPfDao(), serviceTemplate);
 136     }
 137
 138     @Override
 139     public ToscaServiceTemplate deletePolicyType(@NonNull final String name, @NonNull final String version)
 140             throws PfModelException {
 141         assertInitialized();
 142
 143         var policyTypeIdentifier = new ToscaConceptIdentifier(name, version);
 144         assertPolicyTypeNotSupportedInPdpGroup(policyTypeIdentifier);
 145
 146         return new AuthorativeToscaProvider().deletePolicyType(getPfDao(), name, version);
 147     }
 148
 149     @Override
 150     public ToscaServiceTemplate getPolicies(final String name, final String version) throws PfModelException {
 151         assertInitialized();
 152         return new AuthorativeToscaProvider().getPolicies(getPfDao(), name, version);
 153     }
 154
 155     @Override
 156     public List<ToscaPolicy> getPolicyList(final String name, final String version) throws PfModelException {
 157         assertInitialized();
 158         return new AuthorativeToscaProvider().getPolicyList(getPfDao(), name, version);
 159     }
 160
 161     @Override
 162     public ToscaServiceTemplate getFilteredPolicies(@NonNull ToscaTypedEntityFilter<ToscaPolicy> filter)
 163             throws PfModelException {
 164         assertInitialized();
 165         return new AuthorativeToscaProvider().getFilteredPolicies(getPfDao(), filter);
 166     }
 167
 168     @Override
 169     public List<ToscaPolicy> getFilteredPolicyList(@NonNull ToscaTypedEntityFilter<ToscaPolicy> filter)
 170             throws PfModelException {
 171         assertInitialized();
 172         return new AuthorativeToscaProvider().getFilteredPolicyList(getPfDao(), filter);
 173     }
 174
 175     @Override
 176     public ToscaServiceTemplate createPolicies(@NonNull final ToscaServiceTemplate serviceTemplate)
 177             throws PfModelException {
 178         assertInitialized();
 179         return new AuthorativeToscaProvider().createPolicies(getPfDao(), serviceTemplate);
 180     }
 181
 182     @Override
 183     public ToscaServiceTemplate updatePolicies(@NonNull final ToscaServiceTemplate serviceTemplate)
 184             throws PfModelException {
 185         assertInitialized();
 186         return new AuthorativeToscaProvider().updatePolicies(getPfDao(), serviceTemplate);
 187     }
 188
 189     @Override
 190     public ToscaServiceTemplate deletePolicy(@NonNull final String name, @NonNull final String version)
 191             throws PfModelException {
 192         assertInitialized();
 193
 194         var policyIdentifier = new ToscaConceptIdentifier(name, version);
 195         assertPolicyNotDeployedInPdpGroup(policyIdentifier);
 196
 197         return new AuthorativeToscaProvider().deletePolicy(getPfDao(), name, version);
 198     }
 199
 200     @Override
 201     public ToscaServiceTemplate createToscaNodeTemplates(@NonNull final ToscaServiceTemplate serviceTemplate)
 202         throws PfModelException {
 203         assertInitialized();
 204         return new AuthorativeToscaProvider().createToscaNodeTemplates(getPfDao(), serviceTemplate);
 205     }
 206
 207     @Override
 208     public ToscaServiceTemplate updateToscaNodeTemplates(@NonNull final ToscaServiceTemplate serviceTemplate)
 209         throws PfModelRuntimeException, PfModelException {
 210         assertInitialized();
 211         return new AuthorativeToscaProvider().updateToscaNodeTemplates(getPfDao(), serviceTemplate);
 212     }
 213
 214     @Override
 215     public ToscaServiceTemplate deleteToscaNodeTemplate(@NonNull final String name, @NonNull final String version)
 216         throws PfModelException {
 217         assertInitialized();
 218         return new AuthorativeToscaProvider().deleteToscaNodeTemplate(getPfDao(), name, version);
 219     }
 220
 221     @Override
 222     public List<Map<ToscaEntityKey, Map<String, Object>>> getNodeTemplateMetadataSets(final String name,
 223                                                                                       final String version)
 224         throws PfModelException {
 225         assertInitialized();
 226         return new AuthorativeToscaProvider().getNodeTemplateMetadataSet(getPfDao(), name, version);
 227     }
 228
 229     @Override
 230     public List<Map<PfConceptKey, ToscaNodeTemplate>> getToscaNodeTemplate(final String name,
 231                                                                            final String version)
 232         throws PfModelException {
 233         assertInitialized();
 234         return new AuthorativeToscaProvider().getToscaNodeTemplate(getPfDao(), name, version);
 235     }
 236
 237
 238
 239     @Override
 240     public List<PdpGroup> getPdpGroups(final String name) throws PfModelException {
 241         assertInitialized();
 242         return new PdpProvider().getPdpGroups(getPfDao(), name);
 243     }
 244
 245     @Override
 246     public List<PdpGroup> getFilteredPdpGroups(@NonNull PdpGroupFilter filter) throws PfModelException {
 247         assertInitialized();
 248         return new PdpProvider().getFilteredPdpGroups(getPfDao(), filter);
 249     }
 250
 251     @Override
 252     public List<PdpGroup> createPdpGroups(@NonNull final List<PdpGroup> pdpGroups) throws PfModelException {
 253         assertInitialized();
 254         return new PdpProvider().createPdpGroups(getPfDao(), pdpGroups);
 255     }
 256
 257     @Override
 258     public List<PdpGroup> updatePdpGroups(@NonNull final List<PdpGroup> pdpGroups) throws PfModelException {
 259         assertInitialized();
 260         return new PdpProvider().updatePdpGroups(getPfDao(), pdpGroups);
 261     }
 262
 263     @Override
 264     public void updatePdpSubGroup(@NonNull final String pdpGroupName, @NonNull final PdpSubGroup pdpSubGroup)
 265             throws PfModelException {
 266         assertInitialized();
 267         new PdpProvider().updatePdpSubGroup(getPfDao(), pdpGroupName, pdpSubGroup);
 268     }
 269
 270     @Override
 271     public void updatePdp(@NonNull String pdpGroupName, @NonNull String pdpSubGroup, @NonNull Pdp pdp)
 272             throws PfModelException {
 273         new PdpProvider().updatePdp(getPfDao(), pdpGroupName, pdpSubGroup, pdp);
 274     }
 275
 276     @Override
 277     public PdpGroup deletePdpGroup(@NonNull final String name) throws PfModelException {
 278         assertInitialized();
 279         return new PdpProvider().deletePdpGroup(getPfDao(), name);
 280     }
 281
 282     @Override
 283     public List<PdpStatistics> getFilteredPdpStatistics(PdpFilterParameters filterParams) throws PfModelException {
 284         assertInitialized();
 285         return new PdpStatisticsProvider().getFilteredPdpStatistics(getPfDao(), filterParams);
 286     }
 287
 288     @Override
 289     public List<PdpStatistics> createPdpStatistics(@NonNull final List<PdpStatistics> pdpStatisticsList)
 290             throws PfModelException {
 291         assertInitialized();
 292         return new PdpStatisticsProvider().createPdpStatistics(getPfDao(), pdpStatisticsList);
 293     }
 294
 295     @Override
 296     public List<PdpStatistics> updatePdpStatistics(@NonNull final List<PdpStatistics> pdpStatisticsList)
 297             throws PfModelException {
 298         assertInitialized();
 299         return new PdpStatisticsProvider().updatePdpStatistics(getPfDao(), pdpStatisticsList);
 300     }
 301
 302     @Override
 303     public List<PdpStatistics> deletePdpStatistics(@NonNull final String name, final Instant timestamp)
 304             throws PfModelException {
 305         assertInitialized();
 306         return new PdpStatisticsProvider().deletePdpStatistics(getPfDao(), name, timestamp);
 307     }
 308
 309     @Override
 310     public List<PdpPolicyStatus> getAllPolicyStatus() throws PfModelException {
 311         assertInitialized();
 312         return new PdpProvider().getAllPolicyStatus(getPfDao());
 313     }
 314
 315     @Override
 316     public List<PdpPolicyStatus> getAllPolicyStatus(@NonNull ToscaConceptIdentifierOptVersion policy)
 317             throws PfModelException {
 318         assertInitialized();
 319         return new PdpProvider().getAllPolicyStatus(getPfDao(), policy);
 320     }
 321
 322     @Override
 323     public List<PdpPolicyStatus> getGroupPolicyStatus(@NonNull String groupName) throws PfModelException {
 324         assertInitialized();
 325         return new PdpProvider().getGroupPolicyStatus(getPfDao(), groupName);
 326     }
 327
 328     @Override
 329     public void cudPolicyStatus(Collection<PdpPolicyStatus> createObjs, Collection<PdpPolicyStatus> updateObjs,
 330             Collection<PdpPolicyStatus> deleteObjs) {
 331         assertInitialized();
 332         new PdpProvider().cudPolicyStatus(getPfDao(), createObjs, updateObjs, deleteObjs);
 333     }
 334
 335     @Override
 336     public void createAuditRecords(List<PolicyAudit> auditRecords) {
 337         assertInitialized();
 338         new PolicyAuditProvider().createAuditRecords(getPfDao(), auditRecords);
 339     }
 340
 341     @Override
 342     public List<PolicyAudit> getAuditRecords(AuditFilter auditFilter) {
 343         assertInitialized();
 344         return new PolicyAuditProvider().getAuditRecords(getPfDao(), auditFilter);
 345     }
 346
 347     /**
 348      * Check if the model provider is initialized.
 349      */
 350     private void assertInitialized() {
 351         if (getPfDao() == null) {
 352             var errorMessage = "policy models provider is not initilaized";
 353             throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, errorMessage);
 354         }
 355     }
 356
 357     /**
 358      * Assert that the policy type is not supported in any PDP group.
 359      *
 360      * @param policyTypeIdentifier the policy type identifier
 361      * @throws PfModelException if the policy type is supported in a PDP group
 362      */
 363     private void assertPolicyTypeNotSupportedInPdpGroup(ToscaConceptIdentifier policyTypeIdentifier)
 364             throws PfModelException {
 365         for (PdpGroup pdpGroup : getPdpGroups(null)) {
 366             for (PdpSubGroup pdpSubGroup : pdpGroup.getPdpSubgroups()) {
 367                 if (pdpSubGroup.getSupportedPolicyTypes().contains(policyTypeIdentifier)) {
 368                     throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE,
 369                             "policy type is in use, it is referenced in PDP group " + pdpGroup.getName() + " subgroup "
 370                                     + pdpSubGroup.getPdpType());
 371                 }
 372             }
 373         }
 374     }
 375
 376     /**
 377      * Assert that the policy is not deployed in a PDP group.
 378      *
 379      * @param policyIdentifier the identifier of the policy
 380      * @throws PfModelException thrown if the policy is deployed in a PDP group
 381      */
 382     private void assertPolicyNotDeployedInPdpGroup(final ToscaConceptIdentifier policyIdentifier)
 383             throws PfModelException {
 384         for (PdpGroup pdpGroup : getPdpGroups(null)) {
 385             for (PdpSubGroup pdpSubGroup : pdpGroup.getPdpSubgroups()) {
 386                 if (pdpSubGroup.getPolicies().contains(policyIdentifier)) {
 387                     throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE,
 388                             "policy is in use, it is deployed in PDP group " + pdpGroup.getName() + " subgroup "
 389                                     + pdpSubGroup.getPdpType());
 390                 }
 391             }
 392         }
 393     }
 394
 395 }