Addition of Active-Standby Feature

Patch 1: Adds the active-standby feature to drools-pdp.
This feature provides the state control of the
drools-pdp nodes controlling failover with a site
and across sites. Patch 2: Resolve merge conflict in
packages/install/pom.xml and pom.xml. Patch 3: Resolved
comments from Pamela Dragosh and Jorge Hernandez.

Issue-ID: POLICY-156
Change-Id: I922b3d5d8a464006e9675924bcbc7409d68c08d5
Signed-off-by: Kevin McKiou <km097d@att.com>

24 files changed, 4874 insertions, 0 deletions

diff --git a/feature-active-standby-management/pom.xml b/feature-active-standby-management/pom.xml
new file mode 100644
index 00000000..824b38ed
--- /dev/null
+++ b/feature-active-standby-management/pom.xml
@@ -0,0 +1,136 @@
+<!--
+  ============LICENSE_START=======================================================
+  feature-active-standby-management
+  ================================================================================
+  Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+  ================================================================================
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+  
+       http://www.apache.org/licenses/LICENSE-2.0
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+  ============LICENSE_END=========================================================
+  -->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+	<modelVersion>4.0.0</modelVersion>
+
+	<parent>
+		<groupId>org.onap.policy.drools-pdp</groupId>
+		<artifactId>drools-pdp</artifactId>
+		<version>1.1.0-SNAPSHOT</version>
+	</parent>
+
+	<artifactId>feature-active-standby-management</artifactId>
+
+	<name>feature-active-standby-management</name>
+	<description>Separately loadable module for managing active-standby behavior</description>
+
+	<build>
+		<plugins>
+			<plugin>
+				<artifactId>maven-assembly-plugin</artifactId>
+				<version>2.6</version>
+				<executions>
+					<execution>
+						<id>zipfile</id>
+						<goals>
+							<goal>single</goal>
+						</goals>
+						<phase>package</phase>
+						<configuration>
+							<attach>true</attach>
+							<finalName>${project.artifactId}-${project.version}</finalName>
+							<descriptors>
+								<descriptor>src/assembly/assemble_zip.xml</descriptor>
+							</descriptors>
+							<appendAssemblyId>false</appendAssemblyId>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-dependency-plugin</artifactId>
+				<version>2.8</version>
+				<executions>
+					<execution>
+						<id>copy-dependencies</id>
+						<goals>
+							<goal>copy-dependencies</goal>
+						</goals>
+						<phase>prepare-package</phase>
+						<configuration>
+							<transitive>false</transitive>
+							<outputDirectory>${project.build.directory}/assembly/lib</outputDirectory>
+							<overWriteReleases>false</overWriteReleases>
+							<overWriteSnapshots>true</overWriteSnapshots>
+							<overWriteIfNewer>true</overWriteIfNewer>
+							<useRepositoryLayout>false</useRepositoryLayout>
+							<addParentPoms>false</addParentPoms>
+							<copyPom>false</copyPom>
+							<includeScope>runtime</includeScope>
+							<excludeTransitive>true</excludeTransitive>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
+		</plugins>
+	</build>
+
+	<dependencies>
+		<dependency>
+			<groupId>io.swagger</groupId>
+			<artifactId>swagger-jersey2-jaxrs</artifactId>
+			<scope>provided</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.onap.policy.drools-pdp</groupId>
+			<artifactId>policy-core</artifactId>
+			<version>${project.version}</version>
+			<scope>provided</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.onap.policy.drools-pdp</groupId>
+			<artifactId>policy-management</artifactId>
+			<version>${project.version}</version>
+			<scope>provided</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.eclipse.persistence</groupId>
+			<artifactId>eclipselink</artifactId>
+			<scope>provided</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.onap.policy.drools-pdp</groupId>
+			<artifactId>api-active-standby-management</artifactId>
+			<version>${project.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.onap.policy.drools-pdp</groupId>
+			<artifactId>api-state-management</artifactId>
+			<version>${project.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.onap.policy.drools-pdp</groupId>
+			<artifactId>feature-state-management</artifactId>
+			<version>${project.version}</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>com.h2database</groupId>
+			<artifactId>h2</artifactId>
+			<version>[1.4.186,)</version>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+
+</project>
diff --git a/feature-active-standby-management/src/assembly/assemble_zip.xml b/feature-active-standby-management/src/assembly/assemble_zip.xml
new file mode 100644
index 00000000..97b82ac2
--- /dev/null
+++ b/feature-active-standby-management/src/assembly/assemble_zip.xml
@@ -0,0 +1,76 @@
+<!--
+  ============LICENSE_START=======================================================
+  feature-active-standby- management
+  ================================================================================
+  Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+  ================================================================================
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+  
+       http://www.apache.org/licenses/LICENSE-2.0
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+  ============LICENSE_END=========================================================
+  -->
+
+<!-- Defines how we build the .zip file which is our distribution. -->
+
+<assembly
+	xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
+	<id>feature-active-standby-management</id>
+	<formats>
+		<format>zip</format>
+	</formats>
+
+	<!-- we want "system" and related files right at the root level as this 
+		file is suppose to be unzip on top of a karaf distro. -->
+	<includeBaseDirectory>false</includeBaseDirectory>
+
+	<fileSets>
+		<fileSet>
+			<directory>target</directory>
+			<outputDirectory>lib/feature</outputDirectory>
+			<includes>
+				<include>feature-active-standby-management-${project.version}.jar</include>
+			</includes>
+		</fileSet>
+		<fileSet>
+			<directory>target/assembly/lib</directory>
+			<outputDirectory>lib/dependencies</outputDirectory>
+			<includes>
+				<include>*.jar</include>
+			</includes>
+		</fileSet>
+		<fileSet>
+			<directory>src/main/feature/config</directory>
+			<outputDirectory>config</outputDirectory>
+			<fileMode>0644</fileMode>
+			<excludes/>
+		</fileSet>
+		<fileSet>
+			<directory>src/main/feature/bin</directory>
+			<outputDirectory>bin</outputDirectory>
+			<fileMode>0744</fileMode>
+			<excludes/>
+		</fileSet>
+		<fileSet>
+			<directory>src/main/feature/db</directory>
+			<outputDirectory>db</outputDirectory>
+			<fileMode>0744</fileMode>
+			<excludes/>
+		</fileSet>
+		<fileSet>
+			<directory>src/main/feature/install</directory>
+			<outputDirectory>install</outputDirectory>
+			<fileMode>0744</fileMode>
+			<excludes/>
+		</fileSet>
+	</fileSets>
+</assembly>
diff --git a/feature-active-standby-management/src/main/feature/config/feature-active-standby-management.properties b/feature-active-standby-management/src/main/feature/config/feature-active-standby-management.properties
new file mode 100644
index 00000000..d9fd6ca3
--- /dev/null
+++ b/feature-active-standby-management/src/main/feature/config/feature-active-standby-management.properties
@@ -0,0 +1,39 @@
+###
+# ============LICENSE_START=======================================================
+# feature-active-standby-management
+# ================================================================================
+# Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+# ================================================================================
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============LICENSE_END=========================================================
+###
+
+# DB properties
+javax.persistence.jdbc.driver=org.mariadb.jdbc.Driver
+javax.persistence.jdbc.url=jdbc:mariadb://${{SQL_HOST}}:3306/activestandbymanagement
+javax.persistence.jdbc.user=${{SQL_USER}}
+javax.persistence.jdbc.password=${{SQL_PASSWORD}}
+
+# Must be unique across the system
+resource.name=pdp1
+# Name of the site in which this node is hosted 
+site_name=site1
+
+# Needed by DroolsPdpsElectionHandler
+pdp.checkInterval=1500
+pdp.updateInterval=1000
+#pdp.timeout=3000
+# Need long timeout, because testTransaction is only run every 10 seconds.
+pdp.timeout=15000
+#how long do we wait for the pdp table to populate on initial startup
+pdp.initialWait=20000
\ No newline at end of file
diff --git a/feature-active-standby-management/src/main/feature/db/activestandbymanagement/sql/18020-activestandbymanagement.upgrade.sql b/feature-active-standby-management/src/main/feature/db/activestandbymanagement/sql/18020-activestandbymanagement.upgrade.sql
new file mode 100644
index 00000000..4b3375ad
--- /dev/null
+++ b/feature-active-standby-management/src/main/feature/db/activestandbymanagement/sql/18020-activestandbymanagement.upgrade.sql
@@ -0,0 +1,34 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * feature-active-standby-management
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+set foreign_key_checks=0; 
+
+CREATE TABLE if not exists activestandbymanagement.DROOLSPDPENTITY 
+( 
+pdpId VARCHAR(255) NOT NULL, 
+designated TINYINT(1) default 0 NOT NULL, 
+priority INTEGER NOT NULL, 
+site VARCHAR(50), 
+updatedDate TIMESTAMP NOT NULL, 
+designatedDate TIMESTAMP NOT NULL, 
+PRIMARY KEY (pdpId) 
+);
+
+set foreign_key_checks=1;
\ No newline at end of file
diff --git a/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/ActiveStandbyFeature.java b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/ActiveStandbyFeature.java
new file mode 100644
index 00000000..d40a9e0f
--- /dev/null
+++ b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/ActiveStandbyFeature.java
@@ -0,0 +1,240 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * feature-active-standby-management
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.activestandby;
+
+import java.io.IOException;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Persistence;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.onap.policy.drools.core.PolicySessionFeatureAPI;
+import org.onap.policy.drools.features.PolicyEngineFeatureAPI;
+import org.onap.policy.drools.statemanagement.StateManagementFeatureAPI;
+import org.onap.policy.drools.system.PolicyEngine;
+import org.onap.policy.drools.utils.PropertyUtil;
+
+/**
+ * If this feature is supported, there is a single instance of it.
+ * It adds persistence to Drools sessions, but it is also intertwined with
+ * active/standby state management and IntegrityMonitor. For now, they are
+ * all treated as a single feature, but it would be nice to separate them.
+ *
+ * The bulk of the code here was once in other classes, such as
+ * 'PolicyContainer' and 'Main'. It was moved here as part of making this
+ * a separate optional feature.
+ */
+public class ActiveStandbyFeature implements ActiveStandbyFeatureAPI, 
+				PolicySessionFeatureAPI, PolicyEngineFeatureAPI
+{
+	// get an instance of logger
+	private static final Logger logger =
+			LoggerFactory.getLogger(ActiveStandbyFeature.class);
+	
+	private static DroolsPdp myPdp;
+	private static Object myPdpSync = new Object();
+	private static DroolsPdpsElectionHandler electionHandler;
+	
+	private StateManagementFeatureAPI stateManagementFeature;
+	
+	public static final int SEQ_NUM = 1;
+	
+
+	/**************************/
+	/* 'FeatureAPI' interface */
+	/**************************/
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	public int getSequenceNumber()
+	{
+		return(SEQ_NUM);
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	public void globalInit(String args[], String configDir)
+	{
+		// This must come first since it initializes myPdp
+		initializePersistence(configDir);
+		
+		for (StateManagementFeatureAPI feature : StateManagementFeatureAPI.impl.getList())
+		{
+			if (feature.getResourceName().equals(myPdp.getPdpId()))
+			{
+				if(logger.isDebugEnabled()){
+					logger.debug("ActiveStandbyFeature.globalInit: Found StateManagementFeature"
+						+ " with resourceName: {}", myPdp.getPdpId());
+				}
+				stateManagementFeature = feature;
+				break;
+			}
+		}
+		if(stateManagementFeature == null){
+			if(logger.isDebugEnabled()){
+				logger.debug("ActiveStandbyFeature failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", myPdp.getPdpId());
+			}
+			logger.error("ActiveStandbyFeature failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", myPdp.getPdpId());
+		}
+
+
+
+		//Create an instance of the Observer
+		PMStandbyStateChangeNotifier pmNotifier = new PMStandbyStateChangeNotifier();
+
+		//Register the PMStandbyStateChangeNotifier Observer
+		stateManagementFeature.addObserver(pmNotifier);
+		if(logger.isDebugEnabled()){
+			logger.debug("ActiveStandbyFeature.globalInit() exit");
+		}
+	}
+
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	public boolean afterStart(PolicyEngine engine) 
+	{
+		// ASSERTION: engine == PolicyEngine.manager
+		PolicyEngine.manager.lock();
+		return false;
+	}
+
+	/**
+	 * Read in the persistence properties, determine whether persistence is
+	 * enabled or disabled, and initialize persistence if enabled.
+	 */
+	private static void initializePersistence(String configDir)
+	{
+		//Get the Active Standby properties
+		try {
+				Properties activeStandbyProperties = 
+						PropertyUtil.getProperties(configDir + "/feature-active-standby-management.properties");
+				ActiveStandbyProperties.initProperties(activeStandbyProperties);
+				logger.info("initializePersistence: ActiveStandbyProperties success");
+		} catch (IOException e) {
+			logger.error("ActiveStandbyFeature: initializePersistence ActiveStandbyProperties", e);
+		}
+		
+		DroolsPdpsConnector conn = getDroolsPdpsConnector("activeStandbyPU");
+		String resourceName = ActiveStandbyProperties.getProperty(ActiveStandbyProperties.NODE_NAME);
+		if(resourceName == null){
+			throw new NullPointerException();
+		}
+
+		/*
+		 * In a JUnit test environment, one or more PDPs may already have been
+		 * inserted in the DB, so we need to check for this.
+		 */
+		DroolsPdp existingPdp = conn.getPdp(resourceName);
+		if (existingPdp != null) {
+			System.out.println("Found existing PDP record, pdpId="
+					+ existingPdp.getPdpId() + ", isDesignated="
+					+ existingPdp.isDesignated() + ", updatedDate="
+					+ existingPdp.getUpdatedDate());
+			myPdp = existingPdp;
+		}
+
+		synchronized(myPdpSync){
+			if(myPdp == null){
+
+				myPdp = new DroolsPdpImpl(resourceName,false,4,new Date());	
+			}
+			if(myPdp != null){
+				String site_name = ActiveStandbyProperties.getProperty(ActiveStandbyProperties.SITE_NAME);
+				if (site_name == null) {
+					site_name = "";
+				}else{
+					site_name = site_name.trim();
+				}
+				myPdp.setSiteName(site_name);
+			}
+			if(electionHandler == null){
+				electionHandler = new DroolsPdpsElectionHandler(conn,myPdp);
+			}
+		}
+		System.out.println("\n\nThis controller is a standby, waiting to be chosen as primary...\n\n");
+		logger.info("\n\nThis controller is a standby, waiting to be chosen as primary...\n\n");
+	}
+
+
+	/*
+	 * Moved code to instantiate a JpaDroolsPdpsConnector object from main() to
+	 * this method, so it can also be accessed from StandbyStateChangeNotifier
+	 * class.
+	 */
+	public static DroolsPdpsConnector getDroolsPdpsConnector(String pu) {
+
+		Map<String, Object> propMap = new HashMap<String, Object>();
+		propMap.put("javax.persistence.jdbc.driver", ActiveStandbyProperties
+				.getProperty(ActiveStandbyProperties.DB_DRIVER));
+		propMap.put("javax.persistence.jdbc.url",
+				ActiveStandbyProperties.getProperty(ActiveStandbyProperties.DB_URL));
+		propMap.put("javax.persistence.jdbc.user", ActiveStandbyProperties
+				.getProperty(ActiveStandbyProperties.DB_USER));
+		propMap.put("javax.persistence.jdbc.password",
+				ActiveStandbyProperties.getProperty(ActiveStandbyProperties.DB_PWD));
+
+		EntityManagerFactory emf = Persistence.createEntityManagerFactory(
+				pu, propMap);
+		DroolsPdpsConnector conn = new JpaDroolsPdpsConnector(emf);
+
+		return conn;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	public String getPdpdNowActive(){
+		return electionHandler.getPdpdNowActive();
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	public String getPdpdLastActive(){
+		return electionHandler.getPdpdLastActive();
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	public String getResourceName() {
+		return myPdp.getPdpId();
+	}
+}
diff --git a/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/ActiveStandbyProperties.java b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/ActiveStandbyProperties.java
new file mode 100644
index 00000000..6e26334b
--- /dev/null
+++ b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/ActiveStandbyProperties.java
@@ -0,0 +1,71 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * feature-active-standby-management
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.activestandby;
+
+import java.util.Properties;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ActiveStandbyProperties {
+	// get an instance of logger 
+	private static final Logger  logger = LoggerFactory.getLogger(ActiveStandbyProperties.class);
+		
+	public static final String PDP_CHECK_INVERVAL = "pdp.checkInterval";
+	public static final String PDP_UPDATE_INTERVAL = "pdp.updateInterval";
+	public static final String PDP_TIMEOUT = "pdp.timeout";
+	public static final String PDP_INITIAL_WAIT_PERIOD = "pdp.initialWait";
+
+	public static final String NODE_NAME = "resource.name";
+	public static final String SITE_NAME = "site_name";
+	
+	/*
+	 * feature-active-standby-management.properties parameter key values
+	 */
+	public static final String DB_DRIVER = "javax.persistence.jdbc.driver";
+	public static final String DB_URL = "javax.persistence.jdbc.url";
+	public static final String DB_USER = "javax.persistence.jdbc.user";
+	public static final String DB_PWD = "javax.persistence.jdbc.password";
+		
+	private static Properties properties = null;
+	/*
+	 * Initialize the parameter values from the droolsPersitence.properties file values
+	 * 
+	 * This is designed so that the Properties object is obtained from properties
+	 * file and then is passed to this method to initialize the value of the parameters.
+	 * This allows the flexibility of JUnit tests using getProperties(filename) to get the
+	 * properties while runtime methods can use getPropertiesFromClassPath(filename).
+	 * 
+	 */
+	public static void initProperties (Properties prop){
+		logger.info("ActiveStandbyProperties.initProperties(Properties): entry");
+		logger.info("\n\nActiveStandbyProperties.initProperties: Properties = \n{}\n\n", prop);
+		
+		properties = prop;
+	}
+
+	public static String getProperty(String key){
+		return properties.getProperty(key);
+	}
+	
+	public static Properties getProperties() {
+		return properties;
+	}
+}
diff --git a/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdp.java b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdp.java
new file mode 100644
index 00000000..a440a7e1
--- /dev/null
+++ b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdp.java
@@ -0,0 +1,39 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * feature-active-standby-management
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.activestandby;
+
+import java.util.Date;
+
+public interface DroolsPdp {
+
+	public String getPdpId();
+	public boolean isDesignated();
+	public int getPriority();
+	public Date getUpdatedDate();
+	public void setDesignated(boolean isDesignated);
+	public void setUpdatedDate(Date updatedDate);
+	public int comparePriority(DroolsPdp other);
+	public int comparePriority(DroolsPdp other,String previousSite);
+	public String getSiteName();
+	public void setSiteName(String siteName);
+	public Date getDesignatedDate();
+	public void setDesignatedDate(Date designatedDate);
+}
diff --git a/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdpEntity.java b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdpEntity.java
new file mode 100644
index 00000000..ec1ce579
--- /dev/null
+++ b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdpEntity.java
@@ -0,0 +1,137 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * feature-active-standby-management
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.activestandby;
+
+import java.io.Serializable;
+import java.util.Date;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.NamedQueries;
+import javax.persistence.NamedQuery;
+import javax.persistence.Temporal;
+import javax.persistence.TemporalType;
+
+import org.onap.policy.drools.activestandby.DroolsPdpObject;
+
+@Entity
+//@Table(name="DroolsPdpEntity")
+
+@NamedQueries({
+	@NamedQuery(name="DroolsPdpEntity.findAll", query="SELECT e FROM DroolsPdpEntity e "),
+	@NamedQuery(name="DroolsPdpEntity.deleteAll", query="DELETE FROM DroolsPdpEntity WHERE 1=1")
+})
+public class DroolsPdpEntity extends DroolsPdpObject implements Serializable{
+
+	private static final long serialVersionUID = 1L;
+	
+	@Id
+	@Column(name="pdpId", nullable=false)
+	private String pdpId="-1";
+	
+	@Column(name="designated", nullable=false)
+	private boolean designated=false;
+	
+	@Column(name="priority", nullable=false)
+	private int priority=0;
+	
+	@Temporal(TemporalType.TIMESTAMP)
+	@Column(name="updatedDate", nullable=false)
+	private Date updatedDate;
+	
+	@Temporal(TemporalType.TIMESTAMP)
+	@Column(name="designatedDate",nullable=false)
+	private Date designatedDate;
+	
+	@Column(name="site", nullable=true, length = 50)
+	private String site;
+	
+	
+	public DroolsPdpEntity(){
+		updatedDate = new Date();
+		//When this is translated to a TimeStamp in MySQL, it assumes the date is relative
+		//to the local timezone.  So, a value of Date(0) is actually Dec 31 18:00:00 CST 1969
+		//which is an invalid value for the MySql TimeStamp 
+		designatedDate = new Date(864000000);
+	}
+
+	@Override
+	public String getPdpId() {
+		return this.pdpId;
+	}
+	
+	public void setPdpId(String pdpId) {
+		this.pdpId = pdpId;
+	}
+	
+	@Override
+	public boolean isDesignated() {
+		return this.designated;
+	}
+
+	@Override
+	public int getPriority() {
+		return this.priority;
+	}
+
+	public void setPriority(int priority) {
+		this.priority = priority;
+	}
+
+	@Override
+	public Date getUpdatedDate() {
+		return this.updatedDate;
+	}
+
+	@Override
+	public void setDesignated(boolean isDesignated) {		
+		this.designated=isDesignated;		
+	}
+
+	@Override
+	public void setUpdatedDate(Date updatedDate) {
+		this.updatedDate=updatedDate;
+	}
+
+	
+	@Override
+	public String getSiteName() {
+		return site;
+	}
+
+	@Override
+	public void setSiteName(String siteName) {
+		site = siteName;
+		
+	}
+
+	@Override
+	public Date getDesignatedDate() {
+		return designatedDate;
+	}
+
+	@Override
+	public void setDesignatedDate(Date designatedDate) {
+		this.designatedDate = designatedDate;		
+	}
+
+}
diff --git a/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdpImpl.java b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdpImpl.java
new file mode 100644
index 00000000..141d5857
--- /dev/null
+++ b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdpImpl.java
@@ -0,0 +1,92 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * feature-active-standby-management
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.activestandby;
+
+import java.util.Date;
+
+public class DroolsPdpImpl extends DroolsPdpObject {
+
+	private boolean designated;
+	private int priority;
+	private Date updatedDate;
+	private Date designatedDate;
+	private String pdpId;
+	private String site;
+	
+	public DroolsPdpImpl(String pdpId, boolean designated, int priority, Date updatedDate){
+		this.pdpId = pdpId;
+		this.designated = designated;
+		this.priority = priority;
+		this.updatedDate = updatedDate;
+		//When this is translated to a TimeStamp in MySQL, it assumes the date is relative
+		//to the local timezone.  So, a value of Date(0) is actually Dec 31 18:00:00 CST 1969
+		//which is an invalid value for the MySql TimeStamp 
+		this.designatedDate = new Date(864000000);
+
+	}
+	@Override
+	public boolean isDesignated() {
+		
+		return designated;
+	}
+
+	@Override
+	public int getPriority() {		
+		return priority;
+	}
+	@Override
+	public void setUpdatedDate(Date date){
+		this.updatedDate = date;
+	}
+	@Override
+	public Date getUpdatedDate() {		
+		return updatedDate;
+	}
+	
+	@Override
+	public String getPdpId() {		
+		return pdpId;
+	}
+	@Override
+	public void setDesignated(boolean isDesignated) {		
+		this.designated = isDesignated;
+		
+	}
+
+	@Override
+	public String getSiteName() {
+		return site;
+	}
+	@Override
+	public void setSiteName(String siteName) {
+		this.site = siteName;
+		
+	}
+	@Override
+	public Date getDesignatedDate() {
+		return designatedDate;
+	}
+	@Override
+	public void setDesignatedDate(Date designatedDate) {
+		this.designatedDate = designatedDate;
+		
+	}
+}
diff --git a/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdpObject.java b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdpObject.java
new file mode 100644
index 00000000..e434c834
--- /dev/null
+++ b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdpObject.java
@@ -0,0 +1,71 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * feature-active-standby-management
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.activestandby;
+
+
+public abstract class DroolsPdpObject implements DroolsPdp{
+	
+	@Override
+	public boolean equals(Object other){
+		if(other instanceof DroolsPdp){
+		return this.getPdpId().equals(((DroolsPdp)other).getPdpId());
+		}else{
+			return false;
+		}
+	}
+	private int nullSafeCompare(String one, String two){
+		if(one != null && two != null){
+			return one.compareTo(two);
+		}
+		if(one == null && two != null){
+			return -1;
+		}
+		if(one != null && two == null){
+			return 1;
+		}
+		return 0;
+	}
+	@Override
+	public int comparePriority(DroolsPdp other){
+		if(nullSafeCompare(this.getSiteName(),other.getSiteName()) == 0){
+		if(this.getPriority() != other.getPriority()){
+			return this.getPriority() - other.getPriority();
+		}
+		return this.getPdpId().compareTo(other.getPdpId());
+		} else {
+			return nullSafeCompare(this.getSiteName(),other.getSiteName());
+		}
+	}
+	@Override
+	public int comparePriority(DroolsPdp other, String previousSite){
+		if(previousSite == null || previousSite.equals("")){
+			return comparePriority(other);
+		}
+		if(nullSafeCompare(this.getSiteName(),other.getSiteName()) == 0){
+			if(this.getPriority() != other.getPriority()){
+				return this.getPriority() - other.getPriority();
+			}
+			return this.getPdpId().compareTo(other.getPdpId());
+		} else {
+			return nullSafeCompare(this.getSiteName(),other.getSiteName());
+		}
+	}
+}
diff --git a/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdpsConnector.java b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdpsConnector.java
new file mode 100644
index 00000000..d0d33f0f
--- /dev/null
+++ b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdpsConnector.java
@@ -0,0 +1,63 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * feature-active-standby-management
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.activestandby;
+
+import java.util.Collection;
+
+public interface DroolsPdpsConnector {
+
+	
+	//return a list of PDPs, NOT including this PDP
+	public Collection<DroolsPdp> getDroolsPdps();
+	
+	public void update(DroolsPdp pdp);
+	
+	//determines if the DroolsPdp parameter is considered "current" or expired (has it been too long since the Pdp sent an update)
+	public boolean isPdpCurrent(DroolsPdp pdp);
+	
+	// Updates DESIGNATED boolean in PDP record.
+	public void setDesignated(DroolsPdp pdp, boolean designated);
+	
+	// Marks droolspdpentity.DESIGNATED=false, so another PDP-D will go active.
+	public void standDownPdp(String pdpId);
+			
+	// This is used in a JUnit test environment to manually
+	// insert a PDP
+	public void insertPdp(DroolsPdp pdp);
+	
+	// This is used in a JUnit test environment to manually
+	// delete a PDP
+	public void deletePdp(String pdpId);
+		
+	// This is used in a JUnit test environment to manually
+	// clear the droolspdpentity table.
+	public void deleteAllPdps();
+	
+	// This is used in a JUnit test environment to manually
+	// get a PDP
+	public DroolsPdpEntity getPdp(String pdpId);
+	
+	// Used by DroolsPdpsElectionHandler to determine if the currently designated
+	// PDP has failed.
+	public boolean hasDesignatedPdpFailed(Collection<DroolsPdp> pdps);
+
+	
+}
diff --git a/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdpsElectionHandler.java b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdpsElectionHandler.java
new file mode 100644
index 00000000..6edf11f8
--- /dev/null
+++ b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/DroolsPdpsElectionHandler.java
@@ -0,0 +1,1076 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * feature-active-standby-management
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.activestandby;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+import java.util.Timer;
+import java.util.TimerTask;
+
+import org.onap.policy.common.im.StateManagement;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.onap.policy.drools.statemanagement.StateManagementFeatureAPI;
+
+public class DroolsPdpsElectionHandler implements ThreadRunningChecker {
+	// get an instance of logger 
+	private final static Logger  logger = LoggerFactory.getLogger(DroolsPdpsElectionHandler.class);	
+	private DroolsPdpsConnector pdpsConnector;
+	private Object pdpsConnectorLock = new Object();
+	private Object checkUpdateWorkerLock = new Object();
+	private Object checkWaitTimerLock = new Object();
+	private Object designationWaiterLock = new Object();
+	
+	/*
+	 * Must be static, so it can be referenced by JpaDroolsPdpsConnector,
+	 * without requiring a reference to the election handler instantiation.
+	 */
+	private static DroolsPdp myPdp;
+	
+	private DesignationWaiter designationWaiter;
+	private Timer updateWorker;
+	private Timer waitTimer;
+	private Date updateWorkerLastRunDate;
+	private Date waitTimerLastRunDate;
+	private int pdpCheckInterval;
+	private int pdpUpdateInterval;
+	private volatile boolean isDesignated;
+
+	private String pdpdNowActive;
+	private String pdpdLastActive;
+	
+	private StateManagementFeatureAPI stateManagementFeature;
+	
+	public DroolsPdpsElectionHandler(DroolsPdpsConnector pdps, DroolsPdp myPdp){
+		pdpdNowActive = null;
+		pdpdLastActive = null;
+		this.pdpsConnector = pdps;
+		DroolsPdpsElectionHandler.myPdp = myPdp;
+		this.isDesignated = false;
+		pdpCheckInterval = 3000;
+		try{
+			pdpCheckInterval = Integer.parseInt(ActiveStandbyProperties.getProperty(ActiveStandbyProperties.PDP_CHECK_INVERVAL));
+		}catch(Exception e){
+			logger.error
+			("Could not get pdpCheckInterval property. Using default", e);
+		}
+		pdpUpdateInterval = 2000;
+		try{
+			pdpUpdateInterval = Integer.parseInt(ActiveStandbyProperties.getProperty(ActiveStandbyProperties.PDP_UPDATE_INTERVAL));
+		}catch(Exception e){
+			logger.error
+			("Could not get pdpUpdateInterval property. Using default", e);
+		}	
+
+		Date now = new Date();
+
+		// Retrieve the ms since the epoch
+		long nowMs = now.getTime();
+
+		// Create the timer which will update the updateDate in DroolsPdpEntity table.
+		// This is the heartbeat 
+		updateWorker = new Timer();
+
+		// Schedule the heartbeat to start in 100 ms and run at pdpCheckInterval ms thereafter
+		// NOTE: The first run of the TimerUpdateClass results in myPdp being added to the 
+		// drools droolsPdpEntity table.
+		updateWorker.scheduleAtFixedRate(new TimerUpdateClass(), 100, pdpCheckInterval);
+		updateWorkerLastRunDate = new Date(nowMs + 100);
+
+		// Create the timer which will run the election algorithm
+		waitTimer = new Timer();
+
+		// Schedule it to start in startMs ms (so it will run after the updateWorker and run at pdpUpdateInterval ms thereafter
+		long startMs = getDWaiterStartMs();
+		designationWaiter = new DesignationWaiter();
+		waitTimer.scheduleAtFixedRate(designationWaiter, startMs, pdpUpdateInterval);
+		waitTimerLastRunDate = new Date(nowMs + startMs);
+
+		//Get the StateManagementFeature instance
+		
+		for (StateManagementFeatureAPI feature : StateManagementFeatureAPI.impl.getList())
+		{
+			if (feature.getResourceName().equals(myPdp.getPdpId()))
+			{
+				if(logger.isDebugEnabled()){
+					logger.debug("DroolsPdpsElectionHandler: Found StateManagementFeature"
+						+ " with resourceName: {}", myPdp.getPdpId());
+				}
+				stateManagementFeature = feature;
+				break;
+			}
+		}
+		if(stateManagementFeature == null){
+			logger.error("DroolsPdpsElectionHandler failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", myPdp.getPdpId());
+		}
+	}
+	
+	/*
+	 * When the JpaDroolsPdpsConnector.standDown() method is invoked, it needs
+	 * access to myPdp, so it can keep its designation status in sync with the
+	 * DB.
+	 */
+	public static void setMyPdpDesignated(boolean designated) {
+		if(logger.isDebugEnabled()){
+			logger.debug
+			("setMyPdpDesignated: designated= {}", designated);
+		}
+		myPdp.setDesignated(designated);
+	}
+	
+	private class DesignationWaiter extends TimerTask {
+		// get an instance of logger 
+		private final Logger  logger = LoggerFactory.getLogger(DesignationWaiter.class);
+
+		@Override
+		public void run() {
+			try{
+				if(logger.isDebugEnabled()){
+					logger.debug
+					("DesignatedWaiter.run: Entering");
+				}
+				
+				// just here initially so code still works
+				if (pdpsConnector == null) {
+					waitTimerLastRunDate = new Date();
+					if(logger.isDebugEnabled()){
+						logger.debug("DesignatedWaiter.run (pdpsConnector==null) waitTimerLastRunDate = {}", waitTimerLastRunDate);
+					}
+					
+					return;
+				}
+
+				synchronized (designationWaiterLock) {
+
+					if(logger.isDebugEnabled()){
+						logger.debug
+						("DesignatedWaiter.run: Entering synchronized block");
+					}
+
+					checkUpdateWorkerTimer();
+					
+					//It is possible that multiple PDPs are designated lead.  So, we will make a list of all designated
+					//PDPs and then decide which one really should be designated at the end.
+					ArrayList<DroolsPdp> listOfDesignated = new ArrayList<DroolsPdp>();
+
+					Collection<DroolsPdp> pdps = pdpsConnector.getDroolsPdps();
+					DroolsPdp designatedPdp = null;
+
+					if(logger.isDebugEnabled()){
+						logger.debug
+						("DesignatedWaiter.run: pdps.size= {}", pdps.size());
+					}
+
+					//This is only true if all designated PDPs have failed
+					boolean designatedPdpHasFailed = pdpsConnector.hasDesignatedPdpFailed(pdps);
+					if(logger.isDebugEnabled()){
+						logger.debug
+						("DesignatedWaiter.run: designatedPdpHasFailed= {}", designatedPdpHasFailed);
+					}
+					for (DroolsPdp pdp : pdps) {
+						if(logger.isDebugEnabled()){
+							logger.debug
+							("DesignatedWaiter.run: evaluating pdp ID: {}", pdp.getPdpId());
+						}
+
+						/*
+						 * Note: side effect of isPdpCurrent is that any stale but
+						 * designated PDPs will be marked as un-designated.
+						 */
+						boolean isCurrent = pdpsConnector.isPdpCurrent(pdp);
+
+						/*
+						 * We can't use stateManagement.getStandbyStatus() here, because
+						 * we need the standbyStatus, not for this PDP, but for the PDP
+						 * being processed by this loop iteration.
+						 */
+						String standbyStatus = stateManagementFeature.getStandbyStatus(pdp.getPdpId());
+						if(standbyStatus==null){
+							// Treat this case as a cold standby -- if we
+							// abort here, no sessions will be created in a
+							// single-node test environment.
+							standbyStatus = StateManagement.COLD_STANDBY;
+						}
+						if(logger.isDebugEnabled()){
+							logger.debug
+							("DesignatedWaiter.run: PDP= {},  isCurrent= {}", pdp.getPdpId(), isCurrent);
+						}
+
+						/*
+						 * There are 4 combinations of isDesignated and isCurrent.  We will examine each one in-turn
+						 * and evaluate the each pdp in the list of pdps against each combination.
+						 * 
+						 * This is the first combination of isDesignated and isCurrent
+						 */
+						if (pdp.isDesignated()  &&  isCurrent) { 
+							//It is current, but it could have a standbystatus=coldstandby / hotstandby
+							//If so, we need to stand it down and demote it
+							if(!standbyStatus.equals(StateManagement.PROVIDING_SERVICE)){
+								if(pdp.getPdpId().equals(myPdp.getPdpId())){
+									if(logger.isDebugEnabled()){
+										logger.debug
+										("\n\nDesignatedWaiter.run: myPdp {} is current and designated, "
+											+ "butstandbystatus is not providingservice. "
+											+ " Executing stateManagement.demote()" + "\n\n", myPdp.getPdpId());
+									}
+									// So, we must demote it
+									try {
+										//Keep the order like this.  StateManagement is last since it triggers controller shutdown
+										//This will change isDesignated and it can enter another if(combination) below
+										pdpsConnector.standDownPdp(pdp.getPdpId()); 
+										myPdp.setDesignated(false);
+										isDesignated = false;
+										if(!(standbyStatus.equals(StateManagement.HOT_STANDBY) || 
+												standbyStatus.equals(StateManagement.COLD_STANDBY))){
+											/*
+											 * Only demote it if it appears it has not already been demoted. Don't worry
+											 * about synching with the topic endpoint states.  That is done by the 
+											 * refreshStateAudit
+											 */
+											stateManagementFeature.demote();
+										}
+										//update the standbystatus to check in a later combination of isDesignated and isCurrent
+										standbyStatus=stateManagementFeature.getStandbyStatus(pdp.getPdpId());
+									} catch (Exception e) {
+										logger.error
+										("DesignatedWaiter.run: myPdp: {} "
+												+ "Caught Exception attempting to demote myPdp,"
+												+ "message= {}", myPdp.getPdpId(), e.getMessage());
+									}
+								}else{
+									// Don't demote a remote PDP that is current.  It should catch itself
+									if(logger.isDebugEnabled()){
+										logger.debug
+										("\n\nDesignatedWaiter.run: myPdp {} is current and designated, "
+											+ "but standbystatus is not providingservice. "
+											+ " Cannot execute stateManagement.demote() since it it is not myPdp\n\n", myPdp.getPdpId());
+									}
+								}
+
+							}else{
+								// If we get here, it is ok to be on the list
+								if(logger.isDebugEnabled()){
+									logger.debug
+									("DesignatedWaiter.run: PDP= {} is designated, current and {} Noting PDP as "
+										+ "designated, standbyStatus= {}", pdp.getPdpId(), standbyStatus, standbyStatus);
+								}
+								listOfDesignated.add(pdp);
+							}
+
+
+						}
+
+
+						/*
+						 * The second combination of isDesignated and isCurrent
+						 * 					
+						 * PDP is designated but not current; it has failed.   So we stand it down (it doesn't matter what
+						 * its standbyStatus is). None of these go on the list.
+						 */
+						if (pdp.isDesignated()  &&  !isCurrent) {
+							if(logger.isDebugEnabled()){
+								logger.debug
+								("INFO: DesignatedWaiter.run: PDP= {} is currently designated but is not current; "
+									+ "it has failed.  Standing down.  standbyStatus= {}", pdp.getPdpId(), standbyStatus);
+							}
+							/*
+							 * Changes designated to 0 but it is still potentially providing service
+							 * Will affect isDesignated, so, it can enter an if(combination) below
+							 */
+							pdpsConnector.standDownPdp(pdp.getPdpId()); 
+
+							//need to change standbystatus to coldstandby
+							if (pdp.getPdpId().equals(myPdp.getPdpId())){
+								if(logger.isDebugEnabled()){
+									logger.debug
+									("\n\nDesignatedWaiter.run: myPdp {} is not Current. "
+										+ " Executing stateManagement.disableFailed()\n\n", myPdp.getPdpId());
+								}
+								// We found that myPdp is designated but not current
+								// So, we must cause it to disableFail
+								try {
+									myPdp.setDesignated(false);
+									pdpsConnector.setDesignated(myPdp, false);
+									isDesignated = false;
+									stateManagementFeature.disableFailed();
+								} catch (Exception e) {
+									logger.error
+									("DesignatedWaiter.run: myPdp: {} Caught Exception "
+											+ "attempting to disableFail myPdp {}, message= {}",
+											myPdp.getPdpId(), myPdp.getPdpId(), e.getMessage());
+								}
+							} else { //it is a remote PDP that is failed
+								if(logger.isDebugEnabled()){
+									logger.debug
+									("\n\nDesignatedWaiter.run: PDP {} is not Current. "
+										+ " Executing stateManagement.disableFailed(otherResourceName)\n\n", pdp.getPdpId() );
+								}
+								// We found a PDP is designated but not current
+								// We already called standdown(pdp) which will change designated to false
+								// Now we need to disableFail it to get its states in synch.  The standbyStatus
+								// should equal coldstandby
+								try {
+									stateManagementFeature.disableFailed(pdp.getPdpId());
+								} catch (Exception e) {
+									logger.error
+									("DesignatedWaiter.run: for PDP {}  Caught Exception attempting to "
+											+ "disableFail({}), message= {}",
+											pdp.getPdpId(), pdp.getPdpId(), e.getMessage());
+								}
+
+							}
+							continue; //we are not going to do anything else with this pdp
+						} 
+
+						/*
+						 * The third combination of isDesignated and isCurrent
+						 * /*
+						 * If a PDP is not currently designated but is providing service (erroneous, but recoverable) or hot standby 
+						 * we can add it to the list of possible designated if all the designated have failed
+						 */
+						if (!pdp.isDesignated() && isCurrent){
+							if(!(standbyStatus.equals(StateManagement.HOT_STANDBY) ||
+									standbyStatus.equals(StateManagement.COLD_STANDBY))){
+								if(logger.isDebugEnabled()){
+									logger.debug("\n\nDesignatedWaiter.run: PDP {}"
+										+ " is NOT designated but IS current and"
+										+ " has a standbystatus= {}", pdp.getPdpId(), standbyStatus);
+								}
+								// Since it is current, we assume it can adjust its own state.
+								// We will demote if it is myPdp
+								if(pdp.getPdpId().equals(myPdp.getPdpId())){
+									//demote it
+									if(logger.isDebugEnabled()){
+										logger.debug("DesignatedWaiter.run: PDP {} going to "
+											+ "setDesignated = false and calling stateManagement.demote",  pdp.getPdpId());
+									}
+									try {
+										//Keep the order like this.  StateManagement is last since it triggers controller shutdown
+										pdpsConnector.setDesignated(myPdp, false);
+										myPdp.setDesignated(false);
+										isDesignated = false;
+										//This is definitely not a redundant call.  It is attempting to correct a problem
+										stateManagementFeature.demote();
+										//recheck the standbystatus
+										standbyStatus = stateManagementFeature.getStandbyStatus(pdp.getPdpId());
+									} catch (Exception e) {
+										logger.error
+										("DesignatedWaiter.run: myPdp: {} Caught Exception "
+												+ "attempting to demote myPdp {}, message = {}",  myPdp.getPdpId(),
+												myPdp.getPdpId(), e.getMessage());
+									}
+
+								}
+							}
+							if(standbyStatus.equals(StateManagement.HOT_STANDBY) && designatedPdpHasFailed){
+								//add it to the list
+								if(logger.isDebugEnabled()){
+									logger.debug
+									("INFO: DesignatedWaiter.run: PDP= {}"
+										+ " is not designated but is {} and designated PDP "
+										+ "has failed.  standbyStatus= {}", pdp.getPdpId(), 
+										standbyStatus, standbyStatus);
+								}
+								listOfDesignated.add(pdp);
+							}
+							continue; //done with this one
+						}
+
+						/*
+						 * The fourth combination of isDesignated and isCurrent
+						 * 
+						 * We are not going to put any of these on the list since it appears they have failed.
+
+						 * 
+						 */
+						if(!pdp.isDesignated() && !isCurrent) {
+							if(logger.isDebugEnabled()){
+								logger.debug
+								("INFO: DesignatedWaiter.run: PDP= {} "
+									+ "designated= {}, current= {}, "
+									+ "designatedPdpHasFailed= {}, "
+									+ "standbyStatus= {}",pdp.getPdpId(), 
+									pdp.isDesignated(), isCurrent, designatedPdpHasFailed, standbyStatus);
+							}
+							if(!standbyStatus.equals(StateManagement.COLD_STANDBY)){
+								//stand it down
+								//disableFail it
+								pdpsConnector.standDownPdp(pdp.getPdpId()); 
+								if(pdp.getPdpId().equals(myPdp.getPdpId())){
+									/*
+									 * I don't actually know how this condition could happen, but if it did, we would want
+									 * to declare it failed.
+									 */
+									if(logger.isDebugEnabled()){
+										logger.debug
+										("\n\nDesignatedWaiter.run: myPdp {} is !current and !designated, "
+											+ " Executing stateManagement.disableFailed()\n\n", myPdp.getPdpId());
+									}
+									// So, we must disableFail it
+									try {
+										//Keep the order like this.  StateManagement is last since it triggers controller shutdown
+										pdpsConnector.setDesignated(myPdp, false);
+										myPdp.setDesignated(false);
+										isDesignated = false;
+										stateManagementFeature.disableFailed();
+									} catch (Exception e) {
+										logger.error
+										("DesignatedWaiter.run: myPdp: {} Caught Exception attempting to "
+												+ "disableFail myPdp {}, message= {}", 
+												 myPdp.getPdpId(), myPdp.getPdpId(), e.getMessage());
+									}
+								}else{//it is remote
+									if(logger.isDebugEnabled()){
+										logger.debug
+										("\n\nDesignatedWaiter.run: myPdp {} is !current and !designated, "
+											+ " Executing stateManagement.disableFailed({})\n\n", 
+											myPdp.getPdpId(), pdp.getPdpId());
+									}
+									// We already called standdown(pdp) which will change designated to false
+									// Now we need to disableFail it to get its states in sync.  StandbyStatus = coldstandby
+									try {
+										stateManagementFeature.disableFailed(pdp.getPdpId());
+									} catch (Exception e) {
+										logger.error
+										("DesignatedWaiter.run: for PDP {}" 
+												+ " Caught Exception attempting to disableFail({})"
+												+ ", message=", pdp.getPdpId(), pdp.getPdpId(), e.getMessage());
+									}
+								}
+							}
+						}
+
+
+					} // end pdps loop
+
+					/*
+					 * We have checked the four combinations of isDesignated and isCurrent.  Where appropriate,
+					 * we added the PDPs to the potential list of designated pdps
+					 * 
+					 * We need to give priority to pdps on the same site that is currently being used
+					 * First, however, we must sanitize the list of designated to make sure their are
+					 * only designated members or non-designated members.  There should not be both in 
+					 * the list. Because there are real time delays, it is possible that both types could
+					 * be on the list.
+					 */
+					
+					listOfDesignated = santizeDesignatedList(listOfDesignated);
+
+					/*
+					 * We need to figure out the last pdp that was the primary so we can get the last site 
+					 * name and the last session numbers.  We need to create a "dummy" droolspdp since
+					 * it will be used in later comparisons and cannot be null.
+					 */
+					
+					DroolsPdp mostRecentPrimary = computeMostRecentPrimary(pdps, listOfDesignated);
+					
+					if(mostRecentPrimary != null){
+						pdpdLastActive = mostRecentPrimary.getPdpId();
+					}
+					
+					
+					/*
+					 * It is possible to get here with more than one pdp designated and providingservice. This normally
+					 * occurs when there is a race condition with multiple nodes coming up at the same time. If that is
+					 * the case we must determine which one is the one that should be designated and which one should
+					 * be demoted.
+					 * 
+					 * It is possible to have 0, 1, 2 or more but not all, or all designated.  
+					 *   If we have one designated and current, we chose it and are done
+					 *   If we have 2 or more, but not all, we must determine which one is in the same site as
+					 *   the previously designated pdp.
+					 */
+					
+					designatedPdp = computeDesignatedPdp(listOfDesignated, mostRecentPrimary);
+					if(designatedPdp != null){
+						pdpdNowActive = designatedPdp.getPdpId();
+					}
+
+					if (designatedPdp == null) {
+						logger.warn
+						("WARNING: DesignatedWaiter.run: No viable PDP found to be Designated. designatedPdp still null.");
+						// Just to be sure the parameters are correctly set
+						myPdp.setDesignated(false);
+						pdpsConnector.setDesignated(myPdp,false);
+						isDesignated = false;
+						
+						waitTimerLastRunDate = new Date();
+						if(logger.isDebugEnabled()){
+							logger.debug("DesignatedWaiter.run (designatedPdp == null) waitTimerLastRunDate = {}", waitTimerLastRunDate);
+						}
+						
+						return;
+						
+					} else if (designatedPdp.getPdpId().equals(myPdp.getPdpId())) {
+						if(logger.isDebugEnabled()){
+							logger.debug
+							("DesignatedWaiter.run: designatedPdp is PDP={}", myPdp.getPdpId());
+						}
+						/*
+						 * update function expects myPdp.isDesignated to be true.
+						 */
+						try {
+							//Keep the order like this.  StateManagement is last since it triggers controller init
+							myPdp.setDesignated(true);
+							myPdp.setDesignatedDate(new Date());
+							pdpsConnector.setDesignated(myPdp, true);
+							isDesignated = true;
+							String standbyStatus = stateManagementFeature.getStandbyStatus();
+							if(!standbyStatus.equals(StateManagement.PROVIDING_SERVICE)){
+								/*
+								 * Only call promote if it is not already in the right state.  Don't worry about
+								 * synching the lower level topic endpoint states.  That is done by the
+								 * refreshStateAudit.
+								 * Note that we need to fetch the session list from 'mostRecentPrimary'
+								 * at this point -- soon, 'mostRecentPrimary' will be set to this host.
+								 */
+								//this.sessions = mostRecentPrimary.getSessions();
+								stateManagementFeature.promote();
+							}
+						} catch (Exception e) {
+							logger.error
+							("ERROR: DesignatedWaiter.run: Caught Exception attempting to promote PDP={}"
+									+ ", message=", myPdp.getPdpId(), e.getMessage());
+							myPdp.setDesignated(false);
+							pdpsConnector.setDesignated(myPdp,false);
+							isDesignated = false;
+							//If you can't promote it, demote it
+							try {
+								String standbyStatus = stateManagementFeature.getStandbyStatus();
+								if(!(standbyStatus.equals(StateManagement.HOT_STANDBY) || 
+										standbyStatus.equals(StateManagement.COLD_STANDBY))){
+									/*
+									 * Only call demote if it is not already in the right state.  Don't worry about
+									 * synching the lower level topic endpoint states.  That is done by the
+									 * refreshStateAudit.
+									 */
+									stateManagementFeature.demote();
+								}
+							} catch (Exception e1) {
+								logger.error
+								("ERROR: DesignatedWaiter.run: Caught StandbyStatusException "
+										+ "attempting to promote then demote PDP={}, message=",
+										myPdp.getPdpId(), e1.getMessage());
+							}
+
+						} 
+						waitTimerLastRunDate = new Date();
+						if(logger.isDebugEnabled()){
+							logger.debug("DesignatedWaiter.run (designatedPdp.getPdpId().equals(myPdp.getPdpId())) "
+								+ "waitTimerLastRunDate = " + waitTimerLastRunDate);
+						}
+
+						return;
+					}
+					isDesignated = false;
+
+				} // end synchronized
+				if(logger.isDebugEnabled()){
+					logger.debug
+					("DesignatedWaiter.run: myPdp: {}; Returning, isDesignated= {}",
+						isDesignated, myPdp.getPdpId());
+				}
+
+				Date tmpDate = new Date();
+				if(logger.isDebugEnabled()){
+					logger.debug("DesignatedWaiter.run (end of run) waitTimerLastRunDate = {}", tmpDate);
+				}
+				
+				waitTimerLastRunDate = tmpDate;
+				
+			}catch(Exception e){
+				logger.error("DesignatedWaiter.run caught an unexpected exception: ", e);
+			}
+		} // end run
+	}
+	
+	public ArrayList<DroolsPdp> santizeDesignatedList(ArrayList<DroolsPdp> listOfDesignated){
+
+		boolean containsDesignated = false;
+		boolean containsHotStandby = false;
+		ArrayList<DroolsPdp> listForRemoval = new ArrayList<DroolsPdp>();
+		for(DroolsPdp pdp : listOfDesignated){
+			if(logger.isDebugEnabled()){
+				logger.debug
+				("DesignatedWaiter.run sanitizing: pdp = {}" 
+					+ " isDesignated = {}",pdp.getPdpId(), pdp.isDesignated());
+			}
+			if(pdp.isDesignated()){
+				containsDesignated = true;
+			}else {
+				containsHotStandby = true;
+				listForRemoval.add(pdp);
+			}
+		}
+		if(containsDesignated && containsHotStandby){
+			//remove the hot standby from the list
+			listOfDesignated.removeAll(listForRemoval);
+			containsHotStandby = false;
+		}
+		return listOfDesignated;
+	}
+	
+	public DroolsPdp computeMostRecentPrimary(Collection<DroolsPdp> pdps, ArrayList<DroolsPdp> listOfDesignated){
+		boolean containsDesignated = false;
+		for(DroolsPdp pdp : listOfDesignated){
+			if(pdp.isDesignated()){
+				containsDesignated = true;
+			}
+		}
+		DroolsPdp mostRecentPrimary = new DroolsPdpImpl(null, true, 1, new Date(0));
+		mostRecentPrimary.setSiteName(null);
+		if(logger.isDebugEnabled()){
+			logger.debug
+			("DesignatedWaiter.run listOfDesignated.size() = {}", listOfDesignated.size());
+		}
+		if(listOfDesignated.size() <=1){
+			if(logger.isDebugEnabled()){
+				logger.debug("DesignatedWainter.run: listOfDesignated.size <=1");
+			}
+			//Only one or none is designated or hot standby.  Choose the latest designated date
+			for(DroolsPdp pdp : pdps){
+				if(logger.isDebugEnabled()){
+					logger.debug
+					("DesignatedWaiter.run pdp = {}" 
+						+ " pdp.getDesignatedDate() = {}", pdp.getPdpId(), pdp.getDesignatedDate());
+				}
+				if(pdp.getDesignatedDate().compareTo(mostRecentPrimary.getDesignatedDate()) > 0){
+					mostRecentPrimary = pdp;
+					if(logger.isDebugEnabled()){
+						logger.debug
+						("DesignatedWaiter.run mostRecentPrimary = {}", mostRecentPrimary.getPdpId());
+					}
+				}
+			}
+		}else if(listOfDesignated.size() == pdps.size()){
+			if(logger.isDebugEnabled()){
+				logger.debug("DesignatedWainter.run: listOfDesignated.size = pdps.size() which is {}", pdps.size());
+			}
+			//They are all designated or all hot standby.
+			mostRecentPrimary = null;
+			for(DroolsPdp pdp : pdps){
+				if(mostRecentPrimary == null){
+					mostRecentPrimary = pdp;
+					continue;
+				}
+				if(containsDesignated){ //Choose the site of the first designated date
+					if(pdp.getDesignatedDate().compareTo(mostRecentPrimary.getDesignatedDate()) < 0){
+						mostRecentPrimary = pdp;
+						if(logger.isDebugEnabled()){
+							logger.debug
+							("DesignatedWaiter.run mostRecentPrimary = {}", mostRecentPrimary.getPdpId());
+						}
+					}
+				}else{ //Choose the site with the latest designated date
+					if(pdp.getDesignatedDate().compareTo(mostRecentPrimary.getDesignatedDate()) > 0){
+						mostRecentPrimary = pdp;
+						if(logger.isDebugEnabled()){
+							logger.debug
+							("DesignatedWaiter.run mostRecentPrimary = {}", mostRecentPrimary.getPdpId());
+						}
+					}
+				}
+			}
+		}else{
+			if(logger.isDebugEnabled()){
+				logger.debug("DesignatedWainter.run: Some but not all are designated or hot standby. ");
+			}
+			//Some but not all are designated or hot standby. 
+			if(containsDesignated){
+				if(logger.isDebugEnabled()){
+					logger.debug("DesignatedWainter.run: containsDesignated = {}", containsDesignated);
+				}
+				/*
+				 * The list only contains designated.  This is a problem.  It is most likely a race
+				 * condition that resulted in two thinking they should be designated. Choose the 
+				 * site with the latest designated date for the pdp not included on the designated list.
+				 * This should be the site that had the last designation before this race condition
+				 * occurred.
+				 */
+				for(DroolsPdp pdp : pdps){
+					if(listOfDesignated.contains(pdp)){
+						continue; //Don't consider this entry
+					}
+					if(pdp.getDesignatedDate().compareTo(mostRecentPrimary.getDesignatedDate()) > 0){
+						mostRecentPrimary = pdp;
+						if(logger.isDebugEnabled()){
+							logger.debug
+							("DesignatedWaiter.run mostRecentPrimary = {}", mostRecentPrimary.getPdpId());
+						}
+					}
+				}
+			}else{
+				if(logger.isDebugEnabled()){
+					logger.debug("DesignatedWainter.run: containsDesignated = {}", containsDesignated);
+				}
+				//The list only contains hot standby. Choose the site of the latest designated date
+				for(DroolsPdp pdp : pdps){
+					if(pdp.getDesignatedDate().compareTo(mostRecentPrimary.getDesignatedDate()) > 0){
+						mostRecentPrimary = pdp;
+						if(logger.isDebugEnabled()){
+							logger.debug
+							("DesignatedWaiter.run mostRecentPrimary = {}", mostRecentPrimary.getPdpId());
+						}
+					}
+				}
+			}
+		}
+		return mostRecentPrimary;
+	}
+	
+	public DroolsPdp computeDesignatedPdp(ArrayList<DroolsPdp> listOfDesignated, DroolsPdp mostRecentPrimary){
+		DroolsPdp designatedPdp = null;
+		DroolsPdp lowestPriorityPdp = null;
+		if(listOfDesignated.size() > 1){
+			if(logger.isDebugEnabled()){
+				logger.debug
+				("DesignatedWaiter.run: myPdp: {} listOfDesignated.size(): {}", myPdp.getPdpId(), listOfDesignated.size());
+			}
+			DroolsPdp rejectedPdp = null;
+			DroolsPdp lowestPrioritySameSite = null;
+			DroolsPdp lowestPriorityDifferentSite = null;
+			for(DroolsPdp pdp : listOfDesignated){
+				// We need to determine if another PDP is the lowest priority
+				if(nullSafeEquals(pdp.getSiteName(),mostRecentPrimary.getSiteName())){
+					if(lowestPrioritySameSite == null){
+						if(lowestPriorityDifferentSite != null){
+							rejectedPdp = lowestPriorityDifferentSite;
+						}
+						lowestPrioritySameSite = pdp;									
+					}else{
+						if(pdp.getPdpId().equals((lowestPrioritySameSite.getPdpId()))){
+							continue;//nothing to compare
+						}
+						if(pdp.comparePriority(lowestPrioritySameSite) <0){
+							if(logger.isDebugEnabled()){
+								logger.debug
+								("\nDesignatedWaiter.run: myPdp {}  listOfDesignated pdp ID: {}" 
+									+ " has lower priority than pdp ID: {}",myPdp.getPdpId(), pdp.getPdpId(),
+									lowestPrioritySameSite.getPdpId());
+							}
+							//we need to reject lowestPrioritySameSite
+							rejectedPdp = lowestPrioritySameSite;
+							lowestPrioritySameSite = pdp;
+						} else{
+							//we need to reject pdp and keep lowestPrioritySameSite
+							if(logger.isDebugEnabled()){
+								logger.debug
+								("\nDesignatedWaiter.run: myPdp {} listOfDesignated pdp ID: {} " 
+									+ " has higher priority than pdp ID: {}", myPdp.getPdpId(),pdp.getPdpId(),
+									lowestPrioritySameSite.getPdpId());
+							}
+							rejectedPdp = pdp;
+						}
+					}
+				} else{
+					if(lowestPrioritySameSite != null){
+						//if we already have a candidate for same site, we don't want to bother with different sites
+						rejectedPdp = pdp;
+					} else{
+						if(lowestPriorityDifferentSite == null){
+							lowestPriorityDifferentSite = pdp;
+							continue;
+						}
+						if(pdp.getPdpId().equals((lowestPriorityDifferentSite.getPdpId()))){
+							continue;//nothing to compare
+						}
+						if(pdp.comparePriority(lowestPriorityDifferentSite) <0){
+							if(logger.isDebugEnabled()){
+								logger.debug
+								("\nDesignatedWaiter.run: myPdp {} listOfDesignated pdp ID: {}" 
+									+ " has lower priority than pdp ID: {}", myPdp.getPdpId(), pdp.getPdpId(),
+									lowestPriorityDifferentSite.getPdpId());
+							}
+							//we need to reject lowestPriorityDifferentSite
+							rejectedPdp = lowestPriorityDifferentSite;
+							lowestPriorityDifferentSite = pdp;
+						} else{
+							//we need to reject pdp and keep lowestPriorityDifferentSite
+							if(logger.isDebugEnabled()){
+								logger.debug
+								("\nDesignatedWaiter.run: myPdp {} listOfDesignated pdp ID: {}" 
+									+ " has higher priority than pdp ID: {}", myPdp.getPdpId(), pdp.getPdpId(),
+									lowestPriorityDifferentSite.getPdpId());
+							}
+							rejectedPdp = pdp;
+						}
+					}
+				}
+				// If the rejectedPdp is myPdp, we need to stand it down and demote it.  Each pdp is responsible
+				// for demoting itself
+				if(rejectedPdp != null && nullSafeEquals(rejectedPdp.getPdpId(),myPdp.getPdpId())){
+					if(logger.isDebugEnabled()){
+						logger.debug
+						("\n\nDesignatedWaiter.run: myPdp: {} listOfDesignated myPdp ID: {}" 
+							+ " is NOT the lowest priority.  Executing stateManagement.demote()\n\n", myPdp.getPdpId(),
+							 myPdp.getPdpId());
+					}
+					// We found that myPdp is on the listOfDesignated and it is not the lowest priority
+					// So, we must demote it
+					try {
+						//Keep the order like this.  StateManagement is last since it triggers controller shutdown
+						myPdp.setDesignated(false);
+						pdpsConnector.setDesignated(myPdp, false);
+						isDesignated = false;
+						String standbyStatus = stateManagementFeature.getStandbyStatus();
+						if(!(standbyStatus.equals(StateManagement.HOT_STANDBY) || 
+								standbyStatus.equals(StateManagement.COLD_STANDBY))){
+							/*
+							 * Only call demote if it is not already in the right state.  Don't worry about
+							 * synching the lower level topic endpoint states.  That is done by the
+							 * refreshStateAudit.
+							 */
+							stateManagementFeature.demote();
+						}
+					} catch (Exception e) {
+						myPdp.setDesignated(false);
+						pdpsConnector.setDesignated(myPdp, false);
+						isDesignated = false;
+						logger.error
+						("DesignatedWaiter.run: myPdp: {} Caught Exception attempting to "
+								+ "demote myPdp {} myPdp.getPdpId(), message= {}", myPdp.getPdpId(), 
+								e.getMessage());
+					}
+				}
+			} //end: for(DroolsPdp pdp : listOfDesignated)
+			if(lowestPrioritySameSite != null){
+				lowestPriorityPdp = lowestPrioritySameSite;
+			} else {
+				lowestPriorityPdp = lowestPriorityDifferentSite;
+			}
+			//now we have a valid value for lowestPriorityPdp
+			if(logger.isDebugEnabled()){
+				logger.debug
+				("\n\nDesignatedWaiter.run: myPdp: {} listOfDesignated "
+					+ "found the LOWEST priority pdp ID: {} " 
+					+ " It is now the designatedPpd from the perspective of myPdp ID: {} \n\n",
+					 myPdp.getPdpId(), lowestPriorityPdp.getPdpId(), myPdp);
+			}
+			designatedPdp = lowestPriorityPdp;
+
+		} else if(listOfDesignated.isEmpty()){
+			if(logger.isDebugEnabled()){
+				logger.debug
+				("\nDesignatedWaiter.run: myPdp: {} listOfDesignated is: EMPTY.", myPdp.getPdpId());
+			}
+			designatedPdp = null;
+		} else{ //only one in listOfDesignated
+			if(logger.isDebugEnabled()){
+				logger.debug
+				("\nDesignatedWaiter.run: myPdp: {} listOfDesignated "
+					+ "has ONE entry. PDP ID: {}", myPdp.getPdpId(), listOfDesignated.get(0).getPdpId());
+			}
+			designatedPdp = listOfDesignated.get(0);
+		}
+		return designatedPdp;
+
+	}
+	
+	private class TimerUpdateClass extends TimerTask{
+
+		@Override
+		public void run() {
+			try{
+				if(logger.isDebugEnabled()){
+					logger.debug("TimerUpdateClass.run: entry");
+				}
+				checkWaitTimer();
+				synchronized(pdpsConnectorLock){
+					
+					myPdp.setUpdatedDate(new Date());
+					/*
+					Redundant with DesignationWaiter and this updates the date every
+					cycle instead of just when the state changes.			
+					if(myPdp.isDesignated()){
+						myPdp.setDesignatedDate(new Date());
+					}
+ 					*/					
+					pdpsConnector.update(myPdp);
+					
+					Date tmpDate = new Date();
+					if(logger.isDebugEnabled()){
+						logger.debug("TimerUpdateClass.run: updateWorkerLastRunDate = {}", tmpDate);
+					}
+					
+					updateWorkerLastRunDate = tmpDate;
+				}
+				if(logger.isDebugEnabled()){
+					logger.debug("TimerUpdateClass.run.exit");
+				}
+			}catch(Exception e){
+				logger.error("TimerUpdateClass.run caught an unexpected exception: ", e);
+			}
+		}
+	}
+	@Override
+	public void checkThreadStatus() {
+		checkUpdateWorkerTimer();
+		checkWaitTimer();
+	}
+
+	private void checkUpdateWorkerTimer(){
+		synchronized(checkUpdateWorkerLock){
+			try{
+				if(logger.isDebugEnabled()){
+					logger.debug("checkUpdateWorkerTimer: entry");
+				}
+				Date now = new Date();
+				long nowMs = now.getTime();
+				long updateWorkerMs = updateWorkerLastRunDate.getTime();
+				//give it 2 second cushion
+				if((nowMs - updateWorkerMs)  > pdpCheckInterval + 2000){
+					logger.error("checkUpdateWorkerTimer: nowMs - updateWorkerMs = {} " 
+							+ ", exceeds pdpCheckInterval + 2000 = {} "
+							+ "Will reschedule updateWorker timer",(nowMs - updateWorkerMs), (pdpCheckInterval + 2000));
+
+					try{
+						updateWorker.cancel();
+						// Recalculate the time because this is a synchronized section and the thread could have
+						// been blocked.
+						now = new Date();
+						nowMs = now.getTime();
+						updateWorker = new Timer();
+						// reset the updateWorkerLastRunDate
+						updateWorkerLastRunDate = new Date(nowMs + 100);
+						//execute the first time in 100 ms
+						updateWorker.scheduleAtFixedRate(new TimerUpdateClass(), 100, pdpCheckInterval);
+						if(logger.isDebugEnabled()){
+							logger.debug("checkUpdateWorkerTimer: Scheduling updateWorker timer to start in 100 ms ");
+						}
+					}catch(Exception e){
+						logger.error("checkUpdateWorkerTimer: Caught unexpected Exception: ", e);
+						// Recalculate the time because this is a synchronized section and the thread could have
+						// been blocked.
+						now = new Date();
+						nowMs = now.getTime();
+						updateWorker = new Timer();
+						updateWorkerLastRunDate = new Date(nowMs + 100);
+						updateWorker.scheduleAtFixedRate(new TimerUpdateClass(), 100, pdpCheckInterval);
+						if(logger.isDebugEnabled()){
+							logger.debug("checkUpdateWorkerTimer: Attempting to schedule updateWorker timer in 100 ms");
+						}
+					}
+
+				}
+				if(logger.isDebugEnabled()){
+					logger.debug("checkUpdateWorkerTimer: exit");
+				}
+			}catch(Exception e){
+				logger.error("checkUpdateWorkerTimer: caught unexpected exception: ", e);
+			}
+		}
+	}
+
+	private void checkWaitTimer(){
+		synchronized(checkWaitTimerLock){
+			try{
+				if(logger.isDebugEnabled()){
+					logger.debug("checkWaitTimer: entry");
+				}
+				Date now = new Date();
+				long nowMs = now.getTime();
+				long waitTimerMs = waitTimerLastRunDate.getTime();
+
+				//give it 2 times leeway  
+				if((nowMs - waitTimerMs)  > 2*pdpUpdateInterval){
+					logger.error("checkWaitTimer: nowMs - waitTimerMs = {}" 
+							+ ", exceeds pdpUpdateInterval + 2000 = {}"
+							+ "Will reschedule waitTimer timer", (nowMs - waitTimerMs), (2*pdpUpdateInterval));
+
+					try{
+						// Recalculate since the thread could have been stalled on the synchronize()
+						nowMs = (new Date()).getTime();
+						// Time to the start of the next pdpUpdateInterval multiple
+						long startMs = getDWaiterStartMs();
+						waitTimer.cancel();
+						designationWaiter = new DesignationWaiter();
+						waitTimer = new Timer();
+						waitTimerLastRunDate = new Date(nowMs + startMs);
+						waitTimer.scheduleAtFixedRate(designationWaiter, startMs, pdpUpdateInterval);
+						if(logger.isDebugEnabled()){
+							logger.debug("checkWaitTimer: Scheduling waitTimer timer to start in {} ms", startMs);
+						}
+					}catch(Exception e){
+						logger.error("checkWaitTimer: Caught unexpected Exception: ", e);
+						// Recalculate since the thread could have been stalled on the synchronize()
+						nowMs = (new Date()).getTime();
+						// Time to the start of the next pdpUpdateInterval multiple
+						long startMs = getDWaiterStartMs();
+						designationWaiter = new DesignationWaiter();
+						waitTimer = new Timer();
+						waitTimerLastRunDate = new Date(nowMs + startMs);
+						waitTimer.scheduleAtFixedRate(designationWaiter, startMs, pdpUpdateInterval);
+						if(logger.isDebugEnabled()){
+							logger.debug("checkWaitTimer: Scheduling waitTimer timer in {} ms", startMs);
+						}
+					}
+
+				}
+				if(logger.isDebugEnabled()){
+					logger.debug("checkWaitTimer: exit");
+				}
+			}catch(Exception e){
+				logger.error("checkWaitTimer: caught unexpected exception: ", e);
+			}
+		}
+	}
+	
+	private long getDWaiterStartMs(){
+		Date now = new Date();
+		
+		// Retrieve the ms since the epoch
+		long nowMs = now.getTime();
+		
+		// Time since the end of the last pdpUpdateInterval multiple
+		long nowModMs = nowMs % pdpUpdateInterval;
+		
+		// Time to the start of the next pdpUpdateInterval multiple
+		long startMs = 2*pdpUpdateInterval - nowModMs;
+
+		// Give the start time a minimum of a 5 second cushion
+		if(startMs < 5000){
+			// Start at the beginning  of following interval
+			startMs = pdpUpdateInterval + startMs;
+		}
+		return startMs;
+	}
+	
+	private boolean nullSafeEquals(Object one, Object two){
+		if(one == null && two == null){
+			return true;
+		}
+		if(one != null && two != null){
+			return one.equals(two);
+		}
+		return false;
+	}
+	
+	public String getPdpdNowActive(){
+		return pdpdNowActive;
+	}
+	
+	public String getPdpdLastActive(){
+		return pdpdLastActive;
+	}
+}
diff --git a/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/JpaDroolsPdpsConnector.java b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/JpaDroolsPdpsConnector.java
new file mode 100644
index 00000000..0d931acc
--- /dev/null
+++ b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/JpaDroolsPdpsConnector.java
@@ -0,0 +1,636 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * feature-active-standby-management
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.activestandby;
+
+import java.util.Collection;
+import java.util.Date;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.FlushModeType;
+import javax.persistence.LockModeType;
+import javax.persistence.Query;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class JpaDroolsPdpsConnector implements DroolsPdpsConnector {
+
+	// get an instance of logger 
+	private static final Logger  logger = LoggerFactory.getLogger(JpaDroolsPdpsConnector.class);
+	private EntityManagerFactory emf;
+		
+	
+	//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
+	public JpaDroolsPdpsConnector(EntityManagerFactory emf){
+		this.emf = emf;		
+	}
+	@Override
+	public Collection<DroolsPdp> getDroolsPdps() {
+		//return a list of all the DroolsPdps in the database
+		EntityManager em = emf.createEntityManager();
+		try {
+			em.getTransaction().begin();
+			Query droolsPdpsListQuery = em.createQuery("SELECT p FROM DroolsPdpEntity p");
+			List<?> droolsPdpsList = droolsPdpsListQuery.setLockMode(LockModeType.NONE).setFlushMode(FlushModeType.COMMIT).getResultList();
+			LinkedList<DroolsPdp> droolsPdpsReturnList = new LinkedList<DroolsPdp>();
+			for(Object o : droolsPdpsList){
+				if(o instanceof DroolsPdp){
+					//Make sure it is not a cached version
+					em.refresh((DroolsPdpEntity)o);
+					droolsPdpsReturnList.add((DroolsPdp)o);
+					if (logger.isDebugEnabled()) {
+						DroolsPdp droolsPdp = (DroolsPdp)o;
+						logger.debug("getDroolsPdps: PDP= {}"
+								+ ", isDesignated= {}"
+								+ ", updatedDate= {}"
+								+ ", priority= {}", droolsPdp.getPdpId(), droolsPdp.isDesignated(),
+								 droolsPdp.getUpdatedDate(), droolsPdp.getPriority());
+					}
+				}
+			}
+			try{
+			em.getTransaction().commit();
+			}catch(Exception e){
+				  logger.error
+					("Cannot commit getDroolsPdps() transaction", e);
+			}
+			return droolsPdpsReturnList;
+		} finally {
+			cleanup(em, "getDroolsPdps");
+		}
+	}
+
+	private boolean nullSafeEquals(Object one, Object two){
+		if(one == null && two == null){
+			return true;
+		}
+		if(one != null && two != null){
+			return one.equals(two);
+		}
+		return false;
+	}
+	
+	@Override
+	public void update(DroolsPdp pdp) {
+		
+		if (logger.isDebugEnabled()) {
+			logger.debug("update: Entering, pdpId={}", pdp.getPdpId());
+		}
+		
+		//this is to update our own pdp in the database
+		EntityManager em = emf.createEntityManager();
+		try {
+			em.getTransaction().begin();
+			Query droolsPdpsListQuery = em.createQuery("SELECT p FROM DroolsPdpEntity p WHERE p.pdpId=:pdpId");
+			droolsPdpsListQuery.setParameter("pdpId", pdp.getPdpId());
+			List<?> droolsPdpsList = droolsPdpsListQuery.setLockMode(LockModeType.NONE).setFlushMode(FlushModeType.COMMIT).getResultList();
+			DroolsPdpEntity droolsPdpEntity;
+			if(droolsPdpsList.size() == 1 && (droolsPdpsList.get(0) instanceof DroolsPdpEntity)){						
+				droolsPdpEntity = (DroolsPdpEntity)droolsPdpsList.get(0);
+				em.refresh(droolsPdpEntity); //Make sure we have current values
+				Date currentDate = new Date();
+				long difference = currentDate.getTime()-droolsPdpEntity.getUpdatedDate().getTime();
+				//just set some kind of default here
+				long pdpTimeout = 15000;
+				try{
+					pdpTimeout = Long.parseLong(ActiveStandbyProperties.getProperty(ActiveStandbyProperties.PDP_TIMEOUT));
+				}catch(Exception e){
+					  logger.error
+						("Could not get PDP timeout property, using default.", e);
+				}
+				boolean isCurrent = difference<pdpTimeout;
+				if (logger.isDebugEnabled()) {
+					logger.debug("update: PDP= {}, isCurrent={}"
+							+ " difference= {}"
+							+ ", pdpTimeout= {}, designated= {}",
+							pdp.getPdpId(), isCurrent, difference, pdpTimeout, droolsPdpEntity.isDesignated());
+				}
+			} else {
+				if (logger.isDebugEnabled()) {
+					logger.debug("update: For PDP={}"
+							+ ", instantiating new DroolsPdpEntity", pdp.getPdpId());
+				}
+				droolsPdpEntity = new DroolsPdpEntity();
+				em.persist(droolsPdpEntity);
+				droolsPdpEntity.setPdpId(pdp.getPdpId());				
+			}
+			if(droolsPdpEntity.getPriority() != pdp.getPriority()){
+				droolsPdpEntity.setPriority(pdp.getPriority());
+			}
+			if(!droolsPdpEntity.getUpdatedDate().equals(pdp.getUpdatedDate())){
+				droolsPdpEntity.setUpdatedDate(pdp.getUpdatedDate());
+			}
+			/*if(!droolsPdpEntity.getDesignatedDate().equals(pdp.getDesignatedDate())){
+				droolsPdpEntity.setDesignatedDate(pdp.getDesignatedDate());
+			} The designated date is only set below when this first becomes designated*/
+			if(!nullSafeEquals(droolsPdpEntity.getSiteName(),pdp.getSiteName())){
+				droolsPdpEntity.setSiteName(pdp.getSiteName());
+			}
+			
+			if(droolsPdpEntity.isDesignated() != pdp.isDesignated()){
+				if (logger.isDebugEnabled()) {
+					logger.debug("update: pdpId={}"
+							+ ", pdp.isDesignated={}"
+							+ ", droolsPdpEntity.pdpId= {}"
+							+ ", droolsPdpEntity.isDesignated={}",
+							 pdp.getPdpId(), pdp.isDesignated(),droolsPdpEntity.getPdpId(), droolsPdpEntity.isDesignated());
+				}
+				droolsPdpEntity.setDesignated(pdp.isDesignated());
+				//The isDesignated value is not the same and the new one == true
+				if(pdp.isDesignated()){
+					droolsPdpEntity.setDesignatedDate(new Date());
+				}
+			}
+			em.getTransaction().commit();
+		} finally {
+			cleanup(em, "update");
+		}
+		
+		if (logger.isDebugEnabled()) {
+			logger.debug("update: Exiting");
+		}
+
+	}
+
+	/*
+	 * Note: A side effect of this boolean method is that if the PDP is designated but not current, the 
+	 * droolspdpentity.DESIGNATED column will be set to false (the PDP will be un-designated, i.e. marked as
+	 * being in standby mode)
+	 */
+	@Override
+	public boolean isPdpCurrent(DroolsPdp pdp) {
+		
+		boolean isCurrent = isCurrent(pdp);
+		
+		EntityManager em = emf.createEntityManager();
+		try{
+		if(!isCurrent && pdp.isDesignated()){
+			em.getTransaction().begin();
+			Query droolsPdpsListQuery = em.createQuery("SELECT p FROM DroolsPdpEntity p WHERE p.pdpId=:pdpId");
+			droolsPdpsListQuery.setParameter("pdpId", pdp.getPdpId());
+			List<?> droolsPdpsList = droolsPdpsListQuery.setLockMode(LockModeType.NONE).setFlushMode(FlushModeType.COMMIT).getResultList();
+			if(droolsPdpsList.size() == 1 && droolsPdpsList.get(0) instanceof DroolsPdpEntity){			
+				if (logger.isDebugEnabled()) {
+					logger.debug("isPdpCurrent: PDP={}  designated but not current; setting designated to false", pdp.getPdpId());
+				}
+				DroolsPdpEntity droolsPdpEntity = (DroolsPdpEntity)droolsPdpsList.get(0);
+				droolsPdpEntity.setDesignated(false);
+				em.getTransaction().commit();
+			} else {
+				logger.warn("isPdpCurrent: PDP={} is designated but not current; "
+						+ "however it does not have a DB entry, so cannot set DESIGNATED to false!", pdp.getPdpId());
+			}
+		} else {
+			if (logger.isDebugEnabled()) {
+				logger.debug("isPdpCurrent: For PDP= {}, "
+						+ "designated={}, isCurrent={}", pdp.getPdpId(), pdp.isDesignated(), isCurrent);
+			}
+		}
+		}catch(Exception e){
+			  logger.error
+				("Could not update expired record marked as designated in the database", e);
+		} finally {
+			cleanup(em, "isPdpCurrent");
+		}
+		return isCurrent;
+		
+	}
+	
+	@Override
+	public void setDesignated(DroolsPdp pdp, boolean designated) {
+
+		if (logger.isDebugEnabled()) {
+			logger.debug("setDesignated: Entering, pdpId={}"
+					+ ", designated={}", pdp.getPdpId(), designated);
+		}
+
+		EntityManager em = null;
+		try {
+			em = emf.createEntityManager();
+			em.getTransaction().begin();
+			Query droolsPdpsListQuery = em
+					.createQuery("SELECT p FROM DroolsPdpEntity p WHERE p.pdpId=:pdpId");
+			droolsPdpsListQuery.setParameter("pdpId", pdp.getPdpId());
+			List<?> droolsPdpsList = droolsPdpsListQuery.setLockMode(
+					LockModeType.NONE).setFlushMode(FlushModeType.COMMIT).getResultList();
+			if (droolsPdpsList.size() == 1
+					&& droolsPdpsList.get(0) instanceof DroolsPdpEntity) {
+				DroolsPdpEntity droolsPdpEntity = (DroolsPdpEntity) droolsPdpsList
+						.get(0);
+
+				if (logger.isDebugEnabled()) {
+					logger.debug("setDesignated: PDP={}"
+							+ " found, designated= {}"
+							+ ", setting to {}", pdp.getPdpId(), droolsPdpEntity.isDesignated(),
+							 designated);
+				}
+				droolsPdpEntity.setDesignated(designated);
+				if(designated){
+					em.refresh(droolsPdpEntity); //make sure we get the DB value
+					if(!droolsPdpEntity.isDesignated()){ 
+						droolsPdpEntity.setDesignatedDate(new Date());
+					}
+				
+				}
+				em.getTransaction().commit();
+			} else {
+				logger.error("setDesignated: PDP={}"
+						+ " not in DB; cannot update designation", pdp.getPdpId());
+			}
+		} catch (Exception e) {
+			logger.error("setDesignated: Caught Exception", e);
+		} finally {
+			cleanup(em, "setDesignated");
+		}
+
+		if (logger.isDebugEnabled()) {
+			logger.debug("setDesignated: Exiting");
+		}
+
+	}
+	
+	
+	@Override
+	public void standDownPdp(String pdpId) {
+		if(logger.isDebugEnabled()){
+			logger.debug("standDownPdp: Entering, pdpId={}", pdpId);
+		}
+
+		EntityManager em = null;
+		try {
+			/*
+			 * Start transaction.
+			 */
+			em = emf.createEntityManager();
+			em.getTransaction().begin();
+
+			/*
+			 * Get droolspdpentity record for this PDP and mark DESIGNATED as
+			 * false.
+			 */
+			Query droolsPdpsListQuery = em
+					.createQuery("SELECT p FROM DroolsPdpEntity p WHERE p.pdpId=:pdpId");
+			droolsPdpsListQuery.setParameter("pdpId", pdpId);
+			List<?> droolsPdpsList = droolsPdpsListQuery.setLockMode(
+					LockModeType.NONE).setFlushMode(FlushModeType.COMMIT).getResultList();
+			DroolsPdpEntity droolsPdpEntity;
+			if (droolsPdpsList.size() == 1
+					&& (droolsPdpsList.get(0) instanceof DroolsPdpEntity)) {
+				droolsPdpEntity = (DroolsPdpEntity) droolsPdpsList.get(0);
+				droolsPdpEntity.setDesignated(false);
+				em.persist(droolsPdpEntity);
+				if(logger.isDebugEnabled()){
+					logger.debug("standDownPdp: PDP={} persisted as non-designated.", pdpId );
+				}
+			} else {
+				logger.error("standDownPdp: Missing record in droolspdpentity for pdpId={}"
+						+ "; cannot stand down PDP", pdpId);
+			}
+
+			/*
+			 * End transaction.
+			 */
+			em.getTransaction().commit();
+			cleanup(em, "standDownPdp");
+			em = null;
+			
+			// Keep the election handler in sync with the DB
+			DroolsPdpsElectionHandler.setMyPdpDesignated(false);
+
+		} catch (Exception e) {
+			logger.error("standDownPdp: Unexpected Exception attempting to mark "
+					+ "DESIGNATED as false for droolspdpentity, pdpId={}"
+					+ ".  Cannot stand down PDP; message={}", pdpId, e.getMessage(), e);
+		} finally {
+			cleanup(em, "standDownPdp");
+		}
+		if(logger.isDebugEnabled()){
+			logger.debug("standDownPdp: Exiting");
+		}
+
+	}
+	
+	/*
+	 * Determines whether or not a designated PDP has failed.
+	 * 
+	 * Note: The update method, which is run periodically by the
+	 * TimerUpdateClass, will un-designate a PDP that is stale.
+	 */
+	@Override
+	public boolean hasDesignatedPdpFailed(Collection<DroolsPdp> pdps) {
+
+		if (logger.isDebugEnabled()) {
+			logger.debug("hasDesignatedPdpFailed: Entering, pdps.size()={}", pdps.size());
+		}
+
+		boolean failed = true;
+		boolean foundDesignatedPdp = false;
+
+		for (DroolsPdp pdp : pdps) {
+
+			/*
+			 * Normally, the update method will un-designate any stale PDP, but
+			 * we check here to see if the PDP has gone stale since the update
+			 * method was run.
+			 * 
+			 * Even if we determine that the designated PDP is current, we keep
+			 * going (we don't break), so we can get visibility into the other
+			 * PDPs, when in DEBUG mode.
+			 */
+			if (pdp.isDesignated() && isCurrent(pdp)) {
+				if (logger.isDebugEnabled()) {
+					logger.debug("hasDesignatedPdpFailed: Designated PDP={} is current", pdp.getPdpId());
+				}
+				failed = false;
+				foundDesignatedPdp = true;
+			} else if (pdp.isDesignated() && !isCurrent(pdp)) {
+				logger.error("hasDesignatedPdpFailed: Designated PDP={} has failed", pdp.getPdpId());
+				foundDesignatedPdp = true;
+			} else {
+				if (logger.isDebugEnabled()) {
+					logger.debug("hasDesignatedPdpFailed: PDP={} is not designated", pdp.getPdpId());
+				}
+			}
+		}
+
+		if (logger.isDebugEnabled()) {
+			logger.debug("hasDesignatedPdpFailed: Exiting and returning, foundDesignatedPdp={}",
+					foundDesignatedPdp);
+		}
+		return failed;
+	}
+	
+	
+	private boolean isCurrent(DroolsPdp pdp) {
+	
+		if (logger.isDebugEnabled()) {
+			logger.debug("isCurrent: Entering, pdpId={}", pdp.getPdpId());
+		}
+	
+		boolean current = false;
+	
+		// Return if the current PDP is considered "current" based on whatever
+		// time box that may be.
+		// If the the PDP is not current, we should mark it as not primary in
+		// the database
+		Date currentDate = new Date();
+		long difference = currentDate.getTime()
+				- pdp.getUpdatedDate().getTime();
+		// just set some kind of default here
+		long pdpTimeout = 15000;
+		try {
+			pdpTimeout = Long.parseLong(ActiveStandbyProperties
+					.getProperty(ActiveStandbyProperties.PDP_TIMEOUT));
+			if (logger.isDebugEnabled()) {
+				logger.debug("isCurrent: pdp.timeout={}", pdpTimeout);
+			}		
+		} catch (Exception e) {
+			  logger.error
+				("isCurrent: Could not get PDP timeout property, using default.", e);
+		}
+		current = difference < pdpTimeout;
+	
+		if (logger.isDebugEnabled()) {
+			logger.debug("isCurrent: Exiting, difference={}, pdpTimeout={}"
+					+ "; returning current={}", difference, pdpTimeout, current);
+		}
+	
+		return current;
+	}
+	
+	
+	/*
+	 * Currently this method is only used in a JUnit test environment. Gets a
+	 * PDP record from droolspdpentity table.
+	 */
+	@Override
+	public DroolsPdpEntity getPdp(String pdpId) {
+	
+		if (logger.isDebugEnabled()) {
+			logger.debug("getPdp: Entering and getting PDP with pdpId={}", pdpId);
+		}
+	
+		DroolsPdpEntity droolsPdpEntity = null;
+	
+		EntityManager em = null;
+		try {
+			em = emf.createEntityManager();
+			em.getTransaction().begin();
+			Query droolsPdpsListQuery = em
+					.createQuery("SELECT p FROM DroolsPdpEntity p WHERE p.pdpId=:pdpId");
+			droolsPdpsListQuery.setParameter("pdpId", pdpId);
+			List<?> droolsPdpsList = droolsPdpsListQuery.setLockMode(
+					LockModeType.NONE).setFlushMode(FlushModeType.COMMIT).getResultList();
+			if (droolsPdpsList.size() == 1
+					&& droolsPdpsList.get(0) instanceof DroolsPdpEntity) {
+				droolsPdpEntity = (DroolsPdpEntity) droolsPdpsList.get(0);
+				if (logger.isDebugEnabled()) {
+					logger.debug("getPdp: PDP={}"
+							+ " found, isDesignated={},"
+							+ " updatedDate={}, "
+							+ "priority={}", pdpId,
+							droolsPdpEntity.isDesignated(), droolsPdpEntity.getUpdatedDate(),
+							droolsPdpEntity.getPriority());							
+				}
+				
+				// Make sure the droolsPdpEntity is not a cached version
+				em.refresh(droolsPdpEntity);
+				
+				em.getTransaction().commit();
+			} else {
+				logger.error("getPdp: PDP={} not found!?", pdpId);
+			}
+		} catch (Exception e) {
+			  logger.error
+				("getPdp: Caught Exception attempting to get PDP", e);
+		} finally {
+			cleanup(em, "getPdp");
+		}
+	
+		if (logger.isDebugEnabled()) {
+			logger.debug("getPdp: Returning droolsPdpEntity={}", droolsPdpEntity);
+		}
+		return droolsPdpEntity;
+	
+	}
+	
+	/*
+	 * Normally this method should only be used in a JUnit test environment.
+	 * Manually inserts a PDP record in droolspdpentity table.
+	 */
+	@Override
+	public void insertPdp(DroolsPdp pdp) {
+		if(logger.isDebugEnabled()){
+			logger.debug("insertPdp: Entering and manually inserting PDP");
+		}
+
+		/*
+		 * Start transaction
+		 */
+		EntityManager em = emf.createEntityManager();
+		try {
+			em.getTransaction().begin();
+
+			/*
+			 * Insert record.
+			 */
+			DroolsPdpEntity droolsPdpEntity = new DroolsPdpEntity();
+			em.persist(droolsPdpEntity);
+			droolsPdpEntity.setPdpId(pdp.getPdpId());
+			droolsPdpEntity.setDesignated(pdp.isDesignated());
+			droolsPdpEntity.setPriority(pdp.getPriority());
+			droolsPdpEntity.setUpdatedDate(pdp.getUpdatedDate());
+			droolsPdpEntity.setSiteName(pdp.getSiteName());
+
+			/*
+			 * End transaction.
+			 */
+			em.getTransaction().commit();
+		} finally {
+			cleanup(em, "insertPdp");
+		}
+		if(logger.isDebugEnabled()){
+			logger.debug("insertPdp: Exiting");
+		}
+
+	}
+	
+	/*
+	 * Normally this method should only be used in a JUnit test environment.
+	 * Manually deletes all PDP records in droolspdpentity table.
+	 */
+	@Override
+	public void deleteAllPdps() {
+	
+		if(logger.isDebugEnabled()){
+			logger.debug("deleteAllPdps: Entering");
+		}
+	
+		/*
+		 * Start transaction
+		 */
+		EntityManager em = emf.createEntityManager();
+		try {
+			em.getTransaction().begin();
+	
+			Query droolsPdpsListQuery = em
+					.createQuery("SELECT p FROM DroolsPdpEntity p");
+			@SuppressWarnings("unchecked")
+			List<DroolsPdp> droolsPdpsList = droolsPdpsListQuery.setLockMode(
+					LockModeType.NONE).setFlushMode(FlushModeType.COMMIT).getResultList();
+			if(logger.isDebugEnabled()){
+				logger.debug("deleteAllPdps: Deleting {} PDPs", droolsPdpsList.size());
+			}
+			for (DroolsPdp droolsPdp : droolsPdpsList) {
+				String pdpId = droolsPdp.getPdpId();
+				deletePdp(pdpId);
+			}
+	
+			/*
+			 * End transaction.
+			 */
+			em.getTransaction().commit();
+		} finally {
+			cleanup(em, "deleteAllPdps");
+		}
+		if(logger.isDebugEnabled()){
+			logger.debug("deleteAllPdps: Exiting");
+		}
+	
+	}
+	
+	/*
+	 * Normally this method should only be used in a JUnit test environment.
+	 * Manually deletes a PDP record in droolspdpentity table.
+	 */
+	@Override
+	public void deletePdp(String pdpId) {
+		if(logger.isDebugEnabled()){
+			logger.debug("deletePdp: Entering and manually deleting pdpId={}", pdpId);
+		}
+	
+		/*
+		 * Start transaction
+		 */
+		EntityManager em = emf.createEntityManager();
+		try {
+			em.getTransaction().begin();
+		
+			/*
+			 * Delete record.
+			 */
+			DroolsPdpEntity droolsPdpEntity = em.find(DroolsPdpEntity.class, pdpId);
+			if (droolsPdpEntity != null) {
+				if(logger.isDebugEnabled()){
+					logger.debug("deletePdp: Removing PDP");
+				}
+				em.remove(droolsPdpEntity);
+			} else {
+				if(logger.isDebugEnabled()){
+					logger.debug("deletePdp: PDP with ID={} not currently in DB", pdpId);
+				}
+			}
+
+			/*
+			 * End transaction.
+			 */
+			em.getTransaction().commit();
+		} finally {
+			cleanup(em, "deletePdp");
+		}
+		if(logger.isDebugEnabled()){
+			logger.debug("deletePdp: Exiting");
+		}
+	
+	}
+	
+	/*
+	 * Close the specified EntityManager, rolling back any pending transaction
+	 *
+	 * @param em the EntityManager to close ('null' is OK)
+	 * @param method the invoking Java method (used for log messages)
+	 */
+	private static void cleanup(EntityManager em, String method)
+	{
+		if (em != null) {
+			if (em.isOpen()) {
+				if (em.getTransaction().isActive()) {
+					// there is an active EntityTransaction -- roll it back
+					try {
+						em.getTransaction().rollback();
+					} catch (Exception e) {
+						logger.error(method + ": Caught Exception attempting to rollback EntityTransaction,", e);
+					}
+				}
+
+				// now, close the EntityManager
+				try {
+					em.close();
+				} catch (Exception e) {
+					logger.error(method + ": Caught Exception attempting to close EntityManager, ", e);
+				}
+			}
+		}
+	}
+}
diff --git a/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/PMStandbyStateChangeNotifier.java b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/PMStandbyStateChangeNotifier.java
new file mode 100644
index 00000000..ce62bf89
--- /dev/null
+++ b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/PMStandbyStateChangeNotifier.java
@@ -0,0 +1,345 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * feature-active-standby-management
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.activestandby; 
+ 
+/* 
+ * Per MultiSite_v1-10.ppt:
+ * 
+ * Extends the StateChangeNotifier class and overwrites the abstract handleStateChange() method to get state changes 
+ * and do the following: 
+ * 
+ * When the Standby Status changes (from providingservice) to hotstandby or coldstandby, 
+ * the Active/Standby selection algorithm must stand down if the PDP-D is currently the lead/active node 
+ * and allow another PDP-D to take over.  It must also call lock on all engines in the engine management.
+ * 
+ * When the Standby Status changes from (hotstandby) to coldstandby, the Active/Standby algorithm must NOT assume 
+ * the active/lead role.
+ *  
+ * When the Standby Status changes (from coldstandby or providingservice) to hotstandby, 
+ * the Active/Standby algorithm may assume the active/lead role if the active/lead fails.
+ * 
+ * When the Standby Status changes to providingservice (from hotstandby or coldstandby) call unlock on all 
+ * engines in the engine management layer.
+ */
+import java.util.Date;
+import java.util.Timer;
+import java.util.TimerTask;
+
+import org.onap.policy.common.im.StateChangeNotifier;
+import org.onap.policy.common.im.StateManagement;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.onap.policy.drools.system.PolicyEngine;
+
+/*
+ * Some background:
+ * 
+ * Originally, there was a "StandbyStateChangeNotifier" that belonged to policy-core, and this class's handleStateChange() method
+ * used to take care of invoking conn.standDownPdp().   But testing revealed that when a state change to hot standby occurred 
+ * from a demote() operation, first the PMStandbyStateChangeNotifier.handleStateChange() method would be invoked and then the 
+ * StandbyStateChangeNotifier.handleStateChange() method would be invoked, and this ordering was creating the following problem:
+ * 
+ * When PMStandbyStateChangeNotifier.handleStateChange() was invoked it would take a long time to finish, because it would result
+ * in SingleThreadedUebTopicSource.stop() being invoked, which can potentially do a 5 second sleep for each controller being stopped.   
+ * Meanwhile, as these controller stoppages and their associated sleeps were occurring, the election handler would discover the
+ * demoted PDP in hotstandby (but still designated!) and promote it, resulting in the standbyStatus going from hotstandby
+ * to providingservice.  So then, by the time that PMStandbyStateChangeNotifier.handleStateChange() finished its work and
+ * StandbyStateChangeNotifier.handleStateChange() started executing, the standbyStatus was no longer hotstandby (as effected by
+ * the demote), but providingservice (as reset by the election handling logic) and conn.standDownPdp() would not get called!
+ * 
+ * To fix this bug, we consolidated StandbyStateChangeNotifier and PMStandbyStateChangeNotifier, with the standDownPdp() always 
+ * being invoked prior to the TopicEndpoint.manager.lock().  In this way, when the election handling logic is invoked 
+ * during the controller stoppages, the PDP is in hotstandby and the standdown occurs.
+ * 
+ */
+public class PMStandbyStateChangeNotifier extends StateChangeNotifier {
+	// get an instance of logger 
+	private static final Logger  logger = LoggerFactory.getLogger(PMStandbyStateChangeNotifier.class);
+	private Timer delayActivateTimer;
+	private int pdpUpdateInterval;
+	private boolean isWaitingForActivation;
+	private long startTimeWaitingForActivationMs;
+	private long waitInterval;
+	private boolean isNowActivating;
+	private String previousStandbyStatus;
+	public static String NONE = "none";
+	public static String UNSUPPORTED = "unsupported";
+	public static String HOTSTANDBY_OR_COLDSTANDBY = "hotstandby_or_coldstandby";
+		
+	public PMStandbyStateChangeNotifier(){
+		pdpUpdateInterval = Integer.parseInt(ActiveStandbyProperties.getProperty(ActiveStandbyProperties.PDP_UPDATE_INTERVAL));
+		isWaitingForActivation = false;
+		startTimeWaitingForActivationMs = new Date().getTime();
+		//delay the activate so the DesignatedWaiter can run twice - give it an extra 2 seconds
+		waitInterval = 2*pdpUpdateInterval + 2000;
+		isNowActivating=false;
+		previousStandbyStatus = PMStandbyStateChangeNotifier.NONE;
+	}
+
+	@Override
+	public void handleStateChange() {
+		/*
+		 * A note on synchronization: This method is not synchronized because the caller, stateManagememt, 
+		 * has synchronize all of its methods. Only one stateManagement operation can occur at a time. Thus,
+		 * only one handleStateChange() call will ever be made at a time.
+		 */
+		if(logger.isInfoEnabled()){
+			if(logger.isDebugEnabled()){
+				logger.debug("handleStateChange: Entering, message={}, standbyStatus={}",
+						 super.getMessage(), super.getStateManagement().getStandbyStatus());
+			}
+		}
+		String standbyStatus = super.getStateManagement().getStandbyStatus();
+		String pdpId = ActiveStandbyProperties
+				.getProperty(ActiveStandbyProperties.NODE_NAME);
+
+		if(logger.isDebugEnabled()){
+			logger.debug("handleStateChange: previousStandbyStatus = {}"
+				+ "; standbyStatus = {}", previousStandbyStatus, standbyStatus);
+		}
+		
+		if (standbyStatus == null  || standbyStatus.equals(StateManagement.NULL_VALUE)) {
+			if(logger.isDebugEnabled()){
+				logger.debug("handleStateChange: standbyStatus is null; standing down PDP={}", pdpId);
+			}
+			if(previousStandbyStatus.equals(StateManagement.NULL_VALUE)){
+				//We were just here and did this successfully
+				if(logger.isDebugEnabled()){
+					logger.debug("handleStateChange: Is returning because standbyStatus is null and was previously 'null'; PDP={}", pdpId);
+				}
+				return;
+			}
+			isWaitingForActivation = false;
+			try{
+				try{
+					if(logger.isDebugEnabled()){
+						logger.debug("handleStateChange: null:  cancelling delayActivationTimer.");
+					}
+					delayActivateTimer.cancel();
+				}catch(Exception e){
+					if(logger.isInfoEnabled()){
+						logger.info("handleStateChange: null no delayActivationTimer existed.", e);
+					}
+					//If you end of here, there was no active timer
+				}
+				//Only want to lock the endpoints, not the controllers.
+				PolicyEngine.manager.deactivate();
+				//The operation was fully successful, but you cannot assign it a real null value
+				//because later we might try to execute previousStandbyStatus.equals() and get
+				//a null pointer exception.
+				previousStandbyStatus = StateManagement.NULL_VALUE;
+			}catch(Exception e){
+				logger.warn("handleStateChange: standbyStatus == null caught exception: ", e);
+			}
+		} else if (standbyStatus.equals(StateManagement.HOT_STANDBY) || standbyStatus.equals(StateManagement.COLD_STANDBY)) {
+			if(logger.isDebugEnabled()){
+				logger.debug("handleStateChange: standbyStatus={}; standing down PDP={}", standbyStatus, pdpId);
+			}
+			if(previousStandbyStatus.equals(PMStandbyStateChangeNotifier.HOTSTANDBY_OR_COLDSTANDBY)){
+				//We were just here and did this successfully
+				if(logger.isDebugEnabled()){
+					logger.debug("handleStateChange: Is returning because standbyStatus is {}"
+							+ " and was previously {}; PDP= {}", standbyStatus, previousStandbyStatus, pdpId);
+				}
+				return;
+			}
+			isWaitingForActivation = false;
+			try{
+				try{
+					if(logger.isDebugEnabled()){
+						logger.debug("handleStateChange: HOT_STNDBY || COLD_STANDBY:  cancelling delayActivationTimer.");
+					}
+					delayActivateTimer.cancel();
+				}catch(Exception e){
+					if(logger.isDebugEnabled()){
+						logger.debug("handleStateChange: HOT_STANDBY || COLD_STANDBY no delayActivationTimer existed.", e);
+					}
+					//If you end of here, there was no active timer
+				}
+				//Only want to lock the endpoints, not the controllers.
+				PolicyEngine.manager.deactivate();
+				//The operation was fully successful
+				previousStandbyStatus = PMStandbyStateChangeNotifier.HOTSTANDBY_OR_COLDSTANDBY;
+			}catch(Exception e){
+				logger.warn("handleStateChange: standbyStatus = {} caught exception: {}", standbyStatus, e.getMessage(), e);
+			}
+
+		} else if (standbyStatus.equals(StateManagement.PROVIDING_SERVICE)) {
+			if(logger.isDebugEnabled()){
+				logger.debug("handleStateChange: standbyStatus= {} "
+						+ "scheduling activation of PDP={}",standbyStatus, pdpId);
+			}
+			if(previousStandbyStatus.equals(StateManagement.PROVIDING_SERVICE)){
+				//We were just here and did this successfully
+				if(logger.isDebugEnabled()){
+					logger.debug("handleStateChange: Is returning because standbyStatus is {}"
+							+ "and was previously {}; PDP={}", standbyStatus, previousStandbyStatus, pdpId);
+				}
+				return;
+			}
+			try{
+				//UnLock all the endpoints
+				if(logger.isDebugEnabled()){
+					logger.debug("handleStateChange: standbyStatus={}; controllers must be unlocked.",standbyStatus );
+				}
+				/*
+				 * Only endpoints should be unlocked. Controllers have not been locked.
+				 * Because, sometimes, it is possible for more than one PDP-D to become active (race conditions)
+				 * we need to delay the activation of the topic endpoint interfaces to give the election algorithm
+				 * time to resolve the conflict.
+				 */
+				if(logger.isDebugEnabled()){
+					logger.debug("handleStateChange: PROVIDING_SERVICE isWaitingForActivation= {}", isWaitingForActivation);
+				}
+				
+				//Delay activation for 2*pdpUpdateInterval+2000 ms in case of an election handler conflict.  
+				//You could have multiple election handlers thinking they can take over.
+				
+				 // First let's check that the timer has not died
+				if(isWaitingForActivation){
+					if(logger.isDebugEnabled()){
+						logger.debug("handleStateChange: PROVIDING_SERVICE isWaitingForActivation = {}", isWaitingForActivation);
+					}
+					long now = new Date().getTime();
+					long waitTimeMs = now - startTimeWaitingForActivationMs;
+					if(waitTimeMs > 3*waitInterval){
+						if(logger.isDebugEnabled()){
+							logger.debug("handleStateChange: PROVIDING_SERVICE looks like the activation wait timer may be hung,"
+								+ " waitTimeMs = {} and allowable waitInterval = {}"
+								+ " Checking whether it is currently in activation. isNowActivating = {}",
+								waitTimeMs, waitInterval, isNowActivating);
+						}
+						//Now check that it is not currently executing an activation
+						if(!isNowActivating){
+							if(logger.isDebugEnabled()){
+								logger.debug("handleStateChange: PROVIDING_SERVICE looks like the activation wait timer died");
+							}
+							// This will assure the timer is cancelled and rescheduled.
+							isWaitingForActivation = false;
+						}
+					}
+					
+				}
+				
+				if(!isWaitingForActivation){
+					try{
+						//Just in case there is an old timer hanging around
+						if(logger.isDebugEnabled()){
+							logger.debug("handleStateChange: PROVIDING_SERVICE cancelling delayActivationTimer.");
+						}
+						delayActivateTimer.cancel();
+					}catch(Exception e){
+						if(logger.isDebugEnabled()){
+							logger.debug("handleStateChange: PROVIDING_SERVICE no delayActivationTimer existed.");
+						}
+						//If you end of here, there was no active timer
+					}
+					delayActivateTimer = new Timer();
+					//delay the activate so the DesignatedWaiter can run twice
+					delayActivateTimer.schedule(new DelayActivateClass(), waitInterval);
+					isWaitingForActivation = true;
+					startTimeWaitingForActivationMs = new Date().getTime();
+					if(logger.isDebugEnabled()){
+						logger.debug("handleStateChange: PROVIDING_SERVICE scheduling delayActivationTimer in {} ms", waitInterval);
+					}
+				}else{
+					if(logger.isDebugEnabled()){
+						logger.debug("handleStateChange: PROVIDING_SERVICE delayActivationTimer is waiting for activation.");
+					}
+				}
+				
+			}catch(Exception e){
+				logger.warn("handleStateChange: PROVIDING_SERVICE standbyStatus == providingservice caught exception: ", e);
+			}
+
+		} else {
+			logger.error("handleStateChange: Unsupported standbyStatus={}; standing down PDP={}", standbyStatus, pdpId);
+			if(previousStandbyStatus.equals(PMStandbyStateChangeNotifier.UNSUPPORTED)){
+				//We were just here and did this successfully
+				if(logger.isDebugEnabled()){
+					logger.debug("handleStateChange: Is returning because standbyStatus is "
+						+ "UNSUPPORTED and was previously {}; PDP={}", previousStandbyStatus, pdpId);
+				}
+				return;
+			}
+			//Only want to lock the endpoints, not the controllers.
+			isWaitingForActivation = false;
+			try{
+				try{
+					if(logger.isDebugEnabled()){
+						logger.debug("handleStateChange: unsupported standbystatus:  cancelling delayActivationTimer.");
+					}
+					delayActivateTimer.cancel();
+				}catch(Exception e){
+					if(logger.isDebugEnabled()){
+						logger.debug("handleStateChange: unsupported standbystatus: no delayActivationTimer existed.", e);
+					}
+					//If you end of here, there was no active timer
+				}
+				PolicyEngine.manager.deactivate();
+				//We know the standbystatus is unsupported
+				previousStandbyStatus = PMStandbyStateChangeNotifier.UNSUPPORTED;
+			}catch(Exception e){
+				logger.warn("handleStateChange: Unsupported standbyStatus = {} "
+						+ "caught exception: {} ",standbyStatus, e.getMessage(), e);
+			}
+		}
+		if(logger.isDebugEnabled()){
+			logger.debug("handleStateChange: Exiting");
+		}
+	}
+
+	private class DelayActivateClass extends TimerTask{
+
+		private Object delayActivateLock = new Object();
+
+
+		@Override
+		public void run() {
+			isNowActivating = true;
+			try{
+				if(logger.isDebugEnabled()){
+					logger.debug("DelayActivateClass.run: entry");
+				}
+				synchronized(delayActivateLock){
+					PolicyEngine.manager.activate();
+					// The state change fully succeeded
+					previousStandbyStatus = StateManagement.PROVIDING_SERVICE;
+					// We want to set this to false here because the activate call can take a while
+					isWaitingForActivation = false;
+					isNowActivating = false;
+				}
+				if(logger.isDebugEnabled()){
+					logger.debug("DelayActivateClass.run.exit");
+				}
+			}catch(Exception e){
+				isWaitingForActivation = false;
+				isNowActivating = false;
+				logger.warn("DelayActivateClass.run: caught an unexpected exception "
+						+ "calling PolicyEngine.manager.activate: ", e);
+			}
+		}
+	}
+	
+	public String getPreviousStandbyStatus(){
+		return previousStandbyStatus;
+	}
+}
diff --git a/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/ThreadRunningChecker.java b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/ThreadRunningChecker.java
new file mode 100644
index 00000000..db848ebb
--- /dev/null
+++ b/feature-active-standby-management/src/main/java/org/onap/policy/drools/activestandby/ThreadRunningChecker.java
@@ -0,0 +1,26 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * feature-active-standby-management
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.activestandby;
+
+public interface ThreadRunningChecker {
+	public void checkThreadStatus();
+
+}
diff --git a/feature-active-standby-management/src/main/resources/META-INF/persistence.xml b/feature-active-standby-management/src/main/resources/META-INF/persistence.xml
new file mode 100644
index 00000000..4a625b55
--- /dev/null
+++ b/feature-active-standby-management/src/main/resources/META-INF/persistence.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ============LICENSE_START=======================================================
+  feature-active-standby-management
+  ================================================================================
+  Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+  ================================================================================
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+  
+       http://www.apache.org/licenses/LICENSE-2.0
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+  ============LICENSE_END=========================================================
+  -->
+
+<persistence version="2.1"
+	xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
+	<persistence-unit name="activeStandbyPU" transaction-type="RESOURCE_LOCAL">
+	<!-- This is for database access by non-drools methods -->
+		<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
+		<class>org.onap.policy.drools.activestandby.DroolsPdpEntity</class>
+		<properties>
+			<!-- Properties are passed in -->
+        </properties>
+	</persistence-unit>
+</persistence>
diff --git a/feature-active-standby-management/src/main/resources/META-INF/services/org.onap.policy.drools.activestandby.ActiveStandbyFeatureAPI b/feature-active-standby-management/src/main/resources/META-INF/services/org.onap.policy.drools.activestandby.ActiveStandbyFeatureAPI
new file mode 100644
index 00000000..5296f8b7
--- /dev/null
+++ b/feature-active-standby-management/src/main/resources/META-INF/services/org.onap.policy.drools.activestandby.ActiveStandbyFeatureAPI
@@ -0,0 +1 @@
+org.onap.policy.drools.activestandby.ActiveStandbyFeature
diff --git a/feature-active-standby-management/src/main/resources/META-INF/services/org.onap.policy.drools.core.PolicySessionFeatureAPI b/feature-active-standby-management/src/main/resources/META-INF/services/org.onap.policy.drools.core.PolicySessionFeatureAPI
new file mode 100644
index 00000000..5296f8b7
--- /dev/null
+++ b/feature-active-standby-management/src/main/resources/META-INF/services/org.onap.policy.drools.core.PolicySessionFeatureAPI
@@ -0,0 +1 @@
+org.onap.policy.drools.activestandby.ActiveStandbyFeature
diff --git a/feature-active-standby-management/src/main/resources/META-INF/services/org.onap.policy.drools.features.PolicyEngineFeatureAPI b/feature-active-standby-management/src/main/resources/META-INF/services/org.onap.policy.drools.features.PolicyEngineFeatureAPI
new file mode 100644
index 00000000..5296f8b7
--- /dev/null
+++ b/feature-active-standby-management/src/main/resources/META-INF/services/org.onap.policy.drools.features.PolicyEngineFeatureAPI
@@ -0,0 +1 @@
+org.onap.policy.drools.activestandby.ActiveStandbyFeature
diff --git a/feature-active-standby-management/src/test/java/org/onap/policy/drools/controller/test/StandbyStateManagementTest.java b/feature-active-standby-management/src/test/java/org/onap/policy/drools/controller/test/StandbyStateManagementTest.java
new file mode 100644
index 00000000..a4a97968
--- /dev/null
+++ b/feature-active-standby-management/src/test/java/org/onap/policy/drools/controller/test/StandbyStateManagementTest.java
@@ -0,0 +1,1551 @@
+/*
+ * ============LICENSE_START=======================================================
+ * feature-active-standby-management
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.controller.test;
+
+import static org.junit.Assert.assertTrue;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.Properties;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.EntityTransaction;
+import javax.persistence.Persistence;
+
+import org.apache.commons.lang3.time.DateUtils;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.onap.policy.common.im.AdministrativeStateException;
+import org.onap.policy.common.im.IntegrityMonitor;
+import org.onap.policy.common.im.StandbyStatusException;
+import org.onap.policy.common.im.StateManagement;
+import org.onap.policy.drools.activestandby.ActiveStandbyFeatureAPI;
+import org.onap.policy.drools.activestandby.ActiveStandbyProperties;
+import org.onap.policy.drools.activestandby.DroolsPdp;
+import org.onap.policy.drools.activestandby.DroolsPdpEntity;
+import org.onap.policy.drools.activestandby.DroolsPdpImpl;
+import org.onap.policy.drools.activestandby.DroolsPdpsConnector;
+import org.onap.policy.drools.activestandby.DroolsPdpsElectionHandler;
+import org.onap.policy.drools.activestandby.JpaDroolsPdpsConnector;
+import org.onap.policy.drools.activestandby.PMStandbyStateChangeNotifier;
+import org.onap.policy.drools.core.PolicySessionFeatureAPI;
+import org.onap.policy.drools.statemanagement.StateManagementFeatureAPI;
+
+/*
+ * All JUnits are designed to run in the local development environment
+ * where they have write privileges and can execute time-sensitive
+ * tasks.
+ * 
+ * These tests can be run as JUnits, but there is some issue with running them
+ * as part of a "mvn install" build.  Also, they take a very long time to run
+ * due to many real time breaks.  Consequently, they are marked as @Ignore and
+ * only run from the desktop.
+ */ 
+ 
+public class StandbyStateManagementTest {
+	private static final Logger  logger = LoggerFactory.getLogger(StandbyStateManagementTest.class);
+	/*
+	 * Currently, the DroolsPdpsElectionHandler.DesignationWaiter is invoked every ten seconds, starting 
+	 * at ten seconds after the minute boundary (e.g. 13:05:10). So, an 80 second sleep should be 
+	 * sufficient to ensure that we wait for the DesignationWaiter to do its job, before 
+	 * checking the results.
+	 */ 
+	 
+	long sleepTime = 80000;
+	
+	/*
+	 * DroolsPdpsElectionHandler runs every ten seconds, so a 15 second sleep should be 
+	 * plenty to ensure it has time to re-promote this PDP.
+	 */
+	 
+	long electionWaitSleepTime = 15000;
+	
+	/*
+	 * Sleep 5 seconds after each test to allow interrupt (shutdown) recovery.
+	 */
+	 
+	long interruptRecoveryTime = 5000;
+	
+	private static EntityManagerFactory emfx;
+	private static EntityManagerFactory emfd;
+	private static EntityManager emx;
+	private static EntityManager emd;
+	private static EntityTransaction et;
+	
+	private final String configDir = "src/test/resources";
+
+	/*
+	 * See the IntegrityMonitor.getJmxUrl() method for the rationale behind this jmx related processing.
+	 */
+	 
+	@BeforeClass
+	public static void setUpClass() throws Exception {
+		
+		String userDir = System.getProperty("user.dir");
+		logger.debug("setUpClass: userDir={}", userDir);
+		System.setProperty("com.sun.management.jmxremote.port", "9980");
+		System.setProperty("com.sun.management.jmxremote.authenticate","false");
+				
+	}
+
+	@AfterClass
+	public static void tearDownClass() throws Exception {
+	}
+
+	@Before
+	public void setUp() throws Exception {
+		//Create teh data access for xaml db
+		Properties stateManagementProperties = new Properties();
+		stateManagementProperties.load(new FileInputStream(new File(
+				"src/test/resources/feature-state-management.properties")));
+
+		emfx = Persistence.createEntityManagerFactory("junitXacmlPU", stateManagementProperties);
+
+		// Create an entity manager to use the DB
+		emx = emfx.createEntityManager();
+		
+		//Create the data access for drools db
+		Properties activeStandbyProperties = new Properties();
+		activeStandbyProperties.load(new FileInputStream(new File(
+				"src/test/resources/feature-active-standby-management.properties")));
+
+		emfd = Persistence.createEntityManagerFactory("junitDroolsPU", activeStandbyProperties);
+
+		// Create an entity manager to use the DB
+		emd = emfd.createEntityManager();
+	}
+
+	@After
+	public void tearDown() throws Exception {
+				
+	}
+	
+	public void cleanXacmlDb(){
+		et = emx.getTransaction();
+		
+		et.begin();
+		// Make sure we leave the DB clean
+		emx.createQuery("DELETE FROM StateManagementEntity").executeUpdate();
+		emx.createQuery("DELETE FROM ResourceRegistrationEntity").executeUpdate();
+		emx.createQuery("DELETE FROM ForwardProgressEntity").executeUpdate();
+		emx.flush();
+		et.commit();
+	}
+	
+	public void cleanDroolsDb(){
+		et = emd.getTransaction();
+		
+		et.begin();
+		// Make sure we leave the DB clean
+		emd.createQuery("DELETE FROM DroolsPdpEntity").executeUpdate();
+		emd.flush();
+		et.commit();
+	}
+	
+	/*
+	 * These JUnit tests must be run one at a time in an eclipse environment 
+	 * by right-clicking StandbyStateManagementTest and selecting 
+	 * "Run As" -> "JUnit Test". 
+	 * 
+	 * They will run successfully when you run all of them under runAllTests(), 
+	 * however, you will get all sorts of non-fatal errors in the log and on the 
+	 * console that result from overlapping threads that are not terminated at the 
+	 * end of each test. The problem is that the JUnit environment does not terminate 
+	 * all the test threads between tests. This is true even if you break each JUnit
+	 * into a separate file. Consequently, all the tests would have to be refactored 
+	 * so all test object initializations are coordinated.  In other words, you 
+	 * retrieve the ActiveStandbyFeature instance and other class instances only once 
+	 * at the beginning of the JUnits and then reuse them throughout the tests. 
+	 * Initialization of the state of the objects is pretty straight forward as it
+	 * just amounts to manipulating the entries in StateManagementEntity and 
+	 * DroolsPdpEntity tables. However, some thought needs to be given to how to
+	 * "pause" the processing in ActiveStandbyFeature class.  I think we could "pause"
+	 * it by calling globalInit() which will, I think, restart it. So long as it
+	 * does not create a new instance, it will force it to go through an initialization
+	 * cycle which includes a "pause" at the beginning of proecessing.  We just must
+	 * be sure it does not create another instance - which may mean we need to add
+	 * a factory interface instead of calling the constructor directly.
+	 */
+
+	
+	//@Ignore
+	@Test
+	public void runAllTests() throws Exception {
+		testColdStandby();
+		testHotStandby1();
+		testHotStandby2();
+		testLocking1();
+		testLocking2(); 
+		testPMStandbyStateChangeNotifier();
+		testSanitizeDesignatedList();
+		testComputeMostRecentPrimary();
+		testComputeDesignatedPdp();
+	}
+	
+	//@Ignore
+	//@Test
+	public void testPMStandbyStateChangeNotifier() throws Exception {
+		logger.debug("\n\ntestPMStandbyStateChangeNotifier: Entering\n\n");
+		cleanXacmlDb();
+		
+		logger.debug("testPMStandbyStateChangeNotifier: Reading activeStandbyProperties");
+		
+		Properties activeStandbyProperties = new Properties();
+		activeStandbyProperties.load(new FileInputStream(new File(
+				configDir + "/feature-active-standby-management.properties")));
+		ActiveStandbyProperties.initProperties(activeStandbyProperties);
+		String thisPdpId = ActiveStandbyProperties.getProperty(ActiveStandbyProperties.NODE_NAME);
+		
+		logger.debug("testPMStandbyStateChangeNotifier: Getting StateManagementFeatureAPI");
+
+		StateManagementFeatureAPI sm = null;
+		for (StateManagementFeatureAPI feature : StateManagementFeatureAPI.impl.getList())
+		{
+			((PolicySessionFeatureAPI) feature).globalInit(null, configDir);
+			sm = feature;
+			logger.debug("testPMStandbyStateChangeNotifier stateManagementFeature.getResourceName(): {}", sm.getResourceName());
+			break;
+		}
+		if(sm == null){
+			logger.error("testPMStandbyStateChangeNotifier failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+			logger.debug("testPMStandbyStateChangeNotifier failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+		}
+
+		//Create an instance of the Observer
+		PMStandbyStateChangeNotifier pmNotifier = new PMStandbyStateChangeNotifier();
+
+		//Register the PMStandbyStateChangeNotifier Observer
+		sm.addObserver(pmNotifier);
+	
+		//At this point the standbystatus = 'null'
+		sm.lock();
+		assertTrue(pmNotifier.getPreviousStandbyStatus().equals(StateManagement.NULL_VALUE));
+
+		sm.unlock();
+		assertTrue(pmNotifier.getPreviousStandbyStatus().equals(StateManagement.NULL_VALUE));
+
+		//Adding standbystatus=hotstandby
+		sm.demote();
+		System.out.println(pmNotifier.getPreviousStandbyStatus());
+		assertTrue(pmNotifier.getPreviousStandbyStatus().equals(PMStandbyStateChangeNotifier.HOTSTANDBY_OR_COLDSTANDBY));
+
+		//Now making standbystatus=coldstandby
+		sm.lock();
+		assertTrue(pmNotifier.getPreviousStandbyStatus().equals(PMStandbyStateChangeNotifier.HOTSTANDBY_OR_COLDSTANDBY));
+
+		//standbystatus = hotstandby
+		sm.unlock();
+		assertTrue(pmNotifier.getPreviousStandbyStatus().equals(PMStandbyStateChangeNotifier.HOTSTANDBY_OR_COLDSTANDBY));
+
+		//standbystatus = providingservice
+		sm.promote();
+		//The previousStandbyStatus is not updated until after the delay activation expires
+		assertTrue(pmNotifier.getPreviousStandbyStatus().equals(PMStandbyStateChangeNotifier.HOTSTANDBY_OR_COLDSTANDBY));
+
+		//Sleep long enough for the delayActivationTimer to run
+		Thread.sleep(5000);
+		assertTrue(pmNotifier.getPreviousStandbyStatus().equals(StateManagement.PROVIDING_SERVICE));
+
+		//standbystatus = providingservice
+		sm.promote();
+		assertTrue(pmNotifier.getPreviousStandbyStatus().equals(StateManagement.PROVIDING_SERVICE));
+		
+		//standbystatus = coldstandby
+		sm.lock();
+		assertTrue(pmNotifier.getPreviousStandbyStatus().equals(PMStandbyStateChangeNotifier.HOTSTANDBY_OR_COLDSTANDBY));
+
+		//standbystatus = hotstandby
+		sm.unlock();
+		assertTrue(pmNotifier.getPreviousStandbyStatus().equals(PMStandbyStateChangeNotifier.HOTSTANDBY_OR_COLDSTANDBY));
+
+		//standbystatus = hotstandby
+		sm.demote();
+		assertTrue(pmNotifier.getPreviousStandbyStatus().equals(PMStandbyStateChangeNotifier.HOTSTANDBY_OR_COLDSTANDBY));
+	}
+
+	//@Ignore
+	//@Test
+	public void testSanitizeDesignatedList() throws Exception {
+
+		logger.debug("\n\ntestSanitizeDesignatedList: Entering\n\n");
+		
+		// Get a DroolsPdpsConnector
+		
+		logger.debug("testSanitizeDesignatedList: Reading activeStandbyProperties");
+		Properties activeStandbyProperties = new Properties();
+		activeStandbyProperties.load(new FileInputStream(new File(
+				configDir + "/feature-active-standby-management.properties")));
+		String thisPdpId = activeStandbyProperties
+				.getProperty(ActiveStandbyProperties.NODE_NAME);
+
+		logger.debug("testSanitizeDesignatedList: Creating emfDrools");
+		EntityManagerFactory emfDrools = Persistence.createEntityManagerFactory(
+				"junitDroolsPU", activeStandbyProperties);
+		
+		DroolsPdpsConnector droolsPdpsConnector = new JpaDroolsPdpsConnector(emfDrools);
+		
+		// Create 4 pdpd all not designated
+		
+		DroolsPdp pdp1 = new DroolsPdpImpl("pdp1", false, 4, new Date());
+		DroolsPdp pdp2 = new DroolsPdpImpl("pdp2", false, 4, new Date());
+		DroolsPdp pdp3 = new DroolsPdpImpl("pdp3", false, 4, new Date());
+		DroolsPdp pdp4 = new DroolsPdpImpl("pdp4", false, 4, new Date());
+		
+		ArrayList<DroolsPdp> listOfDesignated = new ArrayList<DroolsPdp>();
+		listOfDesignated.add(pdp1);
+		listOfDesignated.add(pdp2);
+		listOfDesignated.add(pdp3);
+		listOfDesignated.add(pdp4);
+		
+		// Now we want to create a StateManagementFeature and initialize it.  It will be
+		// discovered by the ActiveStandbyFeature when the election handler initializes.
+
+		StateManagementFeatureAPI stateManagementFeature = null;
+		for (StateManagementFeatureAPI feature : StateManagementFeatureAPI.impl.getList())
+		{
+			((PolicySessionFeatureAPI) feature).globalInit(null, configDir);
+			stateManagementFeature = feature;
+			logger.debug("testColdStandby stateManagementFeature.getResourceName(): {}", stateManagementFeature.getResourceName());
+			break;
+		}
+		if(stateManagementFeature == null){
+			logger.error("testColdStandby failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+			logger.debug("testColdStandby failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+		}
+		
+		
+		DroolsPdpsElectionHandler droolsPdpsElectionHandler =  new DroolsPdpsElectionHandler(droolsPdpsConnector, pdp1);
+		
+		listOfDesignated = droolsPdpsElectionHandler.santizeDesignatedList(listOfDesignated);
+		
+		logger.debug("\n\ntestSanitizeDesignatedList: listOfDesignated.size = {}\n\n",listOfDesignated.size());
+		
+		assertTrue(listOfDesignated.size()==4);
+		
+		// Now make 2 designated
+		 
+		pdp1.setDesignated(true);
+		pdp2.setDesignated(true);
+		
+		listOfDesignated = droolsPdpsElectionHandler.santizeDesignatedList(listOfDesignated);
+		
+		logger.debug("\n\ntestSanitizeDesignatedList: listOfDesignated.size after 2 designated = {}\n\n", listOfDesignated.size());
+		
+		assertTrue(listOfDesignated.size()==2);
+		assertTrue(listOfDesignated.contains(pdp1));
+		assertTrue(listOfDesignated.contains(pdp2));
+		
+		
+		// Now all are designated.  But, we have to add back the previously non-designated nodes
+		 
+		pdp3.setDesignated(true);
+		pdp4.setDesignated(true);
+		listOfDesignated.add(pdp3);
+		listOfDesignated.add(pdp4);
+		
+		listOfDesignated = droolsPdpsElectionHandler.santizeDesignatedList(listOfDesignated);
+		
+		logger.debug("\n\ntestSanitizeDesignatedList: listOfDesignated.size after all designated = {}\n\n", listOfDesignated.size());
+		
+		assertTrue(listOfDesignated.size()==4);
+		
+	}
+
+
+	//@Ignore
+	//@Test
+	public void testComputeMostRecentPrimary() throws Exception {
+
+		logger.debug("\n\ntestComputeMostRecentPrimary: Entering\n\n");
+		
+		logger.debug("testComputeMostRecentPrimary: Reading activeStandbyProperties");
+		Properties activeStandbyProperties = new Properties();
+		activeStandbyProperties.load(new FileInputStream(new File(
+				configDir + "/feature-active-standby-management.properties")));
+		String thisPdpId = activeStandbyProperties
+				.getProperty(ActiveStandbyProperties.NODE_NAME);
+
+		logger.debug("testComputeMostRecentPrimary: Creating emfDrools");
+		EntityManagerFactory emfDrools = Persistence.createEntityManagerFactory(
+				"junitDroolsPU", activeStandbyProperties);
+		
+		DroolsPdpsConnector droolsPdpsConnector = new JpaDroolsPdpsConnector(emfDrools);
+		
+		
+		// Create 4 pdpd all not designated
+		 
+		 
+		long designatedDateMS = new Date().getTime();
+		DroolsPdp pdp1 = new DroolsPdpImpl("pdp1", false, 4, new Date());
+		pdp1.setDesignatedDate(new Date(designatedDateMS - 2));
+		
+		DroolsPdp pdp2 = new DroolsPdpImpl("pdp2", false, 4, new Date());
+		//oldest
+		pdp2.setDesignatedDate(new Date(designatedDateMS - 3));
+		
+		DroolsPdp pdp3 = new DroolsPdpImpl("pdp3", false, 4, new Date());
+		pdp3.setDesignatedDate(new Date(designatedDateMS - 1));
+
+		DroolsPdp pdp4 = new DroolsPdpImpl("pdp4", false, 4, new Date());
+		//most recent
+		pdp4.setDesignatedDate(new Date(designatedDateMS));
+		
+		ArrayList<DroolsPdp> listOfAllPdps = new ArrayList<DroolsPdp>();
+		listOfAllPdps.add(pdp1);
+		listOfAllPdps.add(pdp2);
+		listOfAllPdps.add(pdp3);
+		listOfAllPdps.add(pdp4);
+				
+		
+		ArrayList<DroolsPdp> listOfDesignated = new ArrayList<DroolsPdp>();
+		listOfDesignated.add(pdp1);
+		listOfDesignated.add(pdp2);
+		listOfDesignated.add(pdp3);
+		listOfDesignated.add(pdp4);
+		
+		// Because the way we sanitize the listOfDesignated, it will always contain all hot standby 
+		// or all designated members.
+		 
+		// Now we want to create a StateManagementFeature and initialize it.  It will be
+		// discovered by the ActiveStandbyFeature when the election handler initializes.
+
+		StateManagementFeatureAPI stateManagementFeature = null;
+		for (StateManagementFeatureAPI feature : StateManagementFeatureAPI.impl.getList())
+		{
+			((PolicySessionFeatureAPI) feature).globalInit(null, configDir);
+			stateManagementFeature = feature;
+			logger.debug("testComputeMostRecentPrimary stateManagementFeature.getResourceName(): {}", stateManagementFeature.getResourceName());
+			break;
+		}
+		if(stateManagementFeature == null){
+			logger.error("testComputeMostRecentPrimary failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+			logger.debug("testComputeMostRecentPrimary failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+		}
+		
+		DroolsPdpsElectionHandler droolsPdpsElectionHandler =  new DroolsPdpsElectionHandler(droolsPdpsConnector, pdp1);
+	
+		DroolsPdp mostRecentPrimary = droolsPdpsElectionHandler.computeMostRecentPrimary(listOfAllPdps, listOfDesignated);
+		
+		logger.debug("\n\ntestComputeMostRecentPrimary: mostRecentPrimary.getPdpId() = {}\n\n", mostRecentPrimary.getPdpId());
+		
+		
+		// If all of the pdps are included in the listOfDesignated and none are designated, it will choose 
+		// the one which has the most recent designated date.
+		 
+		 
+		assertTrue(mostRecentPrimary.getPdpId().equals("pdp4"));
+		
+		
+		// Now let's designate all of those on the listOfDesignated.  It will choose the first one designated
+		 
+		 
+		pdp1.setDesignated(true);
+		pdp2.setDesignated(true);
+		pdp3.setDesignated(true);
+		pdp4.setDesignated(true);
+		
+		mostRecentPrimary = droolsPdpsElectionHandler.computeMostRecentPrimary(listOfAllPdps, listOfDesignated);
+		
+		logger.debug("\n\ntestComputeMostRecentPrimary: All designated all on list, mostRecentPrimary.getPdpId() = {}\n\n", mostRecentPrimary.getPdpId());
+		
+		
+		// If all of the pdps are included in the listOfDesignated and all are designated, it will choose 
+		// the one which was designated first
+		 
+		 
+		assertTrue(mostRecentPrimary.getPdpId().equals("pdp2"));
+		
+		
+		// Now we will designate only 2 and put just them in the listOfDesignated.  The algorithm will now
+		// look for the most recently designated pdp which is not currently designated.
+		 
+		 
+		pdp3.setDesignated(false);
+		pdp4.setDesignated(false);
+		
+		listOfDesignated.remove(pdp3);
+		listOfDesignated.remove(pdp4);
+		
+		mostRecentPrimary = droolsPdpsElectionHandler.computeMostRecentPrimary(listOfAllPdps, listOfDesignated);
+		
+		logger.debug("\n\ntestComputeMostRecentPrimary: mostRecentPrimary.getPdpId() = {}\n\n", mostRecentPrimary.getPdpId());
+		
+		assertTrue(mostRecentPrimary.getPdpId().equals("pdp4"));
+		
+		
+		
+		// Now we will have none designated and put two of them in the listOfDesignated.  The algorithm will now
+		// look for the most recently designated pdp regardless of whether it is currently marked as designated.
+		 
+		 
+		pdp1.setDesignated(false);
+		pdp2.setDesignated(false);
+		
+		mostRecentPrimary = droolsPdpsElectionHandler.computeMostRecentPrimary(listOfAllPdps, listOfDesignated);
+		
+		logger.debug("\n\ntestComputeMostRecentPrimary: 2 on list mostRecentPrimary.getPdpId() = {}\n\n", mostRecentPrimary.getPdpId());
+		
+		assertTrue(mostRecentPrimary.getPdpId().equals("pdp4"));
+		
+		
+		// If we have only one pdp on in the listOfDesignated, the most recently designated pdp will be chosen, regardless
+		// of its designation status
+		 
+		 
+		listOfDesignated.remove(pdp1);
+		
+		mostRecentPrimary = droolsPdpsElectionHandler.computeMostRecentPrimary(listOfAllPdps, listOfDesignated);
+		
+		logger.debug("\n\ntestComputeMostRecentPrimary: 1 on list mostRecentPrimary.getPdpId() = {}\n\n", mostRecentPrimary.getPdpId());
+		
+		assertTrue(mostRecentPrimary.getPdpId().equals("pdp4"));
+		
+		
+		// Finally, if none are on the listOfDesignated, it will again choose the most recently designated pdp.
+		 
+		 
+		listOfDesignated.remove(pdp2);
+
+		mostRecentPrimary = droolsPdpsElectionHandler.computeMostRecentPrimary(listOfAllPdps, listOfDesignated);
+		
+		logger.debug("\n\ntestComputeMostRecentPrimary: 0 on list mostRecentPrimary.getPdpId() = {}\n\n", mostRecentPrimary.getPdpId());
+		
+		assertTrue(mostRecentPrimary.getPdpId().equals("pdp4"));
+		
+	}
+
+	//@Ignore
+	//@Test
+	public void testComputeDesignatedPdp() throws Exception{
+		
+		logger.debug("\n\ntestComputeDesignatedPdp: Entering\n\n");
+		
+		logger.debug("testComputeDesignatedPdp: Reading activeStandbyProperties");
+		Properties activeStandbyProperties = new Properties();
+		activeStandbyProperties.load(new FileInputStream(new File(
+				configDir + "/feature-active-standby-management.properties")));
+		String thisPdpId = activeStandbyProperties
+				.getProperty(ActiveStandbyProperties.NODE_NAME);
+		 
+
+		logger.debug("testComputeDesignatedPdp: Creating emfDrools");
+		EntityManagerFactory emfDrools = Persistence.createEntityManagerFactory(
+				"junitDroolsPU", activeStandbyProperties);
+		
+		DroolsPdpsConnector droolsPdpsConnector = new JpaDroolsPdpsConnector(emfDrools);
+		
+		
+		// Create 4 pdpd all not designated.  Two on site1. Two on site2
+		 
+		 
+		long designatedDateMS = new Date().getTime();
+		DroolsPdp pdp1 = new DroolsPdpImpl("pdp1", false, 4, new Date());
+		pdp1.setDesignatedDate(new Date(designatedDateMS - 2));
+		pdp1.setSiteName("site1");
+		
+		DroolsPdp pdp2 = new DroolsPdpImpl("pdp2", false, 4, new Date());
+		pdp2.setDesignatedDate(new Date(designatedDateMS - 3));
+		pdp2.setSiteName("site1");
+
+		//oldest		
+		DroolsPdp pdp3 = new DroolsPdpImpl("pdp3", false, 4, new Date());
+		pdp3.setDesignatedDate(new Date(designatedDateMS - 4));
+		pdp3.setSiteName("site2");
+		
+		DroolsPdp pdp4 = new DroolsPdpImpl("pdp4", false, 4, new Date());
+		//most recent
+		pdp4.setDesignatedDate(new Date(designatedDateMS));
+		pdp4.setSiteName("site2");
+		
+		ArrayList<DroolsPdp> listOfAllPdps = new ArrayList<DroolsPdp>();
+		listOfAllPdps.add(pdp1);
+		listOfAllPdps.add(pdp2);
+		listOfAllPdps.add(pdp3);
+		listOfAllPdps.add(pdp4);
+				
+		
+		ArrayList<DroolsPdp> listOfDesignated = new ArrayList<DroolsPdp>();
+		
+		
+		// We will first test an empty listOfDesignated. As we know from the previous JUnit,
+		// the pdp with the most designated date will be chosen for mostRecentPrimary
+		
+		// Now we want to create a StateManagementFeature and initialize it.  It will be
+		// discovered by the ActiveStandbyFeature when the election handler initializes.
+
+		StateManagementFeatureAPI stateManagementFeature = null;
+		for (StateManagementFeatureAPI feature : StateManagementFeatureAPI.impl.getList())
+		{
+			((PolicySessionFeatureAPI) feature).globalInit(null, configDir);
+			stateManagementFeature = feature;
+			logger.debug("testComputeDesignatedPdp stateManagementFeature.getResourceName(): {}", stateManagementFeature.getResourceName());
+			break;
+		}
+		if(stateManagementFeature == null){
+			logger.error("testComputeDesignatedPdp failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+			logger.debug("testComputeDesignatedPdp failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+		}
+		
+	
+		DroolsPdpsElectionHandler droolsPdpsElectionHandler =  new DroolsPdpsElectionHandler(droolsPdpsConnector, pdp1);
+		
+		DroolsPdp mostRecentPrimary = pdp4;
+	
+		DroolsPdp designatedPdp = droolsPdpsElectionHandler.computeDesignatedPdp(listOfDesignated, mostRecentPrimary);
+		
+		
+		// The designatedPdp should be null
+		 
+		assertTrue(designatedPdp==null);
+		
+		
+		// Now let's try having only one pdp in listOfDesignated, but not in the same site as the most recent primary
+		 
+		listOfDesignated.add(pdp2);
+		
+		designatedPdp = droolsPdpsElectionHandler.computeDesignatedPdp(listOfDesignated, mostRecentPrimary);
+		
+		
+		// Now the designatedPdp should be the one and only selection in the listOfDesignated
+		 
+		 
+		assertTrue(designatedPdp.getPdpId().equals(pdp2.getPdpId()));
+		
+		
+		// Now let's put 2 pdps in the listOfDesignated, neither in the same site as the mostRecentPrimary
+		 
+		 
+		listOfDesignated.add(pdp1);
+		
+		designatedPdp = droolsPdpsElectionHandler.computeDesignatedPdp(listOfDesignated, mostRecentPrimary);
+		
+		
+		// The designatedPdp should now be the one with the lowest lexiographic score - pdp1
+		 
+		 
+		assertTrue(designatedPdp.getPdpId().equals(pdp1.getPdpId()));
+		
+		
+		// Finally, we will have 2 pdps in the listOfDesignated, one in the same site with the mostRecentPrimary
+		 
+		 
+		listOfDesignated.remove(pdp1);
+		listOfDesignated.add(pdp3);
+		
+		designatedPdp = droolsPdpsElectionHandler.computeDesignatedPdp(listOfDesignated, mostRecentPrimary);
+		
+		
+		// The designatedPdp should now be the one on the same site as the mostRecentPrimary
+		 
+		 
+		assertTrue(designatedPdp.getPdpId().equals(pdp3.getPdpId()));
+	}
+	
+	//@Ignore
+	//@Test
+	public void testColdStandby() throws Exception {
+
+		logger.debug("\n\ntestColdStandby: Entering\n\n");
+		cleanXacmlDb();
+		cleanDroolsDb();
+
+		logger.debug("testColdStandby: Reading stateManagementProperties");
+		Properties stateManagementProperties = new Properties();
+		stateManagementProperties.load(new FileInputStream(new File(
+				configDir + "/feature-state-management.properties")));
+		
+		logger.debug("testColdStandby: Creating emfXacml");
+		EntityManagerFactory emfXacml = Persistence.createEntityManagerFactory(
+				"junitXacmlPU", stateManagementProperties);
+		
+		logger.debug("testColdStandby: Reading activeStandbyProperties");
+		Properties activeStandbyProperties = new Properties();
+		activeStandbyProperties.load(new FileInputStream(new File(
+				configDir + "/feature-active-standby-management.properties")));
+		String thisPdpId = activeStandbyProperties.getProperty(ActiveStandbyProperties.NODE_NAME);
+
+		logger.debug("testColdStandby: Creating emfDrools");
+		EntityManagerFactory emfDrools = Persistence.createEntityManagerFactory(
+				"junitDroolsPU", activeStandbyProperties);
+		
+		DroolsPdpsConnector conn = new JpaDroolsPdpsConnector(emfDrools);
+		
+		logger.debug("testColdStandby: Cleaning up tables");
+		conn.deleteAllPdps();
+	
+		logger.debug("testColdStandby: Inserting PDP={} as designated", thisPdpId);
+		DroolsPdp pdp = new DroolsPdpImpl(thisPdpId, true, 4, new Date());
+		conn.insertPdp(pdp);
+		DroolsPdpEntity droolsPdpEntity = conn.getPdp(thisPdpId);
+		logger.debug("testColdStandby: After insertion, DESIGNATED= {} "
+				+ "for PDP= {}", droolsPdpEntity.isDesignated(), thisPdpId);
+		assertTrue(droolsPdpEntity.isDesignated() == true);
+
+		/*
+		 * When the Standby Status changes (from providingservice) to hotstandby
+		 * or coldstandby,the Active/Standby selection algorithm must stand down
+		 * if thePDP-D is currently the lead/active node and allow another PDP-D
+		 * to take over.
+		 * 
+		 * It must also call lock on all engines in the engine management.
+		 */
+		
+		
+		/*
+		 * Yes, this is kludgy, but we have a chicken and egg problem here: we
+		 * need a StateManagement object to invoke the
+		 * deleteAllStateManagementEntities method.
+		 */
+		logger.debug("testColdStandby: Instantiating stateManagement object");
+		
+		StateManagement sm = new StateManagement(emfXacml, "dummy");
+		sm.deleteAllStateManagementEntities();
+			
+		// Now we want to create a StateManagementFeature and initialize it.  It will be
+		// discovered by the ActiveStandbyFeature when the election handler initializes.
+
+		StateManagementFeatureAPI smf = null;
+		for (StateManagementFeatureAPI feature : StateManagementFeatureAPI.impl.getList())
+		{
+			((PolicySessionFeatureAPI) feature).globalInit(null, configDir);
+			smf = feature;
+			logger.debug("testColdStandby stateManagementFeature.getResourceName(): {}", smf.getResourceName());
+			break;
+		}
+		if(smf == null){
+			logger.error("testColdStandby failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+			logger.debug("testColdStandby failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+		}
+		
+		// Create an ActiveStandbyFeature and initialize it. It will discover the StateManagementFeature
+		// that has been created.
+		ActiveStandbyFeatureAPI activeStandbyFeature = null;
+		for (ActiveStandbyFeatureAPI feature : ActiveStandbyFeatureAPI.impl.getList())
+		{
+			((PolicySessionFeatureAPI) feature).globalInit(null, configDir);
+			activeStandbyFeature = feature;
+			logger.debug("testColdStandby activeStandbyFeature.getResourceName(): {}", activeStandbyFeature.getResourceName());
+			break;
+		}
+		if(activeStandbyFeature == null){
+			logger.error("testColdStandby failed to initialize.  "
+					+ "Unable to get instance of ActiveStandbyFeatureAPI "
+					+ "with resourceID:{}", thisPdpId);
+			logger.debug("testColdStandby failed to initialize.  "
+					+ "Unable to get instance of ActiveStandbyFeatureAPI "
+					+ "with resourceID:{}", thisPdpId);
+		}
+
+		// Artificially putting a PDP into service is really a two step process, 1)
+		// inserting it as designated and 2) promoting it so that its standbyStatus
+		// is providing service.
+		
+		logger.debug("testColdStandby: Runner started; Sleeping "
+				+ interruptRecoveryTime + "ms before promoting PDP= {}",
+				thisPdpId);
+		Thread.sleep(interruptRecoveryTime);
+
+		logger.debug("testColdStandby: Promoting PDP={}", thisPdpId);
+		smf.promote();		
+		
+		String standbyStatus = sm.getStandbyStatus(thisPdpId);
+		logger.debug("testColdStandby: Before locking, PDP= {}  has standbyStatus= {}",
+				 thisPdpId, standbyStatus);
+		
+		logger.debug("testColdStandby: Locking smf");
+		smf.lock();
+		
+		Thread.sleep(interruptRecoveryTime);
+		
+		// Verify that the PDP is no longer designated.
+		 
+		droolsPdpEntity = conn.getPdp(thisPdpId);
+		logger.debug("testColdStandby: After lock sm.lock() invoked, "
+				+ "DESIGNATED= {} for PDP={}", droolsPdpEntity.isDesignated(), thisPdpId);
+		assertTrue(droolsPdpEntity.isDesignated() == false);
+		
+		logger.debug("\n\ntestColdStandby: Exiting\n\n");
+		Thread.sleep(interruptRecoveryTime);
+
+	}
+
+	// Tests hot standby when there is only one PDP.
+	 
+	//@Ignore
+	//@Test
+	public void testHotStandby1() throws Exception {
+	
+		logger.debug("\n\ntestHotStandby1: Entering\n\n");
+		cleanXacmlDb();
+		cleanDroolsDb();
+		
+		logger.debug("testHotStandby1: Reading stateManagementProperties");
+		Properties stateManagementProperties = new Properties();
+		stateManagementProperties.load(new FileInputStream(new File(
+				configDir + "/feature-state-management.properties")));
+
+		logger.debug("testHotStandby1: Creating emfXacml");
+		EntityManagerFactory emfXacml = Persistence.createEntityManagerFactory(
+				"junitXacmlPU", stateManagementProperties);
+		
+		logger.debug("testHotStandby1: Reading activeStandbyProperties");
+		Properties activeStandbyProperties = new Properties();
+		activeStandbyProperties.load(new FileInputStream(new File(
+				configDir + "/feature-active-standby-management.properties")));
+		String thisPdpId = activeStandbyProperties
+				.getProperty(ActiveStandbyProperties.NODE_NAME);
+
+		logger.debug("testHotStandby1: Creating emfDrools");
+		EntityManagerFactory emfDrools = Persistence.createEntityManagerFactory(
+				"junitDroolsPU", activeStandbyProperties);
+		
+		DroolsPdpsConnector conn = new JpaDroolsPdpsConnector(emfDrools);
+		
+		logger.debug("testHotStandby1: Cleaning up tables");
+		conn.deleteAllPdps();
+					
+		/*
+		 * Insert this PDP as not designated.  Initial standby state will be 
+		 * either null or cold standby.   Demoting should transit state to
+		 * hot standby.
+		 */
+		 
+		logger.debug("testHotStandby1: Inserting PDP={} as not designated", thisPdpId);
+		Date yesterday = DateUtils.addDays(new Date(), -1);
+		DroolsPdpImpl pdp = new DroolsPdpImpl(thisPdpId, false, 4, yesterday);
+		conn.insertPdp(pdp);
+		DroolsPdpEntity droolsPdpEntity = conn.getPdp(thisPdpId);
+		logger.debug("testHotStandby1: After insertion, PDP={} has DESIGNATED={}",
+				thisPdpId, droolsPdpEntity.isDesignated());
+		assertTrue(droolsPdpEntity.isDesignated() == false);
+		
+		logger.debug("testHotStandby1: Instantiating stateManagement object");
+		StateManagement sm = new StateManagement(emfXacml, "dummy");
+		sm.deleteAllStateManagementEntities();
+		
+		
+		// Now we want to create a StateManagementFeature and initialize it.  It will be
+		// discovered by the ActiveStandbyFeature when the election handler initializes.
+
+		StateManagementFeatureAPI smf = null;
+		for (StateManagementFeatureAPI feature : StateManagementFeatureAPI.impl.getList())
+		{
+			((PolicySessionFeatureAPI) feature).globalInit(null, configDir);
+			smf = feature;
+			logger.debug("testHotStandby1 stateManagementFeature.getResourceName(): {}", smf.getResourceName());
+			break;
+		}
+		if(smf == null){
+			logger.error("testHotStandby1 failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+			logger.debug("testHotStandby1 failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+		}
+		
+		// Create an ActiveStandbyFeature and initialize it. It will discover the StateManagementFeature
+		// that has been created.
+		ActiveStandbyFeatureAPI activeStandbyFeature = null;
+		for (ActiveStandbyFeatureAPI feature : ActiveStandbyFeatureAPI.impl.getList())
+		{
+			((PolicySessionFeatureAPI) feature).globalInit(null, configDir);
+			activeStandbyFeature = feature;
+			logger.debug("testHotStandby1 activeStandbyFeature.getResourceName(): {}", activeStandbyFeature.getResourceName());
+			break;
+		}
+		if(activeStandbyFeature == null){
+			logger.error("testHotStandby1 failed to initialize.  "
+					+ "Unable to get instance of ActiveStandbyFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+			logger.debug("testHotStandby1 failed to initialize.  "
+					+ "Unable to get instance of ActiveStandbyFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+		}
+		
+
+		logger.debug("testHotStandby1: Demoting PDP={}", thisPdpId);
+		// demoting should cause state to transit to hotstandby
+		smf.demote();
+		
+				
+		logger.debug("testHotStandby1: Sleeping {} ms, to allow JpaDroolsPdpsConnector "
+				+ "time to check droolspdpentity table", sleepTime);
+		Thread.sleep(sleepTime);
+		
+		
+		// Verify that this formerly un-designated PDP in HOT_STANDBY is now designated and providing service.
+		 
+		droolsPdpEntity = conn.getPdp(thisPdpId);
+		logger.debug("testHotStandby1: After sm.demote() invoked, DESIGNATED= {} "
+				+ "for PDP= {}", droolsPdpEntity.isDesignated(), thisPdpId);
+		assertTrue(droolsPdpEntity.isDesignated() == true);
+		String standbyStatus = smf.getStandbyStatus(thisPdpId);
+		logger.debug("testHotStandby1: After demotion, PDP= {} "
+				+ "has standbyStatus= {}", thisPdpId, standbyStatus);
+		assertTrue(standbyStatus != null  &&  standbyStatus.equals(StateManagement.PROVIDING_SERVICE));
+				
+		logger.debug("testHotStandby1: Stopping policyManagementRunner");
+		//policyManagementRunner.stopRunner();		
+	
+		logger.debug("\n\ntestHotStandby1: Exiting\n\n");
+		Thread.sleep(interruptRecoveryTime);
+
+	}
+
+	/*
+	 * Tests hot standby when two PDPs are involved.
+	 */
+		 
+	//@Ignore
+	//@Test
+	public void testHotStandby2() throws Exception {
+
+		logger.info("\n\ntestHotStandby2: Entering\n\n");
+		cleanXacmlDb();
+		cleanDroolsDb();
+		
+		logger.info("testHotStandby2: Reading stateManagementProperties");
+		Properties stateManagementProperties = new Properties();
+		stateManagementProperties.load(new FileInputStream(new File(
+				configDir + "/feature-state-management.properties")));
+		
+		logger.info("testHotStandby2: Creating emfXacml");
+		EntityManagerFactory emfXacml = Persistence.createEntityManagerFactory(
+				"junitXacmlPU", stateManagementProperties);
+		
+		logger.info("testHotStandby2: Reading activeStandbyProperties");
+		Properties activeStandbyProperties = new Properties();
+		activeStandbyProperties.load(new FileInputStream(new File(
+				configDir + "/feature-active-standby-management.properties")));
+		String thisPdpId = activeStandbyProperties
+				.getProperty(ActiveStandbyProperties.NODE_NAME);
+
+		logger.info("testHotStandby2: Creating emfDrools");
+		EntityManagerFactory emfDrools = Persistence.createEntityManagerFactory(
+				"junitDroolsPU", activeStandbyProperties);
+		
+		DroolsPdpsConnector conn = new JpaDroolsPdpsConnector(emfDrools);
+		
+		logger.info("testHotStandby2: Cleaning up tables");
+		conn.deleteAllPdps();
+		
+		
+		// Insert a PDP that's designated but not current.
+		 
+		String activePdpId = "pdp2";
+		logger.info("testHotStandby2: Inserting PDP={} as stale, designated PDP", activePdpId);
+		Date yesterday = DateUtils.addDays(new Date(), -1);
+		DroolsPdp pdp = new DroolsPdpImpl(activePdpId, true, 4, yesterday);
+		conn.insertPdp(pdp);
+		DroolsPdpEntity droolsPdpEntity = conn.getPdp(activePdpId);
+		logger.info("testHotStandby2: After insertion, PDP= {}, which is "
+				+ "not current, has DESIGNATED= {}", activePdpId, droolsPdpEntity.isDesignated());
+		assertTrue(droolsPdpEntity.isDesignated() == true);
+		
+		/*
+		 * Promote the designated PDP.
+		 * 
+		 * We have a chicken and egg problem here: we need a StateManagement
+		 * object to invoke the deleteAllStateManagementEntities method.
+		 */
+		 
+		 
+		logger.info("testHotStandby2: Promoting PDP={}", activePdpId);
+		StateManagement sm = new StateManagement(emfXacml, "dummy");
+		sm.deleteAllStateManagementEntities();
+		
+		
+		sm = new StateManagement(emfXacml, activePdpId);//pdp2
+		
+		// Artificially putting a PDP into service is really a two step process, 1)
+		// inserting it as designated and 2) promoting it so that its standbyStatus
+		// is providing service.
+				
+		/*
+		 * Insert this PDP as not designated.  Initial standby state will be 
+		 * either null or cold standby.   Demoting should transit state to
+		 * hot standby.
+		 */
+		 
+		 
+		logger.info("testHotStandby2: Inserting PDP= {} as not designated", thisPdpId);
+		pdp = new DroolsPdpImpl(thisPdpId, false, 4, yesterday);
+		conn.insertPdp(pdp);
+		droolsPdpEntity = conn.getPdp(thisPdpId);
+		logger.info("testHotStandby2: After insertion, PDP={} "
+				+ "has DESIGNATED= {}", thisPdpId, droolsPdpEntity.isDesignated());
+		assertTrue(droolsPdpEntity.isDesignated() == false);
+		
+		
+		// Now we want to create a StateManagementFeature and initialize it.  It will be
+		// discovered by the ActiveStandbyFeature when the election handler initializes.
+
+		StateManagementFeatureAPI sm2 = null;
+		for (StateManagementFeatureAPI feature : StateManagementFeatureAPI.impl.getList())
+		{
+			((PolicySessionFeatureAPI) feature).globalInit(null, configDir);
+			sm2 = feature;
+			logger.debug("testHotStandby2 stateManagementFeature.getResourceName(): {}", sm2.getResourceName());
+			break;
+		}
+		if(sm2 == null){
+			logger.error("testHotStandby2 failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+			logger.debug("testHotStandby2 failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+		}
+		
+		// Create an ActiveStandbyFeature and initialize it. It will discover the StateManagementFeature
+		// that has been created.
+		ActiveStandbyFeatureAPI activeStandbyFeature = null;
+		for (ActiveStandbyFeatureAPI feature : ActiveStandbyFeatureAPI.impl.getList())
+		{
+			((PolicySessionFeatureAPI) feature).globalInit(null, configDir);
+			activeStandbyFeature = feature;
+			logger.debug("testHotStandby2 activeStandbyFeature.getResourceName(): {}", activeStandbyFeature.getResourceName());
+			break;
+		}
+		if(activeStandbyFeature == null){
+			logger.error("testHotStandby2 failed to initialize.  "
+					+ "Unable to get instance of ActiveStandbyFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+			logger.debug("testHotStandby2 failed to initialize.  "
+					+ "Unable to get instance of ActiveStandbyFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+		}
+		
+		logger.info("testHotStandby2: Runner started; Sleeping {} "
+				+ "ms before promoting/demoting", interruptRecoveryTime);
+		Thread.sleep(interruptRecoveryTime);
+
+		logger.info("testHotStandby2: Runner started; promoting PDP={}", activePdpId);
+		//At this point, the newly created pdp will have set the state to disabled/failed/cold standby
+		//because it is stale. So, it cannot be promoted.  We need to call sm.enableNotFailed() so we
+		//can promote it and demote the other pdp - else the other pdp will just spring back to providingservice
+		sm.enableNotFailed();//pdp2
+		sm.promote();
+		String standbyStatus = sm.getStandbyStatus(activePdpId);
+		logger.info("testHotStandby2: After promoting, PDP= {} has standbyStatus= {}", activePdpId, standbyStatus);
+		
+		// demoting PDP should ensure that state transits to hotstandby
+		logger.info("testHotStandby2: Runner started; demoting PDP= {}", thisPdpId);
+		sm2.demote();//pdp1
+		standbyStatus = sm.getStandbyStatus(thisPdpId);
+		logger.info("testHotStandby2: After demoting, PDP={} has standbyStatus= {}",thisPdpId , standbyStatus);
+		
+		logger.info("testHotStandby2: Sleeping {} ms, to allow JpaDroolsPdpsConnector "
+				+ "time to check droolspdpentity table", sleepTime);
+		Thread.sleep(sleepTime);
+		
+		/*
+		 * Verify that this PDP, demoted to HOT_STANDBY, is now
+		 * re-designated and providing service.
+		 */
+		 
+		droolsPdpEntity = conn.getPdp(thisPdpId);
+		logger.info("testHotStandby2: After demoting PDP={}"
+				+ ", DESIGNATED= {}"
+				+ " for PDP= {}", activePdpId, droolsPdpEntity.isDesignated(), thisPdpId);
+		assertTrue(droolsPdpEntity.isDesignated() == true);
+		standbyStatus = sm2.getStandbyStatus(thisPdpId);
+		logger.info("testHotStandby2: After demoting PDP={}"
+				+ ", PDP={} has standbyStatus= {}",
+				activePdpId, thisPdpId, standbyStatus);
+		assertTrue(standbyStatus != null
+				&& standbyStatus.equals(StateManagement.PROVIDING_SERVICE));
+				
+		logger.info("testHotStandby2: Stopping policyManagementRunner");
+		//policyManagementRunner.stopRunner();		
+
+		logger.info("\n\ntestHotStandby2: Exiting\n\n");
+		Thread.sleep(interruptRecoveryTime);
+
+	}
+	
+	 /*		 	
+	 * 1) Inserts and designates this PDP, then verifies that startTransaction
+	 * is successful.
+	 * 
+	 * 2) Demotes PDP, and verifies that because there is only one PDP, it will
+	 * be immediately re-promoted, thus allowing startTransaction to be
+	 * successful.
+	 * 
+	 * 3) Locks PDP and verifies that startTransaction results in
+	 * AdministrativeStateException.
+	 * 
+	 * 4) Unlocks PDP and verifies that startTransaction results in
+	 * StandbyStatusException.
+	 * 
+	 * 5) Promotes PDP and verifies that startTransaction is once again
+	 * successful.
+	 */
+	 
+	//@Ignore
+	//@Test
+	public void testLocking1() throws Exception {
+		logger.debug("testLocking1: Entry");
+		cleanXacmlDb();
+		cleanDroolsDb();		
+		
+		logger.debug("testLocking1: Reading stateManagementProperties");
+		Properties stateManagementProperties = new Properties();
+		stateManagementProperties.load(new FileInputStream(new File(
+				configDir + "/feature-state-management.properties")));
+
+		logger.debug("testLocking1: Creating emfXacml");
+		EntityManagerFactory emfXacml = Persistence.createEntityManagerFactory(
+				"junitXacmlPU", stateManagementProperties);
+		
+		logger.debug("testLocking1: Reading activeStandbyProperties");
+		Properties activeStandbyProperties = new Properties();
+		activeStandbyProperties.load(new FileInputStream(new File(
+				configDir + "/feature-active-standby-management.properties")));
+		String thisPdpId = activeStandbyProperties
+				.getProperty(ActiveStandbyProperties.NODE_NAME);
+
+		logger.debug("testLocking1: Creating emfDrools");
+		EntityManagerFactory emfDrools = Persistence.createEntityManagerFactory(
+				"junitDroolsPU", activeStandbyProperties);
+		
+		DroolsPdpsConnector conn = new JpaDroolsPdpsConnector(emfDrools);
+		
+		logger.debug("testLocking1: Cleaning up tables");
+		conn.deleteAllPdps();
+		
+		/*
+		 * Insert this PDP as designated.  Initial standby state will be 
+		 * either null or cold standby.
+		 */   
+		 
+		logger.debug("testLocking1: Inserting PDP= {} as designated", thisPdpId);
+		DroolsPdpImpl pdp = new DroolsPdpImpl(thisPdpId, true, 4, new Date());
+		conn.insertPdp(pdp);
+		DroolsPdpEntity droolsPdpEntity = conn.getPdp(thisPdpId);
+		logger.debug("testLocking1: After insertion, PDP= {} has DESIGNATED= {}",
+				 thisPdpId, droolsPdpEntity.isDesignated());
+		assertTrue(droolsPdpEntity.isDesignated() == true);
+		
+		logger.debug("testLocking1: Instantiating stateManagement object");
+		StateManagement smDummy = new StateManagement(emfXacml, "dummy");
+		smDummy.deleteAllStateManagementEntities();
+		
+		// Now we want to create a StateManagementFeature and initialize it.  It will be
+		// discovered by the ActiveStandbyFeature when the election handler initializes.
+
+		StateManagementFeatureAPI sm = null;
+		for (StateManagementFeatureAPI feature : StateManagementFeatureAPI.impl.getList())
+		{
+			((PolicySessionFeatureAPI) feature).globalInit(null, configDir);
+			sm = feature;
+			logger.debug("testLocking1 stateManagementFeature.getResourceName(): {}", sm.getResourceName());
+			break;
+		}
+		if(sm == null){
+			logger.error("testLocking1 failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+			logger.debug("testLocking1 failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+		}
+		
+		// Create an ActiveStandbyFeature and initialize it. It will discover the StateManagementFeature
+		// that has been created.
+		ActiveStandbyFeatureAPI activeStandbyFeature = null;
+		for (ActiveStandbyFeatureAPI feature : ActiveStandbyFeatureAPI.impl.getList())
+		{
+			((PolicySessionFeatureAPI) feature).globalInit(null, configDir);
+			activeStandbyFeature = feature;
+			logger.debug("testLocking1 activeStandbyFeature.getResourceName(): {}", activeStandbyFeature.getResourceName());
+			break;
+		}
+		if(activeStandbyFeature == null){
+			logger.error("testLocking1 failed to initialize.  "
+					+ "Unable to get instance of ActiveStandbyFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+			logger.debug("testLocking1 failed to initialize.  "
+					+ "Unable to get instance of ActiveStandbyFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+		}
+		
+		logger.debug("testLocking1: Runner started; Sleeping "
+				+ interruptRecoveryTime + "ms before promoting PDP={}",
+				thisPdpId);
+		Thread.sleep(interruptRecoveryTime);
+
+		logger.debug("testLocking1: Promoting PDP={}", thisPdpId);
+		sm.promote();
+
+		logger.debug("testLocking1: Sleeping {} ms, to allow time for "
+				+ "policy-management.Main class to come up, designated= {}", 
+				 sleepTime, conn.getPdp(thisPdpId).isDesignated());
+		Thread.sleep(sleepTime);
+		
+		logger.debug("testLocking1: Waking up and invoking startTransaction on active PDP={}"
+				+ ", designated= {}",thisPdpId, conn.getPdp(thisPdpId).isDesignated());
+
+
+		IntegrityMonitor droolsPdpIntegrityMonitor = IntegrityMonitor.getInstance();
+		try {
+			droolsPdpIntegrityMonitor.startTransaction();
+			droolsPdpIntegrityMonitor.endTransaction();
+			logger.debug("testLocking1: As expected, transaction successful");
+		} catch (AdministrativeStateException e) {
+			logger.error("testLocking1: Unexpectedly caught AdministrativeStateException, ", e);
+			assertTrue(false);
+		} catch (StandbyStatusException e) {
+			logger.error("testLocking1: Unexpectedly caught StandbyStatusException, ", e);
+			assertTrue(false);
+		} catch (Exception e) {
+			logger.error("testLocking1: Unexpectedly caught Exception, ", e);
+			assertTrue(false);
+		}
+		
+		// demoting should cause state to transit to hotstandby, followed by re-promotion,
+		// since there is only one PDP.
+		logger.debug("testLocking1: demoting PDP={}", thisPdpId);
+		sm.demote();
+		
+		logger.debug("testLocking1: sleeping" + electionWaitSleepTime
+				+ " to allow election handler to re-promote PDP={}", thisPdpId);
+		Thread.sleep(electionWaitSleepTime);
+								
+		logger.debug("testLocking1: Invoking startTransaction on re-promoted PDP={}"
+				+ ", designated={}", thisPdpId, conn.getPdp(thisPdpId).isDesignated());
+		try {
+			droolsPdpIntegrityMonitor.startTransaction();
+			droolsPdpIntegrityMonitor.endTransaction();
+			logger.debug("testLocking1: As expected, transaction successful");
+		} catch (AdministrativeStateException e) {
+			logger.error("testLocking1: Unexpectedly caught AdministrativeStateException, ", e);
+			assertTrue(false);
+		} catch (StandbyStatusException e) {
+			logger.error("testLocking1: Unexpectedly caught StandbyStatusException, ", e);
+			assertTrue(false);
+		} catch (Exception e) {
+			logger.error("testLocking1: Unexpectedly caught Exception, ", e);
+			assertTrue(false);
+		}
+		
+		// locking should cause state to transit to cold standby
+		logger.debug("testLocking1: locking PDP={}", thisPdpId);
+		sm.lock();
+		
+		// Just to avoid any race conditions, sleep a little after locking
+		logger.debug("testLocking1: Sleeping a few millis after locking, to avoid race condition");
+		Thread.sleep(100);
+		
+		logger.debug("testLocking1: Invoking startTransaction on locked PDP= {}"
+				+ ", designated= {}",thisPdpId, conn.getPdp(thisPdpId).isDesignated());
+		try {
+			droolsPdpIntegrityMonitor.startTransaction();
+			logger.error("testLocking1: startTransaction unexpectedly successful");
+			assertTrue(false);
+		} catch (AdministrativeStateException e) {
+			logger.debug("testLocking1: As expected, caught AdministrativeStateException, ", e);
+		} catch (StandbyStatusException e) {
+			logger.error("testLocking1: Unexpectedly caught StandbyStatusException, ", e);
+			assertTrue(false);
+		} catch (Exception e) {
+			logger.error("testLocking1: Unexpectedly caught Exception, ", e);
+			assertTrue(false);
+		} finally {
+			droolsPdpIntegrityMonitor.endTransaction();
+		}		
+		
+		// unlocking should cause state to transit to hot standby and then providing service
+		logger.debug("testLocking1: unlocking PDP={}", thisPdpId);
+		sm.unlock();
+		
+		// Just to avoid any race conditions, sleep a little after locking
+		logger.debug("testLocking1: Sleeping a few millis after unlocking, to avoid race condition");
+		Thread.sleep(electionWaitSleepTime);
+		
+		logger.debug("testLocking1: Invoking startTransaction on unlocked PDP="
+				+ thisPdpId
+				+ ", designated="
+				+ conn.getPdp(thisPdpId).isDesignated());
+		try {
+			droolsPdpIntegrityMonitor.startTransaction();
+			logger.error("testLocking1: startTransaction successful as expected");
+		} catch (AdministrativeStateException e) {
+			logger.error("testLocking1: Unexpectedly caught AdministrativeStateException, ", e);
+			assertTrue(false);
+		} catch (StandbyStatusException e) {
+			logger.debug("testLocking1: Unexpectedly caught StandbyStatusException, ", e);
+			assertTrue(false);
+		} catch (Exception e) {
+			logger.error("testLocking1: Unexpectedly caught Exception, ", e);
+			assertTrue(false);
+		} finally {
+			droolsPdpIntegrityMonitor.endTransaction();
+		}
+		
+		// demoting should cause state to transit to hot standby
+		logger.debug("testLocking1: demoting PDP={}", thisPdpId);
+		sm.demote();
+		
+		// Just to avoid any race conditions, sleep a little after promoting
+		logger.debug("testLocking1: Sleeping a few millis after demoting, to avoid race condition");
+		Thread.sleep(100);
+		
+		logger.debug("testLocking1: Invoking startTransaction on demoted PDP={}"
+				+ ", designated={}", thisPdpId, conn.getPdp(thisPdpId).isDesignated());
+		try {
+			droolsPdpIntegrityMonitor.startTransaction();
+			droolsPdpIntegrityMonitor.endTransaction();
+			logger.debug("testLocking1: Unexpectedly, transaction successful");
+			assertTrue(false);
+		} catch (AdministrativeStateException e) {
+			logger.error("testLocking1: Unexpectedly caught AdministrativeStateException, ", e);
+			assertTrue(false);
+		} catch (StandbyStatusException e) {
+			logger.error("testLocking1: As expected caught StandbyStatusException, ", e);
+		} catch (Exception e) {
+			logger.error("testLocking1: Unexpectedly caught Exception, ", e);
+			assertTrue(false);
+		}
+		
+		logger.debug("\n\ntestLocking1: Exiting\n\n");
+		Thread.sleep(interruptRecoveryTime);
+
+	}
+	
+	
+	/*
+	 * 1) Inserts and designates this PDP, then verifies that startTransaction
+	 * is successful.
+	 * 
+	 * 2) Inserts another PDP in hotstandby.
+	 * 
+	 * 3) Demotes this PDP, and verifies 1) that other PDP is not promoted (because one
+	 * PDP cannot promote another PDP) and 2) that this PDP is re-promoted.
+	 */
+	 
+	//@Ignore
+	//@Test
+	public void testLocking2() throws Exception {
+
+		logger.debug("\n\ntestLocking2: Entering\n\n");
+		cleanXacmlDb();
+		cleanDroolsDb();		
+		
+		logger.debug("testLocking2: Reading stateManagementProperties");
+		Properties stateManagementProperties = new Properties();
+		stateManagementProperties.load(new FileInputStream(new File(
+				configDir + "/feature-state-management.properties")));
+
+		logger.debug("testLocking2: Creating emfXacml");
+		EntityManagerFactory emfXacml = Persistence.createEntityManagerFactory(
+				"junitXacmlPU", stateManagementProperties);
+		
+		logger.debug("testLocking2: Reading activeStandbyProperties");
+		Properties activeStandbyProperties = new Properties();
+		activeStandbyProperties.load(new FileInputStream(new File(
+				configDir + "/feature-active-standby-management.properties")));
+		String thisPdpId = activeStandbyProperties
+				.getProperty(ActiveStandbyProperties.NODE_NAME);
+
+		logger.debug("testLocking2: Creating emfDrools");
+		EntityManagerFactory emfDrools = Persistence.createEntityManagerFactory(
+				"junitDroolsPU", activeStandbyProperties);
+		
+		DroolsPdpsConnector conn = new JpaDroolsPdpsConnector(emfDrools);
+		
+		logger.debug("testLocking2: Cleaning up tables");
+		conn.deleteAllPdps();
+		
+		/*
+		 * Insert this PDP as designated.  Initial standby state will be 
+		 * either null or cold standby.   Demoting should transit state to
+		 * hot standby.
+		 */
+		 
+		logger.debug("testLocking2: Inserting PDP= {} as designated", thisPdpId);
+		DroolsPdpImpl pdp = new DroolsPdpImpl(thisPdpId, true, 3, new Date());
+		conn.insertPdp(pdp);
+		DroolsPdpEntity droolsPdpEntity = conn.getPdp(thisPdpId);
+		logger.debug("testLocking2: After insertion, PDP= {} has DESIGNATED= {}",
+				thisPdpId, droolsPdpEntity.isDesignated());
+		assertTrue(droolsPdpEntity.isDesignated() == true);
+		
+		logger.debug("testLocking2: Instantiating stateManagement object and promoting PDP={}", thisPdpId);
+		StateManagement smDummy = new StateManagement(emfXacml, "dummy");
+		smDummy.deleteAllStateManagementEntities();
+		
+		// Now we want to create a StateManagementFeature and initialize it.  It will be
+		// discovered by the ActiveStandbyFeature when the election handler initializes.
+
+		StateManagementFeatureAPI sm = null;
+		for (StateManagementFeatureAPI feature : StateManagementFeatureAPI.impl.getList())
+		{
+			((PolicySessionFeatureAPI) feature).globalInit(null, configDir);
+			sm = feature;
+			logger.debug("testLocking2 stateManagementFeature.getResourceName(): {}", sm.getResourceName());
+			break;
+		}
+		if(sm == null){
+			logger.error("testLocking2 failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+			logger.debug("testLocking2 failed to initialize.  "
+					+ "Unable to get instance of StateManagementFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+		}
+		
+		// Create an ActiveStandbyFeature and initialize it. It will discover the StateManagementFeature
+		// that has been created.
+		ActiveStandbyFeatureAPI activeStandbyFeature = null;
+		for (ActiveStandbyFeatureAPI feature : ActiveStandbyFeatureAPI.impl.getList())
+		{
+			((PolicySessionFeatureAPI) feature).globalInit(null, configDir);
+			activeStandbyFeature = feature;
+			logger.debug("testLocking2 activeStandbyFeature.getResourceName(): {}", activeStandbyFeature.getResourceName());
+			break;
+		}
+		if(activeStandbyFeature == null){
+			logger.error("testLocking2 failed to initialize.  "
+					+ "Unable to get instance of ActiveStandbyFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+			logger.debug("testLocking2 failed to initialize.  "
+					+ "Unable to get instance of ActiveStandbyFeatureAPI "
+					+ "with resourceID: {}", thisPdpId);
+		}
+		
+		/*
+		 * Insert another PDP as not designated.  Initial standby state will be 
+		 * either null or cold standby.   Demoting should transit state to
+		 * hot standby.
+		 */
+		 
+		String standbyPdpId = "pdp2";
+		logger.debug("testLocking2: Inserting PDP= {} as not designated", standbyPdpId);
+		Date yesterday = DateUtils.addDays(new Date(), -1);
+		pdp = new DroolsPdpImpl(standbyPdpId, false, 4, yesterday);
+		conn.insertPdp(pdp);
+		droolsPdpEntity = conn.getPdp(standbyPdpId);
+		logger.debug("testLocking2: After insertion, PDP={} has DESIGNATED= {}", 
+				 standbyPdpId, droolsPdpEntity.isDesignated());
+		assertTrue(droolsPdpEntity.isDesignated() == false);
+		
+		logger.debug("testLocking2: Demoting PDP= {}", standbyPdpId);
+		StateManagement sm2 = new StateManagement(emfXacml, standbyPdpId);
+				
+		logger.debug("testLocking2: Runner started; Sleeping {} ms "
+				+ "before promoting/demoting", interruptRecoveryTime);
+		Thread.sleep(interruptRecoveryTime);
+
+		logger.debug("testLocking2: Promoting PDP= {}", thisPdpId);
+		sm.promote();
+
+		// demoting PDP should ensure that state transits to hotstandby
+		logger.debug("testLocking2: Demoting PDP={}", standbyPdpId);
+		sm2.demote();
+		
+		logger.debug("testLocking2: Sleeping {} ms, to allow time for to come up", sleepTime);
+		Thread.sleep(sleepTime);
+		
+		logger.debug("testLocking2: Waking up and invoking startTransaction on active PDP={}"
+				+ ", designated= {}", thisPdpId, conn.getPdp(thisPdpId).isDesignated());
+
+		IntegrityMonitor droolsPdpIntegrityMonitor = IntegrityMonitor.getInstance();
+
+		try {
+			droolsPdpIntegrityMonitor.startTransaction();
+			droolsPdpIntegrityMonitor.endTransaction();
+			logger.debug("testLocking2: As expected, transaction successful");
+		} catch (AdministrativeStateException e) {
+			logger.error("testLocking2: Unexpectedly caught AdministrativeStateException, ", e);
+			assertTrue(false);
+		} catch (StandbyStatusException e) {
+			logger.error("testLocking2: Unexpectedly caught StandbyStatusException, ", e);
+			assertTrue(false);
+		} catch (Exception e) {
+			logger.error("testLocking2: Unexpectedly caught Exception, ", e);
+			assertTrue(false);
+		}
+		
+		// demoting should cause state to transit to hotstandby followed by re-promotion.
+		logger.debug("testLocking2: demoting PDP={}", thisPdpId);
+		sm.demote();
+		
+		logger.debug("testLocking2: sleeping {}"
+				+ " to allow election handler to re-promote PDP={}", electionWaitSleepTime, thisPdpId);
+		Thread.sleep(electionWaitSleepTime);
+		
+		logger.debug("testLocking2: Waking up and invoking startTransaction "
+				+ "on re-promoted PDP= {}, designated= {}",
+				 thisPdpId, conn.getPdp(thisPdpId).isDesignated());
+		try {
+			droolsPdpIntegrityMonitor.startTransaction();
+			droolsPdpIntegrityMonitor.endTransaction();
+			logger.debug("testLocking2: As expected, transaction successful");
+		} catch (AdministrativeStateException e) {
+			logger.error("testLocking2: Unexpectedly caught AdministrativeStateException, ", e);
+			assertTrue(false);
+		} catch (StandbyStatusException e) {
+			logger.error("testLocking2: Unexpectedly caught StandbyStatusException, ", e);
+			assertTrue(false);
+		} catch (Exception e) {
+			logger.error("testLocking2: Unexpectedly caught Exception, ", e);
+			assertTrue(false);
+		}
+		
+		logger.debug("testLocking2: Verifying designated status for PDP= {}", standbyPdpId);
+		boolean standbyPdpDesignated = conn.getPdp(standbyPdpId).isDesignated();
+		assertTrue(standbyPdpDesignated == false);
+
+		logger.debug("\n\ntestLocking2: Exiting\n\n");
+		Thread.sleep(interruptRecoveryTime);
+	}
+}
diff --git a/feature-active-standby-management/src/test/resources/META-INF/persistence.xml b/feature-active-standby-management/src/test/resources/META-INF/persistence.xml
new file mode 100644
index 00000000..ff6ac58a
--- /dev/null
+++ b/feature-active-standby-management/src/test/resources/META-INF/persistence.xml
@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ============LICENSE_START=======================================================
+  feature-active-standby-management
+  ================================================================================
+  Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+  ================================================================================
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+  
+       http://www.apache.org/licenses/LICENSE-2.0
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+  ============LICENSE_END=========================================================
+  -->
+
+<persistence version="2.1"
+	xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
+	<persistence-unit name="junitDroolsPU" transaction-type="RESOURCE_LOCAL">
+		<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
+		<class>org.onap.policy.drools.activestandby.DroolsPdpEntity</class>
+		<properties>
+			<property name="javax.persistence.schema-generation.database.action" value="drop-and-create"/>
+			<property name="javax.persistence.schema-generation.scripts.action" value="drop-and-create"/> 
+            <property name="javax.persistence.schema-generation.scripts.create-target" value="./sql/generatedCreateDrools.ddl"/>
+            <property name="javax.persistence.schema-generation.scripts.drop-target" value="./sql/generatedDropDrools.ddl"/>
+        </properties>
+	</persistence-unit>
+	<persistence-unit name="junitXacmlPU" transaction-type="RESOURCE_LOCAL">
+		<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
+		<class>org.onap.policy.common.im.jpa.StateManagementEntity</class>
+		<class>org.onap.policy.common.im.jpa.ForwardProgressEntity</class>
+		<class>org.onap.policy.common.im.jpa.ResourceRegistrationEntity</class>
+		<properties>
+			<property name="javax.persistence.schema-generation.database.action" value="drop-and-create"/>
+			<property name="javax.persistence.schema-generation.scripts.action" value="drop-and-create"/> 
+            <property name="javax.persistence.schema-generation.scripts.create-target" value="./sql/generatedCreateXacml.ddl"/>
+            <property name="javax.persistence.schema-generation.scripts.drop-target" value="./sql/generatedDropXacml.ddl"/>
+        </properties>
+	</persistence-unit>
+</persistence>
diff --git a/feature-active-standby-management/src/test/resources/feature-active-standby-management.properties b/feature-active-standby-management/src/test/resources/feature-active-standby-management.properties
new file mode 100644
index 00000000..bbae5d98
--- /dev/null
+++ b/feature-active-standby-management/src/test/resources/feature-active-standby-management.properties
@@ -0,0 +1,39 @@
+###
+# ============LICENSE_START=======================================================
+# feature-active-standby-management
+# ================================================================================
+# Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+# ================================================================================
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============LICENSE_END=========================================================
+###
+
+# DB properties
+javax.persistence.jdbc.driver = org.h2.Driver
+javax.persistence.jdbc.url  = jdbc:h2:file:./sql/activestandbymanagement
+javax.persistence.jdbc.user = sa
+javax.persistence.jdbc.password =
+
+# Must be unique across the system
+resource.name=pdp1
+# Name of the site in which this node is hosted 
+site_name=pdp_1
+
+# Needed by DroolsPdpsElectionHandler
+pdp.checkInterval=1500
+pdp.updateInterval=1000
+#pdp.timeout=3000
+# Need long timeout, because testTransaction is only run every 10 seconds.
+pdp.timeout=15000
+#how long do we wait for the pdp table to populate on initial startup
+pdp.initialWait=20000
\ No newline at end of file
diff --git a/feature-active-standby-management/src/test/resources/feature-state-management.properties b/feature-active-standby-management/src/test/resources/feature-state-management.properties
new file mode 100644
index 00000000..3d767a17
--- /dev/null
+++ b/feature-active-standby-management/src/test/resources/feature-state-management.properties
@@ -0,0 +1,74 @@
+###
+# ============LICENSE_START=======================================================
+# feature-active-standby-management
+# ================================================================================
+# Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+# ================================================================================
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============LICENSE_END=========================================================
+###
+
+# DB properties
+javax.persistence.jdbc.driver = org.h2.Driver
+javax.persistence.jdbc.url  = jdbc:h2:file:./sql/statemanagement
+javax.persistence.jdbc.user = sa
+javax.persistence.jdbc.password =
+
+# DroolsPDPIntegrityMonitor Properties
+hostPort = 0.0.0.0:57692
+
+#IntegrityMonitor Properties
+
+# Must be unique across the system
+resource.name=pdp1
+# Name of the site in which this node is hosted 
+site_name = pdp_1
+# Forward Progress Monitor update interval seconds
+fp_monitor_interval = 30
+# Failed counter threshold before failover 
+failed_counter_threshold = 3
+# Interval between test transactions when no traffic seconds
+test_trans_interval = 10
+# Interval between writes of the FPC to the DB seconds 
+write_fpc_interval = 5
+# Node type Note: Make sure you don't leave any trailing spaces, or you'll get an 'invalid node type' error! 
+node_type = pdp_drools
+# Dependency groups are groups of resources upon which a node operational state is dependent upon. 
+# Each group is a comma-separated list of resource names and groups are separated by a semicolon.  For example:
+# dependency_groups=site_1.astra_1,site_1.astra_2;site_1.brms_1,site_1.brms_2;site_1.logparser_1;site_1.pypdp_1
+dependency_groups=
+# When set to true, dependent health checks are performed by using JMX to invoke test() on the dependent.
+# The default false is to use state checks for health.
+test_via_jmx=true
+# This is the max number of seconds beyond which a non incrementing FPC is considered a failure
+max_fpc_update_interval=120
+# Run the state audit every 60 seconds (60000 ms).  The state audit finds stale DB entries in the 
+# forwardprogressentity table and marks the node as disabled/failed in the statemanagemententity 
+# table. NOTE! It will only run on nodes that have a standbystatus = providingservice.
+# A value of <= 0 will turn off the state audit.
+state_audit_interval_ms=60000
+# The refresh state audit is run every (default) 10 minutes (600000 ms) to clean up any state corruption in the 
+# DB statemanagemententity table. It only refreshes the DB state entry for the local node.  That is, it does not
+# refresh the state of any other nodes.  A value <= 0 will turn the audit off. Any other value will override 
+# the default of 600000 ms.
+refresh_state_audit_interval_ms=600000
+
+
+# Repository audit properties
+# Flag to control the execution of the subsystemTest for the Nexus Maven repository
+repository.audit.is.active=false
+repository.audit.ignore.errors=true
+
+# DB Audit Properties
+# Flag to control the execution of the subsystemTest for the Database
+db.audit.is.active=false
diff --git a/feature-active-standby-management/src/test/resources/logback-test.xml b/feature-active-standby-management/src/test/resources/logback-test.xml
new file mode 100644
index 00000000..a36bdb16
--- /dev/null
+++ b/feature-active-standby-management/src/test/resources/logback-test.xml
@@ -0,0 +1,46 @@
+<!--
+  ============LICENSE_START=======================================================
+  feature-state-management
+  ================================================================================
+  Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+  ================================================================================
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+  
+       http://www.apache.org/licenses/LICENSE-2.0
+  
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+  ============LICENSE_END=========================================================
+  -->
+
+<!-- Controls the output of logs for JUnit tests -->
+
+<configuration>
+
+	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+		<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
+			<Pattern>
+				%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36}.%M\(%line\) - %msg%n
+			</Pattern>
+		</encoder>
+	</appender>
+	<appender name="FILE" class="ch.qos.logback.core.FileAppender">
+		<file>logs/debug.log</file>
+		<encoder>
+			<Pattern>
+				%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36}.%M\(%line\) - %msg%n
+			</Pattern>
+		</encoder>
+	</appender>
+	
+	<root level="debug">
+		<appender-ref ref="STDOUT" />
+		<appender-ref ref="FILE" />
+	</root>
+
+</configuration>