public override void Start(MatchedEventMap beginState)
{
var agentInstanceContext = _evalFilterNode.Context.AgentInstanceContext;
agentInstanceContext.InstrumentationProvider.QPatternFilterStart(_evalFilterNode.factoryNode, beginState);
_beginState = beginState;
if (_isStarted) {
throw new IllegalStateException("Filter state node already active");
}
agentInstanceContext.AuditProvider.PatternInstance(true, _evalFilterNode.factoryNode, agentInstanceContext);
// Start the filter
_isStarted = true;
var filterService = _evalFilterNode.Context.FilterService;
_handle = new EPStatementHandleCallbackFilter(
_evalFilterNode.Context.AgentInstanceContext.EpStatementAgentInstanceHandle,
this);
var filterSpec = _evalFilterNode.FactoryNode.FilterSpec;
var filterValues = filterSpec.GetValueSet(
beginState,
_evalFilterNode.AddendumFilters,
agentInstanceContext,
agentInstanceContext.StatementContextFilterEvalEnv);
if (filterValues != null) {
filterService.Add(filterSpec.FilterForEventType, filterValues, _handle);
var filtersVersion = filterService.FiltersVersion;
_evalFilterNode.Context.AgentInstanceContext.EpStatementAgentInstanceHandle.StatementFilterVersion
.StmtFilterVersion = filtersVersion;
}
agentInstanceContext.InstrumentationProvider.APatternFilterStart();
}
public ContextControllerHashFilterEntry(
ContextControllerHashImpl callback,
IntSeqKey controllerPath,
ContextControllerDetailHashItem item,
object[] parentPartitionKeys)
{
this.callback = callback;
this.controllerPath = controllerPath;
this.item = item;
AgentInstanceContext agentInstanceContext = callback.AgentInstanceContextCreate;
this.filterHandle = new EPStatementHandleCallbackFilter(
agentInstanceContext.EpStatementAgentInstanceHandle,
this);
FilterValueSetParam[][] addendum = ContextManagerUtil.ComputeAddendumNonStmt(
parentPartitionKeys,
item.FilterSpecActivatable,
callback.Realization);
this.filterValueSet = item.FilterSpecActivatable.GetValueSet(
null,
addendum,
agentInstanceContext,
agentInstanceContext.StatementContextFilterEvalEnv);
agentInstanceContext.FilterService.Add(
item.FilterSpecActivatable.FilterForEventType,
filterValueSet,
filterHandle);
long filtersVersion = agentInstanceContext.FilterService.FiltersVersion;
agentInstanceContext.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion =
filtersVersion;
}
public void Deactivate()
{
if (filterHandle == null) {
return;
}
AgentInstanceContext agentInstanceContext = controller.Realization.AgentInstanceContextCreate;
FilterValueSetParam[][] addendum = ContextManagerUtil.ComputeAddendumNonStmt(
partitionKeys,
filter.FilterSpecActivatable,
controller.Realization);
FilterValueSetParam[][] filterValueSet = filter.FilterSpecActivatable.GetValueSet(
null,
addendum,
agentInstanceContext,
agentInstanceContext.StatementContextFilterEvalEnv);
agentInstanceContext.FilterService.Remove(
filterHandle,
filter.FilterSpecActivatable.FilterForEventType,
filterValueSet);
filterHandle = null;
long filtersVersion = agentInstanceContext.StatementContext.FilterService.FiltersVersion;
agentInstanceContext.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion =
filtersVersion;
}
public void VisitFilter(
EvalFilterFactoryNode factoryNode,
EvalStateNode stateNode,
EPStatementHandleCallbackFilter handle,
MatchedEventMap beginState)
{
stateNode.Transfer(services);
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="epRuntime">runtime to process</param>
/// <param name="handleCallback">callback</param>
/// <param name="theEvent">event</param>
/// <param name="filterVersion">version of filter</param>
public RouteUnitSingle(
EPEventServiceImpl epRuntime,
EPStatementHandleCallbackFilter handleCallback,
EventBean theEvent,
long filterVersion)
{
this.epRuntime = epRuntime;
this.theEvent = theEvent;
this.handleCallback = handleCallback;
this.filterVersion = filterVersion;
}
public void AddFilterCallback(
FilterHandleCallback filterHandleCallback,
AgentInstanceContext agentInstanceContext,
EventType eventType,
FilterValueSetParam[][] @params,
int filterCallbackId)
{
var handle = new EPStatementHandleCallbackFilter(
agentInstanceContext.EpStatementAgentInstanceHandle,
filterHandleCallback);
agentInstanceContext.FilterService.Add(eventType, @params, handle);
handlesPerOp.Put(filterHandleCallback, handle);
}
protected void Stop(FilterSpecActivatable activatable)
{
if (filterHandle == null) {
return;
}
var agentInstanceContext = callback.AgentInstanceContextCreate;
agentInstanceContext.FilterService.Remove(filterHandle, activatable.FilterForEventType, filterValueSet);
var filtersVersion = agentInstanceContext.FilterService.FiltersVersion;
agentInstanceContext.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion =
filtersVersion;
filterHandle = null;
filterValueSet = null;
}
public bool Activate(
EventBean optionalTriggeringEvent,
ContextControllerEndConditionMatchEventProvider endConditionMatchEventProvider)
{
AgentInstanceContext agentInstanceContext = controller.Realization.AgentInstanceContextCreate;
FilterHandleCallback filterCallback = new ProxyFilterHandleCallback() {
ProcMatchFound = (
theEvent,
allStmtMatches) => FilterMatchFound(theEvent),
ProcIsSubselect = () => false,
};
FilterValueSetParam[][] addendum = ContextManagerUtil.ComputeAddendumNonStmt(
partitionKeys,
filter.FilterSpecActivatable,
controller.Realization);
filterHandle = new EPStatementHandleCallbackFilter(
agentInstanceContext.EpStatementAgentInstanceHandle,
filterCallback);
FilterValueSetParam[][] filterValueSet = filter.FilterSpecActivatable.GetValueSet(
null,
addendum,
agentInstanceContext,
agentInstanceContext.StatementContextFilterEvalEnv);
agentInstanceContext.FilterService.Add(
filter.FilterSpecActivatable.FilterForEventType,
filterValueSet,
filterHandle);
long filtersVersion = agentInstanceContext.FilterService.FiltersVersion;
agentInstanceContext.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion =
filtersVersion;
bool match = false;
if (optionalTriggeringEvent != null) {
match = AgentInstanceUtil.EvaluateFilterForStatement(
optionalTriggeringEvent,
agentInstanceContext,
filterHandle);
}
return match;
}
public void Deactivate()
{
if (filterHandle == null) {
return;
}
var agentInstanceContext = controller.Realization.AgentInstanceContextCreate;
var filterValueSet = ComputeFilterValues(agentInstanceContext);
if (filterValueSet != null) {
agentInstanceContext.FilterService.Remove(
filterHandle,
filter.FilterSpecActivatable.FilterForEventType,
filterValueSet);
var filtersVersion = agentInstanceContext.StatementContext.FilterService.FiltersVersion;
agentInstanceContext.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion =
filtersVersion;
}
filterHandle = null;
}
private void StopFiltering()
{
var agentInstanceContext = _evalFilterNode.Context.AgentInstanceContext;
var filterSpec = _evalFilterNode.FactoryNode.FilterSpec;
var filterValues = filterSpec.GetValueSet(
_beginState,
_evalFilterNode.AddendumFilters,
agentInstanceContext,
agentInstanceContext.StatementContextFilterEvalEnv);
var filterService = _evalFilterNode.Context.FilterService;
if (_handle != null && filterValues != null) {
filterService.Remove(_handle, filterSpec.FilterForEventType, filterValues);
var filtersVersionX = filterService.FiltersVersion;
_evalFilterNode.Context.AgentInstanceContext.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion = filtersVersionX;
}
_handle = null;
_isStarted = false;
var filtersVersion = filterService.FiltersVersion;
_evalFilterNode.Context.AgentInstanceContext.EpStatementAgentInstanceHandle.StatementFilterVersion
.StmtFilterVersion = filtersVersion;
}
private static void Process(
AgentInstance agentInstance,
ICollection<FilterHandle> callbacks,
EventBean theEvent)
{
AgentInstanceContext agentInstanceContext = agentInstance.AgentInstanceContext;
using (agentInstance.AgentInstanceContext.AgentInstanceLock.AcquireWriteLock()) {
try {
agentInstance.AgentInstanceContext.VariableManagementService.SetLocalVersion();
// sub-selects always go first
foreach (FilterHandle handle in callbacks) {
EPStatementHandleCallbackFilter callback = (EPStatementHandleCallbackFilter) handle;
if (callback.AgentInstanceHandle != agentInstanceContext.EpStatementAgentInstanceHandle) {
continue;
}
callback.FilterCallback.MatchFound(theEvent, null);
}
agentInstanceContext.EpStatementAgentInstanceHandle.InternalDispatch();
}
catch (EPException) {
throw;
}
catch (Exception ex) {
agentInstanceContext.ExceptionHandlingService.HandleException(
ex,
agentInstanceContext.EpStatementAgentInstanceHandle,
ExceptionHandlerExceptionType.PROCESS,
theEvent);
}
finally {
if (agentInstanceContext.StatementContext.EpStatementHandle.HasTableAccess) {
agentInstanceContext.TableExprEvaluatorContext.ReleaseAcquiredLocks();
}
}
}
}
public bool Activate(
EventBean optionalTriggeringEvent,
ContextControllerEndConditionMatchEventProvider endConditionMatchEventProvider,
IDictionary<string, object> optionalTriggeringPattern)
{
var agentInstanceContext = controller.Realization.AgentInstanceContextCreate;
FilterHandleCallback filterCallback = new ProxyFilterHandleCallback() {
ProcMatchFound = (
theEvent,
allStmtMatches) => FilterMatchFound(theEvent),
ProcIsSubselect = () => false,
};
filterHandle = new EPStatementHandleCallbackFilter(
agentInstanceContext.EpStatementAgentInstanceHandle,
filterCallback);
var filterValueSet = ComputeFilterValues(agentInstanceContext);
if (filterValueSet != null) {
agentInstanceContext.FilterService.Add(
filter.FilterSpecActivatable.FilterForEventType,
filterValueSet,
filterHandle);
var filtersVersion = agentInstanceContext.FilterService.FiltersVersion;
agentInstanceContext.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion = filtersVersion;
}
var match = false;
if (optionalTriggeringEvent != null) {
match = AgentInstanceUtil.EvaluateFilterForStatement(
optionalTriggeringEvent,
agentInstanceContext,
filterHandle);
}
return match;
}
protected void Start(FilterSpecActivatable activatable)
{
if (filterHandle != null) {
throw new IllegalStateException("Already started");
}
var agentInstanceContext = callback.AgentInstanceContextCreate;
filterHandle = new EPStatementHandleCallbackFilter(
agentInstanceContext.EpStatementAgentInstanceHandle,
this);
var addendum = ContextManagerUtil.ComputeAddendumNonStmt(
parentPartitionKeys,
activatable,
callback.Realization);
filterValueSet = activatable.GetValueSet(
null,
addendum,
agentInstanceContext,
agentInstanceContext.StatementContextFilterEvalEnv);
agentInstanceContext.FilterService.Add(activatable.FilterForEventType, filterValueSet, filterHandle);
var filtersVersion = agentInstanceContext.FilterService.FiltersVersion;
agentInstanceContext.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion =
filtersVersion;
}
public ViewableActivationResult Activate(
AgentInstanceContext agentInstanceContext,
bool isSubselect,
bool isRecoveringResilient)
{
FilterValueSetParam[][] addendum = null;
if (agentInstanceContext.AgentInstanceFilterProxy != null) {
addendum = agentInstanceContext.AgentInstanceFilterProxy.GetAddendumFilters(
FilterSpec,
agentInstanceContext);
}
var filterValues = FilterSpec.GetValueSet(
null,
addendum,
agentInstanceContext,
agentInstanceContext.StatementContextFilterEvalEnv);
EventStream theStream;
if (!agentInstanceContext.AuditProvider.Activated() &&
!agentInstanceContext.InstrumentationProvider.Activated()) {
theStream = CanIterate
? new ZeroDepthStreamIterable(FilterSpec.ResultEventType)
: (EventStream) new ZeroDepthStreamNoIterate(FilterSpec.ResultEventType);
}
else {
var streamNum = StreamNumFromClause ?? -1;
theStream = CanIterate
? new ZeroDepthStreamIterableWAudit(
FilterSpec.ResultEventType,
agentInstanceContext,
FilterSpec,
streamNum,
isSubselect,
SubselectNumber)
: (EventStream) new ZeroDepthStreamNoIterateWAudit(
FilterSpec.ResultEventType,
agentInstanceContext,
FilterSpec,
streamNum,
isSubselect,
SubselectNumber);
}
var statementId = agentInstanceContext.StatementId;
FilterHandleCallback filterCallback;
if (FilterSpec.OptionalPropertyEvaluator == null) {
filterCallback = new ProxyFilterHandleCallback {
ProcMatchFound = (
theEvent,
allStmtMatches) => theStream.Insert(theEvent),
ProcIsSubselect = () => IsSubSelect
};
}
else {
filterCallback = new ProxyFilterHandleCallback {
ProcMatchFound = (
theEvent,
allStmtMatches) => {
var result = FilterSpec.OptionalPropertyEvaluator.GetProperty(theEvent, agentInstanceContext);
if (result == null) {
return;
}
theStream.Insert(result);
},
ProcIsSubselect = () => IsSubSelect
};
}
var filterHandle = new EPStatementHandleCallbackFilter(
agentInstanceContext.EpStatementAgentInstanceHandle,
filterCallback);
agentInstanceContext.StatementContext.StatementContextRuntimeServices.FilterService.Add(
FilterSpec.FilterForEventType,
filterValues,
filterHandle);
var filterStopCallback = new ViewableActivatorFilterStopCallback(Container, filterHandle, FilterSpec);
return new ViewableActivationResult(theStream, filterStopCallback, null, false, false, null, null);
}
public void EvaluateEventForStatement(
EventBean theEvent,
IList<AgentInstance> agentInstances,
AgentInstanceContext agentInstanceContextCreate)
{
// context was created - reevaluate for the given event
ArrayDeque<FilterHandle> callbacks = new ArrayDeque<FilterHandle>(2);
agentInstanceContextCreate.FilterService.Evaluate(theEvent, callbacks, agentInstanceContextCreate); // evaluates for ALL statements
if (callbacks.IsEmpty()) {
return;
}
// there is a single callback and a single context, if they match we are done
if (agentInstances.Count == 1 && callbacks.Count == 1) {
AgentInstance agentInstance = agentInstances[0];
AgentInstanceContext agentInstanceContext = agentInstance.AgentInstanceContext;
FilterHandle callback = callbacks.First;
if (agentInstanceContext.StatementId == callback.StatementId &&
agentInstanceContext.AgentInstanceId == callback.AgentInstanceId) {
Process(agentInstance, callbacks, theEvent);
}
return;
}
// use the right sorted/unsorted Map keyed by AgentInstance to sort
bool isPrioritized = agentInstanceContextCreate.RuntimeSettingsService.ConfigurationRuntime.Execution
.IsPrioritized;
IDictionary<AgentInstance, object> stmtCallbacks;
if (!isPrioritized) {
stmtCallbacks = new Dictionary<AgentInstance, object>();
}
else {
stmtCallbacks = new OrderedListDictionary<AgentInstance, object>(AgentInstanceComparator.INSTANCE);
}
// process all callbacks
foreach (FilterHandle filterHandle in callbacks) {
EPStatementHandleCallbackFilter handleCallback = (EPStatementHandleCallbackFilter) filterHandle;
// determine if this filter entry applies to any of the affected agent instances
int statementId = filterHandle.StatementId;
AgentInstance agentInstanceFound = null;
foreach (AgentInstance agentInstance in agentInstances) {
AgentInstanceContext agentInstanceContext = agentInstance.AgentInstanceContext;
if (agentInstanceContext.StatementId == statementId &&
agentInstanceContext.AgentInstanceId == handleCallback.AgentInstanceId) {
agentInstanceFound = agentInstance;
break;
}
}
if (agentInstanceFound == null) { // when the callback is for some other stmt
continue;
}
EPStatementAgentInstanceHandle handle = handleCallback.AgentInstanceHandle;
// Self-joins require that the internal dispatch happens after all streams are evaluated.
// Priority or preemptive settings also require special ordering.
if (handle.IsCanSelfJoin || isPrioritized) {
var stmtCallback = stmtCallbacks.Get(agentInstanceFound);
if (stmtCallback == null) {
stmtCallbacks.Put(agentInstanceFound, handleCallback);
}
else if (stmtCallback is ArrayDeque<FilterHandle> callbackFilterDeque) {
if (!callbackFilterDeque.Contains(handleCallback)) {
// De-duplicate for Filter OR expression paths
callbackFilterDeque.Add(handleCallback);
}
}
else {
var filterDeque = new ArrayDeque<FilterHandle>(4);
filterDeque.Add((FilterHandle) stmtCallback);
if (stmtCallback != handleCallback) { // De-duplicate for Filter OR expression paths
filterDeque.Add(handleCallback);
}
stmtCallbacks.Put(agentInstanceFound, filterDeque);
}
continue;
}
// no need to be sorted, process
Process(agentInstanceFound, Collections.SingletonList<FilterHandle>(handleCallback), theEvent);
}
if (stmtCallbacks.IsEmpty()) {
return;
}
// Process self-join or sorted prioritized callbacks
foreach (KeyValuePair<AgentInstance, object> entry in stmtCallbacks) {
AgentInstance agentInstance = entry.Key;
object callbackList = entry.Value;
if (callbackList is ICollection<FilterHandle> filterHandleCollection) {
Process(agentInstance, filterHandleCollection, theEvent);
}
else {
Process(
agentInstance,
Collections.SingletonList<FilterHandle>((FilterHandle) callbackList),
theEvent);
}
if (agentInstance.AgentInstanceContext.EpStatementAgentInstanceHandle.IsPreemptive) {
return;
}
}
}
