/// <summary>Ctor. </summary> /// <param name="services">engine services</param> /// <param name="runtime">runtime to process</param> /// <param name="handle">statement handle</param> /// <param name="callbackObject">callback list</param> public TimerUnitMultiple(EPServicesContext services, EPRuntimeImpl runtime, EPStatementAgentInstanceHandle handle, object callbackObject) { _services = services; _handle = handle; _runtime = runtime; _callbackObject = callbackObject; }
public void InitThreading(EPServicesContext services, EPRuntimeImpl runtime) { if (_isInboundThreading) { _inboundQueue = MakeQueue(_config.ThreadPoolInboundCapacity, _config.ThreadPoolInboundBlocking); _inboundThreadPool = GetThreadPool(services.EngineURI, "Inbound", _inboundQueue, _config.ThreadPoolInboundNumThreads); } if (_isTimerThreading) { _timerQueue = MakeQueue(_config.ThreadPoolTimerExecCapacity, _config.ThreadPoolTimerExecBlocking); _timerThreadPool = GetThreadPool(services.EngineURI, "TimerExec", _timerQueue, _config.ThreadPoolTimerExecNumThreads); } if (_isRouteThreading) { _routeQueue = MakeQueue(_config.ThreadPoolRouteExecCapacity, _config.ThreadPoolRouteExecBlocking); _routeThreadPool = GetThreadPool(services.EngineURI, "RouteExec", _routeQueue, _config.ThreadPoolRouteExecNumThreads); } if (_isOutboundThreading) { _outboundQueue = MakeQueue(_config.ThreadPoolOutboundCapacity, _config.ThreadPoolOutboundBlocking); _outboundThreadPool = GetThreadPool(services.EngineURI, "Outbound", _outboundQueue, _config.ThreadPoolOutboundNumThreads); } }
/// <summary>Ctor. </summary> /// <param name="properties">to send</param> /// <param name="eventTypeName">type name</param> /// <param name="services">to wrap</param> /// <param name="runtime">to process</param> public InboundUnitSendObjectArray(Object[] properties, String eventTypeName, EPServicesContext services, EPRuntimeImpl runtime) { _eventTypeName = eventTypeName; _properties = properties; _services = services; _runtime = runtime; }
/// <summary>Ctor. </summary> /// <param name="theEvent">document</param> /// <param name="services">for wrapping event</param> /// <param name="runtime">runtime to process</param> public InboundUnitSendLINQ(XElement theEvent, EPServicesContext services, EPRuntimeImpl runtime) { _event = theEvent; _services = services; _runtime = runtime; }
/// <summary>Ctor. </summary> /// <param name="theEvent">document</param> /// <param name="services">for wrapping event</param> /// <param name="runtime">runtime to process</param> public InboundUnitSendDOM(XmlNode theEvent, EPServicesContext services, EPRuntimeImpl runtime) { _event = theEvent; _services = services; _runtime = runtime; }
/// <summary>Ctor. </summary> /// <param name="epRuntime">runtime to process</param> /// <param name="callbackList">callback list</param> /// <param name="theEvent">event to pass</param> /// <param name="handle">statement handle</param> /// <param name="filterVersion">version of filter</param> public RouteUnitMultiple(EPRuntimeImpl epRuntime, Object callbackList, EventBean theEvent, EPStatementAgentInstanceHandle handle, long filterVersion) { _epRuntime = epRuntime; _callbackList = callbackList; _theEvent = theEvent; _handle = handle; _filterVersion = filterVersion; }
/// <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(EPRuntimeImpl epRuntime, EPStatementHandleCallback handleCallback, EventBean theEvent, long filterVersion) { _epRuntime = epRuntime; _event = theEvent; _handleCallback = handleCallback; _filterVersion = filterVersion; }
/// <summary>Ctor. </summary> /// <param name="map">to send</param> /// <param name="eventTypeName">type name</param> /// <param name="services">to wrap</param> /// <param name="runtime">to process</param> public InboundUnitSendMap(DataMap map, String eventTypeName, EPServicesContext services, EPRuntimeImpl runtime) { _eventTypeName = eventTypeName; _map = map; _services = services; _runtime = runtime; }
/// <summary> /// Ctor. /// </summary> /// <param name="genericRecordDotData">to send</param> /// <param name="eventTypeName">type name</param> /// <param name="services">to wrap</param> /// <param name="runtime">to process</param> public InboundUnitSendAvro( Object genericRecordDotData, string eventTypeName, EPServicesContext services, EPRuntimeImpl runtime) { this._eventTypeName = eventTypeName; this._genericRecordDotData = genericRecordDotData; this._services = services; this._runtime = runtime; }
public void Run() { try { EPRuntimeImpl.ProcessStatementScheduleSingle(_handleCallback, _services); _runtime.Dispatch(); _runtime.ProcessThreadWorkQueue(); } catch (Exception e) { Log.Error("Unexpected error processing timer execution: " + e.Message, e); } }
public void Run() { try { EPRuntimeImpl.ProcessStatementScheduleMultiple(_handle, _callbackObject, _services); // Let listeners know of results _runtime.Dispatch(); // Work off the event queue if any events accumulated in there via a Route() _runtime.ProcessThreadWorkQueue(); } catch (Exception e) { Log.Error("Unexpected error processing multiple timer execution: " + e.Message, e); } }
/// <summary>Ctor. </summary> /// <param name="services">engine services</param> /// <param name="runtime">runtime to process</param> /// <param name="handleCallback">callback</param> public TimerUnitSingle(EPServicesContext services, EPRuntimeImpl runtime, EPStatementHandleCallback handleCallback) { _services = services; _runtime = runtime; _handleCallback = handleCallback; }
private void ProcessScheduleHandles(ArrayBackedCollection <ScheduleHandle> handles) { if (ThreadLogUtil.ENABLED_TRACE) { ThreadLogUtil.Trace("Found schedules for", handles.Count); } if (handles.Count == 0) { return; } // handle 1 result separatly for performance reasons if (handles.Count == 1) { Object[] handleArray = handles.Array; var handle = (EPStatementHandleCallback)handleArray[0]; EPRuntimeImpl.ProcessStatementScheduleSingle(handle, _unisolatedServices); handles.Clear(); return; } Object[] matchArray = handles.Array; int entryCount = handles.Count; LinkedList <ScheduleHandleCallback> entries; // sort multiple matches for the event into statements var stmtCallbacks = SchedulePerStmt; stmtCallbacks.Clear(); for (int i = 0; i < entryCount; i++) { var handleCallback = (EPStatementHandleCallback)matchArray[i]; var handle = handleCallback.AgentInstanceHandle; var callback = handleCallback.ScheduleCallback; var entry = stmtCallbacks.Get(handle); // This statement has not been encountered before if (entry == null) { stmtCallbacks.Put(handle, callback); continue; } // This statement has been encountered once before if (entry is ScheduleHandleCallback) { var existingCallback = (ScheduleHandleCallback)entry; entries = new LinkedList <ScheduleHandleCallback>(); entries.AddLast(existingCallback); entries.AddLast(callback); stmtCallbacks.Put(handle, entries); continue; } // This statement has been encountered more then once before entries = (LinkedList <ScheduleHandleCallback>)entry; entries.AddLast(callback); } handles.Clear(); foreach (var entry in stmtCallbacks) { var handle = entry.Key; var callbackObject = entry.Value; EPRuntimeImpl.ProcessStatementScheduleMultiple(handle, callbackObject, _unisolatedServices); if ((_isPrioritized) && (handle.IsPreemptive)) { break; } } }
/// <summary>Ctor. </summary> /// <param name="theEvent">to process</param> /// <param name="runtime">to process event</param> public InboundUnitSendEvent(Object theEvent, EPRuntimeImpl runtime) { _event = theEvent; _runtime = runtime; }
/// <summary> /// Performs the initialization. /// </summary> /// <param name="startTime">optional start time</param> protected void DoInitialize(long?startTime) { Log.Info("Initializing engine URI '" + _engineURI + "' version " + Version.VERSION); // This setting applies to all engines in a given VM ExecutionPathDebugLog.IsEnabled = _configSnapshot.EngineDefaults.Logging.IsEnableExecutionDebug; ExecutionPathDebugLog.IsTimerDebugEnabled = _configSnapshot.EngineDefaults.Logging.IsEnableTimerDebug; // This setting applies to all engines in a given VM MetricReportingPath.IsMetricsEnabled = _configSnapshot.EngineDefaults.MetricsReporting.IsEnableMetricsReporting; // This setting applies to all engines in a given VM AuditPath.AuditPattern = _configSnapshot.EngineDefaults.Logging.AuditPattern; // This setting applies to all engines in a given VM ThreadingOption.IsThreadingEnabled = ( ThreadingOption.IsThreadingEnabled || _configSnapshot.EngineDefaults.Threading.IsThreadPoolTimerExec || _configSnapshot.EngineDefaults.Threading.IsThreadPoolInbound || _configSnapshot.EngineDefaults.Threading.IsThreadPoolRouteExec || _configSnapshot.EngineDefaults.Threading.IsThreadPoolOutbound ); if (_engine != null) { _engine.Services.TimerService.StopInternalClock(false); // Give the timer thread a little moment to catch up Thread.Sleep(100); if (_configSnapshot.EngineDefaults.MetricsReporting.IsEnableMetricsReporting) { DestroyEngineMetrics(_engine.Services.EngineURI); } _engine.Runtime.Initialize(); _engine.Services.Dispose(); } // Make EP services context factory var epServicesContextFactoryClassName = _configSnapshot.EPServicesContextFactoryClassName; EPServicesContextFactory epServicesContextFactory; if (epServicesContextFactoryClassName == null) { // Check system properties epServicesContextFactoryClassName = Environment.GetEnvironmentVariable("ESPER_EPSERVICE_CONTEXT_FACTORY_CLASS"); } if (epServicesContextFactoryClassName == null) { epServicesContextFactory = new EPServicesContextFactoryDefault(); } else { Type clazz; try { clazz = TransientConfigurationResolver.ResolveClassForNameProvider( _configSnapshot.TransientConfiguration).ClassForName(epServicesContextFactoryClassName); } catch (TypeLoadException) { throw new ConfigurationException( "Type '" + epServicesContextFactoryClassName + "' cannot be loaded"); } Object obj; try { obj = Activator.CreateInstance(clazz); } catch (TypeLoadException) { throw new ConfigurationException("Class '" + clazz + "' cannot be instantiated"); } catch (MissingMethodException e) { throw new ConfigurationException( "Error instantiating class - Default constructor was not found", e); } catch (MethodAccessException e) { throw new ConfigurationException( "Error instantiating class - Caller does not have permission to use constructor", e); } catch (ArgumentException e) { throw new ConfigurationException("Error instantiating class - Type is not a RuntimeType", e); } epServicesContextFactory = (EPServicesContextFactory)obj; } var services = epServicesContextFactory.CreateServicesContext(this, _configSnapshot); // New runtime EPRuntimeSPI runtimeSPI; InternalEventRouteDest routeDest; TimerCallback timerCallback; var runtimeClassName = _configSnapshot.EngineDefaults.AlternativeContext.Runtime; if (runtimeClassName == null) { // Check system properties runtimeClassName = Environment.GetEnvironmentVariable("ESPER_EPRUNTIME_CLASS"); } if (runtimeClassName == null) { var runtimeImpl = new EPRuntimeImpl(services); runtimeSPI = runtimeImpl; routeDest = runtimeImpl; timerCallback = runtimeImpl.TimerCallback; } else { Type clazz; try { clazz = TypeHelper.ResolveType(runtimeClassName, true); } catch (TypeLoadException) { throw new ConfigurationException("Class '" + runtimeClassName + "' cannot be loaded"); } Object obj; try { var c = clazz.GetConstructor(new[] { typeof(EPServicesContext) }); obj = c.Invoke(new object[] { services }); } catch (TypeLoadException) { throw new ConfigurationException("Class '" + clazz + "' cannot be instantiated"); } catch (MissingMethodException) { throw new ConfigurationException( "Class '" + clazz + "' cannot be instantiated, constructor accepting services was not found"); } catch (MethodAccessException) { throw new ConfigurationException("Illegal access instantiating class '" + clazz + "'"); } runtimeSPI = (EPRuntimeSPI)obj; routeDest = (InternalEventRouteDest)obj; timerCallback = (TimerCallback)obj; } routeDest.InternalEventRouter = services.InternalEventRouter; services.InternalEventEngineRouteDest = routeDest; // set current time, if applicable if (startTime != null) { services.SchedulingService.Time = startTime.Value; } // Configure services to use the new runtime services.TimerService.Callback = timerCallback; // Statement lifecycle init services.StatementLifecycleSvc.Init(); // Filter service init services.FilterService.Init(); // Schedule service init services.SchedulingService.Init(); // New admin var configOps = new ConfigurationOperationsImpl( services.EventAdapterService, services.EventTypeIdGenerator, services.EngineImportService, services.VariableService, services.EngineSettingsService, services.ValueAddEventService, services.MetricsReportingService, services.StatementEventTypeRefService, services.StatementVariableRefService, services.PlugInViews, services.FilterService, services.PatternSubexpressionPoolSvc, services.MatchRecognizeStatePoolEngineSvc, services.TableService, _configSnapshot.TransientConfiguration); var defaultStreamSelector = SelectClauseStreamSelectorEnumExtensions.MapFromSODA( _configSnapshot.EngineDefaults.StreamSelection.DefaultStreamSelector); EPAdministratorSPI adminSPI; var adminClassName = _configSnapshot.EngineDefaults.AlternativeContext.Admin; var adminContext = new EPAdministratorContext(runtimeSPI, services, configOps, defaultStreamSelector); if (adminClassName == null) { // Check system properties adminClassName = Environment.GetEnvironmentVariable("ESPER_EPADMIN_CLASS"); } if (adminClassName == null) { adminSPI = new EPAdministratorImpl(adminContext); } else { Type clazz; try { clazz = TypeHelper.ResolveType(adminClassName, true); } catch (TypeLoadException) { throw new ConfigurationException( "Class '" + epServicesContextFactoryClassName + "' cannot be loaded"); } Object obj; try { var c = clazz.GetConstructor(new[] { typeof(EPAdministratorContext) }); obj = c.Invoke(new[] { adminContext }); } catch (TypeLoadException) { throw new ConfigurationException("Class '" + clazz + "' cannot be instantiated"); } catch (MissingMethodException) { throw new ConfigurationException( "Class '" + clazz + "' cannot be instantiated, constructor accepting context was not found"); } catch (MethodAccessException) { throw new ConfigurationException("Illegal access instantiating class '" + clazz + "'"); } adminSPI = (EPAdministratorSPI)obj; } // Start clocking if (_configSnapshot.EngineDefaults.Threading.IsInternalTimerEnabled) { if (_configSnapshot.EngineDefaults.TimeSource.TimeUnit != TimeUnit.MILLISECONDS) { throw new ConfigurationException("Internal timer requires millisecond time resolution"); } services.TimerService.StartInternalClock(); } // Give the timer thread a little moment to start up Thread.Sleep(100); // Save engine instance _engine = new EPServiceEngine(services, runtimeSPI, adminSPI); // Load and initialize adapter loader classes LoadAdapters(services); // Initialize extension services if (services.EngineLevelExtensionServicesContext != null) { services.EngineLevelExtensionServicesContext.Init(services, runtimeSPI, adminSPI); } // Start metrics reporting, if any if (_configSnapshot.EngineDefaults.MetricsReporting.IsEnableMetricsReporting) { services.MetricsReportingService.SetContext(runtimeSPI, services); } // Start engine metrics report if (_configSnapshot.EngineDefaults.MetricsReporting.IsEnableMetricsReporting) { StartEngineMetrics(services, runtimeSPI); } // register with the statement lifecycle service services.StatementLifecycleSvc.LifecycleEvent += HandleLifecycleEvent; // call initialize listeners try { if (ServiceInitialized != null) { ServiceInitialized(this, new ServiceProviderEventArgs(this)); } } catch (Exception ex) { Log.Error("Runtime exception caught during an ServiceInitialized event:" + ex.Message, ex); } }