public void PackageFolderReader_Basic()
{
using (var packageFile = TestPackagesCore.GetLegacyTestPackage())
{
using (var zip = new ZipArchive(File.OpenRead(packageFile)))
using (var zipReader = new PackageArchiveReader(zip))
using (var testDirectory = TestDirectory.Create())
using (var zipFile = new ZipArchive(File.OpenRead(packageFile)))
{
zipFile.ExtractAll(testDirectory);
using (var folderReader = new PackageFolderReader(testDirectory))
{
Assert.Equal(zipReader.GetIdentity(), folderReader.GetIdentity(), new PackageIdentityComparer());
Assert.Equal(zipReader.GetLibItems().Count(), folderReader.GetLibItems().Count());
var referenceItems = zipReader.GetReferenceItems();
var folderItems = folderReader.GetReferenceItems();
Assert.Equal(referenceItems.Count(), folderItems.Count());
Assert.Equal(referenceItems.First().Items.First(), folderItems.First().Items.First());
}
}
}
}
public void PackageFolderReader_Basic()
{
using (var packageFile = TestPackages.GetLegacyTestPackage())
{
using (var zip = new ZipArchive(File.OpenRead(packageFile)))
using (var zipReader = new PackageArchiveReader(zip))
{
var folder = Path.Combine(Path.GetDirectoryName(packageFile), Guid.NewGuid().ToString());
using (var zipFile = new ZipArchive(File.OpenRead(packageFile)))
{
zipFile.ExtractAll(folder);
var folderReader = new PackageFolderReader(folder);
Assert.Equal(zipReader.GetIdentity(), folderReader.GetIdentity(), new PackageIdentityComparer());
Assert.Equal(zipReader.GetLibItems().Count(), folderReader.GetLibItems().Count());
Assert.Equal(zipReader.GetReferenceItems().Count(), folderReader.GetReferenceItems().Count());
Assert.Equal(zipReader.GetReferenceItems().First().Items.First(), folderReader.GetReferenceItems().First().Items.First());
}
}
}
}
public async Task <bool> InstallPackage(PackageIdentity identity)
{
await Download(identity);
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
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(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)
{
InstallFile(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);
await InstallPackage(local.Identity);
}
}
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
}
if (System.IO.Directory.Exists(installedPath + @"\build"))
{
CopyDir.Copy(installedPath + @"\build", Destinationfolder);
}
return(true);
}
public bool IsPackageInstalled(LocalPackageInfo package)
{
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var installedPath = packagePathResolver.GetInstalledPath(package.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)
{
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);
if (infoNew.LastWriteTime != infoOld.LastWriteTime)
{
return(false);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
return(true);
}
public void UninstallPackage(PackageIdentity identity)
{
var package = getLocal(identity.Id);
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var installedPath = packagePathResolver.GetInstalledPath(package.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)
{
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)
{
InstallFile(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)
{
}
}
}
}
}
}
/// <summary>
/// Возвращает наименьшую поддерживаемую версию фреймворка для указанного пакета.
/// </summary>
/// <param name="packageIdentity">Идентификатор пакета.</param>
private NuGetFramework GetPackageLowestSupportedFramework(PackageIdentity packageIdentity)
{
var packagePath = GetPackagePath(packageIdentity);
using (var reader = new PackageFolderReader(packagePath))
{
// Выбираются только поддерживаемые TargetFramework, содержащие файлы в каталоге 'lib'
return(reader.GetLibItems()
.OrderBy(i => i.TargetFramework, NuGetFrameworkComparer)
.FirstOrDefault(i => NuGetFrameworkComparer.Compare(i.TargetFramework, NuGetFramework.AnyFramework) != 0 &&
!i.TargetFramework.IsUnsupported &&
i.Items != null &&
i.Items.Any())?.TargetFramework);
}
}
public void PackagesEndedWithResourcesShouldBeProcessed()
{
var packageName = "solution.resources";
using (var packageFile = TestPackagesCore.GetLegacyResourcesPackage(packageName))
{
using (var zip = new ZipArchive(File.OpenRead(packageFile)))
using (var zipReader = new PackageArchiveReader(zip))
{
var folder = Path.Combine(Path.GetDirectoryName(packageFile), Guid.NewGuid().ToString());
using (var zipFile = new ZipArchive(File.OpenRead(packageFile)))
{
zipFile.ExtractAll(folder);
var folderReader = new PackageFolderReader(folder);
Assert.Equal(zipReader.GetIdentity(), folderReader.GetIdentity(), new PackageIdentityComparer());
var libs1 = zipReader.GetLibItems().Count();
var libs2 = folderReader.GetLibItems().Count();
Assert.Equal(libs1, libs2);
var group1 = zipReader.GetReferenceItems();
var group2 = folderReader.GetReferenceItems();
Assert.Equal(group1.Count(), group2.Count());
// Check that assemblies with the 'resource' in a title are not filtered out.
Assert.True(group1.First().Items.Any(p => p.EndsWith("resources.dll")));
// Check that resource assembly not filtered out.
Assert.True(group2.First().Items.Any(p => p.EndsWith("resources.dll")));
foreach (var item in group1)
{
Assert.False(item.Items.Any(p => p.EndsWith(packageName)));
}
foreach (var item in group2)
{
Assert.False(item.Items.Any(p => p.EndsWith(packageName)));
}
}
}
}
}
/// <summary>
/// Добавляет в содержимое пакета совместимые версии файлов из указанного пакета.
/// </summary>
/// <param name="packageContent">Содержимое пакета.</param>
/// <param name="packageIdentity">Идентификатор пакета.</param>
/// <param name="targetFramework">Версия совместимого фреймворка.</param>
/// <param name="compatibilityProvider">Провайдер для проверки совместимости фреймворков.</param>
private void FillPackageContent(PackageContent packageContent,
PackageIdentity packageIdentity,
NuGetFramework targetFramework,
IFrameworkCompatibilityProvider compatibilityProvider)
{
var packagePath = GetPackagePath(packageIdentity);
using (var reader = new PackageFolderReader(packagePath))
{
var libItems = GetCompatibleItems(reader, reader.GetLibItems().ToList(), targetFramework, compatibilityProvider);
if (libItems?.Items != null)
{
foreach (var item in libItems.Items)
{
var installItem = GetPackageItem(packagePath, item, PackagingConstants.Folders.Lib, libItems.TargetFramework);
packageContent.Lib.Add(installItem);
}
}
var contentItems = GetCompatibleItems(reader, reader.GetContentItems().ToList(), targetFramework, compatibilityProvider);
if (contentItems?.Items != null)
{
foreach (var item in contentItems.Items)
{
var installItem = GetPackageItem(packagePath, item, PackagingConstants.Folders.Content, contentItems.TargetFramework);
packageContent.Content.Add(installItem);
}
}
var pluginItems = GetCompatibleItems(reader, reader.GetPluginItems().ToList(), targetFramework, compatibilityProvider);
if (pluginItems?.Items != null)
{
foreach (var item in pluginItems.Items)
{
var installItem = GetPackageItem(packagePath, item, PluginFolderName, pluginItems.TargetFramework);
packageContent.Plugin.Add(installItem);
}
}
}
}
public void PackageFolderReader_Basic()
{
var packageNupkg = TestPackages.GetLegacyTestPackage();
var zip = new ZipArchive(packageNupkg.OpenRead());
PackageReader zipReader = new PackageReader(zip);
var folder = Path.Combine(packageNupkg.Directory.FullName, Guid.NewGuid().ToString());
var zipFile = new ZipArchive(File.OpenRead(packageNupkg.FullName));
zipFile.ExtractAll(folder);
var folderReader = new PackageFolderReader(folder);
Assert.Equal(zipReader.GetIdentity(), folderReader.GetIdentity(), new PackageIdentityComparer());
Assert.Equal(zipReader.GetLibItems().Count(), folderReader.GetLibItems().Count());
Assert.Equal(zipReader.GetReferenceItems().Count(), folderReader.GetReferenceItems().Count());
Assert.Equal(zipReader.GetReferenceItems().First().Items.First(), folderReader.GetReferenceItems().First().Items.First());
}
public void PackageFolderReader_Basic()
{
FileInfo packageNupkg = TestPackages.GetLegacyTestPackage();
var zip = new ZipArchive(packageNupkg.OpenRead());
PackageReader zipReader = new PackageReader(zip);
string folder = Path.Combine(packageNupkg.Directory.FullName, Guid.NewGuid().ToString());
var zipFile = new ZipArchive(File.OpenRead(packageNupkg.FullName));
zipFile.ExtractAll(folder);
var folderReader = new PackageFolderReader(folder);
Assert.Equal(zipReader.GetIdentity(), folderReader.GetIdentity(), new PackageIdentityComparer());
Assert.Equal(zipReader.GetLibItems().Count(), folderReader.GetLibItems().Count());
Assert.Equal(zipReader.GetReferenceItems().Count(), folderReader.GetReferenceItems().Count());
Assert.Equal(zipReader.GetReferenceItems().First().Items.First(), folderReader.GetReferenceItems().First().Items.First());
}
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 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);
}
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));
}
}
