gerrit.onap Code Review - policy/drools-pdp.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * policy-persistence
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. 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  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.policy.drools.persistence;
  22
  23 import java.util.Collection;
  24 import java.util.Date;
  25 import java.util.LinkedList;
  26 import java.util.List;
  27
  28 import javax.persistence.EntityManager;
  29 import javax.persistence.EntityManagerFactory;
  30 import javax.persistence.FlushModeType;
  31 import javax.persistence.LockModeType;
  32 import javax.persistence.Query;
  33
  34 import org.openecomp.policy.drools.core.IntegrityMonitorProperties;
  35 import org.openecomp.policy.common.logging.flexlogger.FlexLogger;
  36 import org.openecomp.policy.common.logging.flexlogger.Logger;
  37 import org.openecomp.policy.common.logging.eelf.MessageCodes;
  38
  39
  40 public class JpaDroolsPdpsConnector implements DroolsPdpsConnector {
  41
  42         // get an instance of logger
  43         private static Logger  logger = FlexLogger.getLogger(JpaDroolsPdpsConnector.class);
  44         private EntityManagerFactory emf;
  45
  46
  47         //not sure if we want to use the same entity manager factory for drools session and pass it in here, or create a new one
  48         public JpaDroolsPdpsConnector(EntityManagerFactory emf){
  49                 this.emf = emf;
  50         }
  51         @Override
  52         public Collection<DroolsPdp> getDroolsPdps() {
  53                 //return a list of all the DroolsPdps in the database
  54                 EntityManager em = emf.createEntityManager();
  55                 try {
  56                         em.getTransaction().begin();
  57                         Query droolsPdpsListQuery = em.createQuery("SELECT p FROM DroolsPdpEntity p");
  58                         List<?> droolsPdpsList = droolsPdpsListQuery.setLockMode(LockModeType.NONE).setFlushMode(FlushModeType.COMMIT).getResultList();
  59                         LinkedList<DroolsPdp> droolsPdpsReturnList = new LinkedList<DroolsPdp>();
  60                         for(Object o : droolsPdpsList){
  61                                 if(o instanceof DroolsPdp){
  62                                         //Make sure it is not a cached version
  63                                         em.refresh((DroolsPdpEntity)o);
  64                                         droolsPdpsReturnList.add((DroolsPdp)o);
  65                                         if (logger.isDebugEnabled()) {
  66                                                 DroolsPdp droolsPdp = (DroolsPdp)o;
  67                                                 logger.debug("getDroolsPdps: PDP=" + droolsPdp.getPdpId()
  68                                                                 + ", isDesignated=" + droolsPdp.isDesignated()
  69                                                                 + ", updatedDate=" + droolsPdp.getUpdatedDate()
  70                                                                 + ", priority=" + droolsPdp.getPriority());
  71                                         }
  72                                 }
  73                         }
  74                         try{
  75                         em.getTransaction().commit();
  76                         }catch(Exception e){
  77                                   logger.error
  78                                         (MessageCodes.EXCEPTION_ERROR, e,"Cannot commit getDroolsPdps() transaction");
  79                         }
  80                         return droolsPdpsReturnList;
  81                 } finally {
  82                         cleanup(em, "getDroolsPdps");
  83                 }
  84         }
  85
  86         private boolean nullSafeEquals(Object one, Object two){
  87                 if(one == null && two == null){
  88                         return true;
  89                 }
  90                 if(one != null && two != null){
  91                         return one.equals(two);
  92                 }
  93                 return false;
  94         }
  95
  96         @Override
  97         public void update(DroolsPdp pdp) {
  98
  99                 if (logger.isDebugEnabled()) {
 100                         logger.debug("update: Entering, pdpId=" + pdp.getPdpId());
 101                 }
 102
 103                 //this is to update our own pdp in the database
 104                 EntityManager em = emf.createEntityManager();
 105                 try {
 106                         em.getTransaction().begin();
 107                         Query droolsPdpsListQuery = em.createQuery("SELECT p FROM DroolsPdpEntity p WHERE p.pdpId=:pdpId");
 108                         droolsPdpsListQuery.setParameter("pdpId", pdp.getPdpId());
 109                         List<?> droolsPdpsList = droolsPdpsListQuery.setLockMode(LockModeType.NONE).setFlushMode(FlushModeType.COMMIT).getResultList();
 110                         //em.getTransaction().begin();
 111                         DroolsPdpEntity droolsPdpEntity;
 112                         if(droolsPdpsList.size() == 1 && (droolsPdpsList.get(0) instanceof DroolsPdpEntity)){
 113                                 droolsPdpEntity = (DroolsPdpEntity)droolsPdpsList.get(0);
 114                                 //if(pdp.getSessionId() < 0){
 115                                         //if its less than 0, then we know it is not a real session number so we want to save the one that the database has for us, to avoid information loss
 116                                         //pdp.setSessionId(droolsPdpEntity.getSessionId());
 117                                 //}
 118                                 Date currentDate = new Date();
 119                                 long difference = currentDate.getTime()-droolsPdpEntity.getUpdatedDate().getTime();
 120                                 //just set some kind of default here
 121                                 long pdpTimeout = 15000;
 122                                 try{
 123                                         pdpTimeout = Long.parseLong(IntegrityMonitorProperties.getProperty(IntegrityMonitorProperties.PDP_TIMEOUT));
 124                                 }catch(Exception e){
 125                                           logger.error
 126                                                 (MessageCodes.EXCEPTION_ERROR, e,"Could not get PDP timeout property, using default.");
 127                                 }
 128                                 boolean isCurrent = difference<pdpTimeout;
 129                                 if (logger.isDebugEnabled()) {
 130                                         logger.debug("update: PDP=" + pdp.getPdpId() + ", isCurrent="
 131                                                         + isCurrent + ", difference=" + difference
 132                                                         + ", pdpTimeout=" + pdpTimeout + ", designated="
 133                                                         + droolsPdpEntity.isDesignated());
 134                                 }
 135                         } else {
 136                                 if (logger.isDebugEnabled()) {
 137                                         logger.debug("update: For PDP=" + pdp.getPdpId()
 138                                                         + ", instantiating new DroolsPdpEntity");
 139                                 }
 140                                 droolsPdpEntity = new DroolsPdpEntity();
 141                                 em.persist(droolsPdpEntity);
 142                                 droolsPdpEntity.setPdpId(pdp.getPdpId());
 143                         }
 144                         if(droolsPdpEntity.getPriority() != pdp.getPriority()){
 145                                 droolsPdpEntity.setPriority(pdp.getPriority());
 146                         }
 147                         if(!droolsPdpEntity.getUpdatedDate().equals(pdp.getUpdatedDate())){
 148                                 droolsPdpEntity.setUpdatedDate(pdp.getUpdatedDate());
 149                         }
 150                         if(!droolsPdpEntity.getDesignatedDate().equals(pdp.getDesignatedDate())){
 151                                 droolsPdpEntity.setDesignatedDate(pdp.getDesignatedDate());
 152                         }
 153                         if(!nullSafeEquals(droolsPdpEntity.getSiteName(),pdp.getSiteName())){
 154                                 droolsPdpEntity.setSiteName(pdp.getSiteName());
 155                         }
 156                         List<DroolsSessionEntity> sessionsToAdd = new LinkedList<DroolsSessionEntity>();
 157                         for(DroolsSessionEntity localSession : pdp.getSessions()){
 158                                 boolean found = false;
 159                                 for(DroolsSessionEntity dbSession : droolsPdpEntity.getSessions()){
 160                                         if(localSession.equals(dbSession)){
 161                                                 found = true;
 162                                                 dbSession.setSessionId(localSession.getSessionId());
 163                                         }
 164                                 }
 165                                 if(!found){
 166                                         sessionsToAdd.add(localSession);
 167                                 }
 168
 169                         }
 170                         for(DroolsSessionEntity sessionToAdd : sessionsToAdd){
 171                                 em.persist(sessionToAdd);
 172                                 droolsPdpEntity.getSessions().add(sessionToAdd);
 173                         }
 174
 175
 176                         if(droolsPdpEntity.isDesignated() != pdp.isDesignated()){
 177                                 if (logger.isDebugEnabled()) {
 178                                         logger.debug("update: pdpId=" + pdp.getPdpId()
 179                                                         + ", pdp.isDesignated=" + pdp.isDesignated()
 180                                                         + ", droolsPdpEntity.pdpId="
 181                                                         + droolsPdpEntity.getPdpId()
 182                                                         + ", droolsPdpEntity.isDesignated="
 183                                                         + droolsPdpEntity.isDesignated());
 184                                 }
 185                                 droolsPdpEntity.setDesignated(pdp.isDesignated());
 186                         }
 187                         em.getTransaction().commit();
 188                 } finally {
 189                         cleanup(em, "update");
 190                 }
 191
 192                 if (logger.isDebugEnabled()) {
 193                         logger.debug("update: Exiting");
 194                 }
 195
 196         }
 197
 198         /*
 199          * Note: A side effect of this boolean method is that if the PDP is designated but not current, the
 200          * droolspdpentity.DESIGNATED column will be set to false (the PDP will be un-designated, i.e. marked as
 201          * being in standby mode)
 202          */
 203         @Override
 204         public boolean isPdpCurrent(DroolsPdp pdp) {
 205
 206                 boolean isCurrent = isCurrent(pdp);
 207
 208                 EntityManager em = emf.createEntityManager();
 209                 try{
 210                 if(!isCurrent && pdp.isDesignated()){
 211                         em.getTransaction().begin();
 212                         Query droolsPdpsListQuery = em.createQuery("SELECT p FROM DroolsPdpEntity p WHERE p.pdpId=:pdpId");
 213                         droolsPdpsListQuery.setParameter("pdpId", pdp.getPdpId());
 214                         List<?> droolsPdpsList = droolsPdpsListQuery.setLockMode(LockModeType.NONE).setFlushMode(FlushModeType.COMMIT).getResultList();
 215                         if(droolsPdpsList.size() == 1 && droolsPdpsList.get(0) instanceof DroolsPdpEntity){
 216                                 if (logger.isDebugEnabled()) {
 217                                         logger.debug("isPdpCurrent: PDP=" + pdp.getPdpId() + " designated but not current; setting designated to false");
 218                                 }
 219                                 DroolsPdpEntity droolsPdpEntity = (DroolsPdpEntity)droolsPdpsList.get(0);
 220                                 droolsPdpEntity.setDesignated(false);
 221                                 em.getTransaction().commit();
 222                         } else {
 223                                 logger.warn("isPdpCurrent: PDP=" + pdp.getPdpId() + " is designated but not current; however it does not have a DB entry, so cannot set DESIGNATED to false!");
 224                         }
 225                 } else {
 226                         if (logger.isDebugEnabled()) {
 227                                 logger.debug("isPdpCurrent: For PDP=" + pdp.getPdpId()
 228                                                 + ", designated="
 229                                                 + pdp.isDesignated() + ", isCurrent=" + isCurrent);
 230                         }
 231                 }
 232                 }catch(Exception e){
 233                           logger.error
 234                                 (MessageCodes.EXCEPTION_ERROR, e,"Could not update expired record marked as designated in the database");
 235                 } finally {
 236                         cleanup(em, "isPdpCurrent");
 237                 }
 238                 return isCurrent;
 239
 240         }
 241
 242         @Override
 243         public void setDesignated(DroolsPdp pdp, boolean designated) {
 244
 245                 if (logger.isDebugEnabled()) {
 246                         logger.debug("setDesignated: Entering, pdpId='" + pdp.getPdpId()
 247                                         + "', designated=" + designated);
 248                 }
 249
 250                 EntityManager em = null;
 251                 try {
 252                         em = emf.createEntityManager();
 253                         em.getTransaction().begin();
 254                         Query droolsPdpsListQuery = em
 255                                         .createQuery("SELECT p FROM DroolsPdpEntity p WHERE p.pdpId=:pdpId");
 256                         droolsPdpsListQuery.setParameter("pdpId", pdp.getPdpId());
 257                         List<?> droolsPdpsList = droolsPdpsListQuery.setLockMode(
 258                                         LockModeType.NONE).setFlushMode(FlushModeType.COMMIT).getResultList();
 259                         if (droolsPdpsList.size() == 1
 260                                         && droolsPdpsList.get(0) instanceof DroolsPdpEntity) {
 261                                 DroolsPdpEntity droolsPdpEntity = (DroolsPdpEntity) droolsPdpsList
 262                                                 .get(0);
 263                                 if (logger.isDebugEnabled()) {
 264                                         logger.debug("setDesignated: PDP=" + pdp.getPdpId()
 265                                                         + " found, designated="
 266                                                         + droolsPdpEntity.isDesignated() + ", setting to "
 267                                                         + designated);
 268                                 }
 269                                 droolsPdpEntity.setDesignated(designated);
 270                                 em.getTransaction().commit();
 271                         } else {
 272                                 logger.error("setDesignated: PDP=" + pdp.getPdpId()
 273                                                 + " not in DB; cannot update designation");
 274                         }
 275                 } catch (Exception e) {
 276                         logger.error("setDesignated: Caught Exception, message='"
 277                                         + e.getMessage() + "'");
 278                 } finally {
 279                         cleanup(em, "setDesignated");
 280                 }
 281
 282                 if (logger.isDebugEnabled()) {
 283                         logger.debug("setDesignated: Exiting");
 284                 }
 285
 286         }
 287
 288
 289         @Override
 290         public void standDownPdp(String pdpId) {
 291
 292                 logger.info("standDownPdp: Entering, pdpId='" + pdpId + "'");
 293
 294                 EntityManager em = null;
 295                 try {
 296                         /*
 297                          * Start transaction.
 298                          */
 299                         em = emf.createEntityManager();
 300                         em.getTransaction().begin();
 301
 302                         /*
 303                          * Get droolspdpentity record for this PDP and mark DESIGNATED as
 304                          * false.
 305                          */
 306                         Query droolsPdpsListQuery = em
 307                                         .createQuery("SELECT p FROM DroolsPdpEntity p WHERE p.pdpId=:pdpId");
 308                         droolsPdpsListQuery.setParameter("pdpId", pdpId);
 309                         List<?> droolsPdpsList = droolsPdpsListQuery.setLockMode(
 310                                         LockModeType.NONE).setFlushMode(FlushModeType.COMMIT).getResultList();
 311                         DroolsPdpEntity droolsPdpEntity;
 312                         if (droolsPdpsList.size() == 1
 313                                         && (droolsPdpsList.get(0) instanceof DroolsPdpEntity)) {
 314                                 droolsPdpEntity = (DroolsPdpEntity) droolsPdpsList.get(0);
 315                                 droolsPdpEntity.setDesignated(false);
 316                                 em.persist(droolsPdpEntity);
 317                                 logger.info("standDownPdp: PDP=" + pdpId + " persisted as non-designated.");
 318                         } else {
 319                                 logger.error("standDownPdp: Missing record in droolspdpentity for pdpId="
 320                                                 + pdpId + "; cannot stand down PDP");
 321                         }
 322
 323                         /*
 324                          * End transaction.
 325                          */
 326                         em.getTransaction().commit();
 327                         cleanup(em, "standDownPdp");
 328                         em = null;
 329
 330                         // Keep the election handler in sync with the DB
 331                         DroolsPdpsElectionHandler.setMyPdpDesignated(false);
 332
 333                 } catch (Exception e) {
 334                         logger.error("standDownPdp: Unexpected Exception attempting to mark DESIGNATED as false for droolspdpentity, pdpId="
 335                                         + pdpId
 336                                         + ".  Cannot stand down PDP; message="
 337                                         + e.getMessage());
 338                 } finally {
 339                         cleanup(em, "standDownPdp");
 340                 }
 341
 342                 logger.info("standDownPdp: Exiting");
 343
 344         }
 345
 346         /*
 347          * Determines whether or not a designated PDP has failed.
 348          *
 349          * Note: The update method, which is run periodically by the
 350          * TimerUpdateClass, will un-designate a PDP that is stale.
 351          */
 352         @Override
 353         public boolean hasDesignatedPdpFailed(Collection<DroolsPdp> pdps) {
 354
 355                 if (logger.isDebugEnabled()) {
 356                         logger.debug("hasDesignatedPdpFailed: Entering, pdps.size()="
 357                                         + pdps.size());
 358                 }
 359
 360                 boolean failed = true;
 361                 boolean foundDesignatedPdp = false;
 362
 363                 for (DroolsPdp pdp : pdps) {
 364
 365                         /*
 366                          * Normally, the update method will un-designate any stale PDP, but
 367                          * we check here to see if the PDP has gone stale since the update
 368                          * method was run.
 369                          *
 370                          * Even if we determine that the designated PDP is current, we keep
 371                          * going (we don't break), so we can get visibility into the other
 372                          * PDPs, when in DEBUG mode.
 373                          */
 374                         if (pdp.isDesignated() && isCurrent(pdp)) {
 375                                 if (logger.isDebugEnabled()) {
 376                                         logger.debug("hasDesignatedPdpFailed: Designated PDP="
 377                                                         + pdp.getPdpId() + " is current");
 378                                 }
 379                                 failed = false;
 380                                 foundDesignatedPdp = true;
 381                         } else if (pdp.isDesignated() && !isCurrent(pdp)) {
 382                                 logger.error("hasDesignatedPdpFailed: Designated PDP="
 383                                                 + pdp.getPdpId() + " has failed");
 384                                 foundDesignatedPdp = true;
 385                         } else {
 386                                 if (logger.isDebugEnabled()) {
 387                                         logger.debug("hasDesignatedPdpFailed: PDP="
 388                                                         + pdp.getPdpId() + " is not designated");
 389                                 }
 390                         }
 391                 }
 392
 393                 if (logger.isDebugEnabled()) {
 394                         logger.debug("hasDesignatedPdpFailed: Exiting and returning, foundDesignatedPdp="
 395                                         + foundDesignatedPdp);
 396                 }
 397                 return failed;
 398         }
 399
 400
 401         private boolean isCurrent(DroolsPdp pdp) {
 402
 403                 if (logger.isDebugEnabled()) {
 404                         logger.debug("isCurrent: Entering, pdpId="
 405                                         + pdp.getPdpId());
 406                 }
 407
 408                 boolean current = false;
 409
 410                 // Return if the current PDP is considered "current" based on whatever
 411                 // time box that may be.
 412                 // If the the PDP is not current, we should mark it as not primary in
 413                 // the database
 414                 Date currentDate = new Date();
 415                 long difference = currentDate.getTime()
 416                                 - pdp.getUpdatedDate().getTime();
 417                 // just set some kind of default here
 418                 long pdpTimeout = 15000;
 419                 try {
 420                         pdpTimeout = Long.parseLong(IntegrityMonitorProperties
 421                                         .getProperty(IntegrityMonitorProperties.PDP_TIMEOUT));
 422                         if (logger.isDebugEnabled()) {
 423                                 logger.debug("isCurrent: pdp.timeout=" + pdpTimeout);
 424                         }
 425                 } catch (Exception e) {
 426                           logger.error
 427                                 (MessageCodes.EXCEPTION_ERROR, e,
 428                                         "isCurrent: Could not get PDP timeout property, using default.");
 429                 }
 430                 current = difference < pdpTimeout;
 431
 432                 if (logger.isDebugEnabled()) {
 433                         logger.debug("isCurrent: Exiting, difference="
 434                                         + difference + ", pdpTimeout=" + pdpTimeout
 435                                         + "; returning current=" + current);
 436                 }
 437
 438                 return current;
 439         }
 440
 441
 442         /*
 443          * Currently this method is only used in a JUnit test environment. Gets a
 444          * PDP record from droolspdpentity table.
 445          */
 446         @Override
 447         public DroolsPdpEntity getPdp(String pdpId) {
 448
 449                 if (logger.isDebugEnabled()) {
 450                         logger.debug("getPdp: Entering and getting PDP with pdpId='" + pdpId
 451                                         + "'");
 452                 }
 453
 454                 DroolsPdpEntity droolsPdpEntity = null;
 455
 456                 EntityManager em = null;
 457                 try {
 458                         em = emf.createEntityManager();
 459                         em.getTransaction().begin();
 460                         Query droolsPdpsListQuery = em
 461                                         .createQuery("SELECT p FROM DroolsPdpEntity p WHERE p.pdpId=:pdpId");
 462                         droolsPdpsListQuery.setParameter("pdpId", pdpId);
 463                         List<?> droolsPdpsList = droolsPdpsListQuery.setLockMode(
 464                                         LockModeType.NONE).setFlushMode(FlushModeType.COMMIT).getResultList();
 465                         if (droolsPdpsList.size() == 1
 466                                         && droolsPdpsList.get(0) instanceof DroolsPdpEntity) {
 467                                 droolsPdpEntity = (DroolsPdpEntity) droolsPdpsList.get(0);
 468                                 if (logger.isDebugEnabled()) {
 469                                         logger.debug("getPdp: PDP=" + pdpId
 470                                                         + " found, isDesignated="
 471                                                         + droolsPdpEntity.isDesignated() + ", updatedDate="
 472                                                         + droolsPdpEntity.getUpdatedDate() + ", priority="
 473                                                         + droolsPdpEntity.getPriority());
 474                                 }
 475
 476                                 // Make sure the droolsPdpEntity is not a cached version
 477                                 em.refresh(droolsPdpEntity);
 478
 479                                 em.getTransaction().commit();
 480                         } else {
 481                                 logger.error("getPdp: PDP=" + pdpId + " not found!?");
 482                         }
 483                 } catch (Exception e) {
 484                           logger.error
 485                                 (MessageCodes.EXCEPTION_ERROR, e,"getPdp: Caught Exception attempting to get PDP, message='"
 486                                         + e.getMessage() + "'");
 487                 } finally {
 488                         cleanup(em, "getPdp");
 489                 }
 490
 491                 if (logger.isDebugEnabled()) {
 492                         logger.debug("getPdp: Returning droolsPdpEntity=" + droolsPdpEntity);
 493                 }
 494                 return droolsPdpEntity;
 495
 496         }
 497
 498         /*
 499          * Normally this method should only be used in a JUnit test environment.
 500          * Manually inserts a PDP record in droolspdpentity table.
 501          */
 502         @Override
 503         public void insertPdp(DroolsPdp pdp) {
 504
 505                 logger.info("insertPdp: Entering and manually inserting PDP");
 506
 507                 /*
 508                  * Start transaction
 509                  */
 510                 EntityManager em = emf.createEntityManager();
 511                 try {
 512                         em.getTransaction().begin();
 513
 514                         /*
 515                          * Insert record.
 516                          */
 517                         DroolsPdpEntity droolsPdpEntity = new DroolsPdpEntity();
 518                         em.persist(droolsPdpEntity);
 519                         droolsPdpEntity.setPdpId(pdp.getPdpId());
 520                         droolsPdpEntity.setDesignated(pdp.isDesignated());
 521                         droolsPdpEntity.setPriority(pdp.getPriority());
 522                         droolsPdpEntity.setUpdatedDate(pdp.getUpdatedDate());
 523                         droolsPdpEntity.setSiteName(pdp.getSiteName());
 524
 525                         /*
 526                          * End transaction.
 527                          */
 528                         em.getTransaction().commit();
 529                 } finally {
 530                         cleanup(em, "insertPdp");
 531                 }
 532
 533                 logger.info("insertPdp: Exiting");
 534
 535         }
 536
 537         /*
 538          * Normally this method should only be used in a JUnit test environment.
 539          * Manually deletes all PDP records in droolspdpentity table.
 540          */
 541         @Override
 542         public void deleteAllPdps() {
 543
 544                 logger.info("deleteAllPdps: Entering");
 545
 546                 /*
 547                  * Start transaction
 548                  */
 549                 EntityManager em = emf.createEntityManager();
 550                 try {
 551                         em.getTransaction().begin();
 552
 553                         Query droolsPdpsListQuery = em
 554                                         .createQuery("SELECT p FROM DroolsPdpEntity p");
 555                         @SuppressWarnings("unchecked")
 556                         List<DroolsPdp> droolsPdpsList = droolsPdpsListQuery.setLockMode(
 557                                         LockModeType.NONE).setFlushMode(FlushModeType.COMMIT).getResultList();
 558                         logger.info("deleteAllPdps: Deleting " + droolsPdpsList.size() + " PDPs");
 559                         for (DroolsPdp droolsPdp : droolsPdpsList) {
 560                                 String pdpId = droolsPdp.getPdpId();
 561                                 deletePdp(pdpId);
 562                         }
 563
 564                         /*
 565                          * End transaction.
 566                          */
 567                         em.getTransaction().commit();
 568                 } finally {
 569                         cleanup(em, "deleteAllPdps");
 570                 }
 571
 572                 logger.info("deleteAllPdps: Exiting");
 573
 574         }
 575
 576         /*
 577          * Normally this method should only be used in a JUnit test environment.
 578          * Manually deletes a PDP record in droolspdpentity table.
 579          */
 580         @Override
 581         public void deletePdp(String pdpId) {
 582
 583                 logger.info("deletePdp: Entering and manually deleting pdpId='" + pdpId
 584                                 + "'");
 585
 586                 /*
 587                  * Start transaction
 588                  */
 589                 EntityManager em = emf.createEntityManager();
 590                 try {
 591                         em.getTransaction().begin();
 592
 593                         /*
 594                          * Delete record.
 595                          */
 596                         DroolsPdpEntity droolsPdpEntity = em.find(DroolsPdpEntity.class, pdpId);
 597                         if (droolsPdpEntity != null) {
 598                                 logger.info("deletePdp: Removing PDP");
 599                                 em.remove(droolsPdpEntity);
 600                         } else {
 601                                 logger.info("deletePdp: PDP with ID='" + pdpId
 602                                                 + "' not currently in DB");
 603                         }
 604
 605                         /*
 606                          * End transaction.
 607                          */
 608                         em.getTransaction().commit();
 609                 } finally {
 610                         cleanup(em, "deletePdp");
 611                 }
 612
 613                 logger.info("deletePdp: Exiting");
 614
 615         }
 616
 617         /*
 618          * Normally this method should only be used in a JUnit test environment.
 619          * Manually deletes all records in droolsessionentity table.
 620          */
 621         @Override
 622         public void deleteAllSessions() {
 623
 624                 logger.info("deleteAllSessions: Entering");
 625
 626                 /*
 627                  * Start transaction
 628                  */
 629                 EntityManager em = emf.createEntityManager();
 630
 631                 try {
 632                         em.getTransaction().begin();
 633
 634                         Query droolsSessionListQuery = em
 635                                         .createQuery("SELECT p FROM DroolsSessionEntity p");
 636                         @SuppressWarnings("unchecked")
 637                         List<DroolsSession> droolsSessionsList = droolsSessionListQuery.setLockMode(
 638                                         LockModeType.NONE).setFlushMode(FlushModeType.COMMIT).getResultList();
 639                         logger.info("deleteAllSessions: Deleting " + droolsSessionsList.size() + " Sessions");
 640                         for (DroolsSession droolsSession : droolsSessionsList) {
 641                                 logger.info("deleteAllSessions: Deleting droolsSession with pdpId="
 642                                                 + droolsSession.getPdpId() + " and sessionId="
 643                                                 + droolsSession.getSessionId());
 644                                 em.remove(droolsSession);
 645                         }
 646
 647                         /*
 648                          * End transaction.
 649                          */
 650                         em.getTransaction().commit();
 651                 } finally {
 652                         cleanup(em, "deleteAllSessions");
 653                 }
 654                 logger.info("deleteAllSessions: Exiting");
 655
 656         }
 657
 658
 659         /*
 660          * Close the specified EntityManager, rolling back any pending transaction
 661          *
 662          * @param em the EntityManager to close ('null' is OK)
 663          * @param method the invoking Java method (used for log messages)
 664          */
 665         private static void cleanup(EntityManager em, String method)
 666         {
 667                 if (em != null) {
 668                         if (em.isOpen()) {
 669                                 if (em.getTransaction().isActive()) {
 670                                         // there is an active EntityTransaction -- roll it back
 671                                         try {
 672                                                 em.getTransaction().rollback();
 673                                         } catch (Exception e) {
 674                                                 logger.error(method + ": Caught Exception attempting to rollback EntityTransaction, message='"
 675                                                                                    + e.getMessage() + "'");
 676                                         }
 677                                 }
 678
 679                                 // now, close the EntityManager
 680                                 try {
 681                                         em.close();
 682                                 } catch (Exception e) {
 683                                         logger.error(method + ": Caught Exception attempting to close EntityManager, message='"
 684                                                                            + e.getMessage() + "'");
 685                                 }
 686                         }
 687                 }
 688         }
 689 }