public void TestDropNoJoin()
{
var stmtHande = new EPStatementHandle(1, "id", null, StatementType.SELECT, "text", false, null, 1, false, false, new MultiMatchHandlerFactoryImpl().GetDefaultHandler());
var stmtAgentHandle = new EPStatementAgentInstanceHandle(stmtHande, ReaderWriterLockManager.CreateDefaultLock(), -1, null, null);
_streams = new EventStream[4];
_streams[0] = _streamFactoryService.CreateStream(1, _filterSpecs[0], _supportFilterService, stmtAgentHandle, false, null, false, false, null, false, 0, false).First;
_streams[1] = _streamFactoryService.CreateStream(2, _filterSpecs[0], _supportFilterService, stmtAgentHandle, false, null, false, false, null, false, 0, false).First;
_streams[2] = _streamFactoryService.CreateStream(3, _filterSpecs[1], _supportFilterService, stmtAgentHandle, false, null, false, false, null, false, 0, false).First;
_streams[3] = _streamFactoryService.CreateStream(4, _filterSpecs[2], _supportFilterService, stmtAgentHandle, false, null, false, false, null, false, 0, false).First;
_streamFactoryService.DropStream(_filterSpecs[0], _supportFilterService, false, false, false, false);
_streamFactoryService.DropStream(_filterSpecs[1], _supportFilterService, false, false, false, false);
Assert.AreEqual(0, _supportFilterService.Removed.Count);
// Filter removed
_streamFactoryService.DropStream(_filterSpecs[0], _supportFilterService, false, false, false, false);
Assert.AreEqual(1, _supportFilterService.Removed.Count);
_streamFactoryService.DropStream(_filterSpecs[2], _supportFilterService, false, false, false, false);
Assert.AreEqual(2, _supportFilterService.Removed.Count);
// Something already removed
try
{
_streamFactoryService.DropStream(_filterSpecs[2], _supportFilterService, false, false, false, false);
Assert.Fail();
}
catch (IllegalStateException)
{
// Expected
}
}
public void CanDispose()
{
// Setup
// Create a dictionary to use as a pretend populated
// dictionary
var pretendDictionary =
new Dictionary <string, IReaderWriterLock>();
pretendDictionary.Add("Test", Substitute.For <IReaderWriterLock>());
var mgr = new ReaderWriterLockManager <string>(m_factory, m_logger);
// And we will get the private field information to update
// with our pretend dictionary
var field = typeof(ReaderWriterLockManager <string>)
.GetField("m_readerWriters",
System.Reflection.BindingFlags.GetField
| System.Reflection.BindingFlags.Instance
| System.Reflection.BindingFlags.NonPublic);
// Set the value
field.SetValue(mgr, pretendDictionary);
// And for safe measures, read to make sure it is good
Assert.IsNotNull(field.GetValue(mgr));
// Act
mgr.Dispose();
// Assert
// Now we should have a null object instead, due to the
// disposal
var dictionary = (Dictionary <string, IReaderWriterLock>)field.GetValue(mgr);
Assert.AreEqual(null, dictionary);
} /* End of Function - CanDispose */
public void TestNodeMatching()
{
SupportBeanSimple eventObject = new SupportBeanSimple("DepositEvent_1", 1);
EventBean eventBean = SupportEventBeanFactory.CreateObject(eventObject);
FilterHandle expr = new SupportFilterHandle();
_testNode.Add(expr);
// Check matching without an index node
List <FilterHandle> matches = new List <FilterHandle>();
_testNode.MatchEvent(eventBean, matches);
Assert.AreEqual(1, matches.Count);
Assert.AreEqual(expr, matches[0]);
matches.Clear();
// Create, add and populate an index node
FilterParamIndexBase index = new FilterParamIndexEquals(
MakeLookupable("MyString", eventBean.EventType), ReaderWriterLockManager.CreateDefaultLock());
_testNode.Add(index);
index["DepositEvent_1"] = _testEvaluator;
// Verify matcher instance stored in index is called
_testNode.MatchEvent(eventBean, matches);
Assert.IsTrue(_testEvaluator.GetAndResetCountInvoked() == 1);
Assert.IsTrue(_testEvaluator.GetLastEvent() == eventBean);
Assert.AreEqual(1, matches.Count);
Assert.AreEqual(expr, matches[0]);
}
/// <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 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);
}
}
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;
}
public void SetUp()
{
_eventType = SupportEventTypeFactory.CreateBeanType(typeof(SupportBean));
_topNode = new FilterHandleSetNode(ReaderWriterLockManager.CreateDefaultLock());
_filterCallbacks = new List <FilterHandle>();
_pathsAddedTo = new List <ArrayDeque <EventTypeIndexBuilderIndexLookupablePair> >();
_testFilterSpecs = new List <FilterSpecCompiled>();
_matchedEvents = new List <EventBean>();
_unmatchedEvents = new List <EventBean>();
// Any int and double value specified here must match only the current filter spec not any other filter spec
_testFilterSpecs.Add(MakeSpec(new Object[] { "IntPrimitive", FilterOperator.GREATER_OR_EQUAL, 100000 }));
_matchedEvents.Add(MakeEvent(9999999, -1));
_unmatchedEvents.Add(MakeEvent(0, -1));
_testFilterSpecs.Add(MakeSpec(new Object[] { "IntPrimitive", FilterOperator.GREATER_OR_EQUAL, 10,
"DoublePrimitive", FilterOperator.EQUAL, 0.5 }));
_matchedEvents.Add(MakeEvent(10, 0.5));
_unmatchedEvents.Add(MakeEvent(0, 0.5));
_testFilterSpecs.Add(MakeSpec(new Object[] { "DoublePrimitive", FilterOperator.EQUAL, 0.8 }));
_matchedEvents.Add(MakeEvent(-1, 0.8));
_unmatchedEvents.Add(MakeEvent(-1, 0.1));
_testFilterSpecs.Add(MakeSpec(new Object[] { "DoublePrimitive", FilterOperator.EQUAL, 99.99,
"IntPrimitive", FilterOperator.LESS, 1 }));
_matchedEvents.Add(MakeEvent(0, 99.99));
_testFilterSpecs.Add(MakeSpec(new Object[] { "DoublePrimitive", FilterOperator.GREATER, .99,
"IntPrimitive", FilterOperator.EQUAL, 5001 }));
_matchedEvents.Add(MakeEvent(5001, 1.1));
_unmatchedEvents.Add(MakeEvent(5002, 0.98));
_testFilterSpecs.Add(MakeSpec(new Object[] { "IntPrimitive", FilterOperator.LESS, -99000 }));
_matchedEvents.Add(MakeEvent(-99001, -1));
_unmatchedEvents.Add(MakeEvent(-98999, -1));
_testFilterSpecs.Add(MakeSpec(new Object[] { "IntPrimitive", FilterOperator.GREATER_OR_EQUAL, 11,
"DoublePrimitive", FilterOperator.GREATER, 888.0 }));
_matchedEvents.Add(MakeEvent(11, 888.001));
_unmatchedEvents.Add(MakeEvent(10, 888));
_testFilterSpecs.Add(MakeSpec(new Object[] { "IntPrimitive", FilterOperator.EQUAL, 973,
"DoublePrimitive", FilterOperator.EQUAL, 709.0 }));
_matchedEvents.Add(MakeEvent(973, 709));
_unmatchedEvents.Add(MakeEvent(0, 0.5));
_testFilterSpecs.Add(MakeSpec(new Object[] { "IntPrimitive", FilterOperator.EQUAL, 973,
"DoublePrimitive", FilterOperator.EQUAL, 655.0 }));
_matchedEvents.Add(MakeEvent(973, 655));
_unmatchedEvents.Add(MakeEvent(33838, 655.5));
}
public void TestMultithreaded()
{
var topNode = new FilterHandleSetNode(ReaderWriterLockManager.CreateDefaultLock());
PerformMultithreadedTest(topNode, 2, 1000, 1);
PerformMultithreadedTest(topNode, 3, 1000, 1);
PerformMultithreadedTest(topNode, 4, 1000, 1);
PerformMultithreadedTest(new FilterHandleSetNode(ReaderWriterLockManager.CreateDefaultLock()), 2, 1000, 1);
PerformMultithreadedTest(new FilterHandleSetNode(ReaderWriterLockManager.CreateDefaultLock()), 3, 1000, 1);
PerformMultithreadedTest(new FilterHandleSetNode(ReaderWriterLockManager.CreateDefaultLock()), 4, 1000, 1);
}
public void GetForNewItem()
{
// Setup
var fakeItem = Substitute.For <IReaderWriterLock>();
m_factory.Create().Returns(fakeItem);
var mgr = new ReaderWriterLockManager <string>(m_factory, m_logger);
// Act
var item = mgr.GetFor("test");
// Assert
Assert.AreEqual(item, fakeItem);
m_factory.Received().Create();
} /* End of Function - GetForNewItem */
/// <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);
}
}
public void SetUp()
{
SupportBean testBean = new SupportBean();
_testEventBean = SupportEventBeanFactory.CreateObject(testBean);
_testEventType = _testEventBean.EventType;
_handleSetNode = new FilterHandleSetNode(ReaderWriterLockManager.CreateDefaultLock());
_filterCallback = new SupportFilterHandle();
_handleSetNode.Add(_filterCallback);
_testIndex = new EventTypeIndex(new FilterServiceGranularLockFactoryReentrant());
_testIndex.Add(_testEventType, _handleSetNode);
}
public IReaderWriterLock GetStatementLock(String statementName, Attribute[] annotations, bool stateless)
{
bool foundNoLock = AnnotationUtil.FindAttribute(annotations, typeof(NoLockAttribute)) != null;
if (_disableLocking || foundNoLock || stateless)
{
return(ReaderWriterLockManager.VoidLock());
}
if (_fairlocks)
{
return(ReaderWriterLockManager.FairLock());
}
return(ReaderWriterLockManager.CreateDefaultLock());
}
public void GetForOldItem()
{
// Setup
var fakeItem = Substitute.For <IReaderWriterLock>();
Dictionary <string, IReaderWriterLock> dictionary = new Dictionary <string, IReaderWriterLock>();
dictionary.Add("test", fakeItem);
var mgr = new ReaderWriterLockManager <string>(m_factory, m_logger);
// Setup to set the private field
var field = typeof(ReaderWriterLockManager <string>).GetField("m_readerWriters",
System.Reflection.BindingFlags.NonPublic
| System.Reflection.BindingFlags.GetField
| System.Reflection.BindingFlags.Instance);
field.SetValue(mgr, dictionary);
// Act
var item = mgr.GetFor("test");
// Assert
Assert.AreEqual(item, fakeItem);
m_factory.DidNotReceive().Create();
} /* End of Function - GetForOldItem */
public void TestCreateNoJoin()
{
var stmtHande = new EPStatementHandle(1, "id", null, StatementType.SELECT, "text", false, null, 1, false, false, new MultiMatchHandlerFactoryImpl().GetDefaultHandler());
var stmtAgentHandle = new EPStatementAgentInstanceHandle(stmtHande, ReaderWriterLockManager.CreateDefaultLock(), -1, null, null);
_streams = new EventStream[4];
_streams[0] = _streamFactoryService.CreateStream(1, _filterSpecs[0], _supportFilterService, stmtAgentHandle, false, null, false, false, null, false, 0, false).First;
_streams[1] = _streamFactoryService.CreateStream(2, _filterSpecs[0], _supportFilterService, stmtAgentHandle, false, null, false, false, null, false, 0, false).First;
_streams[2] = _streamFactoryService.CreateStream(3, _filterSpecs[1], _supportFilterService, stmtAgentHandle, false, null, false, false, null, false, 0, false).First;
_streams[3] = _streamFactoryService.CreateStream(4, _filterSpecs[2], _supportFilterService, stmtAgentHandle, false, null, false, false, null, false, 0, false).First;
// Streams are reused
Assert.AreSame(_streams[0], _streams[1]);
Assert.AreSame(_streams[0], _streams[2]);
Assert.AreNotSame(_streams[0], _streams[3]);
// Type is ok
Assert.AreEqual(typeof(SupportBean), _streams[0].EventType.UnderlyingType);
// 2 filters are active now
Assert.AreEqual(2, _supportFilterService.Added.Count);
}
public void TestIndex()
{
FilterParamIndexIn index = new FilterParamIndexIn(MakeLookupable("LongBoxed"), ReaderWriterLockManager.CreateDefaultLock());
Assert.AreEqual(FilterOperator.IN_LIST_OF_VALUES, index.FilterOperator);
MultiKeyUntyped inList = new MultiKeyUntyped(new Object[] { 2L, 5L });
index.Put(inList, _testEvaluator);
inList = new MultiKeyUntyped(new Object[] { 10L, 5L });
index.Put(inList, _testEvaluator);
Verify(index, 1L, 0);
Verify(index, 2L, 1);
Verify(index, 5L, 2);
Verify(index, 10L, 1);
Verify(index, 999L, 0);
Verify(index, null, 0);
Assert.AreEqual(_testEvaluator, index.Get(inList));
Assert.IsTrue(index.ReadWriteLock != null);
Assert.IsTrue(index.Remove(inList));
Assert.IsFalse(index.Remove(inList));
Assert.AreEqual(null, index.Get(inList));
try
{
index["a"] = _testEvaluator;
Assert.IsTrue(false);
}
catch (Exception ex)
{
// Expected
}
}
public IReaderWriterLock ObtainNew()
{
return(ReaderWriterLockManager.CreateDefaultLock());
//return new SlimReaderWriterLock();
}
/// <summary>Ctor. </summary>
public StatementEventTypeRefImpl()
{
_typeToStmt = new Dictionary <String, ICollection <String> >();
_stmtToType = new Dictionary <String, String[]>();
_mapLock = ReaderWriterLockManager.CreateLock(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
}
private FilterParamIndexCompare MakeOne(String field, FilterOperator op)
{
return(new FilterParamIndexCompare(MakeLookupable(field), ReaderWriterLockManager.CreateDefaultLock(), op));
}
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);
}
/// <summary>Register an adapter. </summary>
/// <param name="epService">engine</param>
public void RegisterAdapter(EPServiceProvider epService)
{
var spi = (EPServiceProviderSPI)epService;
var eventType = spi.EventAdapterService.GetEventTypeByName(EventTypeName);
var fvs = new FilterSpecCompiled(eventType, null, new IList <FilterSpecParam> [0], null).GetValueSet(null, null, null);
var name = "subscription:" + SubscriptionName;
var metricsHandle = spi.MetricReportingService.GetStatementHandle(name, name);
var statementHandle = new EPStatementHandle(name, name, name, StatementType.ESPERIO, name, false, metricsHandle, 0, false, false, MultiMatchHandlerFactory.DefaultHandler);
var agentHandle = new EPStatementAgentInstanceHandle(statementHandle, ReaderWriterLockManager.CreateDefaultLock(), -1, new StatementAgentInstanceFilterVersion());
var registerHandle = new EPStatementHandleCallback(agentHandle, this);
spi.FilterService.Add(fvs, registerHandle);
}
public void SetUp()
{
_testEvaluator = new SupportEventEvaluator();
_testNode = new FilterHandleSetNode(ReaderWriterLockManager.CreateDefaultLock());
}
public static StatementContext MakeContext(SchedulingService stub)
{
var variableService = new VariableServiceImpl(1000, null, SupportEventAdapterService.Service, null);
var config = new Configuration();
config.EngineDefaults.ViewResourcesConfig.IsAllowMultipleExpiryPolicies = true;
var stmtEngineServices = new StatementContextEngineServices(
"engURI",
SupportEventAdapterService.Service,
new NamedWindowServiceImpl(null, variableService, new TableServiceImpl(), false, ReaderWriterLockManager.CreateDefaultLock(), new ExceptionHandlingService("engURI", Collections.GetEmptyList <ExceptionHandler>(), Collections.GetEmptyList <ConditionHandler>()), false, null),
null, new TableServiceImpl(),
new EngineSettingsService(new Configuration().EngineDefaults, new Uri[0]),
new ValueAddEventServiceImpl(),
config,
null,
null,
null,
null,
new StatementEventTypeRefImpl(),
null,
null,
null,
null);
return(new StatementContext(
stmtEngineServices,
null,
stub,
new ScheduleBucket(1),
new EPStatementHandle("id1", "name1", "epl1", StatementType.SELECT, "epl1", false, null, 0, false, false, MultiMatchHandlerFactory.DefaultHandler),
new ViewResolutionServiceImpl(new PluggableObjectRegistryImpl(new PluggableObjectCollection[] { ViewEnumHelper.BuiltinViews }), null, null),
new PatternObjectResolutionServiceImpl(null),
null,
null,
new MethodResolutionServiceImpl(SupportEngineImportServiceFactory.Make(), null),
null,
null,
new StatementResultServiceImpl("name", null, null, new ThreadingServiceImpl(new ConfigurationEngineDefaults.Threading())), // statement result svc
null,
null,
null,
null,
null,
null,
null,
false,
null,
null,
AggregationServiceFactoryServiceImpl.DEFAULT_FACTORY,
null,
false,
null));
}
private FilterParamIndexDoubleRangeInverted MakeOne(String field, FilterOperator notRangeHalfClosed, EventType testEventType)
{
return(new FilterParamIndexDoubleRangeInverted(MakeLookupable(field), ReaderWriterLockManager.CreateDefaultLock(), notRangeHalfClosed));
}
public void TestIndex()
{
FilterParamIndexNotIn index = new FilterParamIndexNotIn(MakeLookupable("LongBoxed"), ReaderWriterLockManager.CreateDefaultLock());
Assert.AreEqual(FilterOperator.NOT_IN_LIST_OF_VALUES, index.FilterOperator);
index.Put(new MultiKeyUntyped(new Object[] { 2L, 5L }), _testEvaluators[0]);
index.Put(new MultiKeyUntyped(new Object[] { 3L, 4L, 5L }), _testEvaluators[1]);
index.Put(new MultiKeyUntyped(new Object[] { 1L, 4L, 5L }), _testEvaluators[2]);
index.Put(new MultiKeyUntyped(new Object[] { 2L, 5L }), _testEvaluators[3]);
Verify(index, 0L, new bool[] { true, true, true, true });
Verify(index, 1L, new bool[] { true, true, false, true });
Verify(index, 2L, new bool[] { false, true, true, false });
Verify(index, 3L, new bool[] { true, false, true, true });
Verify(index, 4L, new bool[] { true, false, false, true });
Verify(index, 5L, new bool[] { false, false, false, false });
Verify(index, 6L, new bool[] { true, true, true, true });
MultiKeyUntyped inList = new MultiKeyUntyped(new Object[] { 3L, 4L, 5L });
Assert.AreEqual(_testEvaluators[1], index.Get(inList));
Assert.IsTrue(index.ReadWriteLock != null);
Assert.IsTrue(index.Remove(inList));
Assert.IsFalse(index.Remove(inList));
Assert.AreEqual(null, index.Get(inList));
// now that {3,4,5} is removed, verify results again
Verify(index, 0L, new bool[] { true, false, true, true });
Verify(index, 1L, new bool[] { true, false, false, true });
Verify(index, 2L, new bool[] { false, false, true, false });
Verify(index, 3L, new bool[] { true, false, true, true });
Verify(index, 4L, new bool[] { true, false, false, true });
Verify(index, 5L, new bool[] { false, false, false, false });
Verify(index, 6L, new bool[] { true, false, true, true });
try
{
index["a"] = _testEvaluators[0];
Assert.IsTrue(false);
}
catch (Exception ex)
{
// Expected
}
}
public TestStreamFactorySvcImpl()
{
_handle = new EPStatementHandle(1, "name", "text", StatementType.SELECT, "text", false, null, 1, false, false, new MultiMatchHandlerFactoryImpl().GetDefaultHandler());
_agentHandle = new EPStatementAgentInstanceHandle(_handle, ReaderWriterLockManager.CreateDefaultLock(), -1, null, null);
}
private FilterParamIndexDoubleRange MakeOne(String fieldName, FilterOperator operatorType, EventType testEventType)
{
return(new FilterParamIndexDoubleRange(MakeLookupable(fieldName), ReaderWriterLockManager.CreateDefaultLock(), operatorType));
}
