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.controller.test;
  22
  23 import static org.junit.Assert.assertTrue;
  24
  25 import java.io.File;
  26 import java.io.FileInputStream;
  27 import java.io.FileNotFoundException;
  28 import java.io.IOException;
  29 import java.util.ArrayList;
  30 import java.util.Collection;
  31 import java.util.Date;
  32 import java.util.Properties;
  33
  34 import javax.persistence.EntityManager;
  35 import javax.persistence.EntityManagerFactory;
  36 import javax.persistence.EntityTransaction;
  37 import javax.persistence.Persistence;
  38
  39 import org.junit.After;
  40 import org.junit.AfterClass;
  41 import org.junit.Before;
  42 import org.junit.BeforeClass;
  43 import org.junit.Ignore;
  44 import org.junit.Test;
  45 import org.openecomp.policy.common.logging.eelf.PolicyLogger;
  46 import org.openecomp.policy.common.im.AdministrativeStateException;
  47 import org.openecomp.policy.common.im.IntegrityMonitor;
  48 import org.openecomp.policy.common.im.StandbyStatusException;
  49 import org.openecomp.policy.common.im.StateManagement;
  50 import org.openecomp.policy.drools.core.DroolsPDPIntegrityMonitor;
  51 import org.openecomp.policy.drools.core.IntegrityMonitorProperties;
  52 import org.openecomp.policy.drools.core.PolicyContainer;
  53 import org.openecomp.policy.drools.im.PMStandbyStateChangeNotifier;
  54 import org.openecomp.policy.drools.persistence.DroolsPdp;
  55 import org.openecomp.policy.drools.persistence.DroolsPdpEntity;
  56 import org.openecomp.policy.drools.persistence.DroolsPdpImpl;
  57 import org.openecomp.policy.drools.persistence.DroolsPdpsConnector;
  58 import org.openecomp.policy.drools.persistence.DroolsPdpsElectionHandler;
  59 import org.openecomp.policy.drools.persistence.JpaDroolsPdpsConnector;
  60 import org.openecomp.policy.drools.persistence.DroolsPersistenceProperties;
  61 import org.openecomp.policy.drools.persistence.XacmlPersistenceProperties;
  62 import org.openecomp.policy.drools.system.Main;
  63 import org.openecomp.policy.drools.system.PolicyEngine;
  64 import org.apache.commons.lang3.time.DateUtils;
  65
  66 /*
  67  * All JUnits are designed to run in the local development environment
  68  * where they have write privileges and can execute time-sensitive
  69  * tasks.
  70  *
  71  * These tests can be run as JUnits, but there is some issue with running them
  72  * as part of a "mvn install" build.  Also, they take a very long time to run
  73  * due to many real time breaks.  Consequently, they are marked as @Ignore and
  74  * only run from the desktop.
  75  *
  76  */
  77 public class StandbyStateManagementTest {
  78
  79         /*
  80          * Currently, the DroolsPdpsElectionHandler.DesignationWaiter is invoked every ten seconds, starting
  81          * at ten seconds after the minute boundary (e.g. 13:05:10). So, an 80 second sleep should be
  82          * sufficient to ensure that we wait for the DesignationWaiter to do its job, before
  83          * checking the results.
  84          */
  85         long sleepTime = 80000;
  86
  87         /*
  88          * DroolsPdpsElectionHandler runs every ten seconds, so a 15 second sleep should be
  89          * plenty to ensure it has time to re-promote this PDP.
  90          */
  91         long electionWaitSleepTime = 15000;
  92
  93         /*
  94          * Sleep 5 seconds after each test to allow interrupt (shutdown) recovery.
  95          */
  96         long interruptRecoveryTime = 5000;
  97
  98         private static EntityManagerFactory emfx;
  99         private static EntityManagerFactory emfd;
 100         private static EntityManager emx;
 101         private static EntityManager emd;
 102         private static EntityTransaction et;
 103
 104         /*
 105          * See the IntegrityMonitor.getJmxUrl() method for the rationale behind this jmx related processing.
 106          */
 107         @BeforeClass
 108         public static void setUpClass() throws Exception {
 109
 110                 String userDir = System.getProperty("user.dir");
 111                 PolicyLogger.debug("setUpClass: userDir=" + userDir);
 112                 System.setProperty("com.sun.management.jmxremote.port", "9980");
 113                 System.setProperty("com.sun.management.jmxremote.authenticate","false");
 114
 115                 // Make sure path to config directory is set correctly in PolicyContainer.main
 116                 // Also make sure we ignore HTTP server failures resulting from port conflicts.
 117                 PolicyContainer.isUnitTesting = true;
 118
 119         }
 120
 121         @AfterClass
 122         public static void tearDownClass() throws Exception {
 123         }
 124
 125         @Before
 126         public void setUp() throws Exception {
 127                 //Create teh data access for xaml db
 128                 Properties xacmlPersistenceProperties = new Properties();
 129                 xacmlPersistenceProperties.load(new FileInputStream(new File(
 130                                 "src/test/server/config/xacmlPersistence.properties")));
 131
 132                 emfx = Persistence.createEntityManagerFactory("junitXacmlPU", xacmlPersistenceProperties);
 133
 134                 // Create an entity manager to use the DB
 135                 emx = emfx.createEntityManager();
 136
 137                 //Create the data access for drools db
 138                 Properties droolsPersistenceProperties = new Properties();
 139                 droolsPersistenceProperties.load(new FileInputStream(new File(
 140                                 "src/test/server/config/droolsPersistence.properties")));
 141
 142                 emfd = Persistence.createEntityManagerFactory("junitDroolsPU", droolsPersistenceProperties);
 143
 144                 // Create an entity manager to use the DB
 145                 emd = emfd.createEntityManager();
 146         }
 147
 148         @After
 149         public void tearDown() throws Exception {
 150
 151         }
 152
 153         public void cleanXacmlDb(){
 154                 et = emx.getTransaction();
 155
 156                 et.begin();
 157                 // Make sure we leave the DB clean
 158                 emx.createQuery("DELETE FROM StateManagementEntity").executeUpdate();
 159                 emx.createQuery("DELETE FROM ResourceRegistrationEntity").executeUpdate();
 160                 emx.createQuery("DELETE FROM ForwardProgressEntity").executeUpdate();
 161                 emx.createQuery("DELETE FROM IntegrityAuditEntity").executeUpdate();
 162                 emx.flush();
 163                 et.commit();
 164         }
 165
 166         public void cleanDroolsDb(){
 167                 et = emd.getTransaction();
 168
 169                 et.begin();
 170                 // Make sure we leave the DB clean
 171                 emd.createQuery("DELETE FROM DroolsPdpEntity").executeUpdate();
 172                 emd.createQuery("DELETE FROM DroolsSessionEntity").executeUpdate();
 173                 emd.createQuery("DELETE FROM SessionInfo").executeUpdate();
 174                 emd.createQuery("DELETE FROM WorkItemInfo").executeUpdate();
 175                 emd.createQuery("DELETE FROM IntegrityAuditEntity").executeUpdate();
 176                 emd.flush();
 177                 et.commit();
 178         }
 179
 180         @Ignore
 181         @Test
 182         public void runAllTests() throws Exception {
 183                 //testColdStandby();
 184                 //testHotStandby1();
 185                 //testHotStandby2();
 186                 //testLocking1();
 187                 //testLocking2();
 188                 testSanitizeDesignatedList();
 189                 testComputeMostRecentPrimary();
 190                 testComputeDesignatedPdp();
 191         }
 192
 193         //@Ignore
 194         //@Test
 195         public void testSanitizeDesignatedList() throws Exception {
 196
 197                 PolicyLogger.debug("\n\ntestSanitizeDesignatedList: Entering\n\n");
 198
 199                 /*
 200                  * Get a DroolsPdpsConnector
 201                  */
 202                 PolicyLogger.debug("testSanitizeDesignatedList: Reading droolsPersistenceProperties");
 203                 Properties droolsPersistenceProperties = new Properties();
 204                 droolsPersistenceProperties.load(new FileInputStream(new File(
 205                                 "src/test/server/config/droolsPersistence.properties")));
 206                 DroolsPersistenceProperties.initProperties(droolsPersistenceProperties);
 207
 208                 PolicyLogger.debug("testSanitizeDesignatedList: Creating emfDrools");
 209                 EntityManagerFactory emfDrools = Persistence.createEntityManagerFactory(
 210                                 "junitDroolsPU", droolsPersistenceProperties);
 211
 212                 DroolsPdpsConnector droolsPdpsConnector = new JpaDroolsPdpsConnector(emfDrools);
 213
 214                 /*
 215                  * Create 4 pdpd all not designated
 216                  */
 217                 DroolsPdp pdp1 = new DroolsPdpImpl("pdp1", false, 4, new Date());
 218                 DroolsPdp pdp2 = new DroolsPdpImpl("pdp2", false, 4, new Date());
 219                 DroolsPdp pdp3 = new DroolsPdpImpl("pdp3", false, 4, new Date());
 220                 DroolsPdp pdp4 = new DroolsPdpImpl("pdp4", false, 4, new Date());
 221
 222                 ArrayList<DroolsPdp> listOfDesignated = new ArrayList<DroolsPdp>();
 223                 listOfDesignated.add(pdp1);
 224                 listOfDesignated.add(pdp2);
 225                 listOfDesignated.add(pdp3);
 226                 listOfDesignated.add(pdp4);
 227
 228                 DroolsPDPIntegrityMonitor droolsPDPIntegrityMonitor;
 229                 try{
 230                         droolsPDPIntegrityMonitor = DroolsPDPIntegrityMonitor.init("src/test/server/config");
 231                 }catch(Exception e){
 232                         //If it already exists, just get it
 233                         droolsPDPIntegrityMonitor = DroolsPDPIntegrityMonitor.getInstance();
 234                 }
 235                 DroolsPdpsElectionHandler droolsPdpsElectionHandler =  new DroolsPdpsElectionHandler(droolsPdpsConnector, pdp1, droolsPDPIntegrityMonitor);
 236
 237                 listOfDesignated = droolsPdpsElectionHandler.santizeDesignatedList(listOfDesignated);
 238
 239                 PolicyLogger.debug("\n\ntestSanitizeDesignatedList: listOfDesignated.size = " + listOfDesignated.size() + "\n\n");
 240
 241                 assertTrue(listOfDesignated.size()==4);
 242
 243                 /*
 244                  * Now make 2 designated
 245                  */
 246                 pdp1.setDesignated(true);
 247                 pdp2.setDesignated(true);
 248
 249                 listOfDesignated = droolsPdpsElectionHandler.santizeDesignatedList(listOfDesignated);
 250
 251                 PolicyLogger.debug("\n\ntestSanitizeDesignatedList: listOfDesignated.size after 2 designated = " + listOfDesignated.size() + "\n\n");
 252
 253                 assertTrue(listOfDesignated.size()==2);
 254                 assertTrue(listOfDesignated.contains(pdp1));
 255                 assertTrue(listOfDesignated.contains(pdp2));
 256
 257                 /*
 258                  * Now all are designated.  But, we have to add back the previously non-designated nodes
 259                  */
 260                 pdp3.setDesignated(true);
 261                 pdp4.setDesignated(true);
 262                 listOfDesignated.add(pdp3);
 263                 listOfDesignated.add(pdp4);
 264
 265                 listOfDesignated = droolsPdpsElectionHandler.santizeDesignatedList(listOfDesignated);
 266
 267                 PolicyLogger.debug("\n\ntestSanitizeDesignatedList: listOfDesignated.size after all designated = " + listOfDesignated.size() + "\n\n");
 268
 269                 assertTrue(listOfDesignated.size()==4);
 270
 271         }
 272
 273         //@Ignore
 274         //@Test
 275         public void testComputeMostRecentPrimary() throws Exception {
 276
 277                 PolicyLogger.debug("\n\ntestComputeMostRecentPrimary: Entering\n\n");
 278
 279                 /*
 280                  * Get a DroolsPdpsConnector
 281                  */
 282                 PolicyLogger.debug("testComputeMostRecentPrimary: Reading droolsPersistenceProperties");
 283                 Properties droolsPersistenceProperties = new Properties();
 284                 droolsPersistenceProperties.load(new FileInputStream(new File(
 285                                 "src/test/server/config/droolsPersistence.properties")));
 286                 DroolsPersistenceProperties.initProperties(droolsPersistenceProperties);
 287
 288                 PolicyLogger.debug("testComputeMostRecentPrimary: Creating emfDrools");
 289                 EntityManagerFactory emfDrools = Persistence.createEntityManagerFactory(
 290                                 "junitDroolsPU", droolsPersistenceProperties);
 291
 292                 DroolsPdpsConnector droolsPdpsConnector = new JpaDroolsPdpsConnector(emfDrools);
 293
 294                 /*
 295                  * Create 4 pdpd all not designated
 296                  */
 297                 long designatedDateMS = new Date().getTime();
 298                 DroolsPdp pdp1 = new DroolsPdpImpl("pdp1", false, 4, new Date());
 299                 pdp1.setDesignatedDate(new Date(designatedDateMS - 2));
 300
 301                 DroolsPdp pdp2 = new DroolsPdpImpl("pdp2", false, 4, new Date());
 302                 //oldest
 303                 pdp2.setDesignatedDate(new Date(designatedDateMS - 3));
 304
 305                 DroolsPdp pdp3 = new DroolsPdpImpl("pdp3", false, 4, new Date());
 306                 pdp3.setDesignatedDate(new Date(designatedDateMS - 1));
 307
 308                 DroolsPdp pdp4 = new DroolsPdpImpl("pdp4", false, 4, new Date());
 309                 //most recent
 310                 pdp4.setDesignatedDate(new Date(designatedDateMS));
 311
 312                 ArrayList<DroolsPdp> listOfAllPdps = new ArrayList<DroolsPdp>();
 313                 listOfAllPdps.add(pdp1);
 314                 listOfAllPdps.add(pdp2);
 315                 listOfAllPdps.add(pdp3);
 316                 listOfAllPdps.add(pdp4);
 317
 318
 319                 ArrayList<DroolsPdp> listOfDesignated = new ArrayList<DroolsPdp>();
 320                 listOfDesignated.add(pdp1);
 321                 listOfDesignated.add(pdp2);
 322                 listOfDesignated.add(pdp3);
 323                 listOfDesignated.add(pdp4);
 324
 325
 326                 /*
 327                  * Because the way we sanitize the listOfDesignated, it will always contain all hot standby
 328                  * or all designated members.
 329                  */
 330                 DroolsPDPIntegrityMonitor droolsPDPIntegrityMonitor;
 331                 try{
 332                         droolsPDPIntegrityMonitor = DroolsPDPIntegrityMonitor.init("src/test/server/config");
 333                 }catch(Exception e){
 334                         //If it already exists, just get it
 335                         droolsPDPIntegrityMonitor = DroolsPDPIntegrityMonitor.getInstance();
 336                 }
 337                 DroolsPdpsElectionHandler droolsPdpsElectionHandler =  new DroolsPdpsElectionHandler(droolsPdpsConnector, pdp1, droolsPDPIntegrityMonitor);
 338
 339                 DroolsPdp mostRecentPrimary = droolsPdpsElectionHandler.computeMostRecentPrimary(listOfAllPdps, listOfDesignated);
 340
 341                 PolicyLogger.debug("\n\ntestComputeMostRecentPrimary: mostRecentPrimary.getPdpId() = " + mostRecentPrimary.getPdpId() + "\n\n");
 342
 343                 /*
 344                  * If all of the pdps are included in the listOfDesignated and none are designated, it will choose
 345                  * the one which has the most recent designated date.
 346                  */
 347                 assertTrue(mostRecentPrimary.getPdpId().equals("pdp4"));
 348
 349                 /*
 350                  * Now let's designate all of those on the listOfDesignated.  It will choose the first one designated
 351                  */
 352                 pdp1.setDesignated(true);
 353                 pdp2.setDesignated(true);
 354                 pdp3.setDesignated(true);
 355                 pdp4.setDesignated(true);
 356
 357                 mostRecentPrimary = droolsPdpsElectionHandler.computeMostRecentPrimary(listOfAllPdps, listOfDesignated);
 358
 359                 PolicyLogger.debug("\n\ntestComputeMostRecentPrimary: All designated all on list, mostRecentPrimary.getPdpId() = " + mostRecentPrimary.getPdpId() + "\n\n");
 360
 361                 /*
 362                  * If all of the pdps are included in the listOfDesignated and all are designated, it will choose
 363                  * the one which was designated first
 364                  */
 365                 assertTrue(mostRecentPrimary.getPdpId().equals("pdp2"));
 366
 367                 /*
 368                  * Now we will designate only 2 and put just them in the listOfDesignated.  The algorithm will now
 369                  * look for the most recently designated pdp which is not currently designated.
 370                  */
 371                 pdp3.setDesignated(false);
 372                 pdp4.setDesignated(false);
 373
 374                 listOfDesignated.remove(pdp3);
 375                 listOfDesignated.remove(pdp4);
 376
 377                 mostRecentPrimary = droolsPdpsElectionHandler.computeMostRecentPrimary(listOfAllPdps, listOfDesignated);
 378
 379                 PolicyLogger.debug("\n\ntestComputeMostRecentPrimary: mostRecentPrimary.getPdpId() = " + mostRecentPrimary.getPdpId() + "\n\n");
 380
 381                 assertTrue(mostRecentPrimary.getPdpId().equals("pdp4"));
 382
 383
 384                 /*
 385                  * Now we will have none designated and put two of them in the listOfDesignated.  The algorithm will now
 386                  * look for the most recently designated pdp regardless of whether it is currently marked as designated.
 387                  */
 388                 pdp1.setDesignated(false);
 389                 pdp2.setDesignated(false);
 390
 391                 mostRecentPrimary = droolsPdpsElectionHandler.computeMostRecentPrimary(listOfAllPdps, listOfDesignated);
 392
 393                 PolicyLogger.debug("\n\ntestComputeMostRecentPrimary: 2 on list mostRecentPrimary.getPdpId() = " + mostRecentPrimary.getPdpId() + "\n\n");
 394
 395                 assertTrue(mostRecentPrimary.getPdpId().equals("pdp4"));
 396
 397                 /*
 398                  * If we have only one pdp on in the listOfDesignated, the most recently designated pdp will be chosen, regardless
 399                  * of its designation status
 400                  */
 401                 listOfDesignated.remove(pdp1);
 402
 403                 mostRecentPrimary = droolsPdpsElectionHandler.computeMostRecentPrimary(listOfAllPdps, listOfDesignated);
 404
 405                 PolicyLogger.debug("\n\ntestComputeMostRecentPrimary: 1 on list mostRecentPrimary.getPdpId() = " + mostRecentPrimary.getPdpId() + "\n\n");
 406
 407                 assertTrue(mostRecentPrimary.getPdpId().equals("pdp4"));
 408
 409                 /*
 410                  * Finally, if none are on the listOfDesignated, it will again choose the most recently designated pdp.
 411                  */
 412                 listOfDesignated.remove(pdp2);
 413
 414                 mostRecentPrimary = droolsPdpsElectionHandler.computeMostRecentPrimary(listOfAllPdps, listOfDesignated);
 415
 416                 PolicyLogger.debug("\n\ntestComputeMostRecentPrimary: 0 on list mostRecentPrimary.getPdpId() = " + mostRecentPrimary.getPdpId() + "\n\n");
 417
 418                 assertTrue(mostRecentPrimary.getPdpId().equals("pdp4"));
 419
 420         }
 421
 422         //@Ignore
 423         //@Test
 424         public void testComputeDesignatedPdp() throws Exception{
 425
 426                 PolicyLogger.debug("\n\ntestComputeDesignatedPdp: Entering\n\n");
 427
 428                 /*
 429                  * Get a DroolsPdpsConnector
 430                  */
 431                 PolicyLogger.debug("testComputeDesignatedPdp: Reading droolsPersistenceProperties");
 432                 Properties droolsPersistenceProperties = new Properties();
 433                 droolsPersistenceProperties.load(new FileInputStream(new File(
 434                                 "src/test/server/config/droolsPersistence.properties")));
 435                 DroolsPersistenceProperties.initProperties(droolsPersistenceProperties);
 436
 437                 PolicyLogger.debug("testComputeDesignatedPdp: Creating emfDrools");
 438                 EntityManagerFactory emfDrools = Persistence.createEntityManagerFactory(
 439                                 "junitDroolsPU", droolsPersistenceProperties);
 440
 441                 DroolsPdpsConnector droolsPdpsConnector = new JpaDroolsPdpsConnector(emfDrools);
 442
 443                 /*
 444                  * Create 4 pdpd all not designated.  Two on site1. Two on site2
 445                  */
 446                 long designatedDateMS = new Date().getTime();
 447                 DroolsPdp pdp1 = new DroolsPdpImpl("pdp1", false, 4, new Date());
 448                 pdp1.setDesignatedDate(new Date(designatedDateMS - 2));
 449                 pdp1.setSiteName("site1");
 450
 451                 DroolsPdp pdp2 = new DroolsPdpImpl("pdp2", false, 4, new Date());
 452                 pdp2.setDesignatedDate(new Date(designatedDateMS - 3));
 453                 pdp2.setSiteName("site1");
 454
 455                 //oldest
 456                 DroolsPdp pdp3 = new DroolsPdpImpl("pdp3", false, 4, new Date());
 457                 pdp3.setDesignatedDate(new Date(designatedDateMS - 4));
 458                 pdp3.setSiteName("site2");
 459
 460                 DroolsPdp pdp4 = new DroolsPdpImpl("pdp4", false, 4, new Date());
 461                 //most recent
 462                 pdp4.setDesignatedDate(new Date(designatedDateMS));
 463                 pdp4.setSiteName("site2");
 464
 465                 ArrayList<DroolsPdp> listOfAllPdps = new ArrayList<DroolsPdp>();
 466                 listOfAllPdps.add(pdp1);
 467                 listOfAllPdps.add(pdp2);
 468                 listOfAllPdps.add(pdp3);
 469                 listOfAllPdps.add(pdp4);
 470
 471
 472                 ArrayList<DroolsPdp> listOfDesignated = new ArrayList<DroolsPdp>();
 473
 474                 /*
 475                  * We will first test an empty listOfDesignated. As we know from the previous JUnit,
 476                  * the pdp with the most designated date will be chosen for mostRecentPrimary
 477                  */
 478
 479                 DroolsPDPIntegrityMonitor droolsPDPIntegrityMonitor;
 480                 try{
 481                         droolsPDPIntegrityMonitor = DroolsPDPIntegrityMonitor.init("src/test/server/config");
 482                 }catch(Exception e){
 483                         //If it already exists, just get it
 484                         droolsPDPIntegrityMonitor = DroolsPDPIntegrityMonitor.getInstance();
 485                 }
 486                 DroolsPdpsElectionHandler droolsPdpsElectionHandler =  new DroolsPdpsElectionHandler(droolsPdpsConnector, pdp1, droolsPDPIntegrityMonitor);
 487
 488                 DroolsPdp mostRecentPrimary = pdp4;
 489
 490                 DroolsPdp designatedPdp = droolsPdpsElectionHandler.computeDesignatedPdp(listOfDesignated, mostRecentPrimary);
 491
 492                 /*
 493                  * The designatedPdp should be null
 494                  */
 495                 assertTrue(designatedPdp==null);
 496
 497                 /*
 498                  * Now let's try having only one pdp in listOfDesignated, but not in the same site as the most recent primary
 499                  */
 500
 501                 listOfDesignated.add(pdp2);
 502
 503                 designatedPdp = droolsPdpsElectionHandler.computeDesignatedPdp(listOfDesignated, mostRecentPrimary);
 504
 505                 /*
 506                  * Now the designatedPdp should be the one and only selection in the listOfDesignated
 507                  */
 508                 assertTrue(designatedPdp.getPdpId().equals(pdp2.getPdpId()));
 509
 510                 /*
 511                  * Now let's put 2 pdps in the listOfDesignated, neither in the same site as the mostRecentPrimary
 512                  */
 513                 listOfDesignated.add(pdp1);
 514
 515                 designatedPdp = droolsPdpsElectionHandler.computeDesignatedPdp(listOfDesignated, mostRecentPrimary);
 516
 517                 /*
 518                  * The designatedPdp should now be the one with the lowest lexiographic score - pdp1
 519                  */
 520                 assertTrue(designatedPdp.getPdpId().equals(pdp1.getPdpId()));
 521
 522                 /*
 523                  * Finally, we will have 2 pdps in the listOfDesignated, one in the same site with the mostRecentPrimary
 524                  */
 525                 listOfDesignated.remove(pdp1);
 526                 listOfDesignated.add(pdp3);
 527
 528                 designatedPdp = droolsPdpsElectionHandler.computeDesignatedPdp(listOfDesignated, mostRecentPrimary);
 529
 530                 /*
 531                  * The designatedPdp should now be the one on the same site as the mostRecentPrimary
 532                  */
 533                 assertTrue(designatedPdp.getPdpId().equals(pdp3.getPdpId()));
 534         }
 535
 536
 537         //@Ignore
 538         //@Test
 539         public void testColdStandby() throws Exception {
 540
 541                 PolicyLogger.debug("\n\ntestColdStandby: Entering\n\n");
 542                 cleanXacmlDb();
 543                 cleanDroolsDb();
 544
 545                 PolicyLogger.debug("testColdStandby: Reading IntegrityMonitorProperties");
 546                 Properties integrityMonitorProperties = new Properties();
 547                 integrityMonitorProperties.load(new FileInputStream(new File(
 548                                 "src/test/server/config/IntegrityMonitor.properties")));
 549                 IntegrityMonitorProperties.initProperties(integrityMonitorProperties);
 550                 String thisPdpId = IntegrityMonitorProperties
 551                                 .getProperty(IntegrityMonitorProperties.PDP_INSTANCE_ID);
 552
 553                 PolicyLogger.debug("testColdStandby: Reading xacmlPersistenceProperties");
 554                 Properties xacmlPersistenceProperties = new Properties();
 555                 xacmlPersistenceProperties.load(new FileInputStream(new File(
 556                                 "src/test/server/config/xacmlPersistence.properties")));
 557                 XacmlPersistenceProperties.initProperties(xacmlPersistenceProperties);
 558
 559                 PolicyLogger.debug("testColdStandby: Creating emfXacml");
 560                 EntityManagerFactory emfXacml = Persistence.createEntityManagerFactory(
 561                                 "junitXacmlPU", xacmlPersistenceProperties);
 562
 563                 PolicyLogger.debug("testColdStandby: Reading droolsPersistenceProperties");
 564                 Properties droolsPersistenceProperties = new Properties();
 565                 droolsPersistenceProperties.load(new FileInputStream(new File(
 566                                 "src/test/server/config/droolsPersistence.properties")));
 567                 DroolsPersistenceProperties.initProperties(droolsPersistenceProperties);
 568
 569                 PolicyLogger.debug("testColdStandby: Creating emfDrools");
 570                 EntityManagerFactory emfDrools = Persistence.createEntityManagerFactory(
 571                                 "junitDroolsPU", droolsPersistenceProperties);
 572
 573                 DroolsPdpsConnector conn = new JpaDroolsPdpsConnector(emfDrools);
 574
 575                 PolicyLogger.debug("testColdStandby: Cleaning up tables");
 576                 conn.deleteAllSessions();
 577                 conn.deleteAllPdps();
 578
 579                 PolicyLogger.debug("testColdStandby: Inserting PDP=" + thisPdpId + " as designated");
 580                 DroolsPdp pdp = new DroolsPdpImpl(thisPdpId, true, 4, new Date());
 581                 conn.insertPdp(pdp);
 582                 DroolsPdpEntity droolsPdpEntity = conn.getPdp(thisPdpId);
 583                 PolicyLogger.debug("testColdStandby: After insertion, DESIGNATED="
 584                                 + droolsPdpEntity.isDesignated() + " for PDP=" + thisPdpId);
 585                 assertTrue(droolsPdpEntity.isDesignated() == true);
 586
 587                 /*
 588                  * When the Standby Status changes (from providingservice) to hotstandby
 589                  * or coldstandby,the Active/Standby selection algorithm must stand down
 590                  * if thePDP-D is currently the lead/active node and allow another PDP-D
 591                  * to take over.
 592                  *
 593                  * It must also call lock on all engines in the engine management.
 594                  *
 595                  * Yes, this is kludgy, but we have a chicken and egg problem here: we
 596                  * need a StateManagement object to invoke the
 597                  * deleteAllStateManagementEntities method.
 598                  */
 599                 PolicyLogger.debug("testColdStandby: Instantiating stateManagement object");
 600                 StateManagement sm = new StateManagement(emfXacml, "dummy");
 601                 sm.deleteAllStateManagementEntities();
 602                 sm = new StateManagement(emfXacml, thisPdpId);
 603                 PMStandbyStateChangeNotifier pmStandbyStateChangeNotifier = new PMStandbyStateChangeNotifier();
 604                 sm.addObserver(pmStandbyStateChangeNotifier);
 605
 606                 // Artificially putting a PDP into service is really a two step process, 1)
 607                 // inserting it as designated and 2) promoting it so that its standbyStatus
 608                 // is providing service.
 609
 610                 PolicyLogger.debug("testColdStandby: Running policy-management.Main class");
 611                 PolicyManagementRunner policyManagementRunner = new PolicyManagementRunner();
 612                 policyManagementRunner.start();
 613
 614                 PolicyLogger.debug("testColdStandby: Runner started; Sleeping "
 615                                 + interruptRecoveryTime + "ms before promoting PDP="
 616                                 + thisPdpId);
 617                 Thread.sleep(interruptRecoveryTime);
 618
 619                 PolicyLogger.debug("testColdStandby: Promoting PDP=" + thisPdpId);
 620                 sm.promote();
 621
 622                 String standbyStatus = sm.getStandbyStatus(thisPdpId);
 623                 PolicyLogger.debug("testColdStandby: Before locking, PDP=" + thisPdpId + " has standbyStatus="
 624                                 + standbyStatus);
 625
 626                 PolicyLogger.debug("testColdStandby: Locking sm");
 627                 sm.lock();
 628
 629                 Thread.sleep(interruptRecoveryTime);
 630                 /*
 631                  * Verify that the PDP is no longer designated.
 632                  */
 633                 droolsPdpEntity = conn.getPdp(thisPdpId);
 634                 PolicyLogger.debug("testColdStandby: After lock sm.lock() invoked, DESIGNATED="
 635                                 + droolsPdpEntity.isDesignated() + " for PDP=" + thisPdpId);
 636                 assertTrue(droolsPdpEntity.isDesignated() == false);
 637
 638                 PolicyLogger.debug("testColdStandby: Stopping policyManagementRunner");
 639                 //policyManagementRunner.stopRunner();
 640
 641                 PolicyLogger.debug("\n\ntestColdStandby: Exiting\n\n");
 642                 Thread.sleep(interruptRecoveryTime);
 643
 644         }
 645
 646         /*
 647          * Tests hot standby when there is only one PDP.
 648          */
 649         //@Ignore
 650         //@Test
 651         public void testHotStandby1() throws Exception {
 652
 653                 PolicyLogger.debug("\n\ntestHotStandby1: Entering\n\n");
 654                 cleanXacmlDb();
 655                 cleanDroolsDb();
 656
 657                 PolicyLogger.debug("testHotStandby1: Reading IntegrityMonitorProperties");
 658                 Properties integrityMonitorProperties = new Properties();
 659                 integrityMonitorProperties.load(new FileInputStream(new File(
 660                                 "src/test/server/config/IntegrityMonitor.properties")));
 661                 IntegrityMonitorProperties.initProperties(integrityMonitorProperties);
 662                 String thisPdpId = IntegrityMonitorProperties
 663                                 .getProperty(IntegrityMonitorProperties.PDP_INSTANCE_ID);
 664
 665                 PolicyLogger.debug("testHotStandby1: Reading xacmlPersistenceProperties");
 666                 Properties xacmlPersistenceProperties = new Properties();
 667                 xacmlPersistenceProperties.load(new FileInputStream(new File(
 668                                 "src/test/server/config/xacmlPersistence.properties")));
 669                 XacmlPersistenceProperties.initProperties(xacmlPersistenceProperties);
 670
 671                 PolicyLogger.debug("testHotStandby1: Creating emfXacml");
 672                 EntityManagerFactory emfXacml = Persistence.createEntityManagerFactory(
 673                                 "junitXacmlPU", xacmlPersistenceProperties);
 674
 675                 PolicyLogger.debug("testHotStandby1: Reading droolsPersistenceProperties");
 676                 Properties droolsPersistenceProperties = new Properties();
 677                 droolsPersistenceProperties.load(new FileInputStream(new File(
 678                                 "src/test/server/config/droolsPersistence.properties")));
 679                 DroolsPersistenceProperties.initProperties(droolsPersistenceProperties);
 680
 681                 PolicyLogger.debug("testHotStandby1: Creating emfDrools");
 682                 EntityManagerFactory emfDrools = Persistence.createEntityManagerFactory(
 683                                 "junitDroolsPU", droolsPersistenceProperties);
 684
 685                 DroolsPdpsConnector conn = new JpaDroolsPdpsConnector(emfDrools);
 686
 687                 PolicyLogger.debug("testHotStandby1: Cleaning up tables");
 688                 conn.deleteAllSessions();
 689                 conn.deleteAllPdps();
 690
 691                 /*
 692                  * Insert this PDP as not designated.  Initial standby state will be
 693                  * either null or cold standby.   Demoting should transit state to
 694                  * hot standby.
 695                  */
 696                 PolicyLogger.debug("testHotStandby1: Inserting PDP=" + thisPdpId + " as not designated");
 697                 Date yesterday = DateUtils.addDays(new Date(), -1);
 698                 DroolsPdpImpl pdp = new DroolsPdpImpl(thisPdpId, false, 4, yesterday);
 699                 conn.insertPdp(pdp);
 700                 DroolsPdpEntity droolsPdpEntity = conn.getPdp(thisPdpId);
 701                 PolicyLogger.debug("testHotStandby1: After insertion, PDP=" + thisPdpId + " has DESIGNATED="
 702                                 + droolsPdpEntity.isDesignated());
 703                 assertTrue(droolsPdpEntity.isDesignated() == false);
 704
 705                 PolicyLogger.debug("testHotStandby1: Instantiating stateManagement object");
 706                 StateManagement sm = new StateManagement(emfXacml, "dummy");
 707                 sm.deleteAllStateManagementEntities();
 708                 sm = new StateManagement(emfXacml, thisPdpId);
 709                 PMStandbyStateChangeNotifier pmStandbyStateChangeNotifier = new PMStandbyStateChangeNotifier();
 710                 sm.addObserver(pmStandbyStateChangeNotifier);
 711
 712                 PolicyLogger.debug("testHotStandby1: Demoting PDP=" + thisPdpId);
 713                 // demoting should cause state to transit to hotstandby
 714                 sm.demote();
 715
 716                 PolicyLogger.debug("testHotStandby1: Running policy-management.Main class");
 717                 PolicyManagementRunner policyManagementRunner = new PolicyManagementRunner();
 718                 policyManagementRunner.start();
 719
 720                 PolicyLogger.debug("testHotStandby1: Sleeping "
 721                                 + sleepTime
 722                                 + "ms, to allow JpaDroolsPdpsConnector time to check droolspdpentity table");
 723                 Thread.sleep(sleepTime);
 724
 725                 /*
 726                  * Verify that this formerly un-designated PDP in HOT_STANDBY is now designated and providing service.
 727                  */
 728                 droolsPdpEntity = conn.getPdp(thisPdpId);
 729                 PolicyLogger.debug("testHotStandby1: After sm.demote() invoked, DESIGNATED="
 730                                 + droolsPdpEntity.isDesignated() + " for PDP=" + thisPdpId);
 731                 assertTrue(droolsPdpEntity.isDesignated() == true);
 732                 String standbyStatus = sm.getStandbyStatus(thisPdpId);
 733                 PolicyLogger.debug("testHotStandby1: After demotion, PDP=" + thisPdpId + " has standbyStatus="
 734                                 + standbyStatus);
 735                 assertTrue(standbyStatus != null  &&  standbyStatus.equals(StateManagement.PROVIDING_SERVICE));
 736
 737                 PolicyLogger.debug("testHotStandby1: Stopping policyManagementRunner");
 738                 //policyManagementRunner.stopRunner();
 739
 740                 PolicyLogger.debug("\n\ntestHotStandby1: Exiting\n\n");
 741                 Thread.sleep(interruptRecoveryTime);
 742
 743         }
 744
 745         /*
 746          * Tests hot standby when two PDPs are involved.
 747          */
 748         //@Ignore
 749         //@Test
 750         public void testHotStandby2() throws Exception {
 751
 752                 PolicyLogger.info("\n\ntestHotStandby2: Entering\n\n");
 753                 cleanXacmlDb();
 754                 cleanDroolsDb();
 755
 756                 PolicyLogger.info("testHotStandby2: Reading IntegrityMonitorProperties");
 757                 Properties integrityMonitorProperties = new Properties();
 758                 integrityMonitorProperties.load(new FileInputStream(new File(
 759                                 "src/test/server/config/IntegrityMonitor.properties")));
 760                 IntegrityMonitorProperties.initProperties(integrityMonitorProperties);
 761                 String thisPdpId = IntegrityMonitorProperties
 762                                 .getProperty(IntegrityMonitorProperties.PDP_INSTANCE_ID);
 763
 764                 PolicyLogger.info("testHotStandby2: Reading xacmlPersistenceProperties");
 765                 Properties xacmlPersistenceProperties = new Properties();
 766                 xacmlPersistenceProperties.load(new FileInputStream(new File(
 767                                 "src/test/server/config/xacmlPersistence.properties")));
 768                 XacmlPersistenceProperties.initProperties(xacmlPersistenceProperties);
 769
 770                 PolicyLogger.info("testHotStandby2: Creating emfXacml");
 771                 EntityManagerFactory emfXacml = Persistence.createEntityManagerFactory(
 772                                 "junitXacmlPU", xacmlPersistenceProperties);
 773
 774                 PolicyLogger.info("testHotStandby2: Reading droolsPersistenceProperties");
 775                 Properties droolsPersistenceProperties = new Properties();
 776                 droolsPersistenceProperties.load(new FileInputStream(new File(
 777                                 "src/test/server/config/droolsPersistence.properties")));
 778                 DroolsPersistenceProperties.initProperties(droolsPersistenceProperties);
 779
 780                 PolicyLogger.info("testHotStandby2: Creating emfDrools");
 781                 EntityManagerFactory emfDrools = Persistence.createEntityManagerFactory(
 782                                 "junitDroolsPU", droolsPersistenceProperties);
 783
 784                 DroolsPdpsConnector conn = new JpaDroolsPdpsConnector(emfDrools);
 785
 786                 PolicyLogger.info("testHotStandby2: Cleaning up tables");
 787                 conn.deleteAllSessions();
 788                 conn.deleteAllPdps();
 789
 790                 /*
 791                  * Insert a PDP that's designated but not current.
 792                  */
 793                 String activePdpId = "pdp2";
 794                 PolicyLogger.info("testHotStandby2: Inserting PDP=" + activePdpId + " as stale, designated PDP");
 795                 Date yesterday = DateUtils.addDays(new Date(), -1);
 796                 DroolsPdp pdp = new DroolsPdpImpl(activePdpId, true, 4, yesterday);
 797                 conn.insertPdp(pdp);
 798                 DroolsPdpEntity droolsPdpEntity = conn.getPdp(activePdpId);
 799                 PolicyLogger.info("testHotStandby2: After insertion, PDP=" + activePdpId + ", which is not current, has DESIGNATED="
 800                                 + droolsPdpEntity.isDesignated());
 801                 assertTrue(droolsPdpEntity.isDesignated() == true);
 802
 803                 /*
 804                  * Promote the designated PDP.
 805                  *
 806                  * We have a chicken and egg problem here: we need a StateManagement
 807                  * object to invoke the deleteAllStateManagementEntities method.
 808                  */
 809                 PolicyLogger.info("testHotStandy2: Promoting PDP=" + activePdpId);
 810                 StateManagement sm = new StateManagement(emfXacml, "dummy");
 811                 sm.deleteAllStateManagementEntities();
 812                 sm = new StateManagement(emfXacml, activePdpId);//pdp2
 813                 PMStandbyStateChangeNotifier pmStandbyStateChangeNotifier = new PMStandbyStateChangeNotifier();
 814                 sm.addObserver(pmStandbyStateChangeNotifier);
 815
 816                 // Artificially putting a PDP into service is really a two step process, 1)
 817                 // inserting it as designated and 2) promoting it so that its standbyStatus
 818                 // is providing service.
 819
 820                 /*
 821                  * Insert this PDP as not designated.  Initial standby state will be
 822                  * either null or cold standby.   Demoting should transit state to
 823                  * hot standby.
 824                  */
 825                 PolicyLogger.info("testHotStandby2: Inserting PDP=" + thisPdpId + " as not designated");
 826                 pdp = new DroolsPdpImpl(thisPdpId, false, 4, yesterday);
 827                 conn.insertPdp(pdp);
 828                 droolsPdpEntity = conn.getPdp(thisPdpId);
 829                 PolicyLogger.info("testHotStandby2: After insertion, PDP=" + thisPdpId + " has DESIGNATED="
 830                                 + droolsPdpEntity.isDesignated());
 831                 assertTrue(droolsPdpEntity.isDesignated() == false);
 832
 833                 PolicyLogger.info("testHotStandby2: Demoting PDP=" + thisPdpId);//pdp1
 834                 StateManagement sm2 = new StateManagement(emfXacml, thisPdpId);
 835                 sm2.addObserver(pmStandbyStateChangeNotifier);
 836
 837                 PolicyLogger.info("testHotStandby2: Running policy-management.Main class");
 838                 PolicyManagementRunner policyManagementRunner = new PolicyManagementRunner(); //pdp1
 839                 policyManagementRunner.start();
 840
 841                 PolicyLogger.info("testHotStandby2: Runner started; Sleeping "
 842                                 + interruptRecoveryTime + "ms before promoting/demoting");
 843                 Thread.sleep(interruptRecoveryTime);
 844
 845                 PolicyLogger.info("testHotStandby2: Runner started; promoting PDP=" + activePdpId);//pdpd2xs
 846                 //at this point, the newly created pdp will have set the state to disabled/failed/cold standby
 847                 //because it is stale. So, it cannot be promoted.  We need to call sm.enableNotFailed() so we
 848                 //can promote it and demote the other pdp - else the other pdp will just spring back to providingservice
 849                 sm.enableNotFailed();//pdp1
 850                 sm.promote();
 851                 String standbyStatus = sm.getStandbyStatus(activePdpId);
 852                 PolicyLogger.info("testHotStandby2: After promoting, PDP=" + activePdpId + " has standbyStatus="
 853                                 + standbyStatus);
 854
 855                 // demoting PDP should ensure that state transits to hotstandby
 856                 PolicyLogger.info("testHotStandby2: Runner started; demoting PDP=" + thisPdpId);
 857                 sm2.demote();//pdp1
 858                 standbyStatus = sm.getStandbyStatus(thisPdpId);
 859                 PolicyLogger.info("testHotStandby2: After demoting, PDP=" + thisPdpId + " has standbyStatus="
 860                                 + standbyStatus);
 861
 862                 PolicyLogger.info("testHotStandby2: Sleeping "
 863                                 + sleepTime
 864                                 + "ms, to allow JpaDroolsPdpsConnector time to check droolspdpentity table");
 865                 Thread.sleep(sleepTime);
 866
 867                 /*
 868                  * Verify that this PDP, demoted to HOT_STANDBY, is now
 869                  * re-designated and providing service.
 870                  */
 871                 droolsPdpEntity = conn.getPdp(thisPdpId);
 872                 PolicyLogger.info("testHotStandby2: After demoting PDP=" + activePdpId
 873                                 + ", DESIGNATED=" + droolsPdpEntity.isDesignated()
 874                                 + " for PDP=" + thisPdpId);
 875                 assertTrue(droolsPdpEntity.isDesignated() == true);
 876                 standbyStatus = sm2.getStandbyStatus(thisPdpId);
 877                 PolicyLogger.info("testHotStandby2: After demoting PDP=" + activePdpId
 878                                 + ", PDP=" + thisPdpId + " has standbyStatus=" + standbyStatus);
 879                 assertTrue(standbyStatus != null
 880                                 && standbyStatus.equals(StateManagement.PROVIDING_SERVICE));
 881
 882                 PolicyLogger.info("testHotStandby2: Stopping policyManagementRunner");
 883                 //policyManagementRunner.stopRunner();
 884
 885                 PolicyLogger.info("\n\ntestHotStandby2: Exiting\n\n");
 886                 Thread.sleep(interruptRecoveryTime);
 887
 888         }
 889
 890         /*
 891          * 1) Inserts and designates this PDP, then verifies that startTransaction
 892          * is successful.
 893          *
 894          * 2) Demotes PDP, and verifies that because there is only one PDP, it will
 895          * be immediately re-promoted, thus allowing startTransaction to be
 896          * successful.
 897          *
 898          * 3) Locks PDP and verifies that startTransaction results in
 899          * AdministrativeStateException.
 900          *
 901          * 4) Unlocks PDP and verifies that startTransaction results in
 902          * StandbyStatusException.
 903          *
 904          * 5) Promotes PDP and verifies that startTransaction is once again
 905          * successful.
 906          */
 907         //@Ignore
 908         //@Test
 909         public void testLocking1() throws Exception {
 910                 PolicyLogger.debug("testLocking1: Entry");
 911                 cleanXacmlDb();
 912                 cleanDroolsDb();
 913
 914                 PolicyLogger.debug("testLocking1: Reading IntegrityMonitorProperties");
 915                 Properties integrityMonitorProperties = new Properties();
 916                 integrityMonitorProperties.load(new FileInputStream(new File(
 917                                 "src/test/server/config/IntegrityMonitor.properties")));
 918                 IntegrityMonitorProperties.initProperties(integrityMonitorProperties);
 919                 String thisPdpId = IntegrityMonitorProperties
 920                                 .getProperty(IntegrityMonitorProperties.PDP_INSTANCE_ID);
 921
 922                 PolicyLogger.debug("testLocking1: Reading xacmlPersistenceProperties");
 923                 Properties xacmlPersistenceProperties = new Properties();
 924                 xacmlPersistenceProperties.load(new FileInputStream(new File(
 925                                 "src/test/server/config/xacmlPersistence.properties")));
 926                 XacmlPersistenceProperties.initProperties(xacmlPersistenceProperties);
 927
 928                 PolicyLogger.debug("testLocking1: Creating emfXacml");
 929                 EntityManagerFactory emfXacml = Persistence.createEntityManagerFactory(
 930                                 "junitXacmlPU", xacmlPersistenceProperties);
 931
 932                 PolicyLogger.debug("testLocking1: Reading droolsPersistenceProperties");
 933                 Properties droolsPersistenceProperties = new Properties();
 934                 droolsPersistenceProperties.load(new FileInputStream(new File(
 935                                 "src/test/server/config/droolsPersistence.properties")));
 936                 DroolsPersistenceProperties.initProperties(droolsPersistenceProperties);
 937
 938                 PolicyLogger.debug("testLocking1: Creating emfDrools");
 939                 EntityManagerFactory emfDrools = Persistence.createEntityManagerFactory(
 940                                 "junitDroolsPU", droolsPersistenceProperties);
 941
 942                 DroolsPdpsConnector conn = new JpaDroolsPdpsConnector(emfDrools);
 943
 944                 PolicyLogger.debug("testLocking1: Cleaning up tables");
 945                 conn.deleteAllSessions();
 946                 conn.deleteAllPdps();
 947
 948                 /*
 949                  * Insert this PDP as designated.  Initial standby state will be
 950                  * either null or cold standby.
 951                  */
 952                 PolicyLogger.debug("testLocking1: Inserting PDP=" + thisPdpId + " as designated");
 953                 DroolsPdpImpl pdp = new DroolsPdpImpl(thisPdpId, true, 4, new Date());
 954                 conn.insertPdp(pdp);
 955                 DroolsPdpEntity droolsPdpEntity = conn.getPdp(thisPdpId);
 956                 PolicyLogger.debug("testLocking1: After insertion, PDP=" + thisPdpId + " has DESIGNATED="
 957                                 + droolsPdpEntity.isDesignated());
 958                 assertTrue(droolsPdpEntity.isDesignated() == true);
 959
 960                 PolicyLogger.debug("testLocking1: Instantiating stateManagement object");
 961                 StateManagement sm = new StateManagement(emfXacml, "dummy");
 962                 sm.deleteAllStateManagementEntities();
 963                 sm = new StateManagement(emfXacml, thisPdpId);
 964                 PMStandbyStateChangeNotifier pmStandbyStateChangeNotifier = new PMStandbyStateChangeNotifier();
 965                 sm.addObserver(pmStandbyStateChangeNotifier);
 966
 967                 PolicyLogger.debug("testLocking1: Running policy-management.Main class, designated="
 968                                 + conn.getPdp(thisPdpId).isDesignated());
 969                 PolicyManagementRunner policyManagementRunner = new PolicyManagementRunner();
 970                 policyManagementRunner.start();
 971
 972                 PolicyLogger.debug("testLocking1: Runner started; Sleeping "
 973                                 + interruptRecoveryTime + "ms before promoting PDP="
 974                                 + thisPdpId);
 975                 Thread.sleep(interruptRecoveryTime);
 976
 977                 PolicyLogger.debug("testLocking1: Promoting PDP=" + thisPdpId);
 978                 sm.promote();
 979
 980                 PolicyLogger.debug("testLocking1: Sleeping "
 981                                 + sleepTime
 982                                 + "ms, to allow time for policy-management.Main class to come up, designated="
 983                                 + conn.getPdp(thisPdpId).isDesignated());
 984                 Thread.sleep(sleepTime);
 985
 986                 PolicyLogger.debug("testLocking1: Waking up and invoking startTransaction on active PDP="
 987                                 + thisPdpId
 988                                 + ", designated="
 989                                 + conn.getPdp(thisPdpId).isDesignated());
 990                 DroolsPDPIntegrityMonitor droolsPdpIntegrityMonitor = (DroolsPDPIntegrityMonitor) IntegrityMonitor
 991                                 .getInstance();
 992                 try {
 993                         droolsPdpIntegrityMonitor.startTransaction();
 994                         droolsPdpIntegrityMonitor.endTransaction();
 995                         PolicyLogger.debug("testLocking1: As expected, transaction successful");
 996                 } catch (AdministrativeStateException e) {
 997                         PolicyLogger.error("testLocking1: Unexpectedly caught AdministrativeStateException, message=" + e.getMessage());
 998                         assertTrue(false);
 999                 } catch (StandbyStatusException e) {
1000                         PolicyLogger.error("testLocking1: Unexpectedly caught StandbyStatusException, message=" + e.getMessage());
1001                         assertTrue(false);
1002                 } catch (Exception e) {
1003                         PolicyLogger.error("testLocking1: Unexpectedly caught Exception, message=" + e.getMessage());
1004                         assertTrue(false);
1005                 }
1006
1007                 // demoting should cause state to transit to hotstandby, followed by re-promotion,
1008                 // since there is only one PDP.
1009                 PolicyLogger.debug("testLocking1: demoting PDP=" + thisPdpId);
1010                 sm = droolsPdpIntegrityMonitor.getStateManager();
1011                 sm.demote();
1012
1013                 PolicyLogger.debug("testLocking1: sleeping" + electionWaitSleepTime
1014                                 + " to allow election handler to re-promote PDP=" + thisPdpId);
1015                 Thread.sleep(electionWaitSleepTime);
1016
1017                 PolicyLogger.debug("testLocking1: Invoking startTransaction on re-promoted PDP="
1018                                 + thisPdpId
1019                                 + ", designated="
1020                                 + conn.getPdp(thisPdpId).isDesignated());
1021                 try {
1022                         droolsPdpIntegrityMonitor.startTransaction();
1023                         droolsPdpIntegrityMonitor.endTransaction();
1024                         PolicyLogger.debug("testLocking1: As expected, transaction successful");
1025                 } catch (AdministrativeStateException e) {
1026                         PolicyLogger.error("testLocking1: Unexpectedly caught AdministrativeStateException, message=" + e.getMessage());
1027                         assertTrue(false);
1028                 } catch (StandbyStatusException e) {
1029                         PolicyLogger.error("testLocking1: Unexpectedly caught StandbyStatusException, message=" + e.getMessage());
1030                         assertTrue(false);
1031                 } catch (Exception e) {
1032                         PolicyLogger.error("testLocking1: Unexpectedly caught Exception, message=" + e.getMessage());
1033                         assertTrue(false);
1034                 }
1035
1036                 // locking should cause state to transit to cold standby
1037                 PolicyLogger.debug("testLocking1: locking PDP=" + thisPdpId);
1038                 sm.lock();
1039
1040                 // Just to avoid any race conditions, sleep a little after locking
1041                 PolicyLogger.debug("testLocking1: Sleeping a few millis after locking, to avoid race condition");
1042                 Thread.sleep(100);
1043
1044                 PolicyLogger.debug("testLocking1: Invoking startTransaction on locked PDP="
1045                                 + thisPdpId
1046                                 + ", designated="
1047                                 + conn.getPdp(thisPdpId).isDesignated());
1048                 try {
1049                         droolsPdpIntegrityMonitor.startTransaction();
1050                         PolicyLogger.error("testLocking1: startTransaction unexpectedly successful");
1051                         assertTrue(false);
1052                 } catch (AdministrativeStateException e) {
1053                         PolicyLogger.debug("testLocking1: As expected, caught AdministrativeStateException, message=" + e.getMessage());
1054                 } catch (StandbyStatusException e) {
1055                         PolicyLogger.error("testLocking1: Unexpectedly caught StandbyStatusException, message=" + e.getMessage());
1056                         assertTrue(false);
1057                 } catch (Exception e) {
1058                         PolicyLogger.error("testLocking1: Unexpectedly caught Exception, message=" + e.getMessage());
1059                         assertTrue(false);
1060                 } finally {
1061                         droolsPdpIntegrityMonitor.endTransaction();
1062                 }
1063
1064                 // unlocking should cause state to transit to hot standby and then providing service
1065                 PolicyLogger.debug("testLocking1: unlocking PDP=" + thisPdpId);
1066                 sm.unlock();
1067
1068                 // Just to avoid any race conditions, sleep a little after locking
1069                 PolicyLogger.debug("testLocking1: Sleeping a few millis after unlocking, to avoid race condition");
1070                 Thread.sleep(electionWaitSleepTime);
1071
1072                 PolicyLogger.debug("testLocking1: Invoking startTransaction on unlocked PDP="
1073                                 + thisPdpId
1074                                 + ", designated="
1075                                 + conn.getPdp(thisPdpId).isDesignated());
1076                 try {
1077                         droolsPdpIntegrityMonitor.startTransaction();
1078                         PolicyLogger.error("testLocking1: startTransaction successful as expected");
1079                 } catch (AdministrativeStateException e) {
1080                         PolicyLogger.error("testLocking1: Unexpectedly caught AdministrativeStateException, message=" + e.getMessage());
1081                         assertTrue(false);
1082                 } catch (StandbyStatusException e) {
1083                         PolicyLogger.debug("testLocking1: Unexpectedly caught StandbyStatusException, message=" + e.getMessage());
1084                         assertTrue(false);
1085                 } catch (Exception e) {
1086                         PolicyLogger.error("testLocking1: Unexpectedly caught Exception, message=" + e.getMessage());
1087                         assertTrue(false);
1088                 } finally {
1089                         droolsPdpIntegrityMonitor.endTransaction();
1090                 }
1091
1092                 // demoting should cause state to transit to providing service
1093                 PolicyLogger.debug("testLocking1: demoting PDP=" + thisPdpId);
1094                 sm.demote();
1095
1096                 // Just to avoid any race conditions, sleep a little after promoting
1097                 PolicyLogger.debug("testLocking1: Sleeping a few millis after demoting, to avoid race condition");
1098                 Thread.sleep(100);
1099
1100                 PolicyLogger.debug("testLocking1: Invoking startTransaction on demoted PDP="
1101                                 + thisPdpId
1102                                 + ", designated="
1103                                 + conn.getPdp(thisPdpId).isDesignated());
1104                 try {
1105                         droolsPdpIntegrityMonitor.startTransaction();
1106                         droolsPdpIntegrityMonitor.endTransaction();
1107                         PolicyLogger.debug("testLocking1: Unexpectedly, transaction successful");
1108                         assertTrue(false);
1109                 } catch (AdministrativeStateException e) {
1110                         PolicyLogger.error("testLocking1: Unexpectedly caught AdministrativeStateException, message=" + e.getMessage());
1111                         assertTrue(false);
1112                 } catch (StandbyStatusException e) {
1113                         PolicyLogger.error("testLocking1: As expected caught StandbyStatusException, message=" + e.getMessage());
1114                 } catch (Exception e) {
1115                         PolicyLogger.error("testLocking1: Unexpectedly caught Exception, message=" + e.getMessage());
1116                         assertTrue(false);
1117                 }
1118
1119                 PolicyLogger.debug("testLocking1: Stopping policyManagementRunner");
1120                 //policyManagementRunner.stopRunner();
1121
1122                 PolicyLogger.debug("\n\ntestLocking1: Exiting\n\n");
1123                 Thread.sleep(interruptRecoveryTime);
1124
1125         }
1126
1127         /*
1128          * 1) Inserts and designates this PDP, then verifies that startTransaction
1129          * is successful.
1130          *
1131          * 2) Inserts another PDP in hotstandby.
1132          *
1133          * 3) Demotes this PDP, and verifies 1) that other PDP is not promoted (because one
1134          * PDP cannot promote another PDP) and 2) that this PDP is re-promoted.
1135          */
1136         //@Ignore
1137         //@Test
1138         public void testLocking2() throws Exception {
1139
1140                 PolicyLogger.debug("\n\ntestLocking2: Entering\n\n");
1141                 cleanXacmlDb();
1142                 cleanDroolsDb();
1143
1144                 PolicyLogger.debug("testLocking2: Reading IntegrityMonitorProperties");
1145                 Properties integrityMonitorProperties = new Properties();
1146                 integrityMonitorProperties.load(new FileInputStream(new File(
1147                                 "src/test/server/config/IntegrityMonitor.properties")));
1148                 IntegrityMonitorProperties.initProperties(integrityMonitorProperties);
1149                 String thisPdpId = IntegrityMonitorProperties
1150                                 .getProperty(IntegrityMonitorProperties.PDP_INSTANCE_ID);
1151
1152                 PolicyLogger.debug("testLocking2: Reading xacmlPersistenceProperties");
1153                 Properties xacmlPersistenceProperties = new Properties();
1154                 xacmlPersistenceProperties.load(new FileInputStream(new File(
1155                                 "src/test/server/config/xacmlPersistence.properties")));
1156                 XacmlPersistenceProperties.initProperties(xacmlPersistenceProperties);
1157
1158                 PolicyLogger.debug("testLocking2: Creating emfXacml");
1159                 EntityManagerFactory emfXacml = Persistence.createEntityManagerFactory(
1160                                 "junitXacmlPU", xacmlPersistenceProperties);
1161
1162                 PolicyLogger.debug("testLocking2: Reading droolsPersistenceProperties");
1163                 Properties droolsPersistenceProperties = new Properties();
1164                 droolsPersistenceProperties.load(new FileInputStream(new File(
1165                                 "src/test/server/config/droolsPersistence.properties")));
1166                 DroolsPersistenceProperties.initProperties(droolsPersistenceProperties);
1167
1168                 PolicyLogger.debug("testLocking2: Creating emfDrools");
1169                 EntityManagerFactory emfDrools = Persistence.createEntityManagerFactory(
1170                                 "junitDroolsPU", droolsPersistenceProperties);
1171
1172                 DroolsPdpsConnector conn = new JpaDroolsPdpsConnector(emfDrools);
1173
1174                 PolicyLogger.debug("testLocking2: Cleaning up tables");
1175                 conn.deleteAllSessions();
1176                 conn.deleteAllPdps();
1177
1178                 /*
1179                  * Insert this PDP as designated.  Initial standby state will be
1180                  * either null or cold standby.   Demoting should transit state to
1181                  * hot standby.
1182                  */
1183                 PolicyLogger.debug("testLocking2: Inserting PDP=" + thisPdpId + " as designated");
1184                 DroolsPdpImpl pdp = new DroolsPdpImpl(thisPdpId, true, 3, new Date());
1185                 conn.insertPdp(pdp);
1186                 DroolsPdpEntity droolsPdpEntity = conn.getPdp(thisPdpId);
1187                 PolicyLogger.debug("testLocking2: After insertion, PDP=" + thisPdpId + " has DESIGNATED="
1188                                 + droolsPdpEntity.isDesignated());
1189                 assertTrue(droolsPdpEntity.isDesignated() == true);
1190
1191                 PolicyLogger.debug("testLocking2: Instantiating stateManagement object and promoting PDP=" + thisPdpId);
1192                 StateManagement sm = new StateManagement(emfXacml, "dummy");
1193                 sm.deleteAllStateManagementEntities();
1194                 sm = new StateManagement(emfXacml, thisPdpId);
1195                 PMStandbyStateChangeNotifier pmStandbyStateChangeNotifier = new PMStandbyStateChangeNotifier();
1196                 sm.addObserver(pmStandbyStateChangeNotifier);
1197
1198                 /*
1199                  * Insert another PDP as not designated.  Initial standby state will be
1200                  * either null or cold standby.   Demoting should transit state to
1201                  * hot standby.
1202                  */
1203                 String standbyPdpId = "pdp2";
1204                 PolicyLogger.debug("testLocking2: Inserting PDP=" + standbyPdpId + " as not designated");
1205                 Date yesterday = DateUtils.addDays(new Date(), -1);
1206                 pdp = new DroolsPdpImpl(standbyPdpId, false, 4, yesterday);
1207                 conn.insertPdp(pdp);
1208                 droolsPdpEntity = conn.getPdp(standbyPdpId);
1209                 PolicyLogger.debug("testLocking2: After insertion, PDP=" + standbyPdpId + " has DESIGNATED="
1210                                 + droolsPdpEntity.isDesignated());
1211                 assertTrue(droolsPdpEntity.isDesignated() == false);
1212
1213                 PolicyLogger.debug("testLocking2: Demoting PDP=" + standbyPdpId);
1214                 StateManagement sm2 = new StateManagement(emfXacml, standbyPdpId);
1215                 sm2.addObserver(pmStandbyStateChangeNotifier);
1216
1217                 PolicyLogger.debug("testLocking2: Running policy-management.Main class");
1218                 PolicyManagementRunner policyManagementRunner = new PolicyManagementRunner();
1219                 policyManagementRunner.start();
1220
1221                 PolicyLogger.debug("testLocking2: Runner started; Sleeping "
1222                                 + interruptRecoveryTime + "ms before promoting/demoting");
1223                 Thread.sleep(interruptRecoveryTime);
1224
1225                 PolicyLogger.debug("testLocking2: Promoting PDP=" + thisPdpId);
1226                 sm.promote();
1227
1228                 // demoting PDP should ensure that state transits to hotstandby
1229                 PolicyLogger.debug("testLocking2: Demoting PDP=" + standbyPdpId);
1230                 sm2.demote();
1231
1232                 PolicyLogger.debug("testLocking2: Sleeping "
1233                                 + sleepTime
1234                                 + "ms, to allow time for policy-management.Main class to come up");
1235                 Thread.sleep(sleepTime);
1236
1237                 PolicyLogger.debug("testLocking2: Waking up and invoking startTransaction on active PDP="
1238                                 + thisPdpId
1239                                 + ", designated="
1240                                 + conn.getPdp(thisPdpId).isDesignated());
1241                 DroolsPDPIntegrityMonitor droolsPdpIntegrityMonitor = (DroolsPDPIntegrityMonitor) IntegrityMonitor
1242                                 .getInstance();
1243                 try {
1244                         droolsPdpIntegrityMonitor.startTransaction();
1245                         droolsPdpIntegrityMonitor.endTransaction();
1246                         PolicyLogger.debug("testLocking2: As expected, transaction successful");
1247                 } catch (AdministrativeStateException e) {
1248                         PolicyLogger.error("testLocking2: Unexpectedly caught AdministrativeStateException, message=" + e.getMessage());
1249                         assertTrue(false);
1250                 } catch (StandbyStatusException e) {
1251                         PolicyLogger.error("testLocking2: Unexpectedly caught StandbyStatusException, message=" + e.getMessage());
1252                         assertTrue(false);
1253                 } catch (Exception e) {
1254                         PolicyLogger.error("testLocking2: Unexpectedly caught Exception, message=" + e.getMessage());
1255                         assertTrue(false);
1256                 }
1257
1258                 // demoting should cause state to transit to hotstandby followed by re-promotion.
1259                 PolicyLogger.debug("testLocking2: demoting PDP=" + thisPdpId);
1260                 sm = droolsPdpIntegrityMonitor.getStateManager();
1261                 sm.demote();
1262
1263                 PolicyLogger.debug("testLocking2: sleeping" + electionWaitSleepTime
1264                                 + " to allow election handler to re-promote PDP=" + thisPdpId);
1265                 Thread.sleep(electionWaitSleepTime);
1266
1267                 PolicyLogger.debug("testLocking2: Waking up and invoking startTransaction on re-promoted PDP="
1268                                 + thisPdpId + ", designated="
1269                                 + conn.getPdp(thisPdpId).isDesignated());
1270                 try {
1271                         droolsPdpIntegrityMonitor.startTransaction();
1272                         droolsPdpIntegrityMonitor.endTransaction();
1273                         PolicyLogger.debug("testLocking2: As expected, transaction successful");
1274                 } catch (AdministrativeStateException e) {
1275                         PolicyLogger.error("testLocking2: Unexpectedly caught AdministrativeStateException, message=" + e.getMessage());
1276                         assertTrue(false);
1277                 } catch (StandbyStatusException e) {
1278                         PolicyLogger.error("testLocking2: Unexpectedly caught StandbyStatusException, message=" + e.getMessage());
1279                         assertTrue(false);
1280                 } catch (Exception e) {
1281                         PolicyLogger.error("testLocking2: Unexpectedly caught Exception, message=" + e.getMessage());
1282                         assertTrue(false);
1283                 }
1284
1285                 PolicyLogger.debug("testLocking2: Verifying designated status for PDP="
1286                                 + standbyPdpId);
1287                 boolean standbyPdpDesignated = conn.getPdp(standbyPdpId).isDesignated();
1288                 assertTrue(standbyPdpDesignated == false);
1289
1290                 PolicyLogger.debug("testLocking2: Stopping policyManagementRunner");
1291                 //policyManagementRunner.stopRunner();
1292
1293                 PolicyLogger.debug("\n\ntestLocking2: Exiting\n\n");
1294                 Thread.sleep(interruptRecoveryTime);
1295
1296         }
1297
1298         private class PolicyManagementRunner extends Thread {
1299
1300                 public void run() {
1301                         PolicyLogger.info("PolicyManagementRunner.run: Entering");
1302                         String args[] = { "src/main/server/config" };
1303                         try {
1304                                 Main.main(args);
1305                         } catch (Exception e) {
1306                                 PolicyLogger
1307                                                 .info("PolicyManagementRunner.run: Exception thrown from Main.main(), message="
1308                                                                 + e.getMessage());
1309                                 return;
1310                         }
1311                         PolicyLogger.info("PolicyManagementRunner.run: Exiting");
1312                 }
1313
1314                 public void stopRunner() {
1315                         PolicyEngine.manager.shutdown();
1316                 }
1317
1318         }
1319
1320 }