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 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 ContextControllerInitTermInstance(ContextControllerInstanceHandle instanceHandle, IDictionary <String, Object> startProperties, long startTime, long?endTime, int subPathId) { InstanceHandle = instanceHandle; StartProperties = startProperties; StartTime = startTime; EndTime = endTime; SubPathId = subPathId; }
/// <summary> /// Provides the sub-context that ends. /// </summary> /// <param name="contextNestedHandle">The context nested handle.</param> /// <param name="terminationProperties">The termination properties.</param> /// <param name="leaveLocksAcquired">if set to <c>true</c> [leave locks acquired].</param> /// <param name="agentInstances">The agent instances.</param> public void ContextPartitionTerminate( ContextControllerInstanceHandle contextNestedHandle, IDictionary <String, Object> terminationProperties, bool leaveLocksAcquired, IList <AgentInstance> agentInstances) { var handle = (ContextManagerNestedInstanceHandle)contextNestedHandle; if (handle.IsBranch) { var branchHandle = handle; var branch = branchHandle.Controller; RecursiveDeactivateStop(branch, leaveLocksAcquired, agentInstances); if (Log.IsDebugEnabled) { Log.Debug( "Terminated context branch for " + _contextName + " from level " + branch.Factory.FactoryContext.NestingLevel + "(" + branch.Factory.FactoryContext.ContextName + ")" + " parentPath " + branch.PathId); } } else { var leafHandle = handle; var leaf = leafHandle.Controller; var leafEntry = _subcontexts.Get(leaf); if (leafEntry != null) { // could be terminated earlier var ailist = leafEntry.AgentInstances.Get(leafHandle.ContextPartitionOrPathId); if (ailist != null) { StatementAgentInstanceUtil.StopAgentInstances( ailist.AgentInstances, null, _servicesContext, false, false); _contextPartitionIdManager.RemoveId(leafHandle.ContextPartitionOrPathId); ailist.AgentInstances.Clear(); } if (Log.IsDebugEnabled) { Log.Debug( "Terminated context leaf for " + _contextName + " from level " + leaf.Factory.FactoryContext.NestingLevel + "(" + leaf.Factory.FactoryContext.ContextName + ")" + " parentPath " + leaf.PathId + " contextPartId " + leafHandle.ContextPartitionOrPathId); } } } }
public void Visit( int nestingLevel, int pathId, ContextStatePathValueBinding binding, Object payload, ContextController contextController, ContextControllerInstanceHandle instanceHandle) { if (nestingLevel == _maxNestingLevel) { _agentInstanceIds.Add(instanceHandle.ContextPartitionOrPathId); } }
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); } }
public void ContextPartitionTerminate(ContextControllerInstanceHandle contextNestedHandle, IDictionary <String, Object> terminationProperties, bool leaveLocksAcquired, IList <AgentInstance> agentInstancesCollected) { using (_uLock.Acquire()) { var handle = (ContextNestedHandleImpl)contextNestedHandle; var entry = _agentInstances.Delete(handle.ContextPartitionOrPathId); if (entry != null) { StatementAgentInstanceUtil.StopAgentInstances(entry.AgentInstances, terminationProperties, _servicesContext, false, leaveLocksAcquired); if (agentInstancesCollected != null) { agentInstancesCollected.AddAll(entry.AgentInstances); } entry.AgentInstances.Clear(); _contextPartitionIdManager.RemoveId(contextNestedHandle.ContextPartitionOrPathId); } } }
private void InstallFilterFaultHandler(ContextControllerInstanceHandle instanceHandle) { FilterFaultHandler myFaultHandler = null; if (DistinctContexts != null) { myFaultHandler = new DistinctFilterFaultHandler(this); } else { if (StartCondition is ContextControllerConditionFilter) { myFaultHandler = new NonDistinctFilterFaultHandler(this); } } if (myFaultHandler != null && instanceHandle.Instances != null) { foreach (AgentInstance agentInstance in instanceHandle.Instances.AgentInstances) { agentInstance.AgentInstanceContext.EpStatementAgentInstanceHandle.FilterFaultHandler = myFaultHandler; } } }
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 Visit(int nestingLevel, int pathId, ContextStatePathValueBinding binding, Object payload, ContextController contextController, ContextControllerInstanceHandle instanceHandle) { ContextStatePathKey key = new ContextStatePathKey(nestingLevel, pathId, instanceHandle.SubPathId); int agentInstanceId = instanceHandle.ContextPartitionOrPathId; States.Put(key, new ContextStatePathValue(agentInstanceId, binding.ToByteArray(payload), instanceHandle.Instances.State)); ContextPartitionState state = instanceHandle.Instances.State; ContextPartitionIdentifier identifier = contextController.Factory.KeyPayloadToIdentifier(payload); ContextPartitionDescriptor descriptor = new ContextPartitionDescriptor(agentInstanceId, identifier, state); ContextPartitionInfo.Put(agentInstanceId, descriptor); }
public void Visit(int nestingLevel, int pathId, ContextStatePathValueBinding binding, Object payload, ContextController contextController, ContextControllerInstanceHandle instanceHandle) { var key = new ContextStatePathKey(nestingLevel, pathId, instanceHandle.SubPathId); int maxNestingLevel = _nestedFactories.Length; int contextPartitionOrSubPath = instanceHandle.ContextPartitionOrPathId; if (contextController.Factory.FactoryContext.NestingLevel == maxNestingLevel) { var agentInstances = ControllerAgentInstances.Get(contextController); if (agentInstances == null) { agentInstances = new List <LeafDesc>(); ControllerAgentInstances.Put(contextController, agentInstances); } var value = new ContextStatePathValue(contextPartitionOrSubPath, binding.ToByteArray(payload), instanceHandle.Instances.State); agentInstances.Add(new LeafDesc(key, value)); // generate a nice payload text from the paths of keys var entry = _subcontexts.Get(contextController); var keys = ContextManagerNested.GetTreeCompositeKey(_nestedFactories, payload, entry, _subcontexts); var descriptor = new ContextPartitionDescriptor(contextPartitionOrSubPath, new ContextPartitionIdentifierNested(keys), value.State); AgentInstanceInfo.Put(contextPartitionOrSubPath, descriptor); States.Put(key, value); } else { // handle non-leaf Subpaths.Add(contextPartitionOrSubPath); States.Put(key, new ContextStatePathValue(contextPartitionOrSubPath, binding.ToByteArray(payload), ContextPartitionState.STARTED)); } }
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); } } }