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