Remove policy/common integrity-audit suppressions

Changed "DbDAO" to "DbDao".

Change-Id: I51a6706cceef6857404ae7c12ce43e553ea0da29
Issue-ID: POLICY-1133
Signed-off-by: Jim Hahn <jrh3@att.com>

1 files changed, 780 insertions, 0 deletions

diff --git a/integrity-audit/src/main/java/org/onap/policy/common/ia/DbDao.java b/integrity-audit/src/main/java/org/onap/policy/common/ia/DbDao.java
new file mode 100644
index 00000000..08243310
--- /dev/null
+++ b/integrity-audit/src/main/java/org/onap/policy/common/ia/DbDao.java
@@ -0,0 +1,780 @@
+/*
+ * ============LICENSE_START=======================================================
+ * Integrity Audit
+ * ================================================================================
+ * Copyright (C) 2017-2019 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.common.ia;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.EntityTransaction;
+import javax.persistence.LockTimeoutException;
+import javax.persistence.Persistence;
+import javax.persistence.PersistenceUnitUtil;
+import javax.persistence.Query;
+import javax.persistence.TypedQuery;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Root;
+import javax.persistence.metamodel.ManagedType;
+import javax.persistence.metamodel.Metamodel;
+import org.onap.policy.common.ia.jpa.IntegrityAuditEntity;
+import org.onap.policy.common.logging.flexlogger.FlexLogger;
+import org.onap.policy.common.logging.flexlogger.Logger;
+
+/**
+ * class DbDao provides the inteface to the DBs for the purpose of audits.
+ * 
+ */
+public class DbDao {
+    private static final Logger logger = FlexLogger.getLogger(DbDao.class.getName());
+    
+    private String resourceName;
+    private String persistenceUnit;
+    private String dbDriver;
+    private String dbUrl;
+    private String dbUser;
+    private String siteName;
+    private String nodeType;
+    private Properties properties = null;
+
+    private EntityManagerFactory emf;
+
+    /*
+     * Supports designation serialization.
+     */
+    private static final Object lock = new Object();
+    
+    /*
+     * Common strings.
+     */
+    private static final String RESOURCE_MESSAGE = "Resource: ";
+    private static final String WITH_PERSISTENCE_MESSAGE = " with PersistenceUnit: ";
+    private static final String DBDAO_MESSAGE = "DbDao: ";
+    private static final String ENCOUNTERED_MESSAGE = "ecountered a problem in execution: ";
+    
+    /*
+     * DB SELECT String.
+     */
+    private static final String SELECT_STRING = "Select i from IntegrityAuditEntity i "
+            + "where i.resourceName=:rn and i.persistenceUnit=:pu";
+
+    /**
+     * DbDao Constructor.
+     * 
+     * @param resourceName the resource name
+     * @param persistenceUnit the persistence unit
+     * @param properties the properties
+     * @throws IntegrityAuditException if an error occurs
+     */
+    public DbDao(String resourceName, String persistenceUnit, Properties properties) throws IntegrityAuditException {
+        this(resourceName, persistenceUnit, properties, null);
+    }
+
+    /**
+     * DbDao Constructor.
+     * 
+     * @param resourceName the resource name
+     * @param persistenceUnit the persistence unit
+     * @param properties the properties
+     * @param lastUpdateDate may be {@code null}
+     * @param altDbUrl may be {@code null}
+     * @throws IntegrityAuditException if an error occurs
+     */
+    protected DbDao(String resourceName, String persistenceUnit, Properties properties, String altDbUrl)
+            throws IntegrityAuditException {
+        logger.debug("DbDao contructor: enter");
+
+        validateProperties(resourceName, persistenceUnit, properties);
+
+        emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+
+        register(altDbUrl);
+
+        logger.debug("DbDao contructor: exit");
+    }
+
+    /**
+     * Release resources (i.e., the EntityManagerFactory).
+     */
+    public void destroy() {
+        emf.close();
+    }
+
+    /**
+     * validateProperties will validate the properties.
+     * 
+     * @param resourceName the rseource name
+     * @param persistenceUnit the persistence unit
+     * @param properties the properties
+     * @throws IntegrityAuditPropertiesException if an error occurs
+     */
+    private void validateProperties(String resourceName, String persistenceUnit, Properties properties)
+            throws IntegrityAuditPropertiesException {
+        StringBuilder badparams = new StringBuilder();
+        if (IntegrityAudit.parmsAreBad(resourceName, persistenceUnit, properties, badparams)) {
+            String msg = "DbDao: Bad parameters: badparams" + badparams;
+            throw new IntegrityAuditPropertiesException(msg);
+        }
+        this.resourceName = resourceName;
+        this.persistenceUnit = persistenceUnit;
+        this.dbDriver = properties.getProperty(IntegrityAuditProperties.DB_DRIVER).trim();
+        this.dbUrl = properties.getProperty(IntegrityAuditProperties.DB_URL).trim();
+        this.dbUser = properties.getProperty(IntegrityAuditProperties.DB_USER).trim();
+        this.siteName = properties.getProperty(IntegrityAuditProperties.SITE_NAME).trim();
+        this.nodeType = properties.getProperty(IntegrityAuditProperties.NODE_TYPE).trim();
+        this.properties = properties;
+        logger.debug("DbDao.assignProperties: exit:" + "\nresourceName: " + this.resourceName + "\npersistenceUnit: "
+                + this.persistenceUnit + "\nproperties: " + this.properties);
+    }
+
+    /**
+     * getAllMyEntries gets all the DB entries for a particular class.
+     * 
+     * @param className the class name
+     * @return all the DB entries for the given class
+     */
+    public Map<Object, Object> getAllMyEntries(String className) {
+        logger.debug("getAllMyEntries: Entering, className=" + className);
+        HashMap<Object, Object> resultMap = new HashMap<>();
+        EntityManager em = emf.createEntityManager();
+        try {
+            CriteriaBuilder cb = em.getCriteriaBuilder();
+            CriteriaQuery<Object> cq = cb.createQuery();
+            Root<?> rootEntry = cq.from(Class.forName(className));
+            CriteriaQuery<Object> all = cq.select(rootEntry);
+            TypedQuery<Object> allQuery = em.createQuery(all);
+            List<Object> objectList = allQuery.getResultList();
+            // Now create the map
+
+            PersistenceUnitUtil util = emf.getPersistenceUnitUtil();
+            for (Object o : objectList) {
+                Object key = util.getIdentifier(o);
+                resultMap.put(key, o);
+            }
+        } catch (Exception e) {
+            logger.error("getAllEntries encountered exception: ", e);
+        }
+        em.close();
+        logger.debug("getAllMyEntries: Exit, resultMap.keySet()=" + resultMap.keySet());
+        return resultMap;
+    }
+
+    /**
+     * getAllMyEntries gets all entries for a class.
+     * 
+     * @param className the name of the class
+     * @param keySet the keys to get the entries for
+     * @return the map of requested entries
+     */
+    public Map<Object, Object> getAllMyEntries(String className, Set<Object> keySet) {
+        logger.debug("getAllMyEntries: Entering, className=" + className + ",\n keySet=" + keySet);
+
+        HashMap<Object, Object> resultMap = new HashMap<>();
+        EntityManager em = emf.createEntityManager();
+        try {
+            Class<?> clazz = Class.forName(className);
+            for (Object key : keySet) {
+                Object entry = em.find(clazz, key);
+                resultMap.put(key, entry);
+            }
+        } catch (Exception e) {
+            logger.error("getAllMyEntries encountered exception: ", e);
+        }
+        em.close();
+
+        logger.debug("getAllMyEntries: Returning resultMap, size=" + resultMap.size());
+        return resultMap;
+    }
+
+    /**
+     * getAllEntries gets all entriesfor a particular persistence unit adn className.
+     * 
+     * @param persistenceUnit the persistence unit
+     * @param properties the properties
+     * @param className the class name
+     * @return the map of entries
+     */
+    public Map<Object, Object> getAllEntries(String persistenceUnit, Properties properties, String className) {
+
+        logger.debug("getAllEntries: Entering, persistenceUnit=" + persistenceUnit + ",\n className=" + className);
+        HashMap<Object, Object> resultMap = new HashMap<>();
+
+        EntityManagerFactory theEmf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+        EntityManager em = theEmf.createEntityManager();
+        try {
+            CriteriaBuilder cb = em.getCriteriaBuilder();
+            CriteriaQuery<Object> cq = cb.createQuery();
+            Root<?> rootEntry = cq.from(Class.forName(className));
+            CriteriaQuery<Object> all = cq.select(rootEntry);
+            TypedQuery<Object> allQuery = em.createQuery(all);
+            List<Object> objectList = allQuery.getResultList();
+
+            PersistenceUnitUtil util = theEmf.getPersistenceUnitUtil();
+            for (Object o : objectList) {
+                Object key = util.getIdentifier(o);
+                resultMap.put(key, o);
+            }
+        } catch (Exception e) {
+            logger.error("getAllEntries encountered exception:", e);
+        }
+        em.close();
+        theEmf.close();
+
+        logger.debug("getAllEntries: Returning resultMap, size=" + resultMap.size());
+
+        return resultMap;
+    }
+
+
+    /**
+     * getAllEntries gets all entries for a persistence unit.
+     * 
+     * @param persistenceUnit the persistence unit
+     * @param properties the properties
+     * @param className the class name
+     * @param keySet the keys
+     * @return the map of entries
+     */
+
+    public Map<Object, Object> getAllEntries(String persistenceUnit, Properties properties, String className,
+            Set<Object> keySet) {
+        logger.debug("getAllEntries: Entering, persistenceUnit=" + persistenceUnit + ",\n properties= " + properties
+                + ",\n className=" + className + ",\n keySet= " + keySet);
+        EntityManagerFactory theEmf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+        EntityManager em = theEmf.createEntityManager();
+        HashMap<Object, Object> resultMap = new HashMap<>();
+        try {
+            Class<?> clazz = Class.forName(className);
+            for (Object key : keySet) {
+                Object entry = em.find(clazz, key);
+                resultMap.put(key, entry);
+            }
+        } catch (Exception e) {
+            String msg = "getAllEntries encountered exception: " + e;
+            logger.error(msg, e);
+        }
+        em.close();
+        theEmf.close();
+        logger.debug("getAllEntries: Exit, resultMap, size=" + resultMap.size());
+        return resultMap;
+    }
+
+    /**
+     * getIntegrityAuditEntities() Get all the IntegrityAuditEntities for a particular persistence
+     * unit and node type.
+     * 
+     * @param persistenceUnit the persistence unit
+     * @param nodeType the node type
+     * @return the list of IntegrityAuditEntity
+     * @throws DbDaoTransactionException if an error occurs
+     */
+    @SuppressWarnings("unchecked")
+    public List<IntegrityAuditEntity> getIntegrityAuditEntities(String persistenceUnit, String nodeType)
+            throws DbDaoTransactionException {
+        logger.debug("getIntegrityAuditEntities: Entering, persistenceUnit=" + persistenceUnit + ",\n nodeType= "
+                + nodeType);
+        try {
+            EntityManager em = emf.createEntityManager();
+            // Start a transaction
+            EntityTransaction et = em.getTransaction();
+
+            et.begin();
+
+            // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not
+            // found, create a new entry
+            Query iaequery = em
+                    .createQuery("Select i from IntegrityAuditEntity i where i.persistenceUnit=:pu and i.nodeType=:nt");
+            iaequery.setParameter("pu", persistenceUnit);
+            iaequery.setParameter("nt", nodeType);
+
+            List<IntegrityAuditEntity> iaeList = iaequery.getResultList();
+
+            // commit transaction
+            et.commit();
+            em.close();
+            logger.debug("getIntegrityAuditEntities: Exit, iaeList=" + iaeList);
+            return iaeList;
+        } catch (Exception e) {
+            String msg = DBDAO_MESSAGE + "getIntegrityAuditEntities() " + ENCOUNTERED_MESSAGE;
+            logger.error(msg, e);
+            throw new DbDaoTransactionException(e);
+        }
+
+    }
+
+    /**
+     * getMyIntegrityAuditEntity() gets my IntegrityAuditEntity.
+     * 
+     * @return the IntegrityAuditEntity
+     * @throws DbDaoTransactionException if an error occurs
+     */
+    public IntegrityAuditEntity getMyIntegrityAuditEntity() throws DbDaoTransactionException {
+        try {
+            EntityManager em = emf.createEntityManager();
+
+            // Start a transaction
+            EntityTransaction et = em.getTransaction();
+
+            et.begin();
+
+            // if IntegrityAuditEntity entry exists for resourceName and PU, retrieve it
+            Query iaequery = em.createQuery(
+                    SELECT_STRING);
+            iaequery.setParameter("rn", this.resourceName);
+            iaequery.setParameter("pu", this.persistenceUnit);
+
+            @SuppressWarnings("rawtypes")
+            List iaeList = iaequery.getResultList();
+            IntegrityAuditEntity iae = null;
+
+            if (!iaeList.isEmpty()) {
+                // ignores multiple results
+                iae = (IntegrityAuditEntity) iaeList.get(0);
+                // refresh the object from DB in case cached data was returned
+                em.refresh(iae);
+                logger.info(RESOURCE_MESSAGE + this.resourceName + WITH_PERSISTENCE_MESSAGE + this.persistenceUnit
+                        + " exists");
+            } else {
+                // If it does not exist, log an error
+                logger.error("Attempting to setLastUpdated" + " on an entry that does not exist: resource "
+                        + this.resourceName + WITH_PERSISTENCE_MESSAGE + this.persistenceUnit);
+            }
+
+            // close the transaction
+            et.commit();
+            // close the EntityManager
+            em.close();
+
+            return iae;
+        } catch (Exception e) {
+            String msg = DBDAO_MESSAGE + "setLastUpdated() " + ENCOUNTERED_MESSAGE;
+            logger.error(msg + e);
+            throw new DbDaoTransactionException(e);
+        }
+    }
+
+
+    /**
+     * getIntegrityAuditEntity() gets the IntegrityAuditEntity with a particular ID.
+     * 
+     * @param id the ID
+     * @return the IntegrityAuditEntity
+     * @throws DbDaoTransactionException if an error occurs
+     */
+    public IntegrityAuditEntity getIntegrityAuditEntity(long id) throws DbDaoTransactionException {
+        try {
+            EntityManager em = emf.createEntityManager();
+
+            // Start a transaction
+            EntityTransaction et = em.getTransaction();
+
+            et.begin();
+
+            IntegrityAuditEntity iae = em.find(IntegrityAuditEntity.class, id);
+
+            et.commit();
+            em.close();
+
+            return iae;
+        } catch (Exception e) {
+            String msg = DBDAO_MESSAGE + "getIntegrityAuditEntity() " + ENCOUNTERED_MESSAGE;
+            logger.error(msg + e);
+            throw new DbDaoTransactionException(e);
+        }
+    }
+
+    /**
+     * getPersistenceClassNames() gets all the persistence class names.
+     * 
+     * @return the persistence class names
+     */
+    public Set<String> getPersistenceClassNames() {
+        logger.debug("DbDao: getPersistenceClassNames() entry");
+        HashSet<String> returnList = new HashSet<>();
+        final Metamodel mm = emf.getMetamodel();
+        logger.debug("\n" + persistenceUnit + " persistence unit classes:");
+        for (final ManagedType<?> managedType : mm.getManagedTypes()) {
+            Class<?> clazz = managedType.getJavaType();
+            logger.debug("    " + clazz.getSimpleName());
+            returnList.add(clazz.getName()); // the full class name needed to make a query using jpa
+        }
+        logger.debug("DbDao: getPersistenceClassNames() exit");
+        return returnList;
+    }
+
+    /**
+     * Register the IntegrityAudit instance.
+     * 
+     * @param altDbUrl alternate DB URL to be placed into the record, or {@code null} to use the
+     *        default
+     */
+    private void register(String altDbUrl) throws DbDaoTransactionException {
+        try {
+            EntityManager em = emf.createEntityManager();
+
+            // Start a transaction
+            EntityTransaction et = em.getTransaction();
+
+            et.begin();
+
+            // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not
+            // found, create a new entry
+            Query iaequery = em.createQuery(
+                    SELECT_STRING);
+            iaequery.setParameter("rn", this.resourceName);
+            iaequery.setParameter("pu", this.persistenceUnit);
+
+            @SuppressWarnings("rawtypes")
+            List iaeList = iaequery.getResultList();
+            IntegrityAuditEntity iae;
+
+            // If it already exists, we just want to update the properties and lastUpdated date
+            if (!iaeList.isEmpty()) {
+                // ignores multiple results
+                iae = (IntegrityAuditEntity) iaeList.get(0);
+                // refresh the object from DB in case cached data was returned
+                em.refresh(iae);
+                logger.info(RESOURCE_MESSAGE + this.resourceName + WITH_PERSISTENCE_MESSAGE + this.persistenceUnit
+                        + " exists and entry be updated");
+            } else {
+                // If it does not exist, we also must add teh resourceName, persistenceUnit and
+                // designated values
+                logger.info("Adding resource " + resourceName + WITH_PERSISTENCE_MESSAGE + this.persistenceUnit
+                        + " to IntegrityAuditEntity table");
+                iae = new IntegrityAuditEntity();
+                iae.setResourceName(this.resourceName);
+                iae.setPersistenceUnit(this.persistenceUnit);
+                iae.setDesignated(false);
+            }
+            // update/set properties in entry
+            iae.setSite(this.siteName);
+            iae.setNodeType(this.nodeType);
+            iae.setJdbcDriver(this.dbDriver);
+            iae.setJdbcPassword(properties.getProperty(IntegrityAuditProperties.DB_PWD).trim());
+            iae.setJdbcUrl(altDbUrl == null ? this.dbUrl : altDbUrl);
+            iae.setJdbcUser(dbUser);
+
+            em.persist(iae);
+            // flush to the DB
+            em.flush();
+
+            // commit transaction
+            et.commit();
+            em.close();
+        } catch (Exception e) {
+            String msg = DBDAO_MESSAGE + "register() " + "encountered a problem in execution: ";
+            logger.error(msg + e);
+            throw new DbDaoTransactionException(e);
+        }
+
+    }
+
+    public void setDesignated(boolean designated) throws DbDaoTransactionException {
+        setDesignated(this.resourceName, this.persistenceUnit, designated);
+    }
+
+    /**
+     * Set designated.
+     * 
+     * @param resourceName the resource name
+     * @param persistenceUnit the persistence unit
+     * @param desig true if is designated
+     * @throws DbDaoTransactionException if an error occurs
+     */
+    public void setDesignated(String resourceName, String persistenceUnit, boolean desig)
+            throws DbDaoTransactionException {
+        logger.debug("setDesignated: enter, resourceName: " + resourceName + ", persistenceUnit: " + persistenceUnit
+                + ", designated: " + desig);
+        try {
+
+            EntityManager em = emf.createEntityManager();
+
+            // Start a transaction
+            EntityTransaction et = em.getTransaction();
+
+            et.begin();
+
+            // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not
+            // found, create a new entry
+            Query iaequery = em.createQuery(
+                    SELECT_STRING);
+            iaequery.setParameter("rn", resourceName);
+            iaequery.setParameter("pu", persistenceUnit);
+
+            @SuppressWarnings("rawtypes")
+            List iaeList = iaequery.getResultList();
+            IntegrityAuditEntity iae;
+
+            if (!iaeList.isEmpty()) {
+                // ignores multiple results
+                iae = (IntegrityAuditEntity) iaeList.get(0);
+                // refresh the object from DB in case cached data was returned
+                em.refresh(iae);
+                logger.info(RESOURCE_MESSAGE + resourceName + WITH_PERSISTENCE_MESSAGE + persistenceUnit
+                        + " exists and designated be updated");
+                iae.setDesignated(desig);
+
+                em.persist(iae);
+                // flush to the DB
+                em.flush();
+            } else {
+                // If it does not exist, log an error
+                logger.error("Attempting to setDesignated(" + desig + ") on an entry that does not exist:"
+                        + " resource " + resourceName + WITH_PERSISTENCE_MESSAGE + persistenceUnit);
+            }
+
+            // close the transaction
+            et.commit();
+            // close the EntityManager
+            em.close();
+        } catch (Exception e) {
+            String msg = DBDAO_MESSAGE + "setDesignated() " + ENCOUNTERED_MESSAGE;
+            logger.error(msg + e);
+            throw new DbDaoTransactionException(e);
+        }
+
+    }
+
+    /**
+     * Set last updated.
+     * 
+     * @throws DbDaoTransactionException if an error occurs
+     */
+    public void setLastUpdated() throws DbDaoTransactionException {
+        logger.debug("setLastUpdated: enter, resourceName: " + this.resourceName + ", persistenceUnit: "
+                + this.persistenceUnit);
+        try {
+            EntityManager em = emf.createEntityManager();
+
+            // Start a transaction
+            EntityTransaction et = em.getTransaction();
+
+            et.begin();
+
+            // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not
+            // found, create a new entry
+            Query iaequery = em.createQuery(
+                    SELECT_STRING);
+            iaequery.setParameter("rn", this.resourceName);
+            iaequery.setParameter("pu", this.persistenceUnit);
+
+            @SuppressWarnings("rawtypes")
+            List iaeList = iaequery.getResultList();
+            IntegrityAuditEntity iae;
+
+            if (!iaeList.isEmpty()) {
+                // ignores multiple results
+                iae = (IntegrityAuditEntity) iaeList.get(0);
+                // refresh the object from DB in case cached data was returned
+                em.refresh(iae);
+                logger.info(RESOURCE_MESSAGE + this.resourceName + WITH_PERSISTENCE_MESSAGE + this.persistenceUnit
+                        + " exists and lastUpdated be updated");
+                iae.setLastUpdated(AuditorTime.getInstance().getDate());
+
+                em.persist(iae);
+                // flush to the DB
+                em.flush();
+            } else {
+                // If it does not exist, log an error
+                logger.error("Attempting to setLastUpdated" + " on an entry that does not exist:" + " resource "
+                        + this.resourceName + WITH_PERSISTENCE_MESSAGE + this.persistenceUnit);
+            }
+
+            // close the transaction
+            et.commit();
+            // close the EntityManager
+            em.close();
+        } catch (Exception e) {
+            String msg = DBDAO_MESSAGE + "setLastUpdated() " + ENCOUNTERED_MESSAGE;
+            logger.error(msg + e);
+            throw new DbDaoTransactionException(e);
+        }
+
+    }
+
+    /**
+     * Normally this method should only be used in a JUnit test environment. Manually deletes all
+     * PDP records in droolspdpentity table.
+     */
+    public int deleteAllIntegrityAuditEntities() throws DbDaoTransactionException {
+
+        try {
+
+            if (!IntegrityAudit.isUnitTesting()) {
+                String msg = DBDAO_MESSAGE + "deleteAllIntegrityAuditEntities() "
+                        + "should only be invoked during JUnit testing";
+                logger.error(msg);
+                throw new DbDaoTransactionException(msg);
+            }
+
+            EntityManager em = emf.createEntityManager();
+            // Start a transaction
+            EntityTransaction et = em.getTransaction();
+
+            et.begin();
+
+            // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not
+            // found, create a new entry
+            Query iaequery = em.createQuery("Delete from IntegrityAuditEntity");
+
+            int returnCode = iaequery.executeUpdate();
+
+            // commit transaction
+            et.commit();
+            em.close();
+
+            logger.info("deleteAllIntegrityAuditEntities: returnCode=" + returnCode);
+
+            return returnCode;
+
+        } catch (Exception e) {
+            String msg = DBDAO_MESSAGE + "deleteAllIntegrityAuditEntities() " + "encountered a problem in execution: ";
+            logger.error(msg + e);
+            throw new DbDaoTransactionException(e);
+        }
+
+    }
+
+    /**
+     * Changes designation to specified resourceName
+     * 
+     * <p>static lock object in conjunction with synchronized keyword ensures that designation
+     * changes are done serially within a resource. I.e. static lock ensures that multiple
+     * instantiations of DbDao don't interleave changeDesignated() invocations and potentially
+     * produce simultaneous designations.
+     * 
+     * <p>Optimistic locking (the default, versus pessimistic) is sufficient to avoid simultaneous
+     * designations from interleaved changeDesignated() invocations from different resources
+     * (entities), because it prevents "dirty" and "non-repeatable" reads.
+     * 
+     * <p>See http://www.objectdb.com/api/java/jpa/LockModeType
+     * 
+     * <p>and
+     * 
+     * <p>http://stackoverflow.com/questions/2120248/how-to-synchronize-a-static-
+     * variable-among-threads-running-different-instances-o
+     */
+    public void changeDesignated(String resourceName, String persistenceUnit, String nodeType)
+            throws DbDaoTransactionException {
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("changeDesignated: Entering, resourceName=" + resourceName + ", persistenceUnit="
+                    + persistenceUnit + ", nodeType=" + nodeType);
+        }
+
+        long startTime = AuditorTime.getInstance().getMillis();
+
+        synchronized (lock) {
+
+            EntityManager em = null;
+            try {
+
+                em = emf.createEntityManager();
+                em.getTransaction().begin();
+
+                /*
+                 * Define query
+                 */
+                Query query = em.createQuery(
+                        "Select i from IntegrityAuditEntity i where i.persistenceUnit=:pu and i.nodeType=:nt");
+                query.setParameter("pu", persistenceUnit);
+                query.setParameter("nt", nodeType);
+
+                /*
+                 * Execute query using pessimistic write lock. This ensures that if anyone else is
+                 * currently reading the records we'll throw a LockTimeoutException.
+                 */
+                @SuppressWarnings("unchecked")
+                List<IntegrityAuditEntity> integrityAuditEntityList = query.getResultList();
+                for (Object o : integrityAuditEntityList) {
+                    if (o instanceof IntegrityAuditEntity) {
+                        IntegrityAuditEntity integrityAuditEntity = (IntegrityAuditEntity) o;
+                        if (integrityAuditEntity.getResourceName().equals(resourceName)) {
+                            if (logger.isDebugEnabled()) {
+                                logger.debug("changeDesignated: Designating resourceName="
+                                        + integrityAuditEntity.getResourceName());
+                            }
+                            integrityAuditEntity.setDesignated(true);
+                        } else {
+                            if (logger.isDebugEnabled()) {
+                                logger.debug("changeDesignated: Removing designation from resourceName="
+                                        + integrityAuditEntity.getResourceName());
+                            }
+                            integrityAuditEntity.setDesignated(false);
+                        }
+                    }
+                }
+
+                if (logger.isDebugEnabled()) {
+                    logger.debug("changeDesignated: Committing designation to resourceName=" + resourceName);
+                }
+                em.getTransaction().commit();
+
+                /*
+                 * If we get a LockTimeoutException, no harm done really. We'll probably be
+                 * successful on the next attempt. The odds of another DbDao instance on this entity
+                 * or another entity attempting a simultaneous IntegrityAuditEntity table
+                 * read/update are pretty slim (we're only in this method for two or three
+                 * milliseconds)
+                 */
+            } catch (LockTimeoutException e) {
+                if (em != null) {
+                    em.getTransaction().rollback();
+
+                    String msg = "DbDao: changeDesignated() caught LockTimeoutException, message="
+                            + e.getMessage();
+                    logger.error(msg + e);
+                    throw new DbDaoTransactionException(msg, e);
+                } else {
+                    String msg = "DbDao: changeDesignated() caught LockTimeoutException, message="
+                            + e.getMessage() + ". Error rolling back transaction.";
+                    logger.error(msg + e);
+                    throw new DbDaoTransactionException(msg, e);
+                }
+            } catch (Exception e) {
+                if (em != null) {
+                    em.getTransaction().rollback();
+
+                    String msg = "DbDao: changeDesignated() caught Exception, message=" + e.getMessage();
+                    logger.error(msg + e);
+                    throw new DbDaoTransactionException(msg, e);
+                } else {
+                    String msg = "DbDao: changeDesignated() caught Exception, message="
+                            + e.getMessage() + ". Error rolling back transaction.";
+                    logger.error(msg + e);
+                    throw new DbDaoTransactionException(msg, e);
+                }
+            }
+
+        } // end synchronized block
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("changeDesignated: Exiting; time expended="
+                            + (AuditorTime.getInstance().getMillis() - startTime) + "ms");
+        }
+
+    }
+
+}