private static void HandleConsumed <TK, TE>(
string providerDeploymentId,
TK[] objectNames,
EPObjectType objectType,
PathRegistry <TK, TE> registry,
string moduleName,
string selfDeploymentId,
IList <EPDeploymentDependencyConsumed.Item> consumed,
Func <TK, string> objectNameFunction)
where TK : class
{
foreach (TK objectName in objectNames)
{
try {
var ids = registry.GetDependencies(objectName, moduleName);
if (ids != null && ids.Contains(selfDeploymentId))
{
consumed.Add(
new EPDeploymentDependencyConsumed.Item(
providerDeploymentId,
objectType,
objectNameFunction.Invoke(objectName)));
}
}
catch (ArgumentException) {
// not handled
}
}
}
private static void HandleProvided <TK, TE>(
TK[] objectNames,
EPObjectType objectType,
PathRegistry <TK, TE> registry,
string moduleName,
IList <EPDeploymentDependencyProvided.Item> dependencies,
Func <TK, string> objectNameFunction)
where TK : class
{
foreach (TK objectName in objectNames)
{
try {
var ids = registry.GetDependencies(objectName, moduleName);
if (ids != null)
{
dependencies.Add(
new EPDeploymentDependencyProvided.Item(
objectType,
objectNameFunction.Invoke(objectName),
new HashSet <string>(ids)));
}
}
catch (ArgumentException) {
// no need to handle
}
}
}
internal static Pair <Type, T> ResolveFromLocalAndPath <T>(
string soughtName,
ClassProvidedCompileTimeRegistry locals,
PathRegistry <string, ClassProvided> path,
string objectName,
ICollection <string> moduleUses,
ModuleDependenciesCompileTime moduleDependencies,
Func <T, ISet <string> > namesProvider)
where T : Attribute
{
if (locals.Classes.IsEmpty() && path.IsEmpty())
{
return(null);
}
var annotationType = typeof(T);
try {
// try resolve from local
var localPair = ResolveFromLocal(soughtName, locals, annotationType, objectName, namesProvider);
if (localPair != null)
{
return(localPair);
}
// try resolve from path, using module-uses when necessary
return(ResolveFromPath(soughtName, path, annotationType, objectName, moduleUses, moduleDependencies, namesProvider));
}
catch (ExprValidationException ex) {
throw new EPException(ex.Message, ex);
}
}
public static ModuleProviderCLPair Analyze(
EPCompiled compiled,
ClassLoader classLoaderParent,
PathRegistry <String, ClassProvided> classProvidedPathRegistry)
{
var classLoader = new PriorityClassLoader(classLoaderParent, compiled.Assemblies);
var resourceClassName = compiled.Manifest.ModuleProviderClassName;
// load module resource class
Type clazz;
try {
clazz = classLoader.GetClass(resourceClassName);
}
catch (Exception e) {
throw new EPException(e);
}
// instantiate
ModuleProvider moduleResource;
try {
moduleResource = (ModuleProvider)TypeHelper.Instantiate(clazz);
}
catch (EPException) {
throw;
}
catch (Exception e) {
throw new EPException(e);
}
return(new ModuleProviderCLPair(classLoader, moduleResource));
}
public ClassProvidedImportClassLoader(
ClassLoader parent,
PathRegistry <string, ClassProvided> pathRegistry)
{
_parent = parent;
_pathRegistry = pathRegistry;
}
public EventBeanServiceImpl(
EventTypeRepositoryImpl eventTypeRepositoryPreconfigured,
PathRegistry<string, EventType> pathEventTypes,
EventBeanTypedEventFactory typedEventFactory)
{
this.eventTypeRepositoryPreconfigured = eventTypeRepositoryPreconfigured;
this.pathEventTypes = pathEventTypes;
this.typedEventFactory = typedEventFactory;
}
public Path(Node start, List <Node> targets, PathRegistry registry)
{
IsT0 = false;
Start = start;
Targets = targets;
State = PathState.InitialCalulation;
_registry = registry;
_registry.ActivePaths.Add(this);
}
public static ClassLoader GetClassLoader(
ICollection<Assembly> assemblies,
ClassLoader parentClassLoader,
PathRegistry<string, ClassProvided> classProvidedPathRegistry)
{
if (classProvidedPathRegistry.IsEmpty()) {
return new PriorityClassLoader(parentClassLoader, assemblies);
}
return new ClassProvidedImportClassLoader(parentClassLoader, classProvidedPathRegistry);
}
public IndexCollectorCompileTime(
IDictionary<string, NamedWindowMetaData> moduleNamedWindows,
IDictionary<string, TableMetaData> moduleTables,
PathRegistry<string, NamedWindowMetaData> pathNamedWindows,
PathRegistry<string, TableMetaData> pathTables)
{
this.moduleNamedWindows = moduleNamedWindows;
this.moduleTables = moduleTables;
this.pathNamedWindows = pathNamedWindows;
this.pathTables = pathTables;
}
private static void CheckDependency <TK, TR>(
PathRegistry <TK, TR> registry,
TK entityKey,
string moduleName) where TK : class
{
var dependencies = registry.GetDependencies(entityKey, moduleName);
if (dependencies != null && !dependencies.IsEmpty())
{
throw MakeException(registry.ObjectType, entityKey.ToString(), dependencies.First());
}
}
public ExprDeclaredCompileTimeResolverImpl(
string moduleName,
ICollection<string> moduleUses,
ExprDeclaredCompileTimeRegistry locals,
PathRegistry<string, ExpressionDeclItem> path,
ModuleDependenciesCompileTime moduleDependencies)
{
this.moduleName = moduleName;
this.moduleUses = moduleUses;
this.locals = locals;
this.path = path;
this.moduleDependencies = moduleDependencies;
}
public EventTypeResolverImpl(
IDictionary<string, EventType> locals,
PathRegistry<string, EventType> path,
EventTypeNameResolver publics,
BeanEventTypeFactoryPrivate beanEventTypeFactoryPrivate,
EventSerdeFactory eventSerdeFactory)
{
this.locals = locals;
this.path = path;
this.publics = publics;
this.beanEventTypeFactoryPrivate = beanEventTypeFactoryPrivate;
this.eventSerdeFactory = eventSerdeFactory;
}
public static EventType Resolve(
EventTypeMetadata metadata,
EventTypeNameResolver publics,
IDictionary<string, EventType> locals,
PathRegistry<string, EventType> path)
{
EventTypeSPI type;
// public can only see public
if (metadata.AccessModifier == NameAccessModifier.PRECONFIGURED) {
type = (EventTypeSPI) publics.GetTypeByName(metadata.Name);
// for create-schema the type may be defined by the same module
if (type == null) {
type = (EventTypeSPI) locals.Get(metadata.Name);
}
}
else if (metadata.AccessModifier == NameAccessModifier.PUBLIC ||
metadata.AccessModifier == NameAccessModifier.INTERNAL) {
// path-visibility can be provided as local
var local = locals.Get(metadata.Name);
if (local != null) {
if (local.Metadata.AccessModifier == NameAccessModifier.PUBLIC ||
local.Metadata.AccessModifier == NameAccessModifier.INTERNAL) {
return (EventTypeSPI) local;
}
}
try {
var pair = path.GetAnyModuleExpectSingle(
metadata.Name,
Collections.SingletonSet(metadata.ModuleName));
type = (EventTypeSPI) pair?.First;
}
catch (PathException e) {
throw new EPException(e.Message, e);
}
}
else {
type = (EventTypeSPI) locals.Get(metadata.Name);
}
if (type == null) {
throw new EPException(
"Failed to find event type '" +
metadata.Name +
"' among public types, modules-in-path or the current module itself");
}
return type;
}
public TableCompileTimeResolverImpl(
string moduleName,
ICollection<string> moduleUses,
TableCompileTimeRegistry compileTimeRegistry,
PathRegistry<string, TableMetaData> pathTables,
ModuleDependenciesCompileTime moduleDependencies,
bool isFireAndForget)
{
this.moduleName = moduleName;
this.moduleUses = moduleUses;
this.compileTimeRegistry = compileTimeRegistry;
this.pathTables = pathTables;
this.moduleDependencies = moduleDependencies;
this.isFireAndForget = isFireAndForget;
}
public ClassProvidedCompileTimeResolverImpl(
string moduleName,
ICollection <string> moduleUses,
ClassProvidedCompileTimeRegistry locals,
PathRegistry <string, ClassProvided> path,
ModuleDependenciesCompileTime moduleDependencies,
bool isFireAndForget)
{
this._moduleName = moduleName;
this._moduleUses = moduleUses;
this._locals = locals;
this._path = path;
this._moduleDependencies = moduleDependencies;
this._isFireAndForget = isFireAndForget;
}
public ExprDeclaredCompileTimeResolverImpl(
string moduleName,
ICollection<string> moduleUses,
ExprDeclaredCompileTimeRegistry locals,
PathRegistry<string, ExpressionDeclItem> path,
ModuleDependenciesCompileTime moduleDependencies,
bool isFireAndForget)
{
this._moduleName = moduleName;
this._moduleUses = moduleUses;
this._locals = locals;
this._path = path;
this._moduleDependencies = moduleDependencies;
this._isFireAndForget = isFireAndForget;
}
public ScriptCompileTimeResolverImpl(
string moduleName,
ICollection<string> moduleUses,
ScriptCompileTimeRegistry locals,
PathRegistry<NameAndParamNum, ExpressionScriptProvided> path,
ModuleDependenciesCompileTime moduleDependencies,
bool isFireAndForget)
{
this._moduleName = moduleName;
this._moduleUses = moduleUses;
this._locals = locals;
this._path = path;
this._moduleDependencies = moduleDependencies;
_isFireAndForget = isFireAndForget;
}
public ContextCompileTimeResolverImpl(
string moduleName,
ICollection<string> moduleUses,
ContextCompileTimeRegistry locals,
PathRegistry<string, ContextMetaData> path,
ModuleDependenciesCompileTime moduleDependencies,
bool isFireAndForget)
{
this.moduleName = moduleName;
this.moduleUses = moduleUses;
this.locals = locals;
this.path = path;
this.moduleDependencies = moduleDependencies;
this.isFireAndForget = isFireAndForget;
}
public EventTypeCompileTimeResolver(
string moduleName,
ICollection<string> moduleUses,
EventTypeCompileTimeRegistry locals,
EventTypeRepositoryImpl publics,
PathRegistry<string, EventType> path,
ModuleDependenciesCompileTime moduleDependencies,
bool isFireAndForget)
{
this.moduleName = moduleName;
this.moduleUses = moduleUses;
this.locals = locals;
this.publics = publics;
Path = path;
this.moduleDependencies = moduleDependencies;
this.isFireAndForget = isFireAndForget;
}
public VariableCompileTimeResolverImpl(
string moduleName,
ICollection<string> moduleUses,
VariableRepositoryPreconfigured publicVariables,
VariableCompileTimeRegistry compileTimeRegistry,
PathRegistry<string, VariableMetaData> pathVariables,
ModuleDependenciesCompileTime moduleDependencies,
bool isFireAndForget)
{
_moduleName = moduleName;
_moduleUses = moduleUses;
_publicVariables = publicVariables;
_compileTimeRegistry = compileTimeRegistry;
_pathVariables = pathVariables;
_moduleDependencies = moduleDependencies;
_isFireAndForget = isFireAndForget;
}
public static string ResolveContextDeploymentId(
string contextModuleName,
NameAccessModifier? contextVisibility,
string contextName,
string myDeploymentId,
PathRegistry<string, ContextMetaData> pathContextRegistry)
{
bool protectedVisibility = contextVisibility == NameAccessModifier.PRIVATE;
string contextDeploymentId;
if (protectedVisibility) {
contextDeploymentId = myDeploymentId;
}
else {
contextDeploymentId = pathContextRegistry.GetDeploymentId(contextName, contextModuleName);
}
if (contextDeploymentId == null) {
throw FailedToFind(contextModuleName, contextVisibility, contextName);
}
return contextDeploymentId;
}
private static void HandleProvided<TK, TE>(
string deploymentId,
TK[] objectNames,
PathRegistry<TK, TE> source,
string moduleName,
PathRegistry<TK, TE> target)
where TK : class
{
foreach (var objectName in objectNames) {
var e = source.GetEntryWithModule(objectName, moduleName);
if (e != null) {
try {
target.AddEntry(objectName, moduleName, e);
}
catch (PathException ex) {
throw new EPException(ex);
}
}
}
source.DeleteDeployment(deploymentId);
}
public EPCompilerPathableImpl(
PathRegistry<string, VariableMetaData> variablePathRegistry,
PathRegistry<string, EventType> eventTypePathRegistry,
PathRegistry<string, ExpressionDeclItem> exprDeclaredPathRegistry,
PathRegistry<string, NamedWindowMetaData> namedWindowPathRegistry,
PathRegistry<string, TableMetaData> tablePathRegistry,
PathRegistry<string, ContextMetaData> contextPathRegistry,
PathRegistry<NameAndParamNum, ExpressionScriptProvided> scriptPathRegistry,
PathRegistry<string, ClassProvided> classProvidedPathRegistry,
EventTypeRepositoryImpl eventTypePreconfigured,
VariableRepositoryPreconfigured variablePreconfigured)
{
VariablePathRegistry = variablePathRegistry;
EventTypePathRegistry = eventTypePathRegistry;
ExprDeclaredPathRegistry = exprDeclaredPathRegistry;
NamedWindowPathRegistry = namedWindowPathRegistry;
TablePathRegistry = tablePathRegistry;
ContextPathRegistry = contextPathRegistry;
ScriptPathRegistry = scriptPathRegistry;
ClassProvidedPathRegistry = classProvidedPathRegistry;
EventTypePreconfigured = eventTypePreconfigured;
VariablePreconfigured = variablePreconfigured;
}
private static Pair <Type, T> ResolveFromPath <T>(
string soughtName,
PathRegistry <string, ClassProvided> path,
Type annotationType,
string objectName,
ICollection <string> moduleUses,
ModuleDependenciesCompileTime moduleDependencies,
Func <T, ISet <string> > namesProvider)
where T : Attribute
{
// TBD: Verify that annotationType is derived from T
if (!typeof(T).IsAssignableFrom(annotationType))
{
throw new ArgumentException("cannot assign annotationType from " + typeof(T).FullName);
}
IList <PathFunc <T> > foundPath = new List <PathFunc <T> >();
path.TraverseWithModule((moduleName, classProvided) => {
EPTypeHelper.TraverseAnnotations <T>(
classProvided.ClassesMayNull,
(
clazz,
annotation) => {
var t = annotation;
var names = namesProvider.Invoke(t);
foreach (var name in names)
{
if (soughtName.Equals(name))
{
foundPath.Add(new PathFunc <T>(moduleName, clazz, t));
}
}
});
});
PathFunc <T> foundPathFunc;
if (foundPath.IsEmpty())
{
return(null);
}
else if (foundPath.Count == 1)
{
foundPathFunc = foundPath[0];
}
else
{
if (moduleUses == null || moduleUses.IsEmpty())
{
throw GetDuplicateSingleRow(soughtName, objectName);
}
IList <PathFunc <T> > matchesUses = new List <PathFunc <T> >(2);
foreach (var func in foundPath)
{
if (moduleUses.Contains(func.OptionalModuleName))
{
matchesUses.Add(func);
}
}
if (matchesUses.Count > 1)
{
throw GetDuplicateSingleRow(soughtName, objectName);
}
if (matchesUses.IsEmpty())
{
return(null);
}
foundPathFunc = matchesUses[0];
}
moduleDependencies.AddPathClass(foundPathFunc.Clazz.FullName, foundPathFunc.OptionalModuleName);
return(new Pair <Type, T>(foundPathFunc.Clazz, foundPathFunc.Annotation));
}
protected override EventTypeSerdeRepository MakeEventTypeSerdeRepository(
EventTypeRepository preconfigureds,
PathRegistry<String, EventType> eventTypePathRegistry)
{
return EventTypeSerdeRepositoryDefault.INSTANCE;
}
public static void AddJsonUnderlyingClass(
PathRegistry <string, EventType> pathEventTypes,
ParentClassLoader classLoader)
{
pathEventTypes.Traverse(type => AddJsonUnderlyingClassInternal(type, classLoader, null));
}
protected abstract EventTypeSerdeRepository MakeEventTypeSerdeRepository(
EventTypeRepository preconfigureds,
PathRegistry<String, EventType> eventTypePathRegistry);
public StatementContextRuntimeServices(
IContainer container,
ContextManagementService contextManagementService,
ContextServiceFactory contextServiceFactory,
DatabaseConfigServiceRuntime databaseConfigService,
DataFlowFilterServiceAdapter dataFlowFilterServiceAdapter,
EPDataFlowServiceImpl dataflowService,
string runtimeURI,
INamingContext runtimeEnvContext,
ImportServiceRuntime importServiceRuntime,
RuntimeSettingsService runtimeSettingsService,
RuntimeExtensionServices runtimeExtensionServices,
object epRuntime,
EPRenderEventService epRuntimeRenderEvent,
EventServiceSendEventCommon eventServiceSendEventInternal,
EPRuntimeEventProcessWrapped epRuntimeEventProcessWrapped,
EventBeanService eventBeanService,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
EventTableIndexService eventTableIndexService,
EventTypeAvroHandler eventTypeAvroHandler,
PathRegistry<string, EventType> eventTypePathRegistry,
EventTypeRepositoryImpl eventTypeRepositoryPreconfigured,
EventTypeResolvingBeanFactory eventTypeResolvingBeanFactory,
ExceptionHandlingService exceptionHandlingService,
ExpressionResultCacheService expressionResultCacheService,
FilterBooleanExpressionFactory filterBooleanExpressionFactory,
FilterSharedBoolExprRepository filterSharedBoolExprRepository,
FilterSharedLookupableRepository filterSharedLookupableRepository,
HistoricalDataCacheFactory historicalDataCacheFactory,
InternalEventRouter internalEventRouter,
MetricReportingService metricReportingService,
NamedWindowConsumerManagementService namedWindowConsumerManagementService,
NamedWindowManagementService namedWindowManagementService,
PathRegistry<string, ContextMetaData> pathContextRegistry,
PathRegistry<string, NamedWindowMetaData> pathNamedWindowRegistry,
RowRecogStateRepoFactory rowRecogStateRepoFactory,
ResultSetProcessorHelperFactory resultSetProcessorHelperFactory,
StatementAgentInstanceLockFactory statementAgentInstanceLockFactory,
StatementResourceHolderBuilder statementResourceHolderBuilder,
TableExprEvaluatorContext tableExprEvaluatorContext,
TableManagementService tableManagementService,
VariableManagementService variableManagementService,
ViewFactoryService viewFactoryService,
ViewServicePreviousFactory viewServicePreviousFactory)
{
Container = container;
ContextManagementService = contextManagementService;
ContextServiceFactory = contextServiceFactory;
DatabaseConfigService = databaseConfigService;
DataFlowFilterServiceAdapter = dataFlowFilterServiceAdapter;
DataflowService = dataflowService;
RuntimeURI = runtimeURI;
RuntimeEnvContext = runtimeEnvContext;
ImportServiceRuntime = importServiceRuntime;
RuntimeSettingsService = runtimeSettingsService;
RuntimeExtensionServices = runtimeExtensionServices;
Runtime = epRuntime;
EPRuntimeRenderEvent = epRuntimeRenderEvent;
EventServiceSendEventInternal = eventServiceSendEventInternal;
EPRuntimeEventProcessWrapped = epRuntimeEventProcessWrapped;
EventBeanService = eventBeanService;
EventBeanTypedEventFactory = eventBeanTypedEventFactory;
EventTableIndexService = eventTableIndexService;
EventTypeAvroHandler = eventTypeAvroHandler;
EventTypePathRegistry = eventTypePathRegistry;
EventTypeRepositoryPreconfigured = eventTypeRepositoryPreconfigured;
EventTypeResolvingBeanFactory = eventTypeResolvingBeanFactory;
ExceptionHandlingService = exceptionHandlingService;
ExpressionResultCacheService = expressionResultCacheService;
FilterBooleanExpressionFactory = filterBooleanExpressionFactory;
FilterSharedBoolExprRepository = filterSharedBoolExprRepository;
FilterSharedLookupableRepository = filterSharedLookupableRepository;
HistoricalDataCacheFactory = historicalDataCacheFactory;
InternalEventRouter = internalEventRouter;
MetricReportingService = metricReportingService;
NamedWindowConsumerManagementService = namedWindowConsumerManagementService;
NamedWindowManagementService = namedWindowManagementService;
PathContextRegistry = pathContextRegistry;
PathNamedWindowRegistry = pathNamedWindowRegistry;
RowRecogStateRepoFactory = rowRecogStateRepoFactory;
ResultSetProcessorHelperFactory = resultSetProcessorHelperFactory;
StatementAgentInstanceLockFactory = statementAgentInstanceLockFactory;
StatementResourceHolderBuilder = statementResourceHolderBuilder;
TableExprEvaluatorContext = tableExprEvaluatorContext;
TableManagementService = tableManagementService;
VariableManagementService = variableManagementService;
ViewFactoryService = viewFactoryService;
ViewServicePreviousFactory = viewServicePreviousFactory;
}
public EPServicesContext CreateServicesContext(
EPRuntimeSPI epRuntime,
Configuration configs)
{
var container = epRuntime.Container;
var runtimeEnvContext = new RuntimeEnvContext();
var eventProcessingRWLock = epRuntime.Container.RWLockManager().CreateLock("EventProcLock");
var deploymentLifecycleService = new DeploymentLifecycleServiceImpl(-1);
var runtimeSettingsService = MakeRuntimeSettingsService(configs);
var scriptCompiler = new ScriptCompilerImpl(container, configs.Common);
var timeAbacus = TimeAbacusFactory.Make(configs.Common.TimeSource.TimeUnit);
var timeZone = configs.Runtime.Expression.TimeZone ?? TimeZoneInfo.Utc;
var importServiceRuntime = new ImportServiceRuntime(
container,
configs.Common.TransientConfiguration, timeAbacus,
configs.Common.EventTypeAutoNameNamespaces, timeZone,
configs.Common.MethodInvocationReferences,
configs.Common.Imports,
configs.Common.AnnotationImports);
var epServicesHA = InitHA(epRuntime.URI, configs, runtimeEnvContext, eventProcessingRWLock, runtimeSettingsService);
var eventTypeAvroHandler = MakeEventTypeAvroHandler(
importServiceRuntime, configs.Common.EventMeta.AvroSettings, epServicesHA.RuntimeExtensionServices);
var resolvedBeanEventTypes = BeanEventTypeRepoUtil.ResolveBeanEventTypes(configs.Common.EventTypeNames, importServiceRuntime);
var eventBeanTypedEventFactory = MakeEventBeanTypedEventFactory(eventTypeAvroHandler);
var beanEventTypeStemService =
BeanEventTypeRepoUtil.MakeBeanEventTypeStemService(configs, resolvedBeanEventTypes, eventBeanTypedEventFactory);
var eventTypeRepositoryPreconfigured = new EventTypeRepositoryImpl(false);
var eventTypeFactory = MakeEventTypeFactory(
epServicesHA.RuntimeExtensionServices, eventTypeRepositoryPreconfigured, deploymentLifecycleService, eventBeanTypedEventFactory);
var beanEventTypeFactoryPrivate = new BeanEventTypeFactoryPrivate(eventBeanTypedEventFactory, eventTypeFactory, beanEventTypeStemService);
EventTypeRepositoryBeanTypeUtil.BuildBeanTypes(
beanEventTypeStemService,
eventTypeRepositoryPreconfigured,
resolvedBeanEventTypes,
beanEventTypeFactoryPrivate,
configs.Common.EventTypesBean);
EventTypeRepositoryMapTypeUtil.BuildMapTypes(
eventTypeRepositoryPreconfigured,
configs.Common.MapTypeConfigurations,
configs.Common.EventTypesMapEvents,
configs.Common.EventTypesNestableMapEvents,
beanEventTypeFactoryPrivate,
importServiceRuntime);
EventTypeRepositoryOATypeUtil.BuildOATypes(
eventTypeRepositoryPreconfigured,
configs.Common.ObjectArrayTypeConfigurations,
configs.Common.EventTypesNestableObjectArrayEvents,
beanEventTypeFactoryPrivate,
importServiceRuntime);
var xmlFragmentEventTypeFactory = new XMLFragmentEventTypeFactory(beanEventTypeFactoryPrivate, null, eventTypeRepositoryPreconfigured);
EventTypeRepositoryXMLTypeUtil.BuildXMLTypes(
eventTypeRepositoryPreconfigured,
configs.Common.EventTypesXMLDOM,
beanEventTypeFactoryPrivate,
xmlFragmentEventTypeFactory,
container.ResourceManager());
//importServiceRuntime
EventTypeRepositoryAvroTypeUtil.BuildAvroTypes(
eventTypeRepositoryPreconfigured, configs.Common.EventTypesAvro, eventTypeAvroHandler,
beanEventTypeFactoryPrivate.EventBeanTypedEventFactory);
EventTypeRepositoryVariantStreamUtil.BuildVariantStreams(
eventTypeRepositoryPreconfigured, configs.Common.VariantStreams, eventTypeFactory);
var eventTypeResolvingBeanFactory = MakeEventTypeResolvingBeanFactory(eventTypeRepositoryPreconfigured, eventTypeAvroHandler);
var viewableActivatorFactory = InitViewableActivatorFactory();
var statementLifecycleService = new StatementLifecycleServiceImpl();
EventTypeIdResolver eventTypeIdResolver = new ProxyEventTypeIdResolver {
ProcGetTypeById = (
eventTypeIdPublic,
eventTypeIdProtected) => {
if (eventTypeIdProtected == -1) {
return eventTypeRepositoryPreconfigured.GetTypeById(eventTypeIdPublic);
}
var deployerResult = deploymentLifecycleService.GetDeploymentByCRC(eventTypeIdPublic);
return deployerResult.DeploymentTypes.Get(eventTypeIdProtected);
}
};
var filterSharedBoolExprRepository = MakeFilterSharedBoolExprRepository();
var filterSharedLookupableRepository = MakeFilterSharedLookupableRepository();
var filterServiceSPI = MakeFilterService(
epServicesHA.RuntimeExtensionServices, eventTypeRepositoryPreconfigured, statementLifecycleService, runtimeSettingsService,
eventTypeIdResolver, filterSharedLookupableRepository);
var filterBooleanExpressionFactory = MakeFilterBooleanExpressionFactory(statementLifecycleService);
var statementResourceHolderBuilder = MakeStatementResourceHolderBuilder();
var aggregationServiceFactoryService = MakeAggregationServiceFactoryService(epServicesHA.RuntimeExtensionServices);
var viewFactoryService = MakeViewFactoryService();
var patternFactoryService = MakePatternFactoryService();
var exceptionHandlingService = InitExceptionHandling(
epRuntime.URI, configs.Runtime.ExceptionHandling, configs.Runtime.ConditionHandling, ClassForNameProviderDefault.INSTANCE);
var timeSourceService = MakeTimeSource(configs);
var schedulingService = MakeSchedulingService(
epServicesHA,
timeSourceService,
epServicesHA.RuntimeExtensionServices,
runtimeSettingsService,
statementLifecycleService,
importServiceRuntime.TimeZone.Id);
var internalEventRouter = new InternalEventRouterImpl(eventBeanTypedEventFactory);
var multiMatchHandlerFactory = MakeMultiMatchHandlerFactory(configs);
var dispatchService = new DispatchService();
var contextServiceFactory = MakeContextServiceFactory(epServicesHA.RuntimeExtensionServices);
ContextManagementService contextManagementService = new ContextManagementServiceImpl();
var viewServicePreviousFactory = MakeViewServicePreviousFactory(epServicesHA.RuntimeExtensionServices);
var epStatementFactory = MakeEPStatementFactory();
var msecTimerResolution = configs.Runtime.Threading.InternalTimerMsecResolution;
if (msecTimerResolution <= 0) {
throw new ConfigurationException("Timer resolution configuration not set to a valid value, expecting a non-zero value");
}
TimerService timerService = new TimerServiceImpl(epRuntime.URI, msecTimerResolution);
StatementAgentInstanceLockFactory statementAgentInstanceLockFactory = new StatementAgentInstanceLockFactoryImpl(
configs.Runtime.Execution.IsFairlock, configs.Runtime.Execution.IsDisableLocking);
var eventTableIndexService = MakeEventTableIndexService(epServicesHA.RuntimeExtensionServices);
var expressionResultCacheSharable = new ExpressionResultCacheService(
configs.Runtime.Execution.DeclaredExprValueCacheSize,
epRuntime.Container.ThreadLocalManager());
var resultSetProcessorHelperFactory = MakeResultSetProcessorHelperFactory(epServicesHA.RuntimeExtensionServices);
var variableRepositoryPreconfigured = new VariableRepositoryPreconfigured();
VariableUtil.ConfigureVariables(
variableRepositoryPreconfigured, configs.Common.Variables, importServiceRuntime, eventBeanTypedEventFactory,
eventTypeRepositoryPreconfigured, beanEventTypeFactoryPrivate);
var variableManagementService = MakeVariableManagementService(
configs, schedulingService, eventBeanTypedEventFactory, runtimeSettingsService, epServicesHA);
foreach (var publicVariable in variableRepositoryPreconfigured.Metadata) {
variableManagementService.AddVariable(null, publicVariable.Value, null, null);
variableManagementService.AllocateVariableState(
null, publicVariable.Key, DEFAULT_AGENT_INSTANCE_ID, false, null, eventBeanTypedEventFactory);
}
var variablePathRegistry = new PathRegistry<string, VariableMetaData>(PathRegistryObjectType.VARIABLE);
var tableExprEvaluatorContext = new TableExprEvaluatorContext(
epRuntime.Container.ThreadLocalManager());
var tableManagementService = MakeTableManagementService(epServicesHA.RuntimeExtensionServices, tableExprEvaluatorContext);
var tablePathRegistry = new PathRegistry<string, TableMetaData>(PathRegistryObjectType.TABLE);
var metricsReporting = new MetricReportingServiceImpl(
configs.Runtime.MetricsReporting, epRuntime.URI, container.RWLockManager());
var namedWindowFactoryService = MakeNamedWindowFactoryService();
var namedWindowDispatchService = MakeNamedWindowDispatchService(
schedulingService, configs, eventProcessingRWLock, exceptionHandlingService, variableManagementService, tableManagementService,
metricsReporting);
NamedWindowManagementService namedWindowManagementService = new NamedWindowManagementServiceImpl();
var namedWindowConsumerManagementService = MakeNamedWindowConsumerManagementService(namedWindowManagementService);
var pathNamedWindowRegistry = new PathRegistry<string, NamedWindowMetaData>(PathRegistryObjectType.NAMEDWINDOW);
var eventTypePathRegistry = new PathRegistry<string, EventType>(PathRegistryObjectType.EVENTTYPE);
var pathContextRegistry = new PathRegistry<string, ContextMetaData>(PathRegistryObjectType.CONTEXT);
EventBeanService eventBeanService = new EventBeanServiceImpl(
eventTypeRepositoryPreconfigured, eventTypePathRegistry, eventBeanTypedEventFactory);
PatternSubexpressionPoolRuntimeSvc patternSubexpressionPoolSvc;
if (configs.Runtime.Patterns.MaxSubexpressions != null) {
patternSubexpressionPoolSvc = new PatternSubexpressionPoolRuntimeSvcImpl(
configs.Runtime.Patterns.MaxSubexpressions.Value,
configs.Runtime.Patterns.IsMaxSubexpressionPreventStart);
}
else {
patternSubexpressionPoolSvc = PatternSubexpressionPoolRuntimeSvcNoOp.INSTANCE;
}
var exprDeclaredPathRegistry = new PathRegistry<string, ExpressionDeclItem>(PathRegistryObjectType.EXPRDECL);
var scriptPathRegistry = new PathRegistry<NameAndParamNum, ExpressionScriptProvided>(PathRegistryObjectType.SCRIPT);
RowRecogStatePoolRuntimeSvc rowRecogStatePoolEngineSvc = null;
if (configs.Runtime.MatchRecognize.MaxStates != null) {
rowRecogStatePoolEngineSvc = new RowRecogStatePoolRuntimeSvc(
configs.Runtime.MatchRecognize.MaxStates.Value,
configs.Runtime.MatchRecognize.IsMaxStatesPreventStart);
}
var rowRecogStateRepoFactory = MakeRowRecogStateRepoFactory();
DatabaseConfigServiceRuntime databaseConfigServiceRuntime =
new DatabaseConfigServiceImpl(
container,
configs.Common.DatabaseReferences,
importServiceRuntime);
var historicalDataCacheFactory = MakeHistoricalDataCacheFactory(epServicesHA.RuntimeExtensionServices);
var dataflowService = new EPDataFlowServiceImpl(container);
var dataFlowFilterServiceAdapter = MakeDataFlowFilterServiceAdapter();
var threadingService = MakeThreadingService(configs);
var eventRenderer = new EPRenderEventServiceImpl();
var eventSerdeFactory = MakeEventSerdeFactory(epServicesHA.RuntimeExtensionServices);
var eventTypeSerdeRepository = MakeEventTypeSerdeRepository(eventTypeRepositoryPreconfigured, eventTypePathRegistry);
var classLoaderParent = new ParentClassLoader(importServiceRuntime.ClassLoader);
var stageRecoveryService = MakeStageRecoveryService(epServicesHA);
var classProvidedPathRegistry = new PathRegistry<string, ClassProvided>(PathRegistryObjectType.CLASSPROVIDED);
return new EPServicesContext(
container,
aggregationServiceFactoryService,
beanEventTypeFactoryPrivate,
beanEventTypeStemService,
ClassForNameProviderDefault.INSTANCE,
classLoaderParent,
classProvidedPathRegistry,
configs,
contextManagementService,
pathContextRegistry,
contextServiceFactory,
dataflowService,
dataFlowFilterServiceAdapter,
databaseConfigServiceRuntime,
deploymentLifecycleService,
dispatchService,
runtimeEnvContext,
runtimeSettingsService,
epRuntime.URI,
importServiceRuntime,
epStatementFactory,
exprDeclaredPathRegistry,
eventProcessingRWLock,
epServicesHA,
epRuntime,
eventBeanService,
eventBeanTypedEventFactory,
eventRenderer,
eventSerdeFactory,
eventTableIndexService,
eventTypeAvroHandler,
eventTypeFactory,
eventTypeIdResolver,
eventTypePathRegistry,
eventTypeRepositoryPreconfigured,
eventTypeResolvingBeanFactory,
eventTypeSerdeRepository,
exceptionHandlingService,
expressionResultCacheSharable,
filterBooleanExpressionFactory,
filterServiceSPI,
filterSharedBoolExprRepository,
filterSharedLookupableRepository,
historicalDataCacheFactory,
internalEventRouter,
metricsReporting,
multiMatchHandlerFactory,
namedWindowConsumerManagementService,
namedWindowDispatchService,
namedWindowFactoryService,
namedWindowManagementService,
pathNamedWindowRegistry,
patternFactoryService,
patternSubexpressionPoolSvc,
resultSetProcessorHelperFactory,
rowRecogStateRepoFactory,
rowRecogStatePoolEngineSvc,
schedulingService,
scriptPathRegistry,
scriptCompiler,
stageRecoveryService,
statementLifecycleService,
statementAgentInstanceLockFactory,
statementResourceHolderBuilder,
tableExprEvaluatorContext,
tableManagementService,
tablePathRegistry,
threadingService,
timeAbacus,
timeSourceService,
timerService,
variableManagementService,
variablePathRegistry,
viewableActivatorFactory,
viewFactoryService,
viewServicePreviousFactory,
xmlFragmentEventTypeFactory);
}
public EPServicesContext(
IContainer container,
AggregationServiceFactoryService aggregationServiceFactoryService,
BeanEventTypeFactoryPrivate beanEventTypeFactoryPrivate,
BeanEventTypeStemService beanEventTypeStemService,
ClassForNameProvider classForNameProvider,
ParentClassLoader classLoaderParent,
PathRegistry <string, ClassProvided> classProvidedPathRegistry,
Configuration configSnapshot,
ContextManagementService contextManagementService,
PathRegistry <string, ContextMetaData> contextPathRegistry,
ContextServiceFactory contextServiceFactory,
EPDataFlowServiceImpl dataflowService,
DataFlowFilterServiceAdapter dataFlowFilterServiceAdapter,
DatabaseConfigServiceRuntime databaseConfigServiceRuntime,
DeploymentLifecycleService deploymentLifecycleService,
DispatchService dispatchService,
RuntimeEnvContext runtimeEnvContext,
RuntimeSettingsService runtimeSettingsService,
string runtimeURI,
ImportServiceRuntime importServiceRuntime,
EPStatementFactory epStatementFactory,
PathRegistry <string, ExpressionDeclItem> exprDeclaredPathRegistry,
IReaderWriterLock eventProcessingRWLock,
EPServicesHA epServicesHA,
EPRuntimeSPI epRuntime,
EventBeanService eventBeanService,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
EPRenderEventServiceImpl eventRenderer,
EventSerdeFactory eventSerdeFactory,
EventTableIndexService eventTableIndexService,
EventTypeAvroHandler eventTypeAvroHandler,
EventTypeFactory eventTypeFactory,
EventTypeIdResolver eventTypeIdResolver,
PathRegistry <string, EventType> eventTypePathRegistry,
EventTypeRepositoryImpl eventTypeRepositoryBus,
EventTypeResolvingBeanFactory eventTypeResolvingBeanFactory,
EventTypeSerdeRepository eventTypeSerdeRepository,
ExceptionHandlingService exceptionHandlingService,
ExpressionResultCacheService expressionResultCacheService,
FilterBooleanExpressionFactory filterBooleanExpressionFactory,
FilterServiceSPI filterService,
FilterSharedBoolExprRepository filterSharedBoolExprRepository,
FilterSharedLookupableRepository filterSharedLookupableRepository,
HistoricalDataCacheFactory historicalDataCacheFactory,
InternalEventRouterImpl internalEventRouter,
MetricReportingService metricReportingService,
MultiMatchHandlerFactory multiMatchHandlerFactory,
NamedWindowConsumerManagementService namedWindowConsumerManagementService,
NamedWindowDispatchService namedWindowDispatchService,
NamedWindowFactoryService namedWindowFactoryService,
NamedWindowManagementService namedWindowManagementService,
PathRegistry <string, NamedWindowMetaData> namedWindowPathRegistry,
PatternFactoryService patternFactoryService,
PatternSubexpressionPoolRuntimeSvc patternSubexpressionPoolEngineSvc,
ResultSetProcessorHelperFactory resultSetProcessorHelperFactory,
RowRecogStateRepoFactory rowRecogStateRepoFactory,
RowRecogStatePoolRuntimeSvc rowRecogStatePoolEngineSvc,
SchedulingServiceSPI schedulingService,
PathRegistry <NameAndParamNum, ExpressionScriptProvided> scriptPathRegistry,
ScriptCompiler scriptCompiler,
StageRecoveryService stageRecoveryService,
StatementLifecycleService statementLifecycleService,
StatementAgentInstanceLockFactory statementAgentInstanceLockFactory,
StatementResourceHolderBuilder statementResourceHolderBuilder,
TableExprEvaluatorContext tableExprEvaluatorContext,
TableManagementService tableManagementService,
PathRegistry <string, TableMetaData> tablePathRegistry,
ThreadingService threadingService,
TimeAbacus timeAbacus,
TimeSourceService timeSourceService,
TimerService timerService,
VariableManagementService variableManagementService,
PathRegistry <string, VariableMetaData> variablePathRegistry,
ViewableActivatorFactory viewableActivatorFactory,
ViewFactoryService viewFactoryService,
ViewServicePreviousFactory viewServicePreviousFactory,
XMLFragmentEventTypeFactory xmlFragmentEventTypeFactory)
{
_container = container;
_aggregationServiceFactoryService = aggregationServiceFactoryService;
_beanEventTypeFactoryPrivate = beanEventTypeFactoryPrivate;
_beanEventTypeStemService = beanEventTypeStemService;
_classForNameProvider = classForNameProvider;
_classLoaderParent = classLoaderParent;
_classProvidedPathRegistry = classProvidedPathRegistry;
_configSnapshot = configSnapshot;
_contextManagementService = contextManagementService;
_contextPathRegistry = contextPathRegistry;
_contextServiceFactory = contextServiceFactory;
_dataflowService = dataflowService;
_dataFlowFilterServiceAdapter = dataFlowFilterServiceAdapter;
_databaseConfigServiceRuntime = databaseConfigServiceRuntime;
_deploymentLifecycleService = deploymentLifecycleService;
_dispatchService = dispatchService;
_runtimeEnvContext = runtimeEnvContext;
_runtimeSettingsService = runtimeSettingsService;
_runtimeUri = runtimeURI;
_importServiceRuntime = importServiceRuntime;
_epStatementFactory = epStatementFactory;
_exprDeclaredPathRegistry = exprDeclaredPathRegistry;
_eventProcessingRWLock = eventProcessingRWLock;
_epServicesHA = epServicesHA;
_epRuntime = epRuntime;
_eventBeanService = eventBeanService;
_eventBeanTypedEventFactory = eventBeanTypedEventFactory;
_eventRenderer = eventRenderer;
_eventSerdeFactory = eventSerdeFactory;
_eventTableIndexService = eventTableIndexService;
_eventTypeAvroHandler = eventTypeAvroHandler;
_eventTypeFactory = eventTypeFactory;
_eventTypeIdResolver = eventTypeIdResolver;
_eventTypePathRegistry = eventTypePathRegistry;
_eventTypeRepositoryBus = eventTypeRepositoryBus;
_eventTypeResolvingBeanFactory = eventTypeResolvingBeanFactory;
_eventTypeSerdeRepository = eventTypeSerdeRepository;
_exceptionHandlingService = exceptionHandlingService;
_expressionResultCacheService = expressionResultCacheService;
_filterBooleanExpressionFactory = filterBooleanExpressionFactory;
_filterService = filterService;
_filterSharedBoolExprRepository = filterSharedBoolExprRepository;
_filterSharedLookupableRepository = filterSharedLookupableRepository;
_historicalDataCacheFactory = historicalDataCacheFactory;
_internalEventRouter = internalEventRouter;
_metricReportingService = metricReportingService;
_multiMatchHandlerFactory = multiMatchHandlerFactory;
_namedWindowConsumerManagementService = namedWindowConsumerManagementService;
_namedWindowDispatchService = namedWindowDispatchService;
_namedWindowFactoryService = namedWindowFactoryService;
_namedWindowManagementService = namedWindowManagementService;
_namedWindowPathRegistry = namedWindowPathRegistry;
_patternFactoryService = patternFactoryService;
_patternSubexpressionPoolEngineSvc = patternSubexpressionPoolEngineSvc;
_resultSetProcessorHelperFactory = resultSetProcessorHelperFactory;
_rowRecogStateRepoFactory = rowRecogStateRepoFactory;
_rowRecogStatePoolEngineSvc = rowRecogStatePoolEngineSvc;
_schedulingService = schedulingService;
_scriptPathRegistry = scriptPathRegistry;
_stageRecoveryService = stageRecoveryService;
_statementLifecycleService = statementLifecycleService;
_statementAgentInstanceLockFactory = statementAgentInstanceLockFactory;
_statementResourceHolderBuilder = statementResourceHolderBuilder;
_tableExprEvaluatorContext = tableExprEvaluatorContext;
_tableManagementService = tableManagementService;
_tablePathRegistry = tablePathRegistry;
_threadingService = threadingService;
_timeAbacus = timeAbacus;
_timeSourceService = timeSourceService;
_timerService = timerService;
_variableManagementService = variableManagementService;
_variablePathRegistry = variablePathRegistry;
_viewableActivatorFactory = viewableActivatorFactory;
_viewFactoryService = viewFactoryService;
_viewServicePreviousFactory = viewServicePreviousFactory;
_xmlFragmentEventTypeFactory = xmlFragmentEventTypeFactory;
_scriptCompiler = scriptCompiler;
}
