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

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