models-dao/src/main/java/org/onap/policy/models/dao/impl/DefaultPfDao.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.dao.impl;
  23
  24 import java.util.Collection;
  25 import java.util.Collections;
  26 import java.util.List;
  27
  28 import javax.persistence.EntityManager;
  29 import javax.persistence.EntityManagerFactory;
  30 import javax.persistence.Persistence;
  31 import javax.ws.rs.core.Response;
  32
  33 import org.onap.policy.models.base.PfConcept;
  34 import org.onap.policy.models.base.PfConceptKey;
  35 import org.onap.policy.models.base.PfModelException;
  36 import org.onap.policy.models.base.PfModelRuntimeException;
  37 import org.onap.policy.models.base.PfReferenceKey;
  38 import org.onap.policy.models.base.PfUtils;
  39 import org.onap.policy.models.dao.DaoParameters;
  40 import org.onap.policy.models.dao.PfDao;
  41 import org.slf4j.Logger;
  42 import org.slf4j.LoggerFactory;
  43
  44 /**
  45  * The Class DefaultPfDao is an JPA implementation of the {@link PfDao} class for Policy Framework concepts
  46  * ({@link PfConcept}). It uses the default JPA implementation in the javax {@link Persistence} class.
  47  */
  48 public class DefaultPfDao implements PfDao {
  49     private static final Logger LOGGER = LoggerFactory.getLogger(DefaultPfDao.class);
  50
  51     // @formatter:off
  52     private static final String NAME           = "name";
  53     private static final String VERSION        = "version";
  54     private static final String PARENT_NAME    = "parentname";
  55     private static final String PARENT_VERSION = "parentversion";
  56     private static final String LOCAL_NAME     = "localname";
  57
  58     private static final String TABLE_TOKEN = "__TABLE__";
  59
  60     private static final String DELETE_FROM_TABLE = "DELETE FROM __TABLE__ c";
  61
  62     private static final String SELECT_FROM_TABLE = "SELECT c FROM __TABLE__ c";
  63
  64     private static final String WHERE      = " WHERE ";
  65     private static final String AND        = " AND ";
  66
  67     private static final String NAME_FILTER           = "c.key.name = :name";
  68     private static final String VERSION_FILTER        = "c.key.version = :version";
  69     private static final String PARENT_NAME_FILTER    = "c.key.parentKeyName = :parentname";
  70     private static final String PARENT_VERSION_FILTER = "c.key.parentKeyVersion = :parentversion";
  71     private static final String LOCAL_NAME_FILTER     = "c.key.localName = :localname";
  72
  73     private static final String DELETE_BY_CONCEPT_KEY =
  74             DELETE_FROM_TABLE + WHERE + NAME_FILTER + AND + VERSION_FILTER;
  75
  76     private static final String DELETE_BY_REFERENCE_KEY =
  77             DELETE_FROM_TABLE + WHERE + PARENT_NAME_FILTER + AND + PARENT_VERSION_FILTER + AND + LOCAL_NAME_FILTER;
  78
  79     private static final String SELECT_ALL_FOR_PARENT =
  80             SELECT_FROM_TABLE + WHERE + PARENT_NAME_FILTER + AND + PARENT_VERSION_FILTER;
  81
  82     private static final String SELECT_ALL_VERSIONS = SELECT_FROM_TABLE + WHERE + NAME_FILTER;
  83
  84     private static final String SELECT_BY_CONCEPT_KEY =
  85             SELECT_FROM_TABLE + WHERE + NAME_FILTER + AND + VERSION_FILTER;
  86
  87     private static final String SELECT_BY_REFERENCE_KEY =
  88             SELECT_FROM_TABLE + WHERE + PARENT_NAME_FILTER + AND + PARENT_VERSION_FILTER + AND + LOCAL_NAME_FILTER;
  89     // @formatter:on
  90
  91     // Entity manager for JPA
  92     private EntityManagerFactory emf = null;
  93
  94     @Override
  95     public void init(final DaoParameters daoParameters) throws PfModelException {
  96         if (daoParameters == null || daoParameters.getPersistenceUnit() == null) {
  97             LOGGER.error("Policy Framework persistence unit parameter not set");
  98             throw new PfModelException(Response.Status.INTERNAL_SERVER_ERROR,
  99                     "Policy Framework persistence unit parameter not set");
 100         }
 101
 102         LOGGER.debug("Creating Policy Framework persistence unit \"{}\" . . .", daoParameters.getPersistenceUnit());
 103         try {
 104             emf = Persistence.createEntityManagerFactory(daoParameters.getPersistenceUnit(),
 105                     daoParameters.getJdbcProperties());
 106         } catch (final Exception ex) {
 107             String errorMessage = "Creation of Policy Framework persistence unit \""
 108                     + daoParameters.getPersistenceUnit() + "\" failed";
 109             LOGGER.warn(errorMessage, ex);
 110             throw new PfModelException(Response.Status.INTERNAL_SERVER_ERROR, errorMessage, ex);
 111         }
 112         LOGGER.debug("Created Policy Framework persistence unit \"{}\"", daoParameters.getPersistenceUnit());
 113     }
 114
 115     /**
 116      * Gets the entity manager for this DAO.
 117      *
 118      * @return the entity manager
 119      */
 120     protected final synchronized EntityManager getEntityManager() {
 121         if (emf == null) {
 122             LOGGER.warn("Policy Framework DAO has not been initialized");
 123             throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR,
 124                     "Policy Framework DAO has not been initialized");
 125         }
 126
 127         return emf.createEntityManager();
 128     }
 129
 130     @Override
 131     public final void close() {
 132         if (emf != null) {
 133             emf.close();
 134         }
 135     }
 136
 137     @Override
 138     public <T extends PfConcept> void create(final T obj) {
 139         if (obj == null) {
 140             return;
 141         }
 142         final EntityManager mg = getEntityManager();
 143         try {
 144             mg.getTransaction().begin();
 145             mg.merge(obj);
 146             mg.getTransaction().commit();
 147         } finally {
 148             mg.close();
 149         }
 150     }
 151
 152     @Override
 153     public <T extends PfConcept> void delete(final T obj) {
 154         if (obj == null) {
 155             return;
 156         }
 157         final EntityManager mg = getEntityManager();
 158         try {
 159             mg.getTransaction().begin();
 160             mg.remove(mg.contains(obj) ? obj : mg.merge(obj));
 161             mg.getTransaction().commit();
 162         } finally {
 163             mg.close();
 164         }
 165     }
 166
 167     @Override
 168     public <T extends PfConcept> void delete(final Class<T> someClass, final PfConceptKey key) {
 169         if (key == null) {
 170             return;
 171         }
 172         final EntityManager mg = getEntityManager();
 173         try {
 174             // @formatter:off
 175             mg.getTransaction().begin();
 176             mg.createQuery(setQueryTable(DELETE_BY_CONCEPT_KEY, someClass), someClass)
 177                 .setParameter(NAME,    key.getName())
 178                 .setParameter(VERSION, key.getVersion())
 179                 .executeUpdate();
 180             mg.getTransaction().commit();
 181             // @formatter:on
 182         } finally {
 183             mg.close();
 184         }
 185     }
 186
 187     @Override
 188     public <T extends PfConcept> void delete(final Class<T> someClass, final PfReferenceKey key) {
 189         if (key == null) {
 190             return;
 191         }
 192         final EntityManager mg = getEntityManager();
 193         try {
 194             // @formatter:off
 195             mg.getTransaction().begin();
 196             mg.createQuery(setQueryTable(DELETE_BY_REFERENCE_KEY, someClass), someClass)
 197                 .setParameter(PARENT_NAME,    key.getParentKeyName())
 198                 .setParameter(PARENT_VERSION, key.getParentKeyVersion())
 199                 .setParameter(LOCAL_NAME,     key.getLocalName())
 200                 .executeUpdate();
 201             mg.getTransaction().commit();
 202             // @formatter:on
 203         } finally {
 204             mg.close();
 205         }
 206     }
 207
 208     @Override
 209     public <T extends PfConcept> void createCollection(final Collection<T> objs) {
 210         if (objs == null || objs.isEmpty()) {
 211             return;
 212         }
 213         final EntityManager mg = getEntityManager();
 214         try {
 215             mg.getTransaction().begin();
 216             for (final T t : objs) {
 217                 mg.merge(t);
 218             }
 219             mg.getTransaction().commit();
 220         } finally {
 221             mg.close();
 222         }
 223     }
 224
 225     @Override
 226     public <T extends PfConcept> void deleteCollection(final Collection<T> objs) {
 227         if (objs == null || objs.isEmpty()) {
 228             return;
 229         }
 230         final EntityManager mg = getEntityManager();
 231         try {
 232             mg.getTransaction().begin();
 233             for (final T t : objs) {
 234                 mg.remove(mg.contains(t) ? t : mg.merge(t));
 235             }
 236             mg.getTransaction().commit();
 237         } finally {
 238             mg.close();
 239         }
 240     }
 241
 242     @Override
 243     public <T extends PfConcept> int deleteByConceptKey(final Class<T> someClass, final Collection<PfConceptKey> keys) {
 244         if (keys == null || keys.isEmpty()) {
 245             return 0;
 246         }
 247         int deletedCount = 0;
 248         final EntityManager mg = getEntityManager();
 249         try {
 250             // @formatter:off
 251             mg.getTransaction().begin();
 252             for (final PfConceptKey key : keys) {
 253                 deletedCount += mg.createQuery(setQueryTable(DELETE_BY_CONCEPT_KEY, someClass), someClass)
 254                     .setParameter(NAME,    key.getName())
 255                     .setParameter(VERSION, key.getVersion())
 256                     .executeUpdate();
 257             }
 258             mg.getTransaction().commit();
 259             // @formatter:on
 260         } finally {
 261             mg.close();
 262         }
 263         return deletedCount;
 264     }
 265
 266     @Override
 267     public <T extends PfConcept> int deleteByReferenceKey(final Class<T> someClass,
 268             final Collection<PfReferenceKey> keys) {
 269         if (keys == null || keys.isEmpty()) {
 270             return 0;
 271         }
 272         int deletedCount = 0;
 273         final EntityManager mg = getEntityManager();
 274         try {
 275             // @formatter:off
 276             mg.getTransaction().begin();
 277             for (final PfReferenceKey key : keys) {
 278                 deletedCount += mg.createQuery(setQueryTable(DELETE_BY_REFERENCE_KEY, someClass), someClass)
 279                     .setParameter(PARENT_NAME,    key.getParentKeyName())
 280                     .setParameter(PARENT_VERSION, key.getParentKeyVersion())
 281                     .setParameter(LOCAL_NAME,     key.getLocalName())
 282                     .executeUpdate();
 283             }
 284             mg.getTransaction().commit();
 285             // @formatter:on
 286         } finally {
 287             mg.close();
 288         }
 289         return deletedCount;
 290     }
 291
 292     @Override
 293     public <T extends PfConcept> void deleteAll(final Class<T> someClass) {
 294         final EntityManager mg = getEntityManager();
 295         try {
 296             mg.getTransaction().begin();
 297             mg.createQuery(setQueryTable(DELETE_FROM_TABLE, someClass), someClass).executeUpdate();
 298             mg.getTransaction().commit();
 299         } finally {
 300             mg.close();
 301         }
 302     }
 303
 304     @Override
 305     public <T extends PfConcept> List<T> getFiltered(final Class<T> someClass, final String name,
 306             final String version) {
 307         if (name == null) {
 308             return getAll(someClass);
 309         }
 310
 311         if (version == null) {
 312             return getAllVersions(someClass, name);
 313         }
 314
 315         T foundConcept = get(someClass, new PfConceptKey(name, version));
 316
 317         return (foundConcept == null ? Collections.emptyList() : Collections.singletonList(foundConcept));
 318     }
 319
 320     @Override
 321     public <T extends PfConcept> T get(final Class<T> someClass, final PfConceptKey key) {
 322         if (someClass == null) {
 323             return null;
 324         }
 325         final EntityManager mg = getEntityManager();
 326         try {
 327             final T t = mg.find(someClass, key);
 328             if (t != null) {
 329                 // This clone is created to force the JPA DAO to recurse down through the object
 330                 try {
 331                     return PfUtils.makeCopy(t);
 332                 } catch (final Exception e) {
 333                     LOGGER.warn("Could not clone object of class \"" + someClass.getName() + "\"", e);
 334                     return null;
 335                 }
 336             } else {
 337                 return null;
 338             }
 339         } finally {
 340             mg.close();
 341         }
 342     }
 343
 344     @Override
 345     public <T extends PfConcept> T get(final Class<T> someClass, final PfReferenceKey key) {
 346         if (someClass == null) {
 347             return null;
 348         }
 349         final EntityManager mg = getEntityManager();
 350         try {
 351             final T t = mg.find(someClass, key);
 352             if (t != null) {
 353                 try {
 354                     return PfUtils.makeCopy(t);
 355                 } catch (final Exception e) {
 356                     LOGGER.warn("Could not clone object of class \"" + someClass.getName() + "\"", e);
 357                     return null;
 358                 }
 359             } else {
 360                 return null;
 361             }
 362         } finally {
 363             mg.close();
 364         }
 365     }
 366
 367     @Override
 368     public <T extends PfConcept> List<T> getAll(final Class<T> someClass) {
 369         if (someClass == null) {
 370             return Collections.emptyList();
 371         }
 372         final EntityManager mg = getEntityManager();
 373         try {
 374             return mg.createQuery(setQueryTable(SELECT_FROM_TABLE, someClass), someClass).getResultList();
 375         } finally {
 376             mg.close();
 377         }
 378     }
 379
 380     @Override
 381     public <T extends PfConcept> List<T> getAll(final Class<T> someClass, final PfConceptKey parentKey) {
 382         if (someClass == null) {
 383             return Collections.emptyList();
 384         }
 385         final EntityManager mg = getEntityManager();
 386         try {
 387             // @formatter:off
 388             return mg.createQuery(setQueryTable(SELECT_ALL_FOR_PARENT, someClass), someClass)
 389                     .setParameter(PARENT_NAME,    parentKey.getName())
 390                     .setParameter(PARENT_VERSION, parentKey.getVersion())
 391                     .getResultList();
 392             // @formatter:on
 393         } finally {
 394             mg.close();
 395         }
 396     }
 397
 398     @Override
 399     public <T extends PfConcept> List<T> getAllVersions(final Class<T> someClass, final String conceptName) {
 400         if (someClass == null || conceptName == null) {
 401             return Collections.emptyList();
 402         }
 403         final EntityManager mg = getEntityManager();
 404         try {
 405             // @formatter:off
 406             return mg.createQuery(setQueryTable(SELECT_ALL_VERSIONS, someClass), someClass)
 407                     .setParameter(NAME, conceptName)
 408                     .getResultList();
 409             // @formatter:on
 410         } finally {
 411             mg.close();
 412         }
 413     }
 414
 415     @Override
 416     public <T extends PfConcept> T getConcept(final Class<T> someClass, final PfConceptKey key) {
 417         if (someClass == null || key == null) {
 418             return null;
 419         }
 420         final EntityManager mg = getEntityManager();
 421         List<T> ret;
 422         try {
 423             // @formatter:off
 424             ret = mg.createQuery(setQueryTable(SELECT_BY_CONCEPT_KEY, someClass), someClass)
 425                     .setParameter(NAME,    key.getName())
 426                     .setParameter(VERSION, key.getVersion())
 427                     .getResultList();
 428             // @formatter:on
 429         } finally {
 430             mg.close();
 431         }
 432
 433         return getSingleResult(someClass, key.getId(), ret);
 434     }
 435
 436     @Override
 437     public <T extends PfConcept> T getConcept(final Class<T> someClass, final PfReferenceKey key) {
 438         if (someClass == null || key == null) {
 439             return null;
 440         }
 441         final EntityManager mg = getEntityManager();
 442         List<T> ret;
 443         try {
 444             // @formatter:off
 445             ret = mg.createQuery(setQueryTable(SELECT_BY_REFERENCE_KEY, someClass), someClass)
 446                     .setParameter(PARENT_NAME,    key.getParentKeyName())
 447                     .setParameter(PARENT_VERSION, key.getParentKeyVersion())
 448                     .setParameter(LOCAL_NAME,     key.getLocalName())
 449                     .getResultList();
 450             // @formatter:on
 451         } finally {
 452             mg.close();
 453         }
 454
 455         return getSingleResult(someClass, key.getId(), ret);
 456     }
 457
 458     @Override
 459     public <T extends PfConcept> T update(final T obj) {
 460         final EntityManager mg = getEntityManager();
 461         T ret;
 462         try {
 463             mg.getTransaction().begin();
 464             ret = mg.merge(obj);
 465             mg.flush();
 466             mg.getTransaction().commit();
 467         } finally {
 468             mg.close();
 469         }
 470         return ret;
 471     }
 472
 473     @Override
 474     public <T extends PfConcept> long size(final Class<T> someClass) {
 475         if (someClass == null) {
 476             return 0;
 477         }
 478         final EntityManager mg = getEntityManager();
 479         long size = 0;
 480         try {
 481             size = mg.createQuery("SELECT COUNT(c) FROM " + someClass.getSimpleName() + " c", Long.class)
 482                     .getSingleResult();
 483         } finally {
 484             mg.close();
 485         }
 486         return size;
 487     }
 488
 489     /**
 490      * Add the table to a query string.
 491      *
 492      * @param queryString the query string
 493      * @param tableClass the class name of the table
 494      * @return the updated query string
 495      */
 496     private <T extends PfConcept> String setQueryTable(final String queryString, final Class<T> tableClass) {
 497         return queryString.replaceAll(TABLE_TOKEN, tableClass.getSimpleName());
 498     }
 499
 500     /**
 501      * Check that a query returned one and only one entry and return that entry.
 502      *
 503      * @param someClass the class being searched for
 504      * @param conceptName the concept name being searched for
 505      * @param resultList the result list returned by the query
 506      * @return the single unique result
 507      */
 508     private <T extends PfConcept> T getSingleResult(final Class<T> someClass, final String searchFilter, List<T> ret) {
 509         if (ret == null || ret.isEmpty()) {
 510             return null;
 511         }
 512         if (ret.size() > 1) {
 513             throw new IllegalArgumentException("More than one result was returned query on " + someClass
 514                     + " with filter " + searchFilter + ": " + ret);
 515         }
 516         return ret.get(0);
 517     }
 518 }