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);
}
}
private static void CompileDeployWSubstitution(
RegressionEnvironment env,
string epl,
IDictionary<string, object> @params)
{
var compiled = env.Compile("@Name('s0') " + epl);
StatementSubstitutionParameterOption resolver = ctx => {
foreach (var entry in @params) {
ctx.SetObject(entry.Key, entry.Value);
}
};
env.Deploy(compiled, new DeploymentOptions().WithStatementSubstitutionParameter(resolver));
env.AddListener("s0");
}
private static void DeployWithResolver(
RegressionEnvironment env,
EPCompiled compiled,
string statementName,
StatementSubstitutionParameterOption resolver)
{
var options = new DeploymentOptions().WithStatementSubstitutionParameter(resolver);
options.StatementNameRuntime = context => statementName;
try {
env.Deployment.Deploy(compiled, options);
}
catch (EPDeployException e) {
throw new EPRuntimeException(e);
}
}
private static void TryInvalidResolver(
RegressionEnvironment env,
EPCompiled compiled,
string expected,
StatementSubstitutionParameterOption resolver)
{
var options = new DeploymentOptions().WithStatementSubstitutionParameter(resolver);
try {
env.Deployment.Deploy(compiled, options);
Assert.Fail();
}
catch (EPDeploySubstitutionParameterException e) {
AssertMessage(e.Message, expected);
}
catch (EPDeployException e) {
throw new EPRuntimeException(e);
}
}
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 providing values for substitution parameters.
/// </summary>
/// <param name="statementSubstitutionParameter">callback</param>
/// <returns>itself</returns>
public DeploymentOptions WithStatementSubstitutionParameter(
StatementSubstitutionParameterOption statementSubstitutionParameter)
{
StatementSubstitutionParameter = statementSubstitutionParameter;
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 IDictionary <int, IDictionary <int, object> > SetSubstitutionParameterValues(
int rolloutItemNumber,
string deploymentId,
IList <StatementLightweight> lightweights,
StatementSubstitutionParameterOption substitutionParameterResolver)
{
if (substitutionParameterResolver == null)
{
foreach (var lightweight in lightweights)
{
var required = lightweight.StatementInformationals.SubstitutionParamTypes;
if (required != null && required.Length > 0)
{
throw new EPDeploySubstitutionParameterException(
"Statement '" + lightweight.StatementContext.StatementName + "' has " + required.Length + " substitution parameters",
rolloutItemNumber);
}
}
return(EmptyDictionary <int, IDictionary <int, object> > .Instance);
}
IDictionary <int, IDictionary <int, object> > providedAllStmt = new Dictionary <int, IDictionary <int, object> >();
foreach (var lightweight in lightweights)
{
var substitutionTypes = lightweight.StatementInformationals.SubstitutionParamTypes;
IDictionary <string, int> paramNames = lightweight.StatementInformationals.SubstitutionParamNames;
var handler = new DeployerSubstitutionParameterHandler(
deploymentId,
lightweight,
providedAllStmt,
substitutionTypes,
paramNames);
try {
substitutionParameterResolver.Invoke(handler);
}
catch (Exception ex) {
throw new EPDeploySubstitutionParameterException(
"Failed to set substitution parameter value for statement '" + lightweight.StatementContext.StatementName + "': " + ex.Message,
ex,
rolloutItemNumber);
}
if (substitutionTypes == null || substitutionTypes.Length == 0)
{
continue;
}
// check that all values are provided
var provided = providedAllStmt.Get(lightweight.StatementContext.StatementId);
var providedSize = provided == null ? 0 : provided.Count;
if (providedSize != substitutionTypes.Length)
{
for (var i = 0; i < substitutionTypes.Length; i++)
{
if (provided == null || !provided.ContainsKey(i + 1))
{
var name = Convert.ToString(i + 1);
if (paramNames != null && !paramNames.IsEmpty())
{
foreach (var entry in paramNames)
{
if (entry.Value == i + 1)
{
name = "'" + entry.Key + "'";
}
}
}
throw new EPDeploySubstitutionParameterException(
"Missing value for substitution parameter " + name + " for statement '" + lightweight.StatementContext.StatementName + "'",
rolloutItemNumber);
}
}
}
}
return(providedAllStmt);
}
/// <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);
}
}
}
