// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using System.Collections.Generic;
|
using System.Collections.ObjectModel;
|
using System.Linq;
|
|
namespace OpenTap.Package
|
{
|
/// <summary> Type of dependency issue. </summary>
|
public enum DependencyIssueType
|
{
|
/// <summary> No issue noted (Usually notes an installed package). </summary>
|
None,
|
/// <summary> The dependency is missing. </summary>
|
Missing,
|
/// <summary> Incompatible version installed. </summary>
|
[Display("Incompatible Version")]
|
IncompatibleVersion,
|
/// <summary> One of the dependencies has a issue.</summary>
|
[Display("Dependency Missing")]
|
DependencyMissing
|
}
|
|
/// <summary>
|
/// Model object for a dependency issue.
|
/// </summary>
|
public struct DependencyIssue
|
{
|
/// <summary>
|
/// Issue package, eg the missing package.
|
/// </summary>
|
public string PackageName { get; set; }
|
/// <summary>
|
/// Expected version.
|
/// </summary>
|
public VersionSpecifier ExpectedVersion { get; set; }
|
|
/// <summary>
|
/// The version available.
|
/// </summary>
|
public SemanticVersion LoadedVersion { get; set; }
|
|
/// <summary> Denotes which kind of dependency issue it is. </summary>
|
public DependencyIssueType IssueType { get; set; }
|
}
|
|
/// <summary>
|
/// Algorithm for calculate nth degree dependency issues.
|
/// </summary>
|
public class DependencyAnalyzer
|
{
|
/// <summary>
|
/// Broken packages from the packages used to build the object.
|
/// </summary>
|
public ReadOnlyCollection<PackageDef> BrokenPackages { get; set; }
|
Dictionary<string, PackageDef> packagesLookup;
|
Dictionary<PackageDef, List<PackageDef>> dependers;
|
private DependencyAnalyzer() { }
|
|
/// <summary>
|
/// Returns the issues for a given package.
|
/// </summary>
|
/// <param name="pkg"></param>
|
/// <returns></returns>
|
public List<DependencyIssue> GetIssues(PackageDef pkg)
|
{
|
List<DependencyIssue> brokenDependencies = new List<DependencyIssue>();
|
foreach (var dep in pkg.Dependencies)
|
{
|
if (packagesLookup.ContainsKey(dep.Name) == false)
|
{
|
brokenDependencies.Add(new DependencyIssue() { PackageName = dep.Name, ExpectedVersion = dep.Version, IssueType = DependencyIssueType.Missing });
|
continue;
|
}
|
|
var installed = packagesLookup[dep.Name];
|
var iv = installed.Version;
|
var depbase = new DependencyIssue { PackageName = dep.Name, ExpectedVersion = dep.Version, LoadedVersion = iv };
|
if (installed.Version == null)
|
{ // missing
|
depbase.IssueType = DependencyIssueType.Missing;
|
}
|
else if (!dep.Version.IsCompatible(iv))
|
{ // incompatible
|
depbase.IssueType = DependencyIssueType.IncompatibleVersion;
|
}
|
else if (BrokenPackages.Any(pkg2 => pkg2.Name == dep.Name))
|
{ // broken dependency
|
depbase.IssueType = DependencyIssueType.DependencyMissing;
|
}
|
else continue;
|
brokenDependencies.Add(depbase);
|
}
|
return brokenDependencies;
|
}
|
/// <summary> Creates a new dependency analyzer that only shows things related to important_packages. </summary>
|
/// <param name="important_packages"></param>
|
/// <returns></returns>
|
public DependencyAnalyzer FilterRelated(List<PackageDef> important_packages)
|
{
|
HashSet<string> visited = new HashSet<string>();
|
Stack<string> stack = new Stack<string>(important_packages.Select(pkg => pkg.Name));
|
// moving down.
|
while (stack.Count > 0)
|
{
|
var top = stack.Pop();
|
visited.Add(top);
|
var pkg = packagesLookup[top];
|
foreach (var dep in pkg.Dependencies)
|
{
|
if (visited.Contains(dep.Name) == false)
|
{
|
visited.Add(dep.Name);
|
stack.Push(dep.Name);
|
}
|
}
|
}
|
|
// moving up
|
HashSet<string> visited2 = new HashSet<string>();
|
Stack<string> stack2 = new Stack<string>(important_packages.Select(pkg => pkg.Name));
|
// moving down.
|
while (stack2.Count > 0)
|
{
|
var top = stack2.Pop();
|
visited2.Add(top);
|
var pkg = packagesLookup[top];
|
foreach (var dep in dependers[pkg])
|
{
|
if (visited2.Contains(dep.Name) == false)
|
{
|
visited2.Add(dep.Name);
|
stack2.Push(dep.Name);
|
}
|
}
|
}
|
|
visited = new HashSet<string>(visited.Concat(visited2));
|
|
|
return new DependencyAnalyzer
|
{
|
BrokenPackages = BrokenPackages.Where(pkg => visited.Contains(pkg.Name)).ToList().AsReadOnly(),
|
packagesLookup = packagesLookup,
|
dependers = dependers
|
};
|
}
|
|
/// <summary>
|
/// Builds a DependencyTree based on the dependencies between the packages.
|
/// </summary>
|
/// <param name="packages"></param>
|
/// <returns></returns>
|
public static DependencyAnalyzer BuildAnalyzerContext(List<PackageDef> packages)
|
{
|
Dictionary<string, PackageDef> packagesLookup = packages.GroupBy(p => p.Name).Select(p => p.First()).ToDictionary(pkg => pkg.Name);
|
Dictionary<PackageDef, List<PackageDef>> dependers = packages.ToDictionary(pkg => pkg, pkg => new List<PackageDef>());
|
HashSet<PackageDef> broken_packages = new HashSet<PackageDef>();
|
foreach (var package in packages)
|
{
|
foreach (var dep in package.Dependencies)
|
{
|
if (false == packagesLookup.ContainsKey(dep.Name))
|
{ // missing: create placeholder. null means missing.
|
packagesLookup[dep.Name] = new PackageDef { Dependencies = new List<PackageDependency>(), Name = dep.Name, Version = null, Files = new List<PackageFile>() };
|
dependers[packagesLookup[dep.Name]] = new List<PackageDef>();
|
}
|
|
var loadedpackage = packagesLookup[dep.Name];
|
if (false == dep.Version.IsCompatible(loadedpackage.Version) || null == loadedpackage.Version)
|
{
|
broken_packages.Add(package);
|
}
|
|
dependers[packagesLookup[dep.Name]].Add(package);
|
}
|
}
|
|
// find nth order broken packages
|
// if a dependency is broken, the depender is also broken.
|
Stack<PackageDef> newBroken = new Stack<PackageDef>(broken_packages);
|
while (newBroken.Count > 0)
|
{
|
var item = newBroken.Pop();
|
var deps = dependers[item];
|
foreach (var dep in deps)
|
{
|
if (!broken_packages.Contains(dep))
|
{
|
broken_packages.Add(dep);
|
newBroken.Push(dep);
|
}
|
}
|
}
|
|
DependencyAnalyzer deptree = new DependencyAnalyzer();
|
deptree.BrokenPackages = broken_packages.ToList().AsReadOnly();
|
deptree.packagesLookup = packagesLookup;
|
deptree.dependers = dependers;
|
return deptree;
|
}
|
}
|
}
|
