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 java.util.Properties;
  29 import javax.ws.rs.core.Response;
  30 import lombok.NonNull;
  31 import org.eclipse.persistence.config.PersistenceUnitProperties;
  32 import org.onap.policy.models.base.PfModelException;
  33 import org.onap.policy.models.base.PfModelRuntimeException;
  34 import org.onap.policy.models.dao.DaoParameters;
  35 import org.onap.policy.models.dao.PfDao;
  36 import org.onap.policy.models.dao.PfDaoFactory;
  37 import org.onap.policy.models.dao.impl.DefaultPfDao;
  38 import org.onap.policy.models.pdp.concepts.Pdp;
  39 import org.onap.policy.models.pdp.concepts.PdpGroup;
  40 import org.onap.policy.models.pdp.concepts.PdpGroupFilter;
  41 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus;
  42 import org.onap.policy.models.pdp.concepts.PdpStatistics;
  43 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
  44 import org.onap.policy.models.pdp.persistence.provider.PdpProvider;
  45 import org.onap.policy.models.pdp.persistence.provider.PdpStatisticsProvider;
  46 import org.onap.policy.models.provider.PolicyModelsProvider;
  47 import org.onap.policy.models.provider.PolicyModelsProviderParameters;
  48 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  49 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
  50 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyFilter;
  51 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType;
  52 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyTypeFilter;
  53 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  54 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplateFilter;
  55 import org.onap.policy.models.tosca.authorative.provider.AuthorativeToscaProvider;
  56 import org.slf4j.Logger;
  57 import org.slf4j.LoggerFactory;
  58
  59 /**
  60  * This class provides an implementation of the Policy Models Provider for the ONAP Policy Framework that works towards
  61  * a relational database.
  62  *
  63  * @author Liam Fallon (liam.fallon@est.tech)
  64  */
  65 public class DatabasePolicyModelsProviderImpl implements PolicyModelsProvider {
  66
  67     private static final Logger LOGGER = LoggerFactory.getLogger(DatabasePolicyModelsProviderImpl.class);
  68
  69     private final PolicyModelsProviderParameters parameters;
  70
  71     // Database connection and the DAO for reading and writing Policy Framework concepts
  72     private PfDao pfDao;
  73
  74     /**
  75      * Constructor that takes the parameters.
  76      *
  77      * @param parameters the parameters for the provider
  78      */
  79     public DatabasePolicyModelsProviderImpl(@NonNull final PolicyModelsProviderParameters parameters) {
  80         this.parameters = parameters;
  81     }
  82
  83     @Override
  84     public void init() throws PfModelException {
  85         LOGGER.debug("opening the database connection to {} using persistence unit {}", parameters.getDatabaseUrl(),
  86                 parameters.getPersistenceUnit());
  87
  88         if (pfDao != null) {
  89             String errorMessage = "provider is already initialized";
  90             LOGGER.warn(errorMessage);
  91             throw new PfModelException(Response.Status.NOT_ACCEPTABLE, errorMessage);
  92         }
  93
  94         // Parameters for the DAO
  95         final DaoParameters daoParameters = new DaoParameters();
  96         daoParameters.setPluginClass(DefaultPfDao.class.getName());
  97         daoParameters.setPersistenceUnit(parameters.getPersistenceUnit());
  98
  99         // @formatter:off
 100         Properties jdbcProperties = new Properties();
 101         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_DRIVER,   parameters.getDatabaseDriver());
 102         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_URL,      parameters.getDatabaseUrl());
 103         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_USER,     parameters.getDatabaseUser());
 104         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_PASSWORD, parameters.getDatabasePassword());
 105         // @formatter:on
 106
 107         daoParameters.setJdbcProperties(jdbcProperties);
 108
 109         try {
 110             pfDao = new PfDaoFactory().createPfDao(daoParameters);
 111             pfDao.init(daoParameters);
 112         } catch (Exception exc) {
 113             String errorMessage = "could not create Data Access Object (DAO) using url \"" + parameters.getDatabaseUrl()
 114                     + "\" and persistence unit \"" + parameters.getPersistenceUnit() + "\"";
 115
 116             this.close();
 117             throw new PfModelException(Response.Status.NOT_ACCEPTABLE, errorMessage, exc);
 118         }
 119     }
 120
 121     @Override
 122     public void close() throws PfModelException {
 123         LOGGER.debug("closing the database connection to {} using persistence unit {}", parameters.getDatabaseUrl(),
 124                 parameters.getPersistenceUnit());
 125
 126         if (pfDao != null) {
 127             pfDao.close();
 128             pfDao = null;
 129         }
 130
 131         LOGGER.debug("closed the database connection to {} using persistence unit {}", parameters.getDatabaseUrl(),
 132                 parameters.getPersistenceUnit());
 133     }
 134
 135     @Override
 136     public List<ToscaServiceTemplate> getServiceTemplateList(final String name, final String version)
 137             throws PfModelException {
 138         assertInitialized();
 139         return new AuthorativeToscaProvider().getServiceTemplateList(pfDao, name, version);
 140     }
 141
 142
 143     @Override
 144     public List<ToscaServiceTemplate> getFilteredServiceTemplateList(@NonNull ToscaServiceTemplateFilter filter)
 145             throws PfModelException {
 146         assertInitialized();
 147         return new AuthorativeToscaProvider().getFilteredServiceTemplateList(pfDao, filter);
 148     }
 149
 150     @Override
 151     public ToscaServiceTemplate createServiceTemplate(@NonNull final ToscaServiceTemplate serviceTemplate)
 152             throws PfModelException {
 153         assertInitialized();
 154         return new AuthorativeToscaProvider().createServiceTemplate(pfDao, serviceTemplate);
 155     }
 156
 157     @Override
 158     public ToscaServiceTemplate updateServiceTemplate(@NonNull final ToscaServiceTemplate serviceTemplate)
 159             throws PfModelException {
 160         assertInitialized();
 161         return new AuthorativeToscaProvider().updateServiceTemplate(pfDao, serviceTemplate);
 162     }
 163
 164     @Override
 165     public ToscaServiceTemplate deleteServiceTemplate(@NonNull final String name, @NonNull final String version)
 166             throws PfModelException {
 167         assertInitialized();
 168
 169         return new AuthorativeToscaProvider().deleteServiceTemplate(pfDao, name, version);
 170     }
 171
 172     @Override
 173     public ToscaServiceTemplate getPolicyTypes(final String name, final String version) throws PfModelException {
 174         assertInitialized();
 175         return new AuthorativeToscaProvider().getPolicyTypes(pfDao, name, version);
 176     }
 177
 178     @Override
 179     public List<ToscaPolicyType> getPolicyTypeList(final String name, final String version) throws PfModelException {
 180         assertInitialized();
 181         return new AuthorativeToscaProvider().getPolicyTypeList(pfDao, name, version);
 182     }
 183
 184     @Override
 185     public ToscaServiceTemplate getFilteredPolicyTypes(@NonNull ToscaPolicyTypeFilter filter) throws PfModelException {
 186         assertInitialized();
 187         return new AuthorativeToscaProvider().getFilteredPolicyTypes(pfDao, filter);
 188     }
 189
 190     @Override
 191     public List<ToscaPolicyType> getFilteredPolicyTypeList(@NonNull ToscaPolicyTypeFilter filter)
 192             throws PfModelException {
 193         assertInitialized();
 194         return new AuthorativeToscaProvider().getFilteredPolicyTypeList(pfDao, filter);
 195     }
 196
 197     @Override
 198     public ToscaServiceTemplate createPolicyTypes(@NonNull final ToscaServiceTemplate serviceTemplate)
 199             throws PfModelException {
 200         assertInitialized();
 201         return new AuthorativeToscaProvider().createPolicyTypes(pfDao, serviceTemplate);
 202     }
 203
 204     @Override
 205     public ToscaServiceTemplate updatePolicyTypes(@NonNull final ToscaServiceTemplate serviceTemplate)
 206             throws PfModelException {
 207         assertInitialized();
 208         return new AuthorativeToscaProvider().updatePolicyTypes(pfDao, serviceTemplate);
 209     }
 210
 211     @Override
 212     public ToscaServiceTemplate deletePolicyType(@NonNull final String name, @NonNull final String version)
 213             throws PfModelException {
 214         assertInitialized();
 215
 216         ToscaConceptIdentifier policyTypeIdentifier = new ToscaConceptIdentifier(name, version);
 217         assertPolicyTypeNotSupportedInPdpGroup(policyTypeIdentifier);
 218
 219         return new AuthorativeToscaProvider().deletePolicyType(pfDao, name, version);
 220     }
 221
 222     @Override
 223     public ToscaServiceTemplate getPolicies(final String name, final String version) throws PfModelException {
 224         assertInitialized();
 225         return new AuthorativeToscaProvider().getPolicies(pfDao, name, version);
 226     }
 227
 228     @Override
 229     public List<ToscaPolicy> getPolicyList(final String name, final String version) throws PfModelException {
 230         assertInitialized();
 231         return new AuthorativeToscaProvider().getPolicyList(pfDao, name, version);
 232     }
 233
 234     @Override
 235     public ToscaServiceTemplate getFilteredPolicies(@NonNull ToscaPolicyFilter filter) throws PfModelException {
 236         assertInitialized();
 237         return new AuthorativeToscaProvider().getFilteredPolicies(pfDao, filter);
 238     }
 239
 240     @Override
 241     public List<ToscaPolicy> getFilteredPolicyList(@NonNull ToscaPolicyFilter filter) throws PfModelException {
 242         assertInitialized();
 243         return new AuthorativeToscaProvider().getFilteredPolicyList(pfDao, filter);
 244     }
 245
 246     @Override
 247     public ToscaServiceTemplate createPolicies(@NonNull final ToscaServiceTemplate serviceTemplate)
 248             throws PfModelException {
 249         assertInitialized();
 250         return new AuthorativeToscaProvider().createPolicies(pfDao, serviceTemplate);
 251     }
 252
 253     @Override
 254     public ToscaServiceTemplate updatePolicies(@NonNull final ToscaServiceTemplate serviceTemplate)
 255             throws PfModelException {
 256         assertInitialized();
 257         return new AuthorativeToscaProvider().updatePolicies(pfDao, serviceTemplate);
 258     }
 259
 260     @Override
 261     public ToscaServiceTemplate deletePolicy(@NonNull final String name, @NonNull final String version)
 262             throws PfModelException {
 263         assertInitialized();
 264
 265         ToscaConceptIdentifier policyIdentifier = new ToscaConceptIdentifier(name, version);
 266         assertPolicyNotDeployedInPdpGroup(policyIdentifier);
 267
 268         return new AuthorativeToscaProvider().deletePolicy(pfDao, name, version);
 269     }
 270
 271     @Override
 272     public List<PdpGroup> getPdpGroups(final String name) throws PfModelException {
 273         assertInitialized();
 274         return new PdpProvider().getPdpGroups(pfDao, name);
 275     }
 276
 277     @Override
 278     public List<PdpGroup> getFilteredPdpGroups(@NonNull PdpGroupFilter filter) throws PfModelException {
 279         assertInitialized();
 280         return new PdpProvider().getFilteredPdpGroups(pfDao, filter);
 281     }
 282
 283     @Override
 284     public List<PdpGroup> createPdpGroups(@NonNull final List<PdpGroup> pdpGroups) throws PfModelException {
 285         assertInitialized();
 286         return new PdpProvider().createPdpGroups(pfDao, pdpGroups);
 287     }
 288
 289     @Override
 290     public List<PdpGroup> updatePdpGroups(@NonNull final List<PdpGroup> pdpGroups) throws PfModelException {
 291         assertInitialized();
 292         return new PdpProvider().updatePdpGroups(pfDao, pdpGroups);
 293     }
 294
 295     @Override
 296     public void updatePdpSubGroup(@NonNull final String pdpGroupName, @NonNull final PdpSubGroup pdpSubGroup)
 297             throws PfModelException {
 298         assertInitialized();
 299         new PdpProvider().updatePdpSubGroup(pfDao, pdpGroupName, pdpSubGroup);
 300     }
 301
 302     @Override
 303     public void updatePdp(@NonNull String pdpGroupName, @NonNull String pdpSubGroup, @NonNull Pdp pdp)
 304             throws PfModelException {
 305         new PdpProvider().updatePdp(pfDao, pdpGroupName, pdpSubGroup, pdp);
 306     }
 307
 308     @Override
 309     public PdpGroup deletePdpGroup(@NonNull final String name) throws PfModelException {
 310         assertInitialized();
 311         return new PdpProvider().deletePdpGroup(pfDao, name);
 312     }
 313
 314     @Override
 315     public List<PdpStatistics> getPdpStatistics(final String name, final Date timestamp) throws PfModelException {
 316         assertInitialized();
 317         return new PdpStatisticsProvider().getPdpStatistics(pfDao, name, timestamp);
 318     }
 319
 320     @Override
 321     public List<PdpStatistics> getFilteredPdpStatistics(final String name, @NonNull final String pdpGroupName,
 322             final String pdpSubGroup, final Date startTimeStamp, final Date endTimeStamp, final String sortOrder,
 323             final int getRecordNum) throws PfModelException {
 324         assertInitialized();
 325         return new PdpStatisticsProvider().getFilteredPdpStatistics(pfDao, name, pdpGroupName, pdpSubGroup,
 326                 startTimeStamp, endTimeStamp, sortOrder, getRecordNum);
 327     }
 328
 329     @Override
 330     public List<PdpStatistics> createPdpStatistics(@NonNull final List<PdpStatistics> pdpStatisticsList)
 331             throws PfModelException {
 332         assertInitialized();
 333         return new PdpStatisticsProvider().createPdpStatistics(pfDao, pdpStatisticsList);
 334     }
 335
 336     @Override
 337     public List<PdpStatistics> updatePdpStatistics(@NonNull final List<PdpStatistics> pdpStatisticsList)
 338             throws PfModelException {
 339         assertInitialized();
 340         return new PdpStatisticsProvider().updatePdpStatistics(pfDao, pdpStatisticsList);
 341     }
 342
 343     @Override
 344     public List<PdpStatistics> deletePdpStatistics(@NonNull final String name, final Date timestamp)
 345             throws PfModelException {
 346         assertInitialized();
 347         return new PdpStatisticsProvider().deletePdpStatistics(pfDao, name, timestamp);
 348     }
 349
 350     @Override
 351     public List<PdpPolicyStatus> getGroupPolicyStatus(@NonNull String groupName)
 352                     throws PfModelException {
 353         assertInitialized();
 354         return new PdpProvider().getGroupPolicyStatus(pfDao, groupName);
 355     }
 356
 357     @Override
 358     public void cudPolicyStatus(Collection<PdpPolicyStatus> createObjs,
 359                     Collection<PdpPolicyStatus> updateObjs, Collection<PdpPolicyStatus> deleteObjs) {
 360         assertInitialized();
 361         new PdpProvider().cudPolicyStatus(pfDao, createObjs, updateObjs, deleteObjs);
 362     }
 363
 364     /**
 365      * Check if the model provider is initialized.
 366      */
 367     private void assertInitialized() {
 368         if (pfDao == null) {
 369             String errorMessage = "policy models provider is not initilaized";
 370             LOGGER.warn(errorMessage);
 371             throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, errorMessage);
 372         }
 373     }
 374
 375     /**
 376      * Assert that the policy type is not supported in any PDP group.
 377      *
 378      * @param policyTypeIdentifier the policy type identifier
 379      * @throws PfModelException if the policy type is supported in a PDP group
 380      */
 381     private void assertPolicyTypeNotSupportedInPdpGroup(ToscaConceptIdentifier policyTypeIdentifier)
 382             throws PfModelException {
 383         for (PdpGroup pdpGroup : getPdpGroups(null)) {
 384             for (PdpSubGroup pdpSubGroup : pdpGroup.getPdpSubgroups()) {
 385                 if (pdpSubGroup.getSupportedPolicyTypes().contains(policyTypeIdentifier)) {
 386                     throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE,
 387                             "policy type is in use, it is referenced in PDP group " + pdpGroup.getName() + " subgroup "
 388                                     + pdpSubGroup.getPdpType());
 389                 }
 390             }
 391         }
 392     }
 393
 394     /**
 395      * Assert that the policy is not deployed in a PDP group.
 396      *
 397      * @param policyIdentifier the identifier of the policy
 398      * @throws PfModelException thrown if the policy is deployed in a PDP group
 399      */
 400     private void assertPolicyNotDeployedInPdpGroup(final ToscaConceptIdentifier policyIdentifier)
 401             throws PfModelException {
 402         for (PdpGroup pdpGroup : getPdpGroups(null)) {
 403             for (PdpSubGroup pdpSubGroup : pdpGroup.getPdpSubgroups()) {
 404                 if (pdpSubGroup.getPolicies().contains(policyIdentifier)) {
 405                     throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE,
 406                             "policy is in use, it is deployed in PDP group " + pdpGroup.getName() + " subgroup "
 407                                     + pdpSubGroup.getPdpType());
 408                 }
 409             }
 410         }
 411     }
 412 }