private static SerdeCompileTimeResolver MakeSerdeResolver( ConfigurationCompilerSerde config, IDictionary<string, object> transientConfiguration) { var context = new SerdeProviderFactoryContext(); IList<SerdeProvider> providers = null; if (config.SerdeProviderFactories != null) { foreach (var factory in config.SerdeProviderFactories) { try { var instance = TypeHelper.Instantiate<SerdeProviderFactory>( factory, TransientConfigurationResolver.ResolveClassForNameProvider(transientConfiguration)); var provider = instance.GetProvider(context); if (provider == null) { throw new ConfigurationException("Binding provider factory '" + factory + "' returned a null value"); } if (providers == null) { providers = new List<SerdeProvider>(); } providers.Add(provider); } catch (Exception ex) { throw new ConfigurationException("Binding provider factory '" + factory + "' failed to initialize: " + ex.Message, ex); } } } if (providers == null) { providers = EmptyList<SerdeProvider>.Instance; } return new SerdeCompileTimeResolverImpl( providers, config.IsEnableExtendedBuiltin, config.IsEnableSerializable, config.IsEnableSerializationFallback); }
/// <summary> /// Performs the initialization. /// </summary> /// <param name="startTime">optional start time</param> protected void DoInitialize(long?startTime) { Log.Info("Initializing engine URI '" + _engineURI + "' version " + Version.VERSION); // This setting applies to all engines in a given VM ExecutionPathDebugLog.IsEnabled = _configSnapshot.EngineDefaults.Logging.IsEnableExecutionDebug; ExecutionPathDebugLog.IsTimerDebugEnabled = _configSnapshot.EngineDefaults.Logging.IsEnableTimerDebug; // This setting applies to all engines in a given VM MetricReportingPath.IsMetricsEnabled = _configSnapshot.EngineDefaults.MetricsReporting.IsEnableMetricsReporting; // This setting applies to all engines in a given VM AuditPath.AuditPattern = _configSnapshot.EngineDefaults.Logging.AuditPattern; // This setting applies to all engines in a given VM ThreadingOption.IsThreadingEnabled = ( ThreadingOption.IsThreadingEnabled || _configSnapshot.EngineDefaults.Threading.IsThreadPoolTimerExec || _configSnapshot.EngineDefaults.Threading.IsThreadPoolInbound || _configSnapshot.EngineDefaults.Threading.IsThreadPoolRouteExec || _configSnapshot.EngineDefaults.Threading.IsThreadPoolOutbound ); if (_engine != null) { _engine.Services.TimerService.StopInternalClock(false); // Give the timer thread a little moment to catch up Thread.Sleep(100); if (_configSnapshot.EngineDefaults.MetricsReporting.IsEnableMetricsReporting) { DestroyEngineMetrics(_engine.Services.EngineURI); } _engine.Runtime.Initialize(); _engine.Services.Dispose(); } // Make EP services context factory var epServicesContextFactoryClassName = _configSnapshot.EPServicesContextFactoryClassName; EPServicesContextFactory epServicesContextFactory; if (epServicesContextFactoryClassName == null) { // Check system properties epServicesContextFactoryClassName = Environment.GetEnvironmentVariable("ESPER_EPSERVICE_CONTEXT_FACTORY_CLASS"); } if (epServicesContextFactoryClassName == null) { epServicesContextFactory = new EPServicesContextFactoryDefault(); } else { Type clazz; try { clazz = TransientConfigurationResolver.ResolveClassForNameProvider( _configSnapshot.TransientConfiguration).ClassForName(epServicesContextFactoryClassName); } catch (TypeLoadException) { throw new ConfigurationException( "Type '" + epServicesContextFactoryClassName + "' cannot be loaded"); } Object obj; try { obj = Activator.CreateInstance(clazz); } catch (TypeLoadException) { throw new ConfigurationException("Class '" + clazz + "' cannot be instantiated"); } catch (MissingMethodException e) { throw new ConfigurationException( "Error instantiating class - Default constructor was not found", e); } catch (MethodAccessException e) { throw new ConfigurationException( "Error instantiating class - Caller does not have permission to use constructor", e); } catch (ArgumentException e) { throw new ConfigurationException("Error instantiating class - Type is not a RuntimeType", e); } epServicesContextFactory = (EPServicesContextFactory)obj; } var services = epServicesContextFactory.CreateServicesContext(this, _configSnapshot); // New runtime EPRuntimeSPI runtimeSPI; InternalEventRouteDest routeDest; TimerCallback timerCallback; var runtimeClassName = _configSnapshot.EngineDefaults.AlternativeContext.Runtime; if (runtimeClassName == null) { // Check system properties runtimeClassName = Environment.GetEnvironmentVariable("ESPER_EPRUNTIME_CLASS"); } if (runtimeClassName == null) { var runtimeImpl = new EPRuntimeImpl(services); runtimeSPI = runtimeImpl; routeDest = runtimeImpl; timerCallback = runtimeImpl.TimerCallback; } else { Type clazz; try { clazz = TypeHelper.ResolveType(runtimeClassName, true); } catch (TypeLoadException) { throw new ConfigurationException("Class '" + runtimeClassName + "' cannot be loaded"); } Object obj; try { var c = clazz.GetConstructor(new[] { typeof(EPServicesContext) }); obj = c.Invoke(new object[] { services }); } catch (TypeLoadException) { throw new ConfigurationException("Class '" + clazz + "' cannot be instantiated"); } catch (MissingMethodException) { throw new ConfigurationException( "Class '" + clazz + "' cannot be instantiated, constructor accepting services was not found"); } catch (MethodAccessException) { throw new ConfigurationException("Illegal access instantiating class '" + clazz + "'"); } runtimeSPI = (EPRuntimeSPI)obj; routeDest = (InternalEventRouteDest)obj; timerCallback = (TimerCallback)obj; } routeDest.InternalEventRouter = services.InternalEventRouter; services.InternalEventEngineRouteDest = routeDest; // set current time, if applicable if (startTime != null) { services.SchedulingService.Time = startTime.Value; } // Configure services to use the new runtime services.TimerService.Callback = timerCallback; // Statement lifecycle init services.StatementLifecycleSvc.Init(); // Filter service init services.FilterService.Init(); // Schedule service init services.SchedulingService.Init(); // New admin var configOps = new ConfigurationOperationsImpl( services.EventAdapterService, services.EventTypeIdGenerator, services.EngineImportService, services.VariableService, services.EngineSettingsService, services.ValueAddEventService, services.MetricsReportingService, services.StatementEventTypeRefService, services.StatementVariableRefService, services.PlugInViews, services.FilterService, services.PatternSubexpressionPoolSvc, services.MatchRecognizeStatePoolEngineSvc, services.TableService, _configSnapshot.TransientConfiguration); var defaultStreamSelector = SelectClauseStreamSelectorEnumExtensions.MapFromSODA( _configSnapshot.EngineDefaults.StreamSelection.DefaultStreamSelector); EPAdministratorSPI adminSPI; var adminClassName = _configSnapshot.EngineDefaults.AlternativeContext.Admin; var adminContext = new EPAdministratorContext(runtimeSPI, services, configOps, defaultStreamSelector); if (adminClassName == null) { // Check system properties adminClassName = Environment.GetEnvironmentVariable("ESPER_EPADMIN_CLASS"); } if (adminClassName == null) { adminSPI = new EPAdministratorImpl(adminContext); } else { Type clazz; try { clazz = TypeHelper.ResolveType(adminClassName, true); } catch (TypeLoadException) { throw new ConfigurationException( "Class '" + epServicesContextFactoryClassName + "' cannot be loaded"); } Object obj; try { var c = clazz.GetConstructor(new[] { typeof(EPAdministratorContext) }); obj = c.Invoke(new[] { adminContext }); } catch (TypeLoadException) { throw new ConfigurationException("Class '" + clazz + "' cannot be instantiated"); } catch (MissingMethodException) { throw new ConfigurationException( "Class '" + clazz + "' cannot be instantiated, constructor accepting context was not found"); } catch (MethodAccessException) { throw new ConfigurationException("Illegal access instantiating class '" + clazz + "'"); } adminSPI = (EPAdministratorSPI)obj; } // Start clocking if (_configSnapshot.EngineDefaults.Threading.IsInternalTimerEnabled) { if (_configSnapshot.EngineDefaults.TimeSource.TimeUnit != TimeUnit.MILLISECONDS) { throw new ConfigurationException("Internal timer requires millisecond time resolution"); } services.TimerService.StartInternalClock(); } // Give the timer thread a little moment to start up Thread.Sleep(100); // Save engine instance _engine = new EPServiceEngine(services, runtimeSPI, adminSPI); // Load and initialize adapter loader classes LoadAdapters(services); // Initialize extension services if (services.EngineLevelExtensionServicesContext != null) { services.EngineLevelExtensionServicesContext.Init(services, runtimeSPI, adminSPI); } // Start metrics reporting, if any if (_configSnapshot.EngineDefaults.MetricsReporting.IsEnableMetricsReporting) { services.MetricsReportingService.SetContext(runtimeSPI, services); } // Start engine metrics report if (_configSnapshot.EngineDefaults.MetricsReporting.IsEnableMetricsReporting) { StartEngineMetrics(services, runtimeSPI); } // register with the statement lifecycle service services.StatementLifecycleSvc.LifecycleEvent += HandleLifecycleEvent; // call initialize listeners try { if (ServiceInitialized != null) { ServiceInitialized(this, new ServiceProviderEventArgs(this)); } } catch (Exception ex) { Log.Error("Runtime exception caught during an ServiceInitialized event:" + ex.Message, ex); } }
/// <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); } } }
public ClassLoader GetClassLoader() { return TransientConfigurationResolver .ResolveClassLoader(_classLoaderProvider, _transientConfiguration) .GetClassLoader(); }
public ClassLoader GetFastClassClassLoader(Type clazz) { return TransientConfigurationResolver.ResolveFastClassClassLoaderProvider(_transientConfiguration) .Classloader(clazz); }
public ClassForNameProvider GetClassForNameProvider() { return TransientConfigurationResolver.ResolveClassForNameProvider(_transientConfiguration); }
public ClassLoader GetClassLoader() { return(TransientConfigurationResolver.ResolveClassLoader(_transientConfiguration).Classloader()); }