public void AddStatement(ContextControllerStatementBase statement, bool isRecoveringResilient) { // validation down the hierarchy var caches = _factory.ValidateStatement(statement); // add statement var desc = new ContextControllerStatementDesc(statement, new ContextControllerStatementCtxCache[] { caches }); _statements.Put(statement.StatementContext.StatementId, desc); // activate if this is the first statement if (_statements.Count == 1) { Activate(); // this may itself trigger a callback } // activate statement in respect to existing context partitions else { foreach (var entry in _agentInstances) { if (entry.Value.State == ContextPartitionState.STARTED) { var agentInstance = StartStatement(entry.Key, desc, _rootContext, entry.Value.InitPartitionKey, entry.Value.InitContextProperties, isRecoveringResilient); entry.Value.AgentInstances.Add(agentInstance); } } } }
public override ContextControllerStatementCtxCache ValidateStatement(ContextControllerStatementBase statement) { StatementSpecCompiledAnalyzerResult streamAnalysis = StatementSpecCompiledAnalyzer.AnalyzeFilters(statement.StatementSpec); ContextControllerPartitionedUtil.ValidateStatementForContext(FactoryContext.ContextName, statement, streamAnalysis, GetItemEventTypes(_segmentedSpec), FactoryContext.ServicesContext.NamedWindowMgmtService); return(new ContextControllerStatementCtxCacheFilters(streamAnalysis.Filters)); }
public override ContextControllerStatementCtxCache ValidateStatement(ContextControllerStatementBase statement) { var streamAnalysis = StatementSpecCompiledAnalyzer.AnalyzeFilters(statement.StatementSpec); ValidateStatementForContext(statement, streamAnalysis); return(new ContextControllerStatementCtxCacheFilters(streamAnalysis.Filters)); }
internal static void ValidateStatementForContext(String contextName, ContextControllerStatementBase statement, StatementSpecCompiledAnalyzerResult streamAnalysis, ICollection <EventType> itemEventTypes, NamedWindowService namedWindowService) { IList <FilterSpecCompiled> filters = streamAnalysis.Filters; bool isCreateWindow = statement.StatementSpec.CreateWindowDesc != null; // if no create-window: at least one of the filters must match one of the filters specified by the context if (!isCreateWindow) { foreach (FilterSpecCompiled filter in filters) { foreach (EventType itemEventType in itemEventTypes) { EventType stmtFilterType = filter.FilterForEventType; if (stmtFilterType == itemEventType) { return; } if (EventTypeUtility.IsTypeOrSubTypeOf(stmtFilterType, itemEventType)) { return; } NamedWindowProcessor processor = namedWindowService.GetProcessor(stmtFilterType.Name); if (processor != null && processor.ContextName != null && processor.ContextName.Equals(contextName)) { return; } } } if (filters.IsNotEmpty()) { throw new ExprValidationException(GetTypeValidationMessage(contextName, filters[0].FilterForEventType.Name)); } return; } // validate create-window with column definition: not allowed, requires typed if (statement.StatementSpec.CreateWindowDesc.Columns != null && statement.StatementSpec.CreateWindowDesc.Columns.Count > 0) { throw new ExprValidationException("Segmented context '" + contextName + "' requires that named windows are associated to an existing event type and that the event type is listed among the partitions defined by the create-context statement"); } // validate create-window declared type String declaredAsName = statement.StatementSpec.CreateWindowDesc.AsEventTypeName; if (declaredAsName != null) { if (itemEventTypes.Any(itemEventType => itemEventType.Name == declaredAsName)) { return; } throw new ExprValidationException(GetTypeValidationMessage(contextName, declaredAsName)); } }
public void AddStatement(String contextName, ContextControllerStatementBase statement, bool isRecoveringResilient) { ContextManagerEntry entry = _contexts.Get(contextName); if (entry == null) { throw new ExprValidationException(GetNotDecaredText(contextName)); } entry.AddStatement(statement.StatementContext.StatementId); entry.ContextManager.AddStatement(statement, isRecoveringResilient); }
public override ContextControllerStatementCtxCache ValidateStatement(ContextControllerStatementBase statement) { var streamAnalysis = StatementSpecCompiledAnalyzer.AnalyzeFilters(statement.StatementSpec); ContextControllerPartitionedUtil.ValidateStatementForContext( _factoryContext.ContextName, statement, streamAnalysis, GetItemEventTypes(_hashedSpec), _factoryContext.ServicesContext.NamedWindowMgmtService); // register non-property expression to be able to recreated indexes foreach (var entry in _nonPropertyExpressions) { _factoryContext.ServicesContext.FilterNonPropertyRegisteryService.RegisterNonPropertyExpression(statement.StatementContext.StatementName, entry.Key, entry.Value); } return(new ContextControllerStatementCtxCacheFilters(streamAnalysis.Filters)); }
public void AddStatement(ContextControllerStatementBase statement, bool isRecoveringResilient) { // validation down the hierarchy var caches = new ContextControllerStatementCtxCache[_nestedContextFactories.Length]; for (var i = 0; i < _nestedContextFactories.Length; i++) { var nested = _nestedContextFactories[i]; caches[i] = nested.ValidateStatement(statement); } // save statement var desc = new ContextControllerStatementDesc(statement, caches); _statements.Put(statement.StatementContext.StatementId, desc); // activate if this is the first statement if (_statements.Count == 1) { Activate(); // this may itself trigger a callback } // activate statement in respect to existing context partitions else { foreach (var subcontext in _subcontexts) { if (subcontext.Key.Factory.FactoryContext.NestingLevel != _nestedContextFactories.Length) { continue; } if (subcontext.Value.AgentInstances == null || subcontext.Value.AgentInstances.IsEmpty()) { continue; } foreach (var entry in subcontext.Value.AgentInstances) { if (entry.Value.State == ContextPartitionState.STARTED) { var agentInstance = StartStatement( entry.Key, desc, subcontext.Key, entry.Value.InitPartitionKey, entry.Value.InitContextProperties, isRecoveringResilient); entry.Value.AgentInstances.Add(agentInstance); } } } } }
private void ValidateStatementForContext(ContextControllerStatementBase statement, StatementSpecCompiledAnalyzerResult streamAnalysis) { var filters = streamAnalysis.Filters; var isCreateWindow = statement.StatementSpec.CreateWindowDesc != null; var message = "Category context '" + _factoryContext.ContextName + "' requires that any of the events types that are listed in the category context also appear in any of the filter expressions of the statement"; // if no create-window: at least one of the filters must match one of the filters specified by the context if (!isCreateWindow) { foreach (var filter in filters) { var stmtFilterType = filter.FilterForEventType; var contextType = _categorySpec.FilterSpecCompiled.FilterForEventType; if (Equals(stmtFilterType, contextType)) { return; } if (EventTypeUtility.IsTypeOrSubTypeOf(stmtFilterType, contextType)) { return; } } if (!filters.IsEmpty()) { throw new ExprValidationException(message); } return; } // validate create-window var declaredAsName = statement.StatementSpec.CreateWindowDesc.AsEventTypeName; if (declaredAsName != null) { if (_categorySpec.FilterSpecCompiled.FilterForEventType.Name.Equals(declaredAsName)) { return; } throw new ExprValidationException(message); } }
public override ContextControllerStatementCtxCache ValidateStatement(ContextControllerStatementBase statement) { return(null); }
public abstract ContextControllerStatementCtxCache ValidateStatement(ContextControllerStatementBase statement);