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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019 Nordix Foundation.
   4  *  Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   5  * ================================================================================
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * SPDX-License-Identifier: Apache-2.0
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.models.provider.impl;
  23
  24 import java.util.Base64;
  25 import java.util.Date;
  26 import java.util.List;
  27 import java.util.Map;
  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.PdpStatistics;
  42 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
  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.provider.PolicyModelsProviderParameters;
  47 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
  48 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyFilter;
  49 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType;
  50 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyTypeFilter;
  51 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  52 import org.onap.policy.models.tosca.authorative.provider.AuthorativeToscaProvider;
  53 import org.onap.policy.models.tosca.legacy.concepts.LegacyGuardPolicyInput;
  54 import org.onap.policy.models.tosca.legacy.concepts.LegacyGuardPolicyOutput;
  55 import org.onap.policy.models.tosca.legacy.concepts.LegacyOperationalPolicy;
  56 import org.onap.policy.models.tosca.legacy.provider.LegacyProvider;
  57 import org.slf4j.Logger;
  58 import org.slf4j.LoggerFactory;
  59
  60 /**
  61  * This class provides an implementation of the Policy Models Provider for the ONAP Policy Framework that works towards
  62  * a relational database.
  63  *
  64  * @author Liam Fallon (liam.fallon@est.tech)
  65  */
  66 public class DatabasePolicyModelsProviderImpl implements PolicyModelsProvider {
  67
  68     private static final Logger LOGGER = LoggerFactory.getLogger(DefaultPfDao.class);
  69
  70     private final PolicyModelsProviderParameters parameters;
  71
  72     // Database connection and the DAO for reading and writing Policy Framework concepts
  73     private PfDao pfDao;
  74
  75     /**
  76      * Constructor that takes the parameters.
  77      *
  78      * @param parameters the parameters for the provider
  79      */
  80     public DatabasePolicyModelsProviderImpl(@NonNull final PolicyModelsProviderParameters parameters) {
  81         this.parameters = parameters;
  82     }
  83
  84     @Override
  85     public void init() throws PfModelException {
  86         LOGGER.debug("opening the database connection to {} using persistence unit {}", parameters.getDatabaseUrl(),
  87                 parameters.getPersistenceUnit());
  88
  89         if (pfDao != null) {
  90             String errorMessage = "provider is already initialized";
  91             LOGGER.warn(errorMessage);
  92             throw new PfModelException(Response.Status.NOT_ACCEPTABLE, errorMessage);
  93         }
  94
  95         // Parameters for the DAO
  96         final DaoParameters daoParameters = new DaoParameters();
  97         daoParameters.setPluginClass(DefaultPfDao.class.getName());
  98         daoParameters.setPersistenceUnit(parameters.getPersistenceUnit());
  99
 100         // Decode the password using Base64
 101         String decodedPassword = new String(Base64.getDecoder().decode(parameters.getDatabasePassword()));
 102
 103         // @formatter:off
 104         Properties jdbcProperties = new Properties();
 105         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_DRIVER,   parameters.getDatabaseDriver());
 106         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_URL,      parameters.getDatabaseUrl());
 107         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_USER,     parameters.getDatabaseUser());
 108         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_PASSWORD, decodedPassword);
 109         // @formatter:on
 110
 111         daoParameters.setJdbcProperties(jdbcProperties);
 112
 113         try {
 114             pfDao = new PfDaoFactory().createPfDao(daoParameters);
 115             pfDao.init(daoParameters);
 116         } catch (Exception exc) {
 117             String errorMessage = "could not create Data Access Object (DAO) using url \"" + parameters.getDatabaseUrl()
 118                     + "\" and persistence unit \"" + parameters.getPersistenceUnit() + "\"";
 119             LOGGER.warn(errorMessage, exc);
 120
 121             this.close();
 122             throw new PfModelException(Response.Status.NOT_ACCEPTABLE, errorMessage, exc);
 123         }
 124     }
 125
 126     @Override
 127     public void close() throws PfModelException {
 128         LOGGER.debug("closing the database connection to {} using persistence unit {}", parameters.getDatabaseUrl(),
 129                 parameters.getPersistenceUnit());
 130
 131         if (pfDao != null) {
 132             pfDao.close();
 133             pfDao = null;
 134         }
 135
 136         LOGGER.debug("closed the database connection to {} using persistence unit {}", parameters.getDatabaseUrl(),
 137                 parameters.getPersistenceUnit());
 138     }
 139
 140     @Override
 141     public ToscaServiceTemplate getPolicyTypes(final String name, final String version) throws PfModelException {
 142         assertInitialized();
 143         return new AuthorativeToscaProvider().getPolicyTypes(pfDao, name, version);
 144     }
 145
 146     @Override
 147     public List<ToscaPolicyType> getPolicyTypeList(final String name, final String version) throws PfModelException {
 148         assertInitialized();
 149         return new AuthorativeToscaProvider().getPolicyTypeList(pfDao, name, version);
 150     }
 151
 152     @Override
 153     public ToscaServiceTemplate getFilteredPolicyTypes(@NonNull ToscaPolicyTypeFilter filter) throws PfModelException {
 154         assertInitialized();
 155         return new AuthorativeToscaProvider().getFilteredPolicyTypes(pfDao, filter);
 156     }
 157
 158     @Override
 159     public List<ToscaPolicyType> getFilteredPolicyTypeList(@NonNull ToscaPolicyTypeFilter filter)
 160             throws PfModelException {
 161         assertInitialized();
 162         return new AuthorativeToscaProvider().getFilteredPolicyTypeList(pfDao, filter);
 163     }
 164
 165     @Override
 166     public ToscaServiceTemplate createPolicyTypes(@NonNull final ToscaServiceTemplate serviceTemplate)
 167             throws PfModelException {
 168         assertInitialized();
 169         return new AuthorativeToscaProvider().createPolicyTypes(pfDao, serviceTemplate);
 170     }
 171
 172     @Override
 173     public ToscaServiceTemplate updatePolicyTypes(@NonNull final ToscaServiceTemplate serviceTemplate)
 174             throws PfModelException {
 175         assertInitialized();
 176         return new AuthorativeToscaProvider().updatePolicyTypes(pfDao, serviceTemplate);
 177     }
 178
 179     @Override
 180     public ToscaServiceTemplate deletePolicyType(@NonNull final String name, @NonNull final String version)
 181             throws PfModelException {
 182         assertInitialized();
 183         return new AuthorativeToscaProvider().deletePolicyType(pfDao, name, version);
 184     }
 185
 186     @Override
 187     public ToscaServiceTemplate getPolicies(final String name, final String version) throws PfModelException {
 188         assertInitialized();
 189         return new AuthorativeToscaProvider().getPolicies(pfDao, name, version);
 190     }
 191
 192     @Override
 193     public List<ToscaPolicy> getPolicyList(final String name, final String version) throws PfModelException {
 194         assertInitialized();
 195         return new AuthorativeToscaProvider().getPolicyList(pfDao, name, version);
 196     }
 197
 198     @Override
 199     public ToscaServiceTemplate getFilteredPolicies(@NonNull ToscaPolicyFilter filter) throws PfModelException {
 200         assertInitialized();
 201         return new AuthorativeToscaProvider().getFilteredPolicies(pfDao, filter);
 202     }
 203
 204     @Override
 205     public List<ToscaPolicy> getFilteredPolicyList(@NonNull ToscaPolicyFilter filter) throws PfModelException {
 206         assertInitialized();
 207         return new AuthorativeToscaProvider().getFilteredPolicyList(pfDao, filter);
 208     }
 209
 210
 211     @Override
 212     public ToscaServiceTemplate createPolicies(@NonNull final ToscaServiceTemplate serviceTemplate)
 213             throws PfModelException {
 214         assertInitialized();
 215         return new AuthorativeToscaProvider().createPolicies(pfDao, serviceTemplate);
 216     }
 217
 218     @Override
 219     public ToscaServiceTemplate updatePolicies(@NonNull final ToscaServiceTemplate serviceTemplate)
 220             throws PfModelException {
 221         assertInitialized();
 222         return new AuthorativeToscaProvider().updatePolicies(pfDao, serviceTemplate);
 223     }
 224
 225     @Override
 226     public ToscaServiceTemplate deletePolicy(@NonNull final String name, @NonNull final String version)
 227             throws PfModelException {
 228         assertInitialized();
 229         return new AuthorativeToscaProvider().deletePolicy(pfDao, name, version);
 230     }
 231
 232     @Override
 233     public LegacyOperationalPolicy getOperationalPolicy(@NonNull final String policyId, final String policyVersion)
 234             throws PfModelException {
 235         assertInitialized();
 236         return new LegacyProvider().getOperationalPolicy(pfDao, policyId, policyVersion);
 237     }
 238
 239     @Override
 240     public LegacyOperationalPolicy createOperationalPolicy(
 241             @NonNull final LegacyOperationalPolicy legacyOperationalPolicy) throws PfModelException {
 242         assertInitialized();
 243         return new LegacyProvider().createOperationalPolicy(pfDao, legacyOperationalPolicy);
 244     }
 245
 246     @Override
 247     public LegacyOperationalPolicy updateOperationalPolicy(
 248             @NonNull final LegacyOperationalPolicy legacyOperationalPolicy) throws PfModelException {
 249         assertInitialized();
 250         return new LegacyProvider().updateOperationalPolicy(pfDao, legacyOperationalPolicy);
 251     }
 252
 253     @Override
 254     public LegacyOperationalPolicy deleteOperationalPolicy(@NonNull final String policyId,
 255             @NonNull final String policyVersion) throws PfModelException {
 256         assertInitialized();
 257         return new LegacyProvider().deleteOperationalPolicy(pfDao, policyId, policyVersion);
 258     }
 259
 260     @Override
 261     public Map<String, LegacyGuardPolicyOutput> getGuardPolicy(@NonNull final String policyId,
 262             final String policyVersion) throws PfModelException {
 263         assertInitialized();
 264         return new LegacyProvider().getGuardPolicy(pfDao, policyId, policyVersion);
 265     }
 266
 267     @Override
 268     public Map<String, LegacyGuardPolicyOutput> createGuardPolicy(
 269             @NonNull final LegacyGuardPolicyInput legacyGuardPolicy) throws PfModelException {
 270         assertInitialized();
 271         return new LegacyProvider().createGuardPolicy(pfDao, legacyGuardPolicy);
 272     }
 273
 274     @Override
 275     public Map<String, LegacyGuardPolicyOutput> updateGuardPolicy(
 276             @NonNull final LegacyGuardPolicyInput legacyGuardPolicy) throws PfModelException {
 277         assertInitialized();
 278         return new LegacyProvider().updateGuardPolicy(pfDao, legacyGuardPolicy);
 279     }
 280
 281     @Override
 282     public Map<String, LegacyGuardPolicyOutput> deleteGuardPolicy(@NonNull final String policyId,
 283             @NonNull final String policyVersion) throws PfModelException {
 284         assertInitialized();
 285         return new LegacyProvider().deleteGuardPolicy(pfDao, policyId, policyVersion);
 286     }
 287
 288     @Override
 289     public List<PdpGroup> getPdpGroups(final String name) throws PfModelException {
 290         assertInitialized();
 291         return new PdpProvider().getPdpGroups(pfDao, name);
 292     }
 293
 294
 295     @Override
 296     public List<PdpGroup> getFilteredPdpGroups(@NonNull PdpGroupFilter filter) throws PfModelException {
 297         assertInitialized();
 298         return new PdpProvider().getFilteredPdpGroups(pfDao, filter);
 299     }
 300
 301     @Override
 302     public List<PdpGroup> createPdpGroups(@NonNull final List<PdpGroup> pdpGroups) throws PfModelException {
 303         assertInitialized();
 304         return new PdpProvider().createPdpGroups(pfDao, pdpGroups);
 305     }
 306
 307     @Override
 308     public List<PdpGroup> updatePdpGroups(@NonNull final List<PdpGroup> pdpGroups) throws PfModelException {
 309         assertInitialized();
 310         return new PdpProvider().updatePdpGroups(pfDao, pdpGroups);
 311     }
 312
 313     @Override
 314     public void updatePdpSubGroup(@NonNull final String pdpGroupName, @NonNull final PdpSubGroup pdpSubGroup)
 315             throws PfModelException {
 316         assertInitialized();
 317         new PdpProvider().updatePdpSubGroup(pfDao, pdpGroupName, pdpSubGroup);
 318     }
 319
 320     @Override
 321     public void updatePdp(@NonNull String pdpGroupName, @NonNull String pdpSubGroup, @NonNull Pdp pdp)
 322             throws PfModelException {
 323         new PdpProvider().updatePdp(pfDao, pdpGroupName, pdpSubGroup, pdp);
 324     }
 325
 326     @Override
 327     public PdpGroup deletePdpGroup(@NonNull final String name) throws PfModelException {
 328         assertInitialized();
 329         return new PdpProvider().deletePdpGroup(pfDao, name);
 330     }
 331
 332     @Override
 333     public List<PdpStatistics> getPdpStatistics(final String name, final Date timestamp) throws PfModelException {
 334         assertInitialized();
 335         return new PdpStatisticsProvider().getPdpStatistics(pfDao, name, timestamp);
 336     }
 337
 338     @Override
 339     public List<PdpStatistics> getFilteredPdpStatistics(final String name, @NonNull final String pdpGroupName,
 340             final String pdpSubGroup, final Date startTimeStamp, final Date endTimeStamp) throws PfModelException {
 341         assertInitialized();
 342         return new PdpStatisticsProvider().getFilteredPdpStatistics(pfDao, name, pdpGroupName, pdpSubGroup,
 343                 startTimeStamp, endTimeStamp);
 344     }
 345
 346     @Override
 347     public List<PdpStatistics> createPdpStatistics(@NonNull final List<PdpStatistics> pdpStatisticsList)
 348             throws PfModelException {
 349         assertInitialized();
 350         return new PdpStatisticsProvider().createPdpStatistics(pfDao, pdpStatisticsList);
 351     }
 352
 353     @Override
 354     public List<PdpStatistics> updatePdpStatistics(@NonNull final List<PdpStatistics> pdpStatisticsList)
 355             throws PfModelException {
 356         assertInitialized();
 357         return new PdpStatisticsProvider().updatePdpStatistics(pfDao, pdpStatisticsList);
 358     }
 359
 360
 361     @Override
 362     public List<PdpStatistics> deletePdpStatistics(@NonNull final String name, final Date timestamp)
 363             throws PfModelException {
 364         assertInitialized();
 365         return new PdpStatisticsProvider().deletePdpStatistics(pfDao, name, timestamp);
 366     }
 367
 368     /**
 369      * Check if the model provider is initialized.
 370      */
 371     private void assertInitialized() {
 372         if (pfDao == null) {
 373             String errorMessage = "policy models provider is not initilaized";
 374             LOGGER.warn(errorMessage);
 375             throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, errorMessage);
 376         }
 377     }
 378 }