public static void CheckModulePreconditions( string deploymentId, string moduleName, DeploymentInternal deployment, EPServicesContext services) { foreach (var namedWindow in deployment.PathNamedWindows) { CheckDependency(services.NamedWindowPathRegistry, namedWindow, moduleName); } foreach (var table in deployment.PathTables) { CheckDependency(services.TablePathRegistry, table, moduleName); } foreach (var variable in deployment.PathVariables) { CheckDependency(services.VariablePathRegistry, variable, moduleName); } foreach (var context in deployment.PathContexts) { CheckDependency(services.ContextPathRegistry, context, moduleName); } foreach (var eventType in deployment.PathEventTypes) { CheckDependency(services.EventTypePathRegistry, eventType, moduleName); } foreach (var exprDecl in deployment.PathExprDecls) { CheckDependency(services.ExprDeclaredPathRegistry, exprDecl, moduleName); } foreach (var script in deployment.PathScripts) { CheckDependency(services.ScriptPathRegistry, script, moduleName); } foreach (var index in deployment.PathIndexes) { if (index.IsNamedWindow) { var namedWindow = services.NamedWindowPathRegistry.GetWithModule(index.InfraName, index.InfraModuleName); ValidateIndexPrecondition(namedWindow.IndexMetadata, index, deploymentId); } else { var table = services.TablePathRegistry.GetWithModule(index.InfraName, index.InfraModuleName); ValidateIndexPrecondition(table.IndexMetadata, index, deploymentId); } } foreach (var classProvided in deployment.PathClassProvideds) { CheckDependency(services.ClassProvidedPathRegistry, classProvided, moduleName); } }
private void DispatchOnUndeploymentEvent( DeploymentInternal result, int rolloutItemNumber) { var listeners = _services.DeploymentLifecycleService.Listeners; if (listeners.IsEmpty()) { return; } var statements = result.Statements; var @event = new DeploymentStateEventUndeployed( _services.RuntimeURI, result.DeploymentId, result.ModuleProvider.ModuleName, statements, rolloutItemNumber); foreach (DeploymentStateListener listener in listeners) { try { listener.OnUndeployment(@event); } catch (Exception ex) { HandleDeploymentEventListenerException("on-undeployment", ex); } } }
internal static DeploymentRecoveryInformation GetRecoveryInformation(DeploymentInternal deployerResult) { IDictionary <int, object> userObjects = EmptyDictionary <int, object> .Instance; IDictionary <int, string> statementNamesWhenOverridden = EmptyDictionary <int, string> .Instance; foreach (var stmt in deployerResult.Statements) { var spi = (EPStatementSPI)stmt; if (stmt.UserObjectRuntime != null) { if (userObjects.IsEmpty()) { userObjects = new Dictionary <int, object>(); } userObjects.Put(spi.StatementId, spi.StatementContext.UserObjectRuntime); } if (!spi.StatementContext.StatementInformationals.StatementNameCompileTime.Equals(spi.Name)) { if (statementNamesWhenOverridden.IsEmpty()) { statementNamesWhenOverridden = new Dictionary <int, string>(); } statementNamesWhenOverridden.Put(spi.StatementId, spi.Name); } } return(new DeploymentRecoveryInformation(userObjects, statementNamesWhenOverridden)); }
public EventType GetEventType(string deploymentId, string eventTypeName) { DeploymentInternal deployment = services.DeploymentLifecycleService.GetDeploymentById(deploymentId); if (deployment == null) { return null; } string moduleName = deployment.ModuleProvider.ModuleName; return services.EventTypePathRegistry.GetWithModule(eventTypeName, moduleName); }
// what are the dependencies that the given deployment provides to other modules? public static EPDeploymentDependencyProvided GetDependenciesProvided( string selfDeploymentId, EPServicesPath paths, DeploymentLifecycleService deploymentLifecycleService) { DeploymentInternal selfDeployment = deploymentLifecycleService.GetDeploymentById(selfDeploymentId); if (selfDeployment == null) { return(null); } IList <EPDeploymentDependencyProvided.Item> dependencies = new List <EPDeploymentDependencyProvided.Item>(4); string moduleName = selfDeployment.ModuleProvider.ModuleName; HandleProvided(selfDeployment.PathNamedWindows, EPObjectType.NAMEDWINDOW, paths.NamedWindowPathRegistry, moduleName, dependencies, name => name); HandleProvided(selfDeployment.PathTables, EPObjectType.TABLE, paths.TablePathRegistry, moduleName, dependencies, name => name); HandleProvided(selfDeployment.PathVariables, EPObjectType.VARIABLE, paths.VariablePathRegistry, moduleName, dependencies, name => name); HandleProvided(selfDeployment.PathContexts, EPObjectType.CONTEXT, paths.ContextPathRegistry, moduleName, dependencies, name => name); HandleProvided(selfDeployment.PathEventTypes, EPObjectType.EVENTTYPE, paths.EventTypePathRegistry, moduleName, dependencies, name => name); HandleProvided(selfDeployment.PathExprDecls, EPObjectType.EXPRESSION, paths.ExprDeclaredPathRegistry, moduleName, dependencies, name => name); HandleProvided(selfDeployment.PathScripts, EPObjectType.SCRIPT, paths.ScriptPathRegistry, moduleName, dependencies, SCRIPT_OBJECTNAME); HandleProvided( selfDeployment.PathClassProvideds, EPObjectType.CLASSPROVIDED, paths.ClassProvidedPathRegistry, moduleName, dependencies, name => name); foreach (ModuleIndexMeta objectName in selfDeployment.PathIndexes) { EventTableIndexMetadata indexMetadata = GetIndexMetadata(objectName, moduleName, paths); if (indexMetadata == null) { continue; } EventTableIndexMetadataEntry meta = indexMetadata.GetIndexEntryByName(objectName.IndexName); if (meta != null && meta.ReferringDeployments != null && meta.ReferringDeployments.Length > 0) { ISet <string> referred = new HashSet <string>(Arrays.AsList(meta.ReferringDeployments)); referred.Remove(selfDeploymentId); if (!referred.IsEmpty()) { dependencies.Add(new EPDeploymentDependencyProvided.Item(EPObjectType.INDEX, INDEX_OBJECTNAME.Invoke(objectName), referred)); } } } return(new EPDeploymentDependencyProvided(dependencies)); }
private EPDeployment MakeDeployment(DeploymentInternal deployerResult) { var copy = new EPStatement[deployerResult.Statements.Length]; Array.Copy(deployerResult.Statements, 0, copy, 0, deployerResult.Statements.Length); return(new EPDeployment( deployerResult.DeploymentId, deployerResult.ModuleProvider.ModuleName, deployerResult.ModulePropertiesCached, copy, CollectionUtil.CopyArray(deployerResult.DeploymentIdDependencies), DateTimeHelper.GetCurrentTime())); }
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 DeployerRolloutDeploymentResult Rollout( int currentStatementId, ICollection <EPDeploymentRolloutCompiled> itemsProvided, EPRuntimeSPI runtime) { var items = itemsProvided.ToArray(); // per-deployment: determine deployment id var deploymentIds = new string[items.Length]; var deploymentIdSet = new HashSet <string>(); for (var i = 0; i < items.Length; i++) { deploymentIds[i] = DeployerHelperResolver.DetermineDeploymentIdCheckExists( i, items[i].Options, runtime.ServicesContext.DeploymentLifecycleService); if (!deploymentIdSet.Add(deploymentIds[i])) { throw new EPDeployException("Deployment id '" + deploymentIds[i] + "' occurs multiple times in the rollout", i); } } // per-deployment: obtain module providers var moduleProviders = new ModuleProviderCLPair[items.Length]; for (var i = 0; i < items.Length; i++) { var classLoader = DeployerHelperResolver.GetClassLoader(i, items[i].Options.DeploymentClassLoaderOption, runtime.ServicesContext); try { moduleProviders[i] = ModuleProviderUtil.Analyze(items[i].Compiled, classLoader, runtime.ServicesContext.ClassProvidedPathRegistry); } catch (Exception) { RolloutCleanClassloader(deploymentIds, runtime.ServicesContext); } } // per-deployment: check dependencies and initialize EPL objects var inits = new DeployerRolloutInitResult[items.Length]; for (var i = 0; i < items.Length; i++) { try { inits[i] = ResolveDependenciesInitEPLObjects(i, deploymentIds[i], moduleProviders[i], runtime.ServicesContext, runtime.StageService); } catch (EPDeployException) { RolloutCleanPathAndTypes(inits, deploymentIds, runtime.ServicesContext); throw; } catch (Exception ex) { RolloutCleanPathAndTypes(inits, deploymentIds, runtime.ServicesContext); throw new EPDeployException(ex.Message, ex, i); } } // per-deployment - obtain statement lightweights var stmtLightweights = new DeployerModuleStatementLightweights[items.Length]; var numStatements = 0; for (var i = 0; i < items.Length; i++) { var statementIdStart = currentStatementId + numStatements; try { stmtLightweights[i] = InitializeStatements( i, false, inits[i].ModuleEPLObjects, inits[i].ModulePaths, inits[i].ModuleName, moduleProviders[i], deploymentIds[i], statementIdStart, items[i].Options.StatementUserObjectRuntime, items[i].Options.StatementNameRuntime, items[i].Options.StatementSubstitutionParameter, runtime.ServicesContext); } catch (EPDeployException ex) { RolloutCleanLightweights(stmtLightweights, inits, deploymentIds, moduleProviders, runtime.ServicesContext); throw ex; } catch (Exception ex) { RolloutCleanLightweights(stmtLightweights, inits, deploymentIds, moduleProviders, runtime.ServicesContext); throw new EPDeployException(ex.Message, ex, i); } numStatements += stmtLightweights[i].Lightweights.Count; } // per-deployment: start statements depending on context association var statements = new EPStatement[items.Length][]; for (var i = 0; i < items.Length; i++) { try { statements[i] = DeployerHelperStatement.DeployStatements( i, stmtLightweights[i].Lightweights, false, inits[i].ModulePaths, moduleProviders[i], deploymentIds[i], runtime); } catch (EPDeployException ex) { RolloutCleanStatements(statements, stmtLightweights, inits, deploymentIds, moduleProviders, runtime.ServicesContext); throw ex; } catch (Exception t) { RolloutCleanStatements(statements, stmtLightweights, inits, deploymentIds, moduleProviders, runtime.ServicesContext); throw new EPDeployException(t.Message, t, i); } } // per-deployment: add paths dependency information and add deployment var deployments = new DeploymentInternal[items.Length]; for (var i = 0; i < items.Length; i++) { try { // add dependencies AddPathDependencies(deploymentIds[i], moduleProviders[i].ModuleProvider.ModuleDependencies, runtime.ServicesContext); // keep statement and deployment deployments[i] = DeploymentInternal.From( deploymentIds[i], statements[i], inits[i].DeploymentIdDependencies, inits[i].ModulePaths, inits[i].ModuleEPLObjects, moduleProviders[i]); runtime.ServicesContext.DeploymentLifecycleService.AddDeployment(deploymentIds[i], deployments[i]); // register for recovery DeploymentRecoveryInformation recoveryInformation = GetRecoveryInformation(deployments[i]); runtime.ServicesContext.DeploymentRecoveryService.Add( deploymentIds[i], stmtLightweights[i].StatementIdFirstStatement, items[i].Compiled, recoveryInformation.StatementUserObjectsRuntime, recoveryInformation.StatementNamesWhenProvidedByAPI, stmtLightweights[i].SubstitutionParameters); } catch (Exception t) { RolloutCleanStatements(statements, stmtLightweights, inits, deploymentIds, moduleProviders, runtime.ServicesContext); throw new EPDeployException(t.Message, t, i); } } return(new DeployerRolloutDeploymentResult(numStatements, deployments)); }