private void Initialize()
{
Name = Components.Event;
_mEvaluator = new EventEvaluator(this);
SetService(_mEvaluator);
}
public override void MatchEvent(EventBean theEvent, ICollection <FilterHandle> matches)
{
var attributeValue = Lookupable.Getter.Get(theEvent);
var returnValue = new Mutable <bool>(false);
using (Instrument.With(
i => i.QFilterReverseIndex(this, attributeValue),
i => i.AFilterReverseIndex(returnValue.Value)))
{
EventEvaluator evaluator = null;
using (ConstantsMapRwLock.AcquireReadLock())
{
evaluator = ConstantsMap.Get(attributeValue);
}
// No listener found for the value, return
if (evaluator == null)
{
returnValue.Value = false;
}
else
{
evaluator.MatchEvent(theEvent, matches);
returnValue.Value = true;
}
}
}
public override void Put(Object filterConstant, EventEvaluator evaluator)
{
// Store evaluator keyed to set of values
var keys = (MultiKeyUntyped)filterConstant;
// make sure to remove the old evaluator for this constant
var oldEvaluator = _evaluatorsMap.Push(keys, evaluator);
// Store each value to match against in Map with it's evaluator as a list
var keyValues = keys.Keys;
for (var i = 0; i < keyValues.Length; i++)
{
var evaluators = _constantsMap.Get(keyValues[i]);
if (evaluators == null)
{
evaluators = new List <EventEvaluator>();
_constantsMap.Put(keyValues[i], evaluators);
}
else
{
if (oldEvaluator != null)
{
evaluators.Remove(oldEvaluator);
}
}
evaluators.Add(evaluator);
}
}
/// <summary>
/// Add filter callback to an event evaluator, which could be either an index node or a set node.
/// </summary>
/// <param name="remainingParameters">The remaining parameters.</param>
/// <param name="filterCallback">The filter callback.</param>
/// <param name="eventEvaluator">to add the filterCallback to.</param>
/// <param name="treePathInfo">is for holding the information on where the add occured</param>
/// <param name="lockFactory">The lock factory.</param>
/// <returns>
/// bool indicating if the eventEvaluator was successfully added
/// </returns>
private static bool AddToEvaluator(
ArrayDeque <FilterValueSetParam> remainingParameters,
FilterHandle filterCallback,
EventEvaluator eventEvaluator,
ArrayDeque <EventTypeIndexBuilderIndexLookupablePair> treePathInfo,
FilterServiceGranularLockFactory lockFactory)
{
if (eventEvaluator is FilterHandleSetNode)
{
var node = (FilterHandleSetNode)eventEvaluator;
AddToNode(remainingParameters, filterCallback, node, treePathInfo, lockFactory);
return(true);
}
// Check if the next index matches any of the remaining filterCallback parameters
var nextIndex = (FilterParamIndexBase)eventEvaluator;
var parameter = IndexHelper.FindParameter(remainingParameters, nextIndex);
if (parameter != null)
{
remainingParameters.Remove(parameter);
treePathInfo.Add(new EventTypeIndexBuilderIndexLookupablePair(nextIndex, parameter.FilterForValue));
AddToIndex(remainingParameters, filterCallback, nextIndex, parameter.FilterForValue, treePathInfo, lockFactory);
return(true);
}
// This eventEvaluator does not work with any of the remaining filter parameters
return(false);
}
/// <summary>
/// Add filter callback to an event evaluator, which could be either an index node or a set node.
/// </summary>
/// <param name="remainingParameters">The remaining parameters.</param>
/// <param name="filterCallback">The filter callback.</param>
/// <param name="eventEvaluator">to add the filterCallback to.</param>
/// <param name="treePathInfo">is for holding the information on where the add occured</param>
/// <param name="lockFactory">The lock factory.</param>
/// <returns>
/// bool indicating if the eventEvaluator was successfully added
/// </returns>
private static bool AddToEvaluator(
ArrayDeque <FilterValueSetParam> remainingParameters,
FilterHandle filterCallback,
EventEvaluator eventEvaluator,
ArrayDeque <EventTypeIndexBuilderIndexLookupablePair> treePathInfo,
FilterServiceGranularLockFactory lockFactory)
{
if (eventEvaluator is FilterHandleSetNode)
{
var node = (FilterHandleSetNode)eventEvaluator;
#if DEBUG && DIAGNOSTICS
System.Diagnostics.Debug.WriteLine("{0}: AddToEvaluator: {1}", Thread.CurrentThread.ManagedThreadId, node);
#endif
AddToNode(remainingParameters, filterCallback, node, treePathInfo, lockFactory);
return(true);
}
// Check if the next index matches any of the remaining filterCallback parameters
var nextIndex = (FilterParamIndexBase)eventEvaluator;
var parameter = IndexHelper.FindParameter(remainingParameters, nextIndex);
if (parameter != null)
{
remainingParameters.Remove(parameter);
treePathInfo.Add(new EventTypeIndexBuilderIndexLookupablePair(nextIndex, parameter.FilterForValue));
#if DEBUG && DIAGNOSTICS
System.Diagnostics.Debug.WriteLine("{0}: AddToEvaluator -> AddToIndex: {1}", Thread.CurrentThread.ManagedThreadId, nextIndex);
#endif
AddToIndex(remainingParameters, filterCallback, nextIndex, parameter.FilterForValue, treePathInfo, lockFactory);
return(true);
}
// This eventEvaluator does not work with any of the remaining filter parameters
return(false);
}
public override void Put(
object filterConstant,
EventEvaluator evaluator)
{
var keys = (ExprNodeAdapterBase) filterConstant;
evaluatorsMap.Put(keys, evaluator);
}
public override void MatchEvent(
EventBean theEvent,
ICollection<FilterHandle> matches,
ExprEvaluatorContext ctx)
{
object attributeValue = Lookupable.Eval.Eval(theEvent, ctx);
if (InstrumentationHelper.ENABLED) {
InstrumentationHelper.Get().QFilterReverseIndex(this, attributeValue);
}
EventEvaluator evaluator = null;
using (ConstantsMapRwLock.ReadLock.Acquire()) {
evaluator = ConstantsMap.Get(attributeValue);
}
// No listener found for the value, return
if (evaluator == null) {
if (InstrumentationHelper.ENABLED) {
InstrumentationHelper.Get().AFilterReverseIndex(false);
}
return;
}
if (InstrumentationHelper.ENABLED) {
InstrumentationHelper.Get().AFilterReverseIndex(true);
}
evaluator.MatchEvent(theEvent, matches, ctx);
}
public void EventEvaluatorNoRulesShouldReturnEvaluationTrue()
{
// Arrange
const string eventType = "MyEventType";
var rules = new List <Rule <Event> >(); // No rules
var myEvent = new Event
{
EventId = 100,
EventName = "MyEvent100",
EventType = eventType,
Priority = 1,
CreatedDate = DateTime.Now,
Properties = new Dictionary <string, string>
{
{ "prop1", "value1" },
{ "prop2", "value2" }
}
};
// Act
var eventEvaluator = new EventEvaluator(logger);
var result = eventEvaluator.EvaluateEvent(myEvent, rules);
// Assert
Assert.IsTrue(result);
}
public override void Remove(object filterConstant)
{
var range = (DoubleRange)filterConstant;
if (range.Max == null || range.Min == null)
{
RangesNullEndpoints = null;
return;
}
Ranges.Delete(range);
}
public override void Remove(object filterConstant)
{
var range = (StringRange)filterConstant;
if (range.Max == null || range.Min == null)
{
RangesNullEndpoints = null;
}
else
{
Ranges.Remove(range);
}
}
public override void Put(Object filterConstant, EventEvaluator matcher)
{
_constantsMap.Put(filterConstant, matcher);
// Update bounds
var constant = filterConstant.AsDouble();
if ((_lowerBounds == null) || (constant < _lowerBounds))
{
_lowerBounds = constant;
}
if ((_upperBounds == null) || (constant > _upperBounds))
{
_upperBounds = constant;
}
}
public override void Put(
object filterConstant,
EventEvaluator matcher)
{
constantsMap.Put(filterConstant, matcher);
// Update bounds
double constant = filterConstant.AsDouble();
if (lowerBounds == null || constant < lowerBounds) {
lowerBounds = constant;
}
if (upperBounds == null || constant > upperBounds) {
upperBounds = constant;
}
}
public override void Put(Object expressionValue, EventEvaluator matcher)
{
if (!(expressionValue is StringRange))
{
throw new ArgumentException("Supplied expressionValue must be of type DoubleRange");
}
var range = (StringRange)expressionValue;
if ((range.Max == null) || (range.Min == null))
{
_rangesNullEndpoints.Put(range, matcher); // endpoints null - we don't enter
return;
}
Ranges.Put(range, matcher);
}
public override void Remove(object filterConstant)
{
var keys = (HashableMultiKey) filterConstant;
// remove the mapping of value set to evaluator
EventEvaluator eval = evaluatorsMap.Delete(keys);
var keyValues = keys.Keys;
for (var i = 0; i < keyValues.Length; i++) {
var evaluators = constantsMap.Get(keyValues[i]);
if (evaluators != null) {
// could be removed already as same-value constants existed
evaluators.Remove(eval);
if (evaluators.IsEmpty()) {
constantsMap.Remove(keyValues[i]);
}
}
}
}
public override void Put(
object expressionValue,
EventEvaluator matcher)
{
if (!(expressionValue is StringRange))
{
throw new ArgumentException("Supplied expressionValue must be of type DoubleRange");
}
var range = (StringRange)expressionValue;
if (range.Max == null || range.Min == null)
{
RangesNullEndpoints = matcher;
return;
}
Ranges.Put(range, matcher);
}
public void EventEvaluatorRuleMatchExpressionNullShouldReturnEvaluationTrue()
{
// Arrange
const string eventType = "MyEventType";
var rules = new List <Rule <Event> >
{
new Rule <Event>
{
RuleId = 1,
RuleName = "Rule001",
EventType = eventType,
MatchExpression = null,
Rank = 1,
Enabled = true
}
};
var myEvent = new Event
{
EventId = 100,
EventName = "MyEvent100",
EventType = eventType,
Priority = 1,
CreatedDate = DateTime.Now,
Properties = new Dictionary <string, string>
{
{ "prop1", "value1" },
{ "prop2", "value2" }
}
};
// Act
var eventEvaluator = new EventEvaluator(logger);
var result = eventEvaluator.EvaluateEvent(myEvent, rules);
// Assert
Assert.IsTrue(result);
}
public override void Put(
object filterConstant,
EventEvaluator evaluator)
{
// Store evaluator keyed to set of values
var keys = (HashableMultiKey) filterConstant;
filterValueEvaluators.Put(keys, evaluator);
evaluatorsSet.Add(evaluator);
// Store each value to match against in Map with it's evaluator as a list
foreach (var keyValue in keys.Keys) {
var evaluators = constantsMap.Get(keyValue);
if (evaluators == null) {
evaluators = new HashSet<EventEvaluator>();
constantsMap.Put(keyValue, evaluators);
}
evaluators.Add(evaluator);
}
}
public void EventEvaluatorRulesNullShouldThrowInvalidInputException()
{
// Arrange
const string eventType = "MyEventType";
List <Rule <Event> > rules = null; // rules is null
var myEvent = new Event
{
EventId = 100,
EventName = "MyEvent100",
EventType = eventType,
Priority = 1,
CreatedDate = DateTime.Now,
Properties = new Dictionary <string, string>
{
{ "prop1", "value1" },
{ "prop2", "value2" }
}
};
// Act
var eventEvaluator = new EventEvaluator(logger);
try
{
var result = eventEvaluator.EvaluateEvent(myEvent, rules);
}
catch (ArgumentNullException ex)
{
// Assert
Assert.AreEqual("Value cannot be null.\r\nParameter name: rules", ex.Message);
}
}
public void EventEvaluatorEventNullShouldThrowInvalidInputException()
{
// Arrange
const string eventType = "MyEventType";
var rules = new List <Rule <Event> >
{
new Rule <Event>
{
RuleId = 1,
RuleName = "Rule001",
EventType = eventType,
MatchExpression = "p.Properties[\"prop2\"] == \"value2\"",
Rank = 1,
Enabled = true
}
};
Event myEvent = null; // myEvent is null
// Act
var eventEvaluator = new EventEvaluator(logger);
try
{
var result = eventEvaluator.EvaluateEvent(myEvent, rules);
}
catch (ArgumentNullException ex)
{
// Assert
Assert.AreEqual("Value cannot be null.\r\nParameter name: myEvent", ex.Message);
}
}
public override void Put(
object expressionValue,
EventEvaluator matcher)
{
if (!(expressionValue is DoubleRange))
{
throw new ArgumentException("Supplied expressionValue must be of type DoubleRange");
}
var range = (DoubleRange)expressionValue;
if (range.Max == null || range.Min == null)
{
RangesNullEndpoints = matcher;
return;
}
if (Math.Abs(range.Max.Value - range.Min.Value) > LargestRangeValueDouble)
{
LargestRangeValueDouble = Math.Abs(range.Max.Value - range.Min.Value);
}
Ranges.Put(range, matcher);
}
public override void Put(Object expressionValue, EventEvaluator evaluator)
{
}
public override void Put(
object filterConstant,
EventEvaluator evaluator)
{
ConstantsMap.Put(filterConstant, evaluator);
}
// Remove filterCallback from index, returning true if index empty after removal
private static bool RemoveFromIndex(
FilterHandle filterCallback,
FilterParamIndexBase index,
EventTypeIndexBuilderIndexLookupablePair[] treePathInfo,
int treePathPosition,
Object filterForValue)
{
using (index.ReadWriteLock.AcquireWriteLock())
{
EventEvaluator eventEvaluator = index[filterForValue];
if (eventEvaluator == null)
{
Log.Warn(".removeFromIndex ({0}) Could not find the filterCallback value in index, index={1} value={2} filterCallback={3}",
Thread.CurrentThread.ManagedThreadId, index, filterForValue, filterCallback);
return(false);
}
if (eventEvaluator is FilterHandleSetNode)
{
var node = (FilterHandleSetNode)eventEvaluator;
var isEmptyX = RemoveFromNode(filterCallback, node, treePathInfo, treePathPosition);
if (isEmptyX)
{
// Since we are holding a write lock to this index, there should not be a chance that
// another thread had been adding anything to this FilterHandleSetNode
index.Remove(filterForValue);
}
return(index.Count == 0);
}
var nextIndex = (FilterParamIndexBase)eventEvaluator;
var nextPair = treePathPosition < treePathInfo.Length ? treePathInfo[treePathPosition++] : null;
if (nextPair == null)
{
Log.Fatal(".removeFromIndex Expected an inner index to this index, this=" + filterCallback);
Debug.Assert(false);
return(false);
}
if (nextPair.Index != nextIndex)
{
Log.Fatal(".removeFromIndex Expected an index for filterCallback that differs from the found index, this=" + filterCallback +
" expected=" + nextPair.Index);
Debug.Assert(false);
return(false);
}
var nextExpressionValue = nextPair.Lookupable;
var isEmpty = RemoveFromIndex(filterCallback, nextPair.Index, treePathInfo, treePathPosition, nextExpressionValue);
if (isEmpty)
{
// Since we are holding a write lock to this index, there should not be a chance that
// another thread had been adding anything to this FilterHandleSetNode
index.Remove(filterForValue);
}
var size = index.Count;
return(size == 0);
}
}
public override void MatchEvent(EventBean theEvent, ICollection <FilterHandle> matches)
{
var propertyValue = Lookupable.Getter.Get(theEvent);
var returnValue = new Mutable <bool?>(false);
using (Instrument.With(
i => i.QFilterReverseIndex(this, propertyValue),
i => i.AFilterReverseIndex(returnValue.Value)))
{
if (propertyValue == null)
{
return;
}
// A undefine lower bound indicates an empty index
if (_lowerBounds == null)
{
return;
}
var filterOperator = FilterOperator;
var propertyValueDouble = propertyValue.AsDouble();
// Based on current lower and upper bounds check if the property value falls outside - shortcut submap generation
if ((filterOperator == FilterOperator.GREATER) && (propertyValueDouble <= _lowerBounds))
{
return;
}
else if ((filterOperator == FilterOperator.GREATER_OR_EQUAL) && (propertyValueDouble < _lowerBounds))
{
return;
}
else if ((filterOperator == FilterOperator.LESS) && (propertyValueDouble >= _upperBounds))
{
return;
}
else if ((filterOperator == FilterOperator.LESS_OR_EQUAL) && (propertyValueDouble > _upperBounds))
{
return;
}
// Look up in table
using (_constantsMapRwLock.AcquireReadLock())
{
// Get the head or tail end of the map depending on comparison type
IDictionary <Object, EventEvaluator> subMap;
if ((filterOperator == FilterOperator.GREATER) ||
(filterOperator == FilterOperator.GREATER_OR_EQUAL))
{
// At the head of the map are those with a lower numeric constants
subMap = _constantsMap.Head(propertyValue);
}
else
{
subMap = _constantsMap.Tail(propertyValue);
}
// All entries in the subMap are elgibile, with an exception
EventEvaluator exactEquals = null;
if (filterOperator == FilterOperator.LESS)
{
exactEquals = _constantsMap.Get(propertyValue);
}
foreach (EventEvaluator matcher in subMap.Values)
{
// For the LESS comparison type we ignore the exactly equal case
// The subMap is sorted ascending, thus the exactly equals case is the first
if (exactEquals != null)
{
exactEquals = null;
continue;
}
matcher.MatchEvent(theEvent, matches);
}
if (filterOperator == FilterOperator.GREATER_OR_EQUAL)
{
EventEvaluator matcher = _constantsMap.Get(propertyValue);
if (matcher != null)
{
matcher.MatchEvent(theEvent, matches);
}
}
}
returnValue.Value = null;
}
}
public override void Put(Object filterConstant, EventEvaluator matcher)
{
_constantsMap.Put(filterConstant, matcher);
}
public override void Put(object filterConstant, EventEvaluator evaluator) {
var rect = (XYWHRectangle) filterConstant;
MXCIFQuadTreeFilterIndexSet<EventEvaluator>.Set(rect.X, rect.Y, rect.W, rect.H, evaluator, _quadTree);
}
/// <summary> /// Store the event evaluation instance for the given constant. Can override an existing value for /// the same constant. The calling class must make sure that access to the underlying resource is /// protected for multi-threaded access, the GetReadWriteLock() method must supply a lock for this /// purpose. /// </summary> /// <param name="filterConstant">is the constant supplied in the filter parameter</param> /// <param name="evaluator">to be stored for the constant</param> public abstract void Put(Object filterConstant, EventEvaluator evaluator);
public override void Put(object filterConstant, EventEvaluator evaluator)
{
var point = (XYPoint) filterConstant;
PointRegionQuadTreeFilterIndexSet<EventEvaluator>.Set(point.X, point.Y, evaluator, _quadTree);
}
/// <summary>
/// Store the event evaluation instance for the given constant. Can override an existing value for
/// the same constant. The calling class must make sure that access to the underlying resource is
/// protected for multi-threaded access, the GetReadWriteLock() method must supply a lock for this
/// purpose.
/// </summary>
/// <param name="filterConstant">is the constant supplied in the filter parameter</param>
/// <param name="evaluator">to be stored for the constant</param>
public abstract override void Put(
object filterConstant,
EventEvaluator evaluator);
public void EventEvaluatorShouldReturnEvaluationFalse()
{
// Arrange
const string eventType = "MyEventType";
var rules = new List <Rule <Event> >
{
new Rule <Event>
{
RuleId = 1,
RuleName = "Rule001",
EventType = eventType,
MatchExpression = "p.Priority == 1",
Rank = 1,
Enabled = true
},
new Rule <Event>
{
RuleId = 2,
RuleName = "Rule002",
EventType = eventType,
MatchExpression = "p.EventName == \"MyEvent100\"",
Rank = 2,
Enabled = true
},
new Rule <Event>
{
RuleId = 3,
RuleName = "Rule003",
EventType = eventType,
MatchExpression = "p.Properties[\"prop1\"] == \"value10\"", // false
Rank = 3,
Enabled = true
},
new Rule <Event>
{
RuleId = 4,
RuleName = "Rule004",
EventType = eventType,
MatchExpression = "p.Properties[\"prop2\"] == \"value2\"",
Rank = 4,
Enabled = true
},
};
var myEvent = new Event
{
EventId = 100,
EventName = "MyEvent100",
EventType = eventType,
Priority = 1,
CreatedDate = DateTime.Now,
Properties = new Dictionary <string, string>
{
{ "prop1", "value1" },
{ "prop2", "value2" }
}
};
// Act
var eventEvaluator = new EventEvaluator(logger);
var result = eventEvaluator.EvaluateEvent(myEvent, rules);
// Assert
Assert.IsFalse(result);
}
