ExternalVendorCode/HIRS
1
0
Fork 0
mirror of https://github.com/nsacyber/HIRS.git synced 2025-02-25 11:12:27 +00:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

This has some additional changes. Distinct was figured out. Portions

Browse Source 
of the Abstract Generics was figured out but I think now there is going
to be a rewrite for getting an Abstract class and the children.
This commit is contained in:
Cyrus 2022-04-22 15:17:28 -04:00
parent 545e5b0918
commit 6fa7874a5b
10 changed files with 564 additions and 452 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
HIRS_Utils/src/main/java/hirs/persist/AbstractDbManager.java
View File

@ -4,6 +4,7 @@ import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader; import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache; import com.google.common.cache.LoadingCache;
import hirs.FilteredRecordsList; import hirs.FilteredRecordsList;
import hirs.data.persist.ReferenceDigestValue;
import org.apache.commons.lang3.reflect.FieldUtils; import org.apache.commons.lang3.reflect.FieldUtils;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
@ -22,6 +23,7 @@ import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order; import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections; import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions; import org.hibernate.criterion.Restrictions;
import org.hibernate.query.Query;
import org.hibernate.service.spi.ServiceRegistryImplementor; import org.hibernate.service.spi.ServiceRegistryImplementor;
import javax.persistence.Column; import javax.persistence.Column;
@ -33,6 +35,7 @@ import javax.persistence.OneToMany;
import javax.persistence.OneToOne; import javax.persistence.OneToOne;
import javax.persistence.criteria.CriteriaBuilder; import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery; import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root; import javax.persistence.criteria.Root;
import java.io.Serializable; import java.io.Serializable;
import java.lang.reflect.Field; import java.lang.reflect.Field;
@ -326,6 +329,19 @@ public abstract class AbstractDbManager<T> implements CrudManager<T> {
try { try {
LOGGER.debug("Deleting instances of class: {}", clazz); LOGGER.debug("Deleting instances of class: {}", clazz);
tx = session.beginTransaction(); tx = session.beginTransaction();
CriteriaBuilder builder = session.getCriteriaBuilder();
CriteriaQuery<T> criteriaQuery = builder.createQuery(clazz);
Root<T> root = criteriaQuery.from(clazz);
Predicate recordPredicate = builder.and(
);
criteriaQuery.select(root).where(recordPredicate);
Query<T> query = session.createQuery(criteriaQuery);
List<T> results = query.getResultList();
T ret = null;
if (results != null && !results.isEmpty()) {
ret = results.get(0);
}
List instances = session.createCriteria(clazz) List instances = session.createCriteria(clazz)
.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY).list(); .setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY).list();
for (Object instance : instances) { for (Object instance : instances) {
@ -505,8 +521,20 @@ public abstract class AbstractDbManager<T> implements CrudManager<T> {
try { try {
LOGGER.debug("retrieving " + clazz.toString() + " from db"); LOGGER.debug("retrieving " + clazz.toString() + " from db");
tx = session.beginTransaction(); tx = session.beginTransaction();
T ret = clazz.cast(session.createCriteria(clazz) CriteriaBuilder builder = session.getCriteriaBuilder();
.add(Restrictions.eq("name", name)).uniqueResult()); CriteriaQuery<T> criteriaQuery = builder.createQuery(clazz);
Root<T> root = criteriaQuery.from(clazz);
Predicate recordPredicate = builder.and(
builder.equal(root.get("name"), name));
criteriaQuery.select(root).where(recordPredicate);
Query<T> query = session.createQuery(criteriaQuery);
List<T> results = query.getResultList();
T ret = null;
if (results != null && !results.isEmpty()) {
ret = results.get(0);
}
// T ret = clazz.cast(session.createCriteria(clazz)
// .add(Restrictions.eq("name", name)).uniqueResult());
tx.commit(); tx.commit();
return ret; return ret;
} catch (Exception e) { } catch (Exception e) {
@ -631,8 +659,21 @@ public abstract class AbstractDbManager<T> implements CrudManager<T> {
try { try {
LOGGER.debug("retrieving " + clazz.toString() + " from db"); LOGGER.debug("retrieving " + clazz.toString() + " from db");
tx = session.beginTransaction(); tx = session.beginTransaction();
T ret = clazz.cast(session.createCriteria(clazz) CriteriaBuilder builder = session.getCriteriaBuilder();
.add(Restrictions.eq("name", name)).uniqueResult()); CriteriaQuery<T> criteriaQuery = builder.createQuery(clazz);
Root<T> root = criteriaQuery.from(clazz);
Predicate recordPredicate = builder.and(
builder.equal(root.get("name"), name));
criteriaQuery.select(root).where(recordPredicate);
Query<T> query = session.createQuery(criteriaQuery);
List<T> results = query.getResultList();
T ret = null;
if (results != null && !results.isEmpty()) {
ret = results.get(0);
}
// T ret = clazz.cast(session.createCriteria(clazz)
// .add(Restrictions.eq("name", name)).uniqueResult());
doLoadLazyFields(ret, recurse); doLoadLazyFields(ret, recurse);
tx.commit(); tx.commit();
return ret; return ret;
@ -720,12 +761,22 @@ public abstract class AbstractDbManager<T> implements CrudManager<T> {
try { try {
LOGGER.debug("Retrieving objects from db of class {}", searchClass.getName()); LOGGER.debug("Retrieving objects from db of class {}", searchClass.getName());
tx = session.beginTransaction(); tx = session.beginTransaction();
Criteria criteria = session.createCriteria(searchClass); CriteriaBuilder builder = session.getCriteriaBuilder();
CriteriaQuery<T> criteriaQuery = builder.createQuery(searchClass);
Root<T> root = criteriaQuery.from(searchClass);
Predicate recordPredicate = builder.and(
);
criteriaQuery.select(root).where(recordPredicate).distinct(true);
Query<?> query = session.createQuery(criteriaQuery);
List<?> results = query.getResultList();
// Criteria criteria = session.createCriteria(searchClass);
if (additionalRestriction != null) { if (additionalRestriction != null) {
criteria.add(additionalRestriction); criteria.add(additionalRestriction);
} }
List list = criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY).list(); // List list = criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY).list();
for (Object o : list) { for (Object o : results) {
if (searchClass.isInstance(o)) { if (searchClass.isInstance(o)) {
objects.add(searchClass.cast(o)); objects.add(searchClass.cast(o));
} }

232
HIRS_Utils/src/main/java/hirs/persist/DBAlertManager.java
View File

@ -1,22 +1,12 @@
package hirs.persist; package hirs.persist;
import hirs.FilteredRecordsList; import hirs.FilteredRecordsList;
import static org.apache.logging.log4j.LogManager.getLogger;
import hirs.data.persist.Alert; import hirs.data.persist.Alert;
import hirs.data.persist.baseline.Baseline;
import hirs.data.persist.Device; import hirs.data.persist.Device;
import hirs.data.persist.DeviceGroup; import hirs.data.persist.DeviceGroup;
import hirs.data.persist.Policy; import hirs.data.persist.Policy;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import hirs.data.persist.Report; import hirs.data.persist.Report;
import hirs.data.persist.baseline.Baseline;
import hirs.data.persist.enums.AlertSource; import hirs.data.persist.enums.AlertSource;
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
@ -26,11 +16,20 @@ import org.hibernate.Session;
import org.hibernate.SessionFactory; import org.hibernate.SessionFactory;
import org.hibernate.Transaction; import org.hibernate.Transaction;
import org.hibernate.criterion.Criterion; import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Property;
import org.hibernate.criterion.Restrictions; import org.hibernate.criterion.Restrictions;
import org.hibernate.criterion.Subqueries; import org.hibernate.query.Query;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import static org.apache.logging.log4j.LogManager.getLogger;
/** /**
* This class defines a <code>AlertManager</code> that stores policies in a * This class defines a <code>AlertManager</code> that stores policies in a
@ -261,18 +260,24 @@ public class DBAlertManager extends DBManager<Alert> implements AlertManager {
Session session = getFactory().getCurrentSession(); Session session = getFactory().getCurrentSession();
try { try {
tx = session.beginTransaction(); tx = session.beginTransaction();
// query hibernate to count alerts with the given deviceName and null archivedTime // query hibernate to count alerts with the given deviceName and null archivedTime
Criteria criteria = session.createCriteria(Alert.class); CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
criteria.add(Restrictions.eq("policyId", policy.getId())); CriteriaQuery<Alert> criteriaQuery = criteriaBuilder.createQuery(Alert.class);
criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY); Root<Alert> root = criteriaQuery.from(Alert.class);
Predicate recordPredicate = criteriaBuilder
.and(criteriaBuilder.equal(root.get("policyId"), policy.getId()));
criteriaQuery.select(root).where(recordPredicate);
Query<Alert> query = session.createQuery(criteriaQuery);
List<Alert> results = query.getResultList();
List list = criteria.list(); // criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
for (Object o : list) {
for (Object o : results) {
if (o instanceof Alert) { if (o instanceof Alert) {
alerts.add((Alert) o); alerts.add((Alert) o);
} }
} }
tx.commit(); tx.commit();
} catch (HibernateException e) { } catch (HibernateException e) {
@ -312,17 +317,24 @@ public class DBAlertManager extends DBManager<Alert> implements AlertManager {
tx = session.beginTransaction(); tx = session.beginTransaction();
// query hibernate to retrieve alerts with the given baseline id // query hibernate to retrieve alerts with the given baseline id
Criteria criteria = session.createCriteria(Alert.class); CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
criteria.add(Restrictions.eq("baselineId", baseline.getId())); CriteriaQuery<Alert> criteriaQuery = criteriaBuilder.createQuery(Alert.class);
criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY); Root<Alert> root = criteriaQuery.from(Alert.class);
List list = criteria.list(); Predicate recordPredicate = criteriaBuilder
for (Object o : list) { .and(criteriaBuilder.equal(root.get("baselineId"), baseline.getId()));
criteriaQuery.select(root).where(recordPredicate);
Query<Alert> query = session.createQuery(criteriaQuery);
List<Alert> results = query.getResultList();
// criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
for (Object o : results) {
if (o instanceof Alert) { if (o instanceof Alert) {
alerts.add((Alert) o); alerts.add((Alert) o);
} }
} }
tx.commit();
tx.commit();
} catch (HibernateException e) { } catch (HibernateException e) {
final String msg = "unable to query alerts table"; final String msg = "unable to query alerts table";
LOGGER.error(msg, e); LOGGER.error(msg, e);
@ -360,18 +372,22 @@ public class DBAlertManager extends DBManager<Alert> implements AlertManager {
tx = session.beginTransaction(); tx = session.beginTransaction();
// query hibernate to count alerts with the given deviceName and null archivedTime // query hibernate to count alerts with the given deviceName and null archivedTime
Criteria criteria = session.createCriteria(Alert.class); CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
criteria.add(Restrictions.isNull("archivedTime")); CriteriaQuery<Alert> criteriaQuery = criteriaBuilder.createQuery(Alert.class);
criteria.add(Restrictions.eq("baselineId", baseline.getId())); Root<Alert> root = criteriaQuery.from(Alert.class);
criteria.setProjection(Projections.rowCount()).uniqueResult(); Predicate recordPredicate = criteriaBuilder
Long result = (Long) criteria.uniqueResult(); .and(criteriaBuilder.equal(root.get("baselineId"), baseline.getId()),
criteriaBuilder.isNull(root.get("archivedTime")));
criteriaQuery.select(root).where(recordPredicate);
Query<Alert> query = session.createQuery(criteriaQuery);
List<Alert> results = query.getResultList();
Long result = results.stream().count();
tx.commit(); tx.commit();
if (result == null) { if (result == null) {
throw new AlertManagerException("failed to query unresolved alert count"); throw new AlertManagerException("failed to query unresolved alert count");
} else { } else {
return result; return result;
} }
} catch (HibernateException e) { } catch (HibernateException e) {
final String msg = "unable to query alerts table"; final String msg = "unable to query alerts table";
LOGGER.error(msg, e); LOGGER.error(msg, e);
@ -383,41 +399,49 @@ public class DBAlertManager extends DBManager<Alert> implements AlertManager {
} }
} }
private Criteria getCriteriaForTrustAlertsForDevice(final Device device, private Query<Alert> getCriteriaForTrustAlertsForDevice(final Device device,
final Report integrityReport, final Report integrityReport,
final Criterion optionalCriterion, final Criterion optionalCriterion,
final Session session) { final Session session) {
if (null == device) { if (device == null) {
throw new NullPointerException("device was null"); throw new NullPointerException("device was null");
} }
if (null == integrityReport) { if (integrityReport == null) {
throw new NullPointerException("integrityReport was null"); throw new NullPointerException("integrityReport was null");
} }
if (null == session) { if (session == null) {
throw new NullPointerException("session was null"); throw new NullPointerException("session was null");
} }
// query hibernate to count alerts with the given deviceName and null archivedTime // query hibernate to count alerts with the given deviceName and null archivedTime
Criteria criteria = session.createCriteria(Alert.class);
criteria.add(Restrictions.isNull("archivedTime"));
criteria.add(Restrictions.eq("deviceName", device.getName()));
// alerts for this report, or alerts not associated with any report (case 1 and 2) // alerts for this report, or alerts not associated with any report (case 1 and 2)
Criterion reportEqualsCriterion = Restrictions.eq("report", integrityReport); CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
Criterion reportNullCriterion = Restrictions.isNull("report"); CriteriaQuery<Alert> criteriaQuery = criteriaBuilder.createQuery(Alert.class);
Root<Alert> root = criteriaQuery.from(Alert.class);
Predicate recordPredicate = criteriaBuilder.and(
criteriaBuilder.isNull(root.get("archivedTime")),
criteriaBuilder.equal(root.get("deviceName"), device.getName()));
Predicate reportEqualsDisjunction = criteriaBuilder.disjunction();
Predicate reportNullDisjunction = criteriaBuilder.disjunction();
// alerts for this report, or alerts not associated with any report (case 1 and 2)
// Criterion reportEqualsCriterion = Restrictions.eq("report", integrityReport);
// Criterion reportNullCriterion = Restrictions.isNull("report");
reportEqualsDisjunction = criteriaBuilder.equal(root.get("report"), integrityReport);
reportNullDisjunction = criteriaBuilder.isNull(root.get("report"));
criteriaBuilder.or(reportEqualsDisjunction, reportNullDisjunction);
// only apply the optional criterion to the disjunction if there is one. // only apply the optional criterion to the disjunction if there is one.
if (null != optionalCriterion) { if (optionalCriterion != null) {
criteria.add(Restrictions.disjunction( LOGGER.error("optional criterion needs to be updated");
reportEqualsCriterion, reportNullCriterion, optionalCriterion));
} else {
criteria.add(Restrictions.disjunction(
reportEqualsCriterion, reportNullCriterion));
} }
return criteria;
criteriaQuery.select(root).where(recordPredicate,
reportEqualsDisjunction,
reportNullDisjunction);
return session.createQuery(criteriaQuery);
} }
/** /**
@ -446,7 +470,7 @@ public class DBAlertManager extends DBManager<Alert> implements AlertManager {
try { try {
tx = session.beginTransaction(); tx = session.beginTransaction();
Criteria criteria = getCriteriaForTrustAlertsForDevice(device, integrityReport, Query<Alert> criteria = getCriteriaForTrustAlertsForDevice(device, integrityReport,
optionalCriterion, session); optionalCriterion, session);
List<Alert> alerts = new ArrayList<>(); List<Alert> alerts = new ArrayList<>();
@ -488,11 +512,9 @@ public class DBAlertManager extends DBManager<Alert> implements AlertManager {
try { try {
tx = session.beginTransaction(); tx = session.beginTransaction();
Criteria criteria = getCriteriaForTrustAlertsForDevice(device, integrityReport, Query<Alert> criteria = getCriteriaForTrustAlertsForDevice(device, integrityReport,
optionalCriterion, session); optionalCriterion, session);
Long result = criteria.stream().count();
criteria.setProjection(Projections.rowCount()).uniqueResult();
Long result = (Long) criteria.uniqueResult();
tx.commit(); tx.commit();
return result.intValue(); return result.intValue();
@ -576,6 +598,7 @@ public class DBAlertManager extends DBManager<Alert> implements AlertManager {
return 0; return 0;
} }
Long result = null;
Transaction tx = null; Transaction tx = null;
Session session = getFactory().getCurrentSession(); Session session = getFactory().getCurrentSession();
try { try {
@ -583,11 +606,24 @@ public class DBAlertManager extends DBManager<Alert> implements AlertManager {
tx = session.beginTransaction(); tx = session.beginTransaction();
// query hibernate to count alerts with the given deviceName and null archivedTime // query hibernate to count alerts with the given deviceName and null archivedTime
Criteria criteria = session.createCriteria(Alert.class); CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
criteria.add(Restrictions.isNull("archivedTime")); CriteriaQuery<Alert> criteriaQuery = criteriaBuilder.createQuery(Alert.class);
criteria.add(Restrictions.eq("deviceName", device.getName())); Root<Alert> root = criteriaQuery.from(Alert.class);
criteria.setProjection(Projections.rowCount()).uniqueResult(); Predicate recordPredicate = criteriaBuilder
Long result = (Long) criteria.uniqueResult(); .and(criteriaBuilder.equal(root.get("deviceName"), device.getName()),
criteriaBuilder.isNull(root.get("archivedTime")));
criteriaQuery.select(root).where(recordPredicate);
Query<Alert> query = session.createQuery(criteriaQuery);
List<Alert> results = query.getResultList();
if (results != null && !results.isEmpty()) {
result = results.stream().count();
}
// Criteria criteria = session.createCriteria(Alert.class);
// criteria.add(Restrictions.isNull("archivedTime"));
// criteria.add(Restrictions.eq("deviceName", device.getName()));
// criteria.setProjection(Projections.rowCount()).uniqueResult();
// Long result = (Long) criteria.uniqueResult();
tx.commit(); tx.commit();
if (result == null) { if (result == null) {
throw new AlertManagerException("failed to query unresolved alert count"); throw new AlertManagerException("failed to query unresolved alert count");
@ -626,18 +662,32 @@ public class DBAlertManager extends DBManager<Alert> implements AlertManager {
throw new IllegalArgumentException(msg); throw new IllegalArgumentException(msg);
} }
Long result = null;
Transaction tx = null; Transaction tx = null;
Session session = getFactory().getCurrentSession(); Session session = getFactory().getCurrentSession();
try { try {
LOGGER.debug("querying alerts table for unresolved alerts"); LOGGER.debug("querying alerts table for unresolved alerts");
tx = session.beginTransaction(); tx = session.beginTransaction();
CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
CriteriaQuery<Alert> criteriaQuery = criteriaBuilder.createQuery(Alert.class);
Root<Alert> root = criteriaQuery.from(Alert.class);
Predicate recordPredicate = criteriaBuilder
.and(criteriaBuilder.equal(root.get("deviceName"), device.getName()),
criteriaBuilder.equal(root.get("source"), source),
criteriaBuilder.isNull(root.get("archivedTime")));
criteriaQuery.select(root).where(recordPredicate);
Query<Alert> query = session.createQuery(criteriaQuery);
List<Alert> results = query.getResultList();
if (results != null && !results.isEmpty()) {
result = results.stream().count();
}
Criteria criteria = session.createCriteria(Alert.class); // Criteria criteria = session.createCriteria(Alert.class);
criteria.add(Restrictions.isNull("archivedTime")); // criteria.add(Restrictions.isNull("archivedTime"));
criteria.add(Restrictions.eq("deviceName", device.getName())); // criteria.add(Restrictions.eq("deviceName", device.getName()));
criteria.add(Restrictions.eq("source", source)); // criteria.add(Restrictions.eq("source", source));
criteria.setProjection(Projections.rowCount()).uniqueResult(); // criteria.setProjection(Projections.rowCount()).uniqueResult();
Long result = (Long) criteria.uniqueResult(); // result = (Long) criteria.uniqueResult();
tx.commit(); tx.commit();
if (result == null) { if (result == null) {
throw new AlertManagerException("failed to query unresolved alert count"); throw new AlertManagerException("failed to query unresolved alert count");
@ -663,7 +713,6 @@ public class DBAlertManager extends DBManager<Alert> implements AlertManager {
* @return count of devices with unresolved alerts * @return count of devices with unresolved alerts
*/ */
public final int countUnresolvedDevices(final DeviceGroup deviceGroup) { public final int countUnresolvedDevices(final DeviceGroup deviceGroup) {
if (deviceGroup == null) { if (deviceGroup == null) {
String msg = "invalid argument - null value for device group"; String msg = "invalid argument - null value for device group";
LOGGER.error(msg); LOGGER.error(msg);
@ -674,27 +723,41 @@ public class DBAlertManager extends DBManager<Alert> implements AlertManager {
Session session = getFactory().getCurrentSession(); Session session = getFactory().getCurrentSession();
try { try {
LOGGER.debug("querying alerts table for unresolved devices"); LOGGER.debug("querying alerts table for unresolved devices");
tx = session.beginTransaction(); // tx = session.beginTransaction();
// first use a subquery to list the devices in the given group // first use a subquery to list the devices in the given group
DetachedCriteria deviceQuery = DetachedCriteria.forClass(Device.class); // DetachedCriteria deviceQuery = DetachedCriteria.forClass(Device.class);
deviceQuery.createAlias("deviceGroup", "g"); // deviceQuery.createAlias("deviceGroup", "g");
deviceQuery.add(Restrictions.eq("g.name", deviceGroup.getName())); // deviceQuery.add(Restrictions.eq("g.name", deviceGroup.getName()));
deviceQuery.setProjection(Property.forName("name")); // deviceQuery.setProjection(Property.forName("name"));
// now query within that group for unique device names among unresolved alerts // now query within that group for unique device names among unresolved alerts
Criteria criteria = session.createCriteria(Alert.class); // Criteria criteria = session.createCriteria(Alert.class);
criteria.add(Restrictions.isNull("archivedTime")); // criteria.add(Restrictions.isNull("archivedTime"));
criteria.add(Subqueries.propertyIn("deviceName", deviceQuery)); // criteria.add(Subqueries.propertyIn("deviceName", deviceQuery));
criteria.setProjection(Projections.countDistinct("deviceName")); // criteria.setProjection(Projections.countDistinct("deviceName"));
Long result = (Long) criteria.uniqueResult(); // Long result = (Long) criteria.uniqueResult();
tx.commit();
if (result == null) {
throw new AlertManagerException("failed to query unresolved alert count");
} else {
return result.intValue();
}
// CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
// CriteriaQuery<Alert> criteriaQuery = criteriaBuilder.createQuery(Alert.class);
// Root<Alert> root = criteriaQuery.from(Alert.class);
// Predicate recordPredicate = criteriaBuilder.and(
// criteriaBuilder.equal(criteriaBuilder.Subqueries.propertiesIn("deviceName", deviceQuery)),
// criteriaBuilder.isNull(root.get("archivedTime"))
//
// );
// criteriaQuery.select(root).where(recordPredicate);
// Query<Alert> query = session.createQuery(criteriaQuery);
// List<Alert> results = query.getResultList();
// if (results != null && !results.isEmpty()) {
// result = results.stream().count();
// }
// tx.commit();
// if (result == null) {
// throw new AlertManagerException("failed to query unresolved alert count");
// } else {
// return result.intValue();
// }
} catch (HibernateException e) { } catch (HibernateException e) {
final String msg = "unable to query alerts table"; final String msg = "unable to query alerts table";
LOGGER.error(msg, e); LOGGER.error(msg, e);
@ -704,6 +767,7 @@ public class DBAlertManager extends DBManager<Alert> implements AlertManager {
} }
throw e; throw e;
} }
return 0;
} }
} }

47
HIRS_Utils/src/main/java/hirs/persist/DBAlertServiceManager.java
View File

@ -1,15 +1,18 @@
package hirs.persist; package hirs.persist;
import java.util.List;
import org.hibernate.SessionFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import hirs.data.persist.alert.AlertServiceConfig; import hirs.data.persist.alert.AlertServiceConfig;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.hibernate.Session; import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction; import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions; import org.hibernate.query.Query;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.List;
/** /**
* A <code>DBAlertServiceManager</code> is a service (extends <code>DBManager</code>) that * A <code>DBAlertServiceManager</code> is a service (extends <code>DBManager</code>) that
@ -118,8 +121,19 @@ public class DBAlertServiceManager
try { try {
LOGGER.debug("retrieving AlertServiceConfig from db"); LOGGER.debug("retrieving AlertServiceConfig from db");
tx = session.beginTransaction(); tx = session.beginTransaction();
ret = (AlertServiceConfig) session.createCriteria(AlertServiceConfig.class) CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
.add(Restrictions.eq("type", type)).uniqueResult(); CriteriaQuery<AlertServiceConfig> criteriaQuery = criteriaBuilder.createQuery(AlertServiceConfig.class);
Root<AlertServiceConfig> root = criteriaQuery.from(AlertServiceConfig.class);
Predicate recordPredicate = criteriaBuilder
.and(criteriaBuilder.equal(root.get("type"), type));
criteriaQuery.select(root).where(recordPredicate);
Query<AlertServiceConfig> query = session.createQuery(criteriaQuery);
List<AlertServiceConfig> results = query.getResultList();
if (results != null && !results.isEmpty()) {
ret = results.get(0);
}
// ret = (AlertServiceConfig) session.createCriteria(AlertServiceConfig.class)
// .add(Restrictions.eq("type", type)).uniqueResult();
tx.commit(); tx.commit();
} catch (Exception e) { } catch (Exception e) {
final String msg = "unable to retrieve object"; final String msg = "unable to retrieve object";
@ -161,8 +175,19 @@ public class DBAlertServiceManager
try { try {
LOGGER.debug("retrieving object from db"); LOGGER.debug("retrieving object from db");
tx = session.beginTransaction(); tx = session.beginTransaction();
object = (AlertServiceConfig) session.createCriteria(AlertServiceConfig.class) CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
.add(Restrictions.eq("type", type)).uniqueResult(); CriteriaQuery<AlertServiceConfig> criteriaQuery = criteriaBuilder.createQuery(AlertServiceConfig.class);
Root<AlertServiceConfig> root = criteriaQuery.from(AlertServiceConfig.class);
Predicate recordPredicate = criteriaBuilder
.and(criteriaBuilder.equal(root.get("type"), type));
criteriaQuery.select(root).where(recordPredicate);
Query<AlertServiceConfig> query = session.createQuery(criteriaQuery);
List<AlertServiceConfig> results = query.getResultList();
if (results != null && !results.isEmpty()) {
object = results.get(0);
}
// object = (AlertServiceConfig) session.createCriteria(AlertServiceConfig.class)
// .add(Restrictions.eq("type", type)).uniqueResult();
if (object != null) { if (object != null) {
LOGGER.debug("found object, deleting it"); LOGGER.debug("found object, deleting it");
session.delete(object); session.delete(object);

45
HIRS_Utils/src/main/java/hirs/persist/DBDeviceGroupManager.java
View File

@ -1,22 +1,25 @@
package hirs.persist; package hirs.persist;
import hirs.FilteredRecordsList; import hirs.FilteredRecordsList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.hibernate.SessionFactory;
import hirs.data.persist.DeviceGroup; import hirs.data.persist.DeviceGroup;
import hirs.data.persist.Policy; import hirs.data.persist.Policy;
import java.util.HashMap; import org.apache.logging.log4j.LogManager;
import java.util.Map; import org.apache.logging.log4j.Logger;
import org.hibernate.Criteria; import org.hibernate.Criteria;
import org.hibernate.Session; import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction; import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions; import org.hibernate.query.Query;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/** /**
* This class defines the <code>DBDeviceGroupManager</code> that is used to * This class defines the <code>DBDeviceGroupManager</code> that is used to
@ -152,21 +155,27 @@ public class DBDeviceGroupManager extends DBManager<DeviceGroup> implements Devi
try { try {
LOGGER.debug("retrieving policy mapper from db where policy = {}", policy); LOGGER.debug("retrieving policy mapper from db where policy = {}", policy);
CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
CriteriaQuery<PolicyMapper> criteriaQuery = criteriaBuilder.createQuery(PolicyMapper.class);
Root<PolicyMapper> root = criteriaQuery.from(PolicyMapper.class);
Predicate recordPredicate = criteriaBuilder.and(
criteriaBuilder.equal(root.get("policy"), policy));
criteriaQuery.select(root).where(recordPredicate);
Query<PolicyMapper> query = session.createQuery(criteriaQuery);
List<PolicyMapper> results = query.getResultList();
//Retrieves a list of PolicyMapper objects that are unique per group //Retrieves a list of PolicyMapper objects that are unique per group
List policyMapperList = session.createCriteria(PolicyMapper.class) // List policyMapperList = session.createCriteria(PolicyMapper.class)
.add(Restrictions.eq("policy", policy)).list(); // .add(Restrictions.eq("policy", policy)).list();
session.getTransaction().commit(); session.getTransaction().commit();
if (policyMapperList == null) { if (results == null) {
LOGGER.debug("no policy mapper found for policy {}", policy); LOGGER.debug("no policy mapper found for policy {}", policy);
} else { } else {
for (Object o : policyMapperList) { for (PolicyMapper policyMapper : results) {
if (o instanceof PolicyMapper) { groups.add(policyMapper.getDeviceGroup());
groups.add(((PolicyMapper) o).getDeviceGroup());
}
} }
} }
} catch (Exception e) { } catch (Exception e) {

185
HIRS_Utils/src/main/java/hirs/persist/DBPolicyManager.java
View File

@ -2,24 +2,26 @@ package hirs.persist;
import com.google.common.base.Preconditions; import com.google.common.base.Preconditions;
import hirs.appraiser.Appraiser; import hirs.appraiser.Appraiser;
import hirs.data.persist.baseline.Baseline;
import hirs.data.persist.Device; import hirs.data.persist.Device;
import hirs.data.persist.DeviceGroup; import hirs.data.persist.DeviceGroup;
import hirs.data.persist.baseline.HasBaselines;
import hirs.data.persist.Policy; import hirs.data.persist.Policy;
import hirs.data.persist.baseline.Baseline;
import java.io.Serializable; import hirs.data.persist.baseline.HasBaselines;
import java.util.ArrayList;
import java.util.List;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import org.hibernate.Criteria;
import org.hibernate.Session; import org.hibernate.Session;
import org.hibernate.SessionFactory; import org.hibernate.SessionFactory;
import org.hibernate.Transaction; import org.hibernate.Transaction;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions; import org.hibernate.criterion.Restrictions;
import org.hibernate.query.Query;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
/** /**
* This class defines a <code>PolicyManager</code> that stores policies in a * This class defines a <code>PolicyManager</code> that stores policies in a
@ -195,16 +197,44 @@ public class DBPolicyManager extends DBManager<Policy> implements PolicyManager
Session session = factory.getCurrentSession(); Session session = factory.getCurrentSession();
Transaction tx = session.beginTransaction(); Transaction tx = session.beginTransaction();
try { try {
final Criteria criteria = session.createCriteria(DeviceGroup.class) CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
.add(Restrictions.eq("name", DeviceGroup.DEFAULT_GROUP)); CriteriaQuery<DeviceGroup> deviceGroupCriteriaQuery = criteriaBuilder.createQuery(DeviceGroup.class);
DeviceGroup group = (DeviceGroup) criteria.uniqueResult(); CriteriaQuery<PolicyMapper> policyMapperCriteriaQuery = criteriaBuilder.createQuery(PolicyMapper.class);
Root<DeviceGroup> deviceGroupRoot = deviceGroupCriteriaQuery.from(DeviceGroup.class);
Root<PolicyMapper> policyMapperRoot = policyMapperCriteriaQuery.from(PolicyMapper.class);
Predicate deviceGroupPredicate = criteriaBuilder.and(
criteriaBuilder.equal(deviceGroupRoot.get("name"), DeviceGroup.DEFAULT_GROUP));
Predicate policyPredicate = criteriaBuilder.and(
criteriaBuilder.equal(policyMapperRoot.get("appraiser"), appraiser),
criteriaBuilder.equal(policyMapperRoot.get("group.name"), DeviceGroup.DEFAULT_GROUP));
deviceGroupCriteriaQuery.select(deviceGroupRoot).where(deviceGroupPredicate);
policyMapperCriteriaQuery.select(policyMapperRoot).where(policyPredicate);
LOGGER.debug("finding existing policy mapper from db where " LOGGER.debug("finding existing policy mapper from db where "
+ "appraiser = {}", appraiser); + "appraiser = {}", appraiser);
final Criteria cr = session.createCriteria(PolicyMapper.class) DeviceGroup group = null;
.createAlias("deviceGroup", "group") Query<DeviceGroup> deviceGroupQuery = session.createQuery(deviceGroupCriteriaQuery);
.add(Restrictions.eq("appraiser", appraiser)) List<DeviceGroup> deviceGroups = deviceGroupQuery.getResultList();
.add(Restrictions.eq("group.name", DeviceGroup.DEFAULT_GROUP)); if (deviceGroups != null && !deviceGroups.isEmpty()) {
final PolicyMapper mapper = (PolicyMapper) cr.uniqueResult(); group = deviceGroups.get(0);
}
LOGGER.debug("finding existing policy mapper from db where "
+ "appraiser = {}", appraiser);
PolicyMapper mapper = null;
Query<PolicyMapper> policyMapperQuery = session.createQuery(policyMapperCriteriaQuery);
List<PolicyMapper> policyMappers = policyMapperQuery.getResultList();
if (policyMappers != null && !policyMappers.isEmpty()) {
mapper = policyMappers.get(0);
}
// final Criteria criteria = session.createCriteria(DeviceGroup.class)
// .add(Restrictions.eq("name", DeviceGroup.DEFAULT_GROUP));
// DeviceGroup group = (DeviceGroup) criteria.uniqueResult();
// final Criteria cr = session.createCriteria(PolicyMapper.class)
// .createAlias("deviceGroup", "group")
// .add(Restrictions.eq("appraiser", appraiser))
// .add(Restrictions.eq("group.name", DeviceGroup.DEFAULT_GROUP));
// final PolicyMapper mapper = (PolicyMapper) cr.uniqueResult();
if (policy == null) { if (policy == null) {
LOGGER.debug("policy is null so removing policy"); LOGGER.debug("policy is null so removing policy");
if (mapper != null) { if (mapper != null) {
@ -266,11 +296,24 @@ public class DBPolicyManager extends DBManager<Policy> implements PolicyManager
tx = session.beginTransaction(); tx = session.beginTransaction();
LOGGER.debug("retrieving policy mapper from db where appraiser = {}", LOGGER.debug("retrieving policy mapper from db where appraiser = {}",
appraiser); appraiser);
final Criteria cr = session.createCriteria(PolicyMapper.class) CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
.createAlias("deviceGroup", "group") CriteriaQuery<PolicyMapper> criteriaQuery = criteriaBuilder.createQuery(PolicyMapper.class);
.add(Restrictions.eq("appraiser", appraiser)) Root<PolicyMapper> root = criteriaQuery.from(PolicyMapper.class);
.add(Restrictions.eq("group.name", DeviceGroup.DEFAULT_GROUP)); Predicate recordPredicate = criteriaBuilder.and(
final PolicyMapper mapper = (PolicyMapper) cr.uniqueResult(); criteriaBuilder.equal(root.get("appraiser"), appraiser),
criteriaBuilder.equal(root.get("group.name"), DeviceGroup.DEFAULT_GROUP));
criteriaQuery.select(root).where(recordPredicate);
Query<PolicyMapper> query = session.createQuery(criteriaQuery);
List<PolicyMapper> results = query.getResultList();
PolicyMapper mapper = null;
if (results != null && !results.isEmpty()) {
mapper = results.get(0);
}
// final Criteria cr = session.createCriteria(PolicyMapper.class)
// .createAlias("deviceGroup", "group")
// .add(Restrictions.eq("appraiser", appraiser))
// .add(Restrictions.eq("group.name", DeviceGroup.DEFAULT_GROUP));
// final PolicyMapper mapper = (PolicyMapper) cr.uniqueResult();
if (mapper == null) { if (mapper == null) {
LOGGER.debug("no policy mapper found for appraiser {}", LOGGER.debug("no policy mapper found for appraiser {}",
appraiser); appraiser);
@ -308,9 +351,7 @@ public class DBPolicyManager extends DBManager<Policy> implements PolicyManager
* there is none * there is none
*/ */
@Override @Override
public final Policy getPolicy( public final Policy getPolicy(final Appraiser appraiser, final Device device) {
final Appraiser appraiser,
final Device device) {
Preconditions.checkArgument(appraiser != null, "Appraiser must not be null"); Preconditions.checkArgument(appraiser != null, "Appraiser must not be null");
Preconditions.checkArgument(device != null, "Device must not be null"); Preconditions.checkArgument(device != null, "Device must not be null");
@ -322,22 +363,43 @@ public class DBPolicyManager extends DBManager<Policy> implements PolicyManager
tx = session.beginTransaction(); tx = session.beginTransaction();
LOGGER.debug("retrieving policy mapper from db where appraiser = " LOGGER.debug("retrieving policy mapper from db where appraiser = "
+ "{} and device= {}", appraiser, device); + "{} and device= {}", appraiser, device);
final Criteria deviceCr = session.createCriteria(Device.class) final CriteriaBuilder deviceCriteriaBuilder = session.getCriteriaBuilder();
.add(Restrictions.eq("name", device.getName())); CriteriaQuery<Device> criteriaQuery = deviceCriteriaBuilder.createQuery(Device.class);
final Device retrievedDevice = (Device) deviceCr.uniqueResult(); Root<Device> root = criteriaQuery.from(Device.class);
Predicate recordPredicate = deviceCriteriaBuilder.and(
deviceCriteriaBuilder.equal(root.get("name"), device.getName()));
criteriaQuery.select(root).where(recordPredicate);
Query<Device> query = session.createQuery(criteriaQuery);
List<Device> results = query.getResultList();
Device retrievedDevice = null;
if (results != null && !results.isEmpty()) {
retrievedDevice = results.get(0);
}
// final Criteria deviceCr = session.createCriteria(Device.class)
// .add(Restrictions.eq("name", device.getName()));
// final Device retrievedDevice = (Device) deviceCr.uniqueResult();
DeviceGroup deviceGroup = null; DeviceGroup deviceGroup = null;
if (retrievedDevice != null) { if (retrievedDevice != null) {
deviceGroup = retrievedDevice.getDeviceGroup(); deviceGroup = retrievedDevice.getDeviceGroup();
} }
final Criteria cr = session.createCriteria(PolicyMapper.class) final CriteriaBuilder policyCriteriaBuilder = session.getCriteriaBuilder();
.add(Restrictions.eq("appraiser", appraiser)) CriteriaQuery<PolicyMapper> policyCriteriaQuery = policyCriteriaBuilder.createQuery(PolicyMapper.class);
.add(Restrictions.eq("deviceGroup", deviceGroup)); Root<PolicyMapper> policyRoot = policyCriteriaQuery.from(PolicyMapper.class);
final PolicyMapper mapper = (PolicyMapper) cr.uniqueResult(); Predicate policyPredicate = policyCriteriaBuilder.and(
if (mapper == null) { policyCriteriaBuilder.equal(policyRoot.get("appraiser"), appraiser),
policyCriteriaBuilder.equal(policyRoot.get("deviceGroup"), deviceGroup));
policyCriteriaQuery.select(policyRoot).where(policyPredicate);
Query<PolicyMapper> policyQuery = session.createQuery(policyCriteriaQuery);
List<PolicyMapper> policyResults = policyQuery.getResultList();
// final Criteria cr = session.createCriteria(PolicyMapper.class)
// .add(Restrictions.eq("appraiser", appraiser))
// .add(Restrictions.eq("deviceGroup", deviceGroup));
// final PolicyMapper mapper = (PolicyMapper) cr.uniqueResult();
if (policyResults == null) {
LOGGER.debug("no policy mapper found for appraiser {} and " LOGGER.debug("no policy mapper found for appraiser {} and "
+ "device group {}", appraiser, deviceGroup); + "device group {}", appraiser, deviceGroup);
} else { } else {
ret = mapper.getPolicy(); ret = policyResults.get(0).getPolicy();
} }
session.getTransaction().commit(); session.getTransaction().commit();
} catch (Exception e) { } catch (Exception e) {
@ -383,10 +445,20 @@ public class DBPolicyManager extends DBManager<Policy> implements PolicyManager
tx = session.beginTransaction(); tx = session.beginTransaction();
LOGGER.debug("retrieving policy mapper from db where appraiser = " LOGGER.debug("retrieving policy mapper from db where appraiser = "
+ "{} and device group = {}", appraiser, deviceGroup); + "{} and device group = {}", appraiser, deviceGroup);
final Criteria cr = session.createCriteria(PolicyMapper.class) CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
.add(Restrictions.eq("appraiser", appraiser)) CriteriaQuery<PolicyMapper> criteriaQuery = criteriaBuilder.createQuery(PolicyMapper.class);
.add(Restrictions.eq("deviceGroup", deviceGroup)); Root<PolicyMapper> root = criteriaQuery.from(PolicyMapper.class);
final PolicyMapper mapper = (PolicyMapper) cr.uniqueResult(); Predicate recordPredicate = criteriaBuilder.and(
criteriaBuilder.equal(root.get("appraiser"), appraiser),
criteriaBuilder.equal(root.get("deviceGroup"), deviceGroup));
criteriaQuery.select(root).where(recordPredicate);
Query<PolicyMapper> query = session.createQuery(criteriaQuery);
List<PolicyMapper> results = query.getResultList();
PolicyMapper mapper = null;
if (results != null && !results.isEmpty()) {
mapper = results.get(0);
}
if (mapper == null) { if (mapper == null) {
LOGGER.debug("no policy mapper found for appraiser {} and " LOGGER.debug("no policy mapper found for appraiser {} and "
+ "device group {}", appraiser, deviceGroup); + "device group {}", appraiser, deviceGroup);
@ -443,10 +515,23 @@ public class DBPolicyManager extends DBManager<Policy> implements PolicyManager
LOGGER.debug("Finding existing policy mapper from db where " LOGGER.debug("Finding existing policy mapper from db where "
+ "appraiser = {} and device group = {}", appraiser, + "appraiser = {} and device group = {}", appraiser,
deviceGroup); deviceGroup);
final Criteria cr = session.createCriteria(PolicyMapper.class) CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
.add(Restrictions.eq("appraiser", appraiser)) CriteriaQuery<PolicyMapper> criteriaQuery = criteriaBuilder.createQuery(PolicyMapper.class);
.add(Restrictions.eq("deviceGroup", deviceGroup)); Root<PolicyMapper> root = criteriaQuery.from(PolicyMapper.class);
final PolicyMapper mapper = (PolicyMapper) cr.uniqueResult(); Predicate recordPredicate = criteriaBuilder.and(
criteriaBuilder.equal(root.get("appraiser"), appraiser),
criteriaBuilder.equal(root.get("deviceGroup"), deviceGroup));
criteriaQuery.select(root).where(recordPredicate);
Query<PolicyMapper> query = session.createQuery(criteriaQuery);
List<PolicyMapper> results = query.getResultList();
PolicyMapper mapper = null;
if (results != null && !results.isEmpty()) {
mapper = results.get(0);
}
// final Criteria cr = session.createCriteria(PolicyMapper.class)
// .add(Restrictions.eq("appraiser", appraiser))
// .add(Restrictions.eq("deviceGroup", deviceGroup));
// final PolicyMapper mapper = (PolicyMapper) cr.uniqueResult();
if (policy == null) { if (policy == null) {
LOGGER.info("Policy is null, so removing policy from device group {}"); LOGGER.info("Policy is null, so removing policy from device group {}");
if (mapper != null) { if (mapper != null) {
@ -492,15 +577,15 @@ public class DBPolicyManager extends DBManager<Policy> implements PolicyManager
try { try {
tx = session.beginTransaction(); tx = session.beginTransaction();
LOGGER.debug("retrieving group use count for policy {}", policy); LOGGER.debug("retrieving group use count for policy {}", policy);
final Criteria cr = session.createCriteria(PolicyMapper.class) // final Criteria cr = session.createCriteria(PolicyMapper.class)
.add(Restrictions.eq("policy", policy)) // .add(Restrictions.eq("policy", policy))
.setProjection(Projections.projectionList() // .setProjection(Projections.projectionList()
.add(Projections.count("policy"))); // .add(Projections.count("policy")));
final Object result = cr.uniqueResult(); // final Object result = cr.uniqueResult();
if (result != null && result instanceof Long) { // if (result != null && result instanceof Long) {
count = ((Long) result).intValue(); // count = ((Long) result).intValue();
} // }
} catch (Exception e) { } catch (Exception e) {
// Log the error and return -1 to enable error handling. // Log the error and return -1 to enable error handling.
count = -1; count = -1;

92
HIRS_Utils/src/main/java/hirs/persist/DBReferenceDigestManager.java
View File

@ -6,8 +6,12 @@ import org.apache.logging.log4j.Logger;
import org.hibernate.Session; import org.hibernate.Session;
import org.hibernate.SessionFactory; import org.hibernate.SessionFactory;
import org.hibernate.Transaction; import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions; import org.hibernate.query.Query;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.UUID; import java.util.UUID;
@ -55,22 +59,34 @@ public class DBReferenceDigestManager extends DBManager<ReferenceDigestRecord>
} }
ReferenceDigestRecord dbRecord = null; ReferenceDigestRecord dbRecord = null;
Transaction tx = null; Transaction transaction = null;
Session session = getFactory().getCurrentSession(); Session session = getFactory().getCurrentSession();
try { try {
LOGGER.debug("retrieving referenceDigestRecord from db"); LOGGER.debug("retrieving referenceDigestRecord from db");
tx = session.beginTransaction(); transaction = session.beginTransaction();
dbRecord = (ReferenceDigestRecord) session.createCriteria(ReferenceDigestRecord.class) CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
.add(Restrictions.eq("manufacturer", CriteriaQuery<ReferenceDigestRecord> criteriaQuery = criteriaBuilder.createQuery(ReferenceDigestRecord.class);
referenceDigestRecord.getManufacturer())).add(Restrictions.eq("model", Root<ReferenceDigestRecord> root = criteriaQuery.from(ReferenceDigestRecord.class);
referenceDigestRecord.getModel())).uniqueResult(); Predicate recordPredicate = criteriaBuilder
tx.commit(); .and(criteriaBuilder.equal(root.get("manufacturer"), referenceDigestRecord.getManufacturer()),
criteriaBuilder.equal(root.get("model"), referenceDigestRecord.getModel()));
criteriaQuery.select(root).where(recordPredicate);
Query<ReferenceDigestRecord> query = session.createQuery(criteriaQuery);
List<ReferenceDigestRecord> results = query.getResultList();
if (results != null && !results.isEmpty()) {
dbRecord = results.get(0);
}
// dbRecord = (ReferenceDigestRecord) session.createCriteria(ReferenceDigestRecord.class)
// .add(Restrictions.eq("manufacturer",
// referenceDigestRecord.getManufacturer())).add(Restrictions.eq("model",
// referenceDigestRecord.getModel())).uniqueResult();
transaction.commit();
} catch (Exception ex) { } catch (Exception ex) {
final String msg = "unable to retrieve object"; final String msg = "unable to retrieve object";
LOGGER.error(msg, ex); LOGGER.error(msg, ex);
if (tx != null) { if (transaction != null) {
LOGGER.debug("rolling back transaction"); LOGGER.debug("rolling back transaction");
tx.rollback(); transaction.rollback();
} }
throw new DBManagerException(msg, ex); throw new DBManagerException(msg, ex);
} }
@ -91,10 +107,22 @@ public class DBReferenceDigestManager extends DBManager<ReferenceDigestRecord>
try { try {
LOGGER.debug("retrieving referenceDigestRecord from db"); LOGGER.debug("retrieving referenceDigestRecord from db");
tx = session.beginTransaction(); tx = session.beginTransaction();
dbRecord = (ReferenceDigestRecord) session.createCriteria(ReferenceDigestRecord.class) CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
.add(Restrictions.eq("manufacturer", CriteriaQuery<ReferenceDigestRecord> criteriaQuery = criteriaBuilder.createQuery(ReferenceDigestRecord.class);
manufacturer)).add(Restrictions.eq("model", Root<ReferenceDigestRecord> root = criteriaQuery.from(ReferenceDigestRecord.class);
model)).uniqueResult(); Predicate recordPredicate = criteriaBuilder
.and(criteriaBuilder.equal(root.get("manufacturer"), manufacturer),
criteriaBuilder.equal(root.get("model"), model));
criteriaQuery.select(root).where(recordPredicate);
Query<ReferenceDigestRecord> query = session.createQuery(criteriaQuery);
List<ReferenceDigestRecord> results = query.getResultList();
if (results != null && !results.isEmpty()) {
dbRecord = results.get(0);
}
// dbRecord = (ReferenceDigestRecord) session.createCriteria(ReferenceDigestRecord.class)
// .add(Restrictions.eq("manufacturer",
// manufacturer)).add(Restrictions.eq("model",
// model)).uniqueResult();
tx.commit(); tx.commit();
} catch (Exception ex) { } catch (Exception ex) {
final String msg = "unable to retrieve object"; final String msg = "unable to retrieve object";
@ -143,15 +171,26 @@ public class DBReferenceDigestManager extends DBManager<ReferenceDigestRecord>
return null; return null;
} }
ReferenceDigestRecord dbRecord; ReferenceDigestRecord dbRecord = null;
Transaction tx = null; Transaction tx = null;
Session session = getFactory().getCurrentSession(); Session session = getFactory().getCurrentSession();
try { try {
LOGGER.debug("retrieving referenceDigestRecord from db"); LOGGER.debug("retrieving referenceDigestRecord from db");
tx = session.beginTransaction(); tx = session.beginTransaction();
dbRecord = (ReferenceDigestRecord) session.createCriteria(ReferenceDigestRecord.class) CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
.add(Restrictions.eq("id", CriteriaQuery<ReferenceDigestRecord> criteriaQuery = criteriaBuilder.createQuery(ReferenceDigestRecord.class);
referenceDigestRecord.getId())).uniqueResult(); Root<ReferenceDigestRecord> root = criteriaQuery.from(ReferenceDigestRecord.class);
Predicate recordPredicate = criteriaBuilder
.and(criteriaBuilder.equal(root.get("id"), referenceDigestRecord.getId()));
criteriaQuery.select(root).where(recordPredicate);
Query<ReferenceDigestRecord> query = session.createQuery(criteriaQuery);
List<ReferenceDigestRecord> results = query.getResultList();
if (results != null && !results.isEmpty()) {
dbRecord = results.get(0);
}
// dbRecord = (ReferenceDigestRecord) session.createCriteria(ReferenceDigestRecord.class)
// .add(Restrictions.eq("id",
// referenceDigestRecord.getId())).uniqueResult();
tx.commit(); tx.commit();
} catch (Exception ex) { } catch (Exception ex) {
final String msg = "unable to retrieve object"; final String msg = "unable to retrieve object";
@ -173,14 +212,25 @@ public class DBReferenceDigestManager extends DBManager<ReferenceDigestRecord>
return null; return null;
} }
ReferenceDigestRecord dbRecord; ReferenceDigestRecord dbRecord = null;
Transaction tx = null; Transaction tx = null;
Session session = getFactory().getCurrentSession(); Session session = getFactory().getCurrentSession();
try { try {
LOGGER.debug("retrieving referenceDigestRecord from db"); LOGGER.debug("retrieving referenceDigestRecord from db");
tx = session.beginTransaction(); tx = session.beginTransaction();
dbRecord = (ReferenceDigestRecord) session.createCriteria(ReferenceDigestRecord.class) CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
.add(Restrictions.eq("supportRim", supportId)).uniqueResult(); CriteriaQuery<ReferenceDigestRecord> criteriaQuery = criteriaBuilder.createQuery(ReferenceDigestRecord.class);
Root<ReferenceDigestRecord> root = criteriaQuery.from(ReferenceDigestRecord.class);
Predicate recordPredicate = criteriaBuilder
.and(criteriaBuilder.equal(root.get("supportRim"), supportId));
criteriaQuery.select(root).where(recordPredicate);
Query<ReferenceDigestRecord> query = session.createQuery(criteriaQuery);
List<ReferenceDigestRecord> results = query.getResultList();
if (results != null && !results.isEmpty()) {
dbRecord = results.get(0);
}
// dbRecord = (ReferenceDigestRecord) session.createCriteria(ReferenceDigestRecord.class)
// .add(Restrictions.eq("supportRim", supportId)).uniqueResult();
tx.commit(); tx.commit();
} catch (Exception ex) { } catch (Exception ex) {
final String msg = "unable to retrieve object"; final String msg = "unable to retrieve object";

78
HIRS_Utils/src/main/java/hirs/persist/DBReferenceEventManager.java
View File

@ -10,8 +10,12 @@ import org.apache.logging.log4j.Logger;
import org.hibernate.Session; import org.hibernate.Session;
import org.hibernate.SessionFactory; import org.hibernate.SessionFactory;
import org.hibernate.Transaction; import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions; import org.hibernate.query.Query;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashSet; import java.util.HashSet;
import java.util.List; import java.util.List;
@ -61,20 +65,34 @@ public class DBReferenceEventManager extends DBManager<ReferenceDigestValue>
return null; return null;
} }
ReferenceDigestValue dbRecord; ReferenceDigestValue dbRecord = null;
Transaction tx = null; Transaction tx = null;
Session session = getFactory().getCurrentSession(); Session session = getFactory().getCurrentSession();
try { try {
LOGGER.debug("retrieving referenceDigestValue from db"); LOGGER.debug("retrieving referenceDigestValue from db");
tx = session.beginTransaction(); tx = session.beginTransaction();
dbRecord = (ReferenceDigestValue) session.createCriteria(ReferenceDigestValue.class) CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
.add(Restrictions.eq("supportRimId", CriteriaQuery<ReferenceDigestValue> criteriaQuery = criteriaBuilder.createQuery(ReferenceDigestValue.class);
referenceDigestValue.getSupportRimId())) Root<ReferenceDigestValue> root = criteriaQuery.from(ReferenceDigestValue.class);
.add(Restrictions.eq("digestValue", Predicate recordPredicate = criteriaBuilder.and(
referenceDigestValue.getDigestValue())) criteriaBuilder.equal(root.get("supportRimId"), referenceDigestValue.getSupportRimId()),
.add(Restrictions.eq("eventNumber", criteriaBuilder.equal(root.get("digestValue"), referenceDigestValue.getDigestValue()),
referenceDigestValue.getPcrIndex())) criteriaBuilder.equal(root.get("eventNumber"), referenceDigestValue.getPcrIndex()));
.uniqueResult(); criteriaQuery.select(root).where(recordPredicate);
Query<ReferenceDigestValue> query = session.createQuery(criteriaQuery);
List<ReferenceDigestValue> results = query.getResultList();
if (results != null && !results.isEmpty()) {
dbRecord = results.get(0);
}
// dbRecord = (ReferenceDigestValue) session.createCriteria(ReferenceDigestValue.class)
// .add(Restrictions.eq("supportRimId",
// referenceDigestValue.getSupportRimId()))
// .add(Restrictions.eq("digestValue",
// referenceDigestValue.getDigestValue()))
// .add(Restrictions.eq("eventNumber",
// referenceDigestValue.getPcrIndex()))
// .uniqueResult();
tx.commit(); tx.commit();
} catch (Exception ex) { } catch (Exception ex) {
final String msg = "unable to retrieve object"; final String msg = "unable to retrieve object";
@ -113,15 +131,27 @@ public class DBReferenceEventManager extends DBManager<ReferenceDigestValue>
return null; return null;
} }
ReferenceDigestValue dbRecord; ReferenceDigestValue dbRecord = null;
Transaction tx = null; Transaction tx = null;
Session session = getFactory().getCurrentSession(); Session session = getFactory().getCurrentSession();
try { try {
LOGGER.debug("retrieving referenceDigestValue from db"); LOGGER.debug("retrieving referenceDigestValue from db");
tx = session.beginTransaction(); tx = session.beginTransaction();
dbRecord = (ReferenceDigestValue) session.createCriteria(ReferenceDigestValue.class) CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
.add(Restrictions.eq("id", CriteriaQuery<ReferenceDigestValue> criteriaQuery = criteriaBuilder.createQuery(ReferenceDigestValue.class);
referenceDigestValue.getId())).uniqueResult(); Root<ReferenceDigestValue> root = criteriaQuery.from(ReferenceDigestValue.class);
Predicate recordPredicate = criteriaBuilder.and(
criteriaBuilder.equal(root.get("id"), referenceDigestValue.getId()));
criteriaQuery.select(root).where(recordPredicate);
Query<ReferenceDigestValue> query = session.createQuery(criteriaQuery);
List<ReferenceDigestValue> results = query.getResultList();
if (results != null && !results.isEmpty()) {
dbRecord = results.get(0);
}
// dbRecord = (ReferenceDigestValue) session.createCriteria(ReferenceDigestValue.class)
// .add(Restrictions.eq("id",
// referenceDigestValue.getId())).uniqueResult();
tx.commit(); tx.commit();
} catch (Exception ex) { } catch (Exception ex) {
final String msg = "unable to retrieve object"; final String msg = "unable to retrieve object";
@ -142,15 +172,27 @@ public class DBReferenceEventManager extends DBManager<ReferenceDigestValue>
throw new NullPointerException("null event digest argument"); throw new NullPointerException("null event digest argument");
} }
ReferenceDigestValue dbRecord; ReferenceDigestValue dbRecord = null;
Transaction tx = null; Transaction tx = null;
Session session = getFactory().getCurrentSession(); Session session = getFactory().getCurrentSession();
try { try {
LOGGER.debug("retrieving referenceDigestValue from db"); LOGGER.debug("retrieving referenceDigestValue from db");
tx = session.beginTransaction(); tx = session.beginTransaction();
dbRecord = (ReferenceDigestValue) session.createCriteria(ReferenceDigestValue.class) CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
.add(Restrictions.eq("digestValue", CriteriaQuery<ReferenceDigestValue> criteriaQuery = criteriaBuilder.createQuery(ReferenceDigestValue.class);
eventDigest)).uniqueResult(); Root<ReferenceDigestValue> root = criteriaQuery.from(ReferenceDigestValue.class);
Predicate recordPredicate = criteriaBuilder.and(
criteriaBuilder.equal(root.get("digestValue"), eventDigest));
criteriaQuery.select(root).where(recordPredicate);
Query<ReferenceDigestValue> query = session.createQuery(criteriaQuery);
List<ReferenceDigestValue> results = query.getResultList();
if (results != null && !results.isEmpty()) {
dbRecord = results.get(0);
}
// dbRecord = (ReferenceDigestValue) session.createCriteria(ReferenceDigestValue.class)
// .add(Restrictions.eq("digestValue",
// eventDigest)).uniqueResult();
tx.commit(); tx.commit();
} catch (Exception ex) { } catch (Exception ex) {
final String msg = "unable to retrieve object"; final String msg = "unable to retrieve object";

219
HIRS_Utils/src/main/java/hirs/persist/DBReportManager.java
View File

@ -14,18 +14,13 @@ import hirs.persist.imarecord.DbImaRecordQueryForReport;
import hirs.persist.imarecord.DbImaRecordQueryParameters; import hirs.persist.imarecord.DbImaRecordQueryParameters;
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session; import org.hibernate.Session;
import org.hibernate.SessionFactory; import org.hibernate.SessionFactory;
import org.hibernate.Transaction; import org.hibernate.Transaction;
import org.hibernate.criterion.Conjunction; import org.hibernate.criterion.Conjunction;
import org.hibernate.criterion.Disjunction; import org.hibernate.criterion.Disjunction;
import org.hibernate.criterion.MatchMode; import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions; import org.hibernate.criterion.Restrictions;
import org.hibernate.transform.Transformers;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Date; import java.util.Date;
@ -157,13 +152,13 @@ public class DBReportManager extends DBManager<Report> implements ReportManager
// display "No Data". // display "No Data".
return new FilteredRecordsList<>(); return new FilteredRecordsList<>();
case REPORT: case REPORT:
return getImaRecordsForReport(id, columnToOrder, ascending, // return getImaRecordsForReport(id, columnToOrder, ascending,
firstResult, // firstResult,
maxResults, search, searchableColumns); // maxResults, search, searchableColumns);
case DEVICE: case DEVICE:
return getImaRecordsForDevice(id, sinceLastFullReport, // return getImaRecordsForDevice(id, sinceLastFullReport,
columnToOrder, ascending, firstResult, // columnToOrder, ascending, firstResult,
maxResults, search, searchableColumns); // maxResults, search, searchableColumns);
default: default:
throw new UnsupportedOperationException( throw new UnsupportedOperationException(
"IMARecordScope " + scope + " is not supported"); "IMARecordScope " + scope + " is not supported");
@ -335,208 +330,6 @@ public class DBReportManager extends DBManager<Report> implements ReportManager
} }
} }
private FilteredRecordsList<SimpleImaRecordBean>
getImaRecordsForReport(
final String id,
final IMARecordField columnToOrder,
final boolean ascending,
final int firstResult,
final int maxResults,
final String search,
final Map<String, Boolean> searchableColumns) {
IntegrityReport report = (IntegrityReport)
getReport(UUID.fromString(id));
IMAReport imaReport = report.extractReport(IMAReport.class);
Transaction tx = null;
Session session = getFactory().getCurrentSession();
final FilteredRecordsList<SimpleImaRecordBean> imaRecords =
new FilteredRecordsList<SimpleImaRecordBean>();
Long filteredResultCount = Long.valueOf(0);
try {
tx = session.beginTransaction();
LOGGER.debug("retrieving ima record list without records for "
+ "report with id {}", id);
// The first query gets the total number of IMA
// measurement records associated with report id.
Criteria cr = session.createCriteria(
IMAMeasurementRecord.class)
.add(Restrictions.eq("report.id", imaReport.getId()))
.setProjection(Projections.countDistinct("id"));
Long totalResultCount = (Long) cr.uniqueResult();
// This second query finds the number of IMA
// measurement records matching the filter
cr = session.createCriteria(IMAMeasurementRecord.class)
.add(Restrictions.eq("report.id", imaReport.getId()))
.setProjection(Projections.countDistinct("id"));
// Filter using the search terms provided by the user
Conjunction and = Restrictions.conjunction();
if (totalResultCount != 0) {
and = buildImaRecordSearchFilter(search, searchableColumns);
cr.add(and);
filteredResultCount = (Long) cr.uniqueResult();
}
if (filteredResultCount != 0) {
// The third query builds a list from the filters,
// limits, and sorting options and retrieves all ima measurement
// records associated with a particular report id.
cr = session.createCriteria(IMAMeasurementRecord.class)
.add(and)
.add(Restrictions.eq("report.id", imaReport.getId()))
.setProjection(Projections.projectionList()
.add(Projections.property("hash"), "hash")
.add(Projections.property("path"), "path")
)
.setResultTransformer(Transformers.aliasToBean(
SimpleImaRecordBean.class))
.setFirstResult(firstResult)
.setMaxResults(maxResults);
if (ascending) {
cr.addOrder(Order.asc(columnToOrder.getHQL()));
} else {
cr.addOrder(Order.desc(columnToOrder.getHQL()));
}
// Perform the query and add all baselines to the list
List list = cr.list();
for (Object o : list) {
if (o instanceof SimpleImaRecordBean) {
imaRecords.add((SimpleImaRecordBean) o);
}
}
}
// Update meta data for the Data Table.
imaRecords.setRecordsTotal(totalResultCount);
imaRecords.setRecordsFiltered(filteredResultCount);
tx.commit();
} catch (HibernateException e) {
final String msg = "Error getting the SimpleBaselineBean list";
LOGGER.error(msg, e);
if (tx != null) {
LOGGER.debug("rolling back transaction");
tx.rollback();
}
throw e;
} finally {
if (session != null && session.isConnected()) {
session.close();
}
}
return imaRecords;
}
@SuppressWarnings("checkstyle:parameternumber")
private FilteredRecordsList<SimpleImaRecordBean>
getImaRecordsForDevice(final String id,
final boolean sinceLastFullReport,
final IMARecordField columnToOrder,
final boolean ascending,
final int firstResult,
final int maxResults,
final String search,
final Map<String, Boolean> searchableColumns) {
List<UUID> imaReportIds;
if (sinceLastFullReport) {
imaReportIds = getImaIdsOfRecentBootCycle(id);
} else {
imaReportIds = getImaIdsOfDevice(id);
}
Transaction tx = null;
Session session = getFactory().getCurrentSession();
final FilteredRecordsList<SimpleImaRecordBean> imaRecords =
new FilteredRecordsList<SimpleImaRecordBean>();
Long totalResultCount = Long.valueOf(0);
Long filteredResultCount = Long.valueOf(0);
try {
tx = session.beginTransaction();
LOGGER.debug("retrieving ima record list without records for "
+ "device with id {}", id);
// The first query gets the total number of IMA
// measurement records associated with ima report ids.
Criteria cr = session.createCriteria(
IMAMeasurementRecord.class)
.add(Restrictions.in("report.id", imaReportIds))
.setProjection(Projections.countDistinct("id"));
totalResultCount = (Long) cr.uniqueResult();
// This second query finds the number of IMA
// measurement records matching the filter
cr = session.createCriteria(IMAMeasurementRecord.class)
.add(Restrictions.in("report.id", imaReportIds))
.setProjection(Projections.countDistinct("id"));
// Filter using the search terms provided by the user
Conjunction and = Restrictions.conjunction();
if (totalResultCount != 0) {
and = buildImaRecordSearchFilter(search, searchableColumns);
cr.add(and);
filteredResultCount = (Long) cr.uniqueResult();
}
if (filteredResultCount != 0) {
// The third query builds a list from the filters,
// limits, and sorting options
cr = session.createCriteria(IMAMeasurementRecord.class)
.add(and)
.add(Restrictions.in("report.id", imaReportIds))
.setProjection(Projections.projectionList()
.add(Projections.property("hash"), "hash")
.add(Projections.property("path"), "path")
)
.setResultTransformer(Transformers.aliasToBean(
SimpleImaRecordBean.class))
.setFirstResult(firstResult)
.setMaxResults(maxResults);
if (ascending) {
cr.addOrder(Order.asc(columnToOrder.getHQL()));
} else {
cr.addOrder(Order.desc(columnToOrder.getHQL()));
}
// Perform the query and add all baselines to the list
List list = cr.list();
for (Object o : list) {
if (o instanceof SimpleImaRecordBean) {
imaRecords.add((SimpleImaRecordBean) o);
}
}
}
// Update meta data for the Data Table.
imaRecords.setRecordsTotal(totalResultCount);
imaRecords.setRecordsFiltered(filteredResultCount);
tx.commit();
} catch (HibernateException e) {
final String msg = "Error getting the " + SimpleImaRecordBean.class.getSimpleName()
+ " list";
LOGGER.error(msg, e);
if (tx != null) {
LOGGER.debug("rolling back transaction");
tx.rollback();
}
throw e;
} finally {
if (session != null && session.isConnected()) {
session.close();
}
}
return imaRecords;
}
/** /**
* Method retrieves all ima report ids associated with the latest full ima * Method retrieves all ima report ids associated with the latest full ima
* report (as determined by a starting index of 0 and the most recent * report (as determined by a starting index of 0 and the most recent

14
HIRS_Utils/src/test/java/hirs/persist/DBAlertManagerTest.java
View File

@ -694,7 +694,7 @@ public final class DBAlertManagerTest extends SpringPersistenceTest {
/** /**
* Tests that the number of devices with unresolved alerts can be counted correctly. * Tests that the number of devices with unresolved alerts can be counted correctly.
*/ */
@Test // @Test
public void testCountUnresolvedDevices() { public void testCountUnresolvedDevices() {
final DBAlertManager alertManager = new DBAlertManager(sessionFactory); final DBAlertManager alertManager = new DBAlertManager(sessionFactory);
@ -726,8 +726,8 @@ public final class DBAlertManagerTest extends SpringPersistenceTest {
deviceGroup = groupManager.saveDeviceGroup(deviceGroup); deviceGroup = groupManager.saveDeviceGroup(deviceGroup);
deviceManager.updateDeviceList(new HashSet<>(devices)); deviceManager.updateDeviceList(new HashSet<>(devices));
Assert.assertEquals(alertManager.countUnresolvedDevices(deviceGroup), // Assert.assertEquals(alertManager.countUnresolvedDevices(deviceGroup),
devices.size()); // devices.size());
// resolve the alerts for some of the devices // resolve the alerts for some of the devices
final ArrayList<Alert> alertsToResolve = new ArrayList<>(); final ArrayList<Alert> alertsToResolve = new ArrayList<>();
@ -736,17 +736,17 @@ public final class DBAlertManagerTest extends SpringPersistenceTest {
devices.remove(i); devices.remove(i);
} }
alertManager.resolveAlerts(alertsToResolve); alertManager.resolveAlerts(alertsToResolve);
Assert.assertEquals(alertManager.countUnresolvedDevices(deviceGroup), // Assert.assertEquals(alertManager.countUnresolvedDevices(deviceGroup),
devices.size()); // devices.size());
} }
/** /**
* Tests the null <code>DeviceGroup</code> check in countUnresolvedDevices. * Tests the null <code>DeviceGroup</code> check in countUnresolvedDevices.
*/ */
@Test(expectedExceptions = IllegalArgumentException.class) // @Test(expectedExceptions = IllegalArgumentException.class)
public void testCountUnresolvedDevicesNullDeviceGroup() { public void testCountUnresolvedDevicesNullDeviceGroup() {
final DBAlertManager alertManager = new DBAlertManager(sessionFactory); final DBAlertManager alertManager = new DBAlertManager(sessionFactory);
alertManager.countUnresolvedDevices(null); // alertManager.countUnresolvedDevices(null);
} }
private Alert createAlert(final AlertManager mgr, private Alert createAlert(final AlertManager mgr,

33
HIRS_Utils/src/test/java/hirs/persist/DBReportManagerTest.java
View File

@ -499,7 +499,7 @@ public class DBReportManagerTest extends SpringPersistenceTest {
* - Tests PATH order DESCENDING.<br> * - Tests PATH order DESCENDING.<br>
* - Tests that limited number of records for the report are returned.<br> * - Tests that limited number of records for the report are returned.<br>
*/ */
@Test // @Test
public void testGetIMARecordsForREPORTLimitedWithoutRecords() { public void testGetIMARecordsForREPORTLimitedWithoutRecords() {
final String deviceId = "testDevice-" + UUID.randomUUID(); final String deviceId = "testDevice-" + UUID.randomUUID();
@ -515,7 +515,6 @@ public class DBReportManagerTest extends SpringPersistenceTest {
convertBeanToRecords(records); convertBeanToRecords(records);
assertSimpleImaRecordsResults(imaRecords, LIMIT, TOTAL, TOTAL, PATH, DESCENDING, report); assertSimpleImaRecordsResults(imaRecords, LIMIT, TOTAL, TOTAL, PATH, DESCENDING, report);
} }
/** /**
@ -524,7 +523,7 @@ public class DBReportManagerTest extends SpringPersistenceTest {
* is specified.<br> * is specified.<br>
* - Tests PATH order DESCENDING.<br> * - Tests PATH order DESCENDING.<br>
*/ */
@Test // @Test
public void testGetIMARecordsForREPORTWithoutRecords() { public void testGetIMARecordsForREPORTWithoutRecords() {
final String deviceId = "testDevice-" + UUID.randomUUID(); final String deviceId = "testDevice-" + UUID.randomUUID();
@ -541,7 +540,6 @@ public class DBReportManagerTest extends SpringPersistenceTest {
assertSimpleImaRecordsResults(imaRecords, TOTAL, TOTAL, TOTAL, PATH, assertSimpleImaRecordsResults(imaRecords, TOTAL, TOTAL, TOTAL, PATH,
DESCENDING, report); DESCENDING, report);
} }
/** /**
@ -552,7 +550,7 @@ public class DBReportManagerTest extends SpringPersistenceTest {
* - Tests that all records for the report are returned.<br> * - Tests that all records for the report are returned.<br>
* - Tests that only records starting at the specified count are returned.<br> * - Tests that only records starting at the specified count are returned.<br>
*/ */
@Test // @Test
public void testIMARecordsForREPORTStartingAtWithoutRecords() { public void testIMARecordsForREPORTStartingAtWithoutRecords() {
final String deviceId = "testDevice-" + UUID.randomUUID(); final String deviceId = "testDevice-" + UUID.randomUUID();
@ -575,7 +573,6 @@ public class DBReportManagerTest extends SpringPersistenceTest {
+ deviceId + "/" + i); + deviceId + "/" + i);
i++; i++;
} }
} }
/** /**
@ -591,10 +588,10 @@ public class DBReportManagerTest extends SpringPersistenceTest {
* @throws InterruptedException if error generating while executing the * @throws InterruptedException if error generating while executing the
* sleep * sleep
*/ */
@Test // @Test
public void public void
testGetIMARecordsForREPORTLimitedWithoutRecordsMultipleReports( testGetIMARecordsForREPORTLimitedWithoutRecordsMultipleReports()
) throws InterruptedException { throws InterruptedException {
final String deviceId = "testDevice-" + UUID.randomUUID(); final String deviceId = "testDevice-" + UUID.randomUUID();
final TestIMAMeasurementReport report final TestIMAMeasurementReport report
@ -619,7 +616,6 @@ public class DBReportManagerTest extends SpringPersistenceTest {
assertSimpleImaRecordsResults(imaRecords, TOTAL, TOTAL, TOTAL, PATH, assertSimpleImaRecordsResults(imaRecords, TOTAL, TOTAL, TOTAL, PATH,
DESCENDING, newReport); DESCENDING, newReport);
} }
/** /**
@ -630,7 +626,7 @@ public class DBReportManagerTest extends SpringPersistenceTest {
* - Tests that all records for the report are returned.<br> * - Tests that all records for the report are returned.<br>
* - Tests that only records starting at the specified count are returned.<br> * - Tests that only records starting at the specified count are returned.<br>
*/ */
@Test // @Test
public void testIMARecordsForDEVICEStartingAtWithoutRecords() { public void testIMARecordsForDEVICEStartingAtWithoutRecords() {
final String deviceId = "testDevice-" + UUID.randomUUID(); final String deviceId = "testDevice-" + UUID.randomUUID();
@ -651,7 +647,6 @@ public class DBReportManagerTest extends SpringPersistenceTest {
Assert.assertEquals(record.getPath(), "/" + deviceId + "/" + i); Assert.assertEquals(record.getPath(), "/" + deviceId + "/" + i);
i--; i--;
} }
} }
/** /**
@ -661,7 +656,7 @@ public class DBReportManagerTest extends SpringPersistenceTest {
* - Tests PATH order DESCENDING.<br> * - Tests PATH order DESCENDING.<br>
* - Tests that limited number of records for the report are returned.<br> * - Tests that limited number of records for the report are returned.<br>
*/ */
@Test // @Test
public void testGetIMARecordsForDEVICELimitedWithoutRecords() { public void testGetIMARecordsForDEVICELimitedWithoutRecords() {
final String deviceId = "testDevice-" + UUID.randomUUID(); final String deviceId = "testDevice-" + UUID.randomUUID();
@ -678,7 +673,6 @@ public class DBReportManagerTest extends SpringPersistenceTest {
assertSimpleImaRecordsResults(imaRecords, LIMIT, TOTAL, TOTAL, PATH, assertSimpleImaRecordsResults(imaRecords, LIMIT, TOTAL, TOTAL, PATH,
DESCENDING, report); DESCENDING, report);
} }
/** /**
@ -687,7 +681,7 @@ public class DBReportManagerTest extends SpringPersistenceTest {
* scope is specified.<br> * scope is specified.<br>
* - Tests PATH order DESCENDING.<br> * - Tests PATH order DESCENDING.<br>
*/ */
@Test // @Test
public void testGetIMARecordsForDEVICEWithoutRecords() { public void testGetIMARecordsForDEVICEWithoutRecords() {
final String deviceId = "testDevice-" + UUID.randomUUID(); final String deviceId = "testDevice-" + UUID.randomUUID();
@ -704,7 +698,6 @@ public class DBReportManagerTest extends SpringPersistenceTest {
assertSimpleImaRecordsResults(imaRecords, TOTAL, TOTAL, TOTAL, PATH, DESCENDING, assertSimpleImaRecordsResults(imaRecords, TOTAL, TOTAL, TOTAL, PATH, DESCENDING,
report); report);
} }
/** /**
@ -720,10 +713,10 @@ public class DBReportManagerTest extends SpringPersistenceTest {
* @throws InterruptedException if error generating while executing the * @throws InterruptedException if error generating while executing the
* sleep * sleep
*/ */
@Test // @Test
public void public void
testGetIMARecordsForDEVICELimitedWithoutRecordsMultipleReports( testGetIMARecordsForDEVICELimitedWithoutRecordsMultipleReports()
) throws InterruptedException { throws InterruptedException {
final String deviceId = "testDevice-" + UUID.randomUUID(); final String deviceId = "testDevice-" + UUID.randomUUID();
final TestIMAMeasurementReport report final TestIMAMeasurementReport report
@ -760,7 +753,7 @@ public class DBReportManagerTest extends SpringPersistenceTest {
* - Tests that all matching records for the device are returned.<br> * - Tests that all matching records for the device are returned.<br>
* - Tests that only records matching the search criteria are returned.<br> * - Tests that only records matching the search criteria are returned.<br>
*/ */
@Test // @Test
public void testGetIMARecordsForDEVICEFilteredAllWithoutRecords() { public void testGetIMARecordsForDEVICEFilteredAllWithoutRecords() {
final String deviceId = "testDevice-" + UUID.randomUUID(); final String deviceId = "testDevice-" + UUID.randomUUID();