public static ContextControllerConditionNonHA GetEndpoint( IntSeqKey conditionPath, object[] partitionKeys, ContextConditionDescriptor endpoint, ContextControllerConditionCallback callback, ContextController controller, bool isStartEndpoint) { if (endpoint is ContextConditionDescriptorFilter) { ContextConditionDescriptorFilter filter = (ContextConditionDescriptorFilter) endpoint; return new ContextControllerConditionFilter(conditionPath, partitionKeys, filter, callback, controller); } if (endpoint is ContextConditionDescriptorTimePeriod) { ContextConditionDescriptorTimePeriod timePeriod = (ContextConditionDescriptorTimePeriod) endpoint; long scheduleSlot = controller.Realization.AgentInstanceContextCreate.ScheduleBucket.AllocateSlot(); return new ContextControllerConditionTimePeriod( scheduleSlot, timePeriod, conditionPath, callback, controller); } if (endpoint is ContextConditionDescriptorCrontab) { ContextConditionDescriptorCrontab crontab = (ContextConditionDescriptorCrontab) endpoint; ScheduleSpec schedule = ScheduleExpressionUtil.CrontabScheduleBuild( crontab.Evaluators, controller.Realization.AgentInstanceContextCreate); long scheduleSlot = controller.Realization.AgentInstanceContextCreate.ScheduleBucket.AllocateSlot(); return new ContextControllerConditionCrontabImpl( conditionPath, scheduleSlot, schedule, crontab, callback, controller); } if (endpoint is ContextConditionDescriptorPattern) { ContextConditionDescriptorPattern pattern = (ContextConditionDescriptorPattern) endpoint; return new ContextControllerConditionPattern( conditionPath, partitionKeys, pattern, callback, controller); } if (endpoint is ContextConditionDescriptorNever) { return ContextControllerConditionNever.INSTANCE; } if (endpoint is ContextConditionDescriptorImmediate) { return ContextControllerConditionImmediate.INSTANCE; } throw new IllegalStateException("Unrecognized context range endpoint " + endpoint.GetType()); }
public OutputCondition InstantiateOutputCondition( AgentInstanceContext agentInstanceContext, OutputCallback outputCallback) { var scheduleSpec = ScheduleExpressionUtil.CrontabScheduleBuild( scheduleSpecEvaluators, agentInstanceContext); return new OutputConditionCrontab( outputCallback, agentInstanceContext, isStartConditionOnCreation, scheduleSpec); }
public OutputConditionCrontabForge( IList<ExprNode> scheduleSpecExpressionList, bool isStartConditionOnCreation, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { scheduleSpecEvaluators = ScheduleExpressionUtil.CrontabScheduleValidate( ExprNodeOrigin.OUTPUTLIMIT, scheduleSpecExpressionList, false, statementRawInfo, services); this.isStartConditionOnCreation = isStartConditionOnCreation; }
public static bool DetermineCurrentlyRunning( ContextControllerCondition startCondition, ContextControllerInitTerm controller) { if (startCondition.IsImmediate) { return true; } var factory = controller.InitTermFactory; var spec = factory.InitTermSpec; if (spec.IsOverlapping) { return false; } // we are not currently running if either of the endpoints is not crontab-triggered if (spec.StartCondition is ContextConditionDescriptorCrontab && spec.EndCondition is ContextConditionDescriptorCrontab) { var scheduleStart = ((ContextControllerConditionCrontab) startCondition).Schedule; var endCron = (ContextConditionDescriptorCrontab) spec.EndCondition; var scheduleEnd = ScheduleExpressionUtil.CrontabScheduleBuild( endCron.Evaluators, controller.Realization.AgentInstanceContextCreate); var importService = controller.Realization.AgentInstanceContextCreate.ImportServiceRuntime; var time = controller.Realization.AgentInstanceContextCreate.SchedulingService.Time; var nextScheduledStartTime = ScheduleComputeHelper.ComputeNextOccurance( scheduleStart, time, importService.TimeZone, importService.TimeAbacus); var nextScheduledEndTime = ScheduleComputeHelper.ComputeNextOccurance( scheduleEnd, time, importService.TimeZone, importService.TimeAbacus); return nextScheduledStartTime >= nextScheduledEndTime; } if (startCondition.Descriptor is ContextConditionDescriptorTimePeriod) { var descriptor = (ContextConditionDescriptorTimePeriod) startCondition.Descriptor; var endTime = descriptor.GetExpectedEndTime(controller.Realization); if (endTime != null && endTime <= 0) { return true; } } return startCondition is ContextConditionDescriptorImmediate; }
public static bool DetermineCurrentlyRunning( ContextControllerCondition startCondition, ContextControllerInitTerm controller) { if (startCondition.IsImmediate) { return true; } var factory = controller.InitTermFactory; var spec = factory.InitTermSpec; if (spec.IsOverlapping) { return false; } // we are not currently running if either of the endpoints is not crontab-triggered if (spec.StartCondition is ContextConditionDescriptorCrontab && spec.EndCondition is ContextConditionDescriptorCrontab) { ScheduleSpec[] schedulesStart = ((ContextControllerConditionCrontab) startCondition).Schedules; var endCron = (ContextConditionDescriptorCrontab) spec.EndCondition; var schedulesEnd = new ScheduleSpec[endCron.EvaluatorsPerCrontab.Length]; for (var i = 0; i < schedulesEnd.Length; i++) { schedulesEnd[i] = ScheduleExpressionUtil.CrontabScheduleBuild( endCron.EvaluatorsPerCrontab[i], controller.Realization.AgentInstanceContextCreate); } var classpathImportService = controller.Realization.AgentInstanceContextCreate.ImportServiceRuntime; var time = controller.Realization.AgentInstanceContextCreate.SchedulingService.Time; var nextScheduledStartTime = ComputeScheduleMinimumNextOccurance(schedulesStart, time, classpathImportService); var nextScheduledEndTime = ComputeScheduleMinimumNextOccurance(schedulesEnd, time, classpathImportService); return nextScheduledStartTime >= nextScheduledEndTime; } if (startCondition.Descriptor is ContextConditionDescriptorTimePeriod) { var descriptor = (ContextConditionDescriptorTimePeriod) startCondition.Descriptor; var endTime = descriptor.GetExpectedEndTime(controller.Realization); if (endTime != null && endTime <= 0) { return true; } } return startCondition is ContextConditionDescriptorImmediate; }
private ContextDetailMatchPair ValidateRewriteContextCondition( bool isStartCondition, int nestingLevel, ContextSpecCondition endpoint, ISet<string> eventTypesReferenced, MatchEventSpec priorMatches, ISet<string> priorAllTags, CreateContextValidationEnv validationEnv) { if (endpoint is ContextSpecConditionCrontab) { var crontab = (ContextSpecConditionCrontab) endpoint; var forgesPerCrontab = new ExprForge[crontab.Crontabs.Count][]; for (int i = 0; i < crontab.Crontabs.Count; i++) { var item = crontab.Crontabs[i]; var forges = ScheduleExpressionUtil.CrontabScheduleValidate( ExprNodeOrigin.CONTEXTCONDITION, item, false, validationEnv.StatementRawInfo, validationEnv.Services); forgesPerCrontab[i] = forges; } crontab.ForgesPerCrontab = forgesPerCrontab; validationEnv.ScheduleHandleCallbackProviders.Add(crontab); return new ContextDetailMatchPair( crontab, new MatchEventSpec(), new LinkedHashSet<string>(), EmptyList<StmtClassForgeableFactory>.Instance); } if (endpoint is ContextSpecConditionTimePeriod) { var timePeriod = (ContextSpecConditionTimePeriod) endpoint; var validationContext = new ExprValidationContextBuilder( new StreamTypeServiceImpl(false), validationEnv.StatementRawInfo, validationEnv.Services).Build(); ExprNodeUtilityValidate.GetValidatedSubtree( ExprNodeOrigin.CONTEXTCONDITION, timePeriod.TimePeriod, validationContext); if (timePeriod.TimePeriod.IsConstantResult) { if (timePeriod.TimePeriod.EvaluateAsSeconds(null, true, null) < 0) { throw new ExprValidationException( "Invalid negative time period expression '" + ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(timePeriod.TimePeriod) + "'"); } } validationEnv.ScheduleHandleCallbackProviders.Add(timePeriod); return new ContextDetailMatchPair( timePeriod, new MatchEventSpec(), new LinkedHashSet<string>(), EmptyList<StmtClassForgeableFactory>.Instance); } if (endpoint is ContextSpecConditionPattern) { var pattern = (ContextSpecConditionPattern) endpoint; var matches = ValidatePatternContextConditionPattern( isStartCondition, nestingLevel, pattern, eventTypesReferenced, priorMatches, priorAllTags, validationEnv); var validatedDesc = ValidatePatternContextConditionPattern( isStartCondition, nestingLevel, pattern, eventTypesReferenced, priorMatches, priorAllTags, validationEnv); return new ContextDetailMatchPair( pattern, validatedDesc.MatchEventSpec, validatedDesc.AllTags, validatedDesc.AdditionalForgeables); } if (endpoint is ContextSpecConditionFilter) { var filter = (ContextSpecConditionFilter) endpoint; ValidateNotTable(filter.FilterSpecRaw.EventTypeName, validationEnv.Services); // compile as filter if there are no prior match to consider if (priorMatches == null || priorMatches.ArrayEventTypes.IsEmpty() && priorMatches.TaggedEventTypes.IsEmpty()) { var rawExpr = new FilterStreamSpecRaw( filter.FilterSpecRaw, ViewSpec.EMPTY_VIEWSPEC_ARRAY, null, StreamSpecOptions.DEFAULT); var compiledDesc = StreamSpecCompiler.Compile( rawExpr, eventTypesReferenced, false, false, true, false, filter.OptionalFilterAsName, 0, validationEnv.StatementRawInfo, validationEnv.Services); var compiled = (FilterStreamSpecCompiled) compiledDesc.StreamSpecCompiled; filter.FilterSpecCompiled = compiled.FilterSpecCompiled; var matchEventSpec = new MatchEventSpec(); var filterForType = compiled.FilterSpecCompiled.FilterForEventType; var allTags = new LinkedHashSet<string>(); if (filter.OptionalFilterAsName != null) { matchEventSpec.TaggedEventTypes.Put( filter.OptionalFilterAsName, new Pair<EventType, string>(filterForType, rawExpr.RawFilterSpec.EventTypeName)); allTags.Add(filter.OptionalFilterAsName); } validationEnv.FilterSpecCompileds.Add(compiled.FilterSpecCompiled); var serdeForgeables = SerdeEventTypeUtility.Plan( filter.FilterSpecCompiled.FilterForEventType, validationEnv.StatementRawInfo, validationEnv.Services.SerdeEventTypeRegistry, validationEnv.Services.SerdeResolver); var allForgeables = compiledDesc.AdditionalForgeables .Concat(serdeForgeables) .ToList(); return new ContextDetailMatchPair(filter, matchEventSpec, allTags, allForgeables); } // compile as pattern if there are prior matches to consider, since this is a type of followed-by relationship EvalForgeNode forgeNode = new EvalFilterForgeNode(validationEnv.Services.IsAttachPatternText, filter.FilterSpecRaw, filter.OptionalFilterAsName, 0); var pattern = new ContextSpecConditionPattern(forgeNode, true, false); var validated = ValidatePatternContextConditionPattern( isStartCondition, nestingLevel, pattern, eventTypesReferenced, priorMatches, priorAllTags, validationEnv); return new ContextDetailMatchPair(pattern, validated.MatchEventSpec, validated.AllTags, validated.AdditionalForgeables); } if (endpoint is ContextSpecConditionImmediate || endpoint is ContextSpecConditionNever) { return new ContextDetailMatchPair( endpoint, new MatchEventSpec(), new LinkedHashSet<String>(), EmptyList<StmtClassForgeableFactory>.Instance); } throw new IllegalStateException("Unrecognized endpoint type " + endpoint); }