public void Activate(EventBean optionalTriggeringEvent, IDictionary <String, Object> optionalTriggeringPattern, ContextControllerState controllerState, ContextInternalFilterAddendum filterAddendum, int?importPathId)
{
var factoryContext = _factory.FactoryContext;
_activationFilterAddendum = filterAddendum;
foreach (var item in _factory.SegmentedSpec.Items)
{
var callback = new ContextControllerPartitionedFilterCallback(factoryContext.ServicesContext, factoryContext.AgentInstanceContextCreate, item, this, filterAddendum);
_filterCallbacks.Add(callback);
if (optionalTriggeringEvent != null)
{
var match = StatementAgentInstanceUtil.EvaluateFilterForStatement(factoryContext.ServicesContext, optionalTriggeringEvent, factoryContext.AgentInstanceContextCreate, callback.FilterHandle);
if (match)
{
callback.MatchFound(optionalTriggeringEvent, null);
}
}
}
if (factoryContext.NestingLevel == 1)
{
controllerState = ContextControllerStateUtil.GetRecoveryStates(_factory.FactoryContext.StateCache, factoryContext.OutermostContextName);
}
if (controllerState == null)
{
return;
}
int?pathIdToUse = importPathId ?? _pathId;
InitializeFromState(optionalTriggeringEvent, optionalTriggeringPattern, filterAddendum, controllerState, pathIdToUse.Value, null, false);
}
public ContextControllerInstanceHandle ContextPartitionInstantiate(
int?optionalContextPartitionId,
int subPathId,
int?importSubpathId,
ContextController originator,
EventBean optionalTriggeringEvent,
IDictionary <string, object> optionalTriggeringPattern,
object partitionKey,
IDictionary <string, object> contextProperties,
ContextControllerState states,
ContextInternalFilterAddendum filterAddendum,
bool isRecoveringResilient,
ContextPartitionState state)
{
using (_uLock.Acquire()) {
// assign context id
int assignedContextId;
if (optionalContextPartitionId != null && !states.IsImported)
{
assignedContextId = optionalContextPartitionId.Value;
_contextPartitionIdManager.AddExisting(optionalContextPartitionId.Value);
}
else
{
assignedContextId = _contextPartitionIdManager.AllocateId();
if (states != null && states.PartitionImportCallback != null && optionalContextPartitionId != null)
{
states.PartitionImportCallback.Allocated(assignedContextId, optionalContextPartitionId.Value);
}
}
// handle leaf creation
IList <AgentInstance> newInstances = new List <AgentInstance>();
if (state == ContextPartitionState.STARTED)
{
foreach (var statementEntry in _statements)
{
var statementDesc = statementEntry.Value;
var instance = StartStatement(assignedContextId, statementDesc, originator, partitionKey, contextProperties, isRecoveringResilient);
newInstances.Add(instance);
}
}
// for all new contexts: evaluate this event for this statement
if (optionalTriggeringEvent != null || optionalTriggeringPattern != null)
{
StatementAgentInstanceUtil.EvaluateEventForStatement(_servicesContext, optionalTriggeringEvent, optionalTriggeringPattern, newInstances);
}
// save leaf
var filterVersion = _servicesContext.FilterService.FiltersVersion;
var agentInstanceList = new ContextControllerTreeAgentInstanceList(filterVersion, partitionKey, contextProperties, newInstances, state);
_agentInstances.Put(assignedContextId, agentInstanceList);
// Update the filter version for this handle
_factory.FactoryContext.AgentInstanceContextCreate.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion = filterVersion;
return(new ContextNestedHandleImpl(subPathId, assignedContextId, agentInstanceList));
}
}
public void Create(int id, EventBean theEvent)
{
lock (this)
{
ContextControllerFactoryContext factoryContext = _factory.FactoryContext;
if (_partitionKeys.ContainsKey(id))
{
return;
}
IDictionary <String, Object> properties = ContextPropertyEventType.GetHashBean(factoryContext.ContextName, id);
_currentSubpathId++;
// merge filter addendum, if any
ContextInternalFilterAddendum filterAddendumToUse = _activationFilterAddendum;
if (_factory.HasFiltersSpecsNestedContexts)
{
filterAddendumToUse = _activationFilterAddendum != null?_activationFilterAddendum.DeepCopy() : new ContextInternalFilterAddendum();
_factory.PopulateContextInternalFilterAddendums(filterAddendumToUse, id);
}
ContextControllerInstanceHandle handle = _activationCallback.ContextPartitionInstantiate(null, _currentSubpathId, null, this, theEvent, null, id, properties, null, filterAddendumToUse, _factory.FactoryContext.IsRecoveringResilient, ContextPartitionState.STARTED);
_partitionKeys.Put(id, handle);
_factory.FactoryContext.StateCache.AddContextPath(factoryContext.OutermostContextName, factoryContext.NestingLevel, _pathId, _currentSubpathId, handle.ContextPartitionOrPathId, id, _factory.Binding);
// update the filter version for this handle
long filterVersion = factoryContext.ServicesContext.FilterService.FiltersVersion;
_factory.FactoryContext.AgentInstanceContextCreate.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion = filterVersion;
}
}
public void PopulateContextInternalFilterAddendums(ContextInternalFilterAddendum filterAddendum, object key)
{
var assignedContextPartition = key.AsInt();
var code = assignedContextPartition % _hashedSpec.Granularity;
GetAddendumFilters(filterAddendum.FilterAddendum, code, _filtersSpecsNestedContexts, _hashedSpec, null);
}
public static ContextControllerCondition GetEndpoint(String contextName,
EPServicesContext servicesContext,
AgentInstanceContext agentInstanceContext,
ContextDetailCondition endpoint,
ContextControllerConditionCallback callback,
ContextInternalFilterAddendum filterAddendum,
bool isStartEndpoint,
int nestingLevel,
int pathId,
int subpathId) {
if (endpoint is ContextDetailConditionCrontab) {
var crontab = (ContextDetailConditionCrontab) endpoint;
var scheduleSlot = agentInstanceContext.StatementContext.ScheduleBucket.AllocateSlot();
return new ContextControllerConditionCrontab(agentInstanceContext.StatementContext, scheduleSlot, crontab, callback, filterAddendum);
}
else if (endpoint is ContextDetailConditionFilter) {
var filter = (ContextDetailConditionFilter) endpoint;
return new ContextControllerConditionFilter(servicesContext, agentInstanceContext, filter, callback, filterAddendum);
}
else if (endpoint is ContextDetailConditionPattern) {
var key = new ContextStatePathKey(nestingLevel, pathId, subpathId);
var pattern = (ContextDetailConditionPattern) endpoint;
return new ContextControllerConditionPattern(servicesContext, agentInstanceContext, pattern, callback, filterAddendum, isStartEndpoint, key);
}
else if (endpoint is ContextDetailConditionTimePeriod) {
var timePeriod = (ContextDetailConditionTimePeriod) endpoint;
var scheduleSlot = agentInstanceContext.StatementContext.ScheduleBucket.AllocateSlot();
return new ContextControllerConditionTimePeriod(contextName, agentInstanceContext, scheduleSlot, timePeriod, callback, filterAddendum);
}
else if (endpoint is ContextDetailConditionImmediate) {
return new ContextControllerConditionImmediate();
}
throw new IllegalStateException("Unrecognized context range endpoint " + endpoint.GetType());
}
public void ImportContextPartitions(
ContextControllerState state,
int pathIdToUse,
ContextInternalFilterAddendum filterAddendum,
AgentInstanceSelector agentInstanceSelector)
{
InitializeFromState(null, null, filterAddendum, state, pathIdToUse, agentInstanceSelector);
}
public void PopulateContextInternalFilterAddendums(ContextInternalFilterAddendum filterAddendum, object key)
{
if (_filtersSpecsNestedContexts == null || _filtersSpecsNestedContexts.IsEmpty())
{
return;
}
ContextControllerPartitionedUtil.PopulateAddendumFilters(key, _filtersSpecsNestedContexts, _segmentedSpec, null, filterAddendum.FilterAddendum);
}
public ContextControllerConditionCrontab(StatementContext statementContext, ScheduleSlot scheduleSlot, ContextDetailConditionCrontab spec, ContextControllerConditionCallback callback, ContextInternalFilterAddendum filterAddendum)
{
_statementContext = statementContext;
_scheduleSlot = scheduleSlot;
_spec = spec;
_callback = callback;
_filterAddendum = filterAddendum;
}
public ContextControllerConditionFilter(EPServicesContext servicesContext, AgentInstanceContext agentInstanceContext, ContextDetailConditionFilter endpointFilterSpec, ContextControllerConditionCallback callback, ContextInternalFilterAddendum filterAddendum)
{
_servicesContext = servicesContext;
_agentInstanceContext = agentInstanceContext;
_endpointFilterSpec = endpointFilterSpec;
_callback = callback;
_filterAddendum = filterAddendum;
}
public void Activate(EventBean optionalTriggeringEvent, IDictionary <String, Object> optionalTriggeringPattern, ContextControllerState controllerState, ContextInternalFilterAddendum activationFilterAddendum, int?importPathId)
{
ContextControllerFactoryContext factoryContext = _factory.FactoryContext;
_activationFilterAddendum = activationFilterAddendum;
if (factoryContext.NestingLevel == 1)
{
controllerState = ContextControllerStateUtil.GetRecoveryStates(_factory.FactoryContext.StateCache, factoryContext.OutermostContextName);
}
if (controllerState == null)
{
// handle preallocate
if (_factory.HashedSpec.IsPreallocate)
{
for (int i = 0; i < _factory.HashedSpec.Granularity; i++)
{
var properties = ContextPropertyEventType.GetHashBean(factoryContext.ContextName, i);
_currentSubpathId++;
// merge filter addendum, if any
var filterAddendumToUse = activationFilterAddendum;
if (_factory.HasFiltersSpecsNestedContexts)
{
filterAddendumToUse = activationFilterAddendum != null?activationFilterAddendum.DeepCopy() : new ContextInternalFilterAddendum();
_factory.PopulateContextInternalFilterAddendums(filterAddendumToUse, i);
}
ContextControllerInstanceHandle handle = _activationCallback.ContextPartitionInstantiate(null, _currentSubpathId, null, this, optionalTriggeringEvent, null, i, properties, controllerState, filterAddendumToUse, _factory.FactoryContext.IsRecoveringResilient, ContextPartitionState.STARTED);
_partitionKeys.Put(i, handle);
_factory.FactoryContext.StateCache.AddContextPath(
_factory.FactoryContext.OutermostContextName,
_factory.FactoryContext.NestingLevel,
_pathId, _currentSubpathId, handle.ContextPartitionOrPathId, i,
_factory.Binding);
}
return;
}
// start filters if not preallocated
ActivateFilters(optionalTriggeringEvent);
return;
}
// initialize from existing state
int pathIdToUse = importPathId ?? _pathId;
InitializeFromState(optionalTriggeringEvent, optionalTriggeringPattern, controllerState, pathIdToUse, null, false);
// activate filters
if (!_factory.HashedSpec.IsPreallocate)
{
ActivateFilters(null);
}
}
public ContextControllerConditionPattern(EPServicesContext servicesContext, AgentInstanceContext agentInstanceContext, ContextDetailConditionPattern endpointPatternSpec, ContextControllerConditionCallback callback, ContextInternalFilterAddendum filterAddendum, bool startEndpoint, ContextStatePathKey contextStatePathKey)
{
_servicesContext = servicesContext;
_agentInstanceContext = agentInstanceContext;
_endpointPatternSpec = endpointPatternSpec;
_callback = callback;
_filterAddendum = filterAddendum;
_isStartEndpoint = startEndpoint;
_contextStatePathKey = contextStatePathKey;
}
public void Activate(
EventBean optionalTriggeringEvent,
IDictionary <String, Object> optionalTriggeringPattern,
ContextControllerState controllerState,
ContextInternalFilterAddendum activationFilterAddendum,
int?importPathId)
{
if (Factory.FactoryContext.NestingLevel == 1)
{
controllerState = ContextControllerStateUtil.GetRecoveryStates(
Factory.StateCache, Factory.FactoryContext.OutermostContextName);
}
if (controllerState == null)
{
var count = 0;
foreach (var category in _factory.CategorySpec.Items)
{
var context =
ContextPropertyEventType.GetCategorizedBean(
Factory.FactoryContext.ContextName, 0, category.Name);
_currentSubpathId++;
// merge filter addendum, if any
var filterAddendumToUse = activationFilterAddendum;
if (_factory.HasFiltersSpecsNestedContexts())
{
filterAddendumToUse = activationFilterAddendum != null
? activationFilterAddendum.DeepCopy()
: new ContextInternalFilterAddendum();
_factory.PopulateContextInternalFilterAddendums(filterAddendumToUse, count);
}
var handle = _activationCallback.ContextPartitionInstantiate(
null, _currentSubpathId, null, this, optionalTriggeringEvent, optionalTriggeringPattern, count,
context, controllerState, filterAddendumToUse, Factory.FactoryContext.IsRecoveringResilient,
ContextPartitionState.STARTED);
_handleCategories.Put(count, handle);
Factory.StateCache.AddContextPath(
Factory.FactoryContext.OutermostContextName, Factory.FactoryContext.NestingLevel, PathId,
_currentSubpathId, handle.ContextPartitionOrPathId, count, _factory.Binding);
count++;
}
return;
}
var pathIdToUse = importPathId != null ? importPathId.Value : PathId;
InitializeFromState(
optionalTriggeringEvent, optionalTriggeringPattern, activationFilterAddendum, controllerState,
pathIdToUse, null);
}
public ContextControllerConditionTimePeriod(
String contextName,
AgentInstanceContext agentInstanceContext,
long scheduleSlot,
ContextDetailConditionTimePeriod spec,
ContextControllerConditionCallback callback,
ContextInternalFilterAddendum filterAddendum)
{
_contextName = contextName;
_agentInstanceContext = agentInstanceContext;
_scheduleSlot = scheduleSlot;
_spec = spec;
_callback = callback;
_filterAddendum = filterAddendum;
}
public ContextInternalFilterAddendum DeepCopy()
{
var copy = new ContextInternalFilterAddendum();
foreach (var entry in _filterAddendum)
{
var copy2Dim = new FilterValueSetParam[entry.Value.Length][];
copy.FilterAddendum[entry.Key] = copy2Dim;
for (int ii = 0; ii < entry.Value.Length; ii++)
{
var copyList = new FilterValueSetParam[entry.Value[ii].Length];
copy2Dim[ii] = copyList;
Array.Copy(entry.Value[ii], 0, copyList, 0, copyList.Length);
}
copy.FilterAddendum[entry.Key] = copy2Dim;
}
return(copy);
}
public ContextControllerHashedFilterCallback(
EPServicesContext servicesContext,
AgentInstanceContext agentInstanceContextCreateContext,
ContextDetailHashItem hashItem,
ContextControllerHashedInstanceCallback callback,
ContextInternalFilterAddendum filterAddendum)
{
_agentInstanceContextCreateContext = agentInstanceContextCreateContext;
_callback = callback;
_getter = hashItem.Lookupable.Getter;
_filterHandle = new EPStatementHandleCallback(agentInstanceContextCreateContext.EpStatementAgentInstanceHandle, this);
FilterValueSetParam[][] addendum = filterAddendum != null?filterAddendum.GetFilterAddendum(hashItem.FilterSpecCompiled) : null;
FilterValueSet filterValueSet = hashItem.FilterSpecCompiled.GetValueSet(null, null, addendum);
_filterServiceEntry = servicesContext.FilterService.Add(filterValueSet, _filterHandle);
long filtersVersion = servicesContext.FilterService.FiltersVersion;
agentInstanceContextCreateContext.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion = filtersVersion;
}
public ContextControllerPartitionedFilterCallback(EPServicesContext servicesContext, AgentInstanceContext agentInstanceContextCreateContext, ContextDetailPartitionItem partitionItem, ContextControllerPartitionedInstanceCreateCallback callback, ContextInternalFilterAddendum filterAddendum)
{
_agentInstanceContextCreateContext = agentInstanceContextCreateContext;
_callback = callback;
_filterHandle = new EPStatementHandleCallback(agentInstanceContextCreateContext.EpStatementAgentInstanceHandle, this);
_getters = new EventPropertyGetter[partitionItem.PropertyNames.Count];
for (int i = 0; i < partitionItem.PropertyNames.Count; i++)
{
var propertyName = partitionItem.PropertyNames[i];
var getter = partitionItem.FilterSpecCompiled.FilterForEventType.GetGetter(propertyName);
_getters[i] = getter;
}
var addendum = filterAddendum != null?filterAddendum.GetFilterAddendum(partitionItem.FilterSpecCompiled) : null;
var filterValueSet = partitionItem.FilterSpecCompiled.GetValueSet(null, null, addendum);
_filterServiceEntry = servicesContext.FilterService.Add(filterValueSet, _filterHandle);
var filtersVersion = servicesContext.FilterService.FiltersVersion;
agentInstanceContextCreateContext.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion = filtersVersion;
}
public ContextControllerInstanceHandle ContextPartitionInstantiate(
int?optionalContextPartitionId,
int subPathId,
int?importSubpathId,
ContextController originator,
EventBean optionalTriggeringEvent,
IDictionary <String, Object> optionalTriggeringPattern,
Object partitionKey,
IDictionary <String, Object> contextProperties,
ContextControllerState states,
ContextInternalFilterAddendum filterAddendum,
bool isRecoveringResilient,
ContextPartitionState state)
{
using (_iLock.Acquire())
{
ContextControllerTreeEntry entry;
// detect non-leaf
var nestingLevel = originator.Factory.FactoryContext.NestingLevel; // starts at 1 for root
if (nestingLevel < _nestedContextFactories.Length)
{
// next sub-sontext
var nextFactory = _nestedContextFactories[originator.Factory.FactoryContext.NestingLevel];
var nextContext = nextFactory.CreateNoCallback(subPathId, this);
// link current context to sub-context
var branch = _subcontexts.Get(originator);
if (branch.ChildContexts == null)
{
branch.ChildContexts = new Dictionary <int, ContextController>();
}
branch.ChildContexts.Put(subPathId, nextContext);
// save child branch, linking sub-context to its parent
entry = new ContextControllerTreeEntry(originator, null, partitionKey, contextProperties);
_subcontexts.Put(nextContext, entry);
// now post-initialize, this may actually call back
nextContext.Activate(
optionalTriggeringEvent, optionalTriggeringPattern, states, filterAddendum, importSubpathId);
if (Log.IsDebugEnabled)
{
Log.Debug(
"Instantiating branch context path for " + _contextName +
" from level " + originator.Factory.FactoryContext.NestingLevel +
"(" + originator.Factory.FactoryContext.ContextName + ")" +
" parentPath " + originator.PathId +
" for level " + nextContext.Factory.FactoryContext.NestingLevel +
"(" + nextContext.Factory.FactoryContext.ContextName + ")" +
" childPath " + subPathId
);
}
return(new ContextManagerNestedInstanceHandle(subPathId, nextContext, subPathId, true, null));
}
// assign context id
int assignedContextId;
if (optionalContextPartitionId != null && !states.IsImported)
{
assignedContextId = optionalContextPartitionId.Value;
_contextPartitionIdManager.AddExisting(optionalContextPartitionId.Value);
}
else
{
assignedContextId = _contextPartitionIdManager.AllocateId();
if (states != null && states.PartitionImportCallback != null && optionalContextPartitionId != null)
{
states.PartitionImportCallback.Allocated(assignedContextId, optionalContextPartitionId.Value);
}
}
if (Log.IsDebugEnabled)
{
Log.Debug(
"Instantiating agent instance for " + _contextName +
" from level " + originator.Factory.FactoryContext.NestingLevel +
"(" + originator.Factory.FactoryContext.ContextName + ")" +
" parentPath " + originator.PathId +
" contextPartId " + assignedContextId);
}
// handle leaf creation
IList <AgentInstance> newInstances = new List <AgentInstance>();
if (state == ContextPartitionState.STARTED)
{
foreach (var statementEntry in _statements)
{
var statementDesc = statementEntry.Value;
var instance = StartStatement(
assignedContextId, statementDesc, originator, partitionKey, contextProperties,
isRecoveringResilient);
newInstances.Add(instance);
}
}
// for all new contexts: evaluate this event for this statement
if (optionalTriggeringEvent != null)
{
StatementAgentInstanceUtil.EvaluateEventForStatement(
_servicesContext, optionalTriggeringEvent, optionalTriggeringPattern, newInstances);
}
// save leaf
entry = _subcontexts.Get(originator);
if (entry.AgentInstances == null)
{
entry.AgentInstances = new LinkedHashMap <int, ContextControllerTreeAgentInstanceList>();
}
var filterVersion = _servicesContext.FilterService.FiltersVersion;
var agentInstanceList = new ContextControllerTreeAgentInstanceList(
filterVersion, partitionKey, contextProperties, newInstances, state);
entry.AgentInstances.Put(assignedContextId, agentInstanceList);
return(new ContextManagerNestedInstanceHandle(
subPathId, originator, assignedContextId, false, agentInstanceList));
}
}
private void InitializeFromState(
EventBean optionalTriggeringEvent,
IDictionary <String, Object> optionalTriggeringPattern,
ContextInternalFilterAddendum activationFilterAddendum,
ContextControllerState controllerState,
int pathIdToUse,
AgentInstanceSelector agentInstanceSelector)
{
var states = controllerState.States;
var childContexts = ContextControllerStateUtil.GetChildContexts(
Factory.FactoryContext, pathIdToUse, states);
int maxSubpathId = int.MinValue;
foreach (var entry in childContexts)
{
var categoryNumber = (int)_factory.Binding.ByteArrayToObject(entry.Value.Blob, null);
ContextDetailCategoryItem category = _factory.CategorySpec.Items[categoryNumber];
// merge filter addendum, if any
var filterAddendumToUse = activationFilterAddendum;
if (_factory.HasFiltersSpecsNestedContexts())
{
filterAddendumToUse = activationFilterAddendum != null
? activationFilterAddendum.DeepCopy()
: new ContextInternalFilterAddendum();
_factory.PopulateContextInternalFilterAddendums(filterAddendumToUse, categoryNumber);
}
// check if exists already
if (controllerState.IsImported)
{
var existingHandle = _handleCategories.Get(categoryNumber);
if (existingHandle != null)
{
_activationCallback.ContextPartitionNavigate(
existingHandle, this, controllerState, entry.Value.OptionalContextPartitionId.Value,
filterAddendumToUse, agentInstanceSelector, entry.Value.Blob);
continue;
}
}
var context =
ContextPropertyEventType.GetCategorizedBean(Factory.FactoryContext.ContextName, 0, category.Name);
var contextPartitionId = entry.Value.OptionalContextPartitionId.Value;
var assignedSubPathId = !controllerState.IsImported ? entry.Key.SubPath : ++_currentSubpathId;
var handle =
_activationCallback.ContextPartitionInstantiate(
contextPartitionId, assignedSubPathId, entry.Key.SubPath, this, null, null, categoryNumber,
context, controllerState, filterAddendumToUse, Factory.FactoryContext.IsRecoveringResilient,
entry.Value.State);
_handleCategories.Put(categoryNumber, handle);
if (entry.Key.SubPath > maxSubpathId)
{
maxSubpathId = assignedSubPathId;
}
}
if (!controllerState.IsImported)
{
_currentSubpathId = maxSubpathId != int.MinValue ? maxSubpathId : 0;
}
}
public void RangeNotification(
IDictionary <String, Object> builtinProperties,
ContextControllerCondition originCondition,
EventBean optionalTriggeringEvent,
IDictionary <String, Object> optionalTriggeringPattern,
ContextInternalFilterAddendum filterAddendum)
{
var endConditionNotification = originCondition != StartCondition;
var startNow = StartCondition is ContextControllerConditionImmediate;
IList <AgentInstance> agentInstancesLocksHeld = null;
_nonDistinctLastTrigger = optionalTriggeringEvent;
ILockable tempLock = startNow
? _factory.FactoryContext.ServicesContext.FilterService.WriteLock
: new VoidLock();
using (tempLock.Acquire())
{
try
{
if (endConditionNotification)
{
if (originCondition.IsRunning)
{
originCondition.Deactivate();
}
// indicate terminate
var instance = EndConditions.Pluck(originCondition);
if (instance == null)
{
return;
}
// For start-now (non-overlapping only) we hold the lock of the existing agent instance
// until the new one is ready.
if (startNow)
{
agentInstancesLocksHeld = new List <AgentInstance>();
optionalTriggeringEvent = null;
// since we are restarting, we don't want to evaluate the event twice
optionalTriggeringPattern = null;
}
ActivationCallback.ContextPartitionTerminate(
instance.InstanceHandle, builtinProperties, startNow, agentInstancesLocksHeld);
// remove distinct key
RemoveDistinctKey(instance);
// re-activate start condition if not overlapping
if (!_factory.ContextDetailInitiatedTerminated.IsOverlapping)
{
StartCondition.Activate(optionalTriggeringEvent, null, 0, false);
}
_factory.FactoryContext.StateCache.RemoveContextPath(
_factory.FactoryContext.OutermostContextName, _factory.FactoryContext.NestingLevel, _pathId,
instance.SubPathId);
}
// handle start-condition notification
if (!endConditionNotification || startNow)
{
// Check if this is distinct-only and the key already exists
if (_distinctContexts != null)
{
var added = AddDistinctKey(optionalTriggeringEvent);
if (!added)
{
return;
}
}
// For single-instance mode, deactivate
if (!_factory.ContextDetailInitiatedTerminated.IsOverlapping)
{
if (StartCondition.IsRunning)
{
StartCondition.Deactivate();
}
}
// For overlapping mode, make sure we activate again or stay activated
else
{
if (!StartCondition.IsRunning)
{
StartCondition.Activate(null, null, 0, _factory.FactoryContext.IsRecoveringResilient);
}
}
CurrentSubpathId++;
var endEndpoint = MakeEndpoint(
_factory.ContextDetailInitiatedTerminated.End, filterAddendum, false, CurrentSubpathId);
var matchedEventMap = GetMatchedEventMap(builtinProperties);
endEndpoint.Activate(null, matchedEventMap, 0, false);
var startTime = _factory.SchedulingService.Time;
var endTime = endEndpoint.ExpectedEndTime;
var builtinProps = GetBuiltinProperties(_factory.FactoryContext.ContextName, startTime, endTime, builtinProperties);
var instanceHandle = ActivationCallback.ContextPartitionInstantiate(
null, CurrentSubpathId, null, this, optionalTriggeringEvent, optionalTriggeringPattern,
new ContextControllerInitTermState(
_factory.SchedulingService.Time, matchedEventMap.MatchingEventsAsMap), builtinProps,
null, filterAddendum, _factory.FactoryContext.IsRecoveringResilient,
ContextPartitionState.STARTED);
EndConditions.Put(
endEndpoint,
new ContextControllerInitTermInstance(
instanceHandle, builtinProperties, startTime, endTime, CurrentSubpathId));
// install filter fault handlers, if necessary
InstallFilterFaultHandler(instanceHandle);
var state =
new ContextControllerInitTermState(
_factory.FactoryContext.ServicesContext.SchedulingService.Time, builtinProperties);
_factory.FactoryContext.StateCache.AddContextPath(
_factory.FactoryContext.OutermostContextName, _factory.FactoryContext.NestingLevel, _pathId,
CurrentSubpathId, instanceHandle.ContextPartitionOrPathId, state, _factory.Binding);
}
}
finally
{
if (agentInstancesLocksHeld != null)
{
foreach (var agentInstance in agentInstancesLocksHeld)
{
agentInstance.AgentInstanceContext.EpStatementAgentInstanceHandle.StatementFilterVersion.StmtFilterVersion = long.MaxValue;
if (agentInstance.AgentInstanceContext.StatementContext.EpStatementHandle.HasTableAccess)
{
agentInstance.AgentInstanceContext.TableExprEvaluatorContext.ReleaseAcquiredLocks();
}
agentInstance.AgentInstanceContext.AgentInstanceLock.WriteLock.Release();
}
}
}
}
}
public void ContextPartitionNavigate(
ContextControllerInstanceHandle existingHandle,
ContextController originator,
ContextControllerState controllerState,
int exportedCPOrPathId,
ContextInternalFilterAddendum filterAddendum,
AgentInstanceSelector agentInstanceSelector,
byte[] payload,
bool isRecoveringResilient)
{
var nestedHandle = (ContextManagerNestedInstanceHandle)existingHandle;
// detect non-leaf
var nestingLevel = originator.Factory.FactoryContext.NestingLevel; // starts at 1 for root
if (nestingLevel < _nestedContextFactories.Length)
{
nestedHandle.Controller.ImportContextPartitions(
controllerState, exportedCPOrPathId, filterAddendum, agentInstanceSelector);
return;
}
var entry = _subcontexts.Get(originator);
if (entry == null)
{
return;
}
foreach (var cpEntry in entry.AgentInstances.ToArray())
{
if (cpEntry.Value.State == ContextPartitionState.STOPPED)
{
cpEntry.Value.State = ContextPartitionState.STARTED;
entry.AgentInstances.Clear();
foreach (var statement in _statements)
{
var instance = StartStatement(
existingHandle.ContextPartitionOrPathId, statement.Value, originator,
cpEntry.Value.InitPartitionKey, entry.InitContextProperties, false);
cpEntry.Value.AgentInstances.Add(instance);
}
var key = new ContextStatePathKey(
_nestedContextFactories.Length, originator.PathId, existingHandle.SubPathId);
var value = new ContextStatePathValue(
existingHandle.ContextPartitionOrPathId, payload, ContextPartitionState.STARTED);
originator.Factory.FactoryContext.StateCache.UpdateContextPath(_contextName, key, value);
}
else
{
IList <AgentInstance> removed = new List <AgentInstance>(2);
IList <AgentInstance> added = new List <AgentInstance>(2);
var current = cpEntry.Value.AgentInstances;
foreach (var agentInstance in current)
{
if (!agentInstanceSelector.Select(agentInstance))
{
continue;
}
// remove
StatementAgentInstanceUtil.StopAgentInstanceRemoveResources(
agentInstance, null, _servicesContext, false, false);
removed.Add(agentInstance);
// start
var statementDesc = _statements.Get(agentInstance.AgentInstanceContext.StatementId);
var instance = StartStatement(
cpEntry.Key, statementDesc, originator, cpEntry.Value.InitPartitionKey,
entry.InitContextProperties, false);
added.Add(instance);
if (controllerState.PartitionImportCallback != null)
{
controllerState.PartitionImportCallback.Existing(
existingHandle.ContextPartitionOrPathId, exportedCPOrPathId);
}
}
current.RemoveAll(removed);
current.AddAll(added);
}
}
}
public void ContextPartitionNavigate(ContextControllerInstanceHandle existingHandle, ContextController originator, ContextControllerState controllerState, int exportedCPOrPathId, ContextInternalFilterAddendum filterAddendum, AgentInstanceSelector agentInstanceSelector, byte[] payload, bool isRecoveringResilient)
{
var entry = _agentInstances.Get(existingHandle.ContextPartitionOrPathId);
if (entry == null)
{
return;
}
if (entry.State == ContextPartitionState.STOPPED)
{
entry.State = ContextPartitionState.STARTED;
entry.AgentInstances.Clear();
foreach (var statement in _statements)
{
var instance = StartStatement(existingHandle.ContextPartitionOrPathId, statement.Value, originator, entry.InitPartitionKey, entry.InitContextProperties, false);
entry.AgentInstances.Add(instance);
}
var key = new ContextStatePathKey(1, 0, existingHandle.SubPathId);
var value = new ContextStatePathValue(existingHandle.ContextPartitionOrPathId, payload, ContextPartitionState.STARTED);
_rootContext.Factory.FactoryContext.StateCache.UpdateContextPath(_contextName, key, value);
}
else
{
IList <AgentInstance> removed = new List <AgentInstance>(2);
IList <AgentInstance> added = new List <AgentInstance>(2);
foreach (var agentInstance in entry.AgentInstances)
{
if (!agentInstanceSelector.Select(agentInstance))
{
continue;
}
// remove
StatementAgentInstanceUtil.StopAgentInstanceRemoveResources(agentInstance, null, _servicesContext, false, false);
removed.Add(agentInstance);
// start
var statementDesc = _statements.Get(agentInstance.AgentInstanceContext.StatementId);
var instance = StartStatement(existingHandle.ContextPartitionOrPathId, statementDesc, originator, entry.InitPartitionKey, entry.InitContextProperties, isRecoveringResilient);
added.Add(instance);
if (controllerState.PartitionImportCallback != null)
{
controllerState.PartitionImportCallback.Existing(existingHandle.ContextPartitionOrPathId, exportedCPOrPathId);
}
}
entry.AgentInstances.RemoveAll(removed);
entry.AgentInstances.AddAll(added);
}
}
private void InitializeFromState(
EventBean optionalTriggeringEvent,
IDictionary <String, Object> optionalTriggeringPattern,
ContextInternalFilterAddendum filterAddendum,
ContextControllerState controllerState,
int pathIdToUse,
AgentInstanceSelector agentInstanceSelector,
bool loadingExistingState)
{
var factoryContext = _factory.FactoryContext;
var states = controllerState.States;
// restart if there are states
var maxSubpathId = int.MinValue;
var childContexts = ContextControllerStateUtil.GetChildContexts(factoryContext, pathIdToUse, states);
var eventAdapterService = _factory.FactoryContext.ServicesContext.EventAdapterService;
foreach (var entry in childContexts)
{
var keys = (Object[])_factory.Binding.ByteArrayToObject(entry.Value.Blob, eventAdapterService);
var mapKey = GetKeyObjectForLookup(keys);
// merge filter addendum, if any
var myFilterAddendum = _activationFilterAddendum;
if (_factory.HasFiltersSpecsNestedContexts)
{
filterAddendum = _activationFilterAddendum != null
? _activationFilterAddendum.DeepCopy()
: new ContextInternalFilterAddendum();
_factory.PopulateContextInternalFilterAddendums(filterAddendum, mapKey);
}
// check if exists already
if (controllerState.IsImported)
{
var existingHandle = _partitionKeys.Get(mapKey);
if (existingHandle != null)
{
_activationCallback.ContextPartitionNavigate(
existingHandle, this, controllerState, entry.Value.OptionalContextPartitionId.Value,
myFilterAddendum, agentInstanceSelector, entry.Value.Blob, loadingExistingState);
continue;
}
}
var props = ContextPropertyEventType.GetPartitionBean(
factoryContext.ContextName, 0, mapKey, _factory.SegmentedSpec.Items[0].PropertyNames);
var assignedSubpathId = !controllerState.IsImported ? entry.Key.SubPath : ++_currentSubpathId;
var handle =
_activationCallback.ContextPartitionInstantiate(
entry.Value.OptionalContextPartitionId, assignedSubpathId, entry.Key.SubPath, this,
optionalTriggeringEvent, optionalTriggeringPattern, mapKey, props, controllerState,
myFilterAddendum, loadingExistingState || factoryContext.IsRecoveringResilient, entry.Value.State);
_partitionKeys.Put(mapKey, handle);
if (entry.Key.SubPath > maxSubpathId)
{
maxSubpathId = assignedSubpathId;
}
}
if (!controllerState.IsImported)
{
_currentSubpathId = maxSubpathId != int.MinValue ? maxSubpathId : 0;
}
}
private void InitializeFromState(
EventBean optionalTriggeringEvent,
IDictionary <String, Object> optionalTriggeringPattern,
ContextInternalFilterAddendum filterAddendum,
ContextControllerState controllerState,
int pathIdToUse,
AgentInstanceSelector agentInstanceSelector,
bool loadingExistingState)
{
var states = controllerState.States;
var childContexts = ContextControllerStateUtil.GetChildContexts(_factory.FactoryContext, pathIdToUse, states);
var eventAdapterService = _factory.FactoryContext.ServicesContext.EventAdapterService;
var maxSubpathId = int.MinValue;
foreach (var entry in childContexts)
{
var state = (ContextControllerInitTermState)_factory.Binding.ByteArrayToObject(entry.Value.Blob, eventAdapterService);
if (_distinctContexts != null)
{
var filter = (ContextControllerConditionFilter)StartCondition;
var @event = (EventBean)state.PatternData.Get(filter.EndpointFilterSpec.OptionalFilterAsName);
AddDistinctKey(@event);
}
if (controllerState.IsImported)
{
KeyValuePair <ContextControllerCondition, ContextControllerInitTermInstance>?existing = null;
foreach (var entryExisting in EndConditions)
{
if (Compare(state.StartTime, state.PatternData, null,
entryExisting.Value.StartTime, entryExisting.Value.StartProperties, null))
{
existing = entryExisting;
break;
}
}
if (existing != null)
{
ContextControllerInstanceHandle existingHandle = existing.Value.Value.InstanceHandle;
if (existingHandle != null)
{
ActivationCallback.ContextPartitionNavigate(existingHandle, this, controllerState, entry.Value.OptionalContextPartitionId.Value, filterAddendum, agentInstanceSelector, entry.Value.Blob, loadingExistingState);
continue;
}
}
}
var endEndpoint = MakeEndpoint(_factory.ContextDetailInitiatedTerminated.End, filterAddendum, false, entry.Key.SubPath);
var timeOffset = _factory.FactoryContext.ServicesContext.SchedulingService.Time - state.StartTime;
endEndpoint.Activate(optionalTriggeringEvent, null, timeOffset, _factory.FactoryContext.IsRecoveringResilient);
var startTime = state.StartTime;
var endTime = endEndpoint.ExpectedEndTime;
var builtinProps = GetBuiltinProperties(_factory.FactoryContext.ContextName, startTime, endTime, state.PatternData);
var contextPartitionId = entry.Value.OptionalContextPartitionId;
var assignedSubPathId = !controllerState.IsImported ? entry.Key.SubPath : ++CurrentSubpathId;
var instanceHandle = ActivationCallback.ContextPartitionInstantiate(contextPartitionId, assignedSubPathId, entry.Key.SubPath, this, optionalTriggeringEvent, optionalTriggeringPattern, null, builtinProps, controllerState, filterAddendum, loadingExistingState || _factory.FactoryContext.IsRecoveringResilient, entry.Value.State);
EndConditions.Put(endEndpoint, new ContextControllerInitTermInstance(instanceHandle, state.PatternData, startTime, endTime, assignedSubPathId));
if (entry.Key.SubPath > maxSubpathId)
{
maxSubpathId = assignedSubPathId;
}
}
if (!controllerState.IsImported)
{
CurrentSubpathId = maxSubpathId != int.MinValue ? maxSubpathId : 0;
}
}
public void Activate(EventBean optionalTriggeringEvent, IDictionary <String, Object> optionalTriggeringPattern, ContextControllerState controllerState, ContextInternalFilterAddendum filterAddendum, int?importPathId)
{
if (_factory.FactoryContext.NestingLevel == 1)
{
controllerState = ContextControllerStateUtil.GetRecoveryStates(_factory.FactoryContext.StateCache, _factory.FactoryContext.OutermostContextName);
}
bool currentlyRunning;
var contextDetailInitiatedTerminated = _factory.ContextDetailInitiatedTerminated;
if (controllerState == null)
{
StartCondition = MakeEndpoint(contextDetailInitiatedTerminated.Start, filterAddendum, true, 0);
// if this is single-instance mode, check if we are currently running according to schedule
currentlyRunning = StartCondition.IsImmediate;
if (!contextDetailInitiatedTerminated.IsOverlapping)
{
currentlyRunning = DetermineCurrentlyRunning(StartCondition);
}
if (currentlyRunning)
{
CurrentSubpathId++;
var endEndpoint = MakeEndpoint(contextDetailInitiatedTerminated.End, filterAddendum, false, CurrentSubpathId);
endEndpoint.Activate(optionalTriggeringEvent, null, 0, _factory.FactoryContext.IsRecoveringResilient);
var startTime = _factory.SchedulingService.Time;
var endTime = endEndpoint.ExpectedEndTime;
var builtinProps = GetBuiltinProperties(_factory.FactoryContext.ContextName, startTime, endTime, Collections.GetEmptyMap <string, object>());
var instanceHandle = ActivationCallback.ContextPartitionInstantiate(null, CurrentSubpathId, null, this, optionalTriggeringEvent, optionalTriggeringPattern, null, builtinProps, controllerState, filterAddendum, _factory.FactoryContext.IsRecoveringResilient, ContextPartitionState.STARTED);
EndConditions.Put(endEndpoint, new ContextControllerInitTermInstance(instanceHandle, null, startTime, endTime, CurrentSubpathId));
var state = new ContextControllerInitTermState(_factory.FactoryContext.ServicesContext.SchedulingService.Time, builtinProps);
_factory.FactoryContext.StateCache.AddContextPath(_factory.FactoryContext.OutermostContextName, _factory.FactoryContext.NestingLevel, _pathId, CurrentSubpathId, instanceHandle.ContextPartitionOrPathId, state, _factory.Binding);
}
// non-overlapping and not currently running, or overlapping
if ((!contextDetailInitiatedTerminated.IsOverlapping && !currentlyRunning) ||
contextDetailInitiatedTerminated.IsOverlapping)
{
StartCondition.Activate(optionalTriggeringEvent, null, 0, _factory.FactoryContext.IsRecoveringResilient);
}
return;
}
StartCondition = MakeEndpoint(contextDetailInitiatedTerminated.Start, filterAddendum, true, 0);
// if this is single-instance mode, check if we are currently running according to schedule
currentlyRunning = false;
if (!contextDetailInitiatedTerminated.IsOverlapping)
{
currentlyRunning = DetermineCurrentlyRunning(StartCondition);
}
if (!currentlyRunning)
{
StartCondition.Activate(optionalTriggeringEvent, null, 0, _factory.FactoryContext.IsRecoveringResilient);
}
int pathIdToUse = importPathId ?? _pathId;
InitializeFromState(optionalTriggeringEvent, optionalTriggeringPattern, filterAddendum, controllerState, pathIdToUse, null, false);
}
protected ContextControllerCondition MakeEndpoint(ContextDetailCondition endpoint, ContextInternalFilterAddendum filterAddendum, bool isStartEndpoint, int subPathId)
{
return(ContextControllerConditionFactory.GetEndpoint(_factory.FactoryContext.ContextName, _factory.FactoryContext.ServicesContext, _factory.FactoryContext.AgentInstanceContextCreate,
endpoint, this, filterAddendum, isStartEndpoint,
_factory.FactoryContext.NestingLevel, _pathId, subPathId));
}
public void PopulateContextInternalFilterAddendums(ContextInternalFilterAddendum filterAddendum, object categoryIndex)
{
var category = _categorySpec.Items[categoryIndex.AsInt()];
GetAddendumFilters(filterAddendum.FilterAddendum, category, _categorySpec, _filtersSpecsNestedContexts, null);
}
