private void RunAssertionUnresolvedUses(EPServiceProvider epService)
{
// Single module
Module moduleB = GetModule("B", "C");
try {
epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(new Module[] { moduleB }), new DeploymentOrderOptions());
Assert.Fail();
} catch (DeploymentOrderException ex) {
Assert.AreEqual("Module-dependency not found as declared by module 'B' for uses-declaration 'C'", ex.Message);
}
// multiple module
var modules = new Module[] { GetModule("B", "C"), GetModule("C", "D"), GetModule("D", "x") };
try {
epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(modules), new DeploymentOrderOptions());
Assert.Fail();
} catch (DeploymentOrderException ex) {
Assert.AreEqual("Module-dependency not found as declared by module 'D' for uses-declaration 'x'", ex.Message);
}
// turn off uses-checks
var options = new DeploymentOrderOptions();
options.IsCheckUses = false;
epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(modules), options);
}
public void TestUnresolvedUses()
{
// Single module
Module moduleB = GetModule("B", "C");
try {
_deploymentAdmin.GetDeploymentOrder(new Module[] { moduleB }, new DeploymentOrderOptions());
Assert.Fail();
} catch (DeploymentOrderException ex) {
Assert.AreEqual("Module-dependency not found as declared by module 'B' for uses-declaration 'C'", ex.Message);
}
// multiple module
Module[] modules = new Module[] { GetModule("B", "C"), GetModule("C", "D"), GetModule("D", "x") };
try {
_deploymentAdmin.GetDeploymentOrder(modules, new DeploymentOrderOptions());
Assert.Fail();
} catch (DeploymentOrderException ex) {
Assert.AreEqual("Module-dependency not found as declared by module 'D' for uses-declaration 'x'", ex.Message);
}
// turn off uses-checks
DeploymentOrderOptions options = new DeploymentOrderOptions();
options.IsCheckUses = false;
_deploymentAdmin.GetDeploymentOrder(modules, options);
}
private void RunAssertionCircular(EPServiceProvider epService)
{
// Circular 3
Module moduleB = GetModule("B", "C");
Module moduleC = GetModule("C", "D");
Module moduleD = GetModule("D", "B");
try {
epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(new Module[] { moduleC, moduleD, moduleB }), new DeploymentOrderOptions());
Assert.Fail();
} catch (DeploymentOrderException ex) {
Assert.AreEqual("Circular dependency detected in module uses-relationships: module 'C' uses (depends on) module 'D' uses (depends on) module 'B'", ex.Message);
}
// Circular 1 - this is allowed
moduleB = GetModule("B", "B");
DeploymentOrder order = epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(new Module[] { moduleC, moduleD, moduleB }), new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleB, moduleD, moduleC }, order);
// Circular 2
moduleB = GetModule("B", "C");
moduleC = GetModule("C", "B");
try {
epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(new Module[] { moduleC, moduleB }), new DeploymentOrderOptions());
Assert.Fail();
} catch (DeploymentOrderException ex) {
Assert.AreEqual("Circular dependency detected in module uses-relationships: module 'C' uses (depends on) module 'B'", ex.Message);
}
// turn off circular check
var options = new DeploymentOrderOptions();
options.IsCheckCircularDependency = false;
order = epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(new Module[] { moduleC, moduleB }), options);
AssertOrder(new Module[] { moduleB, moduleC }, order);
}
public void TestCircular()
{
// Circular 3
Module moduleB = GetModule("B", "C");
Module moduleC = GetModule("C", "D");
Module moduleD = GetModule("D", "B");
try {
_deploymentAdmin.GetDeploymentOrder(new Module[] { moduleC, moduleD, moduleB }, new DeploymentOrderOptions());
Assert.Fail();
} catch (DeploymentOrderException ex) {
Assert.AreEqual("Circular dependency detected in module uses-relationships: module 'C' uses (depends on) module 'D' uses (depends on) module 'B'", ex.Message);
}
// Circular 1 - this is allowed
moduleB = GetModule("B", "B");
DeploymentOrder order = _deploymentAdmin.GetDeploymentOrder(new Module[] { moduleC, moduleD, moduleB }, new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleB, moduleD, moduleC, }, order);
// Circular 2
moduleB = GetModule("B", "C");
moduleC = GetModule("C", "B");
try {
_deploymentAdmin.GetDeploymentOrder(new Module[] { moduleC, moduleB }, new DeploymentOrderOptions());
Assert.Fail();
} catch (DeploymentOrderException ex) {
Assert.AreEqual("Circular dependency detected in module uses-relationships: module 'C' uses (depends on) module 'B'", ex.Message);
}
// turn off circular check
DeploymentOrderOptions options = new DeploymentOrderOptions();
options.IsCheckCircularDependency = false;
order = _deploymentAdmin.GetDeploymentOrder(new Module[] { moduleC, moduleB }, options);
AssertOrder(new Module[] { moduleB, moduleC }, order);
}
public DeploymentOrder GetDeploymentOrder(ICollection <Module> modules, DeploymentOrderOptions options)
{
using (_iLock.Acquire())
{
if (options == null)
{
options = new DeploymentOrderOptions();
}
var deployments = _deploymentStateService.Deployments;
var proposedModules = new List <Module>();
proposedModules.AddAll(modules);
ICollection <String> availableModuleNames = new HashSet <String>();
foreach (var proposedModule in proposedModules)
{
if (proposedModule.Name != null)
{
availableModuleNames.Add(proposedModule.Name);
}
}
// Collect all uses-dependencies of existing modules
IDictionary <String, ICollection <String> > usesPerModuleName =
new Dictionary <String, ICollection <String> >();
foreach (var deployment in deployments)
{
var info = _deploymentStateService.GetDeployment(deployment);
if (info == null)
{
continue;
}
if ((info.Module.Name == null) || (info.Module.Uses == null))
{
continue;
}
var usesSet = usesPerModuleName.Get(info.Module.Name);
if (usesSet == null)
{
usesSet = new HashSet <String>();
usesPerModuleName.Put(info.Module.Name, usesSet);
}
usesSet.AddAll(info.Module.Uses);
}
// Collect uses-dependencies of proposed modules
foreach (var proposedModule in proposedModules)
{
// check uses-dependency is available
if (options.IsCheckUses)
{
if (proposedModule.Uses != null)
{
foreach (var uses in proposedModule.Uses)
{
if (availableModuleNames.Contains(uses))
{
continue;
}
if (IsDeployed(uses))
{
continue;
}
var message = "Module-dependency not found";
if (proposedModule.Name != null)
{
message += " as declared by module '" + proposedModule.Name + "'";
}
message += " for uses-declaration '" + uses + "'";
throw new DeploymentOrderException(message);
}
}
}
if ((proposedModule.Name == null) || (proposedModule.Uses == null))
{
continue;
}
var usesSet = usesPerModuleName.Get(proposedModule.Name);
if (usesSet == null)
{
usesSet = new HashSet <String>();
usesPerModuleName.Put(proposedModule.Name, usesSet);
}
usesSet.AddAll(proposedModule.Uses);
}
var proposedModuleNames = new HashMap <String, SortedSet <int> >();
var count = 0;
foreach (var proposedModule in proposedModules)
{
var moduleNumbers = proposedModuleNames.Get(proposedModule.Name);
if (moduleNumbers == null)
{
moduleNumbers = new SortedSet <int>();
proposedModuleNames.Put(proposedModule.Name, moduleNumbers);
}
moduleNumbers.Add(count);
count++;
}
var graph = new DependencyGraph(proposedModules.Count, false);
var fromModule = 0;
foreach (var proposedModule in proposedModules)
{
if ((proposedModule.Uses == null) || (proposedModule.Uses.IsEmpty()))
{
fromModule++;
continue;
}
var dependentModuleNumbers = new SortedSet <int>();
foreach (var use in proposedModule.Uses)
{
var moduleNumbers = proposedModuleNames.Get(use);
if (moduleNumbers == null)
{
continue;
}
dependentModuleNumbers.AddAll(moduleNumbers);
}
dependentModuleNumbers.Remove(fromModule);
graph.AddDependency(fromModule, dependentModuleNumbers);
fromModule++;
}
if (options.IsCheckCircularDependency)
{
var circular = graph.FirstCircularDependency;
if (circular != null)
{
var message = "";
var delimiter = "";
foreach (var i in circular)
{
message += delimiter;
message += "module '" + proposedModules[i].Name + "'";
delimiter = " uses (depends on) ";
}
throw new DeploymentOrderException(
"Circular dependency detected in module uses-relationships: " + message);
}
}
var reverseDeployList = new List <Module>();
var ignoreList = new HashSet <int>();
while (ignoreList.Count < proposedModules.Count)
{
// seconardy sort according to the order of listing
ICollection <int> rootNodes = new SortedSet <int>(
new StandardComparer <int>((o1, o2) => - 1 * o1.CompareTo(o2)));
rootNodes.AddAll(graph.GetRootNodes(ignoreList));
if (rootNodes.IsEmpty())
{
// circular dependency could cause this
for (var i = 0; i < proposedModules.Count; i++)
{
if (!ignoreList.Contains(i))
{
rootNodes.Add(i);
break;
}
}
}
foreach (var root in rootNodes)
{
ignoreList.Add(root);
reverseDeployList.Add(proposedModules[root]);
}
}
reverseDeployList.Reverse();
return(new DeploymentOrder(reverseDeployList));
}
}
private void RunAssertionOrder(EPServiceProvider epService)
{
Module moduleA = null;
Module moduleB = null;
Module moduleC = null;
Module moduleD = null;
Module moduleE = null;
DeploymentOrder order = null;
// Tree of 4 deep
moduleA = GetModule("A");
moduleB = GetModule("B", "A");
moduleC = GetModule("C", "A", "B", "D");
moduleD = GetModule("D", "A", "B");
order = epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(new Module[] { moduleC, moduleD, moduleB, moduleA }), new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleA, moduleB, moduleD, moduleC }, order);
// Zero items
order = epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(new Module[] {}), new DeploymentOrderOptions());
AssertOrder(new Module[] {}, order);
// 1 item
moduleA = GetModule("A");
order = epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(new Module[] { moduleA }), new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleA }, order);
// 2 item
moduleA = GetModule("A", "B");
moduleB = GetModule("B");
order = epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(new Module[] { moduleB, moduleA }), new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleB, moduleA }, order);
// 3 item
moduleB = GetModule("B");
moduleC = GetModule("C", "B");
moduleD = GetModule("D");
order = epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(new Module[] { moduleB, moduleC, moduleD }), new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleB, moduleC, moduleD }, order);
order = epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(new Module[] { moduleD, moduleC, moduleB }), new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleB, moduleD, moduleC }, order);
// 2 trees of 2 deep
moduleA = GetModule("A", "B");
moduleB = GetModule("B");
moduleC = GetModule("C", "D");
moduleD = GetModule("D");
order = epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(new Module[] { moduleC, moduleB, moduleA, moduleD }), new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleB, moduleD, moduleC, moduleA }, order);
// Tree of 5 deep
moduleA = GetModule("A", "C");
moduleB = GetModule("B");
moduleC = GetModule("C", "B");
moduleD = GetModule("D", "C", "E");
moduleE = GetModule("E");
order = epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(new Module[] { moduleA, moduleB, moduleC, moduleD, moduleE }), new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleB, moduleC, moduleE, moduleA, moduleD }, order);
order = epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(new Module[] { moduleB, moduleE, moduleC, moduleA, moduleD }), new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleB, moduleE, moduleC, moduleA, moduleD }, order);
order = epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(new Module[] { moduleA, moduleD, moduleE, moduleC, moduleB }), new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleB, moduleE, moduleC, moduleA, moduleD }, order);
// Tree with null names
moduleA = GetModule(null, "C", "A", "B", "D");
moduleB = GetModule(null, "C");
moduleC = GetModule("A");
moduleD = GetModule("B", "A", "C");
moduleE = GetModule("C");
var options = new DeploymentOrderOptions();
options.IsCheckUses = false;
order = epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(new Module[] { moduleA, moduleB, moduleC, moduleD, moduleE }), options);
AssertOrder(new Module[] { moduleC, moduleE, moduleD, moduleA, moduleB }, order);
Assert.IsFalse(epService.EPAdministrator.DeploymentAdmin.IsDeployed("C"));
// Tree with duplicate names
moduleA = GetModule("A", "C");
moduleB = GetModule("B", "C");
moduleC = GetModule("A", "B");
moduleD = GetModule("D", "A");
moduleE = GetModule("C");
order = epService.EPAdministrator.DeploymentAdmin.GetDeploymentOrder(Collections.List(new Module[] { moduleA, moduleB, moduleC, moduleD, moduleE }), options);
AssertOrder(new Module[] { moduleE, moduleB, moduleA, moduleC, moduleD }, order);
}
public void TestOrder()
{
Module moduleA = null;
Module moduleB = null;
Module moduleC = null;
Module moduleD = null;
Module moduleE = null;
DeploymentOrder order = null;
// Tree of 4 deep
moduleA = GetModule("A");
moduleB = GetModule("B", "A");
moduleC = GetModule("C", "A", "B", "D");
moduleD = GetModule("D", "A", "B");
order = _deploymentAdmin.GetDeploymentOrder(new Module[] { moduleC, moduleD, moduleB, moduleA }, new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleA, moduleB, moduleD, moduleC }, order);
// Zero items
order = _deploymentAdmin.GetDeploymentOrder(new Module[] {}, new DeploymentOrderOptions());
AssertOrder(new Module[] {}, order);
// 1 item
moduleA = GetModule("A");
order = _deploymentAdmin.GetDeploymentOrder(new Module[] { moduleA }, new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleA }, order);
// 2 item
moduleA = GetModule("A", "B");
moduleB = GetModule("B");
order = _deploymentAdmin.GetDeploymentOrder(new Module[] { moduleB, moduleA }, new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleB, moduleA }, order);
// 3 item
moduleB = GetModule("B");
moduleC = GetModule("C", "B");
moduleD = GetModule("D");
order = _deploymentAdmin.GetDeploymentOrder(new Module[] { moduleB, moduleC, moduleD }, new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleB, moduleC, moduleD }, order);
order = _deploymentAdmin.GetDeploymentOrder(new Module[] { moduleD, moduleC, moduleB }, new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleB, moduleD, moduleC }, order);
// 2 trees of 2 deep
moduleA = GetModule("A", "B");
moduleB = GetModule("B");
moduleC = GetModule("C", "D");
moduleD = GetModule("D");
order = _deploymentAdmin.GetDeploymentOrder(new Module[] { moduleC, moduleB, moduleA, moduleD }, new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleB, moduleD, moduleC, moduleA }, order);
// Tree of 5 deep
moduleA = GetModule("A", "C");
moduleB = GetModule("B");
moduleC = GetModule("C", "B");
moduleD = GetModule("D", "C", "E");
moduleE = GetModule("E");
order = _deploymentAdmin.GetDeploymentOrder(new Module[] { moduleA, moduleB, moduleC, moduleD, moduleE }, new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleB, moduleC, moduleE, moduleA, moduleD }, order);
order = _deploymentAdmin.GetDeploymentOrder(new Module[] { moduleB, moduleE, moduleC, moduleA, moduleD }, new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleB, moduleE, moduleC, moduleA, moduleD }, order);
order = _deploymentAdmin.GetDeploymentOrder(new Module[] { moduleA, moduleD, moduleE, moduleC, moduleB }, new DeploymentOrderOptions());
AssertOrder(new Module[] { moduleB, moduleE, moduleC, moduleA, moduleD }, order);
// Tree with null names
moduleA = GetModule(null, "C", "A", "B", "D");
moduleB = GetModule(null, "C");
moduleC = GetModule("A");
moduleD = GetModule("B", "A", "C");
moduleE = GetModule("C");
DeploymentOrderOptions options = new DeploymentOrderOptions();
options.IsCheckUses = false;
order = _deploymentAdmin.GetDeploymentOrder(new Module[] { moduleA, moduleB, moduleC, moduleD, moduleE }, options);
AssertOrder(new Module[] { moduleC, moduleE, moduleD, moduleA, moduleB }, order);
Assert.IsFalse(_deploymentAdmin.IsDeployed("C"));
// Tree with duplicate names
moduleA = GetModule("A", "C");
moduleB = GetModule("B", "C");
moduleC = GetModule("A", "B");
moduleD = GetModule("D", "A");
moduleE = GetModule("C");
order = _deploymentAdmin.GetDeploymentOrder(new Module[] { moduleA, moduleB, moduleC, moduleD, moduleE }, options);
AssertOrder(new Module[] { moduleE, moduleB, moduleA, moduleC, moduleD }, order);
}
