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.util.Collection;
  26 import java.util.Date;
  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 Date 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 Date startTimeStamp, final Date endTimeStamp, final String sortOrder,
 258             final int getRecordNum) throws PfModelException {
 259         assertInitialized();
 260         return new PdpStatisticsProvider().getFilteredPdpStatistics(getPfDao(), name, pdpGroupName, pdpSubGroup,
 261                 startTimeStamp, endTimeStamp, sortOrder, getRecordNum);
 262     }
 263
 264     @Override
 265     public List<PdpStatistics> createPdpStatistics(@NonNull final List<PdpStatistics> pdpStatisticsList)
 266             throws PfModelException {
 267         assertInitialized();
 268         return new PdpStatisticsProvider().createPdpStatistics(getPfDao(), pdpStatisticsList);
 269     }
 270
 271     @Override
 272     public List<PdpStatistics> updatePdpStatistics(@NonNull final List<PdpStatistics> pdpStatisticsList)
 273             throws PfModelException {
 274         assertInitialized();
 275         return new PdpStatisticsProvider().updatePdpStatistics(getPfDao(), pdpStatisticsList);
 276     }
 277
 278     @Override
 279     public List<PdpStatistics> deletePdpStatistics(@NonNull final String name, final Date timestamp)
 280             throws PfModelException {
 281         assertInitialized();
 282         return new PdpStatisticsProvider().deletePdpStatistics(getPfDao(), name, timestamp);
 283     }
 284
 285     @Override
 286     public List<PdpPolicyStatus> getAllPolicyStatus() throws PfModelException {
 287         assertInitialized();
 288         return new PdpProvider().getAllPolicyStatus(getPfDao());
 289     }
 290
 291     @Override
 292     public List<PdpPolicyStatus> getAllPolicyStatus(@NonNull ToscaConceptIdentifierOptVersion policy)
 293             throws PfModelException {
 294         assertInitialized();
 295         return new PdpProvider().getAllPolicyStatus(getPfDao(), policy);
 296     }
 297
 298     @Override
 299     public List<PdpPolicyStatus> getGroupPolicyStatus(@NonNull String groupName) throws PfModelException {
 300         assertInitialized();
 301         return new PdpProvider().getGroupPolicyStatus(getPfDao(), groupName);
 302     }
 303
 304     @Override
 305     public void cudPolicyStatus(Collection<PdpPolicyStatus> createObjs, Collection<PdpPolicyStatus> updateObjs,
 306             Collection<PdpPolicyStatus> deleteObjs) {
 307         assertInitialized();
 308         new PdpProvider().cudPolicyStatus(getPfDao(), createObjs, updateObjs, deleteObjs);
 309     }
 310
 311     /**
 312      * Check if the model provider is initialized.
 313      */
 314     private void assertInitialized() {
 315         if (getPfDao() == null) {
 316             String errorMessage = "policy models provider is not initilaized";
 317             throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, errorMessage);
 318         }
 319     }
 320
 321     /**
 322      * Assert that the policy type is not supported in any PDP group.
 323      *
 324      * @param policyTypeIdentifier the policy type identifier
 325      * @throws PfModelException if the policy type is supported in a PDP group
 326      */
 327     private void assertPolicyTypeNotSupportedInPdpGroup(ToscaConceptIdentifier policyTypeIdentifier)
 328             throws PfModelException {
 329         for (PdpGroup pdpGroup : getPdpGroups(null)) {
 330             for (PdpSubGroup pdpSubGroup : pdpGroup.getPdpSubgroups()) {
 331                 if (pdpSubGroup.getSupportedPolicyTypes().contains(policyTypeIdentifier)) {
 332                     throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE,
 333                             "policy type is in use, it is referenced in PDP group " + pdpGroup.getName() + " subgroup "
 334                                     + pdpSubGroup.getPdpType());
 335                 }
 336             }
 337         }
 338     }
 339
 340     /**
 341      * Assert that the policy is not deployed in a PDP group.
 342      *
 343      * @param policyIdentifier the identifier of the policy
 344      * @throws PfModelException thrown if the policy is deployed in a PDP group
 345      */
 346     private void assertPolicyNotDeployedInPdpGroup(final ToscaConceptIdentifier policyIdentifier)
 347             throws PfModelException {
 348         for (PdpGroup pdpGroup : getPdpGroups(null)) {
 349             for (PdpSubGroup pdpSubGroup : pdpGroup.getPdpSubgroups()) {
 350                 if (pdpSubGroup.getPolicies().contains(policyIdentifier)) {
 351                     throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE,
 352                             "policy is in use, it is deployed in PDP group " + pdpGroup.getName() + " subgroup "
 353                                     + pdpSubGroup.getPdpType());
 354                 }
 355             }
 356         }
 357     }
 358 }