public static void ValidateDependencyPreconditions(
ISet <string> deploymentSet,
EPServicesPath paths,
DeploymentLifecycleService deploymentLifecycleService)
{
foreach (var deploymentId in deploymentSet)
{
var consumed = GetDependenciesConsumed(deploymentId, paths, deploymentLifecycleService);
if (consumed == null)
{
throw new EPStageException("Deployment '" + deploymentId + "' was not found");
}
foreach (var item in consumed.Dependencies)
{
if (!deploymentSet.Contains(item.DeploymentId))
{
var message = "Failed to stage deployment '" +
deploymentId +
"': Deployment consumes " +
item.ObjectType.GetPrettyName() +
" '" +
item.ObjectName +
"'" +
" from deployment '" +
item.DeploymentId +
"' and must therefore also be staged";
throw new EPStagePreconditionException(message);
}
}
var provided = GetDependenciesProvided(deploymentId, paths, deploymentLifecycleService);
foreach (var item in provided.Dependencies)
{
foreach (var other in item.DeploymentIds)
{
if (!deploymentSet.Contains(other))
{
var message = "Failed to stage deployment '" +
deploymentId +
"': Deployment provides " +
item.ObjectType.GetPrettyName() +
" '" +
item.ObjectName +
"'" +
" to deployment '" +
other +
"' and must therefore also be staged";
throw new EPStagePreconditionException(message);
}
}
}
}
}
// 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));
}
public static void MovePath(
DeploymentInternal deployment,
EPServicesPath from,
EPServicesPath to)
{
var moduleName = deployment.ModuleProvider.ModuleName;
HandleProvided(deployment.DeploymentId, deployment.PathNamedWindows, from.NamedWindowPathRegistry, moduleName, to.NamedWindowPathRegistry);
HandleProvided(deployment.DeploymentId, deployment.PathTables, from.TablePathRegistry, moduleName, to.TablePathRegistry);
HandleProvided(deployment.DeploymentId, deployment.PathContexts, from.ContextPathRegistry, moduleName, to.ContextPathRegistry);
HandleProvided(deployment.DeploymentId, deployment.PathVariables, from.VariablePathRegistry, moduleName, to.VariablePathRegistry);
HandleProvided(deployment.DeploymentId, deployment.PathEventTypes, from.EventTypePathRegistry, moduleName, to.EventTypePathRegistry);
HandleProvided(deployment.DeploymentId, deployment.PathExprDecls, from.ExprDeclaredPathRegistry, moduleName, to.ExprDeclaredPathRegistry);
HandleProvided(deployment.DeploymentId, deployment.PathScripts, from.ScriptPathRegistry, moduleName, to.ScriptPathRegistry);
}
private static EventTableIndexMetadata GetIndexMetadata(
ModuleIndexMeta objectName,
string moduleName,
EPServicesPath paths)
{
if (objectName.IsNamedWindow)
{
NamedWindowMetaData metaData = paths.NamedWindowPathRegistry.GetWithModule(objectName.InfraName, moduleName);
return(metaData?.IndexMetadata);
}
else
{
TableMetaData metaData = paths.TablePathRegistry.GetWithModule(objectName.InfraName, moduleName);
return(metaData?.IndexMetadata);
}
}
// what are the dependencies that the given deployment consumes from other modules?
public static EPDeploymentDependencyConsumed GetDependenciesConsumed(
string selfDeploymentId,
EPServicesPath paths,
DeploymentLifecycleService deploymentLifecycleService)
{
var selfDeployment = deploymentLifecycleService.GetDeploymentById(selfDeploymentId);
if (selfDeployment == null)
{
return(null);
}
string[] consumedDeploymentIds = selfDeployment.DeploymentIdDependencies;
var consumed = new List <EPDeploymentDependencyConsumed.Item>(4);
foreach (string providerDeploymentId in consumedDeploymentIds)
{
var providingDeployment = deploymentLifecycleService.GetDeploymentById(providerDeploymentId);
if (providingDeployment == null)
{
continue;
}
string moduleName = providingDeployment.ModuleProvider.ModuleName;
HandleConsumed(
providerDeploymentId,
providingDeployment.PathNamedWindows,
EPObjectType.NAMEDWINDOW,
paths.NamedWindowPathRegistry,
moduleName,
selfDeploymentId,
consumed,
name => name);
HandleConsumed(
providerDeploymentId,
providingDeployment.PathTables,
EPObjectType.TABLE,
paths.TablePathRegistry,
moduleName,
selfDeploymentId,
consumed,
name => name);
HandleConsumed(
providerDeploymentId,
providingDeployment.PathVariables,
EPObjectType.VARIABLE,
paths.VariablePathRegistry,
moduleName,
selfDeploymentId,
consumed,
name => name);
HandleConsumed(
providerDeploymentId,
providingDeployment.PathContexts,
EPObjectType.CONTEXT,
paths.ContextPathRegistry,
moduleName,
selfDeploymentId,
consumed,
name => name);
HandleConsumed(
providerDeploymentId,
providingDeployment.PathEventTypes,
EPObjectType.EVENTTYPE,
paths.EventTypePathRegistry,
moduleName,
selfDeploymentId,
consumed,
name => name);
HandleConsumed(
providerDeploymentId,
providingDeployment.PathExprDecls,
EPObjectType.EXPRESSION,
paths.ExprDeclaredPathRegistry,
moduleName,
selfDeploymentId,
consumed,
name => name);
HandleConsumed(
providerDeploymentId,
providingDeployment.PathScripts,
EPObjectType.SCRIPT,
paths.ScriptPathRegistry,
moduleName,
selfDeploymentId,
consumed,
SCRIPT_OBJECTNAME);
HandleConsumed(
providerDeploymentId,
providingDeployment.PathClassProvideds,
EPObjectType.CLASSPROVIDED,
paths.ClassProvidedPathRegistry,
moduleName,
selfDeploymentId,
consumed,
name => name);
foreach (ModuleIndexMeta objectName in providingDeployment.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)
{
bool found = false;
foreach (string dep in meta.ReferringDeployments)
{
if (dep.Equals(selfDeploymentId))
{
found = true;
break;
}
}
if (found)
{
consumed.Add(
new EPDeploymentDependencyConsumed.Item(providerDeploymentId, EPObjectType.INDEX, INDEX_OBJECTNAME.Invoke(objectName)));
}
}
}
}
return(new EPDeploymentDependencyConsumed(consumed));
}
