private void TryIsolated(int numThreads, int numLoops)
{
Configuration config = SupportConfigFactory.GetConfiguration();
config.EngineDefaults.ViewResourcesConfig.IsShareViews = false;
config.EngineDefaults.ExecutionConfig.IsAllowIsolatedService = true;
config.AddEventType("SupportBean", typeof(SupportBean));
EPServiceProvider engine = EPServiceProviderManager.GetDefaultProvider(config);
engine.Initialize();
// execute
var threadPool = Executors.NewFixedThreadPool(numThreads);
var future = new Future <bool> [numThreads];
var sharedStartLock = ReaderWriterLockManager.CreateLock(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
using (sharedStartLock.AcquireWriteLock())
{
for (int i = 0; i < numThreads; i++)
{
var isolate = new IsolateUnisolateCallable(i, engine, numLoops);
future[i] = threadPool.Submit((Func <bool>)isolate.Call);
}
Thread.Sleep(100);
}
threadPool.Shutdown();
threadPool.AwaitTermination(new TimeSpan(0, 0, 10));
for (int i = 0; i < numThreads; i++)
{
Assert.IsTrue(future[i].GetValueOrDefault());
}
}
private void ScheduleNextCallback()
{
var nextScheduleCallback = new ProxyScheduleHandleCallback(delegate { ContinueSendingEvents(); });
var spi = (EPServiceProviderSPI)_epService;
var metricsHandle = spi.MetricReportingService.GetStatementHandle(-1, "AbstractCoordinatedAdapter");
var lockImpl = ReaderWriterLockManager.CreateLock("CSV");
var stmtHandle = new EPStatementHandle(-1, "AbstractCoordinatedAdapter", null, StatementType.ESPERIO, "AbstractCoordinatedAdapter", false, metricsHandle, 0, false, false, spi.ServicesContext.MultiMatchHandlerFactory.GetDefaultHandler());
var agentInstanceHandle = new EPStatementAgentInstanceHandle(stmtHandle, lockImpl, -1, new StatementAgentInstanceFilterVersion(), null);
var scheduleCSVHandle = new EPStatementHandleCallback(agentInstanceHandle, nextScheduleCallback);
ScheduleSlot nextScheduleSlot;
if (EventsToSend.IsEmpty())
{
if ((ExecutionPathDebugLog.IsEnabled) && (Log.IsDebugEnabled))
{
Log.Debug(".scheduleNextCallback no events to send, scheduling callback in 100 ms");
}
nextScheduleSlot = new ScheduleSlot(0, 0);
_schedulingService.Add(100, scheduleCSVHandle, nextScheduleSlot);
}
else
{
// Offset is not a function of the currentTime alone.
var first = EventsToSend.First();
long baseMsec = _currentTime - _startTime;
long afterMsec = first.SendTime - baseMsec;
nextScheduleSlot = first.ScheduleSlot;
if ((ExecutionPathDebugLog.IsEnabled) && (Log.IsDebugEnabled))
{
Log.Debug(".scheduleNextCallback schedulingCallback in " + afterMsec + " milliseconds");
}
_schedulingService.Add(afterMsec, scheduleCSVHandle, nextScheduleSlot);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ObsoleteConcurrentDictionary<K, V>"/> class.
/// </summary>
/// <param name="subDictionary">The sub dictionary.</param>
public ObsoleteConcurrentDictionary(IDictionary <K, V> subDictionary)
{
_subDictionary = subDictionary;
_rwLock = ReaderWriterLockManager.CreateLock(GetType());
_rLock = _rwLock.ReadLock;
_wLock = _rwLock.WriteLock;
}
private void TryChainedCountSum(int numThreads, int numEvents)
{
Configuration config = SupportConfigFactory.GetConfiguration();
config.EngineDefaults.ThreadingConfig.IsInternalTimerEnabled = false;
// This should fail all test in this class
// config.EngineDefaults.ThreadingConfig.InsertIntoDispatchPreserveOrder = false;
EPServiceProvider engine = EPServiceProviderManager.GetDefaultProvider(config);
engine.Initialize();
// setup statements
EPStatement stmtInsertOne = engine.EPAdministrator.CreateEPL("insert into MyStreamOne select count(*) as cnt from " + typeof(SupportBean).FullName);
EPStatement stmtInsertTwo = engine.EPAdministrator.CreateEPL("insert into MyStreamTwo select sum(cnt) as mysum from MyStreamOne");
EPStatement stmtInsertThree = engine.EPAdministrator.CreateEPL("select * from MyStreamTwo");
SupportUpdateListener listener = new SupportUpdateListener();
stmtInsertThree.Events += listener.Update;
#if false
stmtInsertThree.Events += (sender, eargs) =>
{
Console.WriteLine("Event: {0}", eargs.NewEvents[0].Get("mysum"));
};
#endif
// execute
var threadPool = Executors.NewFixedThreadPool(numThreads);
var future = new Future <bool> [numThreads];
var sharedStartLock = ReaderWriterLockManager.CreateLock(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
using (sharedStartLock.AcquireWriteLock()) {
for (int i = 0; i < numThreads; i++)
{
future[i] = threadPool.Submit(
new SendEventRWLockCallable(i, sharedStartLock.ReadLock, engine, EnumerationGenerator.Create(numEvents)));
}
Thread.Sleep(100);
}
threadPool.Shutdown();
threadPool.AwaitTermination(new TimeSpan(0, 0, 10));
for (int i = 0; i < numThreads; i++)
{
Assert.IsTrue((bool)future[i].GetValueOrDefault());
}
// assert result
EventBean[] newEvents = listener.GetNewDataListFlattened();
for (int i = 0; i < numEvents - 1; i++)
{
long expected = Total(i + 1);
Assert.AreEqual(expected, newEvents[i].Get("mysum"));
}
stmtInsertOne.Dispose();
stmtInsertTwo.Dispose();
stmtInsertThree.Dispose();
}
private void TrySendCountFollowedBy(int numThreads, int numEvents, ConfigurationEngineDefaults.Threading.Locking locking)
{
var config = SupportConfigFactory.GetConfiguration();
config.EngineDefaults.ThreadingConfig.InsertIntoDispatchLocking = locking;
config.EngineDefaults.ThreadingConfig.InsertIntoDispatchTimeout = 5000; // 5 second timeout
// This should fail all test in this class
// config.EngineDefaults.ThreadingConfig.InsertIntoDispatchPreserveOrder = false;
var engine = EPServiceProviderManager.GetDefaultProvider(config);
engine.Initialize();
// setup statements
var stmtInsert = engine.EPAdministrator.CreateEPL("insert into MyStream select count(*) as cnt from " + typeof(SupportBean).FullName);
stmtInsert.Events += ((sender, e) => Log.Debug(".Update cnt=" + e.NewEvents[0].Get("cnt")));
var listeners = new SupportUpdateListener[numEvents];
for (var i = 0; i < numEvents; i++)
{
var text = "select * from pattern [MyStream(cnt=" + (i + 1) + ") -> MyStream(cnt=" + (i + 2) + ")]";
var stmt = engine.EPAdministrator.CreateEPL(text);
listeners[i] = new SupportUpdateListener();
stmt.Events += listeners[i].Update;
}
// execute
var threadPool = Executors.NewFixedThreadPool(numThreads);
var future = new Future <bool> [numThreads];
var sharedStartLock = ReaderWriterLockManager.CreateLock(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
using (sharedStartLock.AcquireWriteLock()) {
for (var i = 0; i < numThreads; i++)
{
future[i] = threadPool.Submit(new SendEventRWLockCallable(
i, sharedStartLock.ReadLock, engine,
EnumerationGenerator.Create(numEvents)));
}
Thread.Sleep(100);
}
threadPool.Shutdown();
threadPool.AwaitTermination(new TimeSpan(0, 0, 10));
for (var i = 0; i < numThreads; i++)
{
Assert.IsTrue((bool)future[i].GetValueOrDefault());
}
// assert result
for (var i = 0; i < numEvents - 1; i++)
{
Assert.AreEqual(1, listeners[i].NewDataList.Count, "Listener not invoked: #" + i);
}
}
// Statements ids to remove with the next flush
/// <summary>Ctor. </summary>
/// <param name="engineURI">engine URI</param>
/// <param name="name">name of statement group</param>
/// <param name="initialSize">initial size of array</param>
/// <param name="isReportInactive">true to indicate to report on inactive statements</param>
public StatementMetricArray(String engineURI, String name, int initialSize, bool isReportInactive)
{
this.engineURI = engineURI;
this.isReportInactive = isReportInactive;
metrics = new StatementMetric[initialSize];
statementNames = new String[initialSize];
currentLastElement = -1;
rwLock = ReaderWriterLockManager.CreateLock(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
removedStatementNames = new HashSet <String>();
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="startVersion">the first version number to start from</param>
/// <param name="millisecondLifetimeOldVersions">number of milliseconds a version may hang around before expiry</param>
/// <param name="timeProvider">provides the current time</param>
/// <param name="optionalStateHandler">a optional plug-in that may store variable state and retrieve state upon creation</param>
/// <param name="eventAdapterService">for finding event types</param>
public VariableServiceImpl(int startVersion, long millisecondLifetimeOldVersions, TimeProvider timeProvider, EventAdapterService eventAdapterService, VariableStateHandler optionalStateHandler)
{
_millisecondLifetimeOldVersions = millisecondLifetimeOldVersions;
_timeProvider = timeProvider;
_eventAdapterService = eventAdapterService;
_optionalStateHandler = optionalStateHandler;
_variables = new Dictionary <String, VariableMetaData>().WithNullSupport();
_readWriteLock = ReaderWriterLockManager.CreateLock(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
_variableVersionsPerCP = new List <ConcurrentDictionary <int, VariableReader> >();
_changeCallbacksPerCP = new List <IDictionary <int, ICollection <VariableChangeCallback> > >();
_currentVersionNumber = startVersion;
}
/// <summary>Ctor. </summary>
/// <param name="variableService">variables</param>
public StatementVariableRefImpl(VariableService variableService, TableService tableService)
{
_variableToStmt = new Dictionary <String, ICollection <String> >().WithNullSupport();
_stmtToVariable = new Dictionary <String, ICollection <String> >().WithNullSupport();
_mapLock = ReaderWriterLockManager.CreateLock(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
_variableService = variableService;
_tableService = tableService;
_configuredVariables = new HashSet <String>();
foreach (KeyValuePair <String, VariableReader> entry in variableService.VariableReadersNonCP)
{
_configuredVariables.Add(entry.Key);
}
}
/// <summary>Ctor. </summary>
public StatementEventTypeRefImpl()
{
_typeToStmt = new Dictionary <String, ICollection <String> >();
_stmtToType = new Dictionary <String, String[]>();
_mapLock = ReaderWriterLockManager.CreateLock(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
}
public EPServicesContext CreateServicesContext(EPServiceProvider epServiceProvider, ConfigurationInformation configSnapshot)
{
// Directory for binding resources
var resourceDirectory = new SimpleServiceDirectory();
EventTypeIdGenerator eventTypeIdGenerator;
if (configSnapshot.EngineDefaults.AlternativeContextConfig == null || configSnapshot.EngineDefaults.AlternativeContextConfig.EventTypeIdGeneratorFactory == null)
{
eventTypeIdGenerator = new EventTypeIdGeneratorImpl();
}
else
{
var eventTypeIdGeneratorFactory = TypeHelper.Instantiate <EventTypeIdGeneratorFactory>(
configSnapshot.EngineDefaults.AlternativeContextConfig.EventTypeIdGeneratorFactory);
eventTypeIdGenerator = eventTypeIdGeneratorFactory.Create(new EventTypeIdGeneratorContext(epServiceProvider.URI));
}
// Make services that depend on snapshot config entries
var eventAdapterService = new EventAdapterServiceImpl(eventTypeIdGenerator, configSnapshot.EngineDefaults.EventMetaConfig.AnonymousCacheSize);
Init(eventAdapterService, configSnapshot);
// New read-write lock for concurrent event processing
var eventProcessingRwLock = ReaderWriterLockManager.CreateLock(
MethodBase.GetCurrentMethod().DeclaringType);
var timeSourceService = MakeTimeSource(configSnapshot);
var schedulingService = SchedulingServiceProvider.NewService(timeSourceService);
var schedulingMgmtService = new SchedulingMgmtServiceImpl();
var engineImportService = MakeEngineImportService(configSnapshot);
var engineSettingsService = new EngineSettingsService(configSnapshot.EngineDefaults, configSnapshot.PlugInEventTypeResolutionURIs);
var databaseConfigService = MakeDatabaseRefService(configSnapshot, schedulingService, schedulingMgmtService);
var plugInViews = new PluggableObjectCollection();
plugInViews.AddViews(configSnapshot.PlugInViews, configSnapshot.PlugInVirtualDataWindows);
var plugInPatternObj = new PluggableObjectCollection();
plugInPatternObj.AddPatternObjects(configSnapshot.PlugInPatternObjects);
// exception handling
ExceptionHandlingService exceptionHandlingService = InitExceptionHandling(
epServiceProvider.URI,
configSnapshot.EngineDefaults.ExceptionHandlingConfig,
configSnapshot.EngineDefaults.ConditionHandlingConfig);
// Statement context factory
Type systemVirtualDWViewFactory = null;
if (configSnapshot.EngineDefaults.AlternativeContextConfig.VirtualDataWindowViewFactory != null)
{
try {
systemVirtualDWViewFactory = TypeHelper.ResolveType(configSnapshot.EngineDefaults.AlternativeContextConfig.VirtualDataWindowViewFactory);
if (!systemVirtualDWViewFactory.IsImplementsInterface(typeof(VirtualDataWindowFactory)))
{
throw new ConfigurationException("Class " + systemVirtualDWViewFactory.Name + " does not implement the interface " + typeof(VirtualDataWindowFactory).FullName);
}
}
catch (TypeLoadException e) {
throw new ConfigurationException("Failed to look up class " + systemVirtualDWViewFactory);
}
}
StatementContextFactory statementContextFactory = new StatementContextFactoryDefault(plugInViews, plugInPatternObj, systemVirtualDWViewFactory);
long msecTimerResolution = configSnapshot.EngineDefaults.ThreadingConfig.InternalTimerMsecResolution;
if (msecTimerResolution <= 0)
{
throw new ConfigurationException("Timer resolution configuration not set to a valid value, expecting a non-zero value");
}
var timerService = new TimerServiceImpl(epServiceProvider.URI, msecTimerResolution);
var variableService = new VariableServiceImpl(configSnapshot.EngineDefaults.VariablesConfig.MsecVersionRelease, schedulingService, eventAdapterService, null);
InitVariables(variableService, configSnapshot.Variables, engineImportService);
var tableService = new TableServiceImpl();
var statementLockFactory = new StatementLockFactoryImpl(configSnapshot.EngineDefaults.ExecutionConfig.IsFairlock, configSnapshot.EngineDefaults.ExecutionConfig.IsDisableLocking);
var streamFactoryService = StreamFactoryServiceProvider.NewService(
epServiceProvider.URI,
configSnapshot.EngineDefaults.ViewResourcesConfig.IsShareViews);
var filterService = FilterServiceProvider.NewService(
configSnapshot.EngineDefaults.ExecutionConfig.FilterServiceProfile,
configSnapshot.EngineDefaults.ExecutionConfig.IsAllowIsolatedService);
var metricsReporting = new MetricReportingServiceImpl(configSnapshot.EngineDefaults.MetricsReportingConfig, epServiceProvider.URI);
var namedWindowService = new NamedWindowServiceImpl(
schedulingService,
variableService,
tableService,
engineSettingsService.EngineSettings.ExecutionConfig.IsPrioritized,
eventProcessingRwLock,
exceptionHandlingService,
configSnapshot.EngineDefaults.LoggingConfig.IsEnableQueryPlan,
metricsReporting);
var valueAddEventService = new ValueAddEventServiceImpl();
valueAddEventService.Init(configSnapshot.RevisionEventTypes, configSnapshot.VariantStreams, eventAdapterService, eventTypeIdGenerator);
var statementEventTypeRef = new StatementEventTypeRefImpl();
var statementVariableRef = new StatementVariableRefImpl(variableService, tableService);
var threadingService = new ThreadingServiceImpl(
configSnapshot.EngineDefaults.ThreadingConfig);
var internalEventRouterImpl = new InternalEventRouterImpl();
var statementIsolationService = new StatementIsolationServiceImpl();
DeploymentStateService deploymentStateService = new DeploymentStateServiceImpl();
StatementMetadataFactory stmtMetadataFactory;
if (configSnapshot.EngineDefaults.AlternativeContextConfig.StatementMetadataFactory == null)
{
stmtMetadataFactory = new StatementMetadataFactoryDefault();
}
else
{
stmtMetadataFactory = TypeHelper.Instantiate <StatementMetadataFactory>(configSnapshot.EngineDefaults.AlternativeContextConfig.StatementMetadataFactory);
}
ContextManagementService contextManagementService = new ContextManagementServiceImpl();
SchedulableAgentInstanceDirectory schedulableAgentInstanceDirectory = null; // not required for Non-HA.
PatternSubexpressionPoolEngineSvc patternSubexpressionPoolSvc = null;
if (configSnapshot.EngineDefaults.PatternsConfig.MaxSubexpressions != null)
{
patternSubexpressionPoolSvc = new PatternSubexpressionPoolEngineSvc(
configSnapshot.EngineDefaults.PatternsConfig.MaxSubexpressions.GetValueOrDefault(),
configSnapshot.EngineDefaults.PatternsConfig.IsMaxSubexpressionPreventStart);
}
MatchRecognizeStatePoolEngineSvc matchRecognizeStatePoolEngineSvc = null;
if (configSnapshot.EngineDefaults.MatchRecognizeConfig.MaxStates != null)
{
matchRecognizeStatePoolEngineSvc = new MatchRecognizeStatePoolEngineSvc(
configSnapshot.EngineDefaults.MatchRecognizeConfig.MaxStates.Value,
configSnapshot.EngineDefaults.MatchRecognizeConfig.IsMaxStatesPreventStart);
}
var scriptingService = new ScriptingServiceImpl();
scriptingService.DiscoverEngines();
// New services context
EPServicesContext services = new EPServicesContext(
epServiceProvider.URI, schedulingService,
eventAdapterService, engineImportService, engineSettingsService, databaseConfigService, plugInViews,
statementLockFactory, eventProcessingRwLock, null, resourceDirectory, statementContextFactory,
plugInPatternObj, timerService, filterService, streamFactoryService,
namedWindowService, variableService, tableService, timeSourceService, valueAddEventService, metricsReporting, statementEventTypeRef,
statementVariableRef, configSnapshot, threadingService, internalEventRouterImpl, statementIsolationService, schedulingMgmtService,
deploymentStateService, exceptionHandlingService, new PatternNodeFactoryImpl(), eventTypeIdGenerator, stmtMetadataFactory,
contextManagementService, schedulableAgentInstanceDirectory, patternSubexpressionPoolSvc, matchRecognizeStatePoolEngineSvc,
new DataFlowServiceImpl(epServiceProvider, new DataFlowConfigurationStateServiceImpl()),
new ExprDeclaredServiceImpl(),
new ContextControllerFactoryFactorySvcImpl(),
new ContextManagerFactoryServiceImpl(),
new EPStatementFactoryDefault(),
new RegexHandlerFactoryDefault(),
new ViewableActivatorFactoryDefault(),
scriptingService
);
// Engine services subset available to statements
statementContextFactory.StmtEngineServices = services;
// Circular dependency
var statementLifecycleSvc = new StatementLifecycleSvcImpl(epServiceProvider, services);
services.StatementLifecycleSvc = statementLifecycleSvc;
// Observers to statement events
statementLifecycleSvc.LifecycleEvent += (s, theEvent) => metricsReporting.Observe(theEvent);
// Circular dependency
statementIsolationService.ServicesContext = services;
return(services);
}
private void TryMultiInsertGroup(int numThreads, int numStatements, int numEvents)
{
var config = SupportConfigFactory.GetConfiguration();
// This should fail all test in this class
// config.EngineDefaults.ThreadingConfig.InsertIntoDispatchPreserveOrder = false;
var engine = EPServiceProviderManager.GetDefaultProvider(config);
engine.Initialize();
// setup statements
var insertIntoStmts = new EPStatement[numStatements];
for (var i = 0; i < numStatements; i++)
{
insertIntoStmts[i] = engine.EPAdministrator.CreateEPL("insert into MyStream select " + i + " as ident,count(*) as cnt from " + typeof(SupportBean).FullName);
}
var stmtInsertTwo = engine.EPAdministrator.CreateEPL("select ident, sum(cnt) as mysum from MyStream group by ident");
var listener = new SupportUpdateListener();
stmtInsertTwo.Events += listener.Update;
// execute
var threadPool = Executors.NewFixedThreadPool(numThreads);
var future = new Future <bool> [numThreads];
var sharedStartLock = ReaderWriterLockManager.CreateLock(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
using (sharedStartLock.AcquireWriteLock()) {
for (var i = 0; i < numThreads; i++)
{
future[i] = threadPool.Submit(
new SendEventRWLockCallable(i, sharedStartLock.ReadLock, engine, EnumerationGenerator.Create(numEvents)));
}
Thread.Sleep(100);
}
threadPool.Shutdown();
threadPool.AwaitTermination(new TimeSpan(0, 0, 10));
for (var i = 0; i < numThreads; i++)
{
Assert.IsTrue((bool)future[i].GetValueOrDefault());
}
// assert result
var newEvents = listener.GetNewDataListFlattened();
var resultsPerIdent = new ArrayList[numStatements];
foreach (var theEvent in newEvents)
{
var ident = (int)theEvent.Get("ident");
if (resultsPerIdent[ident] == null)
{
resultsPerIdent[ident] = new ArrayList();
}
var mysum = (long)theEvent.Get("mysum");
resultsPerIdent[ident].Add(mysum);
}
for (var statement = 0; statement < numStatements; statement++)
{
for (var i = 0; i < numEvents - 1; i++)
{
var expected = Total(i + 1);
Assert.AreEqual(expected, resultsPerIdent[statement][i]);
}
}
// destroy
for (var i = 0; i < numStatements; i++)
{
insertIntoStmts[i].Dispose();
}
stmtInsertTwo.Dispose();
}
public EPServicesContext CreateServicesContext(
EPServiceProvider epServiceProvider,
ConfigurationInformation configSnapshot)
{
// Directory for binding resources
var resourceDirectory = new SimpleServiceDirectory();
// Engine import service
var engineImportService = MakeEngineImportService(configSnapshot, AggregationFactoryFactoryDefault.INSTANCE);
// Event Type Id Generation
EventTypeIdGenerator eventTypeIdGenerator;
if (configSnapshot.EngineDefaults.AlternativeContext == null ||
configSnapshot.EngineDefaults.AlternativeContext.EventTypeIdGeneratorFactory == null)
{
eventTypeIdGenerator = new EventTypeIdGeneratorImpl();
}
else
{
var eventTypeIdGeneratorFactory = TypeHelper.Instantiate <EventTypeIdGeneratorFactory>(
configSnapshot.EngineDefaults.AlternativeContext.EventTypeIdGeneratorFactory,
engineImportService.GetClassForNameProvider());
eventTypeIdGenerator = eventTypeIdGeneratorFactory.Create(
new EventTypeIdGeneratorContext(epServiceProvider.URI));
}
// Make services that depend on snapshot config entries
EventAdapterAvroHandler avroHandler = EventAdapterAvroHandlerUnsupported.INSTANCE;
if (configSnapshot.EngineDefaults.EventMeta.AvroSettings.IsEnableAvro)
{
try
{
avroHandler = TypeHelper.Instantiate <EventAdapterAvroHandler>(
EventAdapterAvroHandlerConstants.HANDLER_IMPL, engineImportService.GetClassForNameProvider());
}
catch (Exception e)
{
Log.Debug(
"Avro provider {0} not instantiated, not enabling Avro support: {1}",
EventAdapterAvroHandlerConstants.HANDLER_IMPL, e.Message);
}
try
{
avroHandler.Init(configSnapshot.EngineDefaults.EventMeta.AvroSettings, engineImportService);
}
catch (Exception e)
{
throw new ConfigurationException("Failed to initialize Esper-Avro: " + e.Message, e);
}
}
var eventAdapterService = new EventAdapterServiceImpl(
eventTypeIdGenerator, configSnapshot.EngineDefaults.EventMeta.AnonymousCacheSize, avroHandler,
engineImportService);
Init(eventAdapterService, configSnapshot, engineImportService);
// New read-write lock for concurrent event processing
var eventProcessingRwLock = ReaderWriterLockManager.CreateLock(
MethodBase.GetCurrentMethod().DeclaringType);
var timeSourceService = MakeTimeSource(configSnapshot);
var schedulingService = SchedulingServiceProvider.NewService(timeSourceService);
var schedulingMgmtService = new SchedulingMgmtServiceImpl();
var engineSettingsService = new EngineSettingsService(
configSnapshot.EngineDefaults, configSnapshot.PlugInEventTypeResolutionURIs);
var databaseConfigService = MakeDatabaseRefService(
configSnapshot, schedulingService, schedulingMgmtService, engineImportService);
var plugInViews = new PluggableObjectCollection();
plugInViews.AddViews(
configSnapshot.PlugInViews, configSnapshot.PlugInVirtualDataWindows, engineImportService);
var plugInPatternObj = new PluggableObjectCollection();
plugInPatternObj.AddPatternObjects(configSnapshot.PlugInPatternObjects, engineImportService);
// exception handling
var exceptionHandlingService = InitExceptionHandling(
epServiceProvider.URI, configSnapshot.EngineDefaults.ExceptionHandling,
configSnapshot.EngineDefaults.ConditionHandling, engineImportService);
// Statement context factory
Type systemVirtualDWViewFactory = null;
if (configSnapshot.EngineDefaults.AlternativeContext.VirtualDataWindowViewFactory != null)
{
try
{
systemVirtualDWViewFactory =
engineImportService.GetClassForNameProvider()
.ClassForName(configSnapshot.EngineDefaults.AlternativeContext.VirtualDataWindowViewFactory);
if (!TypeHelper.IsImplementsInterface(systemVirtualDWViewFactory, typeof(VirtualDataWindowFactory)))
{
throw new ConfigurationException(
"Type " + systemVirtualDWViewFactory.Name + " does not implement the interface " +
typeof(VirtualDataWindowFactory).Name);
}
}
catch (TypeLoadException e)
{
throw new ConfigurationException("Failed to look up class " + systemVirtualDWViewFactory);
}
}
var statementContextFactory = new StatementContextFactoryDefault(
plugInViews, plugInPatternObj, systemVirtualDWViewFactory);
var msecTimerResolution = configSnapshot.EngineDefaults.Threading.InternalTimerMsecResolution;
if (msecTimerResolution <= 0)
{
throw new ConfigurationException(
"Timer resolution configuration not set to a valid value, expecting a non-zero value");
}
var timerService = new TimerServiceImpl(epServiceProvider.URI, msecTimerResolution);
var variableService = new VariableServiceImpl(
configSnapshot.EngineDefaults.Variables.MsecVersionRelease, schedulingService, eventAdapterService, null);
InitVariables(variableService, configSnapshot.Variables, engineImportService);
var tableService = new TableServiceImpl();
var statementLockFactory = new StatementLockFactoryImpl(
configSnapshot.EngineDefaults.Execution.IsFairlock,
configSnapshot.EngineDefaults.Execution.IsDisableLocking);
var streamFactoryService = StreamFactoryServiceProvider.NewService(
epServiceProvider.URI, configSnapshot.EngineDefaults.ViewResources.IsShareViews);
var filterService =
FilterServiceProvider.NewService(
configSnapshot.EngineDefaults.Execution.FilterServiceProfile,
configSnapshot.EngineDefaults.Execution.IsAllowIsolatedService);
var metricsReporting = new MetricReportingServiceImpl(
configSnapshot.EngineDefaults.MetricsReporting, epServiceProvider.URI);
var namedWindowMgmtService =
new NamedWindowMgmtServiceImpl(
configSnapshot.EngineDefaults.Logging.IsEnableQueryPlan, metricsReporting);
var namedWindowDispatchService = new NamedWindowDispatchServiceImpl(
schedulingService, variableService, tableService,
engineSettingsService.EngineSettings.Execution.IsPrioritized, eventProcessingRwLock,
exceptionHandlingService, metricsReporting);
var valueAddEventService = new ValueAddEventServiceImpl();
valueAddEventService.Init(
configSnapshot.RevisionEventTypes, configSnapshot.VariantStreams, eventAdapterService,
eventTypeIdGenerator);
var statementEventTypeRef = new StatementEventTypeRefImpl();
var statementVariableRef = new StatementVariableRefImpl(
variableService, tableService, namedWindowMgmtService);
var threadingService = new ThreadingServiceImpl(configSnapshot.EngineDefaults.Threading);
var internalEventRouterImpl = new InternalEventRouterImpl(epServiceProvider.URI);
var statementIsolationService = new StatementIsolationServiceImpl();
var deploymentStateService = new DeploymentStateServiceImpl();
StatementMetadataFactory stmtMetadataFactory;
if (configSnapshot.EngineDefaults.AlternativeContext.StatementMetadataFactory == null)
{
stmtMetadataFactory = new StatementMetadataFactoryDefault();
}
else
{
stmtMetadataFactory = (StatementMetadataFactory)TypeHelper.Instantiate <StatementMetadataFactory>(
configSnapshot.EngineDefaults.AlternativeContext.StatementMetadataFactory,
engineImportService.GetClassForNameProvider());
}
var contextManagementService = new ContextManagementServiceImpl();
PatternSubexpressionPoolEngineSvc patternSubexpressionPoolSvc = null;
if (configSnapshot.EngineDefaults.Patterns.MaxSubexpressions != null)
{
patternSubexpressionPoolSvc =
new PatternSubexpressionPoolEngineSvc(
configSnapshot.EngineDefaults.Patterns.MaxSubexpressions.Value,
configSnapshot.EngineDefaults.Patterns.IsMaxSubexpressionPreventStart);
}
MatchRecognizeStatePoolEngineSvc matchRecognizeStatePoolEngineSvc = null;
if (configSnapshot.EngineDefaults.MatchRecognize.MaxStates != null)
{
matchRecognizeStatePoolEngineSvc =
new MatchRecognizeStatePoolEngineSvc(
configSnapshot.EngineDefaults.MatchRecognize.MaxStates.Value,
configSnapshot.EngineDefaults.MatchRecognize.IsMaxStatesPreventStart);
}
var scriptingService = new ScriptingServiceImpl();
scriptingService.DiscoverEngines();
// New services context
var services = new EPServicesContext(
epServiceProvider.URI, schedulingService,
eventAdapterService, engineImportService, engineSettingsService, databaseConfigService, plugInViews,
statementLockFactory, eventProcessingRwLock, null, resourceDirectory, statementContextFactory,
plugInPatternObj, timerService, filterService, streamFactoryService,
namedWindowMgmtService, namedWindowDispatchService, variableService, tableService, timeSourceService,
valueAddEventService, metricsReporting, statementEventTypeRef,
statementVariableRef, configSnapshot, threadingService, internalEventRouterImpl,
statementIsolationService, schedulingMgmtService,
deploymentStateService, exceptionHandlingService,
new PatternNodeFactoryImpl(), eventTypeIdGenerator,
stmtMetadataFactory,
contextManagementService, patternSubexpressionPoolSvc, matchRecognizeStatePoolEngineSvc,
new DataFlowServiceImpl(
epServiceProvider,
new DataFlowConfigurationStateServiceImpl()),
new ExprDeclaredServiceImpl(),
new ContextControllerFactoryFactorySvcImpl(),
new ContextManagerFactoryServiceImpl(),
new EPStatementFactoryDefault(),
new RegexHandlerFactoryDefault(),
new ViewableActivatorFactoryDefault(),
new FilterNonPropertyRegisteryServiceImpl(),
new ResultSetProcessorHelperFactoryImpl(),
new ViewServicePreviousFactoryImpl(),
new EventTableIndexServiceImpl(),
new EPRuntimeIsolatedFactoryImpl(),
new FilterBooleanExpressionFactoryImpl(),
new DataCacheFactory(),
new MultiMatchHandlerFactoryImpl(),
NamedWindowConsumerMgmtServiceImpl.INSTANCE,
AggregationFactoryFactoryDefault.INSTANCE,
scriptingService
);
// Engine services subset available to statements
statementContextFactory.StmtEngineServices = services;
// Circular dependency
var statementLifecycleSvc = new StatementLifecycleSvcImpl(epServiceProvider, services);
services.StatementLifecycleSvc = statementLifecycleSvc;
// Observers to statement events
statementLifecycleSvc.LifecycleEvent += (s, theEvent) => metricsReporting.Observe(theEvent);
// Circular dependency
statementIsolationService.SetEpServicesContext(services);
return(services);
}
