private static DeploymentInternal Deploy(
bool recovery,
string deploymentId,
int statementIdFirstStatement,
EPCompiled compiled,
StatementNameRuntimeOption statementNameResolverRuntime,
StatementUserObjectRuntimeOption userObjectResolverRuntime,
StatementSubstitutionParameterOption substitutionParameterResolver,
DeploymentClassLoaderOption deploymentClassLoaderOption,
EPRuntimeSPI epRuntime)
{
// set variable local version
epRuntime.ServicesContext.VariableManagementService.SetLocalVersion();
try {
return(DeploySafe(
recovery,
deploymentId,
statementIdFirstStatement,
compiled,
statementNameResolverRuntime,
userObjectResolverRuntime,
substitutionParameterResolver,
deploymentClassLoaderOption,
epRuntime));
}
catch (EPDeployException) {
throw;
}
catch (Exception ex) {
throw new EPDeployException(ex.Message, ex, -1);
}
}
public static DeploymentInternal DeployRecover(
string deploymentId,
int statementIdFirstStatement,
EPCompiled compiled,
StatementNameRuntimeOption statementNameResolverRuntime,
StatementUserObjectRuntimeOption userObjectResolverRuntime,
StatementSubstitutionParameterOption substitutionParameterResolver,
DeploymentClassLoaderOption deploymentClassLoaderOption,
EPRuntimeSPI epRuntime)
{
return(Deploy(
true,
deploymentId,
statementIdFirstStatement,
compiled,
statementNameResolverRuntime,
userObjectResolverRuntime,
substitutionParameterResolver,
deploymentClassLoaderOption,
epRuntime));
}
/// <summary>
/// Sets the callback overriding the statement name that identifies the statement within the deployment
/// and that can be obtained using <see cref="EPStatement.Name" />
/// </summary>
/// <param name="statementNameRuntime">callback</param>
/// <returns>itself</returns>
public DeploymentOptions WithStatementNameRuntime(StatementNameRuntimeOption statementNameRuntime)
{
StatementNameRuntime = statementNameRuntime;
return this;
}
private static DeploymentInternal DeploySafe(
bool recovery,
string deploymentId,
int statementIdFirstStatement,
EPCompiled compiled,
StatementNameRuntimeOption statementNameResolverRuntime,
StatementUserObjectRuntimeOption userObjectResolverRuntime,
StatementSubstitutionParameterOption substitutionParameterResolver,
DeploymentClassLoaderOption deploymentClassLoaderOption,
EPRuntimeSPI epRuntime)
{
var services = epRuntime.ServicesContext;
var deploymentClassLoader = DeployerHelperResolver.GetClassLoader(-1, deploymentClassLoaderOption, services);
var moduleProvider = ModuleProviderUtil.Analyze(compiled, deploymentClassLoader, services.ClassProvidedPathRegistry);
if (moduleProvider.ClassLoader is ClassProvidedImportClassLoader)
{
((ClassProvidedImportClassLoader)moduleProvider.ClassLoader).Imported = moduleProvider.ModuleProvider.ModuleDependencies.PathClasses;
}
var moduleName = moduleProvider.ModuleProvider.ModuleName;
// resolve external dependencies
var moduleDependencies = moduleProvider.ModuleProvider.ModuleDependencies;
var deploymentIdDependencies = ResolveDependencies(-1, moduleDependencies, services);
// initialize EPL objects defined by module
var moduleEPLObjects = InitializeEPLObjects(moduleProvider, deploymentId, services);
// determine staged EPL object overlap
ValidateStagedEPLObjects(moduleEPLObjects, moduleProvider.ModuleProvider.ModuleName, -1, epRuntime.StageService);
// add EPL objects defined by module to path
var modulePaths = UpdatePath(-1, moduleEPLObjects, moduleName, deploymentId, services);
// obtain statement lightweights
var stmtLightweights = InitializeStatements(
-1,
recovery,
moduleEPLObjects,
modulePaths,
moduleName,
moduleProvider,
deploymentId,
statementIdFirstStatement,
userObjectResolverRuntime,
statementNameResolverRuntime,
substitutionParameterResolver,
services);
// start statements depending on context association
var statements = DeployStatements(
-1, stmtLightweights.Lightweights, recovery, modulePaths, moduleProvider, deploymentId, epRuntime);
// add dependencies
AddPathDependencies(deploymentId, moduleDependencies, services);
// keep statement and deployment
var deployed = DeploymentInternal.From(
deploymentId,
statements,
deploymentIdDependencies,
modulePaths,
moduleEPLObjects,
moduleProvider);
services.DeploymentLifecycleService.AddDeployment(deploymentId, deployed);
// register for recovery
if (!recovery)
{
var recoveryInformation = GetRecoveryInformation(deployed);
services.DeploymentRecoveryService.Add(
deploymentId,
statementIdFirstStatement,
compiled,
recoveryInformation.StatementUserObjectsRuntime,
recoveryInformation.StatementNamesWhenProvidedByAPI,
stmtLightweights.SubstitutionParameters);
}
return(deployed);
}
public static DeployerModuleStatementLightweights InitializeStatements(
int rolloutItemNumber,
bool recovery,
DeployerModuleEPLObjects moduleEPLObjects,
DeployerModulePaths modulePaths,
string moduleName,
ModuleProviderCLPair moduleProvider,
string deploymentId,
int statementIdFirstStatement,
StatementUserObjectRuntimeOption userObjectResolverRuntime,
StatementNameRuntimeOption statementNameResolverRuntime,
StatementSubstitutionParameterOption substitutionParameterResolver,
EPServicesContext services)
{
// get module statements
IList <StatementProvider> statementResources;
try {
statementResources = moduleProvider.ModuleProvider.Statements;
}
catch (Exception e) {
throw new EPException(e);
}
// initialize all statements
IList <StatementLightweight> lightweights = new List <StatementLightweight>();
IDictionary <int, IDictionary <int, object> > substitutionParameters;
ISet <string> statementNames = new HashSet <string>();
var moduleIncidentals = moduleEPLObjects.Incidentals;
try {
var statementId = statementIdFirstStatement;
foreach (var statement in statementResources)
{
var lightweight = InitStatement(
recovery,
moduleName,
statement,
deploymentId,
statementId,
moduleEPLObjects.EventTypeResolver,
moduleIncidentals,
statementNameResolverRuntime,
userObjectResolverRuntime,
moduleProvider.ClassLoader,
services);
lightweights.Add(lightweight);
statementId++;
var statementName = lightweight.StatementContext.StatementName;
if (statementNames.Contains(statementName))
{
throw new EPDeployException(
"Duplicate statement name provide by statement name resolver for statement name '" + statementName + "'",
rolloutItemNumber);
}
statementNames.Add(statementName);
}
// set parameters
substitutionParameters = SetSubstitutionParameterValues(rolloutItemNumber, deploymentId, lightweights, substitutionParameterResolver);
}
catch (Exception) {
DeployerHelperResolver.ReverseDeployment(deploymentId, modulePaths.DeploymentTypes, lightweights, new EPStatement[0], moduleProvider, services);
throw;
}
return(new DeployerModuleStatementLightweights(statementIdFirstStatement, lightweights, substitutionParameters));
}
private static StatementLightweight InitStatement(
bool recovery,
string moduleName,
StatementProvider statementProvider,
string deploymentId,
int statementId,
EventTypeResolver eventTypeResolver,
ModuleIncidentals moduleIncidentals,
StatementNameRuntimeOption statementNameResolverRuntime,
StatementUserObjectRuntimeOption userObjectResolverRuntime,
ClassLoader moduleClassLoader,
EPServicesContext services)
{
var informationals = statementProvider.Informationals;
// set instrumentation unless already provided
if (informationals.InstrumentationProvider == null)
{
informationals.InstrumentationProvider = InstrumentationDefault.INSTANCE;
}
var statementResultService = new StatementResultServiceImpl(informationals, services);
FilterSharedLookupableRegistery filterSharedLookupableRegistery = new ProxyFilterSharedLookupableRegistery()
{
ProcRegisterLookupable = (
eventTypeX,
lookupable) => {
services.FilterSharedLookupableRepository.RegisterLookupable(statementId, eventTypeX, lookupable);
},
};
FilterSharedBoolExprRegistery filterSharedBoolExprRegistery = new ProxyFilterSharedBoolExprRegistery()
{
ProcRegisterBoolExpr = (node) => { services.FilterSharedBoolExprRepository.RegisterBoolExpr(statementId, node); },
};
IDictionary <int, FilterSpecActivatable> filterSpecActivatables = new Dictionary <int, FilterSpecActivatable>();
FilterSpecActivatableRegistry filterSpecActivatableRegistry = new ProxyFilterSpecActivatableRegistry()
{
ProcRegister = (filterSpecActivatable) => { filterSpecActivatables.Put(filterSpecActivatable.FilterCallbackId, filterSpecActivatable); },
};
var contextPartitioned = informationals.OptionalContextName != null;
var statementResourceService = new StatementResourceService(contextPartitioned);
// determine statement name
var statementName = informationals.StatementNameCompileTime;
if (statementNameResolverRuntime != null)
{
string statementNameAssigned = statementNameResolverRuntime.Invoke(
new StatementNameRuntimeContext(
deploymentId,
statementName,
statementId,
(string)informationals.Properties.Get(StatementProperty.EPL),
informationals.Annotations));
if (statementNameAssigned != null)
{
statementName = statementNameAssigned;
}
}
statementName = statementName.Trim();
var epInitServices = new EPStatementInitServicesImpl(
statementName,
informationals.Properties,
informationals.Annotations,
deploymentId,
eventTypeResolver,
filterSpecActivatableRegistry,
filterSharedBoolExprRegistery,
filterSharedLookupableRegistery,
moduleIncidentals,
recovery,
statementResourceService,
statementResultService,
services);
if (!services.EpServicesHA.RuntimeExtensionServices.IsHAEnabled)
{
statementProvider.Initialize(epInitServices);
}
else
{
// for HA we set the context classloader as state may be loaded considering the module provider's classloader
// - NEsper doesn't support HA like this, and we wouldn't want to deliver this information in
// - this manner. An alternative delivery mechanism must be established to carry the information
// - without relying on the "current" thread to carry that detail.
// ClassLoader originalClassLoader = Thread.CurrentThread().ContextClassLoader;
// try {
// Thread.CurrentThread().ContextClassLoader = moduleClassLoader;
// statementProvider.Initialize(epInitServices);
// }
// finally {
// Thread.CurrentThread().ContextClassLoader = originalClassLoader;
// }
}
var multiMatchHandler = services.MultiMatchHandlerFactory.Make(informationals.HasSubquery, informationals.IsNeedDedup);
var stmtMetric = services.MetricReportingService.GetStatementHandle(statementId, deploymentId, statementName);
var optionalEPL = (string)informationals.Properties.Get(StatementProperty.EPL);
InsertIntoLatchFactory insertIntoFrontLatchFactory = null;
InsertIntoLatchFactory insertIntoBackLatchFactory = null;
if (informationals.InsertIntoLatchName != null)
{
var latchFactoryNameBack = "insert_stream_B_" + informationals.InsertIntoLatchName + "_" + statementName;
var latchFactoryNameFront = "insert_stream_F_" + informationals.InsertIntoLatchName + "_" + statementName;
var msecTimeout = services.RuntimeSettingsService.ConfigurationRuntime.Threading.InsertIntoDispatchTimeout;
var locking = services.RuntimeSettingsService.ConfigurationRuntime.Threading.InsertIntoDispatchLocking;
var latchFactoryFront = new InsertIntoLatchFactory(
latchFactoryNameFront,
informationals.IsStateless,
msecTimeout,
locking,
services.TimeSourceService);
var latchFactoryBack = new InsertIntoLatchFactory(
latchFactoryNameBack,
informationals.IsStateless,
msecTimeout,
locking,
services.TimeSourceService);
insertIntoFrontLatchFactory = latchFactoryFront;
insertIntoBackLatchFactory = latchFactoryBack;
}
var statementHandle = new EPStatementHandle(
statementName,
deploymentId,
statementId,
optionalEPL,
informationals.Priority,
informationals.IsPreemptive,
informationals.IsCanSelfJoin,
multiMatchHandler,
informationals.HasVariables,
informationals.HasTableAccess,
stmtMetric,
insertIntoFrontLatchFactory,
insertIntoBackLatchFactory);
// determine context
StatementAIResourceRegistry statementAgentInstanceRegistry = null;
ContextRuntimeDescriptor contextRuntimeDescriptor = null;
var optionalContextName = informationals.OptionalContextName;
if (optionalContextName != null)
{
var contextDeploymentId = ContextDeployTimeResolver.ResolveContextDeploymentId(
informationals.OptionalContextModuleName,
informationals.OptionalContextVisibility,
optionalContextName,
deploymentId,
services.ContextPathRegistry);
var contextManager = services.ContextManagementService.GetContextManager(contextDeploymentId, optionalContextName);
contextRuntimeDescriptor = contextManager.ContextRuntimeDescriptor;
var registryRequirements = statementProvider.StatementAIFactoryProvider.Factory.RegistryRequirements;
statementAgentInstanceRegistry = contextManager.AllocateAgentInstanceResourceRegistry(registryRequirements);
}
var statementCPCacheService = new StatementCPCacheService(
contextPartitioned,
statementResourceService,
statementAgentInstanceRegistry);
var eventType = statementProvider.StatementAIFactoryProvider.Factory.StatementEventType;
var configurationThreading = services.RuntimeSettingsService.ConfigurationRuntime.Threading;
var preserveDispatchOrder = configurationThreading.IsListenerDispatchPreserveOrder && !informationals.IsStateless;
var isSpinLocks = configurationThreading.ListenerDispatchLocking == Locking.SPIN;
var msecBlockingTimeout = configurationThreading.ListenerDispatchTimeout;
UpdateDispatchViewBase dispatchChildView;
if (preserveDispatchOrder)
{
if (isSpinLocks)
{
dispatchChildView = new UpdateDispatchViewBlockingSpin(
eventType,
statementResultService,
services.DispatchService,
msecBlockingTimeout,
services.TimeSourceService);
}
else
{
dispatchChildView = new UpdateDispatchViewBlockingWait(eventType, statementResultService, services.DispatchService, msecBlockingTimeout);
}
}
else
{
dispatchChildView = new UpdateDispatchViewNonBlocking(eventType, statementResultService, services.DispatchService);
}
var countSubexpressions = services.ConfigSnapshot.Runtime.Patterns.MaxSubexpressions != null;
PatternSubexpressionPoolStmtSvc patternSubexpressionPoolStmtSvc = null;
if (countSubexpressions)
{
var stmtCounter = new PatternSubexpressionPoolStmtHandler();
patternSubexpressionPoolStmtSvc = new PatternSubexpressionPoolStmtSvc(services.PatternSubexpressionPoolRuntimeSvc, stmtCounter);
services.PatternSubexpressionPoolRuntimeSvc.AddPatternContext(statementId, statementName, stmtCounter);
}
var countMatchRecogStates = services.ConfigSnapshot.Runtime.MatchRecognize.MaxStates != null;
RowRecogStatePoolStmtSvc rowRecogStatePoolStmtSvc = null;
if (countMatchRecogStates && informationals.HasMatchRecognize)
{
var stmtCounter = new RowRecogStatePoolStmtHandler();
rowRecogStatePoolStmtSvc = new RowRecogStatePoolStmtSvc(services.RowRecogStatePoolEngineSvc, stmtCounter);
services.RowRecogStatePoolEngineSvc.AddPatternContext(new DeploymentIdNamePair(deploymentId, statementName), stmtCounter);
}
// get user object for runtime
object userObjectRuntime = null;
if (userObjectResolverRuntime != null)
{
userObjectRuntime = userObjectResolverRuntime.GetUserObject(
new StatementUserObjectRuntimeContext(
deploymentId,
statementName,
statementId,
(string)informationals.Properties.Get(StatementProperty.EPL),
informationals.Annotations));
}
var statementContext = new StatementContext(
services.Container,
contextRuntimeDescriptor,
deploymentId,
statementId,
statementName,
moduleName,
informationals,
userObjectRuntime,
services.StatementContextRuntimeServices,
statementHandle,
filterSpecActivatables,
patternSubexpressionPoolStmtSvc,
rowRecogStatePoolStmtSvc,
new ScheduleBucket(statementId),
statementAgentInstanceRegistry,
statementCPCacheService,
statementProvider.StatementAIFactoryProvider,
statementResultService,
dispatchChildView,
services.FilterService,
services.SchedulingService,
services.InternalEventRouteDest
);
foreach (var readyCallback in epInitServices.ReadyCallbacks)
{
readyCallback.Ready(statementContext, moduleIncidentals, recovery);
}
return(new StatementLightweight(statementProvider, informationals, statementResultService, statementContext));
}
/// <summary>
/// Performs the initialization.
/// </summary>
/// <param name="startTime">optional start time</param>
protected void DoInitialize(long? startTime)
{
Log.Info("Initializing runtime URI '" + URI + "' version " + RuntimeVersion.RUNTIME_VERSION);
// Retain config-at-initialization since config-last-provided can be set to new values and "initialize" can be called
_configAtInitialization = _configLastProvided;
// Verify settings
if (_configLastProvided.Runtime.Threading.IsInternalTimerEnabled &&
_configLastProvided.Common.TimeSource.TimeUnit != TimeUnit.MILLISECONDS) {
throw new ConfigurationException("Internal timer requires millisecond time resolution");
}
// This setting applies to all runtimes in a given VM
ExecutionPathDebugLog.IsDebugEnabled = _configLastProvided.Runtime.Logging.IsEnableExecutionDebug;
ExecutionPathDebugLog.IsTimerDebugEnabled = _configLastProvided.Runtime.Logging.IsEnableTimerDebug;
// This setting applies to all runtimes in a given VM
AuditPath.AuditPattern = _configLastProvided.Runtime.Logging.AuditPattern;
if (_runtimeEnvironment != null) {
if (ServiceStatusProvider != null) {
ServiceStatusProvider.Set(false);
}
_runtimeEnvironment.Services.TimerService.StopInternalClock(false);
if (_configLastProvided.Runtime.MetricsReporting.IsRuntimeMetrics) {
DestroyEngineMetrics(_runtimeEnvironment.Services.RuntimeURI);
}
_runtimeEnvironment.Runtime.Initialize();
_runtimeEnvironment.Services.Destroy();
}
ServiceStatusProvider = new AtomicBoolean(true);
// Make EP services context factory
var epServicesContextFactoryClassName = _configLastProvided.Runtime.EPServicesContextFactoryClassName;
EPServicesContextFactory epServicesContextFactory;
if (epServicesContextFactoryClassName == null) {
// Check system properties
epServicesContextFactoryClassName = Environment.GetEnvironmentVariable("ESPER_EPSERVICE_CONTEXT_FACTORY_CLASS");
}
if (epServicesContextFactoryClassName == null) {
epServicesContextFactory = new EPServicesContextFactoryDefault(Container);
}
else {
Type clazz;
try {
clazz = TransientConfigurationResolver.ResolveClassForNameProvider(_configLastProvided.Common.TransientConfiguration)
.ClassForName(epServicesContextFactoryClassName);
}
catch (TypeLoadException) {
throw new ConfigurationException("Class '" + epServicesContextFactoryClassName + "' cannot be loaded");
}
object obj;
try {
obj = TypeHelper.Instantiate(clazz);
}
catch (Exception) {
throw new ConfigurationException("Class '" + clazz + "' cannot be instantiated");
}
epServicesContextFactory = (EPServicesContextFactory) obj;
}
EPServicesContext services;
try {
services = epServicesContextFactory.CreateServicesContext(this, _configLastProvided);
}
catch (EPException ex) {
throw new ConfigurationException("Failed runtime startup: " + ex.Message, ex);
//throw;
}
catch (Exception ex) {
throw new ConfigurationException("Failed runtime startup: " + ex.Message, ex);
}
// new runtime
EPEventServiceImpl eventService = epServicesContextFactory.CreateEPRuntime(services, ServiceStatusProvider);
eventService.InternalEventRouter = services.InternalEventRouter;
services.InternalEventRouteDest = eventService;
// set current time, if applicable
if (startTime != null) {
services.SchedulingService.Time = startTime.Value;
}
// Configure services to use the new runtime
services.TimerService.Callback = eventService;
// New services
EPDeploymentServiceSPI deploymentService = new EPDeploymentServiceImpl(services, this);
var eventTypeService = new EPEventTypeServiceImpl(services);
EPContextPartitionService contextPartitionService = new EPContextPartitionServiceImpl(services);
EPVariableService variableService = new EPVariableServiceImpl(services);
EPMetricsService metricsService = new EPMetricsServiceImpl(services);
EPFireAndForgetService fireAndForgetService = new EpFireAndForgetServiceImpl(services, ServiceStatusProvider);
EPStageServiceSPI stageService = new EPStageServiceImpl(services, ServiceStatusProvider);
// Build runtime environment
_runtimeEnvironment = new EPRuntimeEnv(
services,
eventService,
deploymentService,
eventTypeService,
contextPartitionService,
variableService,
metricsService,
fireAndForgetService,
stageService);
// Stage Recovery
var stageIterator = services.StageRecoveryService.StagesIterate();
while (stageIterator.MoveNext()) {
var entry = stageIterator.Current;
long currentTimeStage;
if (services.EpServicesHA.CurrentTimeAsRecovered == null) {
currentTimeStage = services.SchedulingService.Time;
} else if (!services.EpServicesHA.CurrentTimeStageAsRecovered.TryGetValue(entry.Value, out currentTimeStage)) {
currentTimeStage = services.SchedulingService.Time;
}
stageService.RecoverStage(entry.Key, entry.Value, currentTimeStage);
}
// Deployment Recovery
var deploymentIterator = services.DeploymentRecoveryService.Deployments();
ISet<EventType> protectedVisibleTypes = new LinkedHashSet<EventType>();
while (deploymentIterator.MoveNext()) {
var entry = deploymentIterator.Current;
var deploymentId = entry.Key;
StatementUserObjectRuntimeOption userObjectResolver = new ProxyStatementUserObjectRuntimeOption {
ProcGetUserObject = env => entry.Value.UserObjectsRuntime.Get(env.StatementId)
};
StatementNameRuntimeOption statementNameResolver =
env => entry.Value.StatementNamesWhenProvidedByAPI.Get(env.StatementId);
StatementSubstitutionParameterOption substitutionParameterResolver = env => {
var param = entry.Value.SubstitutionParameters.Get(env.StatementId);
if (param == null) {
return;
}
if (env.SubstitutionParameterNames != null) {
foreach (var name in env.SubstitutionParameterNames) {
env.SetObject(name.Key, param.Get(name.Value));
}
}
else {
for (var i = 0; i < env.SubstitutionParameterTypes.Length; i++) {
env.SetObject(i + 1, param.Get(i + 1));
}
}
};
DeploymentInternal deployerResult;
try {
deployerResult = Deployer.DeployRecover(
deploymentId,
entry.Value.StatementIdFirstStatement,
entry.Value.Compiled,
statementNameResolver,
userObjectResolver,
substitutionParameterResolver,
null,
this);
}
catch (EPDeployException ex) {
throw new EPException(ex.Message, ex);
}
foreach (var eventType in deployerResult.DeploymentTypes.Values) {
if (eventType.Metadata.BusModifier == EventTypeBusModifier.BUS ||
eventType.Metadata.TypeClass == EventTypeTypeClass.NAMED_WINDOW ||
eventType.Metadata.TypeClass == EventTypeTypeClass.STREAM) {
protectedVisibleTypes.Add(eventType);
}
}
// handle staged deployments
var stageUri = services.StageRecoveryService.DeploymentGetStage(deploymentId);
if (stageUri != null) {
stageService.RecoverDeployment(stageUri, deployerResult);
}
}
// Event Handler Recovery
var eventHandlers = services.ListenerRecoveryService.Listeners;
while (eventHandlers.MoveNext()) {
var deployment = eventHandlers.Current;
var epStatement = services.StatementLifecycleService.GetStatementById(deployment.Key);
epStatement.RecoveryUpdateEventHandlers(new EPStatementListenerSet(deployment.Value));
}
// Filter service init
ISet<EventType> filterServiceTypes = new LinkedHashSet<EventType>(services.EventTypeRepositoryBus.AllTypes);
filterServiceTypes.AddAll(protectedVisibleTypes);
Supplier<ICollection<EventType>> availableTypes = () => filterServiceTypes;
services.FilterServiceSPI.Init(availableTypes);
// Schedule service init
services.SchedulingServiceSPI.Init();
// Stage services init
stageService.RecoveredStageInitialize(availableTypes);
// Start clocking
if (_configLastProvided.Runtime.Threading.IsInternalTimerEnabled) {
services.TimerService.StartInternalClock();
}
// Load and initialize adapter loader classes
LoadAdapters(services);
// Initialize extension services
if (services.RuntimeExtensionServices != null) {
((RuntimeExtensionServicesSPI) services.RuntimeExtensionServices).Init(services, eventService, deploymentService, stageService);
}
// Start metrics reporting, if any
if (_configLastProvided.Runtime.MetricsReporting.IsEnableMetricsReporting) {
services.MetricReportingService.SetContext(services.FilterService, services.SchedulingService, eventService);
}
// Start runtimes metrics report
if (_configLastProvided.Runtime.MetricsReporting.IsRuntimeMetrics) {
StartEngineMetrics(services, eventService);
}
// call initialize listeners
foreach (var listener in _serviceListeners) {
try {
listener.OnEPRuntimeInitialized(this);
}
catch (Exception ex) {
Log.Error("Runtime exception caught during an onEPRuntimeInitialized callback:" + ex.Message, ex);
}
}
}
