public void FrameworkReducer_GetNearestPCLtoPCL()
{
// Arrange
var project = NuGetFramework.Parse("portable-net45+win81");
var packageFrameworks = new List <NuGetFramework>()
{
NuGetFramework.Parse("portable-net45+win8"),
NuGetFramework.Parse("portable-net40+win8"),
NuGetFramework.Parse("portable-net40+win81"),
};
FrameworkReducer reducer = new FrameworkReducer();
// Act
var nearest = reducer.GetNearest(project, packageFrameworks);
// Assert
// net45+win8 is nearest since net45 wins over net40
Assert.Equal(packageFrameworks[0], nearest);
}
public void FrameworkReducer_GetNearestWithGenerations(
string projectFramework,
string packageFrameworks,
string expected)
{
// Arrange
var project = NuGetFramework.Parse(projectFramework);
var frameworks = packageFrameworks.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(s => NuGetFramework.Parse(s)).ToList();
var expectedFramework = expected == null ? null : NuGetFramework.Parse(expected);
FrameworkReducer reducer = new FrameworkReducer();
// Act
var nearest = reducer.GetNearest(project, frameworks);
// Assert
Assert.Equal(expectedFramework, nearest);
}
// The following methods are originally from the internal MSBuildNuGetProjectSystemUtility class
private static FrameworkSpecificGroup GetMostCompatibleGroup(
NuGetFramework projectTargetFramework,
IEnumerable <FrameworkSpecificGroup> itemGroups)
{
FrameworkReducer reducer = new FrameworkReducer();
NuGetFramework mostCompatibleFramework
= reducer.GetNearest(projectTargetFramework, itemGroups.Select(i => i.TargetFramework));
if (mostCompatibleFramework != null)
{
FrameworkSpecificGroup mostCompatibleGroup
= itemGroups.FirstOrDefault(i => i.TargetFramework.Equals(mostCompatibleFramework));
if (IsValid(mostCompatibleGroup))
{
return(mostCompatibleGroup);
}
}
return(null);
}
internal static FrameworkSpecificGroup GetMostCompatibleGroup(NuGetFramework projectTargetFramework, IEnumerable <FrameworkSpecificGroup> itemGroups,
bool altDirSeparator = false)
{
FrameworkReducer reducer = new FrameworkReducer();
NuGetFramework mostCompatibleFramework = reducer.GetNearest(projectTargetFramework, itemGroups.Select(i => i.TargetFramework));
if (mostCompatibleFramework != null)
{
IEnumerable <FrameworkSpecificGroup> mostCompatibleGroups = itemGroups.Where(i => i.TargetFramework.Equals(mostCompatibleFramework));
var mostCompatibleGroup = mostCompatibleGroups.SingleOrDefault();
if (IsValid(mostCompatibleGroup))
{
mostCompatibleGroup = new FrameworkSpecificGroup(mostCompatibleGroup.TargetFramework,
GetValidPackageItems(mostCompatibleGroup.Items).Select(item => altDirSeparator ? PathUtility.ReplaceDirSeparatorWithAltDirSeparator(item)
: PathUtility.ReplaceAltDirSeparatorWithDirSeparator(item)));
}
return(mostCompatibleGroup);
}
return(null);
}
// TODO: Return IEnumerable<DirectoryPath> and remove calls to System.IO
public IEnumerable <string> GetCompatibleAssemblyPaths()
{
List <string> assemblyPaths = new List <string>();
FrameworkReducer reducer = new FrameworkReducer();
NuGetFramework targetFramework = new NuGetFramework(".NETFramework", Version.Parse("4.6")); // If alternate versions of Wyam are developed (I.e., for DNX), this will need to be switched
NuGetFrameworkFullComparer frameworkComparer = new NuGetFrameworkFullComparer();
IPackageRepository packageRepository = PackageRepositoryFactory.Default.CreateRepository(AbsolutePackagesPath);
PackageManager packageManager = new PackageManager(packageRepository, AbsolutePackagesPath);
foreach (IPackage package in packageManager.LocalRepository.GetPackages())
{
List <KeyValuePair <IPackageFile, NuGetFramework> > filesAndFrameworks = package.GetLibFiles()
.Where(x => x.TargetFramework != null)
.Select(x => new KeyValuePair <IPackageFile, NuGetFramework>(x,
new NuGetFramework(x.TargetFramework.Identifier, x.TargetFramework.Version, x.TargetFramework.Profile)))
.ToList();
NuGetFramework targetPackageFramework = reducer.GetNearest(targetFramework, filesAndFrameworks.Select(x => x.Value));
if (targetPackageFramework != null)
{
List <string> packageAssemblyPaths = filesAndFrameworks
.Where(x => frameworkComparer.Equals(targetPackageFramework, x.Value))
.Select(x => System.IO.Path.Combine(AbsolutePackagesPath, String.Format(CultureInfo.InvariantCulture, "{0}.{1}", package.Id, package.Version), x.Key.Path))
.Where(x => System.IO.Path.GetExtension(x) == ".dll")
.ToList();
foreach (string packageAssemblyPath in packageAssemblyPaths)
{
Trace.Verbose("Added assembly file {0} from package {1}.{2}", packageAssemblyPath, package.Id, package.Version);
}
assemblyPaths.AddRange(filesAndFrameworks
.Where(x => frameworkComparer.Equals(targetPackageFramework, x.Value))
.Select(x => System.IO.Path.Combine(AbsolutePackagesPath, String.Format(CultureInfo.InvariantCulture, "{0}.{1}", package.Id, package.Version), x.Key.Path))
.Where(x => System.IO.Path.GetExtension(x) == ".dll"));
}
else
{
Trace.Verbose("Could not find compatible framework for package {0}.{1} (this is normal for content-only packages)", package.Id, package.Version);
}
}
return(assemblyPaths);
}
public void FrameworkReducer_GetNearestNonPCLtoPCLUncertain()
{
// Arrange
var project = NuGetFramework.Parse("win8");
var packageFrameworks = new List <NuGetFramework>()
{
NuGetFramework.Parse("portable-net45+win8+sl6"),
NuGetFramework.Parse("portable-net45+win8+dnxcore50"),
NuGetFramework.Parse("portable-net45+win8+native"),
};
FrameworkReducer reducer = new FrameworkReducer();
// Act
var nearest = reducer.GetNearest(project, packageFrameworks);
// Assert
// There is no certain way to relate these frameworks to each other, but the same one
// should always come back from this compare.
Assert.Equal(packageFrameworks[1], nearest);
}
/// <summary>
/// Convert a V2 IPackage into a V3 PackageDependencyInfo
/// </summary>
private SourcePackageDependencyInfo CreateDependencyInfo(IPackage packageVersion, NuGetFramework projectFramework)
{
var deps = Enumerable.Empty <V3PackageDependency>();
var identity = new PackageIdentity(packageVersion.Id, NuGetVersion.Parse(packageVersion.Version.ToString()));
if (packageVersion.DependencySets != null &&
packageVersion.DependencySets.Any())
{
// Take only the dependency group valid for the project TFM
var nearestFramework = _frameworkReducer.GetNearest(projectFramework, packageVersion.DependencySets.Select(GetFramework));
if (nearestFramework != null)
{
var matches = packageVersion.DependencySets.Where(e => (GetFramework(e).Equals(nearestFramework)));
IEnumerable <PackageDependency> dependencies = matches.First().Dependencies;
deps = dependencies.Select(item => GetPackageDependency(item));
}
}
return(new SourcePackageDependencyInfo(identity, deps, packageVersion.Listed, _source));
}
private string GetTfmToCopy(NuGetFramework sdkTfm, string projectArtifactsBinFolder)
{
var compiledTfms =
Directory.EnumerateDirectories(projectArtifactsBinFolder) // get all directories in bin folder
.Select(Path.GetFileName) // just the folder name (tfm)
.ToDictionary(folder => NuGetFramework.Parse(folder));
var reducer = new FrameworkReducer();
var selectedTfm = reducer.GetNearest(sdkTfm, compiledTfms.Keys);
if (selectedTfm == null)
{
var message = $@"Could not find suitable assets to copy in {projectArtifactsBinFolder}
TFM being tested: {sdkTfm}
project TFMs found: {string.Join(", ", compiledTfms.Keys.Select(k => k.ToString()))}";
throw new Exception(message);
}
var selectedVersion = compiledTfms[selectedTfm];
return(selectedVersion);
}
private static Tuple <NugetPackageType, NuGetFramework> GetNearestFramework(PackageReaderBase packageReader, NuGetFramework targetFramework)
{
var frameworkReducer = new FrameworkReducer();
Dictionary <NugetPackageType, Func <IEnumerable <FrameworkSpecificGroup> > > getter = new Dictionary <NugetPackageType, Func <IEnumerable <FrameworkSpecificGroup> > >
{
{ NugetPackageType.DotNetImplementationAssembly, () => packageReader.GetItems(NugetPackage.DotNetImplementationAssemblyPath) },
{ NugetPackageType.DotNetCompileTimeAssembly, () => packageReader.GetItems(NugetPackage.DotNetCompileTimeAssemblyPath) },
};
NuGetFramework nearest = null;
foreach (var get in getter)
{
var items = get.Value();
var libFrameworks = items.Select(x => x.TargetFramework);
nearest = frameworkReducer.GetNearest(targetFramework, libFrameworks);
if (nearest != null)
{
return(new Tuple <NugetPackageType, NuGetFramework>(get.Key, nearest));
}
}
return(null);
}
public void FrameworkReducer_GetNearestNonPCLtoPCLBasedOnOtherVersions()
{
// Arrange
var project = NuGetFramework.Parse("win8");
var packageFrameworks = new List <NuGetFramework>()
{
NuGetFramework.Parse("portable-net45+win8+wpa81"),
NuGetFramework.Parse("portable-net45+win8+wpa82"),
NuGetFramework.Parse("portable-net45+win8+wpa9"),
NuGetFramework.Parse("portable-net45+win8+wpa10.0"),
NuGetFramework.Parse("portable-net45+win8+wpa11.0+sl5")
};
FrameworkReducer reducer = new FrameworkReducer();
// Act
var nearest = reducer.GetNearest(project, packageFrameworks);
// Assert
// portable-net45+win8+wpa10.0 is the best match since it has the highest
// version of WPA, and the least frameworks
Assert.Equal(packageFrameworks[3], nearest);
}
public IVsNuGetFramework GetNearestImpl(IVsNuGetFramework targetFramework, IEnumerable <IVsNuGetFramework> fallbackTargetFrameworks, IEnumerable <IVsNuGetFramework> frameworks)
{
if (targetFramework == null)
{
throw new ArgumentNullException(nameof(targetFramework));
}
if (fallbackTargetFrameworks == null)
{
throw new ArgumentNullException(nameof(fallbackTargetFrameworks));
}
if (frameworks == null)
{
throw new ArgumentNullException(nameof(frameworks));
}
var inputFrameworks = new Dictionary <NuGetFramework, IVsNuGetFramework>();
NuGetFramework ToNuGetFramework(IVsNuGetFramework framework, string paramName)
{
NuGetFramework nugetFramework = MSBuildProjectFrameworkUtility.GetProjectFramework(
projectFilePath: null,
targetFrameworkMoniker: framework.TargetFrameworkMoniker,
targetPlatformMoniker: framework.TargetPlatformMoniker,
targetPlatformMinVersion: framework.TargetPlatformMinVersion);
if (!nugetFramework.IsSpecificFramework)
{
throw new ArgumentException($"Framework '{framework}' could not be parsed", paramName);
}
inputFrameworks[nugetFramework] = framework;
return(nugetFramework);
}
List <NuGetFramework> ToNuGetFrameworks(IEnumerable <IVsNuGetFramework> enumerable, string paramName)
{
var list = new List <NuGetFramework>();
foreach (var framework in enumerable)
{
if (framework == null)
{
throw new ArgumentException("Enumeration contains a null value", paramName);
}
NuGetFramework nugetFramework = ToNuGetFramework(framework, paramName);
list.Add(nugetFramework);
}
return(list);
}
NuGetFramework targetNuGetFramework = ToNuGetFramework(targetFramework, nameof(targetFramework));
List <NuGetFramework> nugetFallbackTargetFrameworks = ToNuGetFrameworks(fallbackTargetFrameworks, nameof(fallbackTargetFrameworks));
List <NuGetFramework> nugetFrameworks = ToNuGetFrameworks(frameworks, nameof(frameworks));
try
{
if (nugetFallbackTargetFrameworks.Count > 0)
{
targetNuGetFramework = new FallbackFramework(targetNuGetFramework, nugetFallbackTargetFrameworks);
}
var reducer = new FrameworkReducer();
var nearest = reducer.GetNearest(targetNuGetFramework, nugetFrameworks);
if (nearest == null)
{
return(null);
}
var originalFrameworkString = inputFrameworks[nearest];
return(originalFrameworkString);
}
catch (Exception exception)
{
_telemetryProvider.PostFault(exception, typeof(VsFrameworkCompatibility).FullName);
throw;
}
}
public DependencyGraph Analyze(string packageId, string version, string framework)
{
var package = new PackageIdentity(packageId, NuGetVersion.Parse(version));
var settings = Settings.LoadDefaultSettings(root: null, configFileName: null, machineWideSettings: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3());
var nuGetFramework = NuGetFramework.ParseFolder(framework);
var nugetLogger = _logger.AsNuGetLogger();
using (var cacheContext = new SourceCacheContext())
{
var repositories = sourceRepositoryProvider.GetRepositories();
var resolvedPackages = new ConcurrentDictionary <PackageIdentity, SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
ResolvePackage(package, nuGetFramework, cacheContext, nugetLogger, repositories, resolvedPackages).Wait();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(resolvedPackages.Values);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
nugetLogger);
var resolver = new PackageResolver();
var prunedPackages = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(x => resolvedPackages[x]);
var rootNode = new PackageReferenceNode(package.Id, package.Version.ToString());
var packageNodes = new Dictionary <string, PackageReferenceNode>(StringComparer.OrdinalIgnoreCase);
var builder = new DependencyGraph.Builder(rootNode);
foreach (var target in prunedPackages)
{
var downloadResource = target.Source.GetResource <DownloadResource>();
var downloadResult = downloadResource.GetDownloadResourceResultAsync(new PackageIdentity(target.Id, target.Version),
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(settings),
nugetLogger, CancellationToken.None).Result;
var libItems = downloadResult.PackageReader.GetLibItems();
var reducer = new FrameworkReducer();
var nearest = reducer.GetNearest(nuGetFramework, libItems.Select(x => x.TargetFramework));
var assemblyReferences = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)
.Where(x => Path.GetExtension(x).Equals(".dll", StringComparison.OrdinalIgnoreCase))
.Select(x => new AssemblyReferenceNode(Path.GetFileName(x)));
var frameworkItems = downloadResult.PackageReader.GetFrameworkItems();
nearest = reducer.GetNearest(nuGetFramework, frameworkItems.Select(x => x.TargetFramework));
assemblyReferences = assemblyReferences.Concat(frameworkItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)
.Select(x => new AssemblyReferenceNode(x)));
var packageReferenceNode = new PackageReferenceNode(target.Id, target.Version.ToString());
builder.WithNode(packageReferenceNode);
builder.WithNodes(assemblyReferences);
builder.WithEdges(assemblyReferences.Select(x => new Edge(packageReferenceNode, x)));
packageNodes.Add(target.Id, packageReferenceNode);
}
foreach (var target in prunedPackages)
{
var packageReferenceNode = packageNodes[target.Id];
builder.WithEdges(target.Dependencies.Select(x =>
new Edge(packageReferenceNode, packageNodes[x.Id], x.VersionRange.ToString())));
}
return(builder.Build());
}
}
public static List <string> LoadPackageAssemblies(string configPath, string domainName, string userName)
{
List <string> assemblyPaths = new List <string>();
List <string> exceptionsList = new List <string>();
var dependencies = JsonConvert.DeserializeObject <Project>(File.ReadAllText(configPath)).Dependencies;
string appDataPath = new EnvironmentSettings().GetEnvironmentVariablePath(domainName, userName);
string packagePath = Path.Combine(Directory.GetParent(appDataPath).FullName, "packages");
var packagePathResolver = new PackagePathResolver(packagePath);
var nuGetFramework = NuGetFramework.ParseFolder("net48");
var settings = NuGet.Configuration.Settings.LoadDefaultSettings(root: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
var localRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(packagePath, "Local OpenBots Repo", true));
var resolver = new PackageResolver();
var frameworkReducer = new FrameworkReducer();
var repositories = new List <SourceRepository>
{
localRepo
};
Parallel.ForEach(dependencies, async dependency =>
{
try
{
using (var cacheContext = new SourceCacheContext())
{
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(
new PackageIdentity(dependency.Key, NuGetVersion.Parse(dependency.Value)),
nuGetFramework, cacheContext, NullLogger.Instance, repositories, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { dependency.Key },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
foreach (var packageToInstall in packagesToInstall)
{
PackageReaderBase packageReader = new PackageFolderReader(packagePathResolver.GetInstalledPath(packageToInstall));
var nearest = frameworkReducer.GetNearest(nuGetFramework, packageReader.GetLibItems().Select(x => x.TargetFramework));
var packageListAssemblyPaths = packageReader.GetLibItems()
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items.Where(i => i.EndsWith(".dll"))).ToList();
if (packageListAssemblyPaths != null)
{
foreach (string path in packageListAssemblyPaths)
{
if (!assemblyPaths.Contains(Path.Combine(packagePath, $"{packageToInstall.Id}.{packageToInstall.Version}", path)))
{
assemblyPaths.Add(Path.Combine(packagePath, $"{packageToInstall.Id}.{packageToInstall.Version}", path));
}
}
}
}
}
}
catch (Exception)
{
exceptionsList.Add($"Unable to load {packagePath}\\{dependency.Key}.{dependency.Value}");
}
});
if (exceptionsList.Count > 0)
{
exceptionsList.Add("Please install this package using the OpenBots Studio Package Manager");
throw new Exception(string.Join("\n", exceptionsList));
}
List <string> filteredPaths = new List <string>();
foreach (string path in assemblyPaths)
{
if (filteredPaths.Where(a => a.Contains(path.Split('/').Last()) && FileVersionInfo.GetVersionInfo(a).FileVersion ==
FileVersionInfo.GetVersionInfo(path).FileVersion).FirstOrDefault() == null)
{
filteredPaths.Add(path);
}
}
return(filteredPaths);
}
public static List <string> LoadPackageAssemblies(string configPath, bool throwException = false)
{
string packagesPath = Folders.GetFolder(FolderType.LocalAppDataPackagesFolder);
List <string> assemblyPaths = new List <string>();
var dependencies = JsonConvert.DeserializeObject <Project>(File.ReadAllText(configPath)).Dependencies;
var packagePathResolver = new PackagePathResolver(packagesPath);
var nuGetFramework = NuGetFramework.ParseFolder("net48");
var settings = Settings.LoadDefaultSettings(root: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
var localRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(packagesPath, "Local OpenBots Repo", true));
var resolver = new PackageResolver();
var frameworkReducer = new FrameworkReducer();
var repositories = new List <SourceRepository>
{
localRepo
};
Parallel.ForEach(dependencies, async dependency =>
{
try
{
using (var cacheContext = new SourceCacheContext())
{
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(
new PackageIdentity(dependency.Key, NuGetVersion.Parse(dependency.Value)),
nuGetFramework, cacheContext, NullLogger.Instance, repositories, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { dependency.Key },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
foreach (var packageToInstall in packagesToInstall)
{
PackageReaderBase packageReader = new PackageFolderReader(packagePathResolver.GetInstalledPath(packageToInstall));
var nearest = frameworkReducer.GetNearest(nuGetFramework, packageReader.GetLibItems().Select(x => x.TargetFramework));
var packageListAssemblyPaths = packageReader.GetLibItems()
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items.Where(i => i.EndsWith(".dll"))).ToList();
if (packageListAssemblyPaths != null)
{
foreach (string path in packageListAssemblyPaths)
{
if (!assemblyPaths.Contains(Path.Combine(packagesPath, $"{packageToInstall.Id}.{packageToInstall.Version}", path)))
{
assemblyPaths.Add(Path.Combine(packagesPath, $"{packageToInstall.Id}.{packageToInstall.Version}", path));
}
}
}
}
}
}
catch (Exception ex)
{
//Only true for scheduled and attended executions
if (throwException)
{
MessageBox.Show($"Unable to load {packagesPath}\\{dependency.Key}.{dependency.Value}. " +
"Please install this package using the OpenBots Studio Package Manager.", "Error");
Application.Exit();
}
else
{
Console.WriteLine(ex);
}
}
});
try
{
return(FilterAssemblies(assemblyPaths));
}
catch (Exception)
{
//try again
return(LoadPackageAssemblies(configPath, throwException));
}
}
public async Task UninstallPackage(PackageIdentity identity)
{
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var installedPath = packagePathResolver.GetInstalledPath(identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, Logger);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, Logger);
bool failed = true;
try
{
await PackageExtractor.ExtractPackageAsync(installedPath,
packageReader,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
failed = false;
}
catch (Exception)
{
}
if (failed)
{
try
{
await Download(identity);
installedPath = packagePathResolver.GetInstalledPath(identity);
packageReader = new PackageFolderReader(installedPath);
failed = false;
}
catch (Exception)
{
throw;
}
}
var libItems = packageReader.GetLibItems();
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework));
var files = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
RemoveFile(installedPath, f);
}
var cont = packageReader.GetContentItems();
nearest = frameworkReducer.GetNearest(NuGetFramework, cont.Select(x => x.TargetFramework));
files = cont
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
RemoveFile(installedPath, f);
}
if (System.IO.Directory.Exists(installedPath + @"\build"))
{
if (System.IO.Directory.Exists(installedPath + @"\build\x64"))
{
foreach (var f in System.IO.Directory.GetFiles(installedPath + @"\build\x64"))
{
var filename = System.IO.Path.GetFileName(f);
var target = System.IO.Path.Combine(Destinationfolder, filename);
if (System.IO.File.Exists(target))
{
try
{
System.IO.File.Delete(target);
}
catch (Exception)
{
}
}
}
}
}
}
public static async Task <RegistrationInfo> GetRegistrationInfo(HttpClient httpClient, Uri registrationUri, VersionRange range, NuGetFramework projectTargetFramework, ConcurrentDictionary <Uri, JObject> sessionCache = null)
{
NuGetFrameworkFullComparer frameworkComparer = new NuGetFrameworkFullComparer();
FrameworkReducer frameworkReducer = new FrameworkReducer();
JObject index = await LoadResource(httpClient, registrationUri, sessionCache);
if (index == null)
{
throw new ArgumentException(registrationUri.AbsoluteUri);
}
VersionRange preFilterRange = Utils.SetIncludePrerelease(range, true);
IList <Task <JObject> > rangeTasks = new List <Task <JObject> >();
foreach (JObject item in index["items"])
{
NuGetVersion lower = NuGetVersion.Parse(item["lower"].ToString());
NuGetVersion upper = NuGetVersion.Parse(item["upper"].ToString());
if (ResolverMetadataClientUtility.IsItemRangeRequired(preFilterRange, lower, upper))
{
JToken items;
if (!item.TryGetValue("items", out items))
{
Uri rangeUri = item["@id"].ToObject <Uri>();
rangeTasks.Add(LoadResource(httpClient, rangeUri, sessionCache));
}
else
{
rangeTasks.Add(Task.FromResult(item));
}
}
}
await Task.WhenAll(rangeTasks.ToArray());
RegistrationInfo registrationInfo = new RegistrationInfo();
registrationInfo.IncludePrerelease = range.IncludePrerelease;
string id = string.Empty;
foreach (JObject rangeObj in rangeTasks.Select((t) => t.Result))
{
if (rangeObj == null)
{
throw new InvalidDataException(registrationUri.AbsoluteUri);
}
foreach (JObject packageObj in rangeObj["items"])
{
JObject catalogEntry = (JObject)packageObj["catalogEntry"];
NuGetVersion packageVersion = NuGetVersion.Parse(catalogEntry["version"].ToString());
id = catalogEntry["id"].ToString();
int publishedDate = 0;
JToken publishedValue;
if (catalogEntry.TryGetValue("published", out publishedValue))
{
publishedDate = int.Parse(publishedValue.ToObject <DateTime>().ToString("yyyyMMdd"));
}
//publishedDate = 0 means the property doesn't exist in index.json
//publishedDate = 19000101 means the property exists but the package is unlisted
if (range.Satisfies(packageVersion) && (publishedDate != 19000101))
{
PackageInfo packageInfo = new PackageInfo();
packageInfo.Version = packageVersion;
packageInfo.PackageContent = new Uri(packageObj["packageContent"].ToString());
JArray dependencyGroupsArray = (JArray)catalogEntry["dependencyGroups"];
if (dependencyGroupsArray != null)
{
// only one target framework group will be used at install time, which means
// we can filter down to that group now by using the project target framework
var depFrameworks = dependencyGroupsArray.Select(e => GetFramework(e as JObject));
var targetFramework = frameworkReducer.GetNearest(projectTargetFramework, depFrameworks);
// If no frameworks are compatible we just ignore them - Should this be an exception?
if (targetFramework != null)
{
foreach (JObject dependencyGroupObj in dependencyGroupsArray)
{
NuGetFramework currentFramework = GetFramework(dependencyGroupObj);
if (frameworkComparer.Equals(currentFramework, targetFramework))
{
foreach (JObject dependencyObj in dependencyGroupObj["dependencies"])
{
DependencyInfo dependencyInfo = new DependencyInfo();
dependencyInfo.Id = dependencyObj["id"].ToString();
dependencyInfo.Range = Utils.CreateVersionRange((string)dependencyObj["range"], range.IncludePrerelease);
dependencyInfo.RegistrationUri = dependencyObj["registration"].ToObject <Uri>();
packageInfo.Dependencies.Add(dependencyInfo);
}
}
}
}
}
registrationInfo.Add(packageInfo);
}
}
registrationInfo.Id = id;
}
return(registrationInfo);
}
public bool InstallPackage(string TargetFolder, PackageIdentity identity, bool LoadDlls)
{
bool ret = true;
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(PackagesInstallFolder);
var installedPath = packagePathResolver.GetInstalledPath(identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
var libItems = packageReader.GetLibItems();
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework));
var files = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
InstallFile(TargetFolder, installedPath, f, LoadDlls);
}
var cont = packageReader.GetContentItems();
nearest = frameworkReducer.GetNearest(NuGetFramework, cont.Select(x => x.TargetFramework));
files = cont
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
InstallFile(TargetFolder, installedPath, f, LoadDlls);
}
try
{
var dependencies = packageReader.GetPackageDependencies();
nearest = frameworkReducer.GetNearest(NuGetFramework, dependencies.Select(x => x.TargetFramework));
foreach (var dep in dependencies.Where(x => x.TargetFramework.Equals(nearest)))
{
foreach (var p in dep.Packages)
{
var local = getLocal(p.Id);
InstallPackage(TargetFolder, local.Identity, LoadDlls);
}
}
}
catch (Exception ex)
{
ret = false;
Log.Error(ex.ToString());
}
if (System.IO.Directory.Exists(installedPath + @"\build"))
{
if (System.IO.Directory.Exists(installedPath + @"\build\x64"))
{
foreach (var f in System.IO.Directory.GetFiles(installedPath + @"\build\x64"))
{
var filename = System.IO.Path.GetFileName(f);
var target = System.IO.Path.Combine(TargetFolder, filename);
CopyIfNewer(f, target);
}
}
}
return(ret);
}
/// <summary>
/// Adds refresh files to the specified project for all assemblies references belonging to the packages
/// specified by packageNames.
/// </summary>
/// <param name="project">The project.</param>
/// <param name="repositoryPath">The file system pointing to 'packages' folder under the solution.</param>
/// <param name="packageNames">The package names.</param>
private void AddRefreshFilesForReferences(EnvDTE.Project project, string repositoryPath, IEnumerable <PackageIdentity> packageNames)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
if (repositoryPath == null)
{
throw new ArgumentNullException("repositoryPath");
}
if (!packageNames.Any())
{
return;
}
VSAPIProjectContext context = new VSAPIProjectContext(skipAssemblyReferences: true, bindingRedirectsDisabled: true);
var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders());
var logger = new LoggerAdapter(context);
context.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
logger,
signedPackageVerifier,
SignedPackageVerifierSettings.GetClientPolicy(_settings, logger));
WebSiteProjectSystem projectSystem = new WebSiteProjectSystem(_vsProjectAdapterProvider.CreateAdapterForFullyLoadedProject(project), context);
foreach (var packageName in packageNames)
{
string packagePath = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", packageName.Id, packageName.Version);
DirectoryInfo packageFolder = new DirectoryInfo(Path.Combine(repositoryPath, packagePath));
PackageFolderReader reader = new PackageFolderReader(packageFolder);
var frameworkGroups = reader.GetReferenceItems();
var groups = reader.GetReferenceItems();
var fwComparer = new NuGetFrameworkFullComparer();
FrameworkReducer reducer = new FrameworkReducer();
NuGetFramework targetGroupFramework = reducer.GetNearest(projectSystem.TargetFramework, groups.Select(e => e.TargetFramework));
if (targetGroupFramework != null)
{
var refGroup = groups.Where(e => fwComparer.Equals(targetGroupFramework, e.TargetFramework)).FirstOrDefault();
foreach (string refItem in refGroup.Items)
{
string sourcePath = Path.Combine(packageFolder.FullName, refItem.Replace('/', Path.DirectorySeparatorChar));
// create one refresh file for each assembly reference, as per required by Website projects
// projectSystem.CreateRefreshFile(assemblyPath);
RefreshFileUtility.CreateRefreshFile(projectSystem, sourcePath);
}
}
}
}
public async Task <IReadOnlyList <NuGetVersion> > GetAllVersions(string package, IEnumerable <Uri> sources, bool includePrerelease, NuGetFramework targetFramework,
string projectFilePath, bool isDevelopmentDependency, int olderThanDays)
{
var allVersions = new List <NuGetVersion>();
foreach (var source in sources)
{
try
{
var metadata = await FindMetadataResourceForSource(source, projectFilePath);
if (metadata != null)
{
var compatibleMetadataList = (await metadata.GetMetadataAsync(package, includePrerelease, false, _context, NullLogger.Instance, CancellationToken.None)).ToList();
if (olderThanDays > 0)
{
compatibleMetadataList = compatibleMetadataList.Where(c => !c.Published.HasValue ||
c.Published <= DateTimeOffset.UtcNow.AddDays(-olderThanDays)).ToList();
}
// We need to ensure that we only get package versions which are compatible with the requested target framework.
// For development dependencies, we do not perform this check
if (!isDevelopmentDependency)
{
var reducer = new FrameworkReducer();
compatibleMetadataList = compatibleMetadataList
.Where(meta => meta.DependencySets == null || !meta.DependencySets.Any() ||
reducer.GetNearest(targetFramework, meta.DependencySets.Select(ds => ds.TargetFramework)) != null)
.ToList();
}
foreach (var m in compatibleMetadataList)
{
if (m is PackageSearchMetadata packageSearchMetadata)
{
allVersions.Add(packageSearchMetadata.Version);
}
else if (m is PackageSearchMetadataV2Feed packageSearchMetadataV2Feed)
{
allVersions.Add(packageSearchMetadataV2Feed.Version);
}
else if (m is LocalPackageSearchMetadata localPackageSearchMetadata)
{
allVersions.Add(localPackageSearchMetadata.Identity.Version);
}
else
{
allVersions.Add(m.Identity.Version);
}
}
;
}
}
catch (HttpRequestException)
{
// Suppress HTTP errors when connecting to NuGet sources
}
}
return(allVersions);
}
public static bool TryGetCompatibleItems <T>(FrameworkName projectFramework, IEnumerable <T> items, out IEnumerable <T> compatibleItems) where T : IFrameworkTargetable
{
if (!items.Any())
{
compatibleItems = Enumerable.Empty <T>();
return(true);
}
// Not all projects have a framework, we need to consider those projects.
var internalProjectFramework = projectFramework ?? EmptyFramework;
// Turn something that looks like this:
// item -> [Framework1, Framework2, Framework3] into
// [{item, Framework1}, {item, Framework2}, {item, Framework3}]
var normalizedItems = from item in items
let frameworks = (item.SupportedFrameworks != null && item.SupportedFrameworks.Any()) ? item.SupportedFrameworks : new FrameworkName[] { null }
from framework in frameworks
select new
{
Item = item,
TargetFramework = framework
};
// Group references by target framework (if there is no target framework we assume it is the default)
var frameworkGroups = normalizedItems
.GroupBy(g => g.TargetFramework, g => g.Item)
.ToList();
// Try to find the best match using NuGet's Get Nearest algorithm
var nuGetFrameworkToFrameworkGroup = frameworkGroups
.Where(g => g.Key != null)
.ToDictionary(g => GetNuGetFramework(
NetPortableProfileTable.Instance,
ReferenceAssemblyFrameworkNameProvider.Instance,
g.Key),
NuGetFramework.Comparer);
var reducer = new FrameworkReducer(
ReferenceAssemblyFrameworkNameProvider.Instance,
ReferenceAssemblyCompatibilityProvider.Instance);
var nearest = reducer.GetNearest(
GetNuGetFramework(
NetPortableProfileTable.Instance,
ReferenceAssemblyFrameworkNameProvider.Instance,
internalProjectFramework),
nuGetFrameworkToFrameworkGroup.Keys);
if (nearest != null)
{
compatibleItems = nuGetFrameworkToFrameworkGroup[nearest];
}
else
{
compatibleItems = null;
}
bool hasItems = compatibleItems != null && compatibleItems.Any();
if (!hasItems)
{
// if there's no matching profile, fall back to the items without target framework
// because those are considered to be compatible with any target framework
compatibleItems = frameworkGroups.Where(g => g.Key == null).SelectMany(g => g);
hasItems = compatibleItems != null && compatibleItems.Any();
}
if (!hasItems)
{
compatibleItems = null;
}
return(hasItems);
}
public static async Task Main()
{
var packageId = "cake.nuget";
var packageVersion = NuGetVersion.Parse("0.30.0");
var nuGetFramework = NuGetFramework.ParseFolder("net46");
var settings = Settings.LoadDefaultSettings(root: null);
var packageSourceProvider = new PackageSourceProvider(
settings, new PackageSource[] { new PackageSource("https://api.nuget.org/v3/index.json") });
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, Repository.Provider.GetCoreV3());
using (var cacheContext = new SourceCacheContext())
{
var repositories = sourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(
new PackageIdentity(packageId, packageVersion),
nuGetFramework, cacheContext, NullLogger.Instance, repositories, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new PackagePathResolver(Path.GetFullPath("packages"));
var packageExtractionContext =
new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, NullLogger.Instance),
NullLogger.Instance);
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
PackageReaderBase packageReader;
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(settings),
NullLogger.Instance, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
packageReader = downloadResult.PackageReader;
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
var libItems = packageReader.GetLibItems();
var nearest = frameworkReducer.GetNearest(nuGetFramework, libItems.Select(x => x.TargetFramework));
Console.WriteLine(string.Join("\n", libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)));
var frameworkItems = packageReader.GetFrameworkItems();
nearest = frameworkReducer.GetNearest(nuGetFramework, frameworkItems.Select(x => x.TargetFramework));
Console.WriteLine(string.Join("\n", frameworkItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)));
}
}
async Task GetPackageDependencies(PackageIdentity package,
NuGetFramework framework,
SourceCacheContext cacheContext,
ILogger logger,
IEnumerable <SourceRepository> repositories,
ISet <SourcePackageDependencyInfo> availablePackages)
{
if (availablePackages.Contains(package))
{
return;
}
foreach (var sourceRepository in repositories)
{
var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
var dependencyInfo = await dependencyInfoResource.ResolvePackage(
package, framework, cacheContext, logger, CancellationToken.None);
if (dependencyInfo == null)
{
continue;
}
availablePackages.Add(dependencyInfo);
foreach (var dependency in dependencyInfo.Dependencies)
{
await GetPackageDependencies(
new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion),
framework, cacheContext, logger, repositories, availablePackages);
}
}
}
}
private IEnumerable <LibraryDependency> GetDependencies(LocalPackageInfo package, NuGetFramework targetFramework)
{
NuspecReader nuspecReader = null;
using (var stream = File.OpenRead(package.ManifestPath))
{
nuspecReader = new NuspecReader(stream);
}
var reducer = new FrameworkReducer();
var deps = nuspecReader.GetDependencyGroups()
.ToDictionary(g => new NuGetFramework(g.TargetFramework),
g => g.Packages);
var nearest = reducer.GetNearest(targetFramework, deps.Keys);
if (nearest != null)
{
foreach (var d in deps[nearest])
{
yield return(new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = d.Id,
VersionRange = d.VersionRange == null ? null : new NuGetVersionRange(d.VersionRange)
}
});
}
}
// TODO: Remove this when we do #596
// ASP.NET Core isn't compatible with generic PCL profiles
//if (string.Equals(targetFramework.Identifier, VersionUtility.AspNetCoreFrameworkIdentifier, StringComparison.OrdinalIgnoreCase))
//{
// yield break;
//}
var frameworks = nuspecReader.GetFrameworkReferenceGroups()
.ToDictionary(f => f.TargetFramework,
f => f.Items);
nearest = reducer.GetNearest(targetFramework, frameworks.Keys) ?? frameworks.Keys.FirstOrDefault(f => f.AnyPlatform);
if (nearest != null)
{
if (nearest.AnyPlatform && !targetFramework.IsDesktop())
{
// REVIEW: This isn't 100% correct since none *can* mean
// any in theory, but in practice it means .NET full reference assembly
// If there's no supported target frameworks and we're not targeting
// the desktop framework then skip it.
// To do this properly we'll need all reference assemblies supported
// by each supported target framework which isn't always available.
yield break;
}
foreach (var name in frameworks[nearest])
{
yield return(new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = name,
IsGacOrFrameworkReference = true
}
});
}
}
}
public IEnumerable <AssemblyInfo> GetAssemblies(PackageIdentity pkg)
{
// Ignore all SDK packages:
if (pkg == null || IsSystemPackage(pkg))
{
return(Enumerable.Empty <AssemblyInfo>());
}
var pkgInfo = LocalPackagesFinder.GetPackage(pkg, Logger, CancellationToken.None);
if (pkgInfo == null)
{
Logger.LogWarning($"Could not find Package {pkg}");
return(Enumerable.Empty <AssemblyInfo>());
}
var packageReader = pkgInfo.GetReader();
var libs = packageReader?.GetLibItems();
// If package contains no dlls:
if (libs == null)
{
Logger.LogWarning($"Could not find any dll for {pkg}");
return(Enumerable.Empty <AssemblyInfo>());
}
var root = Path.GetDirectoryName(pkgInfo.Path);
string[] CheckOnFramework(NuGetFramework framework)
{
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(framework, libs.Select(x => x.TargetFramework));
if (nearest == null)
{
return(new string[0]);
}
var files = libs
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)
.Where(n => n.EndsWith(".dll"))
.Select(p => Path.Combine(root, p));
return(files.ToArray());
}
var names = CheckOnFramework(NETCOREAPP3_1);
Assembly?LoadAssembly(string path)
{
try
{
return(Assembly.LoadFile(path));
}
catch (Exception e)
{
Logger.LogWarning($"Unable to load assembly '{path}' ({e.Message})");
return(null);
}
}
return(names
.Select(LoadAssembly)
.Select(AssemblyInfo.Create)
.Where(a => a != null));
}
private async Task DownloadDependecies(List <PluginDependencyConfig> packages)
{
var repositories = _nugetSourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
var resolver = new PackageResolver();
var frameworkReducer = new FrameworkReducer();
PackageReaderBase packageReader;
using (var context = new SourceCacheContext())
{
foreach (var package in packages)
{
_logger.LogInformation(
$"Getting Dependency for package {package.PackageName} v{package.PackageVersion}");
await GetPackageDependencies(GetPackageIdentity(package.PackageName, package.PackageVersion), context,
repositories, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { package.PackageName },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
_nugetSourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
foreach (var packageToInstall in packagesToInstall)
{
var basePath = "";
var installedPath = _packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
_logger.LogInformation(
$"Download package {packageToInstall.Id} {packageToInstall.Version}");
var downloadResource =
await packageToInstall.Source
.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(context),
SettingsUtility.GetGlobalPackagesFolder(_nugetSettings),
NullLogger.Instance, CancellationToken.None);
_logger.LogInformation(
$"Extracting package {packageToInstall.Id} v{packageToInstall.Version}");
var extractedFiles = await PackageExtractor.ExtractPackageAsync(downloadResult.PackageSource,
downloadResult.PackageStream,
_packagePathResolver,
_packageExtractionContext,
CancellationToken.None);
var pathList = extractedFiles.ToArray()[0].Split(Path.DirectorySeparatorChar).ToList();
pathList.RemoveAt(pathList.Count - 1);
basePath = string.Join($"{Path.DirectorySeparatorChar}", pathList);
packageReader = downloadResult.PackageReader;
}
else
{
packageReader = new PackageFolderReader(installedPath);
var pathList = packageReader.GetNuspecFile().Split(Path.DirectorySeparatorChar).ToList();
pathList.RemoveAt(pathList.Count - 1);
basePath = string.Join($"{Path.DirectorySeparatorChar}", pathList);
}
var libItems = packageReader.GetLibItems();
var nearest =
frameworkReducer.GetNearest(_nuGetFramework, libItems.Select(x => x.TargetFramework));
var items = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
//var frameworkItems = packageReader.GetFrameworkItems();
//nearest = frameworkReducer.GetNearest(_nuGetFramework,
// frameworkItems.Select(x => x.TargetFramework));
//items.AddRange(frameworkItems
// .Where(x => x.TargetFramework.Equals(nearest))
// .SelectMany(x => x.Items));
items.ForEach(lib =>
{
if (!string.IsNullOrEmpty(lib))
{
if (lib.EndsWith(".dll"))
{
if (!lib.Contains("System."))
{
var libName = Path.Combine(_packagesDirectory,
$"{basePath}", lib.Replace('/', Path.DirectorySeparatorChar));
_assembliesToLoad.Add(libName);
}
}
}
;
});
}
}
}
}
public void UninstallPackage(string TargetFolder, PackageIdentity identity)
{
var packagePathResolver = new PackagePathResolver(PackagesInstallFolder);
var installedPath = packagePathResolver.GetInstalledPath(identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
var libItems = packageReader.GetLibItems();
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework));
var files = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
UninstallFile(TargetFolder, installedPath, f);
}
var cont = packageReader.GetContentItems();
nearest = frameworkReducer.GetNearest(NuGetFramework, cont.Select(x => x.TargetFramework));
files = cont
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
UninstallFile(TargetFolder, installedPath, f);
}
try
{
var dependencies = packageReader.GetPackageDependencies();
nearest = frameworkReducer.GetNearest(NuGetFramework, dependencies.Select(x => x.TargetFramework));
foreach (var dep in dependencies.Where(x => x.TargetFramework.Equals(nearest)))
{
foreach (var p in dep.Packages)
{
var local = getLocal(p.Id);
UninstallPackage(TargetFolder, local.Identity);
}
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
if (System.IO.Directory.Exists(installedPath + @"\build"))
{
if (System.IO.Directory.Exists(installedPath + @"\build\x64"))
{
foreach (var f in System.IO.Directory.GetFiles(installedPath + @"\build\x64"))
{
var filename = System.IO.Path.GetFileName(f);
var target = System.IO.Path.Combine(TargetFolder, filename);
if (System.IO.File.Exists(target))
{
try
{
System.IO.File.Delete(target);
}
catch (Exception)
{
PendingDeletion.Add(target);
}
}
}
}
}
}
public async Task <IEnumerable <string> > DownloadPackageAndDependenciesAsync(string packageId, string version, string nuGetDir)
{
List <string> dllsToCopy = new List <string>();
NuGetVersion packageVersion = NuGetVersion.Parse(version);
using (SourceCacheContext cacheContext = new SourceCacheContext())
{
IEnumerable <SourceRepository> repositories = _sourceRepositoryProvider.GetRepositories();
HashSet <SourcePackageDependencyInfo> availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependenciesAsync(
new PackageIdentity(packageId, packageVersion),
_nuGetFramework, cacheContext, _logger, repositories, availablePackages);
PackageResolverContext resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
_sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
_logger);
PackageResolver resolver = new PackageResolver();
IEnumerable <SourcePackageDependencyInfo> packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
PackagePathResolver packagePathResolver = new PackagePathResolver(nuGetDir);
PackageExtractionContext packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, ClientPolicyContext.GetClientPolicy(_settings, _logger), _logger);
FrameworkReducer frameworkReducer = new FrameworkReducer();
foreach (SourcePackageDependencyInfo packageToInstall in packagesToInstall)
{
PackageReaderBase packageReader;
string installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
DownloadResource downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
DownloadResourceResult downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(_settings),
_logger, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
packageReader = downloadResult.PackageReader;
installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
IEnumerable <FrameworkSpecificGroup> libItems = packageReader.GetLibItems();
NuGetFramework nearest = frameworkReducer.GetNearest(_nuGetFramework, libItems.Select(x => x.TargetFramework));
IEnumerable <string> items = libItems.Where(x => x.TargetFramework.Equals(nearest)).SelectMany(x => x.Items).Where(x => Path.GetExtension(x) == ".dll");
foreach (var item in items)
{
dllsToCopy.Add(Path.Combine(installedPath, item));
}
}
}
return(dllsToCopy);
}
public NuGetFramework GetNearest(string frameworkVersion)
{
var framework = NuGetFramework.Parse(frameworkVersion);
return(Reducer.GetNearest(framework, FrameworkVersions));
}
public virtual async Task <IEnumerable <Assembly> > LoadAssembliesFromNuGetPackageAsync(string nupkgFile)
{
var fullPath = Path.GetFullPath(nupkgFile).ToLower();
if (m_LoadedPackageAssemblies.ContainsKey(fullPath))
{
if (m_LoadedPackageAssemblies[fullPath].All(d => d.Assembly.IsAlive))
{
return(m_LoadedPackageAssemblies[fullPath].Select(d => d.Assembly.Target).Cast <Assembly>());
}
m_LoadedPackageAssemblies.Remove(fullPath);
}
List <CachedNuGetAssembly> assemblies = new List <CachedNuGetAssembly>();
var packageReader = new PackageArchiveReader(nupkgFile);
var identity = await packageReader.GetIdentityAsync(CancellationToken.None);
using (var cache = new SourceCacheContext())
{
var dependencies = await GetDependenciesAsync(identity, cache);
foreach (var dependency in dependencies.Where(d => !d.Id.Equals(identity.Id)))
{
var nupkg = GetNugetPackageFile(dependency);
if (!File.Exists(nupkg))
{
var latestInstalledVersion = await GetLatestPackageIdentityAsync(dependency.Id);
if (latestInstalledVersion == null)
{
Logger.LogWarning("Failed to resolve: " + dependency.Id);
continue;
}
nupkg = GetNugetPackageFile(latestInstalledVersion);
}
await LoadAssembliesFromNuGetPackageAsync(nupkg);
}
}
var libItems = packageReader.GetLibItems().ToList();
var nearest = m_FrameworkReducer.GetNearest(m_CurrentFramework, libItems.Select(x => x.TargetFramework));
foreach (var file in libItems.Where(x => x.TargetFramework.Equals(nearest)))
{
foreach (var item in file.Items)
{
if (!item.EndsWith(".dll"))
{
continue;
}
var entry = packageReader.GetEntry(item);
using var stream = entry.Open();
var ms = new MemoryStream();
await stream.CopyToAsync(ms);
try
{
var asm = Assembly.Load(ms.ToArray());
var name = GetVersionIndependentName(asm.FullName, out string extractedVersion);
var parsedVersion = new Version(extractedVersion);
assemblies.Add(new CachedNuGetAssembly
{
Assembly = new WeakReference(asm),
AssemblyName = name,
Version = parsedVersion
});
}
catch (Exception ex)
{
Logger.LogError("Failed to load assembly: " + item);
Logger.LogError(ex.ToString());
}
finally
{
ms.Close();
stream.Close();
}
}
}
m_LoadedPackageAssemblies.Add(fullPath, assemblies);
packageReader.Dispose();
return(assemblies.Select(d => d.Assembly.Target).Cast <Assembly>());
}
public async Task <bool> IsPackageInstalled(LocalPackageInfo package)
{
try
{
await Download(package.Identity);
}
catch (Exception ex)
{
OpenRPAPackageManagerLogger.Instance.LogError(ex.ToString());
}
try
{
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var installedPath = packagePathResolver.GetInstalledPath(package.Identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
var libItems = packageReader.GetLibItems();
if (libItems.Count() == 0)
{
Console.WriteLine("Booom!");
}
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework));
var files = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
string source = "";
string f2 = "";
string filename = "";
string dir = "";
string target = "";
try
{
source = System.IO.Path.Combine(installedPath, f);
f2 = f.Substring(f.IndexOf("/", 4) + 1);
filename = System.IO.Path.GetFileName(f2);
dir = System.IO.Path.GetDirectoryName(f2);
target = System.IO.Path.Combine(Destinationfolder, dir, filename);
if (!System.IO.Directory.Exists(System.IO.Path.Combine(Destinationfolder, dir)))
{
System.IO.Directory.CreateDirectory(System.IO.Path.Combine(Destinationfolder, dir));
}
if (!System.IO.File.Exists(source))
{
return(false);
}
if (!System.IO.File.Exists(target))
{
return(false);
}
var infoOld = new System.IO.FileInfo(source);
var infoNew = new System.IO.FileInfo(target);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
return(true);
}
catch (Exception ex)
{
OpenRPAPackageManagerLogger.Instance.LogError(ex.ToString());
return(false);
}
}
private void HandleRuntimeDlls(PackageIdentity packageIdentity, List <ZipArchiveEntry> zipArchiveEntries)
{
var runtimeEntries = zipArchiveEntries
.Where(e => string.Equals(e.FullName.Split('/')[0], "runtimes", StringComparison.InvariantCultureIgnoreCase))
.Select(e => new { Rid = e.FullName.Split('/')[1], Entry = e }).ToList();
foreach (var runtime in runtimeEntries)
{
var runtimeDll = new RunTimeDll()
{
FileName = runtime.Entry.Name,
FullFilePath = Path.Combine(_root, packageIdentity.ToString(), runtime.Entry.FullName),
RelativeFilePath = Path.Combine(packageIdentity.ToString(), runtime.Entry.FullName),
PackageIdentity = packageIdentity.Id,
};
var runtimeDllDetails = ParseRuntimeDllDetails(runtime.Entry.FullName);
runtimeDll.RID = runtimeDllDetails.Rid;
runtimeDll.TargetFramework = runtimeDllDetails.Target;
runtimeDll.TargetFrameworkShortName = runtimeDllDetails.TargetShortName;
runtimeDll.TargetVersion = runtimeDllDetails.TargetVersion;
RuntimeDlls.Add(runtimeDll);
}
var supportedRunTimeDlls = RuntimeDlls.Where(x => SupportedRids.Contains(x.RID)).ToList();
var runtimeLibFiles = supportedRunTimeDlls.Where(x => x.IsLib).GroupBy(x => x.FileName).ToList();
foreach (var fileGroup in runtimeLibFiles)
{
var targetFrameworks = fileGroup.Select(x =>
NuGetFramework.ParseFrameworkName(x.TargetFramework, new DefaultFrameworkNameProvider()))
.ToList();
var compatibleFrameworks =
targetFrameworks.Where(x => _compProvider.IsCompatible(_targetFramework, x)).ToList();
foreach (var runTimeDll in fileGroup)
{
if (compatibleFrameworks.Any(x => string.Equals(x.DotNetFrameworkName, runTimeDll.TargetFramework)))
{
runTimeDll.IsSupported = true;
}
}
var mostMatching = _reducer.GetNearest(_targetFramework, targetFrameworks);
if (mostMatching == null)
{
continue;
}
foreach (var runTimeDll in fileGroup)
{
if (string.Equals(runTimeDll.TargetFramework, mostMatching.DotNetFrameworkName))
{
runTimeDll.IsRecommended = true;
}
}
}
var runtimeNativeFiles = supportedRunTimeDlls.Where(x => x.IsNative).GroupBy(x => x.FileName).ToList();
foreach (var fileGroup in runtimeNativeFiles)
{
foreach (var runTimeDll in fileGroup)
{
runTimeDll.IsSupported = true;
}
// The Rids are already ordered from best match to the least matching
var recommededFound = false;
foreach (var supportedRid in SupportedRids)
{
foreach (var runTimeDll in fileGroup)
{
if (string.Equals(runTimeDll.RID, supportedRid))
{
runTimeDll.IsRecommended = true;
recommededFound = true;
break;
}
if (recommededFound)
{
break;
}
}
}
}
}